ViewVC Help
View File | Revision Log | Show Annotations | Download File
/cvs/deliantra/server/common/map.C
(Generate patch)

Comparing deliantra/server/common/map.C (file contents):
Revision 1.29 by root, Sun Sep 10 16:00:23 2006 UTC vs.
Revision 1.46 by root, Wed Dec 20 11:36:38 2006 UTC

1
2/*
3 * static char *rcsid_map_c =
4 * "$Id: map.C,v 1.29 2006/09/10 16:00:23 root Exp $";
5 */
6
7/* 1/*
8 CrossFire, A Multiplayer game for X-windows 2 CrossFire, A Multiplayer game for X-windows
9 3
10 Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team 4 Copyright (C) 2001-2003 Mark Wedel & Crossfire Development Team
11 Copyright (C) 1992 Frank Tore Johansen 5 Copyright (C) 1992 Frank Tore Johansen
… …
22 16
23 You should have received a copy of the GNU General Public License 17 You should have received a copy of the GNU General Public License
24 along with this program; if not, write to the Free Software 18 along with this program; if not, write to the Free Software
25 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. 19 Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
26 20
27 The authors can be reached via e-mail at crossfire-devel@real-time.com 21 The authors can be reached via e-mail at <crossfire@schmorp.de>
28*/ 22*/
29 23
30 24
31#include <global.h> 25#include <global.h>
32#include <funcpoint.h> 26#include <funcpoint.h>
33 27
34#include <loader.h> 28#include <loader.h>
35#ifndef WIN32 /* ---win32 exclude header */
36# include <unistd.h> 29#include <unistd.h>
37#endif /* win32 */
38 30
39#include "path.h" 31#include "path.h"
40 32
41
42extern int nrofallocobjects, nroffreeobjects;
43
44/* 33/*
45 * Returns the mapstruct which has a name matching the given argument. 34 * Returns the maptile which has a name matching the given argument.
46 * return NULL if no match is found. 35 * return NULL if no match is found.
47 */ 36 */
48 37
49mapstruct * 38maptile *
50has_been_loaded (const char *name) 39has_been_loaded (const char *name)
51{ 40{
52 mapstruct *map; 41 maptile *map;
53 42
54 if (!name || !*name) 43 if (!name || !*name)
55 return 0; 44 return 0;
56 for (map = first_map; map; map = map->next) 45 for (map = first_map; map; map = map->next)
57 if (!strcmp (name, map->path)) 46 if (!strcmp (name, map->path))
… …
165int 154int
166check_path (const char *name, int prepend_dir) 155check_path (const char *name, int prepend_dir)
167{ 156{
168 char buf[MAX_BUF]; 157 char buf[MAX_BUF];
169 158
170#ifndef WIN32
171 char *endbuf; 159 char *endbuf;
172 struct stat statbuf; 160 struct stat statbuf;
173 int mode = 0; 161 int mode = 0;
174#endif
175 162
176 if (prepend_dir) 163 if (prepend_dir)
177 strcpy (buf, create_pathname (name)); 164 strcpy (buf, create_pathname (name));
178 else 165 else
179 strcpy (buf, name); 166 strcpy (buf, name);
180#ifdef WIN32 /* ***win32: check this sucker in windows style. */
181 return (_access (buf, 0));
182#else
183 167
184 /* old method (strchr(buf, '\0')) seemd very odd to me - 168 /* old method (strchr(buf, '\0')) seemd very odd to me -
185 * this method should be equivalant and is clearer. 169 * this method should be equivalant and is clearer.
186 * Can not use strcat because we need to cycle through 170 * Can not use strcat because we need to cycle through
187 * all the names. 171 * all the names.
… …
200 if ((statbuf.st_mode & S_IWGRP && getegid () == statbuf.st_gid) || 184 if ((statbuf.st_mode & S_IWGRP && getegid () == statbuf.st_gid) ||
201 (statbuf.st_mode & S_IWUSR && geteuid () == statbuf.st_uid) || (statbuf.st_mode & S_IWOTH)) 185 (statbuf.st_mode & S_IWUSR && geteuid () == statbuf.st_uid) || (statbuf.st_mode & S_IWOTH))
202 mode |= 2; 186 mode |= 2;
203 187
204 return (mode); 188 return (mode);
205#endif
206} 189}
207 190
208/* 191/*
209 * Prints out debug-information about a map. 192 * Prints out debug-information about a map.
210 * Dumping these at llevError doesn't seem right, but is 193 * Dumping these at llevError doesn't seem right, but is
211 * necessary to make sure the information is in fact logged. 194 * necessary to make sure the information is in fact logged.
212 */ 195 */
213 196
214void 197void
215dump_map (const mapstruct *m) 198dump_map (const maptile *m)
216{ 199{
217 LOG (llevError, "Map %s status: %d.\n", m->path, m->in_memory); 200 LOG (llevError, "Map %s status: %d.\n", m->path, m->in_memory);
218 LOG (llevError, "Size: %dx%d Start: %d,%d\n", MAP_WIDTH (m), MAP_HEIGHT (m), MAP_ENTER_X (m), MAP_ENTER_Y (m)); 201 LOG (llevError, "Size: %dx%d Start: %d,%d\n", MAP_WIDTH (m), MAP_HEIGHT (m), MAP_ENTER_X (m), MAP_ENTER_Y (m));
219 202
220 if (m->msg != NULL) 203 if (m->msg != NULL)
… …
237 */ 220 */
238 221
239void 222void
240dump_all_maps (void) 223dump_all_maps (void)
241{ 224{
242 mapstruct *m; 225 maptile *m;
243 226
244 for (m = first_map; m != NULL; m = m->next) 227 for (m = first_map; m; m = m->next)
245 {
246 dump_map (m); 228 dump_map (m);
247 }
248} 229}
249 230
250/* This rolls up wall, blocks_magic, blocks_view, etc, all into 231/* This rolls up wall, blocks_magic, blocks_view, etc, all into
251 * one function that just returns a P_.. value (see map.h) 232 * one function that just returns a P_.. value (see map.h)
252 * it will also do map translation for tiled maps, returning 233 * it will also do map translation for tiled maps, returning
… …
256 * is needed. The case of not passing values is if we're just 237 * is needed. The case of not passing values is if we're just
257 * checking for the existence of something on those spaces, but 238 * checking for the existence of something on those spaces, but
258 * don't expect to insert/remove anything from those spaces. 239 * don't expect to insert/remove anything from those spaces.
259 */ 240 */
260int 241int
261get_map_flags (mapstruct *oldmap, mapstruct **newmap, sint16 x, sint16 y, sint16 * nx, sint16 * ny) 242get_map_flags (maptile *oldmap, maptile **newmap, sint16 x, sint16 y, sint16 *nx, sint16 *ny)
262{ 243{
263 sint16 newx, newy; 244 sint16 newx, newy;
264 int retval = 0; 245 int retval = 0;
265 mapstruct *mp; 246 maptile *mp;
266 247
267 if (out_of_map (oldmap, x, y))
268 return P_OUT_OF_MAP;
269 newx = x; 248 newx = x;
270 newy = y; 249 newy = y;
250
271 mp = get_map_from_coord (oldmap, &newx, &newy); 251 mp = get_map_from_coord (oldmap, &newx, &newy);
252
253 if (!mp)
254 return P_OUT_OF_MAP;
255
272 if (mp != oldmap) 256 if (mp != oldmap)
273 retval |= P_NEW_MAP; 257 retval |= P_NEW_MAP;
274 if (newmap)
275 *newmap = mp;
276 if (nx)
277 *nx = newx;
278 if (ny)
279 *ny = newy;
280 258
281 retval |= mp->spaces[newx + mp->width * newy].flags; 259 if (newmap) *newmap = mp;
260 if (nx) *nx = newx;
261 if (ny) *ny = newy;
282 262
283 return retval; 263 return retval | mp->at (newx, newy).flags ();
284} 264}
285
286 265
287/* 266/*
288 * Returns true if the given coordinate is blocked except by the 267 * Returns true if the given coordinate is blocked except by the
289 * object passed is not blocking. This is used with 268 * object passed is not blocking. This is used with
290 * multipart monsters - if we want to see if a 2x2 monster 269 * multipart monsters - if we want to see if a 2x2 monster
… …
294 * monster. 273 * monster.
295 * m, x, y are the target map/coordinates - needed for map tiling. 274 * m, x, y are the target map/coordinates - needed for map tiling.
296 * the coordinates & map passed in should have been updated for tiling 275 * the coordinates & map passed in should have been updated for tiling
297 * by the caller. 276 * by the caller.
298 */ 277 */
299
300int 278int
301blocked_link (object *ob, mapstruct *m, int sx, int sy) 279blocked_link (object *ob, maptile *m, int sx, int sy)
302{ 280{
303 object *tmp; 281 object *tmp;
304 int mflags, blocked; 282 int mflags, blocked;
305 283
306 /* Make sure the coordinates are valid - they should be, as caller should 284 /* Make sure the coordinates are valid - they should be, as caller should
… …
313 } 291 }
314 292
315 /* Save some cycles - instead of calling get_map_flags(), just get the value 293 /* Save some cycles - instead of calling get_map_flags(), just get the value
316 * directly. 294 * directly.
317 */ 295 */
318 mflags = m->spaces[sx + m->width * sy].flags; 296 mflags = m->at (sx, sy).flags ();
319 297
320 blocked = GET_MAP_MOVE_BLOCK (m, sx, sy); 298 blocked = GET_MAP_MOVE_BLOCK (m, sx, sy);
321 299
322 /* If space is currently not blocked by anything, no need to 300 /* If space is currently not blocked by anything, no need to
323 * go further. Not true for players - all sorts of special 301 * go further. Not true for players - all sorts of special
… …
342 /* We basically go through the stack of objects, and if there is 320 /* We basically go through the stack of objects, and if there is
343 * some other object that has NO_PASS or FLAG_ALIVE set, return 321 * some other object that has NO_PASS or FLAG_ALIVE set, return
344 * true. If we get through the entire stack, that must mean 322 * true. If we get through the entire stack, that must mean
345 * ob is blocking it, so return 0. 323 * ob is blocking it, so return 0.
346 */ 324 */
347 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = tmp->above) 325 for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)
348 { 326 {
349 327
350 /* This must be before the checks below. Code for inventory checkers. */ 328 /* This must be before the checks below. Code for inventory checkers. */
351 if (tmp->type == CHECK_INV && OB_MOVE_BLOCK (ob, tmp)) 329 if (tmp->type == CHECK_INV && OB_MOVE_BLOCK (ob, tmp))
352 { 330 {
… …
416 * 394 *
417 * Note this used to be arch_blocked, but with new movement 395 * Note this used to be arch_blocked, but with new movement
418 * code, we need to have actual object to check its move_type 396 * code, we need to have actual object to check its move_type
419 * against the move_block values. 397 * against the move_block values.
420 */ 398 */
421
422int 399int
423ob_blocked (const object *ob, mapstruct *m, sint16 x, sint16 y) 400ob_blocked (const object *ob, maptile *m, sint16 x, sint16 y)
424{ 401{
425 archetype *tmp; 402 archetype *tmp;
426 int flag; 403 int flag;
427 mapstruct *m1; 404 maptile *m1;
428 sint16 sx, sy; 405 sint16 sx, sy;
429 406
430 if (ob == NULL) 407 if (ob == NULL)
431 { 408 {
432 flag = get_map_flags (m, &m1, x, y, &sx, &sy); 409 flag = get_map_flags (m, &m1, x, y, &sx, &sy);
… …
456 433
457 /* Note it is intentional that we check ob - the movement type of the 434 /* Note it is intentional that we check ob - the movement type of the
458 * head of the object should correspond for the entire object. 435 * head of the object should correspond for the entire object.
459 */ 436 */
460 if (OB_TYPE_MOVE_BLOCK (ob, GET_MAP_MOVE_BLOCK (m1, sx, sy))) 437 if (OB_TYPE_MOVE_BLOCK (ob, GET_MAP_MOVE_BLOCK (m1, sx, sy)))
461 return AB_NO_PASS; 438 return P_NO_PASS;
462
463 } 439 }
440
464 return 0; 441 return 0;
465} 442}
466 443
467/* When the map is loaded, load_object does not actually insert objects 444/* When the map is loaded, load_object does not actually insert objects
468 * into inventory, but just links them. What this does is go through 445 * into inventory, but just links them. What this does is go through
… …
497 * they are saved). We do have to look for the old maps that did save 474 * they are saved). We do have to look for the old maps that did save
498 * the more sections and not re-add sections for them. 475 * the more sections and not re-add sections for them.
499 */ 476 */
500 477
501static void 478static void
502link_multipart_objects (mapstruct *m) 479link_multipart_objects (maptile *m)
503{ 480{
504 int x, y; 481 int x, y;
505 object *tmp, *op, *last, *above; 482 object *tmp, *op, *last, *above;
506 archetype *at; 483 archetype *at;
507 484
508 for (x = 0; x < MAP_WIDTH (m); x++) 485 for (x = 0; x < MAP_WIDTH (m); x++)
509 for (y = 0; y < MAP_HEIGHT (m); y++) 486 for (y = 0; y < MAP_HEIGHT (m); y++)
510 for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = above) 487 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = above)
511 { 488 {
512 above = tmp->above; 489 above = tmp->above;
513 490
514 /* already multipart - don't do anything more */ 491 /* already multipart - don't do anything more */
515 if (tmp->head || tmp->more) 492 if (tmp->head || tmp->more)
… …
544 * Loads (ands parses) the objects into a given map from the specified 521 * Loads (ands parses) the objects into a given map from the specified
545 * file pointer. 522 * file pointer.
546 * mapflags is the same as we get with load_original_map 523 * mapflags is the same as we get with load_original_map
547 */ 524 */
548void 525void
549load_objects (mapstruct *m, object_thawer & fp, int mapflags) 526load_objects (maptile *m, object_thawer & fp, int mapflags)
550{ 527{
551 int i, j; 528 int i, j;
552 int unique; 529 int unique;
553 object *op, *prev = NULL, *last_more = NULL, *otmp; 530 object *op, *prev = NULL, *last_more = NULL, *otmp;
554 531
555 op = get_object (); 532 op = object::create ();
556 op->map = m; /* To handle buttons correctly */ 533 op->map = m; /* To handle buttons correctly */
557 534
558 while ((i = load_object (fp, op, mapflags))) 535 while ((i = load_object (fp, op, mapflags)))
559 { 536 {
560 /* if the archetype for the object is null, means that we 537 /* if the archetype for the object is null, means that we
… …
568 } 545 }
569 546
570 547
571 switch (i) 548 switch (i)
572 { 549 {
573 case LL_NORMAL: 550 case LL_NORMAL:
574 /* if we are loading an overlay, put the floors on the bottom */ 551 /* if we are loading an overlay, put the floors on the bottom */
575 if ((QUERY_FLAG (op, FLAG_IS_FLOOR) || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)) && mapflags & MAP_OVERLAY) 552 if ((QUERY_FLAG (op, FLAG_IS_FLOOR) || QUERY_FLAG (op, FLAG_OVERLAY_FLOOR)) && mapflags & MAP_OVERLAY)
576 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY | INS_MAP_LOAD); 553 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY | INS_MAP_LOAD);
577 else 554 else
578 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD); 555 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD);
579 556
580 if (op->inv) 557 if (op->inv)
581 sum_weight (op); 558 sum_weight (op);
582 559
583 prev = op, last_more = op; 560 prev = op, last_more = op;
584 break; 561 break;
585 562
586 case LL_MORE: 563 case LL_MORE:
587 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY); 564 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY);
588 op->head = prev, last_more->more = op, last_more = op; 565 op->head = prev, last_more->more = op, last_more = op;
589 break; 566 break;
590 } 567 }
591 568
592 if (mapflags & MAP_STYLE) 569 if (mapflags & MAP_STYLE)
593 remove_from_active_list (op); 570 remove_from_active_list (op);
594 571
595 op = get_object (); 572 op = object::create ();
596 op->map = m; 573 op->map = m;
597 } 574 }
598 575
599 for (i = 0; i < m->width; i++) 576 for (i = 0; i < m->width; i++)
600 { 577 {
601 for (j = 0; j < m->height; j++) 578 for (j = 0; j < m->height; j++)
602 { 579 {
603 unique = 0; 580 unique = 0;
604 /* check for unique items, or unique squares */ 581 /* check for unique items, or unique squares */
605 for (otmp = get_map_ob (m, i, j); otmp; otmp = otmp->above) 582 for (otmp = GET_MAP_OB (m, i, j); otmp; otmp = otmp->above)
606 { 583 {
607 if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL)) 584 if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL))
608 unique = 1; 585 unique = 1;
586
609 if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique)) 587 if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique))
610 SET_FLAG (otmp, FLAG_OBJ_ORIGINAL); 588 SET_FLAG (otmp, FLAG_OBJ_ORIGINAL);
611 } 589 }
612 } 590 }
613 } 591 }
614 592
615 free_object (op); 593 op->destroy ();
616 link_multipart_objects (m); 594 link_multipart_objects (m);
617} 595}
618 596
619/* This saves all the objects on the map in a non destructive fashion. 597/* This saves all the objects on the map in a non destructive fashion.
620 * Modified by MSW 2001-07-01 to do in a single pass - reduces code, 598 * Modified by MSW 2001-07-01 to do in a single pass - reduces code,
621 * and we only save the head of multi part objects - this is needed 599 * and we only save the head of multi part objects - this is needed
622 * in order to do map tiling properly. 600 * in order to do map tiling properly.
623 */ 601 */
624void 602void
625save_objects (mapstruct *m, object_freezer & fp, object_freezer & fp2, int flag) 603save_objects (maptile *m, object_freezer & fp, object_freezer & fp2, int flag)
626{ 604{
627 int i, j = 0, unique = 0; 605 int i, j = 0, unique = 0;
628 object *op; 606 object *op;
629 607
630 /* first pass - save one-part objects */ 608 /* first pass - save one-part objects */
631 for (i = 0; i < MAP_WIDTH (m); i++) 609 for (i = 0; i < MAP_WIDTH (m); i++)
632 for (j = 0; j < MAP_HEIGHT (m); j++) 610 for (j = 0; j < MAP_HEIGHT (m); j++)
633 { 611 {
634 unique = 0; 612 unique = 0;
635 for (op = get_map_ob (m, i, j); op; op = op->above) 613 for (op = GET_MAP_OB (m, i, j); op; op = op->above)
636 { 614 {
637 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) 615 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
638 unique = 1; 616 unique = 1;
639 617
640 if (op->type == PLAYER) 618 if (op->type == PLAYER)
641 {
642 LOG (llevDebug, "Player on map that is being saved\n");
643 continue; 619 continue;
644 }
645 620
646 if (op->head || op->owner) 621 if (op->head || op->owner)
647 continue; 622 continue;
648 623
649 if (unique || QUERY_FLAG (op, FLAG_UNIQUE)) 624 if (unique || QUERY_FLAG (op, FLAG_UNIQUE))
650 save_object (fp2, op, 3); 625 save_object (fp2, op, 3);
651 else if (flag == 0 || (flag == 2 && (!QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) && !QUERY_FLAG (op, FLAG_UNPAID)))) 626 else if (flag == 0 || (flag == 2 && (!QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) && !QUERY_FLAG (op, FLAG_UNPAID))))
652 save_object (fp, op, 3); 627 save_object (fp, op, 3);
628 }
629 }
630}
653 631
654 } /* for this space */ 632maptile::maptile ()
655 } /* for this j */ 633{
634 in_memory = MAP_SWAPPED;
635 /* The maps used to pick up default x and y values from the
636 * map archetype. Mimic that behaviour.
637 */
638 MAP_WIDTH (this) = 16;
639 MAP_HEIGHT (this) = 16;
640 MAP_RESET_TIMEOUT (this) = 0;
641 MAP_TIMEOUT (this) = 300;
642 MAP_ENTER_X (this) = 0;
643 MAP_ENTER_Y (this) = 0;
644 /*set part to -1 indicating conversion to weather map not yet done */
645 MAP_WORLDPARTX (this) = -1;
646 MAP_WORLDPARTY (this) = -1;
656} 647}
657 648
658/* 649/*
659 * Allocates, initialises, and returns a pointer to a mapstruct. 650 * Allocates, initialises, and returns a pointer to a maptile.
660 * Modified to no longer take a path option which was not being 651 * Modified to no longer take a path option which was not being
661 * used anyways. MSW 2001-07-01 652 * used anyways. MSW 2001-07-01
662 */ 653 */
663 654maptile *
664mapstruct *
665get_linked_map (void) 655get_linked_map (void)
666{ 656{
667 mapstruct *map = new mapstruct; 657 maptile *mp, *map = new maptile;
668 mapstruct *mp;
669 658
670 for (mp = first_map; mp != NULL && mp->next != NULL; mp = mp->next); 659 for (mp = first_map; mp && mp->next; mp = mp->next);
660
671 if (mp == NULL) 661 if (mp == NULL)
672 first_map = map; 662 first_map = map;
673 else 663 else
674 mp->next = map; 664 mp->next = map;
675 665
676 map->in_memory = MAP_SWAPPED;
677 /* The maps used to pick up default x and y values from the
678 * map archetype. Mimic that behaviour.
679 */
680 MAP_WIDTH (map) = 16;
681 MAP_HEIGHT (map) = 16;
682 MAP_RESET_TIMEOUT (map) = 0;
683 MAP_TIMEOUT (map) = 300;
684 MAP_ENTER_X (map) = 0;
685 MAP_ENTER_Y (map) = 0;
686 /*set part to -1 indicating conversion to weather map not yet done */
687 MAP_WORLDPARTX (map) = -1;
688 MAP_WORLDPARTY (map) = -1;
689 return map; 666 return map;
690} 667}
691 668
692/* 669/*
693 * Allocates the arrays contained in a mapstruct. 670 * Allocates the arrays contained in a maptile.
694 * This basically allocates the dynamic array of spaces for the 671 * This basically allocates the dynamic array of spaces for the
695 * map. 672 * map.
696 */ 673 */
697
698void 674void
699allocate_map (mapstruct *m) 675maptile::allocate ()
700{ 676{
701 m->in_memory = MAP_IN_MEMORY; 677 in_memory = MAP_IN_MEMORY;
678
702 /* Log this condition and free the storage. We could I suppose 679 /* Log this condition and free the storage. We could I suppose
703 * realloc, but if the caller is presuming the data will be intact, 680 * realloc, but if the caller is presuming the data will be intact,
704 * that is their poor assumption. 681 * that is their poor assumption.
705 */ 682 */
706 if (m->spaces) 683 if (spaces)
707 { 684 {
708 LOG (llevError, "allocate_map called with already allocated map (%s)\n", m->path); 685 LOG (llevError, "allocate_map called with already allocated map (%s)\n", path);
709 free (m->spaces); 686 free (spaces);
710 } 687 }
711 688
712 m->spaces = (MapSpace *) calloc (1, MAP_WIDTH (m) * MAP_HEIGHT (m) * sizeof (MapSpace)); 689 spaces = (mapspace *)
690 calloc (1, width * height * sizeof (mapspace));
713 691
714 if (m->spaces == NULL) 692 if (!spaces)
715 fatal (OUT_OF_MEMORY); 693 fatal (OUT_OF_MEMORY);
716} 694}
717 695
718/* Create and returns a map of the specific size. Used 696/* Create and returns a map of the specific size. Used
719 * in random map code and the editor. 697 * in random map code and the editor.
720 */ 698 */
721mapstruct * 699maptile *
722get_empty_map (int sizex, int sizey) 700get_empty_map (int sizex, int sizey)
723{ 701{
724 mapstruct *m = get_linked_map (); 702 maptile *m = get_linked_map ();
725 703
726 m->width = sizex; 704 m->width = sizex;
727 m->height = sizey; 705 m->height = sizey;
728 m->in_memory = MAP_SWAPPED; 706 m->in_memory = MAP_SWAPPED;
729 allocate_map (m); 707 m->allocate ();
708
730 return m; 709 return m;
731} 710}
732 711
733/* Takes a string from a map definition and outputs a pointer to the array of shopitems 712/* Takes a string from a map definition and outputs a pointer to the array of shopitems
734 * corresponding to that string. Memory is allocated for this, it must be freed 713 * corresponding to that string. Memory is allocated for this, it must be freed
… …
742 char *shop_string, *p, *q, *next_semicolon, *next_colon; 721 char *shop_string, *p, *q, *next_semicolon, *next_colon;
743 shopitems *items = NULL; 722 shopitems *items = NULL;
744 int i = 0, number_of_entries = 0; 723 int i = 0, number_of_entries = 0;
745 const typedata *current_type; 724 const typedata *current_type;
746 725
747 shop_string = strdup_local (input_string); 726 shop_string = strdup (input_string);
748 p = shop_string; 727 p = shop_string;
749 /* first we'll count the entries, we'll need that for allocating the array shortly */ 728 /* first we'll count the entries, we'll need that for allocating the array shortly */
750 while (p) 729 while (p)
751 { 730 {
752 p = strchr (p, ';'); 731 p = strchr (p, ';');
… …
811} 790}
812 791
813/* opposite of parse string, this puts the string that was originally fed in to 792/* opposite of parse string, this puts the string that was originally fed in to
814 * the map (or something equivilent) into output_string. */ 793 * the map (or something equivilent) into output_string. */
815static void 794static void
816print_shop_string (mapstruct *m, char *output_string) 795print_shop_string (maptile *m, char *output_string)
817{ 796{
818 int i; 797 int i;
819 char tmp[MAX_BUF]; 798 char tmp[MAX_BUF];
820 799
821 strcpy (output_string, ""); 800 strcpy (output_string, "");
… …
855 * MSW 2001-07-01 834 * MSW 2001-07-01
856 * return 0 on success, 1 on failure. 835 * return 0 on success, 1 on failure.
857 */ 836 */
858 837
859static int 838static int
860load_map_header (object_thawer & fp, mapstruct *m) 839load_map_header (object_thawer & fp, maptile *m)
861{ 840{
862 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end; 841 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end;
863 int msgpos = 0; 842 int msgpos = 0;
864 int maplorepos = 0; 843 int maplorepos = 0;
865 844
866 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 845 while (fgets (buf, HUGE_BUF, fp) != NULL)
867 { 846 {
868 buf[HUGE_BUF - 1] = 0; 847 buf[HUGE_BUF - 1] = 0;
869 key = buf; 848 key = buf;
849
870 while (isspace (*key)) 850 while (isspace (*key))
871 key++; 851 key++;
852
872 if (*key == 0) 853 if (*key == 0)
873 continue; /* empty line */ 854 continue; /* empty line */
855
874 value = strchr (key, ' '); 856 value = strchr (key, ' ');
857
875 if (!value) 858 if (!value)
876 { 859 {
877 end = strchr (key, '\n'); 860 if ((end = strchr (key, '\n')))
878 if (end != NULL)
879 {
880 *end = 0; 861 *end = 0;
881 }
882 } 862 }
883 else 863 else
884 { 864 {
885 *value = 0; 865 *value = 0;
886 value++; 866 value++;
887 end = strchr (value, '\n'); 867 end = strchr (value, '\n');
868
888 while (isspace (*value)) 869 while (isspace (*value))
889 { 870 {
890 value++; 871 value++;
872
891 if (*value == '\0' || value == end) 873 if (*value == '\0' || value == end)
892 { 874 {
893 /* Nothing but spaces. */ 875 /* Nothing but spaces. */
894 value = NULL; 876 value = NULL;
895 break; 877 break;
… …
918 * that use the parameter. 900 * that use the parameter.
919 */ 901 */
920 902
921 if (!strcmp (key, "msg")) 903 if (!strcmp (key, "msg"))
922 { 904 {
923 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 905 while (fgets (buf, HUGE_BUF, fp) != NULL)
924 { 906 {
925 if (!strcmp (buf, "endmsg\n")) 907 if (!strcmp (buf, "endmsg\n"))
926 break; 908 break;
927 else 909 else
928 { 910 {
… …
935 * with nothing between). There is no reason in those cases to 917 * with nothing between). There is no reason in those cases to
936 * keep the empty message. Also, msgbuf contains garbage data 918 * keep the empty message. Also, msgbuf contains garbage data
937 * when msgpos is zero, so copying it results in crashes 919 * when msgpos is zero, so copying it results in crashes
938 */ 920 */
939 if (msgpos != 0) 921 if (msgpos != 0)
940 m->msg = strdup_local (msgbuf); 922 m->msg = strdup (msgbuf);
941 } 923 }
942 else if (!strcmp (key, "maplore")) 924 else if (!strcmp (key, "maplore"))
943 { 925 {
944 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 926 while (fgets (buf, HUGE_BUF, fp) != NULL)
945 { 927 {
946 if (!strcmp (buf, "endmaplore\n")) 928 if (!strcmp (buf, "endmaplore\n"))
947 break; 929 break;
948 else 930 else
949 { 931 {
… …
951 strcpy (maplorebuf + maplorepos, buf); 933 strcpy (maplorebuf + maplorepos, buf);
952 maplorepos += strlen (buf); 934 maplorepos += strlen (buf);
953 } 935 }
954 } 936 }
955 if (maplorepos != 0) 937 if (maplorepos != 0)
956 m->maplore = strdup_local (maplorebuf); 938 m->maplore = strdup (maplorebuf);
957 } 939 }
958 else if (!strcmp (key, "end")) 940 else if (!strcmp (key, "end"))
959 { 941 {
960 break; 942 break;
961 } 943 }
… …
970 LOG (llevError, "loading map and got a non 'arch map' line(%s %s)?\n", key, value); 952 LOG (llevError, "loading map and got a non 'arch map' line(%s %s)?\n", key, value);
971 } 953 }
972 else if (!strcmp (key, "name")) 954 else if (!strcmp (key, "name"))
973 { 955 {
974 *end = 0; 956 *end = 0;
975 m->name = strdup_local (value); 957 m->name = strdup (value);
976 } 958 }
977 /* first strcmp value on these are old names supported 959 /* first strcmp value on these are old names supported
978 * for compatibility reasons. The new values (second) are 960 * for compatibility reasons. The new values (second) are
979 * what really should be used. 961 * what really should be used.
980 */ 962 */
981 else if (!strcmp (key, "oid")) 963 else if (!strcmp (key, "oid"))
982 {
983 fp.get (m, atoi (value)); 964 fp.get (m, atoi (value));
984 }
985 else if (!strcmp (key, "attach")) 965 else if (!strcmp (key, "attach"))
986 {
987 m->attach = value; 966 m->attach = value;
988 }
989 else if (!strcmp (key, "hp") || !strcmp (key, "enter_x")) 967 else if (!strcmp (key, "hp") || !strcmp (key, "enter_x"))
990 {
991 m->enter_x = atoi (value); 968 m->enter_x = atoi (value);
992 }
993 else if (!strcmp (key, "sp") || !strcmp (key, "enter_y")) 969 else if (!strcmp (key, "sp") || !strcmp (key, "enter_y"))
994 {
995 m->enter_y = atoi (value); 970 m->enter_y = atoi (value);
996 }
997 else if (!strcmp (key, "x") || !strcmp (key, "width")) 971 else if (!strcmp (key, "x") || !strcmp (key, "width"))
998 {
999 m->width = atoi (value); 972 m->width = atoi (value);
1000 }
1001 else if (!strcmp (key, "y") || !strcmp (key, "height")) 973 else if (!strcmp (key, "y") || !strcmp (key, "height"))
1002 {
1003 m->height = atoi (value); 974 m->height = atoi (value);
1004 }
1005 else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout")) 975 else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout"))
1006 {
1007 m->reset_timeout = atoi (value); 976 m->reset_timeout = atoi (value);
1008 }
1009 else if (!strcmp (key, "value") || !strcmp (key, "swap_time")) 977 else if (!strcmp (key, "value") || !strcmp (key, "swap_time"))
1010 {
1011 m->timeout = atoi (value); 978 m->timeout = atoi (value);
1012 }
1013 else if (!strcmp (key, "level") || !strcmp (key, "difficulty")) 979 else if (!strcmp (key, "level") || !strcmp (key, "difficulty"))
1014 { 980 m->difficulty = clamp (atoi (value), 1, settings.max_level);
1015 m->difficulty = atoi (value);
1016 }
1017 else if (!strcmp (key, "invisible") || !strcmp (key, "darkness")) 981 else if (!strcmp (key, "invisible") || !strcmp (key, "darkness"))
1018 {
1019 m->darkness = atoi (value); 982 m->darkness = atoi (value);
1020 }
1021 else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime")) 983 else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime"))
1022 {
1023 m->fixed_resettime = atoi (value); 984 m->fixed_resettime = atoi (value);
1024 }
1025 else if (!strcmp (key, "unique")) 985 else if (!strcmp (key, "unique"))
1026 {
1027 m->unique = atoi (value); 986 m->unique = atoi (value);
1028 }
1029 else if (!strcmp (key, "template")) 987 else if (!strcmp (key, "template"))
1030 {
1031 m->templatemap = atoi (value); 988 m->templatemap = atoi (value);
1032 }
1033 else if (!strcmp (key, "region")) 989 else if (!strcmp (key, "region"))
1034 {
1035 m->region = get_region_by_name (value); 990 m->region = get_region_by_name (value);
1036 }
1037 else if (!strcmp (key, "shopitems")) 991 else if (!strcmp (key, "shopitems"))
1038 { 992 {
1039 *end = 0; 993 *end = 0;
1040 m->shopitems = parse_shop_string (value); 994 m->shopitems = parse_shop_string (value);
1041 } 995 }
1042 else if (!strcmp (key, "shopgreed")) 996 else if (!strcmp (key, "shopgreed"))
1043 {
1044 m->shopgreed = atof (value); 997 m->shopgreed = atof (value);
1045 }
1046 else if (!strcmp (key, "shopmin")) 998 else if (!strcmp (key, "shopmin"))
1047 {
1048 m->shopmin = atol (value); 999 m->shopmin = atol (value);
1049 }
1050 else if (!strcmp (key, "shopmax")) 1000 else if (!strcmp (key, "shopmax"))
1051 {
1052 m->shopmax = atol (value); 1001 m->shopmax = atol (value);
1053 }
1054 else if (!strcmp (key, "shoprace")) 1002 else if (!strcmp (key, "shoprace"))
1055 { 1003 {
1056 *end = 0; 1004 *end = 0;
1057 m->shoprace = strdup_local (value); 1005 m->shoprace = strdup (value);
1058 } 1006 }
1059 else if (!strcmp (key, "outdoor")) 1007 else if (!strcmp (key, "outdoor"))
1060 {
1061 m->outdoor = atoi (value); 1008 m->outdoor = atoi (value);
1062 }
1063 else if (!strcmp (key, "temp")) 1009 else if (!strcmp (key, "temp"))
1064 {
1065 m->temp = atoi (value); 1010 m->temp = atoi (value);
1066 }
1067 else if (!strcmp (key, "pressure")) 1011 else if (!strcmp (key, "pressure"))
1068 {
1069 m->pressure = atoi (value); 1012 m->pressure = atoi (value);
1070 }
1071 else if (!strcmp (key, "humid")) 1013 else if (!strcmp (key, "humid"))
1072 {
1073 m->humid = atoi (value); 1014 m->humid = atoi (value);
1074 }
1075 else if (!strcmp (key, "windspeed")) 1015 else if (!strcmp (key, "windspeed"))
1076 {
1077 m->windspeed = atoi (value); 1016 m->windspeed = atoi (value);
1078 }
1079 else if (!strcmp (key, "winddir")) 1017 else if (!strcmp (key, "winddir"))
1080 {
1081 m->winddir = atoi (value); 1018 m->winddir = atoi (value);
1082 }
1083 else if (!strcmp (key, "sky")) 1019 else if (!strcmp (key, "sky"))
1084 {
1085 m->sky = atoi (value); 1020 m->sky = atoi (value);
1086 }
1087 else if (!strcmp (key, "nosmooth")) 1021 else if (!strcmp (key, "nosmooth"))
1088 {
1089 m->nosmooth = atoi (value); 1022 m->nosmooth = atoi (value);
1090 }
1091 else if (!strncmp (key, "tile_path_", 10)) 1023 else if (!strncmp (key, "tile_path_", 10))
1092 { 1024 {
1093 int tile = atoi (key + 10); 1025 int tile = atoi (key + 10);
1094 1026
1095 if (tile < 1 || tile > 4) 1027 if (tile < 1 || tile > 4)
… …
1128 } 1060 }
1129 1061
1130 if (editor) 1062 if (editor)
1131 { 1063 {
1132 /* Use the value as in the file. */ 1064 /* Use the value as in the file. */
1133 m->tile_path[tile - 1] = strdup_local (value); 1065 m->tile_path[tile - 1] = strdup (value);
1134 } 1066 }
1135 else if (path != NULL) 1067 else if (path != NULL)
1136 { 1068 {
1137 /* Use the normalized value. */ 1069 /* Use the normalized value. */
1138 m->tile_path[tile - 1] = strdup_local (path); 1070 m->tile_path[tile - 1] = strdup (path);
1139 } 1071 }
1140 } /* end if tile direction (in)valid */ 1072 } /* end if tile direction (in)valid */
1141 } 1073 }
1142 else 1074 else
1143 {
1144 LOG (llevError, "Got unknown value in map header: %s %s\n", key, value); 1075 LOG (llevError, "Got unknown value in map header: %s %s\n", key, value);
1145 }
1146 } 1076 }
1077
1147 if (!key || strcmp (key, "end")) 1078 if (!key || strcmp (key, "end"))
1148 { 1079 {
1149 LOG (llevError, "Got premature eof on map header!\n"); 1080 LOG (llevError, "Got premature eof on map header!\n");
1150 return 1; 1081 return 1;
1151 } 1082 }
1083
1152 return 0; 1084 return 0;
1153} 1085}
1154 1086
1155/* 1087/*
1156 * Opens the file "filename" and reads information about the map 1088 * Opens the file "filename" and reads information about the map
1157 * from the given file, and stores it in a newly allocated 1089 * from the given file, and stores it in a newly allocated
1158 * mapstruct. A pointer to this structure is returned, or NULL on failure. 1090 * maptile. A pointer to this structure is returned, or NULL on failure.
1159 * flags correspond to those in map.h. Main ones used are 1091 * flags correspond to those in map.h. Main ones used are
1160 * MAP_PLAYER_UNIQUE, in which case we don't do any name changes, and 1092 * MAP_PLAYER_UNIQUE, in which case we don't do any name changes, and
1161 * MAP_BLOCK, in which case we block on this load. This happens in all 1093 * MAP_BLOCK, in which case we block on this load. This happens in all
1162 * cases, no matter if this flag is set or not. 1094 * cases, no matter if this flag is set or not.
1163 * MAP_STYLE: style map - don't add active objects, don't add to server 1095 * MAP_STYLE: style map - don't add active objects, don't add to server
1164 * managed map list. 1096 * managed map list.
1165 */ 1097 */
1166 1098
1167mapstruct * 1099maptile *
1168load_original_map (const char *filename, int flags) 1100load_original_map (const char *filename, int flags)
1169{ 1101{
1170 mapstruct *m; 1102 maptile *m;
1171 char pathname[MAX_BUF]; 1103 char pathname[MAX_BUF];
1172 1104
1173 if (flags & MAP_PLAYER_UNIQUE) 1105 if (flags & MAP_PLAYER_UNIQUE)
1174 strcpy (pathname, filename); 1106 strcpy (pathname, filename);
1175 else if (flags & MAP_OVERLAY) 1107 else if (flags & MAP_OVERLAY)
… …
1192 LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags); 1124 LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags);
1193 delete_map (m); 1125 delete_map (m);
1194 return NULL; 1126 return NULL;
1195 } 1127 }
1196 1128
1197 allocate_map (m); 1129 m->allocate ();
1198 1130
1199 m->in_memory = MAP_LOADING; 1131 m->in_memory = MAP_LOADING;
1200 load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE)); 1132 load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE));
1201 1133
1202 m->in_memory = MAP_IN_MEMORY; 1134 m->in_memory = MAP_IN_MEMORY;
… …
1211 * Loads a map, which has been loaded earlier, from file. 1143 * Loads a map, which has been loaded earlier, from file.
1212 * Return the map object we load into (this can change from the passed 1144 * Return the map object we load into (this can change from the passed
1213 * option if we can't find the original map) 1145 * option if we can't find the original map)
1214 */ 1146 */
1215 1147
1216static mapstruct * 1148static maptile *
1217load_temporary_map (mapstruct *m) 1149load_temporary_map (maptile *m)
1218{ 1150{
1219 char buf[MAX_BUF]; 1151 char buf[MAX_BUF];
1220 1152
1221 if (!m->tmpname) 1153 if (!m->tmpname)
1222 { 1154 {
… …
1248 LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname); 1180 LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname);
1249 delete_map (m); 1181 delete_map (m);
1250 m = load_original_map (m->path, 0); 1182 m = load_original_map (m->path, 0);
1251 return NULL; 1183 return NULL;
1252 } 1184 }
1185
1253 allocate_map (m); 1186 m->allocate ();
1254 1187
1255 m->in_memory = MAP_LOADING; 1188 m->in_memory = MAP_LOADING;
1256 load_objects (m, thawer, 0); 1189 load_objects (m, thawer, 0);
1257 1190
1258 m->in_memory = MAP_IN_MEMORY; 1191 m->in_memory = MAP_IN_MEMORY;
… …
1264 * Loads a map, which has been loaded earlier, from file. 1197 * Loads a map, which has been loaded earlier, from file.
1265 * Return the map object we load into (this can change from the passed 1198 * Return the map object we load into (this can change from the passed
1266 * option if we can't find the original map) 1199 * option if we can't find the original map)
1267 */ 1200 */
1268 1201
1269mapstruct * 1202maptile *
1270load_overlay_map (const char *filename, mapstruct *m) 1203load_overlay_map (const char *filename, maptile *m)
1271{ 1204{
1272 char pathname[MAX_BUF]; 1205 char pathname[MAX_BUF];
1273 1206
1274 strcpy (pathname, create_overlay_pathname (filename)); 1207 strcpy (pathname, create_overlay_pathname (filename));
1275 1208
… …
1283 LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname); 1216 LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname);
1284 delete_map (m); 1217 delete_map (m);
1285 m = load_original_map (m->path, 0); 1218 m = load_original_map (m->path, 0);
1286 return NULL; 1219 return NULL;
1287 } 1220 }
1288 /*allocate_map(m); */ 1221 /*m->allocate ();*/
1289 1222
1290 m->in_memory = MAP_LOADING; 1223 m->in_memory = MAP_LOADING;
1291 load_objects (m, thawer, MAP_OVERLAY); 1224 load_objects (m, thawer, MAP_OVERLAY);
1292 1225
1293 m->in_memory = MAP_IN_MEMORY; 1226 m->in_memory = MAP_IN_MEMORY;
… …
1298 * This is the start of unique map handling code 1231 * This is the start of unique map handling code
1299 *****************************************************************************/ 1232 *****************************************************************************/
1300 1233
1301/* This goes through map 'm' and removed any unique items on the map. */ 1234/* This goes through map 'm' and removed any unique items on the map. */
1302static void 1235static void
1303delete_unique_items (mapstruct *m) 1236delete_unique_items (maptile *m)
1304{ 1237{
1305 int i, j, unique; 1238 int i, j, unique;
1306 object *op, *next; 1239 object *op, *next;
1307 1240
1308 for (i = 0; i < MAP_WIDTH (m); i++) 1241 for (i = 0; i < MAP_WIDTH (m); i++)
1309 for (j = 0; j < MAP_HEIGHT (m); j++) 1242 for (j = 0; j < MAP_HEIGHT (m); j++)
1310 { 1243 {
1311 unique = 0; 1244 unique = 0;
1245
1312 for (op = get_map_ob (m, i, j); op; op = next) 1246 for (op = GET_MAP_OB (m, i, j); op; op = next)
1313 { 1247 {
1314 next = op->above; 1248 next = op->above;
1249
1315 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) 1250 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
1316 unique = 1; 1251 unique = 1;
1252
1317 if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique)) 1253 if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique))
1318 { 1254 {
1319 clean_object (op); 1255 clean_object (op);
1256
1320 if (QUERY_FLAG (op, FLAG_IS_LINKED)) 1257 if (QUERY_FLAG (op, FLAG_IS_LINKED))
1321 remove_button_link (op); 1258 remove_button_link (op);
1322 remove_ob (op); 1259
1323 free_object (op); 1260 op->destroy ();
1324 } 1261 }
1325 } 1262 }
1326 } 1263 }
1327} 1264}
1328 1265
… …
1330/* 1267/*
1331 * Loads unique objects from file(s) into the map which is in memory 1268 * Loads unique objects from file(s) into the map which is in memory
1332 * m is the map to load unique items into. 1269 * m is the map to load unique items into.
1333 */ 1270 */
1334static void 1271static void
1335load_unique_objects (mapstruct *m) 1272load_unique_objects (maptile *m)
1336{ 1273{
1337 int count; 1274 int count;
1338 char firstname[MAX_BUF]; 1275 char firstname[MAX_BUF];
1339 1276
1340 for (count = 0; count < 10; count++) 1277 for (count = 0; count < 10; count++)
… …
1363 1300
1364/* 1301/*
1365 * Saves a map to file. If flag is set, it is saved into the same 1302 * Saves a map to file. If flag is set, it is saved into the same
1366 * file it was (originally) loaded from. Otherwise a temporary 1303 * file it was (originally) loaded from. Otherwise a temporary
1367 * filename will be genarated, and the file will be stored there. 1304 * filename will be genarated, and the file will be stored there.
1368 * The temporary filename will be stored in the mapstructure. 1305 * The temporary filename will be stored in the maptileure.
1369 * If the map is unique, we also save to the filename in the map 1306 * If the map is unique, we also save to the filename in the map
1370 * (this should have been updated when first loaded) 1307 * (this should have been updated when first loaded)
1371 */ 1308 */
1372 1309
1373int 1310int
1374new_save_map (mapstruct *m, int flag) 1311new_save_map (maptile *m, int flag)
1375{ 1312{
1376 char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF]; 1313 char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF];
1377 int i; 1314 int i;
1378 1315
1379 if (flag && !*m->path) 1316 if (flag && !*m->path)
… …
1397 make_path_to_file (filename); 1334 make_path_to_file (filename);
1398 } 1335 }
1399 else 1336 else
1400 { 1337 {
1401 if (!m->tmpname) 1338 if (!m->tmpname)
1402 m->tmpname = tempnam_local (settings.tmpdir, NULL); 1339 m->tmpname = tempnam (settings.tmpdir, NULL);
1403 1340
1404 strcpy (filename, m->tmpname); 1341 strcpy (filename, m->tmpname);
1405 } 1342 }
1406 1343
1407 LOG (llevDebug, "Saving map %s to %s\n", m->path, filename); 1344 LOG (llevDebug, "Saving map %s to %s\n", m->path, filename);
… …
1431 print_shop_string (m, shop); 1368 print_shop_string (m, shop);
1432 fprintf (freezer, "shopitems %s\n", shop); 1369 fprintf (freezer, "shopitems %s\n", shop);
1433 } 1370 }
1434 if (m->shopgreed) 1371 if (m->shopgreed)
1435 fprintf (freezer, "shopgreed %f\n", m->shopgreed); 1372 fprintf (freezer, "shopgreed %f\n", m->shopgreed);
1436#ifndef WIN32
1437 if (m->shopmin) 1373 if (m->shopmin)
1438 fprintf (freezer, "shopmin %llu\n", m->shopmin); 1374 fprintf (freezer, "shopmin %llu\n", m->shopmin);
1439 if (m->shopmax) 1375 if (m->shopmax)
1440 fprintf (freezer, "shopmax %llu\n", m->shopmax); 1376 fprintf (freezer, "shopmax %llu\n", m->shopmax);
1441#else
1442 if (m->shopmin)
1443 fprintf (freezer, "shopmin %I64u\n", m->shopmin);
1444 if (m->shopmax)
1445 fprintf (freezer, "shopmax %I64u\n", m->shopmax);
1446#endif
1447 if (m->shoprace) 1377 if (m->shoprace)
1448 fprintf (freezer, "shoprace %s\n", m->shoprace); 1378 fprintf (freezer, "shoprace %s\n", m->shoprace);
1449 if (m->darkness) 1379 if (m->darkness)
1450 fprintf (freezer, "darkness %d\n", m->darkness); 1380 fprintf (freezer, "darkness %d\n", m->darkness);
1451 if (m->width) 1381 if (m->width)
… …
1530 object *tmp, *next; 1460 object *tmp, *next;
1531 1461
1532 for (tmp = op->inv; tmp; tmp = next) 1462 for (tmp = op->inv; tmp; tmp = next)
1533 { 1463 {
1534 next = tmp->below; 1464 next = tmp->below;
1465
1535 clean_object (tmp); 1466 clean_object (tmp);
1536 if (QUERY_FLAG (tmp, FLAG_IS_LINKED)) 1467 if (QUERY_FLAG (tmp, FLAG_IS_LINKED))
1537 remove_button_link (tmp); 1468 remove_button_link (tmp);
1538 remove_ob (tmp); 1469
1539 free_object (tmp); 1470 tmp->destroy ();
1540 } 1471 }
1541} 1472}
1542 1473
1543/* 1474/*
1544 * Remove and free all objects in the given map. 1475 * Remove and free all objects in the given map.
1545 */ 1476 */
1546 1477
1547void 1478void
1548free_all_objects (mapstruct *m) 1479free_all_objects (maptile *m)
1549{ 1480{
1550 int i, j; 1481 int i, j;
1551 object *op; 1482 object *op;
1552 1483
1553 for (i = 0; i < MAP_WIDTH (m); i++) 1484 for (i = 0; i < MAP_WIDTH (m); i++)
… …
1560 if (op == previous_obj) 1491 if (op == previous_obj)
1561 { 1492 {
1562 LOG (llevDebug, "free_all_objects: Link error, bailing out.\n"); 1493 LOG (llevDebug, "free_all_objects: Link error, bailing out.\n");
1563 break; 1494 break;
1564 } 1495 }
1496
1565 previous_obj = op; 1497 previous_obj = op;
1498
1566 if (op->head != NULL) 1499 if (op->head != NULL)
1567 op = op->head; 1500 op = op->head;
1568 1501
1569 /* If the map isn't in memory, free_object will remove and 1502 /* If the map isn't in memory, free_object will remove and
1570 * free objects in op's inventory. So let it do the job. 1503 * free objects in op's inventory. So let it do the job.
1571 */ 1504 */
1572 if (m->in_memory == MAP_IN_MEMORY) 1505 if (m->in_memory == MAP_IN_MEMORY)
1573 clean_object (op); 1506 clean_object (op);
1574 remove_ob (op); 1507
1575 free_object (op); 1508 op->destroy ();
1576 } 1509 }
1577 } 1510 }
1578} 1511}
1579 1512
1580/* 1513/*
1581 * Frees everything allocated by the given mapstructure. 1514 * Frees everything allocated by the given maptileure.
1582 * don't free tmpname - our caller is left to do that 1515 * don't free tmpname - our caller is left to do that
1583 */ 1516 */
1584 1517
1585void 1518void
1586free_map (mapstruct *m, int flag) 1519free_map (maptile *m, int flag)
1587{ 1520{
1588 int i; 1521 int i;
1589 1522
1590 if (!m->in_memory) 1523 if (!m->in_memory)
1591 { 1524 {
1592 LOG (llevError, "Trying to free freed map.\n"); 1525 LOG (llevError, "Trying to free freed map.\n");
1593 return; 1526 return;
1594 } 1527 }
1528
1529 // TODO: use new/delete
1530#define FREE_AND_CLEAR(p) { free (p); p = NULL; }
1531
1595 if (flag && m->spaces) 1532 if (flag && m->spaces)
1596 free_all_objects (m); 1533 free_all_objects (m);
1597 if (m->name) 1534 if (m->name)
1598 FREE_AND_CLEAR (m->name); 1535 FREE_AND_CLEAR (m->name);
1599 if (m->spaces) 1536 if (m->spaces)
1600 FREE_AND_CLEAR (m->spaces); 1537 FREE_AND_CLEAR (m->spaces);
1601 if (m->msg) 1538 if (m->msg)
1602 FREE_AND_CLEAR (m->msg); 1539 FREE_AND_CLEAR (m->msg);
1603 if (m->maplore) 1540 if (m->maplore)
1604 FREE_AND_CLEAR (m->maplore); 1541 FREE_AND_CLEAR (m->maplore);
1605 if (m->shopitems) 1542
1606 delete[]m->shopitems; 1543 delete [] m->shopitems;
1607 m->shopitems = 0; 1544 m->shopitems = 0;
1545
1608 if (m->shoprace) 1546 if (m->shoprace)
1609 FREE_AND_CLEAR (m->shoprace); 1547 FREE_AND_CLEAR (m->shoprace);
1548
1610 if (m->buttons) 1549 if (m->buttons)
1611 free_objectlinkpt (m->buttons); 1550 free_objectlinkpt (m->buttons);
1551
1612 m->buttons = NULL; 1552 m->buttons = NULL;
1553
1613 for (i = 0; i < 4; i++) 1554 for (i = 0; i < 4; i++)
1614 { 1555 {
1615 if (m->tile_path[i]) 1556 if (m->tile_path[i])
1616 FREE_AND_CLEAR (m->tile_path[i]); 1557 FREE_AND_CLEAR (m->tile_path[i]);
1617 m->tile_map[i] = NULL; 1558 m->tile_map[i] = NULL;
1618 } 1559 }
1560
1619 m->in_memory = MAP_SWAPPED; 1561 m->in_memory = MAP_SWAPPED;
1562
1563#undef FREE_AND_CLEAR
1564
1620} 1565}
1621 1566
1622/* 1567/*
1623 * function: vanish mapstruct 1568 * function: vanish maptile
1624 * m : pointer to mapstruct, if NULL no action 1569 * m : pointer to maptile, if NULL no action
1625 * this deletes all the data on the map (freeing pointers) 1570 * this deletes all the data on the map (freeing pointers)
1626 * and then removes this map from the global linked list of maps. 1571 * and then removes this map from the global linked list of maps.
1627 */ 1572 */
1628 1573
1629void 1574void
1630delete_map (mapstruct *m) 1575delete_map (maptile *m)
1631{ 1576{
1632 mapstruct *tmp, *last; 1577 maptile *tmp, *last;
1633 int i; 1578 int i;
1634 1579
1635 if (!m) 1580 if (!m)
1636 return; 1581 return;
1637 1582
… …
1684 else 1629 else
1685 last->next = m->next; 1630 last->next = m->next;
1686 1631
1687 delete m; 1632 delete m;
1688} 1633}
1689
1690
1691 1634
1692/* 1635/*
1693 * Makes sure the given map is loaded and swapped in. 1636 * Makes sure the given map is loaded and swapped in.
1694 * name is path name of the map. 1637 * name is path name of the map.
1695 * flags meaning: 1638 * flags meaning:
… …
1698 * 0x2 (MAP_PLAYER_UNIQUE) - this is a unique map for each player. 1641 * 0x2 (MAP_PLAYER_UNIQUE) - this is a unique map for each player.
1699 * dont do any more name translation on it. 1642 * dont do any more name translation on it.
1700 * 1643 *
1701 * Returns a pointer to the given map. 1644 * Returns a pointer to the given map.
1702 */ 1645 */
1703 1646maptile *
1704mapstruct *
1705ready_map_name (const char *name, int flags) 1647ready_map_name (const char *name, int flags)
1706{ 1648{
1707 mapstruct *m; 1649 maptile *m;
1708 1650
1709 if (!name) 1651 if (!name)
1710 return (NULL); 1652 return (NULL);
1711 1653
1712 /* Have we been at this level before? */ 1654 /* Have we been at this level before? */
… …
1814 * have a difficulty set than using this function - human calculation 1756 * have a difficulty set than using this function - human calculation
1815 * is much better than this functions guesswork. 1757 * is much better than this functions guesswork.
1816 */ 1758 */
1817 1759
1818int 1760int
1819calculate_difficulty (mapstruct *m) 1761calculate_difficulty (maptile *m)
1820{ 1762{
1821 object *op; 1763 object *op;
1822 archetype *at; 1764 archetype *at;
1823 int x, y, i; 1765 int x, y, i;
1824 long monster_cnt = 0; 1766 long monster_cnt = 0;
… …
1831 return MAP_DIFFICULTY (m); 1773 return MAP_DIFFICULTY (m);
1832 } 1774 }
1833 1775
1834 for (x = 0; x < MAP_WIDTH (m); x++) 1776 for (x = 0; x < MAP_WIDTH (m); x++)
1835 for (y = 0; y < MAP_HEIGHT (m); y++) 1777 for (y = 0; y < MAP_HEIGHT (m); y++)
1836 for (op = get_map_ob (m, x, y); op != NULL; op = op->above) 1778 for (op = GET_MAP_OB (m, x, y); op != NULL; op = op->above)
1837 { 1779 {
1838 if (QUERY_FLAG (op, FLAG_MONSTER)) 1780 if (QUERY_FLAG (op, FLAG_MONSTER))
1839 { 1781 {
1840 total_exp += op->stats.exp; 1782 total_exp += op->stats.exp;
1841 monster_cnt++; 1783 monster_cnt++;
… …
1866 1808
1867 return 1; 1809 return 1;
1868} 1810}
1869 1811
1870void 1812void
1871clean_tmp_map (mapstruct *m) 1813clean_tmp_map (maptile *m)
1872{ 1814{
1873 if (m->tmpname == NULL) 1815 if (m->tmpname == NULL)
1874 return; 1816 return;
1875 INVOKE_MAP (CLEAN, m); 1817 INVOKE_MAP (CLEAN, m);
1876 (void) unlink (m->tmpname); 1818 (void) unlink (m->tmpname);
… …
1901 * to maps than los. 1843 * to maps than los.
1902 * postive values make it darker, negative make it brighter 1844 * postive values make it darker, negative make it brighter
1903 */ 1845 */
1904 1846
1905int 1847int
1906change_map_light (mapstruct *m, int change) 1848change_map_light (maptile *m, int change)
1907{ 1849{
1908 int new_level = m->darkness + change; 1850 int new_level = m->darkness + change;
1909 1851
1910 /* Nothing to do */ 1852 /* Nothing to do */
1911 if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS)) 1853 if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS))
… …
1934 /* All clients need to get re-updated for the change */ 1876 /* All clients need to get re-updated for the change */
1935 update_all_map_los (m); 1877 update_all_map_los (m);
1936 return 1; 1878 return 1;
1937} 1879}
1938 1880
1939
1940/* 1881/*
1941 * This function updates various attributes about a specific space 1882 * This function updates various attributes about a specific space
1942 * on the map (what it looks like, whether it blocks magic, 1883 * on the map (what it looks like, whether it blocks magic,
1943 * has a living creatures, prevents people from passing 1884 * has a living creatures, prevents people from passing
1944 * through, etc) 1885 * through, etc)
1945 */ 1886 */
1946void 1887void
1947update_position (mapstruct *m, int x, int y) 1888mapspace::update_ ()
1948{ 1889{
1949 object *tmp, *last = NULL; 1890 object *tmp, *last = 0;
1950 uint8 flags = 0, oldflags, light = 0, anywhere = 0; 1891 uint8 flags = 0, light = 0, anywhere = 0;
1951 New_Face *top, *floor, *middle; 1892 New_Face *top, *floor, *middle;
1952 object *top_obj, *floor_obj, *middle_obj; 1893 object *top_obj, *floor_obj, *middle_obj;
1953 MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0; 1894 MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;
1954 1895
1955 oldflags = GET_MAP_FLAGS (m, x, y);
1956 if (!(oldflags & P_NEED_UPDATE))
1957 {
1958 LOG (llevDebug, "update_position called with P_NEED_UPDATE not set: %s (%d, %d)\n", m->path, x, y);
1959 return;
1960 }
1961
1962 middle = blank_face; 1896 middle = blank_face;
1963 top = blank_face; 1897 top = blank_face;
1964 floor = blank_face; 1898 floor = blank_face;
1965 1899
1966 middle_obj = NULL; 1900 middle_obj = 0;
1967 top_obj = NULL; 1901 top_obj = 0;
1968 floor_obj = NULL; 1902 floor_obj = 0;
1969 1903
1970 for (tmp = get_map_ob (m, x, y); tmp; last = tmp, tmp = tmp->above) 1904 for (tmp = bottom; tmp; last = tmp, tmp = tmp->above)
1971 { 1905 {
1972
1973 /* This could be made additive I guess (two lights better than 1906 /* This could be made additive I guess (two lights better than
1974 * one). But if so, it shouldn't be a simple additive - 2 1907 * one). But if so, it shouldn't be a simple additive - 2
1975 * light bulbs do not illuminate twice as far as once since 1908 * light bulbs do not illuminate twice as far as once since
1976 * it is a disapation factor that is squared (or is it cubed?) 1909 * it is a dissapation factor that is cubed.
1977 */ 1910 */
1978 if (tmp->glow_radius > light) 1911 if (tmp->glow_radius > light)
1979 light = tmp->glow_radius; 1912 light = tmp->glow_radius;
1980 1913
1981 /* This call is needed in order to update objects the player 1914 /* This call is needed in order to update objects the player
… …
2019 { 1952 {
2020 middle = tmp->face; 1953 middle = tmp->face;
2021 middle_obj = tmp; 1954 middle_obj = tmp;
2022 } 1955 }
2023 } 1956 }
1957
2024 if (tmp == tmp->above) 1958 if (tmp == tmp->above)
2025 { 1959 {
2026 LOG (llevError, "Error in structure of map\n"); 1960 LOG (llevError, "Error in structure of map\n");
2027 exit (-1); 1961 exit (-1);
2028 } 1962 }
2029 1963
2030 move_slow |= tmp->move_slow; 1964 move_slow |= tmp->move_slow;
2031 move_block |= tmp->move_block; 1965 move_block |= tmp->move_block;
2032 move_on |= tmp->move_on; 1966 move_on |= tmp->move_on;
2033 move_off |= tmp->move_off; 1967 move_off |= tmp->move_off;
2034 move_allow |= tmp->move_allow; 1968 move_allow |= tmp->move_allow;
2035 1969
2036 if (QUERY_FLAG (tmp, FLAG_ALIVE))
2037 flags |= P_IS_ALIVE;
2038 if (QUERY_FLAG (tmp, FLAG_NO_MAGIC))
2039 flags |= P_NO_MAGIC;
2040 if (QUERY_FLAG (tmp, FLAG_DAMNED))
2041 flags |= P_NO_CLERIC;
2042 if (tmp->type == SAFE_GROUND)
2043 flags |= P_SAFE;
2044
2045 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) 1970 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) flags |= P_BLOCKSVIEW;
2046 flags |= P_BLOCKSVIEW; 1971 if (QUERY_FLAG (tmp, FLAG_NO_MAGIC)) flags |= P_NO_MAGIC;
2047 } /* for stack of objects */ 1972 if (tmp->type == PLAYER) flags |= P_PLAYER;
2048 1973 if (tmp->type == SAFE_GROUND) flags |= P_SAFE;
2049 /* we don't want to rely on this function to have accurate flags, but 1974 if (QUERY_FLAG (tmp, FLAG_ALIVE)) flags |= P_IS_ALIVE;
2050 * since we're already doing the work, we calculate them here. 1975 if (QUERY_FLAG (tmp, FLAG_DAMNED)) flags |= P_NO_CLERIC;
2051 * if they don't match, logic is broken someplace.
2052 */
2053 if (((oldflags & ~(P_NEED_UPDATE | P_NO_ERROR)) != flags) && (!(oldflags & P_NO_ERROR)))
2054 { 1976 }
2055 LOG (llevDebug, "update_position: updated flags do not match old flags: %s (old=%d,new=%d) %x != %x\n", 1977
2056 m->path, x, y, (oldflags & ~P_NEED_UPDATE), flags); 1978 this->light = light;
2057 } 1979 this->flags_ = flags;
2058 SET_MAP_FLAGS (m, x, y, flags); 1980 this->move_block = move_block & ~move_allow;
2059 SET_MAP_MOVE_BLOCK (m, x, y, move_block & ~move_allow); 1981 this->move_on = move_on;
2060 SET_MAP_MOVE_ON (m, x, y, move_on); 1982 this->move_off = move_off;
2061 SET_MAP_MOVE_OFF (m, x, y, move_off); 1983 this->move_slow = move_slow;
2062 SET_MAP_MOVE_SLOW (m, x, y, move_slow);
2063 1984
2064 /* At this point, we have a floor face (if there is a floor), 1985 /* At this point, we have a floor face (if there is a floor),
2065 * and the floor is set - we are not going to touch it at 1986 * and the floor is set - we are not going to touch it at
2066 * this point. 1987 * this point.
2067 * middle contains the highest visibility face. 1988 * middle contains the highest visibility face.
… …
2121 break; 2042 break;
2122 } 2043 }
2123 } 2044 }
2124 } 2045 }
2125 } 2046 }
2047
2126 if (middle == floor) 2048 if (middle == floor)
2127 middle = blank_face; 2049 middle = blank_face;
2050
2128 if (top == middle) 2051 if (top == middle)
2129 middle = blank_face; 2052 middle = blank_face;
2130 SET_MAP_FACE (m, x, y, top, 0);
2131 if (top != blank_face)
2132 SET_MAP_FACE_OBJ (m, x, y, top_obj, 0);
2133 else
2134 SET_MAP_FACE_OBJ (m, x, y, NULL, 0);
2135 SET_MAP_FACE (m, x, y, middle, 1);
2136 if (middle != blank_face)
2137 SET_MAP_FACE_OBJ (m, x, y, middle_obj, 1);
2138 else
2139 SET_MAP_FACE_OBJ (m, x, y, NULL, 1);
2140 SET_MAP_FACE (m, x, y, floor, 2);
2141 if (floor != blank_face)
2142 SET_MAP_FACE_OBJ (m, x, y, floor_obj, 2);
2143 else
2144 SET_MAP_FACE_OBJ (m, x, y, NULL, 2);
2145 SET_MAP_LIGHT (m, x, y, light);
2146}
2147 2053
2054 faces [0] = top; faces_obj [0] = top != blank_face ? top_obj : 0;
2055 faces [1] = middle; faces_obj [1] = middle != blank_face ? middle_obj : 0;
2056 faces [2] = floor; faces_obj [2] = floor != blank_face ? floor_obj : 0;
2057}
2148 2058
2149void 2059void
2150set_map_reset_time (mapstruct *map) 2060set_map_reset_time (maptile *map)
2151{ 2061{
2152 int timeout; 2062 int timeout;
2153 2063
2154 timeout = MAP_RESET_TIMEOUT (map); 2064 timeout = MAP_RESET_TIMEOUT (map);
2155 if (timeout <= 0) 2065 if (timeout <= 0)
2156 timeout = MAP_DEFAULTRESET; 2066 timeout = MAP_DEFAULTRESET;
2157 if (timeout >= MAP_MAXRESET) 2067 if (timeout >= MAP_MAXRESET)
2158 timeout = MAP_MAXRESET; 2068 timeout = MAP_MAXRESET;
2159 MAP_WHEN_RESET (map) = seconds () + timeout; 2069 MAP_WHEN_RESET (map) = time (0) + timeout;
2160} 2070}
2161 2071
2162/* this updates the orig_map->tile_map[tile_num] value after loading 2072/* this updates the orig_map->tile_map[tile_num] value after loading
2163 * the map. It also takes care of linking back the freshly loaded 2073 * the map. It also takes care of linking back the freshly loaded
2164 * maps tile_map values if it tiles back to this one. It returns 2074 * maps tile_map values if it tiles back to this one. It returns
2165 * the value of orig_map->tile_map[tile_num]. It really only does this 2075 * the value of orig_map->tile_map[tile_num]. It really only does this
2166 * so that it is easier for calling functions to verify success. 2076 * so that it is easier for calling functions to verify success.
2167 */ 2077 */
2168 2078
2169static mapstruct * 2079static maptile *
2170load_and_link_tiled_map (mapstruct *orig_map, int tile_num) 2080load_and_link_tiled_map (maptile *orig_map, int tile_num)
2171{ 2081{
2172 int dest_tile = (tile_num + 2) % 4; 2082 int dest_tile = (tile_num + 2) % 4;
2173 char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]); 2083 char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]);
2174 2084
2175 orig_map->tile_map[tile_num] = ready_map_name (path, 0); 2085 orig_map->tile_map[tile_num] = ready_map_name (path, 0);
… …
2190 * tiled maps. 2100 * tiled maps.
2191 * 2101 *
2192 * 2102 *
2193 */ 2103 */
2194int 2104int
2195out_of_map (mapstruct *m, int x, int y) 2105out_of_map (maptile *m, int x, int y)
2196{ 2106{
2197
2198 /* If we get passed a null map, this is obviously the 2107 /* If we get passed a null map, this is obviously the
2199 * case. This generally shouldn't happen, but if the 2108 * case. This generally shouldn't happen, but if the
2200 * map loads fail below, it could happen. 2109 * map loads fail below, it could happen.
2201 */ 2110 */
2202 if (!m) 2111 if (!m)
… …
2204 2113
2205 if (x < 0) 2114 if (x < 0)
2206 { 2115 {
2207 if (!m->tile_path[3]) 2116 if (!m->tile_path[3])
2208 return 1; 2117 return 1;
2118
2209 if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY) 2119 if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
2210 {
2211 load_and_link_tiled_map (m, 3); 2120 load_and_link_tiled_map (m, 3);
2212 } 2121
2213 return (out_of_map (m->tile_map[3], x + MAP_WIDTH (m->tile_map[3]), y)); 2122 return (out_of_map (m->tile_map[3], x + MAP_WIDTH (m->tile_map[3]), y));
2214 } 2123 }
2124
2215 if (x >= MAP_WIDTH (m)) 2125 if (x >= MAP_WIDTH (m))
2216 { 2126 {
2217 if (!m->tile_path[1]) 2127 if (!m->tile_path[1])
2218 return 1; 2128 return 1;
2129
2219 if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY) 2130 if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
2220 {
2221 load_and_link_tiled_map (m, 1); 2131 load_and_link_tiled_map (m, 1);
2222 } 2132
2223 return (out_of_map (m->tile_map[1], x - MAP_WIDTH (m), y)); 2133 return (out_of_map (m->tile_map[1], x - MAP_WIDTH (m), y));
2224 } 2134 }
2135
2225 if (y < 0) 2136 if (y < 0)
2226 { 2137 {
2227 if (!m->tile_path[0]) 2138 if (!m->tile_path[0])
2228 return 1; 2139 return 1;
2140
2229 if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY) 2141 if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
2230 {
2231 load_and_link_tiled_map (m, 0); 2142 load_and_link_tiled_map (m, 0);
2232 } 2143
2233 return (out_of_map (m->tile_map[0], x, y + MAP_HEIGHT (m->tile_map[0]))); 2144 return (out_of_map (m->tile_map[0], x, y + MAP_HEIGHT (m->tile_map[0])));
2234 } 2145 }
2146
2235 if (y >= MAP_HEIGHT (m)) 2147 if (y >= MAP_HEIGHT (m))
2236 { 2148 {
2237 if (!m->tile_path[2]) 2149 if (!m->tile_path[2])
2238 return 1; 2150 return 1;
2151
2239 if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY) 2152 if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
2240 {
2241 load_and_link_tiled_map (m, 2); 2153 load_and_link_tiled_map (m, 2);
2242 } 2154
2243 return (out_of_map (m->tile_map[2], x, y - MAP_HEIGHT (m))); 2155 return (out_of_map (m->tile_map[2], x, y - MAP_HEIGHT (m)));
2244 } 2156 }
2245 2157
2246 /* Simple case - coordinates are within this local 2158 /* Simple case - coordinates are within this local
2247 * map. 2159 * map.
… …
2255 * the map as that the coordinates are really on, and 2167 * the map as that the coordinates are really on, and
2256 * updates x and y to be the localized coordinates. 2168 * updates x and y to be the localized coordinates.
2257 * Using this is more efficient of calling out_of_map 2169 * Using this is more efficient of calling out_of_map
2258 * and then figuring out what the real map is 2170 * and then figuring out what the real map is
2259 */ 2171 */
2260mapstruct * 2172maptile *
2261get_map_from_coord (mapstruct *m, sint16 * x, sint16 * y) 2173get_map_from_coord (maptile *m, sint16 * x, sint16 * y)
2262{ 2174{
2263 2175
2264 if (*x < 0) 2176 if (*x < 0)
2265 { 2177 {
2266 if (!m->tile_path[3]) 2178 if (!m->tile_path[3])
2267 return NULL; 2179 return 0;
2268 if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY) 2180 if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
2269 load_and_link_tiled_map (m, 3); 2181 load_and_link_tiled_map (m, 3);
2270 2182
2271 *x += MAP_WIDTH (m->tile_map[3]); 2183 *x += MAP_WIDTH (m->tile_map[3]);
2272 return (get_map_from_coord (m->tile_map[3], x, y)); 2184 return (get_map_from_coord (m->tile_map[3], x, y));
2273 } 2185 }
2186
2274 if (*x >= MAP_WIDTH (m)) 2187 if (*x >= MAP_WIDTH (m))
2275 { 2188 {
2276 if (!m->tile_path[1]) 2189 if (!m->tile_path[1])
2277 return NULL; 2190 return 0;
2191
2278 if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY) 2192 if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
2279 load_and_link_tiled_map (m, 1); 2193 load_and_link_tiled_map (m, 1);
2280 2194
2281 *x -= MAP_WIDTH (m); 2195 *x -= MAP_WIDTH (m);
2282 return (get_map_from_coord (m->tile_map[1], x, y)); 2196 return (get_map_from_coord (m->tile_map[1], x, y));
2283 } 2197 }
2198
2284 if (*y < 0) 2199 if (*y < 0)
2285 { 2200 {
2286 if (!m->tile_path[0]) 2201 if (!m->tile_path[0])
2287 return NULL; 2202 return 0;
2203
2288 if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY) 2204 if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
2289 load_and_link_tiled_map (m, 0); 2205 load_and_link_tiled_map (m, 0);
2290 2206
2291 *y += MAP_HEIGHT (m->tile_map[0]); 2207 *y += MAP_HEIGHT (m->tile_map[0]);
2292 return (get_map_from_coord (m->tile_map[0], x, y)); 2208 return (get_map_from_coord (m->tile_map[0], x, y));
2293 } 2209 }
2210
2294 if (*y >= MAP_HEIGHT (m)) 2211 if (*y >= MAP_HEIGHT (m))
2295 { 2212 {
2296 if (!m->tile_path[2]) 2213 if (!m->tile_path[2])
2297 return NULL; 2214 return 0;
2215
2298 if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY) 2216 if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
2299 load_and_link_tiled_map (m, 2); 2217 load_and_link_tiled_map (m, 2);
2300 2218
2301 *y -= MAP_HEIGHT (m); 2219 *y -= MAP_HEIGHT (m);
2302 return (get_map_from_coord (m->tile_map[2], x, y)); 2220 return (get_map_from_coord (m->tile_map[2], x, y));
… …
2312/** 2230/**
2313 * Return whether map2 is adjacent to map1. If so, store the distance from 2231 * Return whether map2 is adjacent to map1. If so, store the distance from
2314 * map1 to map2 in dx/dy. 2232 * map1 to map2 in dx/dy.
2315 */ 2233 */
2316static int 2234static int
2317adjacent_map (const mapstruct *map1, const mapstruct *map2, int *dx, int *dy) 2235adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy)
2318{ 2236{
2319 if (!map1 || !map2) 2237 if (!map1 || !map2)
2320 return 0; 2238 return 0;
2321 2239
2322 if (map1 == map2) 2240 if (map1 == map2)
… …
2480 * for something in the future. Also, since no object is pasted, the best 2398 * for something in the future. Also, since no object is pasted, the best
2481 * field of the rv_vector is set to NULL. 2399 * field of the rv_vector is set to NULL.
2482 */ 2400 */
2483 2401
2484void 2402void
2485get_rangevector_from_mapcoord (const mapstruct *m, int x, int y, const object *op2, rv_vector * retval, int flags) 2403get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector * retval, int flags)
2486{ 2404{
2487 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y)) 2405 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
2488 { 2406 {
2489 /* be conservative and fill in _some_ data */ 2407 /* be conservative and fill in _some_ data */
2490 retval->distance = 100000; 2408 retval->distance = 100000;

Diff Legend

– Removed lines
+ Added lines
< Changed lines
> Changed lines