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.44 by root, Mon Dec 18 04:07:30 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
… …
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 402
422int 403int
423ob_blocked (const object *ob, mapstruct *m, sint16 x, sint16 y) 404ob_blocked (const object *ob, maptile *m, sint16 x, sint16 y)
424{ 405{
425 archetype *tmp; 406 archetype *tmp;
426 int flag; 407 int flag;
427 mapstruct *m1; 408 maptile *m1;
428 sint16 sx, sy; 409 sint16 sx, sy;
429 410
430 if (ob == NULL) 411 if (ob == NULL)
431 { 412 {
432 flag = get_map_flags (m, &m1, x, y, &sx, &sy); 413 flag = get_map_flags (m, &m1, x, y, &sx, &sy);
… …
497 * they are saved). We do have to look for the old maps that did save 478 * 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. 479 * the more sections and not re-add sections for them.
499 */ 480 */
500 481
501static void 482static void
502link_multipart_objects (mapstruct *m) 483link_multipart_objects (maptile *m)
503{ 484{
504 int x, y; 485 int x, y;
505 object *tmp, *op, *last, *above; 486 object *tmp, *op, *last, *above;
506 archetype *at; 487 archetype *at;
507 488
… …
544 * Loads (ands parses) the objects into a given map from the specified 525 * Loads (ands parses) the objects into a given map from the specified
545 * file pointer. 526 * file pointer.
546 * mapflags is the same as we get with load_original_map 527 * mapflags is the same as we get with load_original_map
547 */ 528 */
548void 529void
549load_objects (mapstruct *m, object_thawer & fp, int mapflags) 530load_objects (maptile *m, object_thawer & fp, int mapflags)
550{ 531{
551 int i, j; 532 int i, j;
552 int unique; 533 int unique;
553 object *op, *prev = NULL, *last_more = NULL, *otmp; 534 object *op, *prev = NULL, *last_more = NULL, *otmp;
554 535
555 op = get_object (); 536 op = object::create ();
556 op->map = m; /* To handle buttons correctly */ 537 op->map = m; /* To handle buttons correctly */
557 538
558 while ((i = load_object (fp, op, mapflags))) 539 while ((i = load_object (fp, op, mapflags)))
559 { 540 {
560 /* if the archetype for the object is null, means that we 541 /* if the archetype for the object is null, means that we
… …
568 } 549 }
569 550
570 551
571 switch (i) 552 switch (i)
572 { 553 {
573 case LL_NORMAL: 554 case LL_NORMAL:
574 /* if we are loading an overlay, put the floors on the bottom */ 555 /* 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) 556 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); 557 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY | INS_MAP_LOAD);
577 else 558 else
578 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD); 559 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD);
579 560
580 if (op->inv) 561 if (op->inv)
581 sum_weight (op); 562 sum_weight (op);
582 563
583 prev = op, last_more = op; 564 prev = op, last_more = op;
584 break; 565 break;
585 566
586 case LL_MORE: 567 case LL_MORE:
587 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY); 568 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; 569 op->head = prev, last_more->more = op, last_more = op;
589 break; 570 break;
590 } 571 }
591 572
592 if (mapflags & MAP_STYLE) 573 if (mapflags & MAP_STYLE)
593 remove_from_active_list (op); 574 remove_from_active_list (op);
594 575
595 op = get_object (); 576 op = object::create ();
596 op->map = m; 577 op->map = m;
597 } 578 }
598 579
599 for (i = 0; i < m->width; i++) 580 for (i = 0; i < m->width; i++)
600 { 581 {
… …
604 /* check for unique items, or unique squares */ 585 /* check for unique items, or unique squares */
605 for (otmp = get_map_ob (m, i, j); otmp; otmp = otmp->above) 586 for (otmp = get_map_ob (m, i, j); otmp; otmp = otmp->above)
606 { 587 {
607 if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL)) 588 if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL))
608 unique = 1; 589 unique = 1;
590
609 if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique)) 591 if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique))
610 SET_FLAG (otmp, FLAG_OBJ_ORIGINAL); 592 SET_FLAG (otmp, FLAG_OBJ_ORIGINAL);
611 } 593 }
612 } 594 }
613 } 595 }
614 596
615 free_object (op); 597 op->destroy ();
616 link_multipart_objects (m); 598 link_multipart_objects (m);
617} 599}
618 600
619/* This saves all the objects on the map in a non destructive fashion. 601/* 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, 602 * 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 603 * and we only save the head of multi part objects - this is needed
622 * in order to do map tiling properly. 604 * in order to do map tiling properly.
623 */ 605 */
624void 606void
625save_objects (mapstruct *m, object_freezer & fp, object_freezer & fp2, int flag) 607save_objects (maptile *m, object_freezer & fp, object_freezer & fp2, int flag)
626{ 608{
627 int i, j = 0, unique = 0; 609 int i, j = 0, unique = 0;
628 object *op; 610 object *op;
629 611
630 /* first pass - save one-part objects */ 612 /* first pass - save one-part objects */
… …
653 635
654 } /* for this space */ 636 } /* for this space */
655 } /* for this j */ 637 } /* for this j */
656} 638}
657 639
640maptile::maptile ()
641{
642 in_memory = MAP_SWAPPED;
643 /* The maps used to pick up default x and y values from the
644 * map archetype. Mimic that behaviour.
645 */
646 MAP_WIDTH (this) = 16;
647 MAP_HEIGHT (this) = 16;
648 MAP_RESET_TIMEOUT (this) = 0;
649 MAP_TIMEOUT (this) = 300;
650 MAP_ENTER_X (this) = 0;
651 MAP_ENTER_Y (this) = 0;
652 /*set part to -1 indicating conversion to weather map not yet done */
653 MAP_WORLDPARTX (this) = -1;
654 MAP_WORLDPARTY (this) = -1;
655}
656
658/* 657/*
659 * Allocates, initialises, and returns a pointer to a mapstruct. 658 * Allocates, initialises, and returns a pointer to a maptile.
660 * Modified to no longer take a path option which was not being 659 * Modified to no longer take a path option which was not being
661 * used anyways. MSW 2001-07-01 660 * used anyways. MSW 2001-07-01
662 */ 661 */
663 662maptile *
664mapstruct *
665get_linked_map (void) 663get_linked_map (void)
666{ 664{
667 mapstruct *map = new mapstruct; 665 maptile *mp, *map = new maptile;
668 mapstruct *mp;
669 666
670 for (mp = first_map; mp != NULL && mp->next != NULL; mp = mp->next); 667 for (mp = first_map; mp && mp->next; mp = mp->next);
668
671 if (mp == NULL) 669 if (mp == NULL)
672 first_map = map; 670 first_map = map;
673 else 671 else
674 mp->next = map; 672 mp->next = map;
675 673
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; 674 return map;
690} 675}
691 676
692/* 677/*
693 * Allocates the arrays contained in a mapstruct. 678 * Allocates the arrays contained in a maptile.
694 * This basically allocates the dynamic array of spaces for the 679 * This basically allocates the dynamic array of spaces for the
695 * map. 680 * map.
696 */ 681 */
697
698void 682void
699allocate_map (mapstruct *m) 683maptile::allocate ()
700{ 684{
701 m->in_memory = MAP_IN_MEMORY; 685 in_memory = MAP_IN_MEMORY;
686
702 /* Log this condition and free the storage. We could I suppose 687 /* Log this condition and free the storage. We could I suppose
703 * realloc, but if the caller is presuming the data will be intact, 688 * realloc, but if the caller is presuming the data will be intact,
704 * that is their poor assumption. 689 * that is their poor assumption.
705 */ 690 */
706 if (m->spaces) 691 if (spaces)
707 { 692 {
708 LOG (llevError, "allocate_map called with already allocated map (%s)\n", m->path); 693 LOG (llevError, "allocate_map called with already allocated map (%s)\n", path);
709 free (m->spaces); 694 free (spaces);
710 } 695 }
711 696
712 m->spaces = (MapSpace *) calloc (1, MAP_WIDTH (m) * MAP_HEIGHT (m) * sizeof (MapSpace)); 697 spaces = (MapSpace *)
698 calloc (1, width * height * sizeof (MapSpace));
713 699
714 if (m->spaces == NULL) 700 if (!spaces)
715 fatal (OUT_OF_MEMORY); 701 fatal (OUT_OF_MEMORY);
716} 702}
717 703
718/* Create and returns a map of the specific size. Used 704/* Create and returns a map of the specific size. Used
719 * in random map code and the editor. 705 * in random map code and the editor.
720 */ 706 */
721mapstruct * 707maptile *
722get_empty_map (int sizex, int sizey) 708get_empty_map (int sizex, int sizey)
723{ 709{
724 mapstruct *m = get_linked_map (); 710 maptile *m = get_linked_map ();
725 711
726 m->width = sizex; 712 m->width = sizex;
727 m->height = sizey; 713 m->height = sizey;
728 m->in_memory = MAP_SWAPPED; 714 m->in_memory = MAP_SWAPPED;
729 allocate_map (m); 715 m->allocate ();
716
730 return m; 717 return m;
731} 718}
732 719
733/* Takes a string from a map definition and outputs a pointer to the array of shopitems 720/* 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 721 * corresponding to that string. Memory is allocated for this, it must be freed
… …
742 char *shop_string, *p, *q, *next_semicolon, *next_colon; 729 char *shop_string, *p, *q, *next_semicolon, *next_colon;
743 shopitems *items = NULL; 730 shopitems *items = NULL;
744 int i = 0, number_of_entries = 0; 731 int i = 0, number_of_entries = 0;
745 const typedata *current_type; 732 const typedata *current_type;
746 733
747 shop_string = strdup_local (input_string); 734 shop_string = strdup (input_string);
748 p = shop_string; 735 p = shop_string;
749 /* first we'll count the entries, we'll need that for allocating the array shortly */ 736 /* first we'll count the entries, we'll need that for allocating the array shortly */
750 while (p) 737 while (p)
751 { 738 {
752 p = strchr (p, ';'); 739 p = strchr (p, ';');
… …
811} 798}
812 799
813/* opposite of parse string, this puts the string that was originally fed in to 800/* opposite of parse string, this puts the string that was originally fed in to
814 * the map (or something equivilent) into output_string. */ 801 * the map (or something equivilent) into output_string. */
815static void 802static void
816print_shop_string (mapstruct *m, char *output_string) 803print_shop_string (maptile *m, char *output_string)
817{ 804{
818 int i; 805 int i;
819 char tmp[MAX_BUF]; 806 char tmp[MAX_BUF];
820 807
821 strcpy (output_string, ""); 808 strcpy (output_string, "");
… …
855 * MSW 2001-07-01 842 * MSW 2001-07-01
856 * return 0 on success, 1 on failure. 843 * return 0 on success, 1 on failure.
857 */ 844 */
858 845
859static int 846static int
860load_map_header (object_thawer & fp, mapstruct *m) 847load_map_header (object_thawer & fp, maptile *m)
861{ 848{
862 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end; 849 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end;
863 int msgpos = 0; 850 int msgpos = 0;
864 int maplorepos = 0; 851 int maplorepos = 0;
865 852
866 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 853 while (fgets (buf, HUGE_BUF, fp) != NULL)
867 { 854 {
868 buf[HUGE_BUF - 1] = 0; 855 buf[HUGE_BUF - 1] = 0;
869 key = buf; 856 key = buf;
857
870 while (isspace (*key)) 858 while (isspace (*key))
871 key++; 859 key++;
860
872 if (*key == 0) 861 if (*key == 0)
873 continue; /* empty line */ 862 continue; /* empty line */
863
874 value = strchr (key, ' '); 864 value = strchr (key, ' ');
865
875 if (!value) 866 if (!value)
876 { 867 {
877 end = strchr (key, '\n'); 868 if ((end = strchr (key, '\n')))
878 if (end != NULL)
879 {
880 *end = 0; 869 *end = 0;
881 }
882 } 870 }
883 else 871 else
884 { 872 {
885 *value = 0; 873 *value = 0;
886 value++; 874 value++;
887 end = strchr (value, '\n'); 875 end = strchr (value, '\n');
876
888 while (isspace (*value)) 877 while (isspace (*value))
889 { 878 {
890 value++; 879 value++;
880
891 if (*value == '\0' || value == end) 881 if (*value == '\0' || value == end)
892 { 882 {
893 /* Nothing but spaces. */ 883 /* Nothing but spaces. */
894 value = NULL; 884 value = NULL;
895 break; 885 break;
… …
918 * that use the parameter. 908 * that use the parameter.
919 */ 909 */
920 910
921 if (!strcmp (key, "msg")) 911 if (!strcmp (key, "msg"))
922 { 912 {
923 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 913 while (fgets (buf, HUGE_BUF, fp) != NULL)
924 { 914 {
925 if (!strcmp (buf, "endmsg\n")) 915 if (!strcmp (buf, "endmsg\n"))
926 break; 916 break;
927 else 917 else
928 { 918 {
… …
935 * with nothing between). There is no reason in those cases to 925 * with nothing between). There is no reason in those cases to
936 * keep the empty message. Also, msgbuf contains garbage data 926 * keep the empty message. Also, msgbuf contains garbage data
937 * when msgpos is zero, so copying it results in crashes 927 * when msgpos is zero, so copying it results in crashes
938 */ 928 */
939 if (msgpos != 0) 929 if (msgpos != 0)
940 m->msg = strdup_local (msgbuf); 930 m->msg = strdup (msgbuf);
941 } 931 }
942 else if (!strcmp (key, "maplore")) 932 else if (!strcmp (key, "maplore"))
943 { 933 {
944 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 934 while (fgets (buf, HUGE_BUF, fp) != NULL)
945 { 935 {
946 if (!strcmp (buf, "endmaplore\n")) 936 if (!strcmp (buf, "endmaplore\n"))
947 break; 937 break;
948 else 938 else
949 { 939 {
… …
951 strcpy (maplorebuf + maplorepos, buf); 941 strcpy (maplorebuf + maplorepos, buf);
952 maplorepos += strlen (buf); 942 maplorepos += strlen (buf);
953 } 943 }
954 } 944 }
955 if (maplorepos != 0) 945 if (maplorepos != 0)
956 m->maplore = strdup_local (maplorebuf); 946 m->maplore = strdup (maplorebuf);
957 } 947 }
958 else if (!strcmp (key, "end")) 948 else if (!strcmp (key, "end"))
959 { 949 {
960 break; 950 break;
961 } 951 }
… …
970 LOG (llevError, "loading map and got a non 'arch map' line(%s %s)?\n", key, value); 960 LOG (llevError, "loading map and got a non 'arch map' line(%s %s)?\n", key, value);
971 } 961 }
972 else if (!strcmp (key, "name")) 962 else if (!strcmp (key, "name"))
973 { 963 {
974 *end = 0; 964 *end = 0;
975 m->name = strdup_local (value); 965 m->name = strdup (value);
976 } 966 }
977 /* first strcmp value on these are old names supported 967 /* first strcmp value on these are old names supported
978 * for compatibility reasons. The new values (second) are 968 * for compatibility reasons. The new values (second) are
979 * what really should be used. 969 * what really should be used.
980 */ 970 */
981 else if (!strcmp (key, "oid")) 971 else if (!strcmp (key, "oid"))
982 {
983 fp.get (m, atoi (value)); 972 fp.get (m, atoi (value));
984 }
985 else if (!strcmp (key, "attach")) 973 else if (!strcmp (key, "attach"))
986 {
987 m->attach = value; 974 m->attach = value;
988 }
989 else if (!strcmp (key, "hp") || !strcmp (key, "enter_x")) 975 else if (!strcmp (key, "hp") || !strcmp (key, "enter_x"))
990 {
991 m->enter_x = atoi (value); 976 m->enter_x = atoi (value);
992 }
993 else if (!strcmp (key, "sp") || !strcmp (key, "enter_y")) 977 else if (!strcmp (key, "sp") || !strcmp (key, "enter_y"))
994 {
995 m->enter_y = atoi (value); 978 m->enter_y = atoi (value);
996 }
997 else if (!strcmp (key, "x") || !strcmp (key, "width")) 979 else if (!strcmp (key, "x") || !strcmp (key, "width"))
998 {
999 m->width = atoi (value); 980 m->width = atoi (value);
1000 }
1001 else if (!strcmp (key, "y") || !strcmp (key, "height")) 981 else if (!strcmp (key, "y") || !strcmp (key, "height"))
1002 {
1003 m->height = atoi (value); 982 m->height = atoi (value);
1004 }
1005 else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout")) 983 else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout"))
1006 {
1007 m->reset_timeout = atoi (value); 984 m->reset_timeout = atoi (value);
1008 }
1009 else if (!strcmp (key, "value") || !strcmp (key, "swap_time")) 985 else if (!strcmp (key, "value") || !strcmp (key, "swap_time"))
1010 {
1011 m->timeout = atoi (value); 986 m->timeout = atoi (value);
1012 }
1013 else if (!strcmp (key, "level") || !strcmp (key, "difficulty")) 987 else if (!strcmp (key, "level") || !strcmp (key, "difficulty"))
1014 { 988 m->difficulty = clamp (atoi (value), 1, settings.max_level);
1015 m->difficulty = atoi (value);
1016 }
1017 else if (!strcmp (key, "invisible") || !strcmp (key, "darkness")) 989 else if (!strcmp (key, "invisible") || !strcmp (key, "darkness"))
1018 {
1019 m->darkness = atoi (value); 990 m->darkness = atoi (value);
1020 }
1021 else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime")) 991 else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime"))
1022 {
1023 m->fixed_resettime = atoi (value); 992 m->fixed_resettime = atoi (value);
1024 }
1025 else if (!strcmp (key, "unique")) 993 else if (!strcmp (key, "unique"))
1026 {
1027 m->unique = atoi (value); 994 m->unique = atoi (value);
1028 }
1029 else if (!strcmp (key, "template")) 995 else if (!strcmp (key, "template"))
1030 {
1031 m->templatemap = atoi (value); 996 m->templatemap = atoi (value);
1032 }
1033 else if (!strcmp (key, "region")) 997 else if (!strcmp (key, "region"))
1034 {
1035 m->region = get_region_by_name (value); 998 m->region = get_region_by_name (value);
1036 }
1037 else if (!strcmp (key, "shopitems")) 999 else if (!strcmp (key, "shopitems"))
1038 { 1000 {
1039 *end = 0; 1001 *end = 0;
1040 m->shopitems = parse_shop_string (value); 1002 m->shopitems = parse_shop_string (value);
1041 } 1003 }
1042 else if (!strcmp (key, "shopgreed")) 1004 else if (!strcmp (key, "shopgreed"))
1043 {
1044 m->shopgreed = atof (value); 1005 m->shopgreed = atof (value);
1045 }
1046 else if (!strcmp (key, "shopmin")) 1006 else if (!strcmp (key, "shopmin"))
1047 {
1048 m->shopmin = atol (value); 1007 m->shopmin = atol (value);
1049 }
1050 else if (!strcmp (key, "shopmax")) 1008 else if (!strcmp (key, "shopmax"))
1051 {
1052 m->shopmax = atol (value); 1009 m->shopmax = atol (value);
1053 }
1054 else if (!strcmp (key, "shoprace")) 1010 else if (!strcmp (key, "shoprace"))
1055 { 1011 {
1056 *end = 0; 1012 *end = 0;
1057 m->shoprace = strdup_local (value); 1013 m->shoprace = strdup (value);
1058 } 1014 }
1059 else if (!strcmp (key, "outdoor")) 1015 else if (!strcmp (key, "outdoor"))
1060 {
1061 m->outdoor = atoi (value); 1016 m->outdoor = atoi (value);
1062 }
1063 else if (!strcmp (key, "temp")) 1017 else if (!strcmp (key, "temp"))
1064 {
1065 m->temp = atoi (value); 1018 m->temp = atoi (value);
1066 }
1067 else if (!strcmp (key, "pressure")) 1019 else if (!strcmp (key, "pressure"))
1068 {
1069 m->pressure = atoi (value); 1020 m->pressure = atoi (value);
1070 }
1071 else if (!strcmp (key, "humid")) 1021 else if (!strcmp (key, "humid"))
1072 {
1073 m->humid = atoi (value); 1022 m->humid = atoi (value);
1074 }
1075 else if (!strcmp (key, "windspeed")) 1023 else if (!strcmp (key, "windspeed"))
1076 {
1077 m->windspeed = atoi (value); 1024 m->windspeed = atoi (value);
1078 }
1079 else if (!strcmp (key, "winddir")) 1025 else if (!strcmp (key, "winddir"))
1080 {
1081 m->winddir = atoi (value); 1026 m->winddir = atoi (value);
1082 }
1083 else if (!strcmp (key, "sky")) 1027 else if (!strcmp (key, "sky"))
1084 {
1085 m->sky = atoi (value); 1028 m->sky = atoi (value);
1086 }
1087 else if (!strcmp (key, "nosmooth")) 1029 else if (!strcmp (key, "nosmooth"))
1088 {
1089 m->nosmooth = atoi (value); 1030 m->nosmooth = atoi (value);
1090 }
1091 else if (!strncmp (key, "tile_path_", 10)) 1031 else if (!strncmp (key, "tile_path_", 10))
1092 { 1032 {
1093 int tile = atoi (key + 10); 1033 int tile = atoi (key + 10);
1094 1034
1095 if (tile < 1 || tile > 4) 1035 if (tile < 1 || tile > 4)
… …
1128 } 1068 }
1129 1069
1130 if (editor) 1070 if (editor)
1131 { 1071 {
1132 /* Use the value as in the file. */ 1072 /* Use the value as in the file. */
1133 m->tile_path[tile - 1] = strdup_local (value); 1073 m->tile_path[tile - 1] = strdup (value);
1134 } 1074 }
1135 else if (path != NULL) 1075 else if (path != NULL)
1136 { 1076 {
1137 /* Use the normalized value. */ 1077 /* Use the normalized value. */
1138 m->tile_path[tile - 1] = strdup_local (path); 1078 m->tile_path[tile - 1] = strdup (path);
1139 } 1079 }
1140 } /* end if tile direction (in)valid */ 1080 } /* end if tile direction (in)valid */
1141 } 1081 }
1142 else 1082 else
1143 {
1144 LOG (llevError, "Got unknown value in map header: %s %s\n", key, value); 1083 LOG (llevError, "Got unknown value in map header: %s %s\n", key, value);
1145 }
1146 } 1084 }
1085
1147 if (!key || strcmp (key, "end")) 1086 if (!key || strcmp (key, "end"))
1148 { 1087 {
1149 LOG (llevError, "Got premature eof on map header!\n"); 1088 LOG (llevError, "Got premature eof on map header!\n");
1150 return 1; 1089 return 1;
1151 } 1090 }
1091
1152 return 0; 1092 return 0;
1153} 1093}
1154 1094
1155/* 1095/*
1156 * Opens the file "filename" and reads information about the map 1096 * Opens the file "filename" and reads information about the map
1157 * from the given file, and stores it in a newly allocated 1097 * from the given file, and stores it in a newly allocated
1158 * mapstruct. A pointer to this structure is returned, or NULL on failure. 1098 * maptile. A pointer to this structure is returned, or NULL on failure.
1159 * flags correspond to those in map.h. Main ones used are 1099 * 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 1100 * 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 1101 * 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. 1102 * 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 1103 * MAP_STYLE: style map - don't add active objects, don't add to server
1164 * managed map list. 1104 * managed map list.
1165 */ 1105 */
1166 1106
1167mapstruct * 1107maptile *
1168load_original_map (const char *filename, int flags) 1108load_original_map (const char *filename, int flags)
1169{ 1109{
1170 mapstruct *m; 1110 maptile *m;
1171 char pathname[MAX_BUF]; 1111 char pathname[MAX_BUF];
1172 1112
1173 if (flags & MAP_PLAYER_UNIQUE) 1113 if (flags & MAP_PLAYER_UNIQUE)
1174 strcpy (pathname, filename); 1114 strcpy (pathname, filename);
1175 else if (flags & MAP_OVERLAY) 1115 else if (flags & MAP_OVERLAY)
… …
1192 LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags); 1132 LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags);
1193 delete_map (m); 1133 delete_map (m);
1194 return NULL; 1134 return NULL;
1195 } 1135 }
1196 1136
1197 allocate_map (m); 1137 m->allocate ();
1198 1138
1199 m->in_memory = MAP_LOADING; 1139 m->in_memory = MAP_LOADING;
1200 load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE)); 1140 load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE));
1201 1141
1202 m->in_memory = MAP_IN_MEMORY; 1142 m->in_memory = MAP_IN_MEMORY;
… …
1211 * Loads a map, which has been loaded earlier, from file. 1151 * Loads a map, which has been loaded earlier, from file.
1212 * Return the map object we load into (this can change from the passed 1152 * Return the map object we load into (this can change from the passed
1213 * option if we can't find the original map) 1153 * option if we can't find the original map)
1214 */ 1154 */
1215 1155
1216static mapstruct * 1156static maptile *
1217load_temporary_map (mapstruct *m) 1157load_temporary_map (maptile *m)
1218{ 1158{
1219 char buf[MAX_BUF]; 1159 char buf[MAX_BUF];
1220 1160
1221 if (!m->tmpname) 1161 if (!m->tmpname)
1222 { 1162 {
… …
1248 LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname); 1188 LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname);
1249 delete_map (m); 1189 delete_map (m);
1250 m = load_original_map (m->path, 0); 1190 m = load_original_map (m->path, 0);
1251 return NULL; 1191 return NULL;
1252 } 1192 }
1193
1253 allocate_map (m); 1194 m->allocate ();
1254 1195
1255 m->in_memory = MAP_LOADING; 1196 m->in_memory = MAP_LOADING;
1256 load_objects (m, thawer, 0); 1197 load_objects (m, thawer, 0);
1257 1198
1258 m->in_memory = MAP_IN_MEMORY; 1199 m->in_memory = MAP_IN_MEMORY;
… …
1264 * Loads a map, which has been loaded earlier, from file. 1205 * Loads a map, which has been loaded earlier, from file.
1265 * Return the map object we load into (this can change from the passed 1206 * Return the map object we load into (this can change from the passed
1266 * option if we can't find the original map) 1207 * option if we can't find the original map)
1267 */ 1208 */
1268 1209
1269mapstruct * 1210maptile *
1270load_overlay_map (const char *filename, mapstruct *m) 1211load_overlay_map (const char *filename, maptile *m)
1271{ 1212{
1272 char pathname[MAX_BUF]; 1213 char pathname[MAX_BUF];
1273 1214
1274 strcpy (pathname, create_overlay_pathname (filename)); 1215 strcpy (pathname, create_overlay_pathname (filename));
1275 1216
… …
1283 LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname); 1224 LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname);
1284 delete_map (m); 1225 delete_map (m);
1285 m = load_original_map (m->path, 0); 1226 m = load_original_map (m->path, 0);
1286 return NULL; 1227 return NULL;
1287 } 1228 }
1288 /*allocate_map(m); */ 1229 /*m->allocate ();*/
1289 1230
1290 m->in_memory = MAP_LOADING; 1231 m->in_memory = MAP_LOADING;
1291 load_objects (m, thawer, MAP_OVERLAY); 1232 load_objects (m, thawer, MAP_OVERLAY);
1292 1233
1293 m->in_memory = MAP_IN_MEMORY; 1234 m->in_memory = MAP_IN_MEMORY;
… …
1298 * This is the start of unique map handling code 1239 * This is the start of unique map handling code
1299 *****************************************************************************/ 1240 *****************************************************************************/
1300 1241
1301/* This goes through map 'm' and removed any unique items on the map. */ 1242/* This goes through map 'm' and removed any unique items on the map. */
1302static void 1243static void
1303delete_unique_items (mapstruct *m) 1244delete_unique_items (maptile *m)
1304{ 1245{
1305 int i, j, unique; 1246 int i, j, unique;
1306 object *op, *next; 1247 object *op, *next;
1307 1248
1308 for (i = 0; i < MAP_WIDTH (m); i++) 1249 for (i = 0; i < MAP_WIDTH (m); i++)
1309 for (j = 0; j < MAP_HEIGHT (m); j++) 1250 for (j = 0; j < MAP_HEIGHT (m); j++)
1310 { 1251 {
1311 unique = 0; 1252 unique = 0;
1253
1312 for (op = get_map_ob (m, i, j); op; op = next) 1254 for (op = get_map_ob (m, i, j); op; op = next)
1313 { 1255 {
1314 next = op->above; 1256 next = op->above;
1257
1315 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) 1258 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
1316 unique = 1; 1259 unique = 1;
1260
1317 if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique)) 1261 if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique))
1318 { 1262 {
1319 clean_object (op); 1263 clean_object (op);
1264
1320 if (QUERY_FLAG (op, FLAG_IS_LINKED)) 1265 if (QUERY_FLAG (op, FLAG_IS_LINKED))
1321 remove_button_link (op); 1266 remove_button_link (op);
1322 remove_ob (op); 1267
1323 free_object (op); 1268 op->destroy ();
1324 } 1269 }
1325 } 1270 }
1326 } 1271 }
1327} 1272}
1328 1273
… …
1330/* 1275/*
1331 * Loads unique objects from file(s) into the map which is in memory 1276 * Loads unique objects from file(s) into the map which is in memory
1332 * m is the map to load unique items into. 1277 * m is the map to load unique items into.
1333 */ 1278 */
1334static void 1279static void
1335load_unique_objects (mapstruct *m) 1280load_unique_objects (maptile *m)
1336{ 1281{
1337 int count; 1282 int count;
1338 char firstname[MAX_BUF]; 1283 char firstname[MAX_BUF];
1339 1284
1340 for (count = 0; count < 10; count++) 1285 for (count = 0; count < 10; count++)
… …
1363 1308
1364/* 1309/*
1365 * Saves a map to file. If flag is set, it is saved into the same 1310 * 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 1311 * file it was (originally) loaded from. Otherwise a temporary
1367 * filename will be genarated, and the file will be stored there. 1312 * filename will be genarated, and the file will be stored there.
1368 * The temporary filename will be stored in the mapstructure. 1313 * The temporary filename will be stored in the maptileure.
1369 * If the map is unique, we also save to the filename in the map 1314 * If the map is unique, we also save to the filename in the map
1370 * (this should have been updated when first loaded) 1315 * (this should have been updated when first loaded)
1371 */ 1316 */
1372 1317
1373int 1318int
1374new_save_map (mapstruct *m, int flag) 1319new_save_map (maptile *m, int flag)
1375{ 1320{
1376 char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF]; 1321 char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF];
1377 int i; 1322 int i;
1378 1323
1379 if (flag && !*m->path) 1324 if (flag && !*m->path)
… …
1397 make_path_to_file (filename); 1342 make_path_to_file (filename);
1398 } 1343 }
1399 else 1344 else
1400 { 1345 {
1401 if (!m->tmpname) 1346 if (!m->tmpname)
1402 m->tmpname = tempnam_local (settings.tmpdir, NULL); 1347 m->tmpname = tempnam (settings.tmpdir, NULL);
1403 1348
1404 strcpy (filename, m->tmpname); 1349 strcpy (filename, m->tmpname);
1405 } 1350 }
1406 1351
1407 LOG (llevDebug, "Saving map %s to %s\n", m->path, filename); 1352 LOG (llevDebug, "Saving map %s to %s\n", m->path, filename);
… …
1431 print_shop_string (m, shop); 1376 print_shop_string (m, shop);
1432 fprintf (freezer, "shopitems %s\n", shop); 1377 fprintf (freezer, "shopitems %s\n", shop);
1433 } 1378 }
1434 if (m->shopgreed) 1379 if (m->shopgreed)
1435 fprintf (freezer, "shopgreed %f\n", m->shopgreed); 1380 fprintf (freezer, "shopgreed %f\n", m->shopgreed);
1436#ifndef WIN32
1437 if (m->shopmin) 1381 if (m->shopmin)
1438 fprintf (freezer, "shopmin %llu\n", m->shopmin); 1382 fprintf (freezer, "shopmin %llu\n", m->shopmin);
1439 if (m->shopmax) 1383 if (m->shopmax)
1440 fprintf (freezer, "shopmax %llu\n", m->shopmax); 1384 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) 1385 if (m->shoprace)
1448 fprintf (freezer, "shoprace %s\n", m->shoprace); 1386 fprintf (freezer, "shoprace %s\n", m->shoprace);
1449 if (m->darkness) 1387 if (m->darkness)
1450 fprintf (freezer, "darkness %d\n", m->darkness); 1388 fprintf (freezer, "darkness %d\n", m->darkness);
1451 if (m->width) 1389 if (m->width)
… …
1530 object *tmp, *next; 1468 object *tmp, *next;
1531 1469
1532 for (tmp = op->inv; tmp; tmp = next) 1470 for (tmp = op->inv; tmp; tmp = next)
1533 { 1471 {
1534 next = tmp->below; 1472 next = tmp->below;
1473
1535 clean_object (tmp); 1474 clean_object (tmp);
1536 if (QUERY_FLAG (tmp, FLAG_IS_LINKED)) 1475 if (QUERY_FLAG (tmp, FLAG_IS_LINKED))
1537 remove_button_link (tmp); 1476 remove_button_link (tmp);
1538 remove_ob (tmp); 1477
1539 free_object (tmp); 1478 tmp->destroy ();
1540 } 1479 }
1541} 1480}
1542 1481
1543/* 1482/*
1544 * Remove and free all objects in the given map. 1483 * Remove and free all objects in the given map.
1545 */ 1484 */
1546 1485
1547void 1486void
1548free_all_objects (mapstruct *m) 1487free_all_objects (maptile *m)
1549{ 1488{
1550 int i, j; 1489 int i, j;
1551 object *op; 1490 object *op;
1552 1491
1553 for (i = 0; i < MAP_WIDTH (m); i++) 1492 for (i = 0; i < MAP_WIDTH (m); i++)
… …
1560 if (op == previous_obj) 1499 if (op == previous_obj)
1561 { 1500 {
1562 LOG (llevDebug, "free_all_objects: Link error, bailing out.\n"); 1501 LOG (llevDebug, "free_all_objects: Link error, bailing out.\n");
1563 break; 1502 break;
1564 } 1503 }
1504
1565 previous_obj = op; 1505 previous_obj = op;
1506
1566 if (op->head != NULL) 1507 if (op->head != NULL)
1567 op = op->head; 1508 op = op->head;
1568 1509
1569 /* If the map isn't in memory, free_object will remove and 1510 /* 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. 1511 * free objects in op's inventory. So let it do the job.
1571 */ 1512 */
1572 if (m->in_memory == MAP_IN_MEMORY) 1513 if (m->in_memory == MAP_IN_MEMORY)
1573 clean_object (op); 1514 clean_object (op);
1574 remove_ob (op); 1515
1575 free_object (op); 1516 op->destroy ();
1576 } 1517 }
1577 } 1518 }
1578} 1519}
1579 1520
1580/* 1521/*
1581 * Frees everything allocated by the given mapstructure. 1522 * Frees everything allocated by the given maptileure.
1582 * don't free tmpname - our caller is left to do that 1523 * don't free tmpname - our caller is left to do that
1583 */ 1524 */
1584 1525
1585void 1526void
1586free_map (mapstruct *m, int flag) 1527free_map (maptile *m, int flag)
1587{ 1528{
1588 int i; 1529 int i;
1589 1530
1590 if (!m->in_memory) 1531 if (!m->in_memory)
1591 { 1532 {
1592 LOG (llevError, "Trying to free freed map.\n"); 1533 LOG (llevError, "Trying to free freed map.\n");
1593 return; 1534 return;
1594 } 1535 }
1536
1537 // TODO: use new/delete
1538#define FREE_AND_CLEAR(p) { free (p); p = NULL; }
1539
1595 if (flag && m->spaces) 1540 if (flag && m->spaces)
1596 free_all_objects (m); 1541 free_all_objects (m);
1597 if (m->name) 1542 if (m->name)
1598 FREE_AND_CLEAR (m->name); 1543 FREE_AND_CLEAR (m->name);
1599 if (m->spaces) 1544 if (m->spaces)
1600 FREE_AND_CLEAR (m->spaces); 1545 FREE_AND_CLEAR (m->spaces);
1601 if (m->msg) 1546 if (m->msg)
1602 FREE_AND_CLEAR (m->msg); 1547 FREE_AND_CLEAR (m->msg);
1603 if (m->maplore) 1548 if (m->maplore)
1604 FREE_AND_CLEAR (m->maplore); 1549 FREE_AND_CLEAR (m->maplore);
1605 if (m->shopitems) 1550
1606 delete[]m->shopitems; 1551 delete [] m->shopitems;
1607 m->shopitems = 0; 1552 m->shopitems = 0;
1553
1608 if (m->shoprace) 1554 if (m->shoprace)
1609 FREE_AND_CLEAR (m->shoprace); 1555 FREE_AND_CLEAR (m->shoprace);
1556
1610 if (m->buttons) 1557 if (m->buttons)
1611 free_objectlinkpt (m->buttons); 1558 free_objectlinkpt (m->buttons);
1559
1612 m->buttons = NULL; 1560 m->buttons = NULL;
1561
1613 for (i = 0; i < 4; i++) 1562 for (i = 0; i < 4; i++)
1614 { 1563 {
1615 if (m->tile_path[i]) 1564 if (m->tile_path[i])
1616 FREE_AND_CLEAR (m->tile_path[i]); 1565 FREE_AND_CLEAR (m->tile_path[i]);
1617 m->tile_map[i] = NULL; 1566 m->tile_map[i] = NULL;
1618 } 1567 }
1568
1619 m->in_memory = MAP_SWAPPED; 1569 m->in_memory = MAP_SWAPPED;
1570
1571#undef FREE_AND_CLEAR
1572
1620} 1573}
1621 1574
1622/* 1575/*
1623 * function: vanish mapstruct 1576 * function: vanish maptile
1624 * m : pointer to mapstruct, if NULL no action 1577 * m : pointer to maptile, if NULL no action
1625 * this deletes all the data on the map (freeing pointers) 1578 * this deletes all the data on the map (freeing pointers)
1626 * and then removes this map from the global linked list of maps. 1579 * and then removes this map from the global linked list of maps.
1627 */ 1580 */
1628 1581
1629void 1582void
1630delete_map (mapstruct *m) 1583delete_map (maptile *m)
1631{ 1584{
1632 mapstruct *tmp, *last; 1585 maptile *tmp, *last;
1633 int i; 1586 int i;
1634 1587
1635 if (!m) 1588 if (!m)
1636 return; 1589 return;
1637 1590
… …
1684 else 1637 else
1685 last->next = m->next; 1638 last->next = m->next;
1686 1639
1687 delete m; 1640 delete m;
1688} 1641}
1689
1690
1691 1642
1692/* 1643/*
1693 * Makes sure the given map is loaded and swapped in. 1644 * Makes sure the given map is loaded and swapped in.
1694 * name is path name of the map. 1645 * name is path name of the map.
1695 * flags meaning: 1646 * flags meaning:
… …
1698 * 0x2 (MAP_PLAYER_UNIQUE) - this is a unique map for each player. 1649 * 0x2 (MAP_PLAYER_UNIQUE) - this is a unique map for each player.
1699 * dont do any more name translation on it. 1650 * dont do any more name translation on it.
1700 * 1651 *
1701 * Returns a pointer to the given map. 1652 * Returns a pointer to the given map.
1702 */ 1653 */
1703 1654maptile *
1704mapstruct *
1705ready_map_name (const char *name, int flags) 1655ready_map_name (const char *name, int flags)
1706{ 1656{
1707 mapstruct *m; 1657 maptile *m;
1708 1658
1709 if (!name) 1659 if (!name)
1710 return (NULL); 1660 return (NULL);
1711 1661
1712 /* Have we been at this level before? */ 1662 /* Have we been at this level before? */
… …
1814 * have a difficulty set than using this function - human calculation 1764 * have a difficulty set than using this function - human calculation
1815 * is much better than this functions guesswork. 1765 * is much better than this functions guesswork.
1816 */ 1766 */
1817 1767
1818int 1768int
1819calculate_difficulty (mapstruct *m) 1769calculate_difficulty (maptile *m)
1820{ 1770{
1821 object *op; 1771 object *op;
1822 archetype *at; 1772 archetype *at;
1823 int x, y, i; 1773 int x, y, i;
1824 long monster_cnt = 0; 1774 long monster_cnt = 0;
… …
1866 1816
1867 return 1; 1817 return 1;
1868} 1818}
1869 1819
1870void 1820void
1871clean_tmp_map (mapstruct *m) 1821clean_tmp_map (maptile *m)
1872{ 1822{
1873 if (m->tmpname == NULL) 1823 if (m->tmpname == NULL)
1874 return; 1824 return;
1875 INVOKE_MAP (CLEAN, m); 1825 INVOKE_MAP (CLEAN, m);
1876 (void) unlink (m->tmpname); 1826 (void) unlink (m->tmpname);
… …
1901 * to maps than los. 1851 * to maps than los.
1902 * postive values make it darker, negative make it brighter 1852 * postive values make it darker, negative make it brighter
1903 */ 1853 */
1904 1854
1905int 1855int
1906change_map_light (mapstruct *m, int change) 1856change_map_light (maptile *m, int change)
1907{ 1857{
1908 int new_level = m->darkness + change; 1858 int new_level = m->darkness + change;
1909 1859
1910 /* Nothing to do */ 1860 /* Nothing to do */
1911 if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS)) 1861 if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS))
… …
1942 * on the map (what it looks like, whether it blocks magic, 1892 * on the map (what it looks like, whether it blocks magic,
1943 * has a living creatures, prevents people from passing 1893 * has a living creatures, prevents people from passing
1944 * through, etc) 1894 * through, etc)
1945 */ 1895 */
1946void 1896void
1947update_position (mapstruct *m, int x, int y) 1897update_position (maptile *m, int x, int y)
1948{ 1898{
1949 object *tmp, *last = NULL; 1899 object *tmp, *last = NULL;
1950 uint8 flags = 0, oldflags, light = 0, anywhere = 0; 1900 uint8 flags = 0, oldflags, light = 0, anywhere = 0;
1951 New_Face *top, *floor, *middle; 1901 New_Face *top, *floor, *middle;
1952 object *top_obj, *floor_obj, *middle_obj; 1902 object *top_obj, *floor_obj, *middle_obj;
… …
2145 SET_MAP_LIGHT (m, x, y, light); 2095 SET_MAP_LIGHT (m, x, y, light);
2146} 2096}
2147 2097
2148 2098
2149void 2099void
2150set_map_reset_time (mapstruct *map) 2100set_map_reset_time (maptile *map)
2151{ 2101{
2152 int timeout; 2102 int timeout;
2153 2103
2154 timeout = MAP_RESET_TIMEOUT (map); 2104 timeout = MAP_RESET_TIMEOUT (map);
2155 if (timeout <= 0) 2105 if (timeout <= 0)
2156 timeout = MAP_DEFAULTRESET; 2106 timeout = MAP_DEFAULTRESET;
2157 if (timeout >= MAP_MAXRESET) 2107 if (timeout >= MAP_MAXRESET)
2158 timeout = MAP_MAXRESET; 2108 timeout = MAP_MAXRESET;
2159 MAP_WHEN_RESET (map) = seconds () + timeout; 2109 MAP_WHEN_RESET (map) = time (0) + timeout;
2160} 2110}
2161 2111
2162/* this updates the orig_map->tile_map[tile_num] value after loading 2112/* 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 2113 * 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 2114 * 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 2115 * 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. 2116 * so that it is easier for calling functions to verify success.
2167 */ 2117 */
2168 2118
2169static mapstruct * 2119static maptile *
2170load_and_link_tiled_map (mapstruct *orig_map, int tile_num) 2120load_and_link_tiled_map (maptile *orig_map, int tile_num)
2171{ 2121{
2172 int dest_tile = (tile_num + 2) % 4; 2122 int dest_tile = (tile_num + 2) % 4;
2173 char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]); 2123 char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]);
2174 2124
2175 orig_map->tile_map[tile_num] = ready_map_name (path, 0); 2125 orig_map->tile_map[tile_num] = ready_map_name (path, 0);
… …
2190 * tiled maps. 2140 * tiled maps.
2191 * 2141 *
2192 * 2142 *
2193 */ 2143 */
2194int 2144int
2195out_of_map (mapstruct *m, int x, int y) 2145out_of_map (maptile *m, int x, int y)
2196{ 2146{
2197 2147
2198 /* If we get passed a null map, this is obviously the 2148 /* If we get passed a null map, this is obviously the
2199 * case. This generally shouldn't happen, but if the 2149 * case. This generally shouldn't happen, but if the
2200 * map loads fail below, it could happen. 2150 * map loads fail below, it could happen.
… …
2255 * the map as that the coordinates are really on, and 2205 * the map as that the coordinates are really on, and
2256 * updates x and y to be the localized coordinates. 2206 * updates x and y to be the localized coordinates.
2257 * Using this is more efficient of calling out_of_map 2207 * Using this is more efficient of calling out_of_map
2258 * and then figuring out what the real map is 2208 * and then figuring out what the real map is
2259 */ 2209 */
2260mapstruct * 2210maptile *
2261get_map_from_coord (mapstruct *m, sint16 * x, sint16 * y) 2211get_map_from_coord (maptile *m, sint16 * x, sint16 * y)
2262{ 2212{
2263 2213
2264 if (*x < 0) 2214 if (*x < 0)
2265 { 2215 {
2266 if (!m->tile_path[3]) 2216 if (!m->tile_path[3])
… …
2312/** 2262/**
2313 * Return whether map2 is adjacent to map1. If so, store the distance from 2263 * Return whether map2 is adjacent to map1. If so, store the distance from
2314 * map1 to map2 in dx/dy. 2264 * map1 to map2 in dx/dy.
2315 */ 2265 */
2316static int 2266static int
2317adjacent_map (const mapstruct *map1, const mapstruct *map2, int *dx, int *dy) 2267adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy)
2318{ 2268{
2319 if (!map1 || !map2) 2269 if (!map1 || !map2)
2320 return 0; 2270 return 0;
2321 2271
2322 if (map1 == map2) 2272 if (map1 == map2)
… …
2480 * for something in the future. Also, since no object is pasted, the best 2430 * for something in the future. Also, since no object is pasted, the best
2481 * field of the rv_vector is set to NULL. 2431 * field of the rv_vector is set to NULL.
2482 */ 2432 */
2483 2433
2484void 2434void
2485get_rangevector_from_mapcoord (const mapstruct *m, int x, int y, const object *op2, rv_vector * retval, int flags) 2435get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector * retval, int flags)
2486{ 2436{
2487 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y)) 2437 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
2488 { 2438 {
2489 /* be conservative and fill in _some_ data */ 2439 /* be conservative and fill in _some_ data */
2490 retval->distance = 100000; 2440 retval->distance = 100000;

Diff Legend

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