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.41 by root, Tue Dec 12 22:37:05 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 33
42extern int nrofallocobjects, nroffreeobjects;
43
44/* 34/*
45 * Returns the mapstruct which has a name matching the given argument. 35 * Returns the maptile which has a name matching the given argument.
46 * return NULL if no match is found. 36 * return NULL if no match is found.
47 */ 37 */
48 38
49mapstruct * 39maptile *
50has_been_loaded (const char *name) 40has_been_loaded (const char *name)
51{ 41{
52 mapstruct *map; 42 maptile *map;
53 43
54 if (!name || !*name) 44 if (!name || !*name)
55 return 0; 45 return 0;
56 for (map = first_map; map; map = map->next) 46 for (map = first_map; map; map = map->next)
57 if (!strcmp (name, map->path)) 47 if (!strcmp (name, map->path))
… …
165int 155int
166check_path (const char *name, int prepend_dir) 156check_path (const char *name, int prepend_dir)
167{ 157{
168 char buf[MAX_BUF]; 158 char buf[MAX_BUF];
169 159
170#ifndef WIN32
171 char *endbuf; 160 char *endbuf;
172 struct stat statbuf; 161 struct stat statbuf;
173 int mode = 0; 162 int mode = 0;
174#endif
175 163
176 if (prepend_dir) 164 if (prepend_dir)
177 strcpy (buf, create_pathname (name)); 165 strcpy (buf, create_pathname (name));
178 else 166 else
179 strcpy (buf, name); 167 strcpy (buf, name);
180#ifdef WIN32 /* ***win32: check this sucker in windows style. */
181 return (_access (buf, 0));
182#else
183 168
184 /* old method (strchr(buf, '\0')) seemd very odd to me - 169 /* old method (strchr(buf, '\0')) seemd very odd to me -
185 * this method should be equivalant and is clearer. 170 * this method should be equivalant and is clearer.
186 * Can not use strcat because we need to cycle through 171 * Can not use strcat because we need to cycle through
187 * all the names. 172 * all the names.
… …
200 if ((statbuf.st_mode & S_IWGRP && getegid () == statbuf.st_gid) || 185 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)) 186 (statbuf.st_mode & S_IWUSR && geteuid () == statbuf.st_uid) || (statbuf.st_mode & S_IWOTH))
202 mode |= 2; 187 mode |= 2;
203 188
204 return (mode); 189 return (mode);
205#endif
206} 190}
207 191
208/* 192/*
209 * Prints out debug-information about a map. 193 * Prints out debug-information about a map.
210 * Dumping these at llevError doesn't seem right, but is 194 * Dumping these at llevError doesn't seem right, but is
211 * necessary to make sure the information is in fact logged. 195 * necessary to make sure the information is in fact logged.
212 */ 196 */
213 197
214void 198void
215dump_map (const mapstruct *m) 199dump_map (const maptile *m)
216{ 200{
217 LOG (llevError, "Map %s status: %d.\n", m->path, m->in_memory); 201 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)); 202 LOG (llevError, "Size: %dx%d Start: %d,%d\n", MAP_WIDTH (m), MAP_HEIGHT (m), MAP_ENTER_X (m), MAP_ENTER_Y (m));
219 203
220 if (m->msg != NULL) 204 if (m->msg != NULL)
… …
237 */ 221 */
238 222
239void 223void
240dump_all_maps (void) 224dump_all_maps (void)
241{ 225{
242 mapstruct *m; 226 maptile *m;
243 227
244 for (m = first_map; m != NULL; m = m->next) 228 for (m = first_map; m != NULL; m = m->next)
245 { 229 {
246 dump_map (m); 230 dump_map (m);
247 } 231 }
… …
256 * is needed. The case of not passing values is if we're just 240 * is needed. The case of not passing values is if we're just
257 * checking for the existence of something on those spaces, but 241 * checking for the existence of something on those spaces, but
258 * don't expect to insert/remove anything from those spaces. 242 * don't expect to insert/remove anything from those spaces.
259 */ 243 */
260int 244int
261get_map_flags (mapstruct *oldmap, mapstruct **newmap, sint16 x, sint16 y, sint16 * nx, sint16 * ny) 245get_map_flags (maptile *oldmap, maptile **newmap, sint16 x, sint16 y, sint16 * nx, sint16 * ny)
262{ 246{
263 sint16 newx, newy; 247 sint16 newx, newy;
264 int retval = 0; 248 int retval = 0;
265 mapstruct *mp; 249 maptile *mp;
266 250
267 if (out_of_map (oldmap, x, y)) 251 if (out_of_map (oldmap, x, y))
268 return P_OUT_OF_MAP; 252 return P_OUT_OF_MAP;
269 newx = x; 253 newx = x;
270 newy = y; 254 newy = y;
… …
281 retval |= mp->spaces[newx + mp->width * newy].flags; 265 retval |= mp->spaces[newx + mp->width * newy].flags;
282 266
283 return retval; 267 return retval;
284} 268}
285 269
286
287/* 270/*
288 * Returns true if the given coordinate is blocked except by the 271 * Returns true if the given coordinate is blocked except by the
289 * object passed is not blocking. This is used with 272 * object passed is not blocking. This is used with
290 * multipart monsters - if we want to see if a 2x2 monster 273 * 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 274 * can move 1 space to the left, we don't want its own area
… …
294 * monster. 277 * monster.
295 * m, x, y are the target map/coordinates - needed for map tiling. 278 * m, x, y are the target map/coordinates - needed for map tiling.
296 * the coordinates & map passed in should have been updated for tiling 279 * the coordinates & map passed in should have been updated for tiling
297 * by the caller. 280 * by the caller.
298 */ 281 */
299
300int 282int
301blocked_link (object *ob, mapstruct *m, int sx, int sy) 283blocked_link (object *ob, maptile *m, int sx, int sy)
302{ 284{
303 object *tmp; 285 object *tmp;
304 int mflags, blocked; 286 int mflags, blocked;
305 287
306 /* Make sure the coordinates are valid - they should be, as caller should 288 /* 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 400 * code, we need to have actual object to check its move_type
419 * against the move_block values. 401 * against the move_block values.
420 */ 402 */
421 403
422int 404int
423ob_blocked (const object *ob, mapstruct *m, sint16 x, sint16 y) 405ob_blocked (const object *ob, maptile *m, sint16 x, sint16 y)
424{ 406{
425 archetype *tmp; 407 archetype *tmp;
426 int flag; 408 int flag;
427 mapstruct *m1; 409 maptile *m1;
428 sint16 sx, sy; 410 sint16 sx, sy;
429 411
430 if (ob == NULL) 412 if (ob == NULL)
431 { 413 {
432 flag = get_map_flags (m, &m1, x, y, &sx, &sy); 414 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 479 * 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. 480 * the more sections and not re-add sections for them.
499 */ 481 */
500 482
501static void 483static void
502link_multipart_objects (mapstruct *m) 484link_multipart_objects (maptile *m)
503{ 485{
504 int x, y; 486 int x, y;
505 object *tmp, *op, *last, *above; 487 object *tmp, *op, *last, *above;
506 archetype *at; 488 archetype *at;
507 489
… …
544 * Loads (ands parses) the objects into a given map from the specified 526 * Loads (ands parses) the objects into a given map from the specified
545 * file pointer. 527 * file pointer.
546 * mapflags is the same as we get with load_original_map 528 * mapflags is the same as we get with load_original_map
547 */ 529 */
548void 530void
549load_objects (mapstruct *m, object_thawer & fp, int mapflags) 531load_objects (maptile *m, object_thawer & fp, int mapflags)
550{ 532{
551 int i, j; 533 int i, j;
552 int unique; 534 int unique;
553 object *op, *prev = NULL, *last_more = NULL, *otmp; 535 object *op, *prev = NULL, *last_more = NULL, *otmp;
554 536
555 op = get_object (); 537 op = object::create ();
556 op->map = m; /* To handle buttons correctly */ 538 op->map = m; /* To handle buttons correctly */
557 539
558 while ((i = load_object (fp, op, mapflags))) 540 while ((i = load_object (fp, op, mapflags)))
559 { 541 {
560 /* if the archetype for the object is null, means that we 542 /* if the archetype for the object is null, means that we
… …
568 } 550 }
569 551
570 552
571 switch (i) 553 switch (i)
572 { 554 {
573 case LL_NORMAL: 555 case LL_NORMAL:
574 /* if we are loading an overlay, put the floors on the bottom */ 556 /* 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) 557 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); 558 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY | INS_MAP_LOAD);
577 else 559 else
578 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD); 560 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD);
579 561
580 if (op->inv) 562 if (op->inv)
581 sum_weight (op); 563 sum_weight (op);
582 564
583 prev = op, last_more = op; 565 prev = op, last_more = op;
584 break; 566 break;
585 567
586 case LL_MORE: 568 case LL_MORE:
587 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY); 569 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; 570 op->head = prev, last_more->more = op, last_more = op;
589 break; 571 break;
590 } 572 }
591 573
592 if (mapflags & MAP_STYLE) 574 if (mapflags & MAP_STYLE)
593 remove_from_active_list (op); 575 remove_from_active_list (op);
594 576
595 op = get_object (); 577 op = object::create ();
596 op->map = m; 578 op->map = m;
597 } 579 }
598 580
599 for (i = 0; i < m->width; i++) 581 for (i = 0; i < m->width; i++)
600 { 582 {
… …
604 /* check for unique items, or unique squares */ 586 /* check for unique items, or unique squares */
605 for (otmp = get_map_ob (m, i, j); otmp; otmp = otmp->above) 587 for (otmp = get_map_ob (m, i, j); otmp; otmp = otmp->above)
606 { 588 {
607 if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL)) 589 if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL))
608 unique = 1; 590 unique = 1;
591
609 if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique)) 592 if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique))
610 SET_FLAG (otmp, FLAG_OBJ_ORIGINAL); 593 SET_FLAG (otmp, FLAG_OBJ_ORIGINAL);
611 } 594 }
612 } 595 }
613 } 596 }
614 597
615 free_object (op); 598 op->destroy ();
616 link_multipart_objects (m); 599 link_multipart_objects (m);
617} 600}
618 601
619/* This saves all the objects on the map in a non destructive fashion. 602/* 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, 603 * 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 604 * and we only save the head of multi part objects - this is needed
622 * in order to do map tiling properly. 605 * in order to do map tiling properly.
623 */ 606 */
624void 607void
625save_objects (mapstruct *m, object_freezer & fp, object_freezer & fp2, int flag) 608save_objects (maptile *m, object_freezer & fp, object_freezer & fp2, int flag)
626{ 609{
627 int i, j = 0, unique = 0; 610 int i, j = 0, unique = 0;
628 object *op; 611 object *op;
629 612
630 /* first pass - save one-part objects */ 613 /* first pass - save one-part objects */
… …
653 636
654 } /* for this space */ 637 } /* for this space */
655 } /* for this j */ 638 } /* for this j */
656} 639}
657 640
641maptile::maptile ()
642{
643 in_memory = MAP_SWAPPED;
644 /* The maps used to pick up default x and y values from the
645 * map archetype. Mimic that behaviour.
646 */
647 MAP_WIDTH (this) = 16;
648 MAP_HEIGHT (this) = 16;
649 MAP_RESET_TIMEOUT (this) = 0;
650 MAP_TIMEOUT (this) = 300;
651 MAP_ENTER_X (this) = 0;
652 MAP_ENTER_Y (this) = 0;
653 /*set part to -1 indicating conversion to weather map not yet done */
654 MAP_WORLDPARTX (this) = -1;
655 MAP_WORLDPARTY (this) = -1;
656}
657
658/* 658/*
659 * Allocates, initialises, and returns a pointer to a mapstruct. 659 * Allocates, initialises, and returns a pointer to a maptile.
660 * Modified to no longer take a path option which was not being 660 * Modified to no longer take a path option which was not being
661 * used anyways. MSW 2001-07-01 661 * used anyways. MSW 2001-07-01
662 */ 662 */
663 663maptile *
664mapstruct *
665get_linked_map (void) 664get_linked_map (void)
666{ 665{
667 mapstruct *map = new mapstruct; 666 maptile *mp, *map = new maptile;
668 mapstruct *mp;
669 667
670 for (mp = first_map; mp != NULL && mp->next != NULL; mp = mp->next); 668 for (mp = first_map; mp && mp->next; mp = mp->next);
669
671 if (mp == NULL) 670 if (mp == NULL)
672 first_map = map; 671 first_map = map;
673 else 672 else
674 mp->next = map; 673 mp->next = map;
675 674
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; 675 return map;
690} 676}
691 677
692/* 678/*
693 * Allocates the arrays contained in a mapstruct. 679 * Allocates the arrays contained in a maptile.
694 * This basically allocates the dynamic array of spaces for the 680 * This basically allocates the dynamic array of spaces for the
695 * map. 681 * map.
696 */ 682 */
697
698void 683void
699allocate_map (mapstruct *m) 684maptile::allocate ()
700{ 685{
701 m->in_memory = MAP_IN_MEMORY; 686 in_memory = MAP_IN_MEMORY;
687
702 /* Log this condition and free the storage. We could I suppose 688 /* Log this condition and free the storage. We could I suppose
703 * realloc, but if the caller is presuming the data will be intact, 689 * realloc, but if the caller is presuming the data will be intact,
704 * that is their poor assumption. 690 * that is their poor assumption.
705 */ 691 */
706 if (m->spaces) 692 if (spaces)
707 { 693 {
708 LOG (llevError, "allocate_map called with already allocated map (%s)\n", m->path); 694 LOG (llevError, "allocate_map called with already allocated map (%s)\n", path);
709 free (m->spaces); 695 free (spaces);
710 } 696 }
711 697
712 m->spaces = (MapSpace *) calloc (1, MAP_WIDTH (m) * MAP_HEIGHT (m) * sizeof (MapSpace)); 698 spaces = (MapSpace *)
699 calloc (1, width * height * sizeof (MapSpace));
713 700
714 if (m->spaces == NULL) 701 if (!spaces)
715 fatal (OUT_OF_MEMORY); 702 fatal (OUT_OF_MEMORY);
716} 703}
717 704
718/* Create and returns a map of the specific size. Used 705/* Create and returns a map of the specific size. Used
719 * in random map code and the editor. 706 * in random map code and the editor.
720 */ 707 */
721mapstruct * 708maptile *
722get_empty_map (int sizex, int sizey) 709get_empty_map (int sizex, int sizey)
723{ 710{
724 mapstruct *m = get_linked_map (); 711 maptile *m = get_linked_map ();
725 712
726 m->width = sizex; 713 m->width = sizex;
727 m->height = sizey; 714 m->height = sizey;
728 m->in_memory = MAP_SWAPPED; 715 m->in_memory = MAP_SWAPPED;
729 allocate_map (m); 716 m->allocate ();
717
730 return m; 718 return m;
731} 719}
732 720
733/* Takes a string from a map definition and outputs a pointer to the array of shopitems 721/* 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 722 * corresponding to that string. Memory is allocated for this, it must be freed
… …
811} 799}
812 800
813/* opposite of parse string, this puts the string that was originally fed in to 801/* opposite of parse string, this puts the string that was originally fed in to
814 * the map (or something equivilent) into output_string. */ 802 * the map (or something equivilent) into output_string. */
815static void 803static void
816print_shop_string (mapstruct *m, char *output_string) 804print_shop_string (maptile *m, char *output_string)
817{ 805{
818 int i; 806 int i;
819 char tmp[MAX_BUF]; 807 char tmp[MAX_BUF];
820 808
821 strcpy (output_string, ""); 809 strcpy (output_string, "");
… …
855 * MSW 2001-07-01 843 * MSW 2001-07-01
856 * return 0 on success, 1 on failure. 844 * return 0 on success, 1 on failure.
857 */ 845 */
858 846
859static int 847static int
860load_map_header (object_thawer & fp, mapstruct *m) 848load_map_header (object_thawer & fp, maptile *m)
861{ 849{
862 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end; 850 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end;
863 int msgpos = 0; 851 int msgpos = 0;
864 int maplorepos = 0; 852 int maplorepos = 0;
865 853
866 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 854 while (fgets (buf, HUGE_BUF, fp) != NULL)
867 { 855 {
868 buf[HUGE_BUF - 1] = 0; 856 buf[HUGE_BUF - 1] = 0;
869 key = buf; 857 key = buf;
858
870 while (isspace (*key)) 859 while (isspace (*key))
871 key++; 860 key++;
861
872 if (*key == 0) 862 if (*key == 0)
873 continue; /* empty line */ 863 continue; /* empty line */
864
874 value = strchr (key, ' '); 865 value = strchr (key, ' ');
866
875 if (!value) 867 if (!value)
876 { 868 {
877 end = strchr (key, '\n'); 869 if ((end = strchr (key, '\n')))
878 if (end != NULL)
879 {
880 *end = 0; 870 *end = 0;
881 }
882 } 871 }
883 else 872 else
884 { 873 {
885 *value = 0; 874 *value = 0;
886 value++; 875 value++;
887 end = strchr (value, '\n'); 876 end = strchr (value, '\n');
877
888 while (isspace (*value)) 878 while (isspace (*value))
889 { 879 {
890 value++; 880 value++;
881
891 if (*value == '\0' || value == end) 882 if (*value == '\0' || value == end)
892 { 883 {
893 /* Nothing but spaces. */ 884 /* Nothing but spaces. */
894 value = NULL; 885 value = NULL;
895 break; 886 break;
… …
918 * that use the parameter. 909 * that use the parameter.
919 */ 910 */
920 911
921 if (!strcmp (key, "msg")) 912 if (!strcmp (key, "msg"))
922 { 913 {
923 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 914 while (fgets (buf, HUGE_BUF, fp) != NULL)
924 { 915 {
925 if (!strcmp (buf, "endmsg\n")) 916 if (!strcmp (buf, "endmsg\n"))
926 break; 917 break;
927 else 918 else
928 { 919 {
… …
939 if (msgpos != 0) 930 if (msgpos != 0)
940 m->msg = strdup_local (msgbuf); 931 m->msg = strdup_local (msgbuf);
941 } 932 }
942 else if (!strcmp (key, "maplore")) 933 else if (!strcmp (key, "maplore"))
943 { 934 {
944 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 935 while (fgets (buf, HUGE_BUF, fp) != NULL)
945 { 936 {
946 if (!strcmp (buf, "endmaplore\n")) 937 if (!strcmp (buf, "endmaplore\n"))
947 break; 938 break;
948 else 939 else
949 { 940 {
… …
977 /* first strcmp value on these are old names supported 968 /* first strcmp value on these are old names supported
978 * for compatibility reasons. The new values (second) are 969 * for compatibility reasons. The new values (second) are
979 * what really should be used. 970 * what really should be used.
980 */ 971 */
981 else if (!strcmp (key, "oid")) 972 else if (!strcmp (key, "oid"))
982 {
983 fp.get (m, atoi (value)); 973 fp.get (m, atoi (value));
984 }
985 else if (!strcmp (key, "attach")) 974 else if (!strcmp (key, "attach"))
986 {
987 m->attach = value; 975 m->attach = value;
988 }
989 else if (!strcmp (key, "hp") || !strcmp (key, "enter_x")) 976 else if (!strcmp (key, "hp") || !strcmp (key, "enter_x"))
990 {
991 m->enter_x = atoi (value); 977 m->enter_x = atoi (value);
992 }
993 else if (!strcmp (key, "sp") || !strcmp (key, "enter_y")) 978 else if (!strcmp (key, "sp") || !strcmp (key, "enter_y"))
994 {
995 m->enter_y = atoi (value); 979 m->enter_y = atoi (value);
996 }
997 else if (!strcmp (key, "x") || !strcmp (key, "width")) 980 else if (!strcmp (key, "x") || !strcmp (key, "width"))
998 {
999 m->width = atoi (value); 981 m->width = atoi (value);
1000 }
1001 else if (!strcmp (key, "y") || !strcmp (key, "height")) 982 else if (!strcmp (key, "y") || !strcmp (key, "height"))
1002 {
1003 m->height = atoi (value); 983 m->height = atoi (value);
1004 }
1005 else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout")) 984 else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout"))
1006 {
1007 m->reset_timeout = atoi (value); 985 m->reset_timeout = atoi (value);
1008 }
1009 else if (!strcmp (key, "value") || !strcmp (key, "swap_time")) 986 else if (!strcmp (key, "value") || !strcmp (key, "swap_time"))
1010 {
1011 m->timeout = atoi (value); 987 m->timeout = atoi (value);
1012 }
1013 else if (!strcmp (key, "level") || !strcmp (key, "difficulty")) 988 else if (!strcmp (key, "level") || !strcmp (key, "difficulty"))
1014 { 989 m->difficulty = clamp (atoi (value), 1, settings.max_level);
1015 m->difficulty = atoi (value);
1016 }
1017 else if (!strcmp (key, "invisible") || !strcmp (key, "darkness")) 990 else if (!strcmp (key, "invisible") || !strcmp (key, "darkness"))
1018 {
1019 m->darkness = atoi (value); 991 m->darkness = atoi (value);
1020 }
1021 else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime")) 992 else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime"))
1022 {
1023 m->fixed_resettime = atoi (value); 993 m->fixed_resettime = atoi (value);
1024 }
1025 else if (!strcmp (key, "unique")) 994 else if (!strcmp (key, "unique"))
1026 {
1027 m->unique = atoi (value); 995 m->unique = atoi (value);
1028 }
1029 else if (!strcmp (key, "template")) 996 else if (!strcmp (key, "template"))
1030 {
1031 m->templatemap = atoi (value); 997 m->templatemap = atoi (value);
1032 }
1033 else if (!strcmp (key, "region")) 998 else if (!strcmp (key, "region"))
1034 {
1035 m->region = get_region_by_name (value); 999 m->region = get_region_by_name (value);
1036 }
1037 else if (!strcmp (key, "shopitems")) 1000 else if (!strcmp (key, "shopitems"))
1038 { 1001 {
1039 *end = 0; 1002 *end = 0;
1040 m->shopitems = parse_shop_string (value); 1003 m->shopitems = parse_shop_string (value);
1041 } 1004 }
1042 else if (!strcmp (key, "shopgreed")) 1005 else if (!strcmp (key, "shopgreed"))
1043 {
1044 m->shopgreed = atof (value); 1006 m->shopgreed = atof (value);
1045 }
1046 else if (!strcmp (key, "shopmin")) 1007 else if (!strcmp (key, "shopmin"))
1047 {
1048 m->shopmin = atol (value); 1008 m->shopmin = atol (value);
1049 }
1050 else if (!strcmp (key, "shopmax")) 1009 else if (!strcmp (key, "shopmax"))
1051 {
1052 m->shopmax = atol (value); 1010 m->shopmax = atol (value);
1053 }
1054 else if (!strcmp (key, "shoprace")) 1011 else if (!strcmp (key, "shoprace"))
1055 { 1012 {
1056 *end = 0; 1013 *end = 0;
1057 m->shoprace = strdup_local (value); 1014 m->shoprace = strdup_local (value);
1058 } 1015 }
1059 else if (!strcmp (key, "outdoor")) 1016 else if (!strcmp (key, "outdoor"))
1060 {
1061 m->outdoor = atoi (value); 1017 m->outdoor = atoi (value);
1062 }
1063 else if (!strcmp (key, "temp")) 1018 else if (!strcmp (key, "temp"))
1064 {
1065 m->temp = atoi (value); 1019 m->temp = atoi (value);
1066 }
1067 else if (!strcmp (key, "pressure")) 1020 else if (!strcmp (key, "pressure"))
1068 {
1069 m->pressure = atoi (value); 1021 m->pressure = atoi (value);
1070 }
1071 else if (!strcmp (key, "humid")) 1022 else if (!strcmp (key, "humid"))
1072 {
1073 m->humid = atoi (value); 1023 m->humid = atoi (value);
1074 }
1075 else if (!strcmp (key, "windspeed")) 1024 else if (!strcmp (key, "windspeed"))
1076 {
1077 m->windspeed = atoi (value); 1025 m->windspeed = atoi (value);
1078 }
1079 else if (!strcmp (key, "winddir")) 1026 else if (!strcmp (key, "winddir"))
1080 {
1081 m->winddir = atoi (value); 1027 m->winddir = atoi (value);
1082 }
1083 else if (!strcmp (key, "sky")) 1028 else if (!strcmp (key, "sky"))
1084 {
1085 m->sky = atoi (value); 1029 m->sky = atoi (value);
1086 }
1087 else if (!strcmp (key, "nosmooth")) 1030 else if (!strcmp (key, "nosmooth"))
1088 {
1089 m->nosmooth = atoi (value); 1031 m->nosmooth = atoi (value);
1090 }
1091 else if (!strncmp (key, "tile_path_", 10)) 1032 else if (!strncmp (key, "tile_path_", 10))
1092 { 1033 {
1093 int tile = atoi (key + 10); 1034 int tile = atoi (key + 10);
1094 1035
1095 if (tile < 1 || tile > 4) 1036 if (tile < 1 || tile > 4)
… …
1138 m->tile_path[tile - 1] = strdup_local (path); 1079 m->tile_path[tile - 1] = strdup_local (path);
1139 } 1080 }
1140 } /* end if tile direction (in)valid */ 1081 } /* end if tile direction (in)valid */
1141 } 1082 }
1142 else 1083 else
1143 {
1144 LOG (llevError, "Got unknown value in map header: %s %s\n", key, value); 1084 LOG (llevError, "Got unknown value in map header: %s %s\n", key, value);
1145 }
1146 } 1085 }
1086
1147 if (!key || strcmp (key, "end")) 1087 if (!key || strcmp (key, "end"))
1148 { 1088 {
1149 LOG (llevError, "Got premature eof on map header!\n"); 1089 LOG (llevError, "Got premature eof on map header!\n");
1150 return 1; 1090 return 1;
1151 } 1091 }
1092
1152 return 0; 1093 return 0;
1153} 1094}
1154 1095
1155/* 1096/*
1156 * Opens the file "filename" and reads information about the map 1097 * Opens the file "filename" and reads information about the map
1157 * from the given file, and stores it in a newly allocated 1098 * from the given file, and stores it in a newly allocated
1158 * mapstruct. A pointer to this structure is returned, or NULL on failure. 1099 * maptile. A pointer to this structure is returned, or NULL on failure.
1159 * flags correspond to those in map.h. Main ones used are 1100 * 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 1101 * 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 1102 * 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. 1103 * 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 1104 * MAP_STYLE: style map - don't add active objects, don't add to server
1164 * managed map list. 1105 * managed map list.
1165 */ 1106 */
1166 1107
1167mapstruct * 1108maptile *
1168load_original_map (const char *filename, int flags) 1109load_original_map (const char *filename, int flags)
1169{ 1110{
1170 mapstruct *m; 1111 maptile *m;
1171 char pathname[MAX_BUF]; 1112 char pathname[MAX_BUF];
1172 1113
1173 if (flags & MAP_PLAYER_UNIQUE) 1114 if (flags & MAP_PLAYER_UNIQUE)
1174 strcpy (pathname, filename); 1115 strcpy (pathname, filename);
1175 else if (flags & MAP_OVERLAY) 1116 else if (flags & MAP_OVERLAY)
… …
1192 LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags); 1133 LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags);
1193 delete_map (m); 1134 delete_map (m);
1194 return NULL; 1135 return NULL;
1195 } 1136 }
1196 1137
1197 allocate_map (m); 1138 m->allocate ();
1198 1139
1199 m->in_memory = MAP_LOADING; 1140 m->in_memory = MAP_LOADING;
1200 load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE)); 1141 load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE));
1201 1142
1202 m->in_memory = MAP_IN_MEMORY; 1143 m->in_memory = MAP_IN_MEMORY;
… …
1211 * Loads a map, which has been loaded earlier, from file. 1152 * Loads a map, which has been loaded earlier, from file.
1212 * Return the map object we load into (this can change from the passed 1153 * Return the map object we load into (this can change from the passed
1213 * option if we can't find the original map) 1154 * option if we can't find the original map)
1214 */ 1155 */
1215 1156
1216static mapstruct * 1157static maptile *
1217load_temporary_map (mapstruct *m) 1158load_temporary_map (maptile *m)
1218{ 1159{
1219 char buf[MAX_BUF]; 1160 char buf[MAX_BUF];
1220 1161
1221 if (!m->tmpname) 1162 if (!m->tmpname)
1222 { 1163 {
… …
1248 LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname); 1189 LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname);
1249 delete_map (m); 1190 delete_map (m);
1250 m = load_original_map (m->path, 0); 1191 m = load_original_map (m->path, 0);
1251 return NULL; 1192 return NULL;
1252 } 1193 }
1194
1253 allocate_map (m); 1195 m->allocate ();
1254 1196
1255 m->in_memory = MAP_LOADING; 1197 m->in_memory = MAP_LOADING;
1256 load_objects (m, thawer, 0); 1198 load_objects (m, thawer, 0);
1257 1199
1258 m->in_memory = MAP_IN_MEMORY; 1200 m->in_memory = MAP_IN_MEMORY;
… …
1264 * Loads a map, which has been loaded earlier, from file. 1206 * Loads a map, which has been loaded earlier, from file.
1265 * Return the map object we load into (this can change from the passed 1207 * Return the map object we load into (this can change from the passed
1266 * option if we can't find the original map) 1208 * option if we can't find the original map)
1267 */ 1209 */
1268 1210
1269mapstruct * 1211maptile *
1270load_overlay_map (const char *filename, mapstruct *m) 1212load_overlay_map (const char *filename, maptile *m)
1271{ 1213{
1272 char pathname[MAX_BUF]; 1214 char pathname[MAX_BUF];
1273 1215
1274 strcpy (pathname, create_overlay_pathname (filename)); 1216 strcpy (pathname, create_overlay_pathname (filename));
1275 1217
… …
1283 LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname); 1225 LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname);
1284 delete_map (m); 1226 delete_map (m);
1285 m = load_original_map (m->path, 0); 1227 m = load_original_map (m->path, 0);
1286 return NULL; 1228 return NULL;
1287 } 1229 }
1288 /*allocate_map(m); */ 1230 /*m->allocate ();*/
1289 1231
1290 m->in_memory = MAP_LOADING; 1232 m->in_memory = MAP_LOADING;
1291 load_objects (m, thawer, MAP_OVERLAY); 1233 load_objects (m, thawer, MAP_OVERLAY);
1292 1234
1293 m->in_memory = MAP_IN_MEMORY; 1235 m->in_memory = MAP_IN_MEMORY;
… …
1298 * This is the start of unique map handling code 1240 * This is the start of unique map handling code
1299 *****************************************************************************/ 1241 *****************************************************************************/
1300 1242
1301/* This goes through map 'm' and removed any unique items on the map. */ 1243/* This goes through map 'm' and removed any unique items on the map. */
1302static void 1244static void
1303delete_unique_items (mapstruct *m) 1245delete_unique_items (maptile *m)
1304{ 1246{
1305 int i, j, unique; 1247 int i, j, unique;
1306 object *op, *next; 1248 object *op, *next;
1307 1249
1308 for (i = 0; i < MAP_WIDTH (m); i++) 1250 for (i = 0; i < MAP_WIDTH (m); i++)
1309 for (j = 0; j < MAP_HEIGHT (m); j++) 1251 for (j = 0; j < MAP_HEIGHT (m); j++)
1310 { 1252 {
1311 unique = 0; 1253 unique = 0;
1254
1312 for (op = get_map_ob (m, i, j); op; op = next) 1255 for (op = get_map_ob (m, i, j); op; op = next)
1313 { 1256 {
1314 next = op->above; 1257 next = op->above;
1258
1315 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) 1259 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
1316 unique = 1; 1260 unique = 1;
1261
1317 if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique)) 1262 if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique))
1318 { 1263 {
1319 clean_object (op); 1264 clean_object (op);
1265
1320 if (QUERY_FLAG (op, FLAG_IS_LINKED)) 1266 if (QUERY_FLAG (op, FLAG_IS_LINKED))
1321 remove_button_link (op); 1267 remove_button_link (op);
1322 remove_ob (op); 1268
1323 free_object (op); 1269 op->destroy ();
1324 } 1270 }
1325 } 1271 }
1326 } 1272 }
1327} 1273}
1328 1274
… …
1330/* 1276/*
1331 * Loads unique objects from file(s) into the map which is in memory 1277 * Loads unique objects from file(s) into the map which is in memory
1332 * m is the map to load unique items into. 1278 * m is the map to load unique items into.
1333 */ 1279 */
1334static void 1280static void
1335load_unique_objects (mapstruct *m) 1281load_unique_objects (maptile *m)
1336{ 1282{
1337 int count; 1283 int count;
1338 char firstname[MAX_BUF]; 1284 char firstname[MAX_BUF];
1339 1285
1340 for (count = 0; count < 10; count++) 1286 for (count = 0; count < 10; count++)
… …
1363 1309
1364/* 1310/*
1365 * Saves a map to file. If flag is set, it is saved into the same 1311 * 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 1312 * file it was (originally) loaded from. Otherwise a temporary
1367 * filename will be genarated, and the file will be stored there. 1313 * filename will be genarated, and the file will be stored there.
1368 * The temporary filename will be stored in the mapstructure. 1314 * The temporary filename will be stored in the maptileure.
1369 * If the map is unique, we also save to the filename in the map 1315 * If the map is unique, we also save to the filename in the map
1370 * (this should have been updated when first loaded) 1316 * (this should have been updated when first loaded)
1371 */ 1317 */
1372 1318
1373int 1319int
1374new_save_map (mapstruct *m, int flag) 1320new_save_map (maptile *m, int flag)
1375{ 1321{
1376 char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF]; 1322 char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF];
1377 int i; 1323 int i;
1378 1324
1379 if (flag && !*m->path) 1325 if (flag && !*m->path)
… …
1431 print_shop_string (m, shop); 1377 print_shop_string (m, shop);
1432 fprintf (freezer, "shopitems %s\n", shop); 1378 fprintf (freezer, "shopitems %s\n", shop);
1433 } 1379 }
1434 if (m->shopgreed) 1380 if (m->shopgreed)
1435 fprintf (freezer, "shopgreed %f\n", m->shopgreed); 1381 fprintf (freezer, "shopgreed %f\n", m->shopgreed);
1436#ifndef WIN32
1437 if (m->shopmin) 1382 if (m->shopmin)
1438 fprintf (freezer, "shopmin %llu\n", m->shopmin); 1383 fprintf (freezer, "shopmin %llu\n", m->shopmin);
1439 if (m->shopmax) 1384 if (m->shopmax)
1440 fprintf (freezer, "shopmax %llu\n", m->shopmax); 1385 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) 1386 if (m->shoprace)
1448 fprintf (freezer, "shoprace %s\n", m->shoprace); 1387 fprintf (freezer, "shoprace %s\n", m->shoprace);
1449 if (m->darkness) 1388 if (m->darkness)
1450 fprintf (freezer, "darkness %d\n", m->darkness); 1389 fprintf (freezer, "darkness %d\n", m->darkness);
1451 if (m->width) 1390 if (m->width)
… …
1530 object *tmp, *next; 1469 object *tmp, *next;
1531 1470
1532 for (tmp = op->inv; tmp; tmp = next) 1471 for (tmp = op->inv; tmp; tmp = next)
1533 { 1472 {
1534 next = tmp->below; 1473 next = tmp->below;
1474
1535 clean_object (tmp); 1475 clean_object (tmp);
1536 if (QUERY_FLAG (tmp, FLAG_IS_LINKED)) 1476 if (QUERY_FLAG (tmp, FLAG_IS_LINKED))
1537 remove_button_link (tmp); 1477 remove_button_link (tmp);
1538 remove_ob (tmp); 1478
1539 free_object (tmp); 1479 tmp->destroy ();
1540 } 1480 }
1541} 1481}
1542 1482
1543/* 1483/*
1544 * Remove and free all objects in the given map. 1484 * Remove and free all objects in the given map.
1545 */ 1485 */
1546 1486
1547void 1487void
1548free_all_objects (mapstruct *m) 1488free_all_objects (maptile *m)
1549{ 1489{
1550 int i, j; 1490 int i, j;
1551 object *op; 1491 object *op;
1552 1492
1553 for (i = 0; i < MAP_WIDTH (m); i++) 1493 for (i = 0; i < MAP_WIDTH (m); i++)
… …
1560 if (op == previous_obj) 1500 if (op == previous_obj)
1561 { 1501 {
1562 LOG (llevDebug, "free_all_objects: Link error, bailing out.\n"); 1502 LOG (llevDebug, "free_all_objects: Link error, bailing out.\n");
1563 break; 1503 break;
1564 } 1504 }
1505
1565 previous_obj = op; 1506 previous_obj = op;
1507
1566 if (op->head != NULL) 1508 if (op->head != NULL)
1567 op = op->head; 1509 op = op->head;
1568 1510
1569 /* If the map isn't in memory, free_object will remove and 1511 /* 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. 1512 * free objects in op's inventory. So let it do the job.
1571 */ 1513 */
1572 if (m->in_memory == MAP_IN_MEMORY) 1514 if (m->in_memory == MAP_IN_MEMORY)
1573 clean_object (op); 1515 clean_object (op);
1574 remove_ob (op); 1516
1575 free_object (op); 1517 op->destroy ();
1576 } 1518 }
1577 } 1519 }
1578} 1520}
1579 1521
1580/* 1522/*
1581 * Frees everything allocated by the given mapstructure. 1523 * Frees everything allocated by the given maptileure.
1582 * don't free tmpname - our caller is left to do that 1524 * don't free tmpname - our caller is left to do that
1583 */ 1525 */
1584 1526
1585void 1527void
1586free_map (mapstruct *m, int flag) 1528free_map (maptile *m, int flag)
1587{ 1529{
1588 int i; 1530 int i;
1589 1531
1590 if (!m->in_memory) 1532 if (!m->in_memory)
1591 { 1533 {
… …
1618 } 1560 }
1619 m->in_memory = MAP_SWAPPED; 1561 m->in_memory = MAP_SWAPPED;
1620} 1562}
1621 1563
1622/* 1564/*
1623 * function: vanish mapstruct 1565 * function: vanish maptile
1624 * m : pointer to mapstruct, if NULL no action 1566 * m : pointer to maptile, if NULL no action
1625 * this deletes all the data on the map (freeing pointers) 1567 * this deletes all the data on the map (freeing pointers)
1626 * and then removes this map from the global linked list of maps. 1568 * and then removes this map from the global linked list of maps.
1627 */ 1569 */
1628 1570
1629void 1571void
1630delete_map (mapstruct *m) 1572delete_map (maptile *m)
1631{ 1573{
1632 mapstruct *tmp, *last; 1574 maptile *tmp, *last;
1633 int i; 1575 int i;
1634 1576
1635 if (!m) 1577 if (!m)
1636 return; 1578 return;
1637 1579
… …
1699 * dont do any more name translation on it. 1641 * dont do any more name translation on it.
1700 * 1642 *
1701 * Returns a pointer to the given map. 1643 * Returns a pointer to the given map.
1702 */ 1644 */
1703 1645
1704mapstruct * 1646maptile *
1705ready_map_name (const char *name, int flags) 1647ready_map_name (const char *name, int flags)
1706{ 1648{
1707 mapstruct *m; 1649 maptile *m;
1708 1650
1709 if (!name) 1651 if (!name)
1710 return (NULL); 1652 return (NULL);
1711 1653
1712 /* Have we been at this level before? */ 1654 /* Have we been at this level before? */
… …
1814 * have a difficulty set than using this function - human calculation 1756 * have a difficulty set than using this function - human calculation
1815 * is much better than this functions guesswork. 1757 * is much better than this functions guesswork.
1816 */ 1758 */
1817 1759
1818int 1760int
1819calculate_difficulty (mapstruct *m) 1761calculate_difficulty (maptile *m)
1820{ 1762{
1821 object *op; 1763 object *op;
1822 archetype *at; 1764 archetype *at;
1823 int x, y, i; 1765 int x, y, i;
1824 long monster_cnt = 0; 1766 long monster_cnt = 0;
… …
1866 1808
1867 return 1; 1809 return 1;
1868} 1810}
1869 1811
1870void 1812void
1871clean_tmp_map (mapstruct *m) 1813clean_tmp_map (maptile *m)
1872{ 1814{
1873 if (m->tmpname == NULL) 1815 if (m->tmpname == NULL)
1874 return; 1816 return;
1875 INVOKE_MAP (CLEAN, m); 1817 INVOKE_MAP (CLEAN, m);
1876 (void) unlink (m->tmpname); 1818 (void) unlink (m->tmpname);
… …
1901 * to maps than los. 1843 * to maps than los.
1902 * postive values make it darker, negative make it brighter 1844 * postive values make it darker, negative make it brighter
1903 */ 1845 */
1904 1846
1905int 1847int
1906change_map_light (mapstruct *m, int change) 1848change_map_light (maptile *m, int change)
1907{ 1849{
1908 int new_level = m->darkness + change; 1850 int new_level = m->darkness + change;
1909 1851
1910 /* Nothing to do */ 1852 /* Nothing to do */
1911 if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS)) 1853 if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS))
… …
1942 * on the map (what it looks like, whether it blocks magic, 1884 * on the map (what it looks like, whether it blocks magic,
1943 * has a living creatures, prevents people from passing 1885 * has a living creatures, prevents people from passing
1944 * through, etc) 1886 * through, etc)
1945 */ 1887 */
1946void 1888void
1947update_position (mapstruct *m, int x, int y) 1889update_position (maptile *m, int x, int y)
1948{ 1890{
1949 object *tmp, *last = NULL; 1891 object *tmp, *last = NULL;
1950 uint8 flags = 0, oldflags, light = 0, anywhere = 0; 1892 uint8 flags = 0, oldflags, light = 0, anywhere = 0;
1951 New_Face *top, *floor, *middle; 1893 New_Face *top, *floor, *middle;
1952 object *top_obj, *floor_obj, *middle_obj; 1894 object *top_obj, *floor_obj, *middle_obj;
… …
2145 SET_MAP_LIGHT (m, x, y, light); 2087 SET_MAP_LIGHT (m, x, y, light);
2146} 2088}
2147 2089
2148 2090
2149void 2091void
2150set_map_reset_time (mapstruct *map) 2092set_map_reset_time (maptile *map)
2151{ 2093{
2152 int timeout; 2094 int timeout;
2153 2095
2154 timeout = MAP_RESET_TIMEOUT (map); 2096 timeout = MAP_RESET_TIMEOUT (map);
2155 if (timeout <= 0) 2097 if (timeout <= 0)
… …
2164 * maps tile_map values if it tiles back to this one. It returns 2106 * 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 2107 * 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. 2108 * so that it is easier for calling functions to verify success.
2167 */ 2109 */
2168 2110
2169static mapstruct * 2111static maptile *
2170load_and_link_tiled_map (mapstruct *orig_map, int tile_num) 2112load_and_link_tiled_map (maptile *orig_map, int tile_num)
2171{ 2113{
2172 int dest_tile = (tile_num + 2) % 4; 2114 int dest_tile = (tile_num + 2) % 4;
2173 char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]); 2115 char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]);
2174 2116
2175 orig_map->tile_map[tile_num] = ready_map_name (path, 0); 2117 orig_map->tile_map[tile_num] = ready_map_name (path, 0);
… …
2190 * tiled maps. 2132 * tiled maps.
2191 * 2133 *
2192 * 2134 *
2193 */ 2135 */
2194int 2136int
2195out_of_map (mapstruct *m, int x, int y) 2137out_of_map (maptile *m, int x, int y)
2196{ 2138{
2197 2139
2198 /* If we get passed a null map, this is obviously the 2140 /* If we get passed a null map, this is obviously the
2199 * case. This generally shouldn't happen, but if the 2141 * case. This generally shouldn't happen, but if the
2200 * map loads fail below, it could happen. 2142 * map loads fail below, it could happen.
… …
2255 * the map as that the coordinates are really on, and 2197 * the map as that the coordinates are really on, and
2256 * updates x and y to be the localized coordinates. 2198 * updates x and y to be the localized coordinates.
2257 * Using this is more efficient of calling out_of_map 2199 * Using this is more efficient of calling out_of_map
2258 * and then figuring out what the real map is 2200 * and then figuring out what the real map is
2259 */ 2201 */
2260mapstruct * 2202maptile *
2261get_map_from_coord (mapstruct *m, sint16 * x, sint16 * y) 2203get_map_from_coord (maptile *m, sint16 * x, sint16 * y)
2262{ 2204{
2263 2205
2264 if (*x < 0) 2206 if (*x < 0)
2265 { 2207 {
2266 if (!m->tile_path[3]) 2208 if (!m->tile_path[3])
… …
2312/** 2254/**
2313 * Return whether map2 is adjacent to map1. If so, store the distance from 2255 * Return whether map2 is adjacent to map1. If so, store the distance from
2314 * map1 to map2 in dx/dy. 2256 * map1 to map2 in dx/dy.
2315 */ 2257 */
2316static int 2258static int
2317adjacent_map (const mapstruct *map1, const mapstruct *map2, int *dx, int *dy) 2259adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy)
2318{ 2260{
2319 if (!map1 || !map2) 2261 if (!map1 || !map2)
2320 return 0; 2262 return 0;
2321 2263
2322 if (map1 == map2) 2264 if (map1 == map2)
… …
2480 * for something in the future. Also, since no object is pasted, the best 2422 * for something in the future. Also, since no object is pasted, the best
2481 * field of the rv_vector is set to NULL. 2423 * field of the rv_vector is set to NULL.
2482 */ 2424 */
2483 2425
2484void 2426void
2485get_rangevector_from_mapcoord (const mapstruct *m, int x, int y, const object *op2, rv_vector * retval, int flags) 2427get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector * retval, int flags)
2486{ 2428{
2487 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y)) 2429 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
2488 { 2430 {
2489 /* be conservative and fill in _some_ data */ 2431 /* be conservative and fill in _some_ data */
2490 retval->distance = 100000; 2432 retval->distance = 100000;

Diff Legend

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