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.45 by root, Wed Dec 20 09:14:21 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 != NULL; m = m->next)
245 { 228 {
246 dump_map (m); 229 dump_map (m);
247 } 230 }
… …
256 * is needed. The case of not passing values is if we're just 239 * is needed. The case of not passing values is if we're just
257 * checking for the existence of something on those spaces, but 240 * checking for the existence of something on those spaces, but
258 * don't expect to insert/remove anything from those spaces. 241 * don't expect to insert/remove anything from those spaces.
259 */ 242 */
260int 243int
261get_map_flags (mapstruct *oldmap, mapstruct **newmap, sint16 x, sint16 y, sint16 * nx, sint16 * ny) 244get_map_flags (maptile *oldmap, maptile **newmap, sint16 x, sint16 y, sint16 * nx, sint16 * ny)
262{ 245{
263 sint16 newx, newy; 246 sint16 newx, newy;
264 int retval = 0; 247 int retval = 0;
265 mapstruct *mp; 248 maptile *mp;
266 249
267 if (out_of_map (oldmap, x, y)) 250 if (out_of_map (oldmap, x, y))
268 return P_OUT_OF_MAP; 251 return P_OUT_OF_MAP;
269 newx = x; 252 newx = x;
270 newy = y; 253 newy = y;
… …
281 retval |= mp->spaces[newx + mp->width * newy].flags; 264 retval |= mp->spaces[newx + mp->width * newy].flags;
282 265
283 return retval; 266 return retval;
284} 267}
285 268
286
287/* 269/*
288 * Returns true if the given coordinate is blocked except by the 270 * Returns true if the given coordinate is blocked except by the
289 * object passed is not blocking. This is used with 271 * object passed is not blocking. This is used with
290 * multipart monsters - if we want to see if a 2x2 monster 272 * multipart monsters - if we want to see if a 2x2 monster
291 * can move 1 space to the left, we don't want its own area 273 * can move 1 space to the left, we don't want its own area
… …
294 * monster. 276 * monster.
295 * m, x, y are the target map/coordinates - needed for map tiling. 277 * m, x, y are the target map/coordinates - needed for map tiling.
296 * the coordinates & map passed in should have been updated for tiling 278 * the coordinates & map passed in should have been updated for tiling
297 * by the caller. 279 * by the caller.
298 */ 280 */
299
300int 281int
301blocked_link (object *ob, mapstruct *m, int sx, int sy) 282blocked_link (object *ob, maptile *m, int sx, int sy)
302{ 283{
303 object *tmp; 284 object *tmp;
304 int mflags, blocked; 285 int mflags, blocked;
305 286
306 /* Make sure the coordinates are valid - they should be, as caller should 287 /* Make sure the coordinates are valid - they should be, as caller should
… …
342 /* We basically go through the stack of objects, and if there is 323 /* 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 324 * some other object that has NO_PASS or FLAG_ALIVE set, return
344 * true. If we get through the entire stack, that must mean 325 * true. If we get through the entire stack, that must mean
345 * ob is blocking it, so return 0. 326 * ob is blocking it, so return 0.
346 */ 327 */
347 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = tmp->above) 328 for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)
348 { 329 {
349 330
350 /* This must be before the checks below. Code for inventory checkers. */ 331 /* This must be before the checks below. Code for inventory checkers. */
351 if (tmp->type == CHECK_INV && OB_MOVE_BLOCK (ob, tmp)) 332 if (tmp->type == CHECK_INV && OB_MOVE_BLOCK (ob, tmp))
352 { 333 {
… …
416 * 397 *
417 * Note this used to be arch_blocked, but with new movement 398 * Note this used to be arch_blocked, but with new movement
418 * code, we need to have actual object to check its move_type 399 * code, we need to have actual object to check its move_type
419 * against the move_block values. 400 * against the move_block values.
420 */ 401 */
421
422int 402int
423ob_blocked (const object *ob, mapstruct *m, sint16 x, sint16 y) 403ob_blocked (const object *ob, maptile *m, sint16 x, sint16 y)
424{ 404{
425 archetype *tmp; 405 archetype *tmp;
426 int flag; 406 int flag;
427 mapstruct *m1; 407 maptile *m1;
428 sint16 sx, sy; 408 sint16 sx, sy;
429 409
430 if (ob == NULL) 410 if (ob == NULL)
431 { 411 {
432 flag = get_map_flags (m, &m1, x, y, &sx, &sy); 412 flag = get_map_flags (m, &m1, x, y, &sx, &sy);
… …
456 436
457 /* Note it is intentional that we check ob - the movement type of the 437 /* Note it is intentional that we check ob - the movement type of the
458 * head of the object should correspond for the entire object. 438 * head of the object should correspond for the entire object.
459 */ 439 */
460 if (OB_TYPE_MOVE_BLOCK (ob, GET_MAP_MOVE_BLOCK (m1, sx, sy))) 440 if (OB_TYPE_MOVE_BLOCK (ob, GET_MAP_MOVE_BLOCK (m1, sx, sy)))
461 return AB_NO_PASS; 441 return P_NO_PASS;
462
463 } 442 }
443
464 return 0; 444 return 0;
465} 445}
466 446
467/* When the map is loaded, load_object does not actually insert objects 447/* 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 448 * 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 477 * 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. 478 * the more sections and not re-add sections for them.
499 */ 479 */
500 480
501static void 481static void
502link_multipart_objects (mapstruct *m) 482link_multipart_objects (maptile *m)
503{ 483{
504 int x, y; 484 int x, y;
505 object *tmp, *op, *last, *above; 485 object *tmp, *op, *last, *above;
506 archetype *at; 486 archetype *at;
507 487
508 for (x = 0; x < MAP_WIDTH (m); x++) 488 for (x = 0; x < MAP_WIDTH (m); x++)
509 for (y = 0; y < MAP_HEIGHT (m); y++) 489 for (y = 0; y < MAP_HEIGHT (m); y++)
510 for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = above) 490 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = above)
511 { 491 {
512 above = tmp->above; 492 above = tmp->above;
513 493
514 /* already multipart - don't do anything more */ 494 /* already multipart - don't do anything more */
515 if (tmp->head || tmp->more) 495 if (tmp->head || tmp->more)
… …
544 * Loads (ands parses) the objects into a given map from the specified 524 * Loads (ands parses) the objects into a given map from the specified
545 * file pointer. 525 * file pointer.
546 * mapflags is the same as we get with load_original_map 526 * mapflags is the same as we get with load_original_map
547 */ 527 */
548void 528void
549load_objects (mapstruct *m, object_thawer & fp, int mapflags) 529load_objects (maptile *m, object_thawer & fp, int mapflags)
550{ 530{
551 int i, j; 531 int i, j;
552 int unique; 532 int unique;
553 object *op, *prev = NULL, *last_more = NULL, *otmp; 533 object *op, *prev = NULL, *last_more = NULL, *otmp;
554 534
555 op = get_object (); 535 op = object::create ();
556 op->map = m; /* To handle buttons correctly */ 536 op->map = m; /* To handle buttons correctly */
557 537
558 while ((i = load_object (fp, op, mapflags))) 538 while ((i = load_object (fp, op, mapflags)))
559 { 539 {
560 /* if the archetype for the object is null, means that we 540 /* if the archetype for the object is null, means that we
… …
568 } 548 }
569 549
570 550
571 switch (i) 551 switch (i)
572 { 552 {
573 case LL_NORMAL: 553 case LL_NORMAL:
574 /* if we are loading an overlay, put the floors on the bottom */ 554 /* 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) 555 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); 556 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY | INS_MAP_LOAD);
577 else 557 else
578 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD); 558 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD);
579 559
580 if (op->inv) 560 if (op->inv)
581 sum_weight (op); 561 sum_weight (op);
582 562
583 prev = op, last_more = op; 563 prev = op, last_more = op;
584 break; 564 break;
585 565
586 case LL_MORE: 566 case LL_MORE:
587 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY); 567 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; 568 op->head = prev, last_more->more = op, last_more = op;
589 break; 569 break;
590 } 570 }
591 571
592 if (mapflags & MAP_STYLE) 572 if (mapflags & MAP_STYLE)
593 remove_from_active_list (op); 573 remove_from_active_list (op);
594 574
595 op = get_object (); 575 op = object::create ();
596 op->map = m; 576 op->map = m;
597 } 577 }
598 578
599 for (i = 0; i < m->width; i++) 579 for (i = 0; i < m->width; i++)
600 { 580 {
601 for (j = 0; j < m->height; j++) 581 for (j = 0; j < m->height; j++)
602 { 582 {
603 unique = 0; 583 unique = 0;
604 /* check for unique items, or unique squares */ 584 /* check for unique items, or unique squares */
605 for (otmp = get_map_ob (m, i, j); otmp; otmp = otmp->above) 585 for (otmp = GET_MAP_OB (m, i, j); otmp; otmp = otmp->above)
606 { 586 {
607 if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL)) 587 if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL))
608 unique = 1; 588 unique = 1;
589
609 if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique)) 590 if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique))
610 SET_FLAG (otmp, FLAG_OBJ_ORIGINAL); 591 SET_FLAG (otmp, FLAG_OBJ_ORIGINAL);
611 } 592 }
612 } 593 }
613 } 594 }
614 595
615 free_object (op); 596 op->destroy ();
616 link_multipart_objects (m); 597 link_multipart_objects (m);
617} 598}
618 599
619/* This saves all the objects on the map in a non destructive fashion. 600/* 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, 601 * 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 602 * and we only save the head of multi part objects - this is needed
622 * in order to do map tiling properly. 603 * in order to do map tiling properly.
623 */ 604 */
624void 605void
625save_objects (mapstruct *m, object_freezer & fp, object_freezer & fp2, int flag) 606save_objects (maptile *m, object_freezer & fp, object_freezer & fp2, int flag)
626{ 607{
627 int i, j = 0, unique = 0; 608 int i, j = 0, unique = 0;
628 object *op; 609 object *op;
629 610
630 /* first pass - save one-part objects */ 611 /* first pass - save one-part objects */
631 for (i = 0; i < MAP_WIDTH (m); i++) 612 for (i = 0; i < MAP_WIDTH (m); i++)
632 for (j = 0; j < MAP_HEIGHT (m); j++) 613 for (j = 0; j < MAP_HEIGHT (m); j++)
633 { 614 {
634 unique = 0; 615 unique = 0;
635 for (op = get_map_ob (m, i, j); op; op = op->above) 616 for (op = GET_MAP_OB (m, i, j); op; op = op->above)
636 { 617 {
637 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) 618 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
638 unique = 1; 619 unique = 1;
639 620
640 if (op->type == PLAYER) 621 if (op->type == PLAYER)
641 {
642 LOG (llevDebug, "Player on map that is being saved\n");
643 continue; 622 continue;
644 }
645 623
646 if (op->head || op->owner) 624 if (op->head || op->owner)
647 continue; 625 continue;
648 626
649 if (unique || QUERY_FLAG (op, FLAG_UNIQUE)) 627 if (unique || QUERY_FLAG (op, FLAG_UNIQUE))
650 save_object (fp2, op, 3); 628 save_object (fp2, op, 3);
651 else if (flag == 0 || (flag == 2 && (!QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) && !QUERY_FLAG (op, FLAG_UNPAID)))) 629 else if (flag == 0 || (flag == 2 && (!QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) && !QUERY_FLAG (op, FLAG_UNPAID))))
652 save_object (fp, op, 3); 630 save_object (fp, op, 3);
631 }
632 }
633}
653 634
654 } /* for this space */ 635maptile::maptile ()
655 } /* for this j */ 636{
637 in_memory = MAP_SWAPPED;
638 /* The maps used to pick up default x and y values from the
639 * map archetype. Mimic that behaviour.
640 */
641 MAP_WIDTH (this) = 16;
642 MAP_HEIGHT (this) = 16;
643 MAP_RESET_TIMEOUT (this) = 0;
644 MAP_TIMEOUT (this) = 300;
645 MAP_ENTER_X (this) = 0;
646 MAP_ENTER_Y (this) = 0;
647 /*set part to -1 indicating conversion to weather map not yet done */
648 MAP_WORLDPARTX (this) = -1;
649 MAP_WORLDPARTY (this) = -1;
656} 650}
657 651
658/* 652/*
659 * Allocates, initialises, and returns a pointer to a mapstruct. 653 * Allocates, initialises, and returns a pointer to a maptile.
660 * Modified to no longer take a path option which was not being 654 * Modified to no longer take a path option which was not being
661 * used anyways. MSW 2001-07-01 655 * used anyways. MSW 2001-07-01
662 */ 656 */
663 657maptile *
664mapstruct *
665get_linked_map (void) 658get_linked_map (void)
666{ 659{
667 mapstruct *map = new mapstruct; 660 maptile *mp, *map = new maptile;
668 mapstruct *mp;
669 661
670 for (mp = first_map; mp != NULL && mp->next != NULL; mp = mp->next); 662 for (mp = first_map; mp && mp->next; mp = mp->next);
663
671 if (mp == NULL) 664 if (mp == NULL)
672 first_map = map; 665 first_map = map;
673 else 666 else
674 mp->next = map; 667 mp->next = map;
675 668
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; 669 return map;
690} 670}
691 671
692/* 672/*
693 * Allocates the arrays contained in a mapstruct. 673 * Allocates the arrays contained in a maptile.
694 * This basically allocates the dynamic array of spaces for the 674 * This basically allocates the dynamic array of spaces for the
695 * map. 675 * map.
696 */ 676 */
697
698void 677void
699allocate_map (mapstruct *m) 678maptile::allocate ()
700{ 679{
701 m->in_memory = MAP_IN_MEMORY; 680 in_memory = MAP_IN_MEMORY;
681
702 /* Log this condition and free the storage. We could I suppose 682 /* Log this condition and free the storage. We could I suppose
703 * realloc, but if the caller is presuming the data will be intact, 683 * realloc, but if the caller is presuming the data will be intact,
704 * that is their poor assumption. 684 * that is their poor assumption.
705 */ 685 */
706 if (m->spaces) 686 if (spaces)
707 { 687 {
708 LOG (llevError, "allocate_map called with already allocated map (%s)\n", m->path); 688 LOG (llevError, "allocate_map called with already allocated map (%s)\n", path);
709 free (m->spaces); 689 free (spaces);
710 } 690 }
711 691
712 m->spaces = (MapSpace *) calloc (1, MAP_WIDTH (m) * MAP_HEIGHT (m) * sizeof (MapSpace)); 692 spaces = (mapspace *)
693 calloc (1, width * height * sizeof (mapspace));
713 694
714 if (m->spaces == NULL) 695 if (!spaces)
715 fatal (OUT_OF_MEMORY); 696 fatal (OUT_OF_MEMORY);
716} 697}
717 698
718/* Create and returns a map of the specific size. Used 699/* Create and returns a map of the specific size. Used
719 * in random map code and the editor. 700 * in random map code and the editor.
720 */ 701 */
721mapstruct * 702maptile *
722get_empty_map (int sizex, int sizey) 703get_empty_map (int sizex, int sizey)
723{ 704{
724 mapstruct *m = get_linked_map (); 705 maptile *m = get_linked_map ();
725 706
726 m->width = sizex; 707 m->width = sizex;
727 m->height = sizey; 708 m->height = sizey;
728 m->in_memory = MAP_SWAPPED; 709 m->in_memory = MAP_SWAPPED;
729 allocate_map (m); 710 m->allocate ();
711
730 return m; 712 return m;
731} 713}
732 714
733/* Takes a string from a map definition and outputs a pointer to the array of shopitems 715/* 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 716 * corresponding to that string. Memory is allocated for this, it must be freed
… …
742 char *shop_string, *p, *q, *next_semicolon, *next_colon; 724 char *shop_string, *p, *q, *next_semicolon, *next_colon;
743 shopitems *items = NULL; 725 shopitems *items = NULL;
744 int i = 0, number_of_entries = 0; 726 int i = 0, number_of_entries = 0;
745 const typedata *current_type; 727 const typedata *current_type;
746 728
747 shop_string = strdup_local (input_string); 729 shop_string = strdup (input_string);
748 p = shop_string; 730 p = shop_string;
749 /* first we'll count the entries, we'll need that for allocating the array shortly */ 731 /* first we'll count the entries, we'll need that for allocating the array shortly */
750 while (p) 732 while (p)
751 { 733 {
752 p = strchr (p, ';'); 734 p = strchr (p, ';');
… …
811} 793}
812 794
813/* opposite of parse string, this puts the string that was originally fed in to 795/* opposite of parse string, this puts the string that was originally fed in to
814 * the map (or something equivilent) into output_string. */ 796 * the map (or something equivilent) into output_string. */
815static void 797static void
816print_shop_string (mapstruct *m, char *output_string) 798print_shop_string (maptile *m, char *output_string)
817{ 799{
818 int i; 800 int i;
819 char tmp[MAX_BUF]; 801 char tmp[MAX_BUF];
820 802
821 strcpy (output_string, ""); 803 strcpy (output_string, "");
… …
855 * MSW 2001-07-01 837 * MSW 2001-07-01
856 * return 0 on success, 1 on failure. 838 * return 0 on success, 1 on failure.
857 */ 839 */
858 840
859static int 841static int
860load_map_header (object_thawer & fp, mapstruct *m) 842load_map_header (object_thawer & fp, maptile *m)
861{ 843{
862 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end; 844 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end;
863 int msgpos = 0; 845 int msgpos = 0;
864 int maplorepos = 0; 846 int maplorepos = 0;
865 847
866 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 848 while (fgets (buf, HUGE_BUF, fp) != NULL)
867 { 849 {
868 buf[HUGE_BUF - 1] = 0; 850 buf[HUGE_BUF - 1] = 0;
869 key = buf; 851 key = buf;
852
870 while (isspace (*key)) 853 while (isspace (*key))
871 key++; 854 key++;
855
872 if (*key == 0) 856 if (*key == 0)
873 continue; /* empty line */ 857 continue; /* empty line */
858
874 value = strchr (key, ' '); 859 value = strchr (key, ' ');
860
875 if (!value) 861 if (!value)
876 { 862 {
877 end = strchr (key, '\n'); 863 if ((end = strchr (key, '\n')))
878 if (end != NULL)
879 {
880 *end = 0; 864 *end = 0;
881 }
882 } 865 }
883 else 866 else
884 { 867 {
885 *value = 0; 868 *value = 0;
886 value++; 869 value++;
887 end = strchr (value, '\n'); 870 end = strchr (value, '\n');
871
888 while (isspace (*value)) 872 while (isspace (*value))
889 { 873 {
890 value++; 874 value++;
875
891 if (*value == '\0' || value == end) 876 if (*value == '\0' || value == end)
892 { 877 {
893 /* Nothing but spaces. */ 878 /* Nothing but spaces. */
894 value = NULL; 879 value = NULL;
895 break; 880 break;
… …
918 * that use the parameter. 903 * that use the parameter.
919 */ 904 */
920 905
921 if (!strcmp (key, "msg")) 906 if (!strcmp (key, "msg"))
922 { 907 {
923 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 908 while (fgets (buf, HUGE_BUF, fp) != NULL)
924 { 909 {
925 if (!strcmp (buf, "endmsg\n")) 910 if (!strcmp (buf, "endmsg\n"))
926 break; 911 break;
927 else 912 else
928 { 913 {
… …
935 * with nothing between). There is no reason in those cases to 920 * with nothing between). There is no reason in those cases to
936 * keep the empty message. Also, msgbuf contains garbage data 921 * keep the empty message. Also, msgbuf contains garbage data
937 * when msgpos is zero, so copying it results in crashes 922 * when msgpos is zero, so copying it results in crashes
938 */ 923 */
939 if (msgpos != 0) 924 if (msgpos != 0)
940 m->msg = strdup_local (msgbuf); 925 m->msg = strdup (msgbuf);
941 } 926 }
942 else if (!strcmp (key, "maplore")) 927 else if (!strcmp (key, "maplore"))
943 { 928 {
944 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 929 while (fgets (buf, HUGE_BUF, fp) != NULL)
945 { 930 {
946 if (!strcmp (buf, "endmaplore\n")) 931 if (!strcmp (buf, "endmaplore\n"))
947 break; 932 break;
948 else 933 else
949 { 934 {
… …
951 strcpy (maplorebuf + maplorepos, buf); 936 strcpy (maplorebuf + maplorepos, buf);
952 maplorepos += strlen (buf); 937 maplorepos += strlen (buf);
953 } 938 }
954 } 939 }
955 if (maplorepos != 0) 940 if (maplorepos != 0)
956 m->maplore = strdup_local (maplorebuf); 941 m->maplore = strdup (maplorebuf);
957 } 942 }
958 else if (!strcmp (key, "end")) 943 else if (!strcmp (key, "end"))
959 { 944 {
960 break; 945 break;
961 } 946 }
… …
970 LOG (llevError, "loading map and got a non 'arch map' line(%s %s)?\n", key, value); 955 LOG (llevError, "loading map and got a non 'arch map' line(%s %s)?\n", key, value);
971 } 956 }
972 else if (!strcmp (key, "name")) 957 else if (!strcmp (key, "name"))
973 { 958 {
974 *end = 0; 959 *end = 0;
975 m->name = strdup_local (value); 960 m->name = strdup (value);
976 } 961 }
977 /* first strcmp value on these are old names supported 962 /* first strcmp value on these are old names supported
978 * for compatibility reasons. The new values (second) are 963 * for compatibility reasons. The new values (second) are
979 * what really should be used. 964 * what really should be used.
980 */ 965 */
981 else if (!strcmp (key, "oid")) 966 else if (!strcmp (key, "oid"))
982 {
983 fp.get (m, atoi (value)); 967 fp.get (m, atoi (value));
984 }
985 else if (!strcmp (key, "attach")) 968 else if (!strcmp (key, "attach"))
986 {
987 m->attach = value; 969 m->attach = value;
988 }
989 else if (!strcmp (key, "hp") || !strcmp (key, "enter_x")) 970 else if (!strcmp (key, "hp") || !strcmp (key, "enter_x"))
990 {
991 m->enter_x = atoi (value); 971 m->enter_x = atoi (value);
992 }
993 else if (!strcmp (key, "sp") || !strcmp (key, "enter_y")) 972 else if (!strcmp (key, "sp") || !strcmp (key, "enter_y"))
994 {
995 m->enter_y = atoi (value); 973 m->enter_y = atoi (value);
996 }
997 else if (!strcmp (key, "x") || !strcmp (key, "width")) 974 else if (!strcmp (key, "x") || !strcmp (key, "width"))
998 {
999 m->width = atoi (value); 975 m->width = atoi (value);
1000 }
1001 else if (!strcmp (key, "y") || !strcmp (key, "height")) 976 else if (!strcmp (key, "y") || !strcmp (key, "height"))
1002 {
1003 m->height = atoi (value); 977 m->height = atoi (value);
1004 }
1005 else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout")) 978 else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout"))
1006 {
1007 m->reset_timeout = atoi (value); 979 m->reset_timeout = atoi (value);
1008 }
1009 else if (!strcmp (key, "value") || !strcmp (key, "swap_time")) 980 else if (!strcmp (key, "value") || !strcmp (key, "swap_time"))
1010 {
1011 m->timeout = atoi (value); 981 m->timeout = atoi (value);
1012 }
1013 else if (!strcmp (key, "level") || !strcmp (key, "difficulty")) 982 else if (!strcmp (key, "level") || !strcmp (key, "difficulty"))
1014 { 983 m->difficulty = clamp (atoi (value), 1, settings.max_level);
1015 m->difficulty = atoi (value);
1016 }
1017 else if (!strcmp (key, "invisible") || !strcmp (key, "darkness")) 984 else if (!strcmp (key, "invisible") || !strcmp (key, "darkness"))
1018 {
1019 m->darkness = atoi (value); 985 m->darkness = atoi (value);
1020 }
1021 else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime")) 986 else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime"))
1022 {
1023 m->fixed_resettime = atoi (value); 987 m->fixed_resettime = atoi (value);
1024 }
1025 else if (!strcmp (key, "unique")) 988 else if (!strcmp (key, "unique"))
1026 {
1027 m->unique = atoi (value); 989 m->unique = atoi (value);
1028 }
1029 else if (!strcmp (key, "template")) 990 else if (!strcmp (key, "template"))
1030 {
1031 m->templatemap = atoi (value); 991 m->templatemap = atoi (value);
1032 }
1033 else if (!strcmp (key, "region")) 992 else if (!strcmp (key, "region"))
1034 {
1035 m->region = get_region_by_name (value); 993 m->region = get_region_by_name (value);
1036 }
1037 else if (!strcmp (key, "shopitems")) 994 else if (!strcmp (key, "shopitems"))
1038 { 995 {
1039 *end = 0; 996 *end = 0;
1040 m->shopitems = parse_shop_string (value); 997 m->shopitems = parse_shop_string (value);
1041 } 998 }
1042 else if (!strcmp (key, "shopgreed")) 999 else if (!strcmp (key, "shopgreed"))
1043 {
1044 m->shopgreed = atof (value); 1000 m->shopgreed = atof (value);
1045 }
1046 else if (!strcmp (key, "shopmin")) 1001 else if (!strcmp (key, "shopmin"))
1047 {
1048 m->shopmin = atol (value); 1002 m->shopmin = atol (value);
1049 }
1050 else if (!strcmp (key, "shopmax")) 1003 else if (!strcmp (key, "shopmax"))
1051 {
1052 m->shopmax = atol (value); 1004 m->shopmax = atol (value);
1053 }
1054 else if (!strcmp (key, "shoprace")) 1005 else if (!strcmp (key, "shoprace"))
1055 { 1006 {
1056 *end = 0; 1007 *end = 0;
1057 m->shoprace = strdup_local (value); 1008 m->shoprace = strdup (value);
1058 } 1009 }
1059 else if (!strcmp (key, "outdoor")) 1010 else if (!strcmp (key, "outdoor"))
1060 {
1061 m->outdoor = atoi (value); 1011 m->outdoor = atoi (value);
1062 }
1063 else if (!strcmp (key, "temp")) 1012 else if (!strcmp (key, "temp"))
1064 {
1065 m->temp = atoi (value); 1013 m->temp = atoi (value);
1066 }
1067 else if (!strcmp (key, "pressure")) 1014 else if (!strcmp (key, "pressure"))
1068 {
1069 m->pressure = atoi (value); 1015 m->pressure = atoi (value);
1070 }
1071 else if (!strcmp (key, "humid")) 1016 else if (!strcmp (key, "humid"))
1072 {
1073 m->humid = atoi (value); 1017 m->humid = atoi (value);
1074 }
1075 else if (!strcmp (key, "windspeed")) 1018 else if (!strcmp (key, "windspeed"))
1076 {
1077 m->windspeed = atoi (value); 1019 m->windspeed = atoi (value);
1078 }
1079 else if (!strcmp (key, "winddir")) 1020 else if (!strcmp (key, "winddir"))
1080 {
1081 m->winddir = atoi (value); 1021 m->winddir = atoi (value);
1082 }
1083 else if (!strcmp (key, "sky")) 1022 else if (!strcmp (key, "sky"))
1084 {
1085 m->sky = atoi (value); 1023 m->sky = atoi (value);
1086 }
1087 else if (!strcmp (key, "nosmooth")) 1024 else if (!strcmp (key, "nosmooth"))
1088 {
1089 m->nosmooth = atoi (value); 1025 m->nosmooth = atoi (value);
1090 }
1091 else if (!strncmp (key, "tile_path_", 10)) 1026 else if (!strncmp (key, "tile_path_", 10))
1092 { 1027 {
1093 int tile = atoi (key + 10); 1028 int tile = atoi (key + 10);
1094 1029
1095 if (tile < 1 || tile > 4) 1030 if (tile < 1 || tile > 4)
… …
1128 } 1063 }
1129 1064
1130 if (editor) 1065 if (editor)
1131 { 1066 {
1132 /* Use the value as in the file. */ 1067 /* Use the value as in the file. */
1133 m->tile_path[tile - 1] = strdup_local (value); 1068 m->tile_path[tile - 1] = strdup (value);
1134 } 1069 }
1135 else if (path != NULL) 1070 else if (path != NULL)
1136 { 1071 {
1137 /* Use the normalized value. */ 1072 /* Use the normalized value. */
1138 m->tile_path[tile - 1] = strdup_local (path); 1073 m->tile_path[tile - 1] = strdup (path);
1139 } 1074 }
1140 } /* end if tile direction (in)valid */ 1075 } /* end if tile direction (in)valid */
1141 } 1076 }
1142 else 1077 else
1143 {
1144 LOG (llevError, "Got unknown value in map header: %s %s\n", key, value); 1078 LOG (llevError, "Got unknown value in map header: %s %s\n", key, value);
1145 }
1146 } 1079 }
1080
1147 if (!key || strcmp (key, "end")) 1081 if (!key || strcmp (key, "end"))
1148 { 1082 {
1149 LOG (llevError, "Got premature eof on map header!\n"); 1083 LOG (llevError, "Got premature eof on map header!\n");
1150 return 1; 1084 return 1;
1151 } 1085 }
1086
1152 return 0; 1087 return 0;
1153} 1088}
1154 1089
1155/* 1090/*
1156 * Opens the file "filename" and reads information about the map 1091 * Opens the file "filename" and reads information about the map
1157 * from the given file, and stores it in a newly allocated 1092 * from the given file, and stores it in a newly allocated
1158 * mapstruct. A pointer to this structure is returned, or NULL on failure. 1093 * maptile. A pointer to this structure is returned, or NULL on failure.
1159 * flags correspond to those in map.h. Main ones used are 1094 * 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 1095 * 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 1096 * 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. 1097 * 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 1098 * MAP_STYLE: style map - don't add active objects, don't add to server
1164 * managed map list. 1099 * managed map list.
1165 */ 1100 */
1166 1101
1167mapstruct * 1102maptile *
1168load_original_map (const char *filename, int flags) 1103load_original_map (const char *filename, int flags)
1169{ 1104{
1170 mapstruct *m; 1105 maptile *m;
1171 char pathname[MAX_BUF]; 1106 char pathname[MAX_BUF];
1172 1107
1173 if (flags & MAP_PLAYER_UNIQUE) 1108 if (flags & MAP_PLAYER_UNIQUE)
1174 strcpy (pathname, filename); 1109 strcpy (pathname, filename);
1175 else if (flags & MAP_OVERLAY) 1110 else if (flags & MAP_OVERLAY)
… …
1192 LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags); 1127 LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags);
1193 delete_map (m); 1128 delete_map (m);
1194 return NULL; 1129 return NULL;
1195 } 1130 }
1196 1131
1197 allocate_map (m); 1132 m->allocate ();
1198 1133
1199 m->in_memory = MAP_LOADING; 1134 m->in_memory = MAP_LOADING;
1200 load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE)); 1135 load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE));
1201 1136
1202 m->in_memory = MAP_IN_MEMORY; 1137 m->in_memory = MAP_IN_MEMORY;
… …
1211 * Loads a map, which has been loaded earlier, from file. 1146 * Loads a map, which has been loaded earlier, from file.
1212 * Return the map object we load into (this can change from the passed 1147 * Return the map object we load into (this can change from the passed
1213 * option if we can't find the original map) 1148 * option if we can't find the original map)
1214 */ 1149 */
1215 1150
1216static mapstruct * 1151static maptile *
1217load_temporary_map (mapstruct *m) 1152load_temporary_map (maptile *m)
1218{ 1153{
1219 char buf[MAX_BUF]; 1154 char buf[MAX_BUF];
1220 1155
1221 if (!m->tmpname) 1156 if (!m->tmpname)
1222 { 1157 {
… …
1248 LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname); 1183 LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname);
1249 delete_map (m); 1184 delete_map (m);
1250 m = load_original_map (m->path, 0); 1185 m = load_original_map (m->path, 0);
1251 return NULL; 1186 return NULL;
1252 } 1187 }
1188
1253 allocate_map (m); 1189 m->allocate ();
1254 1190
1255 m->in_memory = MAP_LOADING; 1191 m->in_memory = MAP_LOADING;
1256 load_objects (m, thawer, 0); 1192 load_objects (m, thawer, 0);
1257 1193
1258 m->in_memory = MAP_IN_MEMORY; 1194 m->in_memory = MAP_IN_MEMORY;
… …
1264 * Loads a map, which has been loaded earlier, from file. 1200 * Loads a map, which has been loaded earlier, from file.
1265 * Return the map object we load into (this can change from the passed 1201 * Return the map object we load into (this can change from the passed
1266 * option if we can't find the original map) 1202 * option if we can't find the original map)
1267 */ 1203 */
1268 1204
1269mapstruct * 1205maptile *
1270load_overlay_map (const char *filename, mapstruct *m) 1206load_overlay_map (const char *filename, maptile *m)
1271{ 1207{
1272 char pathname[MAX_BUF]; 1208 char pathname[MAX_BUF];
1273 1209
1274 strcpy (pathname, create_overlay_pathname (filename)); 1210 strcpy (pathname, create_overlay_pathname (filename));
1275 1211
… …
1283 LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname); 1219 LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname);
1284 delete_map (m); 1220 delete_map (m);
1285 m = load_original_map (m->path, 0); 1221 m = load_original_map (m->path, 0);
1286 return NULL; 1222 return NULL;
1287 } 1223 }
1288 /*allocate_map(m); */ 1224 /*m->allocate ();*/
1289 1225
1290 m->in_memory = MAP_LOADING; 1226 m->in_memory = MAP_LOADING;
1291 load_objects (m, thawer, MAP_OVERLAY); 1227 load_objects (m, thawer, MAP_OVERLAY);
1292 1228
1293 m->in_memory = MAP_IN_MEMORY; 1229 m->in_memory = MAP_IN_MEMORY;
… …
1298 * This is the start of unique map handling code 1234 * This is the start of unique map handling code
1299 *****************************************************************************/ 1235 *****************************************************************************/
1300 1236
1301/* This goes through map 'm' and removed any unique items on the map. */ 1237/* This goes through map 'm' and removed any unique items on the map. */
1302static void 1238static void
1303delete_unique_items (mapstruct *m) 1239delete_unique_items (maptile *m)
1304{ 1240{
1305 int i, j, unique; 1241 int i, j, unique;
1306 object *op, *next; 1242 object *op, *next;
1307 1243
1308 for (i = 0; i < MAP_WIDTH (m); i++) 1244 for (i = 0; i < MAP_WIDTH (m); i++)
1309 for (j = 0; j < MAP_HEIGHT (m); j++) 1245 for (j = 0; j < MAP_HEIGHT (m); j++)
1310 { 1246 {
1311 unique = 0; 1247 unique = 0;
1248
1312 for (op = get_map_ob (m, i, j); op; op = next) 1249 for (op = GET_MAP_OB (m, i, j); op; op = next)
1313 { 1250 {
1314 next = op->above; 1251 next = op->above;
1252
1315 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) 1253 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
1316 unique = 1; 1254 unique = 1;
1255
1317 if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique)) 1256 if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique))
1318 { 1257 {
1319 clean_object (op); 1258 clean_object (op);
1259
1320 if (QUERY_FLAG (op, FLAG_IS_LINKED)) 1260 if (QUERY_FLAG (op, FLAG_IS_LINKED))
1321 remove_button_link (op); 1261 remove_button_link (op);
1322 remove_ob (op); 1262
1323 free_object (op); 1263 op->destroy ();
1324 } 1264 }
1325 } 1265 }
1326 } 1266 }
1327} 1267}
1328 1268
… …
1330/* 1270/*
1331 * Loads unique objects from file(s) into the map which is in memory 1271 * Loads unique objects from file(s) into the map which is in memory
1332 * m is the map to load unique items into. 1272 * m is the map to load unique items into.
1333 */ 1273 */
1334static void 1274static void
1335load_unique_objects (mapstruct *m) 1275load_unique_objects (maptile *m)
1336{ 1276{
1337 int count; 1277 int count;
1338 char firstname[MAX_BUF]; 1278 char firstname[MAX_BUF];
1339 1279
1340 for (count = 0; count < 10; count++) 1280 for (count = 0; count < 10; count++)
… …
1363 1303
1364/* 1304/*
1365 * Saves a map to file. If flag is set, it is saved into the same 1305 * 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 1306 * file it was (originally) loaded from. Otherwise a temporary
1367 * filename will be genarated, and the file will be stored there. 1307 * filename will be genarated, and the file will be stored there.
1368 * The temporary filename will be stored in the mapstructure. 1308 * The temporary filename will be stored in the maptileure.
1369 * If the map is unique, we also save to the filename in the map 1309 * If the map is unique, we also save to the filename in the map
1370 * (this should have been updated when first loaded) 1310 * (this should have been updated when first loaded)
1371 */ 1311 */
1372 1312
1373int 1313int
1374new_save_map (mapstruct *m, int flag) 1314new_save_map (maptile *m, int flag)
1375{ 1315{
1376 char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF]; 1316 char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF];
1377 int i; 1317 int i;
1378 1318
1379 if (flag && !*m->path) 1319 if (flag && !*m->path)
… …
1397 make_path_to_file (filename); 1337 make_path_to_file (filename);
1398 } 1338 }
1399 else 1339 else
1400 { 1340 {
1401 if (!m->tmpname) 1341 if (!m->tmpname)
1402 m->tmpname = tempnam_local (settings.tmpdir, NULL); 1342 m->tmpname = tempnam (settings.tmpdir, NULL);
1403 1343
1404 strcpy (filename, m->tmpname); 1344 strcpy (filename, m->tmpname);
1405 } 1345 }
1406 1346
1407 LOG (llevDebug, "Saving map %s to %s\n", m->path, filename); 1347 LOG (llevDebug, "Saving map %s to %s\n", m->path, filename);
… …
1431 print_shop_string (m, shop); 1371 print_shop_string (m, shop);
1432 fprintf (freezer, "shopitems %s\n", shop); 1372 fprintf (freezer, "shopitems %s\n", shop);
1433 } 1373 }
1434 if (m->shopgreed) 1374 if (m->shopgreed)
1435 fprintf (freezer, "shopgreed %f\n", m->shopgreed); 1375 fprintf (freezer, "shopgreed %f\n", m->shopgreed);
1436#ifndef WIN32
1437 if (m->shopmin) 1376 if (m->shopmin)
1438 fprintf (freezer, "shopmin %llu\n", m->shopmin); 1377 fprintf (freezer, "shopmin %llu\n", m->shopmin);
1439 if (m->shopmax) 1378 if (m->shopmax)
1440 fprintf (freezer, "shopmax %llu\n", m->shopmax); 1379 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) 1380 if (m->shoprace)
1448 fprintf (freezer, "shoprace %s\n", m->shoprace); 1381 fprintf (freezer, "shoprace %s\n", m->shoprace);
1449 if (m->darkness) 1382 if (m->darkness)
1450 fprintf (freezer, "darkness %d\n", m->darkness); 1383 fprintf (freezer, "darkness %d\n", m->darkness);
1451 if (m->width) 1384 if (m->width)
… …
1530 object *tmp, *next; 1463 object *tmp, *next;
1531 1464
1532 for (tmp = op->inv; tmp; tmp = next) 1465 for (tmp = op->inv; tmp; tmp = next)
1533 { 1466 {
1534 next = tmp->below; 1467 next = tmp->below;
1468
1535 clean_object (tmp); 1469 clean_object (tmp);
1536 if (QUERY_FLAG (tmp, FLAG_IS_LINKED)) 1470 if (QUERY_FLAG (tmp, FLAG_IS_LINKED))
1537 remove_button_link (tmp); 1471 remove_button_link (tmp);
1538 remove_ob (tmp); 1472
1539 free_object (tmp); 1473 tmp->destroy ();
1540 } 1474 }
1541} 1475}
1542 1476
1543/* 1477/*
1544 * Remove and free all objects in the given map. 1478 * Remove and free all objects in the given map.
1545 */ 1479 */
1546 1480
1547void 1481void
1548free_all_objects (mapstruct *m) 1482free_all_objects (maptile *m)
1549{ 1483{
1550 int i, j; 1484 int i, j;
1551 object *op; 1485 object *op;
1552 1486
1553 for (i = 0; i < MAP_WIDTH (m); i++) 1487 for (i = 0; i < MAP_WIDTH (m); i++)
… …
1560 if (op == previous_obj) 1494 if (op == previous_obj)
1561 { 1495 {
1562 LOG (llevDebug, "free_all_objects: Link error, bailing out.\n"); 1496 LOG (llevDebug, "free_all_objects: Link error, bailing out.\n");
1563 break; 1497 break;
1564 } 1498 }
1499
1565 previous_obj = op; 1500 previous_obj = op;
1501
1566 if (op->head != NULL) 1502 if (op->head != NULL)
1567 op = op->head; 1503 op = op->head;
1568 1504
1569 /* If the map isn't in memory, free_object will remove and 1505 /* 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. 1506 * free objects in op's inventory. So let it do the job.
1571 */ 1507 */
1572 if (m->in_memory == MAP_IN_MEMORY) 1508 if (m->in_memory == MAP_IN_MEMORY)
1573 clean_object (op); 1509 clean_object (op);
1574 remove_ob (op); 1510
1575 free_object (op); 1511 op->destroy ();
1576 } 1512 }
1577 } 1513 }
1578} 1514}
1579 1515
1580/* 1516/*
1581 * Frees everything allocated by the given mapstructure. 1517 * Frees everything allocated by the given maptileure.
1582 * don't free tmpname - our caller is left to do that 1518 * don't free tmpname - our caller is left to do that
1583 */ 1519 */
1584 1520
1585void 1521void
1586free_map (mapstruct *m, int flag) 1522free_map (maptile *m, int flag)
1587{ 1523{
1588 int i; 1524 int i;
1589 1525
1590 if (!m->in_memory) 1526 if (!m->in_memory)
1591 { 1527 {
1592 LOG (llevError, "Trying to free freed map.\n"); 1528 LOG (llevError, "Trying to free freed map.\n");
1593 return; 1529 return;
1594 } 1530 }
1531
1532 // TODO: use new/delete
1533#define FREE_AND_CLEAR(p) { free (p); p = NULL; }
1534
1595 if (flag && m->spaces) 1535 if (flag && m->spaces)
1596 free_all_objects (m); 1536 free_all_objects (m);
1597 if (m->name) 1537 if (m->name)
1598 FREE_AND_CLEAR (m->name); 1538 FREE_AND_CLEAR (m->name);
1599 if (m->spaces) 1539 if (m->spaces)
1600 FREE_AND_CLEAR (m->spaces); 1540 FREE_AND_CLEAR (m->spaces);
1601 if (m->msg) 1541 if (m->msg)
1602 FREE_AND_CLEAR (m->msg); 1542 FREE_AND_CLEAR (m->msg);
1603 if (m->maplore) 1543 if (m->maplore)
1604 FREE_AND_CLEAR (m->maplore); 1544 FREE_AND_CLEAR (m->maplore);
1605 if (m->shopitems) 1545
1606 delete[]m->shopitems; 1546 delete [] m->shopitems;
1607 m->shopitems = 0; 1547 m->shopitems = 0;
1548
1608 if (m->shoprace) 1549 if (m->shoprace)
1609 FREE_AND_CLEAR (m->shoprace); 1550 FREE_AND_CLEAR (m->shoprace);
1551
1610 if (m->buttons) 1552 if (m->buttons)
1611 free_objectlinkpt (m->buttons); 1553 free_objectlinkpt (m->buttons);
1554
1612 m->buttons = NULL; 1555 m->buttons = NULL;
1556
1613 for (i = 0; i < 4; i++) 1557 for (i = 0; i < 4; i++)
1614 { 1558 {
1615 if (m->tile_path[i]) 1559 if (m->tile_path[i])
1616 FREE_AND_CLEAR (m->tile_path[i]); 1560 FREE_AND_CLEAR (m->tile_path[i]);
1617 m->tile_map[i] = NULL; 1561 m->tile_map[i] = NULL;
1618 } 1562 }
1563
1619 m->in_memory = MAP_SWAPPED; 1564 m->in_memory = MAP_SWAPPED;
1565
1566#undef FREE_AND_CLEAR
1567
1620} 1568}
1621 1569
1622/* 1570/*
1623 * function: vanish mapstruct 1571 * function: vanish maptile
1624 * m : pointer to mapstruct, if NULL no action 1572 * m : pointer to maptile, if NULL no action
1625 * this deletes all the data on the map (freeing pointers) 1573 * this deletes all the data on the map (freeing pointers)
1626 * and then removes this map from the global linked list of maps. 1574 * and then removes this map from the global linked list of maps.
1627 */ 1575 */
1628 1576
1629void 1577void
1630delete_map (mapstruct *m) 1578delete_map (maptile *m)
1631{ 1579{
1632 mapstruct *tmp, *last; 1580 maptile *tmp, *last;
1633 int i; 1581 int i;
1634 1582
1635 if (!m) 1583 if (!m)
1636 return; 1584 return;
1637 1585
… …
1684 else 1632 else
1685 last->next = m->next; 1633 last->next = m->next;
1686 1634
1687 delete m; 1635 delete m;
1688} 1636}
1689
1690
1691 1637
1692/* 1638/*
1693 * Makes sure the given map is loaded and swapped in. 1639 * Makes sure the given map is loaded and swapped in.
1694 * name is path name of the map. 1640 * name is path name of the map.
1695 * flags meaning: 1641 * flags meaning:
… …
1698 * 0x2 (MAP_PLAYER_UNIQUE) - this is a unique map for each player. 1644 * 0x2 (MAP_PLAYER_UNIQUE) - this is a unique map for each player.
1699 * dont do any more name translation on it. 1645 * dont do any more name translation on it.
1700 * 1646 *
1701 * Returns a pointer to the given map. 1647 * Returns a pointer to the given map.
1702 */ 1648 */
1703 1649maptile *
1704mapstruct *
1705ready_map_name (const char *name, int flags) 1650ready_map_name (const char *name, int flags)
1706{ 1651{
1707 mapstruct *m; 1652 maptile *m;
1708 1653
1709 if (!name) 1654 if (!name)
1710 return (NULL); 1655 return (NULL);
1711 1656
1712 /* Have we been at this level before? */ 1657 /* Have we been at this level before? */
… …
1814 * have a difficulty set than using this function - human calculation 1759 * have a difficulty set than using this function - human calculation
1815 * is much better than this functions guesswork. 1760 * is much better than this functions guesswork.
1816 */ 1761 */
1817 1762
1818int 1763int
1819calculate_difficulty (mapstruct *m) 1764calculate_difficulty (maptile *m)
1820{ 1765{
1821 object *op; 1766 object *op;
1822 archetype *at; 1767 archetype *at;
1823 int x, y, i; 1768 int x, y, i;
1824 long monster_cnt = 0; 1769 long monster_cnt = 0;
… …
1831 return MAP_DIFFICULTY (m); 1776 return MAP_DIFFICULTY (m);
1832 } 1777 }
1833 1778
1834 for (x = 0; x < MAP_WIDTH (m); x++) 1779 for (x = 0; x < MAP_WIDTH (m); x++)
1835 for (y = 0; y < MAP_HEIGHT (m); y++) 1780 for (y = 0; y < MAP_HEIGHT (m); y++)
1836 for (op = get_map_ob (m, x, y); op != NULL; op = op->above) 1781 for (op = GET_MAP_OB (m, x, y); op != NULL; op = op->above)
1837 { 1782 {
1838 if (QUERY_FLAG (op, FLAG_MONSTER)) 1783 if (QUERY_FLAG (op, FLAG_MONSTER))
1839 { 1784 {
1840 total_exp += op->stats.exp; 1785 total_exp += op->stats.exp;
1841 monster_cnt++; 1786 monster_cnt++;
… …
1866 1811
1867 return 1; 1812 return 1;
1868} 1813}
1869 1814
1870void 1815void
1871clean_tmp_map (mapstruct *m) 1816clean_tmp_map (maptile *m)
1872{ 1817{
1873 if (m->tmpname == NULL) 1818 if (m->tmpname == NULL)
1874 return; 1819 return;
1875 INVOKE_MAP (CLEAN, m); 1820 INVOKE_MAP (CLEAN, m);
1876 (void) unlink (m->tmpname); 1821 (void) unlink (m->tmpname);
… …
1901 * to maps than los. 1846 * to maps than los.
1902 * postive values make it darker, negative make it brighter 1847 * postive values make it darker, negative make it brighter
1903 */ 1848 */
1904 1849
1905int 1850int
1906change_map_light (mapstruct *m, int change) 1851change_map_light (maptile *m, int change)
1907{ 1852{
1908 int new_level = m->darkness + change; 1853 int new_level = m->darkness + change;
1909 1854
1910 /* Nothing to do */ 1855 /* Nothing to do */
1911 if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS)) 1856 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 */ 1879 /* All clients need to get re-updated for the change */
1935 update_all_map_los (m); 1880 update_all_map_los (m);
1936 return 1; 1881 return 1;
1937} 1882}
1938 1883
1939
1940/* 1884/*
1941 * This function updates various attributes about a specific space 1885 * This function updates various attributes about a specific space
1942 * on the map (what it looks like, whether it blocks magic, 1886 * on the map (what it looks like, whether it blocks magic,
1943 * has a living creatures, prevents people from passing 1887 * has a living creatures, prevents people from passing
1944 * through, etc) 1888 * through, etc)
1945 */ 1889 */
1946void 1890void
1947update_position (mapstruct *m, int x, int y) 1891update_position (maptile *m, int x, int y)
1948{ 1892{
1949 object *tmp, *last = NULL; 1893 object *tmp, *last = 0;
1950 uint8 flags = 0, oldflags, light = 0, anywhere = 0; 1894 uint8 flags = 0, oldflags, light = 0, anywhere = 0;
1951 New_Face *top, *floor, *middle; 1895 New_Face *top, *floor, *middle;
1952 object *top_obj, *floor_obj, *middle_obj; 1896 object *top_obj, *floor_obj, *middle_obj;
1953 MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0; 1897 MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;
1954 1898
… …
1958 LOG (llevDebug, "update_position called with P_NEED_UPDATE not set: %s (%d, %d)\n", m->path, x, y); 1902 LOG (llevDebug, "update_position called with P_NEED_UPDATE not set: %s (%d, %d)\n", m->path, x, y);
1959 return; 1903 return;
1960 } 1904 }
1961 1905
1962 middle = blank_face; 1906 middle = blank_face;
1963 top = blank_face; 1907 top = blank_face;
1964 floor = blank_face; 1908 floor = blank_face;
1965 1909
1966 middle_obj = NULL; 1910 middle_obj = 0;
1967 top_obj = NULL; 1911 top_obj = 0;
1968 floor_obj = NULL; 1912 floor_obj = 0;
1969 1913
1970 for (tmp = get_map_ob (m, x, y); tmp; last = tmp, tmp = tmp->above) 1914 for (tmp = GET_MAP_OB (m, x, y); tmp; last = tmp, tmp = tmp->above)
1971 { 1915 {
1972
1973 /* This could be made additive I guess (two lights better than 1916 /* This could be made additive I guess (two lights better than
1974 * one). But if so, it shouldn't be a simple additive - 2 1917 * one). But if so, it shouldn't be a simple additive - 2
1975 * light bulbs do not illuminate twice as far as once since 1918 * light bulbs do not illuminate twice as far as once since
1976 * it is a disapation factor that is squared (or is it cubed?) 1919 * it is a dissapation factor that is cubed.
1977 */ 1920 */
1978 if (tmp->glow_radius > light) 1921 if (tmp->glow_radius > light)
1979 light = tmp->glow_radius; 1922 light = tmp->glow_radius;
1980 1923
1981 /* This call is needed in order to update objects the player 1924 /* This call is needed in order to update objects the player
… …
2019 { 1962 {
2020 middle = tmp->face; 1963 middle = tmp->face;
2021 middle_obj = tmp; 1964 middle_obj = tmp;
2022 } 1965 }
2023 } 1966 }
1967
2024 if (tmp == tmp->above) 1968 if (tmp == tmp->above)
2025 { 1969 {
2026 LOG (llevError, "Error in structure of map\n"); 1970 LOG (llevError, "Error in structure of map\n");
2027 exit (-1); 1971 exit (-1);
2028 } 1972 }
2029 1973
2030 move_slow |= tmp->move_slow; 1974 move_slow |= tmp->move_slow;
2031 move_block |= tmp->move_block; 1975 move_block |= tmp->move_block;
2032 move_on |= tmp->move_on; 1976 move_on |= tmp->move_on;
2033 move_off |= tmp->move_off; 1977 move_off |= tmp->move_off;
2034 move_allow |= tmp->move_allow; 1978 move_allow |= tmp->move_allow;
2035 1979
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)) 1980 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) flags |= P_BLOCKSVIEW;
2046 flags |= P_BLOCKSVIEW; 1981 if (QUERY_FLAG (tmp, FLAG_NO_MAGIC)) flags |= P_NO_MAGIC;
2047 } /* for stack of objects */ 1982 if (tmp->type == PLAYER) flags |= P_PLAYER;
1983 if (tmp->type == SAFE_GROUND) flags |= P_SAFE;
1984 if (QUERY_FLAG (tmp, FLAG_ALIVE)) flags |= P_IS_ALIVE;
1985 if (QUERY_FLAG (tmp, FLAG_DAMNED)) flags |= P_NO_CLERIC;
1986 }
2048 1987
2049 /* we don't want to rely on this function to have accurate flags, but 1988 /* we don't want to rely on this function to have accurate flags, but
2050 * since we're already doing the work, we calculate them here. 1989 * since we're already doing the work, we calculate them here.
2051 * if they don't match, logic is broken someplace. 1990 * if they don't match, logic is broken someplace.
2052 */ 1991 */
2053 if (((oldflags & ~(P_NEED_UPDATE | P_NO_ERROR)) != flags) && (!(oldflags & P_NO_ERROR))) 1992 if (((oldflags & ~(P_NEED_UPDATE | P_NO_ERROR)) != flags) && (!(oldflags & P_NO_ERROR)))
2054 {
2055 LOG (llevDebug, "update_position: updated flags do not match old flags: %s (old=%d,new=%d) %x != %x\n", 1993 LOG (llevDebug, "update_position: updated flags do not match old flags: %s (old=%d,new=%d) %x != %x\n",
2056 m->path, x, y, (oldflags & ~P_NEED_UPDATE), flags); 1994 m->path, x, y, (oldflags & ~P_NEED_UPDATE), flags);
2057 } 1995
2058 SET_MAP_FLAGS (m, x, y, flags); 1996 mapspace &s = m->at (x, y);
2059 SET_MAP_MOVE_BLOCK (m, x, y, move_block & ~move_allow); 1997
2060 SET_MAP_MOVE_ON (m, x, y, move_on); 1998 s.flags = flags;
2061 SET_MAP_MOVE_OFF (m, x, y, move_off); 1999 s.move_block = move_block & ~move_allow;
2062 SET_MAP_MOVE_SLOW (m, x, y, move_slow); 2000 s.move_on = move_on;
2001 s.move_off = move_off;
2002 s.move_slow = move_slow;
2063 2003
2064 /* At this point, we have a floor face (if there is a floor), 2004 /* 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 2005 * and the floor is set - we are not going to touch it at
2066 * this point. 2006 * this point.
2067 * middle contains the highest visibility face. 2007 * middle contains the highest visibility face.
… …
2121 break; 2061 break;
2122 } 2062 }
2123 } 2063 }
2124 } 2064 }
2125 } 2065 }
2066
2126 if (middle == floor) 2067 if (middle == floor)
2127 middle = blank_face; 2068 middle = blank_face;
2069
2128 if (top == middle) 2070 if (top == middle)
2129 middle = blank_face; 2071 middle = blank_face;
2072
2130 SET_MAP_FACE (m, x, y, top, 0); 2073 SET_MAP_FACE (m, x, y, top, 0);
2131 if (top != blank_face) 2074 if (top != blank_face)
2132 SET_MAP_FACE_OBJ (m, x, y, top_obj, 0); 2075 SET_MAP_FACE_OBJ (m, x, y, top_obj, 0);
2133 else 2076 else
2134 SET_MAP_FACE_OBJ (m, x, y, NULL, 0); 2077 SET_MAP_FACE_OBJ (m, x, y, NULL, 0);
2078
2135 SET_MAP_FACE (m, x, y, middle, 1); 2079 SET_MAP_FACE (m, x, y, middle, 1);
2136 if (middle != blank_face) 2080 if (middle != blank_face)
2137 SET_MAP_FACE_OBJ (m, x, y, middle_obj, 1); 2081 SET_MAP_FACE_OBJ (m, x, y, middle_obj, 1);
2138 else 2082 else
2139 SET_MAP_FACE_OBJ (m, x, y, NULL, 1); 2083 SET_MAP_FACE_OBJ (m, x, y, NULL, 1);
2084
2140 SET_MAP_FACE (m, x, y, floor, 2); 2085 SET_MAP_FACE (m, x, y, floor, 2);
2141 if (floor != blank_face) 2086 if (floor != blank_face)
2142 SET_MAP_FACE_OBJ (m, x, y, floor_obj, 2); 2087 SET_MAP_FACE_OBJ (m, x, y, floor_obj, 2);
2143 else 2088 else
2144 SET_MAP_FACE_OBJ (m, x, y, NULL, 2); 2089 SET_MAP_FACE_OBJ (m, x, y, NULL, 2);
2090
2145 SET_MAP_LIGHT (m, x, y, light); 2091 SET_MAP_LIGHT (m, x, y, light);
2146} 2092}
2147 2093
2148 2094
2149void 2095void
2150set_map_reset_time (mapstruct *map) 2096set_map_reset_time (maptile *map)
2151{ 2097{
2152 int timeout; 2098 int timeout;
2153 2099
2154 timeout = MAP_RESET_TIMEOUT (map); 2100 timeout = MAP_RESET_TIMEOUT (map);
2155 if (timeout <= 0) 2101 if (timeout <= 0)
2156 timeout = MAP_DEFAULTRESET; 2102 timeout = MAP_DEFAULTRESET;
2157 if (timeout >= MAP_MAXRESET) 2103 if (timeout >= MAP_MAXRESET)
2158 timeout = MAP_MAXRESET; 2104 timeout = MAP_MAXRESET;
2159 MAP_WHEN_RESET (map) = seconds () + timeout; 2105 MAP_WHEN_RESET (map) = time (0) + timeout;
2160} 2106}
2161 2107
2162/* this updates the orig_map->tile_map[tile_num] value after loading 2108/* 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 2109 * 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 2110 * 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 2111 * 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. 2112 * so that it is easier for calling functions to verify success.
2167 */ 2113 */
2168 2114
2169static mapstruct * 2115static maptile *
2170load_and_link_tiled_map (mapstruct *orig_map, int tile_num) 2116load_and_link_tiled_map (maptile *orig_map, int tile_num)
2171{ 2117{
2172 int dest_tile = (tile_num + 2) % 4; 2118 int dest_tile = (tile_num + 2) % 4;
2173 char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]); 2119 char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]);
2174 2120
2175 orig_map->tile_map[tile_num] = ready_map_name (path, 0); 2121 orig_map->tile_map[tile_num] = ready_map_name (path, 0);
… …
2190 * tiled maps. 2136 * tiled maps.
2191 * 2137 *
2192 * 2138 *
2193 */ 2139 */
2194int 2140int
2195out_of_map (mapstruct *m, int x, int y) 2141out_of_map (maptile *m, int x, int y)
2196{ 2142{
2197 2143
2198 /* If we get passed a null map, this is obviously the 2144 /* If we get passed a null map, this is obviously the
2199 * case. This generally shouldn't happen, but if the 2145 * case. This generally shouldn't happen, but if the
2200 * map loads fail below, it could happen. 2146 * map loads fail below, it could happen.
… …
2255 * the map as that the coordinates are really on, and 2201 * the map as that the coordinates are really on, and
2256 * updates x and y to be the localized coordinates. 2202 * updates x and y to be the localized coordinates.
2257 * Using this is more efficient of calling out_of_map 2203 * Using this is more efficient of calling out_of_map
2258 * and then figuring out what the real map is 2204 * and then figuring out what the real map is
2259 */ 2205 */
2260mapstruct * 2206maptile *
2261get_map_from_coord (mapstruct *m, sint16 * x, sint16 * y) 2207get_map_from_coord (maptile *m, sint16 * x, sint16 * y)
2262{ 2208{
2263 2209
2264 if (*x < 0) 2210 if (*x < 0)
2265 { 2211 {
2266 if (!m->tile_path[3]) 2212 if (!m->tile_path[3])
… …
2312/** 2258/**
2313 * Return whether map2 is adjacent to map1. If so, store the distance from 2259 * Return whether map2 is adjacent to map1. If so, store the distance from
2314 * map1 to map2 in dx/dy. 2260 * map1 to map2 in dx/dy.
2315 */ 2261 */
2316static int 2262static int
2317adjacent_map (const mapstruct *map1, const mapstruct *map2, int *dx, int *dy) 2263adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy)
2318{ 2264{
2319 if (!map1 || !map2) 2265 if (!map1 || !map2)
2320 return 0; 2266 return 0;
2321 2267
2322 if (map1 == map2) 2268 if (map1 == map2)
… …
2480 * for something in the future. Also, since no object is pasted, the best 2426 * for something in the future. Also, since no object is pasted, the best
2481 * field of the rv_vector is set to NULL. 2427 * field of the rv_vector is set to NULL.
2482 */ 2428 */
2483 2429
2484void 2430void
2485get_rangevector_from_mapcoord (const mapstruct *m, int x, int y, const object *op2, rv_vector * retval, int flags) 2431get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector * retval, int flags)
2486{ 2432{
2487 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y)) 2433 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
2488 { 2434 {
2489 /* be conservative and fill in _some_ data */ 2435 /* be conservative and fill in _some_ data */
2490 retval->distance = 100000; 2436 retval->distance = 100000;

Diff Legend

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