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.37 by pippijn, Mon Dec 11 14:28:12 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>
… …
37#endif /* win32 */ 31#endif /* win32 */
38 32
39#include "path.h" 33#include "path.h"
40 34
41 35
42extern int nrofallocobjects, nroffreeobjects;
43
44/* 36/*
45 * Returns the mapstruct which has a name matching the given argument. 37 * Returns the maptile which has a name matching the given argument.
46 * return NULL if no match is found. 38 * return NULL if no match is found.
47 */ 39 */
48 40
49mapstruct * 41maptile *
50has_been_loaded (const char *name) 42has_been_loaded (const char *name)
51{ 43{
52 mapstruct *map; 44 maptile *map;
53 45
54 if (!name || !*name) 46 if (!name || !*name)
55 return 0; 47 return 0;
56 for (map = first_map; map; map = map->next) 48 for (map = first_map; map; map = map->next)
57 if (!strcmp (name, map->path)) 49 if (!strcmp (name, map->path))
… …
210 * Dumping these at llevError doesn't seem right, but is 202 * Dumping these at llevError doesn't seem right, but is
211 * necessary to make sure the information is in fact logged. 203 * necessary to make sure the information is in fact logged.
212 */ 204 */
213 205
214void 206void
215dump_map (const mapstruct *m) 207dump_map (const maptile *m)
216{ 208{
217 LOG (llevError, "Map %s status: %d.\n", m->path, m->in_memory); 209 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)); 210 LOG (llevError, "Size: %dx%d Start: %d,%d\n", MAP_WIDTH (m), MAP_HEIGHT (m), MAP_ENTER_X (m), MAP_ENTER_Y (m));
219 211
220 if (m->msg != NULL) 212 if (m->msg != NULL)
… …
237 */ 229 */
238 230
239void 231void
240dump_all_maps (void) 232dump_all_maps (void)
241{ 233{
242 mapstruct *m; 234 maptile *m;
243 235
244 for (m = first_map; m != NULL; m = m->next) 236 for (m = first_map; m != NULL; m = m->next)
245 { 237 {
246 dump_map (m); 238 dump_map (m);
247 } 239 }
… …
256 * is needed. The case of not passing values is if we're just 248 * is needed. The case of not passing values is if we're just
257 * checking for the existence of something on those spaces, but 249 * checking for the existence of something on those spaces, but
258 * don't expect to insert/remove anything from those spaces. 250 * don't expect to insert/remove anything from those spaces.
259 */ 251 */
260int 252int
261get_map_flags (mapstruct *oldmap, mapstruct **newmap, sint16 x, sint16 y, sint16 * nx, sint16 * ny) 253get_map_flags (maptile *oldmap, maptile **newmap, sint16 x, sint16 y, sint16 * nx, sint16 * ny)
262{ 254{
263 sint16 newx, newy; 255 sint16 newx, newy;
264 int retval = 0; 256 int retval = 0;
265 mapstruct *mp; 257 maptile *mp;
266 258
267 if (out_of_map (oldmap, x, y)) 259 if (out_of_map (oldmap, x, y))
268 return P_OUT_OF_MAP; 260 return P_OUT_OF_MAP;
269 newx = x; 261 newx = x;
270 newy = y; 262 newy = y;
… …
281 retval |= mp->spaces[newx + mp->width * newy].flags; 273 retval |= mp->spaces[newx + mp->width * newy].flags;
282 274
283 return retval; 275 return retval;
284} 276}
285 277
286
287/* 278/*
288 * Returns true if the given coordinate is blocked except by the 279 * Returns true if the given coordinate is blocked except by the
289 * object passed is not blocking. This is used with 280 * object passed is not blocking. This is used with
290 * multipart monsters - if we want to see if a 2x2 monster 281 * 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 282 * can move 1 space to the left, we don't want its own area
… …
294 * monster. 285 * monster.
295 * m, x, y are the target map/coordinates - needed for map tiling. 286 * m, x, y are the target map/coordinates - needed for map tiling.
296 * the coordinates & map passed in should have been updated for tiling 287 * the coordinates & map passed in should have been updated for tiling
297 * by the caller. 288 * by the caller.
298 */ 289 */
299
300int 290int
301blocked_link (object *ob, mapstruct *m, int sx, int sy) 291blocked_link (object *ob, maptile *m, int sx, int sy)
302{ 292{
303 object *tmp; 293 object *tmp;
304 int mflags, blocked; 294 int mflags, blocked;
305 295
306 /* Make sure the coordinates are valid - they should be, as caller should 296 /* 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 408 * code, we need to have actual object to check its move_type
419 * against the move_block values. 409 * against the move_block values.
420 */ 410 */
421 411
422int 412int
423ob_blocked (const object *ob, mapstruct *m, sint16 x, sint16 y) 413ob_blocked (const object *ob, maptile *m, sint16 x, sint16 y)
424{ 414{
425 archetype *tmp; 415 archetype *tmp;
426 int flag; 416 int flag;
427 mapstruct *m1; 417 maptile *m1;
428 sint16 sx, sy; 418 sint16 sx, sy;
429 419
430 if (ob == NULL) 420 if (ob == NULL)
431 { 421 {
432 flag = get_map_flags (m, &m1, x, y, &sx, &sy); 422 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 487 * 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. 488 * the more sections and not re-add sections for them.
499 */ 489 */
500 490
501static void 491static void
502link_multipart_objects (mapstruct *m) 492link_multipart_objects (maptile *m)
503{ 493{
504 int x, y; 494 int x, y;
505 object *tmp, *op, *last, *above; 495 object *tmp, *op, *last, *above;
506 archetype *at; 496 archetype *at;
507 497
… …
544 * Loads (ands parses) the objects into a given map from the specified 534 * Loads (ands parses) the objects into a given map from the specified
545 * file pointer. 535 * file pointer.
546 * mapflags is the same as we get with load_original_map 536 * mapflags is the same as we get with load_original_map
547 */ 537 */
548void 538void
549load_objects (mapstruct *m, object_thawer & fp, int mapflags) 539load_objects (maptile *m, object_thawer & fp, int mapflags)
550{ 540{
551 int i, j; 541 int i, j;
552 int unique; 542 int unique;
553 object *op, *prev = NULL, *last_more = NULL, *otmp; 543 object *op, *prev = NULL, *last_more = NULL, *otmp;
554 544
… …
620 * Modified by MSW 2001-07-01 to do in a single pass - reduces code, 610 * 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 611 * and we only save the head of multi part objects - this is needed
622 * in order to do map tiling properly. 612 * in order to do map tiling properly.
623 */ 613 */
624void 614void
625save_objects (mapstruct *m, object_freezer & fp, object_freezer & fp2, int flag) 615save_objects (maptile *m, object_freezer & fp, object_freezer & fp2, int flag)
626{ 616{
627 int i, j = 0, unique = 0; 617 int i, j = 0, unique = 0;
628 object *op; 618 object *op;
629 619
630 /* first pass - save one-part objects */ 620 /* first pass - save one-part objects */
… …
653 643
654 } /* for this space */ 644 } /* for this space */
655 } /* for this j */ 645 } /* for this j */
656} 646}
657 647
648maptile::maptile ()
649{
650 in_memory = MAP_SWAPPED;
651 /* The maps used to pick up default x and y values from the
652 * map archetype. Mimic that behaviour.
653 */
654 MAP_WIDTH (this) = 16;
655 MAP_HEIGHT (this) = 16;
656 MAP_RESET_TIMEOUT (this) = 0;
657 MAP_TIMEOUT (this) = 300;
658 MAP_ENTER_X (this) = 0;
659 MAP_ENTER_Y (this) = 0;
660 /*set part to -1 indicating conversion to weather map not yet done */
661 MAP_WORLDPARTX (this) = -1;
662 MAP_WORLDPARTY (this) = -1;
663}
664
658/* 665/*
659 * Allocates, initialises, and returns a pointer to a mapstruct. 666 * Allocates, initialises, and returns a pointer to a maptile.
660 * Modified to no longer take a path option which was not being 667 * Modified to no longer take a path option which was not being
661 * used anyways. MSW 2001-07-01 668 * used anyways. MSW 2001-07-01
662 */ 669 */
663 670maptile *
664mapstruct *
665get_linked_map (void) 671get_linked_map (void)
666{ 672{
667 mapstruct *map = new mapstruct; 673 maptile *mp, *map = new maptile;
668 mapstruct *mp;
669 674
670 for (mp = first_map; mp != NULL && mp->next != NULL; mp = mp->next); 675 for (mp = first_map; mp && mp->next; mp = mp->next);
676
671 if (mp == NULL) 677 if (mp == NULL)
672 first_map = map; 678 first_map = map;
673 else 679 else
674 mp->next = map; 680 mp->next = map;
675 681
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; 682 return map;
690} 683}
691 684
692/* 685/*
693 * Allocates the arrays contained in a mapstruct. 686 * Allocates the arrays contained in a maptile.
694 * This basically allocates the dynamic array of spaces for the 687 * This basically allocates the dynamic array of spaces for the
695 * map. 688 * map.
696 */ 689 */
697
698void 690void
699allocate_map (mapstruct *m) 691maptile::allocate ()
700{ 692{
701 m->in_memory = MAP_IN_MEMORY; 693 in_memory = MAP_IN_MEMORY;
694
702 /* Log this condition and free the storage. We could I suppose 695 /* Log this condition and free the storage. We could I suppose
703 * realloc, but if the caller is presuming the data will be intact, 696 * realloc, but if the caller is presuming the data will be intact,
704 * that is their poor assumption. 697 * that is their poor assumption.
705 */ 698 */
706 if (m->spaces) 699 if (spaces)
707 { 700 {
708 LOG (llevError, "allocate_map called with already allocated map (%s)\n", m->path); 701 LOG (llevError, "allocate_map called with already allocated map (%s)\n", path);
709 free (m->spaces); 702 free (spaces);
710 } 703 }
711 704
712 m->spaces = (MapSpace *) calloc (1, MAP_WIDTH (m) * MAP_HEIGHT (m) * sizeof (MapSpace)); 705 spaces = (MapSpace *)
706 calloc (1, width * height * sizeof (MapSpace));
713 707
714 if (m->spaces == NULL) 708 if (!spaces)
715 fatal (OUT_OF_MEMORY); 709 fatal (OUT_OF_MEMORY);
716} 710}
717 711
718/* Create and returns a map of the specific size. Used 712/* Create and returns a map of the specific size. Used
719 * in random map code and the editor. 713 * in random map code and the editor.
720 */ 714 */
721mapstruct * 715maptile *
722get_empty_map (int sizex, int sizey) 716get_empty_map (int sizex, int sizey)
723{ 717{
724 mapstruct *m = get_linked_map (); 718 maptile *m = get_linked_map ();
725 719
726 m->width = sizex; 720 m->width = sizex;
727 m->height = sizey; 721 m->height = sizey;
728 m->in_memory = MAP_SWAPPED; 722 m->in_memory = MAP_SWAPPED;
729 allocate_map (m); 723 m->allocate ();
724
730 return m; 725 return m;
731} 726}
732 727
733/* Takes a string from a map definition and outputs a pointer to the array of shopitems 728/* 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 729 * corresponding to that string. Memory is allocated for this, it must be freed
… …
811} 806}
812 807
813/* opposite of parse string, this puts the string that was originally fed in to 808/* opposite of parse string, this puts the string that was originally fed in to
814 * the map (or something equivilent) into output_string. */ 809 * the map (or something equivilent) into output_string. */
815static void 810static void
816print_shop_string (mapstruct *m, char *output_string) 811print_shop_string (maptile *m, char *output_string)
817{ 812{
818 int i; 813 int i;
819 char tmp[MAX_BUF]; 814 char tmp[MAX_BUF];
820 815
821 strcpy (output_string, ""); 816 strcpy (output_string, "");
… …
855 * MSW 2001-07-01 850 * MSW 2001-07-01
856 * return 0 on success, 1 on failure. 851 * return 0 on success, 1 on failure.
857 */ 852 */
858 853
859static int 854static int
860load_map_header (object_thawer & fp, mapstruct *m) 855load_map_header (object_thawer & fp, maptile *m)
861{ 856{
862 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end; 857 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end;
863 int msgpos = 0; 858 int msgpos = 0;
864 int maplorepos = 0; 859 int maplorepos = 0;
865 860
866 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 861 while (fgets (buf, HUGE_BUF, fp) != NULL)
867 { 862 {
868 buf[HUGE_BUF - 1] = 0; 863 buf[HUGE_BUF - 1] = 0;
869 key = buf; 864 key = buf;
865
870 while (isspace (*key)) 866 while (isspace (*key))
871 key++; 867 key++;
868
872 if (*key == 0) 869 if (*key == 0)
873 continue; /* empty line */ 870 continue; /* empty line */
871
874 value = strchr (key, ' '); 872 value = strchr (key, ' ');
873
875 if (!value) 874 if (!value)
876 { 875 {
877 end = strchr (key, '\n'); 876 if ((end = strchr (key, '\n')))
878 if (end != NULL)
879 {
880 *end = 0; 877 *end = 0;
881 }
882 } 878 }
883 else 879 else
884 { 880 {
885 *value = 0; 881 *value = 0;
886 value++; 882 value++;
887 end = strchr (value, '\n'); 883 end = strchr (value, '\n');
884
888 while (isspace (*value)) 885 while (isspace (*value))
889 { 886 {
890 value++; 887 value++;
888
891 if (*value == '\0' || value == end) 889 if (*value == '\0' || value == end)
892 { 890 {
893 /* Nothing but spaces. */ 891 /* Nothing but spaces. */
894 value = NULL; 892 value = NULL;
895 break; 893 break;
… …
918 * that use the parameter. 916 * that use the parameter.
919 */ 917 */
920 918
921 if (!strcmp (key, "msg")) 919 if (!strcmp (key, "msg"))
922 { 920 {
923 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 921 while (fgets (buf, HUGE_BUF, fp) != NULL)
924 { 922 {
925 if (!strcmp (buf, "endmsg\n")) 923 if (!strcmp (buf, "endmsg\n"))
926 break; 924 break;
927 else 925 else
928 { 926 {
… …
939 if (msgpos != 0) 937 if (msgpos != 0)
940 m->msg = strdup_local (msgbuf); 938 m->msg = strdup_local (msgbuf);
941 } 939 }
942 else if (!strcmp (key, "maplore")) 940 else if (!strcmp (key, "maplore"))
943 { 941 {
944 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 942 while (fgets (buf, HUGE_BUF, fp) != NULL)
945 { 943 {
946 if (!strcmp (buf, "endmaplore\n")) 944 if (!strcmp (buf, "endmaplore\n"))
947 break; 945 break;
948 else 946 else
949 { 947 {
… …
1153} 1151}
1154 1152
1155/* 1153/*
1156 * Opens the file "filename" and reads information about the map 1154 * Opens the file "filename" and reads information about the map
1157 * from the given file, and stores it in a newly allocated 1155 * from the given file, and stores it in a newly allocated
1158 * mapstruct. A pointer to this structure is returned, or NULL on failure. 1156 * maptile. A pointer to this structure is returned, or NULL on failure.
1159 * flags correspond to those in map.h. Main ones used are 1157 * 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 1158 * 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 1159 * 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. 1160 * 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 1161 * MAP_STYLE: style map - don't add active objects, don't add to server
1164 * managed map list. 1162 * managed map list.
1165 */ 1163 */
1166 1164
1167mapstruct * 1165maptile *
1168load_original_map (const char *filename, int flags) 1166load_original_map (const char *filename, int flags)
1169{ 1167{
1170 mapstruct *m; 1168 maptile *m;
1171 char pathname[MAX_BUF]; 1169 char pathname[MAX_BUF];
1172 1170
1173 if (flags & MAP_PLAYER_UNIQUE) 1171 if (flags & MAP_PLAYER_UNIQUE)
1174 strcpy (pathname, filename); 1172 strcpy (pathname, filename);
1175 else if (flags & MAP_OVERLAY) 1173 else if (flags & MAP_OVERLAY)
… …
1192 LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags); 1190 LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags);
1193 delete_map (m); 1191 delete_map (m);
1194 return NULL; 1192 return NULL;
1195 } 1193 }
1196 1194
1197 allocate_map (m); 1195 m->allocate ();
1198 1196
1199 m->in_memory = MAP_LOADING; 1197 m->in_memory = MAP_LOADING;
1200 load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE)); 1198 load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE));
1201 1199
1202 m->in_memory = MAP_IN_MEMORY; 1200 m->in_memory = MAP_IN_MEMORY;
… …
1211 * Loads a map, which has been loaded earlier, from file. 1209 * Loads a map, which has been loaded earlier, from file.
1212 * Return the map object we load into (this can change from the passed 1210 * Return the map object we load into (this can change from the passed
1213 * option if we can't find the original map) 1211 * option if we can't find the original map)
1214 */ 1212 */
1215 1213
1216static mapstruct * 1214static maptile *
1217load_temporary_map (mapstruct *m) 1215load_temporary_map (maptile *m)
1218{ 1216{
1219 char buf[MAX_BUF]; 1217 char buf[MAX_BUF];
1220 1218
1221 if (!m->tmpname) 1219 if (!m->tmpname)
1222 { 1220 {
… …
1248 LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname); 1246 LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname);
1249 delete_map (m); 1247 delete_map (m);
1250 m = load_original_map (m->path, 0); 1248 m = load_original_map (m->path, 0);
1251 return NULL; 1249 return NULL;
1252 } 1250 }
1251
1253 allocate_map (m); 1252 m->allocate ();
1254 1253
1255 m->in_memory = MAP_LOADING; 1254 m->in_memory = MAP_LOADING;
1256 load_objects (m, thawer, 0); 1255 load_objects (m, thawer, 0);
1257 1256
1258 m->in_memory = MAP_IN_MEMORY; 1257 m->in_memory = MAP_IN_MEMORY;
… …
1264 * Loads a map, which has been loaded earlier, from file. 1263 * Loads a map, which has been loaded earlier, from file.
1265 * Return the map object we load into (this can change from the passed 1264 * Return the map object we load into (this can change from the passed
1266 * option if we can't find the original map) 1265 * option if we can't find the original map)
1267 */ 1266 */
1268 1267
1269mapstruct * 1268maptile *
1270load_overlay_map (const char *filename, mapstruct *m) 1269load_overlay_map (const char *filename, maptile *m)
1271{ 1270{
1272 char pathname[MAX_BUF]; 1271 char pathname[MAX_BUF];
1273 1272
1274 strcpy (pathname, create_overlay_pathname (filename)); 1273 strcpy (pathname, create_overlay_pathname (filename));
1275 1274
… …
1283 LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname); 1282 LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname);
1284 delete_map (m); 1283 delete_map (m);
1285 m = load_original_map (m->path, 0); 1284 m = load_original_map (m->path, 0);
1286 return NULL; 1285 return NULL;
1287 } 1286 }
1288 /*allocate_map(m); */ 1287 /*m->allocate ();*/
1289 1288
1290 m->in_memory = MAP_LOADING; 1289 m->in_memory = MAP_LOADING;
1291 load_objects (m, thawer, MAP_OVERLAY); 1290 load_objects (m, thawer, MAP_OVERLAY);
1292 1291
1293 m->in_memory = MAP_IN_MEMORY; 1292 m->in_memory = MAP_IN_MEMORY;
… …
1298 * This is the start of unique map handling code 1297 * This is the start of unique map handling code
1299 *****************************************************************************/ 1298 *****************************************************************************/
1300 1299
1301/* This goes through map 'm' and removed any unique items on the map. */ 1300/* This goes through map 'm' and removed any unique items on the map. */
1302static void 1301static void
1303delete_unique_items (mapstruct *m) 1302delete_unique_items (maptile *m)
1304{ 1303{
1305 int i, j, unique; 1304 int i, j, unique;
1306 object *op, *next; 1305 object *op, *next;
1307 1306
1308 for (i = 0; i < MAP_WIDTH (m); i++) 1307 for (i = 0; i < MAP_WIDTH (m); i++)
… …
1330/* 1329/*
1331 * Loads unique objects from file(s) into the map which is in memory 1330 * Loads unique objects from file(s) into the map which is in memory
1332 * m is the map to load unique items into. 1331 * m is the map to load unique items into.
1333 */ 1332 */
1334static void 1333static void
1335load_unique_objects (mapstruct *m) 1334load_unique_objects (maptile *m)
1336{ 1335{
1337 int count; 1336 int count;
1338 char firstname[MAX_BUF]; 1337 char firstname[MAX_BUF];
1339 1338
1340 for (count = 0; count < 10; count++) 1339 for (count = 0; count < 10; count++)
… …
1363 1362
1364/* 1363/*
1365 * Saves a map to file. If flag is set, it is saved into the same 1364 * 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 1365 * file it was (originally) loaded from. Otherwise a temporary
1367 * filename will be genarated, and the file will be stored there. 1366 * filename will be genarated, and the file will be stored there.
1368 * The temporary filename will be stored in the mapstructure. 1367 * The temporary filename will be stored in the maptileure.
1369 * If the map is unique, we also save to the filename in the map 1368 * If the map is unique, we also save to the filename in the map
1370 * (this should have been updated when first loaded) 1369 * (this should have been updated when first loaded)
1371 */ 1370 */
1372 1371
1373int 1372int
1374new_save_map (mapstruct *m, int flag) 1373new_save_map (maptile *m, int flag)
1375{ 1374{
1376 char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF]; 1375 char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF];
1377 int i; 1376 int i;
1378 1377
1379 if (flag && !*m->path) 1378 if (flag && !*m->path)
… …
1543/* 1542/*
1544 * Remove and free all objects in the given map. 1543 * Remove and free all objects in the given map.
1545 */ 1544 */
1546 1545
1547void 1546void
1548free_all_objects (mapstruct *m) 1547free_all_objects (maptile *m)
1549{ 1548{
1550 int i, j; 1549 int i, j;
1551 object *op; 1550 object *op;
1552 1551
1553 for (i = 0; i < MAP_WIDTH (m); i++) 1552 for (i = 0; i < MAP_WIDTH (m); i++)
… …
1576 } 1575 }
1577 } 1576 }
1578} 1577}
1579 1578
1580/* 1579/*
1581 * Frees everything allocated by the given mapstructure. 1580 * Frees everything allocated by the given maptileure.
1582 * don't free tmpname - our caller is left to do that 1581 * don't free tmpname - our caller is left to do that
1583 */ 1582 */
1584 1583
1585void 1584void
1586free_map (mapstruct *m, int flag) 1585free_map (maptile *m, int flag)
1587{ 1586{
1588 int i; 1587 int i;
1589 1588
1590 if (!m->in_memory) 1589 if (!m->in_memory)
1591 { 1590 {
… …
1618 } 1617 }
1619 m->in_memory = MAP_SWAPPED; 1618 m->in_memory = MAP_SWAPPED;
1620} 1619}
1621 1620
1622/* 1621/*
1623 * function: vanish mapstruct 1622 * function: vanish maptile
1624 * m : pointer to mapstruct, if NULL no action 1623 * m : pointer to maptile, if NULL no action
1625 * this deletes all the data on the map (freeing pointers) 1624 * this deletes all the data on the map (freeing pointers)
1626 * and then removes this map from the global linked list of maps. 1625 * and then removes this map from the global linked list of maps.
1627 */ 1626 */
1628 1627
1629void 1628void
1630delete_map (mapstruct *m) 1629delete_map (maptile *m)
1631{ 1630{
1632 mapstruct *tmp, *last; 1631 maptile *tmp, *last;
1633 int i; 1632 int i;
1634 1633
1635 if (!m) 1634 if (!m)
1636 return; 1635 return;
1637 1636
… …
1699 * dont do any more name translation on it. 1698 * dont do any more name translation on it.
1700 * 1699 *
1701 * Returns a pointer to the given map. 1700 * Returns a pointer to the given map.
1702 */ 1701 */
1703 1702
1704mapstruct * 1703maptile *
1705ready_map_name (const char *name, int flags) 1704ready_map_name (const char *name, int flags)
1706{ 1705{
1707 mapstruct *m; 1706 maptile *m;
1708 1707
1709 if (!name) 1708 if (!name)
1710 return (NULL); 1709 return (NULL);
1711 1710
1712 /* Have we been at this level before? */ 1711 /* Have we been at this level before? */
… …
1814 * have a difficulty set than using this function - human calculation 1813 * have a difficulty set than using this function - human calculation
1815 * is much better than this functions guesswork. 1814 * is much better than this functions guesswork.
1816 */ 1815 */
1817 1816
1818int 1817int
1819calculate_difficulty (mapstruct *m) 1818calculate_difficulty (maptile *m)
1820{ 1819{
1821 object *op; 1820 object *op;
1822 archetype *at; 1821 archetype *at;
1823 int x, y, i; 1822 int x, y, i;
1824 long monster_cnt = 0; 1823 long monster_cnt = 0;
… …
1866 1865
1867 return 1; 1866 return 1;
1868} 1867}
1869 1868
1870void 1869void
1871clean_tmp_map (mapstruct *m) 1870clean_tmp_map (maptile *m)
1872{ 1871{
1873 if (m->tmpname == NULL) 1872 if (m->tmpname == NULL)
1874 return; 1873 return;
1875 INVOKE_MAP (CLEAN, m); 1874 INVOKE_MAP (CLEAN, m);
1876 (void) unlink (m->tmpname); 1875 (void) unlink (m->tmpname);
… …
1901 * to maps than los. 1900 * to maps than los.
1902 * postive values make it darker, negative make it brighter 1901 * postive values make it darker, negative make it brighter
1903 */ 1902 */
1904 1903
1905int 1904int
1906change_map_light (mapstruct *m, int change) 1905change_map_light (maptile *m, int change)
1907{ 1906{
1908 int new_level = m->darkness + change; 1907 int new_level = m->darkness + change;
1909 1908
1910 /* Nothing to do */ 1909 /* Nothing to do */
1911 if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS)) 1910 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, 1941 * on the map (what it looks like, whether it blocks magic,
1943 * has a living creatures, prevents people from passing 1942 * has a living creatures, prevents people from passing
1944 * through, etc) 1943 * through, etc)
1945 */ 1944 */
1946void 1945void
1947update_position (mapstruct *m, int x, int y) 1946update_position (maptile *m, int x, int y)
1948{ 1947{
1949 object *tmp, *last = NULL; 1948 object *tmp, *last = NULL;
1950 uint8 flags = 0, oldflags, light = 0, anywhere = 0; 1949 uint8 flags = 0, oldflags, light = 0, anywhere = 0;
1951 New_Face *top, *floor, *middle; 1950 New_Face *top, *floor, *middle;
1952 object *top_obj, *floor_obj, *middle_obj; 1951 object *top_obj, *floor_obj, *middle_obj;
… …
2145 SET_MAP_LIGHT (m, x, y, light); 2144 SET_MAP_LIGHT (m, x, y, light);
2146} 2145}
2147 2146
2148 2147
2149void 2148void
2150set_map_reset_time (mapstruct *map) 2149set_map_reset_time (maptile *map)
2151{ 2150{
2152 int timeout; 2151 int timeout;
2153 2152
2154 timeout = MAP_RESET_TIMEOUT (map); 2153 timeout = MAP_RESET_TIMEOUT (map);
2155 if (timeout <= 0) 2154 if (timeout <= 0)
… …
2164 * maps tile_map values if it tiles back to this one. It returns 2163 * 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 2164 * 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. 2165 * so that it is easier for calling functions to verify success.
2167 */ 2166 */
2168 2167
2169static mapstruct * 2168static maptile *
2170load_and_link_tiled_map (mapstruct *orig_map, int tile_num) 2169load_and_link_tiled_map (maptile *orig_map, int tile_num)
2171{ 2170{
2172 int dest_tile = (tile_num + 2) % 4; 2171 int dest_tile = (tile_num + 2) % 4;
2173 char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]); 2172 char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]);
2174 2173
2175 orig_map->tile_map[tile_num] = ready_map_name (path, 0); 2174 orig_map->tile_map[tile_num] = ready_map_name (path, 0);
… …
2190 * tiled maps. 2189 * tiled maps.
2191 * 2190 *
2192 * 2191 *
2193 */ 2192 */
2194int 2193int
2195out_of_map (mapstruct *m, int x, int y) 2194out_of_map (maptile *m, int x, int y)
2196{ 2195{
2197 2196
2198 /* If we get passed a null map, this is obviously the 2197 /* If we get passed a null map, this is obviously the
2199 * case. This generally shouldn't happen, but if the 2198 * case. This generally shouldn't happen, but if the
2200 * map loads fail below, it could happen. 2199 * map loads fail below, it could happen.
… …
2255 * the map as that the coordinates are really on, and 2254 * the map as that the coordinates are really on, and
2256 * updates x and y to be the localized coordinates. 2255 * updates x and y to be the localized coordinates.
2257 * Using this is more efficient of calling out_of_map 2256 * Using this is more efficient of calling out_of_map
2258 * and then figuring out what the real map is 2257 * and then figuring out what the real map is
2259 */ 2258 */
2260mapstruct * 2259maptile *
2261get_map_from_coord (mapstruct *m, sint16 * x, sint16 * y) 2260get_map_from_coord (maptile *m, sint16 * x, sint16 * y)
2262{ 2261{
2263 2262
2264 if (*x < 0) 2263 if (*x < 0)
2265 { 2264 {
2266 if (!m->tile_path[3]) 2265 if (!m->tile_path[3])
… …
2312/** 2311/**
2313 * Return whether map2 is adjacent to map1. If so, store the distance from 2312 * Return whether map2 is adjacent to map1. If so, store the distance from
2314 * map1 to map2 in dx/dy. 2313 * map1 to map2 in dx/dy.
2315 */ 2314 */
2316static int 2315static int
2317adjacent_map (const mapstruct *map1, const mapstruct *map2, int *dx, int *dy) 2316adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy)
2318{ 2317{
2319 if (!map1 || !map2) 2318 if (!map1 || !map2)
2320 return 0; 2319 return 0;
2321 2320
2322 if (map1 == map2) 2321 if (map1 == map2)
… …
2480 * for something in the future. Also, since no object is pasted, the best 2479 * for something in the future. Also, since no object is pasted, the best
2481 * field of the rv_vector is set to NULL. 2480 * field of the rv_vector is set to NULL.
2482 */ 2481 */
2483 2482
2484void 2483void
2485get_rangevector_from_mapcoord (const mapstruct *m, int x, int y, const object *op2, rv_vector * retval, int flags) 2484get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector * retval, int flags)
2486{ 2485{
2487 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y)) 2486 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
2488 { 2487 {
2489 /* be conservative and fill in _some_ data */ 2488 /* be conservative and fill in _some_ data */
2490 retval->distance = 100000; 2489 retval->distance = 100000;

Diff Legend

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