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.53 by root, Wed Dec 27 09:28:01 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 37maptile *
49mapstruct *
50has_been_loaded (const char *name) 38has_been_loaded (const char *name)
51{ 39{
52 mapstruct *map;
53
54 if (!name || !*name) 40 if (!name || !*name)
55 return 0; 41 return 0;
56 for (map = first_map; map; map = map->next) 42
43 for_all_maps (map)
57 if (!strcmp (name, map->path)) 44 if (!strcmp (name, map->path))
58 break;
59 return (map); 45 return map;
46
47 return 0;
60} 48}
61 49
62/* 50/*
63 * This makes a path absolute outside the world of Crossfire. 51 * This makes a path absolute outside the world of Crossfire.
64 * In other words, it prepends LIBDIR/MAPDIR/ to the given path 52 * In other words, it prepends LIBDIR/MAPDIR/ to the given path
… …
165int 153int
166check_path (const char *name, int prepend_dir) 154check_path (const char *name, int prepend_dir)
167{ 155{
168 char buf[MAX_BUF]; 156 char buf[MAX_BUF];
169 157
170#ifndef WIN32
171 char *endbuf; 158 char *endbuf;
172 struct stat statbuf; 159 struct stat statbuf;
173 int mode = 0; 160 int mode = 0;
174#endif
175 161
176 if (prepend_dir) 162 if (prepend_dir)
177 strcpy (buf, create_pathname (name)); 163 strcpy (buf, create_pathname (name));
178 else 164 else
179 strcpy (buf, name); 165 strcpy (buf, name);
180#ifdef WIN32 /* ***win32: check this sucker in windows style. */
181 return (_access (buf, 0));
182#else
183 166
184 /* old method (strchr(buf, '\0')) seemd very odd to me - 167 /* old method (strchr(buf, '\0')) seemd very odd to me -
185 * this method should be equivalant and is clearer. 168 * this method should be equivalant and is clearer.
186 * Can not use strcat because we need to cycle through 169 * Can not use strcat because we need to cycle through
187 * all the names. 170 * all the names.
… …
200 if ((statbuf.st_mode & S_IWGRP && getegid () == statbuf.st_gid) || 183 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)) 184 (statbuf.st_mode & S_IWUSR && geteuid () == statbuf.st_uid) || (statbuf.st_mode & S_IWOTH))
202 mode |= 2; 185 mode |= 2;
203 186
204 return (mode); 187 return (mode);
205#endif
206} 188}
207 189
208/* 190/*
209 * Prints out debug-information about a map. 191 * Prints out debug-information about a map.
210 * Dumping these at llevError doesn't seem right, but is 192 * Dumping these at llevError doesn't seem right, but is
211 * necessary to make sure the information is in fact logged. 193 * necessary to make sure the information is in fact logged.
212 */ 194 */
213 195
214void 196void
215dump_map (const mapstruct *m) 197dump_map (const maptile *m)
216{ 198{
217 LOG (llevError, "Map %s status: %d.\n", m->path, m->in_memory); 199 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)); 200 LOG (llevError, "Size: %dx%d Start: %d,%d\n", m->width, m->height, m->enter_x, m->enter_y);
219 201
220 if (m->msg != NULL) 202 if (m->msg != NULL)
221 LOG (llevError, "Message:\n%s", m->msg); 203 LOG (llevError, "Message:\n%s", m->msg);
222 204
223 if (m->maplore != NULL) 205 if (m->maplore != NULL)
… …
237 */ 219 */
238 220
239void 221void
240dump_all_maps (void) 222dump_all_maps (void)
241{ 223{
242 mapstruct *m; 224 for_all_maps (m)
243
244 for (m = first_map; m != NULL; m = m->next)
245 {
246 dump_map (m); 225 dump_map (m);
247 }
248} 226}
249 227
250/* This rolls up wall, blocks_magic, blocks_view, etc, all into 228/* This rolls up wall, blocks_magic, blocks_view, etc, all into
251 * one function that just returns a P_.. value (see map.h) 229 * one function that just returns a P_.. value (see map.h)
252 * it will also do map translation for tiled maps, returning 230 * it will also do map translation for tiled maps, returning
… …
256 * is needed. The case of not passing values is if we're just 234 * is needed. The case of not passing values is if we're just
257 * checking for the existence of something on those spaces, but 235 * checking for the existence of something on those spaces, but
258 * don't expect to insert/remove anything from those spaces. 236 * don't expect to insert/remove anything from those spaces.
259 */ 237 */
260int 238int
261get_map_flags (mapstruct *oldmap, mapstruct **newmap, sint16 x, sint16 y, sint16 * nx, sint16 * ny) 239get_map_flags (maptile *oldmap, maptile **newmap, sint16 x, sint16 y, sint16 *nx, sint16 *ny)
262{ 240{
263 sint16 newx, newy; 241 sint16 newx, newy;
264 int retval = 0; 242 int retval = 0;
265 mapstruct *mp; 243 maptile *mp;
266 244
267 if (out_of_map (oldmap, x, y))
268 return P_OUT_OF_MAP;
269 newx = x; 245 newx = x;
270 newy = y; 246 newy = y;
247
271 mp = get_map_from_coord (oldmap, &newx, &newy); 248 mp = get_map_from_coord (oldmap, &newx, &newy);
249
250 if (!mp)
251 return P_OUT_OF_MAP;
252
272 if (mp != oldmap) 253 if (mp != oldmap)
273 retval |= P_NEW_MAP; 254 retval |= P_NEW_MAP;
274 if (newmap)
275 *newmap = mp;
276 if (nx)
277 *nx = newx;
278 if (ny)
279 *ny = newy;
280 255
281 retval |= mp->spaces[newx + mp->width * newy].flags; 256 if (newmap) *newmap = mp;
257 if (nx) *nx = newx;
258 if (ny) *ny = newy;
282 259
283 return retval; 260 return retval | mp->at (newx, newy).flags ();
284} 261}
285
286 262
287/* 263/*
288 * Returns true if the given coordinate is blocked except by the 264 * Returns true if the given coordinate is blocked except by the
289 * object passed is not blocking. This is used with 265 * object passed is not blocking. This is used with
290 * multipart monsters - if we want to see if a 2x2 monster 266 * multipart monsters - if we want to see if a 2x2 monster
… …
294 * monster. 270 * monster.
295 * m, x, y are the target map/coordinates - needed for map tiling. 271 * m, x, y are the target map/coordinates - needed for map tiling.
296 * the coordinates & map passed in should have been updated for tiling 272 * the coordinates & map passed in should have been updated for tiling
297 * by the caller. 273 * by the caller.
298 */ 274 */
299
300int 275int
301blocked_link (object *ob, mapstruct *m, int sx, int sy) 276blocked_link (object *ob, maptile *m, int sx, int sy)
302{ 277{
303 object *tmp; 278 object *tmp;
304 int mflags, blocked; 279 int mflags, blocked;
305 280
306 /* Make sure the coordinates are valid - they should be, as caller should 281 /* Make sure the coordinates are valid - they should be, as caller should
… …
313 } 288 }
314 289
315 /* Save some cycles - instead of calling get_map_flags(), just get the value 290 /* Save some cycles - instead of calling get_map_flags(), just get the value
316 * directly. 291 * directly.
317 */ 292 */
318 mflags = m->spaces[sx + m->width * sy].flags; 293 mflags = m->at (sx, sy).flags ();
319 294
320 blocked = GET_MAP_MOVE_BLOCK (m, sx, sy); 295 blocked = GET_MAP_MOVE_BLOCK (m, sx, sy);
321 296
322 /* If space is currently not blocked by anything, no need to 297 /* If space is currently not blocked by anything, no need to
323 * go further. Not true for players - all sorts of special 298 * go further. Not true for players - all sorts of special
… …
342 /* We basically go through the stack of objects, and if there is 317 /* We basically go through the stack of objects, and if there is
343 * some other object that has NO_PASS or FLAG_ALIVE set, return 318 * some other object that has NO_PASS or FLAG_ALIVE set, return
344 * true. If we get through the entire stack, that must mean 319 * true. If we get through the entire stack, that must mean
345 * ob is blocking it, so return 0. 320 * ob is blocking it, so return 0.
346 */ 321 */
347 for (tmp = GET_MAP_OB (m, sx, sy); tmp != NULL; tmp = tmp->above) 322 for (tmp = GET_MAP_OB (m, sx, sy); tmp; tmp = tmp->above)
348 { 323 {
349 324
350 /* This must be before the checks below. Code for inventory checkers. */ 325 /* This must be before the checks below. Code for inventory checkers. */
351 if (tmp->type == CHECK_INV && OB_MOVE_BLOCK (ob, tmp)) 326 if (tmp->type == CHECK_INV && OB_MOVE_BLOCK (ob, tmp))
352 { 327 {
… …
416 * 391 *
417 * Note this used to be arch_blocked, but with new movement 392 * Note this used to be arch_blocked, but with new movement
418 * code, we need to have actual object to check its move_type 393 * code, we need to have actual object to check its move_type
419 * against the move_block values. 394 * against the move_block values.
420 */ 395 */
421
422int 396int
423ob_blocked (const object *ob, mapstruct *m, sint16 x, sint16 y) 397ob_blocked (const object *ob, maptile *m, sint16 x, sint16 y)
424{ 398{
425 archetype *tmp; 399 archetype *tmp;
426 int flag; 400 int flag;
427 mapstruct *m1; 401 maptile *m1;
428 sint16 sx, sy; 402 sint16 sx, sy;
429 403
430 if (ob == NULL) 404 if (ob == NULL)
431 { 405 {
432 flag = get_map_flags (m, &m1, x, y, &sx, &sy); 406 flag = get_map_flags (m, &m1, x, y, &sx, &sy);
433 if (flag & P_OUT_OF_MAP) 407 if (flag & P_OUT_OF_MAP)
434 return P_OUT_OF_MAP; 408 return P_OUT_OF_MAP;
435 409
436 /* don't have object, so don't know what types would block */ 410 /* don't have object, so don't know what types would block */
437 return (GET_MAP_MOVE_BLOCK (m1, sx, sy)); 411 return m1->at (sx, sy).move_block;
438 } 412 }
439 413
440 for (tmp = ob->arch; tmp != NULL; tmp = tmp->more) 414 for (tmp = ob->arch; tmp; tmp = tmp->more)
441 { 415 {
442 flag = get_map_flags (m, &m1, x + tmp->clone.x, y + tmp->clone.y, &sx, &sy); 416 flag = get_map_flags (m, &m1, x + tmp->clone.x, y + tmp->clone.y, &sx, &sy);
443 417
444 if (flag & P_OUT_OF_MAP) 418 if (flag & P_OUT_OF_MAP)
445 return P_OUT_OF_MAP; 419 return P_OUT_OF_MAP;
446 if (flag & P_IS_ALIVE) 420 if (flag & P_IS_ALIVE)
447 return P_IS_ALIVE; 421 return P_IS_ALIVE;
448 422
423 mapspace &ms = m1->at (sx, sy);
424
425
449 /* find_first_free_spot() calls this function. However, often 426 /* find_first_free_spot() calls this function. However, often
450 * ob doesn't have any move type (when used to place exits) 427 * ob doesn't have any move type (when used to place exits)
451 * so the AND operation in OB_TYPE_MOVE_BLOCK doesn't work. 428 * so the AND operation in OB_TYPE_MOVE_BLOCK doesn't work.
452 */ 429 */
453 430
454 if (ob->move_type == 0 && GET_MAP_MOVE_BLOCK (m1, sx, sy) != MOVE_ALL) 431 if (ob->move_type == 0 && ms.move_block != MOVE_ALL)
455 continue; 432 continue;
456 433
457 /* Note it is intentional that we check ob - the movement type of the 434 /* Note it is intentional that we check ob - the movement type of the
458 * head of the object should correspond for the entire object. 435 * head of the object should correspond for the entire object.
459 */ 436 */
460 if (OB_TYPE_MOVE_BLOCK (ob, GET_MAP_MOVE_BLOCK (m1, sx, sy))) 437 if (OB_TYPE_MOVE_BLOCK (ob, ms.move_block))
461 return AB_NO_PASS; 438 return P_NO_PASS;
462
463 } 439 }
440
464 return 0; 441 return 0;
465} 442}
466 443
467/* When the map is loaded, load_object does not actually insert objects 444/* When the map is loaded, load_object does not actually insert objects
468 * into inventory, but just links them. What this does is go through 445 * into inventory, but just links them. What this does is go through
… …
495 * for objects whose arch says they are multipart yet according to the 472 * for objects whose arch says they are multipart yet according to the
496 * info we have, they only have the head (as would be expected when 473 * info we have, they only have the head (as would be expected when
497 * they are saved). We do have to look for the old maps that did save 474 * they are saved). We do have to look for the old maps that did save
498 * the more sections and not re-add sections for them. 475 * the more sections and not re-add sections for them.
499 */ 476 */
500
501static void 477static void
502link_multipart_objects (mapstruct *m) 478link_multipart_objects (maptile *m)
503{ 479{
504 int x, y; 480 int x, y;
505 object *tmp, *op, *last, *above; 481 object *tmp, *op, *last, *above;
506 archetype *at; 482 archetype *at;
507 483
508 for (x = 0; x < MAP_WIDTH (m); x++) 484 for (x = 0; x < m->width; x++)
509 for (y = 0; y < MAP_HEIGHT (m); y++) 485 for (y = 0; y < m->height; y++)
510 for (tmp = get_map_ob (m, x, y); tmp != NULL; tmp = above) 486 for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = above)
511 { 487 {
512 above = tmp->above; 488 above = tmp->above;
513 489
514 /* already multipart - don't do anything more */ 490 /* already multipart - don't do anything more */
515 if (tmp->head || tmp->more) 491 if (tmp->head || tmp->more)
… …
544 * Loads (ands parses) the objects into a given map from the specified 520 * Loads (ands parses) the objects into a given map from the specified
545 * file pointer. 521 * file pointer.
546 * mapflags is the same as we get with load_original_map 522 * mapflags is the same as we get with load_original_map
547 */ 523 */
548void 524void
549load_objects (mapstruct *m, object_thawer & fp, int mapflags) 525load_objects (maptile *m, object_thawer & fp, int mapflags)
550{ 526{
551 int i, j; 527 int i, j;
552 int unique; 528 int unique;
553 object *op, *prev = NULL, *last_more = NULL, *otmp; 529 object *op, *prev = NULL, *last_more = NULL, *otmp;
554 530
555 op = get_object (); 531 op = object::create ();
556 op->map = m; /* To handle buttons correctly */ 532 op->map = m; /* To handle buttons correctly */
557 533
558 while ((i = load_object (fp, op, mapflags))) 534 while ((i = load_object (fp, op, mapflags)))
559 { 535 {
560 /* if the archetype for the object is null, means that we 536 /* if the archetype for the object is null, means that we
… …
565 { 541 {
566 LOG (llevDebug, "Discarding object without arch: %s\n", op->name ? (const char *) op->name : "(null)"); 542 LOG (llevDebug, "Discarding object without arch: %s\n", op->name ? (const char *) op->name : "(null)");
567 continue; 543 continue;
568 } 544 }
569 545
570
571 switch (i) 546 switch (i)
572 { 547 {
573 case LL_NORMAL: 548 case LL_NORMAL:
574 /* if we are loading an overlay, put the floors on the bottom */ 549 /* 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) 550 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); 551 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY | INS_MAP_LOAD);
577 else 552 else
578 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD); 553 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ON_TOP | INS_MAP_LOAD);
579 554
580 if (op->inv) 555 if (op->inv)
581 sum_weight (op); 556 sum_weight (op);
582 557
583 prev = op, last_more = op; 558 prev = op, last_more = op;
584 break; 559 break;
585 560
586 case LL_MORE: 561 case LL_MORE:
587 insert_ob_in_map (op, m, op, INS_NO_MERGE | INS_NO_WALK_ON | INS_ABOVE_FLOOR_ONLY); 562 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; 563 op->head = prev, last_more->more = op, last_more = op;
589 break; 564 break;
590 } 565 }
591 566
592 if (mapflags & MAP_STYLE) 567 if (mapflags & MAP_STYLE)
593 remove_from_active_list (op); 568 remove_from_active_list (op);
594 569
595 op = get_object (); 570 op = object::create ();
596 op->map = m; 571 op->map = m;
597 } 572 }
598 573
599 for (i = 0; i < m->width; i++) 574 for (i = 0; i < m->width; i++)
600 { 575 {
601 for (j = 0; j < m->height; j++) 576 for (j = 0; j < m->height; j++)
602 { 577 {
603 unique = 0; 578 unique = 0;
604 /* check for unique items, or unique squares */ 579 /* check for unique items, or unique squares */
605 for (otmp = get_map_ob (m, i, j); otmp; otmp = otmp->above) 580 for (otmp = GET_MAP_OB (m, i, j); otmp; otmp = otmp->above)
606 { 581 {
607 if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL)) 582 if (QUERY_FLAG (otmp, FLAG_UNIQUE) || QUERY_FLAG (otmp, FLAG_OBJ_SAVE_ON_OVL))
608 unique = 1; 583 unique = 1;
584
609 if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique)) 585 if (!(mapflags & (MAP_OVERLAY | MAP_PLAYER_UNIQUE) || unique))
610 SET_FLAG (otmp, FLAG_OBJ_ORIGINAL); 586 SET_FLAG (otmp, FLAG_OBJ_ORIGINAL);
611 } 587 }
612 } 588 }
613 } 589 }
614 590
615 free_object (op); 591 op->destroy ();
616 link_multipart_objects (m); 592 link_multipart_objects (m);
617} 593}
618 594
619/* This saves all the objects on the map in a non destructive fashion. 595/* 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, 596 * 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 597 * and we only save the head of multi part objects - this is needed
622 * in order to do map tiling properly. 598 * in order to do map tiling properly.
623 */ 599 */
624void 600void
625save_objects (mapstruct *m, object_freezer & fp, object_freezer & fp2, int flag) 601save_objects (maptile *m, object_freezer &fp, object_freezer &fp2, int flag)
626{ 602{
627 int i, j = 0, unique = 0; 603 int i, j = 0, unique = 0;
628 object *op; 604 object *op;
629 605
630 /* first pass - save one-part objects */ 606 /* first pass - save one-part objects */
631 for (i = 0; i < MAP_WIDTH (m); i++) 607 for (i = 0; i < m->width; i++)
632 for (j = 0; j < MAP_HEIGHT (m); j++) 608 for (j = 0; j < m->height; j++)
633 { 609 {
634 unique = 0; 610 unique = 0;
611
635 for (op = get_map_ob (m, i, j); op; op = op->above) 612 for (op = m->at (i, j).bot; op; op = op->above)
636 { 613 {
637 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) 614 if (op->flag [FLAG_UNIQUE] && op->flag [FLAG_IS_FLOOR])
638 unique = 1; 615 unique = 1;
639 616
640 if (op->type == PLAYER) 617 if (op->type == PLAYER)
641 {
642 LOG (llevDebug, "Player on map that is being saved\n");
643 continue; 618 continue;
644 }
645 619
646 if (op->head || op->owner) 620 if (op->head || op->owner)
647 continue; 621 continue;
648 622
649 if (unique || QUERY_FLAG (op, FLAG_UNIQUE)) 623 if (unique || op->flag [FLAG_UNIQUE])
650 save_object (fp2, op, 3); 624 save_object (fp2, op, 1);
651 else if (flag == 0 || (flag == 2 && (!QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) && !QUERY_FLAG (op, FLAG_UNPAID)))) 625 else if (flag == 0 || (flag == 2 && (!op->flag [FLAG_OBJ_ORIGINAL] && !op->flag [FLAG_UNPAID])))
652 save_object (fp, op, 3); 626 save_object (fp, op, 1);
653 627 }
654 } /* for this space */ 628 }
655 } /* for this j */
656} 629}
657 630
658/* 631maptile::maptile ()
659 * Allocates, initialises, and returns a pointer to a mapstruct.
660 * Modified to no longer take a path option which was not being
661 * used anyways. MSW 2001-07-01
662 */
663
664mapstruct *
665get_linked_map (void)
666{ 632{
667 mapstruct *map = new mapstruct;
668 mapstruct *mp;
669
670 for (mp = first_map; mp != NULL && mp->next != NULL; mp = mp->next);
671 if (mp == NULL)
672 first_map = map;
673 else
674 mp->next = map;
675
676 map->in_memory = MAP_SWAPPED; 633 in_memory = MAP_SWAPPED;
677 /* The maps used to pick up default x and y values from the 634 /* The maps used to pick up default x and y values from the
678 * map archetype. Mimic that behaviour. 635 * map archetype. Mimic that behaviour.
679 */ 636 */
680 MAP_WIDTH (map) = 16; 637 width = 16;
681 MAP_HEIGHT (map) = 16; 638 height = 16;
682 MAP_RESET_TIMEOUT (map) = 0; 639 reset_timeout = 0;
683 MAP_TIMEOUT (map) = 300; 640 timeout = 300;
684 MAP_ENTER_X (map) = 0; 641 enter_x = 0;
685 MAP_ENTER_Y (map) = 0; 642 enter_y = 0;
686 /*set part to -1 indicating conversion to weather map not yet done */ 643 /*set part to -1 indicating conversion to weather map not yet done */
687 MAP_WORLDPARTX (map) = -1; 644 worldpartx = -1;
688 MAP_WORLDPARTY (map) = -1; 645 worldparty = -1;
646}
647
648/*
649 * Allocates, initialises, and returns a pointer to a maptile.
650 * Modified to no longer take a path option which was not being
651 * used anyways. MSW 2001-07-01
652 */
653maptile *
654get_linked_map (void)
655{
656 maptile *map = new maptile;
657
658 map->next = first_map;
659 first_map = map;
660
689 return map; 661 return map;
690} 662}
691 663
692/* 664/*
693 * Allocates the arrays contained in a mapstruct. 665 * Allocates the arrays contained in a maptile.
694 * This basically allocates the dynamic array of spaces for the 666 * This basically allocates the dynamic array of spaces for the
695 * map. 667 * map.
696 */ 668 */
697
698void 669void
699allocate_map (mapstruct *m) 670maptile::allocate ()
700{ 671{
701 m->in_memory = MAP_IN_MEMORY; 672 in_memory = MAP_IN_MEMORY;
673
702 /* Log this condition and free the storage. We could I suppose 674 /* Log this condition and free the storage. We could I suppose
703 * realloc, but if the caller is presuming the data will be intact, 675 * realloc, but if the caller is presuming the data will be intact,
704 * that is their poor assumption. 676 * that is their poor assumption.
705 */ 677 */
706 if (m->spaces) 678 if (spaces)
707 { 679 {
708 LOG (llevError, "allocate_map called with already allocated map (%s)\n", m->path); 680 LOG (llevError, "allocate_map called with already allocated map (%s)\n", path);
709 free (m->spaces); 681 sfree (spaces, size ());
710 } 682 }
711 683
712 m->spaces = (MapSpace *) calloc (1, MAP_WIDTH (m) * MAP_HEIGHT (m) * sizeof (MapSpace)); 684 spaces = salloc0<mapspace> (size ());
713
714 if (m->spaces == NULL)
715 fatal (OUT_OF_MEMORY);
716} 685}
717 686
718/* Create and returns a map of the specific size. Used 687/* Create and returns a map of the specific size. Used
719 * in random map code and the editor. 688 * in random map code and the editor.
720 */ 689 */
721mapstruct * 690maptile *
722get_empty_map (int sizex, int sizey) 691get_empty_map (int sizex, int sizey)
723{ 692{
724 mapstruct *m = get_linked_map (); 693 maptile *m = get_linked_map ();
725 694
726 m->width = sizex; 695 m->width = sizex;
727 m->height = sizey; 696 m->height = sizey;
728 m->in_memory = MAP_SWAPPED; 697 m->in_memory = MAP_SWAPPED;
729 allocate_map (m); 698 m->allocate ();
699
730 return m; 700 return m;
731} 701}
732 702
733/* Takes a string from a map definition and outputs a pointer to the array of shopitems 703/* 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 704 * corresponding to that string. Memory is allocated for this, it must be freed
… …
742 char *shop_string, *p, *q, *next_semicolon, *next_colon; 712 char *shop_string, *p, *q, *next_semicolon, *next_colon;
743 shopitems *items = NULL; 713 shopitems *items = NULL;
744 int i = 0, number_of_entries = 0; 714 int i = 0, number_of_entries = 0;
745 const typedata *current_type; 715 const typedata *current_type;
746 716
747 shop_string = strdup_local (input_string); 717 shop_string = strdup (input_string);
748 p = shop_string; 718 p = shop_string;
749 /* first we'll count the entries, we'll need that for allocating the array shortly */ 719 /* first we'll count the entries, we'll need that for allocating the array shortly */
750 while (p) 720 while (p)
751 { 721 {
752 p = strchr (p, ';'); 722 p = strchr (p, ';');
… …
811} 781}
812 782
813/* opposite of parse string, this puts the string that was originally fed in to 783/* opposite of parse string, this puts the string that was originally fed in to
814 * the map (or something equivilent) into output_string. */ 784 * the map (or something equivilent) into output_string. */
815static void 785static void
816print_shop_string (mapstruct *m, char *output_string) 786print_shop_string (maptile *m, char *output_string)
817{ 787{
818 int i; 788 int i;
819 char tmp[MAX_BUF]; 789 char tmp[MAX_BUF];
820 790
821 strcpy (output_string, ""); 791 strcpy (output_string, "");
… …
855 * MSW 2001-07-01 825 * MSW 2001-07-01
856 * return 0 on success, 1 on failure. 826 * return 0 on success, 1 on failure.
857 */ 827 */
858 828
859static int 829static int
860load_map_header (object_thawer & fp, mapstruct *m) 830load_map_header (object_thawer & fp, maptile *m)
861{ 831{
862 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end; 832 char buf[HUGE_BUF], msgbuf[HUGE_BUF], maplorebuf[HUGE_BUF], *key = NULL, *value, *end;
863 int msgpos = 0; 833 int msgpos = 0;
864 int maplorepos = 0; 834 int maplorepos = 0;
865 835
866 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 836 while (fgets (buf, HUGE_BUF, fp) != NULL)
867 { 837 {
868 buf[HUGE_BUF - 1] = 0; 838 buf[HUGE_BUF - 1] = 0;
869 key = buf; 839 key = buf;
840
870 while (isspace (*key)) 841 while (isspace (*key))
871 key++; 842 key++;
843
872 if (*key == 0) 844 if (*key == 0)
873 continue; /* empty line */ 845 continue; /* empty line */
846
874 value = strchr (key, ' '); 847 value = strchr (key, ' ');
848
875 if (!value) 849 if (!value)
876 { 850 {
877 end = strchr (key, '\n'); 851 if ((end = strchr (key, '\n')))
878 if (end != NULL)
879 {
880 *end = 0; 852 *end = 0;
881 }
882 } 853 }
883 else 854 else
884 { 855 {
885 *value = 0; 856 *value = 0;
886 value++; 857 value++;
887 end = strchr (value, '\n'); 858 end = strchr (value, '\n');
859
888 while (isspace (*value)) 860 while (isspace (*value))
889 { 861 {
890 value++; 862 value++;
863
891 if (*value == '\0' || value == end) 864 if (*value == '\0' || value == end)
892 { 865 {
893 /* Nothing but spaces. */ 866 /* Nothing but spaces. */
894 value = NULL; 867 value = NULL;
895 break; 868 break;
… …
918 * that use the parameter. 891 * that use the parameter.
919 */ 892 */
920 893
921 if (!strcmp (key, "msg")) 894 if (!strcmp (key, "msg"))
922 { 895 {
923 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 896 while (fgets (buf, HUGE_BUF, fp) != NULL)
924 { 897 {
925 if (!strcmp (buf, "endmsg\n")) 898 if (!strcmp (buf, "endmsg\n"))
926 break; 899 break;
927 else 900 else
928 { 901 {
… …
935 * with nothing between). There is no reason in those cases to 908 * with nothing between). There is no reason in those cases to
936 * keep the empty message. Also, msgbuf contains garbage data 909 * keep the empty message. Also, msgbuf contains garbage data
937 * when msgpos is zero, so copying it results in crashes 910 * when msgpos is zero, so copying it results in crashes
938 */ 911 */
939 if (msgpos != 0) 912 if (msgpos != 0)
940 m->msg = strdup_local (msgbuf); 913 m->msg = strdup (msgbuf);
941 } 914 }
942 else if (!strcmp (key, "maplore")) 915 else if (!strcmp (key, "maplore"))
943 { 916 {
944 while (fgets (buf, HUGE_BUF - 1, fp) != NULL) 917 while (fgets (buf, HUGE_BUF, fp) != NULL)
945 { 918 {
946 if (!strcmp (buf, "endmaplore\n")) 919 if (!strcmp (buf, "endmaplore\n"))
947 break; 920 break;
948 else 921 else
949 { 922 {
… …
951 strcpy (maplorebuf + maplorepos, buf); 924 strcpy (maplorebuf + maplorepos, buf);
952 maplorepos += strlen (buf); 925 maplorepos += strlen (buf);
953 } 926 }
954 } 927 }
955 if (maplorepos != 0) 928 if (maplorepos != 0)
956 m->maplore = strdup_local (maplorebuf); 929 m->maplore = strdup (maplorebuf);
957 } 930 }
958 else if (!strcmp (key, "end")) 931 else if (!strcmp (key, "end"))
959 { 932 {
960 break; 933 break;
961 } 934 }
… …
970 LOG (llevError, "loading map and got a non 'arch map' line(%s %s)?\n", key, value); 943 LOG (llevError, "loading map and got a non 'arch map' line(%s %s)?\n", key, value);
971 } 944 }
972 else if (!strcmp (key, "name")) 945 else if (!strcmp (key, "name"))
973 { 946 {
974 *end = 0; 947 *end = 0;
975 m->name = strdup_local (value); 948 m->name = strdup (value);
976 } 949 }
977 /* first strcmp value on these are old names supported 950 /* first strcmp value on these are old names supported
978 * for compatibility reasons. The new values (second) are 951 * for compatibility reasons. The new values (second) are
979 * what really should be used. 952 * what really should be used.
980 */ 953 */
981 else if (!strcmp (key, "oid")) 954 else if (!strcmp (key, "oid"))
982 {
983 fp.get (m, atoi (value)); 955 fp.get (m, atoi (value));
984 }
985 else if (!strcmp (key, "attach")) 956 else if (!strcmp (key, "attach"))
986 {
987 m->attach = value; 957 m->attach = value;
988 }
989 else if (!strcmp (key, "hp") || !strcmp (key, "enter_x")) 958 else if (!strcmp (key, "hp") || !strcmp (key, "enter_x"))
990 {
991 m->enter_x = atoi (value); 959 m->enter_x = atoi (value);
992 }
993 else if (!strcmp (key, "sp") || !strcmp (key, "enter_y")) 960 else if (!strcmp (key, "sp") || !strcmp (key, "enter_y"))
994 {
995 m->enter_y = atoi (value); 961 m->enter_y = atoi (value);
996 }
997 else if (!strcmp (key, "x") || !strcmp (key, "width")) 962 else if (!strcmp (key, "x") || !strcmp (key, "width"))
998 {
999 m->width = atoi (value); 963 m->width = atoi (value);
1000 }
1001 else if (!strcmp (key, "y") || !strcmp (key, "height")) 964 else if (!strcmp (key, "y") || !strcmp (key, "height"))
1002 {
1003 m->height = atoi (value); 965 m->height = atoi (value);
1004 }
1005 else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout")) 966 else if (!strcmp (key, "weight") || !strcmp (key, "reset_timeout"))
1006 {
1007 m->reset_timeout = atoi (value); 967 m->reset_timeout = atoi (value);
1008 }
1009 else if (!strcmp (key, "value") || !strcmp (key, "swap_time")) 968 else if (!strcmp (key, "value") || !strcmp (key, "swap_time"))
1010 {
1011 m->timeout = atoi (value); 969 m->timeout = atoi (value);
1012 }
1013 else if (!strcmp (key, "level") || !strcmp (key, "difficulty")) 970 else if (!strcmp (key, "level") || !strcmp (key, "difficulty"))
1014 { 971 m->difficulty = clamp (atoi (value), 1, settings.max_level);
1015 m->difficulty = atoi (value);
1016 }
1017 else if (!strcmp (key, "invisible") || !strcmp (key, "darkness")) 972 else if (!strcmp (key, "invisible") || !strcmp (key, "darkness"))
1018 {
1019 m->darkness = atoi (value); 973 m->darkness = atoi (value);
1020 }
1021 else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime")) 974 else if (!strcmp (key, "stand_still") || !strcmp (key, "fixed_resettime"))
1022 {
1023 m->fixed_resettime = atoi (value); 975 m->fixed_resettime = atoi (value);
1024 }
1025 else if (!strcmp (key, "unique")) 976 else if (!strcmp (key, "unique"))
1026 {
1027 m->unique = atoi (value); 977 m->unique = atoi (value);
1028 }
1029 else if (!strcmp (key, "template")) 978 else if (!strcmp (key, "template"))
1030 {
1031 m->templatemap = atoi (value); 979 m->templatemap = atoi (value);
1032 }
1033 else if (!strcmp (key, "region")) 980 else if (!strcmp (key, "region"))
1034 {
1035 m->region = get_region_by_name (value); 981 m->region = get_region_by_name (value);
1036 }
1037 else if (!strcmp (key, "shopitems")) 982 else if (!strcmp (key, "shopitems"))
1038 { 983 {
1039 *end = 0; 984 *end = 0;
1040 m->shopitems = parse_shop_string (value); 985 m->shopitems = parse_shop_string (value);
1041 } 986 }
1042 else if (!strcmp (key, "shopgreed")) 987 else if (!strcmp (key, "shopgreed"))
1043 {
1044 m->shopgreed = atof (value); 988 m->shopgreed = atof (value);
1045 }
1046 else if (!strcmp (key, "shopmin")) 989 else if (!strcmp (key, "shopmin"))
1047 {
1048 m->shopmin = atol (value); 990 m->shopmin = atol (value);
1049 }
1050 else if (!strcmp (key, "shopmax")) 991 else if (!strcmp (key, "shopmax"))
1051 {
1052 m->shopmax = atol (value); 992 m->shopmax = atol (value);
1053 }
1054 else if (!strcmp (key, "shoprace")) 993 else if (!strcmp (key, "shoprace"))
1055 { 994 {
1056 *end = 0; 995 *end = 0;
1057 m->shoprace = strdup_local (value); 996 m->shoprace = strdup (value);
1058 } 997 }
1059 else if (!strcmp (key, "outdoor")) 998 else if (!strcmp (key, "outdoor"))
1060 {
1061 m->outdoor = atoi (value); 999 m->outdoor = atoi (value);
1062 }
1063 else if (!strcmp (key, "temp")) 1000 else if (!strcmp (key, "temp"))
1064 {
1065 m->temp = atoi (value); 1001 m->temp = atoi (value);
1066 }
1067 else if (!strcmp (key, "pressure")) 1002 else if (!strcmp (key, "pressure"))
1068 {
1069 m->pressure = atoi (value); 1003 m->pressure = atoi (value);
1070 }
1071 else if (!strcmp (key, "humid")) 1004 else if (!strcmp (key, "humid"))
1072 {
1073 m->humid = atoi (value); 1005 m->humid = atoi (value);
1074 }
1075 else if (!strcmp (key, "windspeed")) 1006 else if (!strcmp (key, "windspeed"))
1076 {
1077 m->windspeed = atoi (value); 1007 m->windspeed = atoi (value);
1078 }
1079 else if (!strcmp (key, "winddir")) 1008 else if (!strcmp (key, "winddir"))
1080 {
1081 m->winddir = atoi (value); 1009 m->winddir = atoi (value);
1082 }
1083 else if (!strcmp (key, "sky")) 1010 else if (!strcmp (key, "sky"))
1084 {
1085 m->sky = atoi (value); 1011 m->sky = atoi (value);
1086 }
1087 else if (!strcmp (key, "nosmooth")) 1012 else if (!strcmp (key, "nosmooth"))
1088 {
1089 m->nosmooth = atoi (value); 1013 m->nosmooth = atoi (value);
1090 }
1091 else if (!strncmp (key, "tile_path_", 10)) 1014 else if (!strncmp (key, "tile_path_", 10))
1092 { 1015 {
1093 int tile = atoi (key + 10); 1016 int tile = atoi (key + 10);
1094 1017
1095 if (tile < 1 || tile > 4) 1018 if (tile < 1 || tile > 4)
… …
1128 } 1051 }
1129 1052
1130 if (editor) 1053 if (editor)
1131 { 1054 {
1132 /* Use the value as in the file. */ 1055 /* Use the value as in the file. */
1133 m->tile_path[tile - 1] = strdup_local (value); 1056 m->tile_path[tile - 1] = strdup (value);
1134 } 1057 }
1135 else if (path != NULL) 1058 else if (path != NULL)
1136 { 1059 {
1137 /* Use the normalized value. */ 1060 /* Use the normalized value. */
1138 m->tile_path[tile - 1] = strdup_local (path); 1061 m->tile_path[tile - 1] = strdup (path);
1139 } 1062 }
1140 } /* end if tile direction (in)valid */ 1063 } /* end if tile direction (in)valid */
1141 } 1064 }
1142 else 1065 else
1143 {
1144 LOG (llevError, "Got unknown value in map header: %s %s\n", key, value); 1066 LOG (llevError, "Got unknown value in map header: %s %s\n", key, value);
1145 }
1146 } 1067 }
1068
1147 if (!key || strcmp (key, "end")) 1069 if (!key || strcmp (key, "end"))
1148 { 1070 {
1149 LOG (llevError, "Got premature eof on map header!\n"); 1071 LOG (llevError, "Got premature eof on map header!\n");
1150 return 1; 1072 return 1;
1151 } 1073 }
1074
1152 return 0; 1075 return 0;
1153} 1076}
1154 1077
1155/* 1078/*
1156 * Opens the file "filename" and reads information about the map 1079 * Opens the file "filename" and reads information about the map
1157 * from the given file, and stores it in a newly allocated 1080 * from the given file, and stores it in a newly allocated
1158 * mapstruct. A pointer to this structure is returned, or NULL on failure. 1081 * maptile. A pointer to this structure is returned, or NULL on failure.
1159 * flags correspond to those in map.h. Main ones used are 1082 * 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 1083 * 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 1084 * 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. 1085 * 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 1086 * MAP_STYLE: style map - don't add active objects, don't add to server
1164 * managed map list. 1087 * managed map list.
1165 */ 1088 */
1166 1089
1167mapstruct * 1090maptile *
1168load_original_map (const char *filename, int flags) 1091load_original_map (const char *filename, int flags)
1169{ 1092{
1170 mapstruct *m; 1093 maptile *m;
1171 char pathname[MAX_BUF]; 1094 char pathname[MAX_BUF];
1172 1095
1173 if (flags & MAP_PLAYER_UNIQUE) 1096 if (flags & MAP_PLAYER_UNIQUE)
1174 strcpy (pathname, filename); 1097 strcpy (pathname, filename);
1175 else if (flags & MAP_OVERLAY) 1098 else if (flags & MAP_OVERLAY)
… …
1189 strcpy (m->path, filename); 1112 strcpy (m->path, filename);
1190 if (load_map_header (thawer, m)) 1113 if (load_map_header (thawer, m))
1191 { 1114 {
1192 LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags); 1115 LOG (llevError, "Error loading map header for %s, flags=%d\n", filename, flags);
1193 delete_map (m); 1116 delete_map (m);
1194 return NULL; 1117 return 0;
1195 } 1118 }
1196 1119
1197 allocate_map (m); 1120 m->allocate ();
1198 1121
1199 m->in_memory = MAP_LOADING; 1122 m->in_memory = MAP_LOADING;
1200 load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE)); 1123 load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE));
1201 1124
1202 m->in_memory = MAP_IN_MEMORY; 1125 m->in_memory = MAP_IN_MEMORY;
1203 if (!MAP_DIFFICULTY (m)) 1126 if (!m->difficulty)
1204 MAP_DIFFICULTY (m) = calculate_difficulty (m); 1127 m->difficulty = calculate_difficulty (m);
1205 set_map_reset_time (m); 1128 set_map_reset_time (m);
1206 m->instantiate (); 1129 m->instantiate ();
1207 return (m); 1130 return (m);
1208} 1131}
1209 1132
… …
1211 * Loads a map, which has been loaded earlier, from file. 1134 * Loads a map, which has been loaded earlier, from file.
1212 * Return the map object we load into (this can change from the passed 1135 * Return the map object we load into (this can change from the passed
1213 * option if we can't find the original map) 1136 * option if we can't find the original map)
1214 */ 1137 */
1215 1138
1216static mapstruct * 1139static maptile *
1217load_temporary_map (mapstruct *m) 1140load_temporary_map (maptile *m)
1218{ 1141{
1219 char buf[MAX_BUF]; 1142 char buf[MAX_BUF];
1220 1143
1221 if (!m->tmpname) 1144 if (!m->tmpname)
1222 { 1145 {
… …
1248 LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname); 1171 LOG (llevError, "Error loading map header for %s (%s)\n", m->path, m->tmpname);
1249 delete_map (m); 1172 delete_map (m);
1250 m = load_original_map (m->path, 0); 1173 m = load_original_map (m->path, 0);
1251 return NULL; 1174 return NULL;
1252 } 1175 }
1176
1253 allocate_map (m); 1177 m->allocate ();
1254 1178
1255 m->in_memory = MAP_LOADING; 1179 m->in_memory = MAP_LOADING;
1256 load_objects (m, thawer, 0); 1180 load_objects (m, thawer, 0);
1257 1181
1258 m->in_memory = MAP_IN_MEMORY; 1182 m->in_memory = MAP_IN_MEMORY;
… …
1264 * Loads a map, which has been loaded earlier, from file. 1188 * Loads a map, which has been loaded earlier, from file.
1265 * Return the map object we load into (this can change from the passed 1189 * Return the map object we load into (this can change from the passed
1266 * option if we can't find the original map) 1190 * option if we can't find the original map)
1267 */ 1191 */
1268 1192
1269mapstruct * 1193maptile *
1270load_overlay_map (const char *filename, mapstruct *m) 1194load_overlay_map (const char *filename, maptile *m)
1271{ 1195{
1272 char pathname[MAX_BUF]; 1196 char pathname[MAX_BUF];
1273 1197
1274 strcpy (pathname, create_overlay_pathname (filename)); 1198 strcpy (pathname, create_overlay_pathname (filename));
1275 1199
… …
1281 if (load_map_header (thawer, m)) 1205 if (load_map_header (thawer, m))
1282 { 1206 {
1283 LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname); 1207 LOG (llevError, "Error loading map header for overlay %s (%s)\n", m->path, pathname);
1284 delete_map (m); 1208 delete_map (m);
1285 m = load_original_map (m->path, 0); 1209 m = load_original_map (m->path, 0);
1286 return NULL; 1210 return 0;
1287 } 1211 }
1288 /*allocate_map(m); */ 1212 /*m->allocate ();*/
1289 1213
1290 m->in_memory = MAP_LOADING; 1214 m->in_memory = MAP_LOADING;
1291 load_objects (m, thawer, MAP_OVERLAY); 1215 load_objects (m, thawer, MAP_OVERLAY);
1292 1216
1293 m->in_memory = MAP_IN_MEMORY; 1217 m->in_memory = MAP_IN_MEMORY;
… …
1298 * This is the start of unique map handling code 1222 * This is the start of unique map handling code
1299 *****************************************************************************/ 1223 *****************************************************************************/
1300 1224
1301/* This goes through map 'm' and removed any unique items on the map. */ 1225/* This goes through map 'm' and removed any unique items on the map. */
1302static void 1226static void
1303delete_unique_items (mapstruct *m) 1227delete_unique_items (maptile *m)
1304{ 1228{
1305 int i, j, unique; 1229 int i, j, unique;
1306 object *op, *next; 1230 object *op, *next;
1307 1231
1308 for (i = 0; i < MAP_WIDTH (m); i++) 1232 for (i = 0; i < m->width; i++)
1309 for (j = 0; j < MAP_HEIGHT (m); j++) 1233 for (j = 0; j < m->height; j++)
1310 { 1234 {
1311 unique = 0; 1235 unique = 0;
1236
1312 for (op = get_map_ob (m, i, j); op; op = next) 1237 for (op = GET_MAP_OB (m, i, j); op; op = next)
1313 { 1238 {
1314 next = op->above; 1239 next = op->above;
1240
1315 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) 1241 if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE))
1316 unique = 1; 1242 unique = 1;
1243
1317 if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique)) 1244 if (op->head == NULL && (QUERY_FLAG (op, FLAG_UNIQUE) || unique))
1318 { 1245 {
1319 clean_object (op); 1246 op->destroy_inv (false);
1320 if (QUERY_FLAG (op, FLAG_IS_LINKED)) 1247 op->destroy ();
1321 remove_button_link (op);
1322 remove_ob (op);
1323 free_object (op);
1324 } 1248 }
1325 } 1249 }
1326 } 1250 }
1327} 1251}
1328 1252
1329
1330/* 1253/*
1331 * Loads unique objects from file(s) into the map which is in memory 1254 * Loads unique objects from file(s) into the map which is in memory
1332 * m is the map to load unique items into. 1255 * m is the map to load unique items into.
1333 */ 1256 */
1334static void 1257static void
1335load_unique_objects (mapstruct *m) 1258load_unique_objects (maptile *m)
1336{ 1259{
1337 int count; 1260 int count;
1338 char firstname[MAX_BUF]; 1261 char firstname[MAX_BUF];
1339 1262
1340 for (count = 0; count < 10; count++) 1263 for (count = 0; count < 10; count++)
… …
1353 return; 1276 return;
1354 1277
1355 m->in_memory = MAP_LOADING; 1278 m->in_memory = MAP_LOADING;
1356 if (m->tmpname == NULL) /* if we have loaded unique items from */ 1279 if (m->tmpname == NULL) /* if we have loaded unique items from */
1357 delete_unique_items (m); /* original map before, don't duplicate them */ 1280 delete_unique_items (m); /* original map before, don't duplicate them */
1281
1358 load_objects (m, thawer, 0); 1282 load_objects (m, thawer, 0);
1359 1283
1360 m->in_memory = MAP_IN_MEMORY; 1284 m->in_memory = MAP_IN_MEMORY;
1361} 1285}
1362
1363 1286
1364/* 1287/*
1365 * Saves a map to file. If flag is set, it is saved into the same 1288 * 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 1289 * file it was (originally) loaded from. Otherwise a temporary
1367 * filename will be genarated, and the file will be stored there. 1290 * filename will be genarated, and the file will be stored there.
1368 * The temporary filename will be stored in the mapstructure. 1291 * The temporary filename will be stored in the maptileure.
1369 * If the map is unique, we also save to the filename in the map 1292 * If the map is unique, we also save to the filename in the map
1370 * (this should have been updated when first loaded) 1293 * (this should have been updated when first loaded)
1371 */ 1294 */
1372
1373int 1295int
1374new_save_map (mapstruct *m, int flag) 1296new_save_map (maptile *m, int flag)
1375{ 1297{
1376 char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF]; 1298 char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF];
1377 int i; 1299 int i;
1378 1300
1379 if (flag && !*m->path) 1301 if (flag && !*m->path)
… …
1397 make_path_to_file (filename); 1319 make_path_to_file (filename);
1398 } 1320 }
1399 else 1321 else
1400 { 1322 {
1401 if (!m->tmpname) 1323 if (!m->tmpname)
1402 m->tmpname = tempnam_local (settings.tmpdir, NULL); 1324 m->tmpname = tempnam (settings.tmpdir, NULL);
1403 1325
1404 strcpy (filename, m->tmpname); 1326 strcpy (filename, m->tmpname);
1405 } 1327 }
1406 1328
1407 LOG (llevDebug, "Saving map %s to %s\n", m->path, filename); 1329 LOG (llevDebug, "Saving map %s to %s\n", m->path, filename);
… …
1431 print_shop_string (m, shop); 1353 print_shop_string (m, shop);
1432 fprintf (freezer, "shopitems %s\n", shop); 1354 fprintf (freezer, "shopitems %s\n", shop);
1433 } 1355 }
1434 if (m->shopgreed) 1356 if (m->shopgreed)
1435 fprintf (freezer, "shopgreed %f\n", m->shopgreed); 1357 fprintf (freezer, "shopgreed %f\n", m->shopgreed);
1436#ifndef WIN32
1437 if (m->shopmin) 1358 if (m->shopmin)
1438 fprintf (freezer, "shopmin %llu\n", m->shopmin); 1359 fprintf (freezer, "shopmin %llu\n", m->shopmin);
1439 if (m->shopmax) 1360 if (m->shopmax)
1440 fprintf (freezer, "shopmax %llu\n", m->shopmax); 1361 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) 1362 if (m->shoprace)
1448 fprintf (freezer, "shoprace %s\n", m->shoprace); 1363 fprintf (freezer, "shoprace %s\n", m->shoprace);
1449 if (m->darkness) 1364 if (m->darkness)
1450 fprintf (freezer, "darkness %d\n", m->darkness); 1365 fprintf (freezer, "darkness %d\n", m->darkness);
1451 if (m->width) 1366 if (m->width)
… …
1516 freezer.save (filename); 1431 freezer.save (filename);
1517 1432
1518 return 0; 1433 return 0;
1519} 1434}
1520 1435
1521
1522/*
1523 * Remove and free all objects in the inventory of the given object.
1524 * object.c ?
1525 */
1526
1527void
1528clean_object (object *op)
1529{
1530 object *tmp, *next;
1531
1532 for (tmp = op->inv; tmp; tmp = next)
1533 {
1534 next = tmp->below;
1535 clean_object (tmp);
1536 if (QUERY_FLAG (tmp, FLAG_IS_LINKED))
1537 remove_button_link (tmp);
1538 remove_ob (tmp);
1539 free_object (tmp);
1540 }
1541}
1542
1543/* 1436/*
1544 * Remove and free all objects in the given map. 1437 * Remove and free all objects in the given map.
1545 */ 1438 */
1546
1547void 1439void
1548free_all_objects (mapstruct *m) 1440free_all_objects (maptile *m)
1549{ 1441{
1550 int i, j; 1442 if (!m->spaces)
1551 object *op; 1443 return;
1552 1444
1553 for (i = 0; i < MAP_WIDTH (m); i++) 1445 for (int i = 0; i < m->width; i++)
1554 for (j = 0; j < MAP_HEIGHT (m); j++) 1446 for (int j = 0; j < m->height; j++)
1555 { 1447 {
1556 object *previous_obj = NULL; 1448 mapspace &ms = m->at (i, j);
1557 1449
1558 while ((op = GET_MAP_OB (m, i, j)) != NULL) 1450 while (object *op = ms.bot)
1559 { 1451 {
1560 if (op == previous_obj)
1561 {
1562 LOG (llevDebug, "free_all_objects: Link error, bailing out.\n");
1563 break;
1564 }
1565 previous_obj = op;
1566 if (op->head != NULL) 1452 if (op->head)
1567 op = op->head; 1453 op = op->head;
1568 1454
1569 /* If the map isn't in memory, free_object will remove and 1455 op->destroy_inv (false);
1570 * free objects in op's inventory. So let it do the job. 1456 op->destroy ();
1571 */
1572 if (m->in_memory == MAP_IN_MEMORY)
1573 clean_object (op);
1574 remove_ob (op);
1575 free_object (op);
1576 } 1457 }
1577 } 1458 }
1578} 1459}
1579 1460
1580/* 1461/*
1581 * Frees everything allocated by the given mapstructure. 1462 * Frees everything allocated by the given maptileure.
1582 * don't free tmpname - our caller is left to do that 1463 * don't free tmpname - our caller is left to do that
1583 */ 1464 */
1584
1585void 1465void
1586free_map (mapstruct *m, int flag) 1466free_map (maptile *m, int flag)
1587{ 1467{
1588 int i; 1468 if (!m->in_memory) //TODO: makes no sense to me?
1589
1590 if (!m->in_memory)
1591 {
1592 LOG (llevError, "Trying to free freed map.\n");
1593 return; 1469 return;
1594 } 1470
1471 m->in_memory = MAP_SAVING;
1472
1473 // TODO: use new/delete
1474
1595 if (flag && m->spaces) 1475 if (flag && m->spaces)
1596 free_all_objects (m); 1476 free_all_objects (m);
1597 if (m->name) 1477
1598 FREE_AND_CLEAR (m->name); 1478 sfree (m->spaces, m->size ()), m->spaces = 0;
1599 if (m->spaces) 1479
1600 FREE_AND_CLEAR (m->spaces); 1480 free (m->name), m->name = 0;
1601 if (m->msg) 1481 free (m->msg), m->msg = 0;
1602 FREE_AND_CLEAR (m->msg); 1482 free (m->maplore), m->maplore = 0;
1603 if (m->maplore) 1483 free (m->shoprace), m->shoprace = 0;
1604 FREE_AND_CLEAR (m->maplore); 1484 delete [] m->shopitems, m->shopitems = 0;
1605 if (m->shopitems) 1485
1606 delete[]m->shopitems;
1607 m->shopitems = 0;
1608 if (m->shoprace)
1609 FREE_AND_CLEAR (m->shoprace);
1610 if (m->buttons) 1486 if (m->buttons)
1611 free_objectlinkpt (m->buttons); 1487 free_objectlinkpt (m->buttons), m->buttons = 0;
1612 m->buttons = NULL; 1488
1613 for (i = 0; i < 4; i++) 1489 for (int i = 0; i < 4; i++)
1614 { 1490 free (m->tile_path[i]), m->tile_path[i] = 0;
1615 if (m->tile_path[i]) 1491
1616 FREE_AND_CLEAR (m->tile_path[i]);
1617 m->tile_map[i] = NULL;
1618 }
1619 m->in_memory = MAP_SWAPPED; 1492 m->in_memory = MAP_SWAPPED;
1620} 1493}
1621 1494
1622/* 1495maptile::~maptile ()
1623 * function: vanish mapstruct 1496{
1624 * m : pointer to mapstruct, if NULL no action 1497 assert (destroyed ());
1625 * this deletes all the data on the map (freeing pointers) 1498}
1626 * and then removes this map from the global linked list of maps.
1627 */
1628 1499
1629void 1500void
1630delete_map (mapstruct *m) 1501maptile::do_destroy ()
1631{ 1502{
1632 mapstruct *tmp, *last; 1503 attachable::do_destroy ();
1633 int i;
1634 1504
1635 if (!m)
1636 return;
1637
1638 m->clear ();
1639
1640 if (m->in_memory == MAP_IN_MEMORY)
1641 {
1642 /* change to MAP_SAVING, even though we are not,
1643 * so that remove_ob doesn't do as much work.
1644 */
1645 m->in_memory = MAP_SAVING;
1646 free_map (m, 1); 1505 free_map (this, 1);
1647 } 1506 free (tmpname), tmpname = 0;
1648 /* move this out of free_map, since tmpname can still be needed if 1507
1649 * the map is swapped out.
1650 */
1651 if (m->tmpname)
1652 {
1653 free (m->tmpname);
1654 m->tmpname = NULL;
1655 }
1656 last = NULL;
1657 /* We need to look through all the maps and see if any maps 1508 /* We need to look through all the maps and see if any maps
1658 * are pointing at this one for tiling information. Since 1509 * are pointing at this one for tiling information. Since
1659 * tiling can be assymetric, we just can not look to see which 1510 * tiling can be asymetric, we just can not look to see which
1660 * maps this map tiles with and clears those. 1511 * maps this map tiles with and clears those.
1661 */ 1512 */
1662 for (tmp = first_map; tmp != NULL; tmp = tmp->next) 1513 //TODO: non-euclidean-tiling MUST GO
1663 { 1514 for_all_maps (m)
1664 if (tmp->next == m)
1665 last = tmp;
1666
1667 /* This should hopefully get unrolled on a decent compiler */
1668 for (i = 0; i < 4; i++) 1515 for (int i = 0; i < 4; i++)
1669 if (tmp->tile_map[i] == m) 1516 if (m->tile_map[i] == this)
1670 tmp->tile_map[i] = NULL; 1517 m->tile_map[i] = 0;
1671 }
1672 1518
1673 /* If last is null, then this should be the first map in the list */ 1519 if (first_map == this)
1674 if (!last)
1675 {
1676 if (m == first_map)
1677 first_map = m->next; 1520 first_map = next;
1678 else
1679 /* m->path is a static char, so should hopefully still have
1680 * some useful data in it.
1681 */
1682 LOG (llevError, "delete_map: Unable to find map %s in list\n", m->path);
1683 }
1684 else 1521 else
1685 last->next = m->next; 1522 for_all_maps (m)
1686 1523 if (m->next = this)
1687 delete m; 1524 {
1525 m->next = next;
1526 break;
1527 }
1688} 1528}
1689 1529
1690 1530//TODO: must go
1531void
1532delete_map (maptile *m)
1533{
1534 if (m)
1535 m->destroy ();
1536}
1691 1537
1692/* 1538/*
1693 * Makes sure the given map is loaded and swapped in. 1539 * Makes sure the given map is loaded and swapped in.
1694 * name is path name of the map. 1540 * name is path name of the map.
1695 * flags meaning: 1541 * flags meaning:
… …
1698 * 0x2 (MAP_PLAYER_UNIQUE) - this is a unique map for each player. 1544 * 0x2 (MAP_PLAYER_UNIQUE) - this is a unique map for each player.
1699 * dont do any more name translation on it. 1545 * dont do any more name translation on it.
1700 * 1546 *
1701 * Returns a pointer to the given map. 1547 * Returns a pointer to the given map.
1702 */ 1548 */
1703 1549maptile *
1704mapstruct *
1705ready_map_name (const char *name, int flags) 1550ready_map_name (const char *name, int flags)
1706{ 1551{
1707 mapstruct *m;
1708
1709 if (!name) 1552 if (!name)
1710 return (NULL); 1553 return 0;
1711 1554
1712 /* Have we been at this level before? */ 1555 /* Have we been at this level before? */
1713 m = has_been_loaded (name); 1556 maptile *m = has_been_loaded (name);
1714 1557
1715 /* Map is good to go, so just return it */ 1558 /* Map is good to go, so just return it */
1716 if (m && (m->in_memory == MAP_LOADING || m->in_memory == MAP_IN_MEMORY)) 1559 if (m && (m->in_memory == MAP_LOADING || m->in_memory == MAP_IN_MEMORY))
1717 {
1718 return m; 1560 return m;
1719 }
1720 1561
1721 /* unique maps always get loaded from their original location, and never 1562 /* unique maps always get loaded from their original location, and never
1722 * a temp location. Likewise, if map_flush is set, or we have never loaded 1563 * a temp location. Likewise, if map_flush is set, or we have never loaded
1723 * this map, load it now. I removed the reset checking from here - 1564 * this map, load it now. I removed the reset checking from here -
1724 * it seems the probability of a player trying to enter a map that should 1565 * it seems the probability of a player trying to enter a map that should
… …
1726 * a bit cleaner (and players probably shouldn't rely on exact timing for 1567 * a bit cleaner (and players probably shouldn't rely on exact timing for
1727 * resets in any case - if they really care, they should use the 'maps command. 1568 * resets in any case - if they really care, they should use the 'maps command.
1728 */ 1569 */
1729 if ((flags & (MAP_FLUSH | MAP_PLAYER_UNIQUE)) || !m) 1570 if ((flags & (MAP_FLUSH | MAP_PLAYER_UNIQUE)) || !m)
1730 { 1571 {
1731
1732 /* first visit or time to reset */ 1572 /* first visit or time to reset */
1733 if (m) 1573 if (m)
1734 { 1574 {
1735 clean_tmp_map (m); /* Doesn't make much difference */ 1575 clean_tmp_map (m); /* Doesn't make much difference */
1736 delete_map (m); 1576 delete_map (m);
… …
1814 * have a difficulty set than using this function - human calculation 1654 * have a difficulty set than using this function - human calculation
1815 * is much better than this functions guesswork. 1655 * is much better than this functions guesswork.
1816 */ 1656 */
1817 1657
1818int 1658int
1819calculate_difficulty (mapstruct *m) 1659calculate_difficulty (maptile *m)
1820{ 1660{
1821 object *op; 1661 object *op;
1822 archetype *at; 1662 archetype *at;
1823 int x, y, i; 1663 int x, y, i;
1824 long monster_cnt = 0; 1664 long monster_cnt = 0;
1825 double avgexp = 0; 1665 double avgexp = 0;
1826 sint64 total_exp = 0; 1666 sint64 total_exp = 0;
1827 1667
1828 if (MAP_DIFFICULTY (m)) 1668 if (m->difficulty)
1829 { 1669 {
1830 LOG (llevDebug, "Using stored map difficulty: %d\n", MAP_DIFFICULTY (m)); 1670 LOG (llevDebug, "Using stored map difficulty: %d\n", m->difficulty);
1831 return MAP_DIFFICULTY (m); 1671 return m->difficulty;
1832 } 1672 }
1833 1673
1834 for (x = 0; x < MAP_WIDTH (m); x++) 1674 for (x = 0; x < m->width; x++)
1835 for (y = 0; y < MAP_HEIGHT (m); y++) 1675 for (y = 0; y < m->height; y++)
1836 for (op = get_map_ob (m, x, y); op != NULL; op = op->above) 1676 for (op = GET_MAP_OB (m, x, y); op != NULL; op = op->above)
1837 { 1677 {
1838 if (QUERY_FLAG (op, FLAG_MONSTER)) 1678 if (QUERY_FLAG (op, FLAG_MONSTER))
1839 { 1679 {
1840 total_exp += op->stats.exp; 1680 total_exp += op->stats.exp;
1841 monster_cnt++; 1681 monster_cnt++;
… …
1866 1706
1867 return 1; 1707 return 1;
1868} 1708}
1869 1709
1870void 1710void
1871clean_tmp_map (mapstruct *m) 1711clean_tmp_map (maptile *m)
1872{ 1712{
1873 if (m->tmpname == NULL) 1713 if (m->tmpname == NULL)
1874 return; 1714 return;
1875 INVOKE_MAP (CLEAN, m); 1715 INVOKE_MAP (CLEAN, m);
1876 (void) unlink (m->tmpname); 1716 (void) unlink (m->tmpname);
… …
1889 if (first_map->in_memory == MAP_SAVING) 1729 if (first_map->in_memory == MAP_SAVING)
1890 first_map->in_memory = MAP_IN_MEMORY; 1730 first_map->in_memory = MAP_IN_MEMORY;
1891 delete_map (first_map); 1731 delete_map (first_map);
1892 real_maps++; 1732 real_maps++;
1893 } 1733 }
1734
1894 LOG (llevDebug, "free_all_maps: Freed %d maps\n", real_maps); 1735 LOG (llevDebug, "free_all_maps: Freed %d maps\n", real_maps);
1895} 1736}
1896 1737
1897/* change_map_light() - used to change map light level (darkness) 1738/* change_map_light() - used to change map light level (darkness)
1898 * up or down. Returns true if successful. It should now be 1739 * up or down. Returns true if successful. It should now be
… …
1901 * to maps than los. 1742 * to maps than los.
1902 * postive values make it darker, negative make it brighter 1743 * postive values make it darker, negative make it brighter
1903 */ 1744 */
1904 1745
1905int 1746int
1906change_map_light (mapstruct *m, int change) 1747change_map_light (maptile *m, int change)
1907{ 1748{
1908 int new_level = m->darkness + change; 1749 int new_level = m->darkness + change;
1909 1750
1910 /* Nothing to do */ 1751 /* Nothing to do */
1911 if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS)) 1752 if (!change || (new_level <= 0 && m->darkness == 0) || (new_level >= MAX_DARKNESS && m->darkness >= MAX_DARKNESS))
… …
1934 /* All clients need to get re-updated for the change */ 1775 /* All clients need to get re-updated for the change */
1935 update_all_map_los (m); 1776 update_all_map_los (m);
1936 return 1; 1777 return 1;
1937} 1778}
1938 1779
1939
1940/* 1780/*
1941 * This function updates various attributes about a specific space 1781 * This function updates various attributes about a specific space
1942 * on the map (what it looks like, whether it blocks magic, 1782 * on the map (what it looks like, whether it blocks magic,
1943 * has a living creatures, prevents people from passing 1783 * has a living creatures, prevents people from passing
1944 * through, etc) 1784 * through, etc)
1945 */ 1785 */
1946void 1786void
1947update_position (mapstruct *m, int x, int y) 1787mapspace::update_ ()
1948{ 1788{
1949 object *tmp, *last = NULL; 1789 object *tmp, *last = 0;
1950 uint8 flags = 0, oldflags, light = 0, anywhere = 0; 1790 uint8 flags = 0, light = 0, anywhere = 0;
1951 New_Face *top, *floor, *middle; 1791 New_Face *top, *floor, *middle;
1952 object *top_obj, *floor_obj, *middle_obj; 1792 object *top_obj, *floor_obj, *middle_obj;
1953 MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0; 1793 MoveType move_block = 0, move_slow = 0, move_on = 0, move_off = 0, move_allow = 0;
1954 1794
1955 oldflags = GET_MAP_FLAGS (m, x, y);
1956 if (!(oldflags & P_NEED_UPDATE))
1957 {
1958 LOG (llevDebug, "update_position called with P_NEED_UPDATE not set: %s (%d, %d)\n", m->path, x, y);
1959 return;
1960 }
1961
1962 middle = blank_face; 1795 middle = blank_face;
1963 top = blank_face; 1796 top = blank_face;
1964 floor = blank_face; 1797 floor = blank_face;
1965 1798
1966 middle_obj = NULL; 1799 middle_obj = 0;
1967 top_obj = NULL; 1800 top_obj = 0;
1968 floor_obj = NULL; 1801 floor_obj = 0;
1969 1802
1970 for (tmp = get_map_ob (m, x, y); tmp; last = tmp, tmp = tmp->above) 1803 for (tmp = bot; tmp; last = tmp, tmp = tmp->above)
1971 { 1804 {
1972
1973 /* This could be made additive I guess (two lights better than 1805 /* This could be made additive I guess (two lights better than
1974 * one). But if so, it shouldn't be a simple additive - 2 1806 * one). But if so, it shouldn't be a simple additive - 2
1975 * light bulbs do not illuminate twice as far as once since 1807 * light bulbs do not illuminate twice as far as once since
1976 * it is a disapation factor that is squared (or is it cubed?) 1808 * it is a dissapation factor that is cubed.
1977 */ 1809 */
1978 if (tmp->glow_radius > light) 1810 if (tmp->glow_radius > light)
1979 light = tmp->glow_radius; 1811 light = tmp->glow_radius;
1980 1812
1981 /* This call is needed in order to update objects the player 1813 /* This call is needed in order to update objects the player
… …
2019 { 1851 {
2020 middle = tmp->face; 1852 middle = tmp->face;
2021 middle_obj = tmp; 1853 middle_obj = tmp;
2022 } 1854 }
2023 } 1855 }
1856
2024 if (tmp == tmp->above) 1857 if (tmp == tmp->above)
2025 { 1858 {
2026 LOG (llevError, "Error in structure of map\n"); 1859 LOG (llevError, "Error in structure of map\n");
2027 exit (-1); 1860 exit (-1);
2028 } 1861 }
2029 1862
2030 move_slow |= tmp->move_slow; 1863 move_slow |= tmp->move_slow;
2031 move_block |= tmp->move_block; 1864 move_block |= tmp->move_block;
2032 move_on |= tmp->move_on; 1865 move_on |= tmp->move_on;
2033 move_off |= tmp->move_off; 1866 move_off |= tmp->move_off;
2034 move_allow |= tmp->move_allow; 1867 move_allow |= tmp->move_allow;
2035 1868
2036 if (QUERY_FLAG (tmp, FLAG_ALIVE))
2037 flags |= P_IS_ALIVE;
2038 if (QUERY_FLAG (tmp, FLAG_NO_MAGIC))
2039 flags |= P_NO_MAGIC;
2040 if (QUERY_FLAG (tmp, FLAG_DAMNED))
2041 flags |= P_NO_CLERIC;
2042 if (tmp->type == SAFE_GROUND)
2043 flags |= P_SAFE;
2044
2045 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) 1869 if (QUERY_FLAG (tmp, FLAG_BLOCKSVIEW)) flags |= P_BLOCKSVIEW;
2046 flags |= P_BLOCKSVIEW; 1870 if (QUERY_FLAG (tmp, FLAG_NO_MAGIC)) flags |= P_NO_MAGIC;
2047 } /* for stack of objects */ 1871 if (tmp->type == PLAYER) flags |= P_PLAYER;
2048 1872 if (tmp->type == SAFE_GROUND) flags |= P_SAFE;
2049 /* we don't want to rely on this function to have accurate flags, but 1873 if (QUERY_FLAG (tmp, FLAG_ALIVE)) flags |= P_IS_ALIVE;
2050 * since we're already doing the work, we calculate them here. 1874 if (QUERY_FLAG (tmp, FLAG_DAMNED)) flags |= P_NO_CLERIC;
2051 * if they don't match, logic is broken someplace.
2052 */
2053 if (((oldflags & ~(P_NEED_UPDATE | P_NO_ERROR)) != flags) && (!(oldflags & P_NO_ERROR)))
2054 { 1875 }
2055 LOG (llevDebug, "update_position: updated flags do not match old flags: %s (old=%d,new=%d) %x != %x\n", 1876
2056 m->path, x, y, (oldflags & ~P_NEED_UPDATE), flags); 1877 this->light = light;
2057 } 1878 this->flags_ = flags;
2058 SET_MAP_FLAGS (m, x, y, flags); 1879 this->move_block = move_block & ~move_allow;
2059 SET_MAP_MOVE_BLOCK (m, x, y, move_block & ~move_allow); 1880 this->move_on = move_on;
2060 SET_MAP_MOVE_ON (m, x, y, move_on); 1881 this->move_off = move_off;
2061 SET_MAP_MOVE_OFF (m, x, y, move_off); 1882 this->move_slow = move_slow;
2062 SET_MAP_MOVE_SLOW (m, x, y, move_slow);
2063 1883
2064 /* At this point, we have a floor face (if there is a floor), 1884 /* At this point, we have a floor face (if there is a floor),
2065 * and the floor is set - we are not going to touch it at 1885 * and the floor is set - we are not going to touch it at
2066 * this point. 1886 * this point.
2067 * middle contains the highest visibility face. 1887 * middle contains the highest visibility face.
… …
2121 break; 1941 break;
2122 } 1942 }
2123 } 1943 }
2124 } 1944 }
2125 } 1945 }
1946
2126 if (middle == floor) 1947 if (middle == floor)
2127 middle = blank_face; 1948 middle = blank_face;
1949
2128 if (top == middle) 1950 if (top == middle)
2129 middle = blank_face; 1951 middle = blank_face;
2130 SET_MAP_FACE (m, x, y, top, 0);
2131 if (top != blank_face)
2132 SET_MAP_FACE_OBJ (m, x, y, top_obj, 0);
2133 else
2134 SET_MAP_FACE_OBJ (m, x, y, NULL, 0);
2135 SET_MAP_FACE (m, x, y, middle, 1);
2136 if (middle != blank_face)
2137 SET_MAP_FACE_OBJ (m, x, y, middle_obj, 1);
2138 else
2139 SET_MAP_FACE_OBJ (m, x, y, NULL, 1);
2140 SET_MAP_FACE (m, x, y, floor, 2);
2141 if (floor != blank_face)
2142 SET_MAP_FACE_OBJ (m, x, y, floor_obj, 2);
2143 else
2144 SET_MAP_FACE_OBJ (m, x, y, NULL, 2);
2145 SET_MAP_LIGHT (m, x, y, light);
2146}
2147 1952
1953 faces [0] = top; faces_obj [0] = top != blank_face ? top_obj : 0;
1954 faces [1] = middle; faces_obj [1] = middle != blank_face ? middle_obj : 0;
1955 faces [2] = floor; faces_obj [2] = floor != blank_face ? floor_obj : 0;
1956}
2148 1957
2149void 1958void
2150set_map_reset_time (mapstruct *map) 1959set_map_reset_time (maptile *map)
2151{ 1960{
2152 int timeout; 1961 int timeout;
2153 1962
2154 timeout = MAP_RESET_TIMEOUT (map); 1963 timeout = map->reset_timeout;
2155 if (timeout <= 0) 1964 if (timeout <= 0)
2156 timeout = MAP_DEFAULTRESET; 1965 timeout = MAP_DEFAULTRESET;
2157 if (timeout >= MAP_MAXRESET) 1966 if (timeout >= MAP_MAXRESET)
2158 timeout = MAP_MAXRESET; 1967 timeout = MAP_MAXRESET;
2159 MAP_WHEN_RESET (map) = seconds () + timeout; 1968 map->reset_time = time (0) + timeout;
2160} 1969}
2161 1970
2162/* this updates the orig_map->tile_map[tile_num] value after loading 1971/* 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 1972 * 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 1973 * 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 1974 * 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. 1975 * so that it is easier for calling functions to verify success.
2167 */ 1976 */
2168 1977
2169static mapstruct * 1978static maptile *
2170load_and_link_tiled_map (mapstruct *orig_map, int tile_num) 1979load_and_link_tiled_map (maptile *orig_map, int tile_num)
2171{ 1980{
2172 int dest_tile = (tile_num + 2) % 4; 1981 int dest_tile = (tile_num + 2) % 4;
2173 char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]); 1982 char *path = path_combine_and_normalize (orig_map->path, orig_map->tile_path[tile_num]);
2174 1983
2175 orig_map->tile_map[tile_num] = ready_map_name (path, 0); 1984 orig_map->tile_map[tile_num] = ready_map_name (path, 0);
… …
2190 * tiled maps. 1999 * tiled maps.
2191 * 2000 *
2192 * 2001 *
2193 */ 2002 */
2194int 2003int
2195out_of_map (mapstruct *m, int x, int y) 2004out_of_map (maptile *m, int x, int y)
2196{ 2005{
2197
2198 /* If we get passed a null map, this is obviously the 2006 /* If we get passed a null map, this is obviously the
2199 * case. This generally shouldn't happen, but if the 2007 * case. This generally shouldn't happen, but if the
2200 * map loads fail below, it could happen. 2008 * map loads fail below, it could happen.
2201 */ 2009 */
2202 if (!m) 2010 if (!m)
… …
2204 2012
2205 if (x < 0) 2013 if (x < 0)
2206 { 2014 {
2207 if (!m->tile_path[3]) 2015 if (!m->tile_path[3])
2208 return 1; 2016 return 1;
2017
2209 if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY) 2018 if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
2210 {
2211 load_and_link_tiled_map (m, 3); 2019 load_and_link_tiled_map (m, 3);
2212 } 2020
2213 return (out_of_map (m->tile_map[3], x + MAP_WIDTH (m->tile_map[3]), y)); 2021 return (out_of_map (m->tile_map[3], x + m->tile_map[3]->width, y));
2214 } 2022 }
2215 if (x >= MAP_WIDTH (m)) 2023
2024 if (x >= m->width)
2216 { 2025 {
2217 if (!m->tile_path[1]) 2026 if (!m->tile_path[1])
2218 return 1; 2027 return 1;
2028
2219 if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY) 2029 if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
2220 {
2221 load_and_link_tiled_map (m, 1); 2030 load_and_link_tiled_map (m, 1);
2222 } 2031
2223 return (out_of_map (m->tile_map[1], x - MAP_WIDTH (m), y)); 2032 return (out_of_map (m->tile_map[1], x - m->width, y));
2224 } 2033 }
2034
2225 if (y < 0) 2035 if (y < 0)
2226 { 2036 {
2227 if (!m->tile_path[0]) 2037 if (!m->tile_path[0])
2228 return 1; 2038 return 1;
2039
2229 if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY) 2040 if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
2230 {
2231 load_and_link_tiled_map (m, 0); 2041 load_and_link_tiled_map (m, 0);
2232 } 2042
2233 return (out_of_map (m->tile_map[0], x, y + MAP_HEIGHT (m->tile_map[0]))); 2043 return (out_of_map (m->tile_map[0], x, y + m->tile_map[0]->height));
2234 } 2044 }
2235 if (y >= MAP_HEIGHT (m)) 2045
2046 if (y >= m->height)
2236 { 2047 {
2237 if (!m->tile_path[2]) 2048 if (!m->tile_path[2])
2238 return 1; 2049 return 1;
2050
2239 if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY) 2051 if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
2240 {
2241 load_and_link_tiled_map (m, 2); 2052 load_and_link_tiled_map (m, 2);
2242 } 2053
2243 return (out_of_map (m->tile_map[2], x, y - MAP_HEIGHT (m))); 2054 return (out_of_map (m->tile_map[2], x, y - m->height));
2244 } 2055 }
2245 2056
2246 /* Simple case - coordinates are within this local 2057 /* Simple case - coordinates are within this local
2247 * map. 2058 * map.
2248 */ 2059 */
… …
2255 * the map as that the coordinates are really on, and 2066 * the map as that the coordinates are really on, and
2256 * updates x and y to be the localized coordinates. 2067 * updates x and y to be the localized coordinates.
2257 * Using this is more efficient of calling out_of_map 2068 * Using this is more efficient of calling out_of_map
2258 * and then figuring out what the real map is 2069 * and then figuring out what the real map is
2259 */ 2070 */
2260mapstruct * 2071maptile *
2261get_map_from_coord (mapstruct *m, sint16 * x, sint16 * y) 2072get_map_from_coord (maptile *m, sint16 * x, sint16 * y)
2262{ 2073{
2263 2074
2264 if (*x < 0) 2075 if (*x < 0)
2265 { 2076 {
2266 if (!m->tile_path[3]) 2077 if (!m->tile_path[3])
2267 return NULL; 2078 return 0;
2268 if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY) 2079 if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY)
2269 load_and_link_tiled_map (m, 3); 2080 load_and_link_tiled_map (m, 3);
2270 2081
2271 *x += MAP_WIDTH (m->tile_map[3]); 2082 *x += m->tile_map[3]->width;
2272 return (get_map_from_coord (m->tile_map[3], x, y)); 2083 return (get_map_from_coord (m->tile_map[3], x, y));
2273 } 2084 }
2274 if (*x >= MAP_WIDTH (m)) 2085
2086 if (*x >= m->width)
2275 { 2087 {
2276 if (!m->tile_path[1]) 2088 if (!m->tile_path[1])
2277 return NULL; 2089 return 0;
2090
2278 if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY) 2091 if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY)
2279 load_and_link_tiled_map (m, 1); 2092 load_and_link_tiled_map (m, 1);
2280 2093
2281 *x -= MAP_WIDTH (m); 2094 *x -= m->width;
2282 return (get_map_from_coord (m->tile_map[1], x, y)); 2095 return (get_map_from_coord (m->tile_map[1], x, y));
2283 } 2096 }
2097
2284 if (*y < 0) 2098 if (*y < 0)
2285 { 2099 {
2286 if (!m->tile_path[0]) 2100 if (!m->tile_path[0])
2287 return NULL; 2101 return 0;
2102
2288 if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY) 2103 if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY)
2289 load_and_link_tiled_map (m, 0); 2104 load_and_link_tiled_map (m, 0);
2290 2105
2291 *y += MAP_HEIGHT (m->tile_map[0]); 2106 *y += m->tile_map[0]->height;
2292 return (get_map_from_coord (m->tile_map[0], x, y)); 2107 return (get_map_from_coord (m->tile_map[0], x, y));
2293 } 2108 }
2294 if (*y >= MAP_HEIGHT (m)) 2109
2110 if (*y >= m->height)
2295 { 2111 {
2296 if (!m->tile_path[2]) 2112 if (!m->tile_path[2])
2297 return NULL; 2113 return 0;
2114
2298 if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY) 2115 if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY)
2299 load_and_link_tiled_map (m, 2); 2116 load_and_link_tiled_map (m, 2);
2300 2117
2301 *y -= MAP_HEIGHT (m); 2118 *y -= m->height;
2302 return (get_map_from_coord (m->tile_map[2], x, y)); 2119 return (get_map_from_coord (m->tile_map[2], x, y));
2303 } 2120 }
2304 2121
2305 /* Simple case - coordinates are within this local 2122 /* Simple case - coordinates are within this local
2306 * map. 2123 * map.
… …
2312/** 2129/**
2313 * Return whether map2 is adjacent to map1. If so, store the distance from 2130 * Return whether map2 is adjacent to map1. If so, store the distance from
2314 * map1 to map2 in dx/dy. 2131 * map1 to map2 in dx/dy.
2315 */ 2132 */
2316static int 2133static int
2317adjacent_map (const mapstruct *map1, const mapstruct *map2, int *dx, int *dy) 2134adjacent_map (const maptile *map1, const maptile *map2, int *dx, int *dy)
2318{ 2135{
2319 if (!map1 || !map2) 2136 if (!map1 || !map2)
2320 return 0; 2137 return 0;
2321 2138
2322 if (map1 == map2) 2139 if (map1 == map2)
… …
2326 2143
2327 } 2144 }
2328 else if (map1->tile_map[0] == map2) 2145 else if (map1->tile_map[0] == map2)
2329 { /* up */ 2146 { /* up */
2330 *dx = 0; 2147 *dx = 0;
2331 *dy = -MAP_HEIGHT (map2); 2148 *dy = -map2->height;
2332 } 2149 }
2333 else if (map1->tile_map[1] == map2) 2150 else if (map1->tile_map[1] == map2)
2334 { /* right */ 2151 { /* right */
2335 *dx = MAP_WIDTH (map1); 2152 *dx = map1->width;
2336 *dy = 0; 2153 *dy = 0;
2337 } 2154 }
2338 else if (map1->tile_map[2] == map2) 2155 else if (map1->tile_map[2] == map2)
2339 { /* down */ 2156 { /* down */
2340 *dx = 0; 2157 *dx = 0;
2341 *dy = MAP_HEIGHT (map1); 2158 *dy = map1->height;
2342 } 2159 }
2343 else if (map1->tile_map[3] == map2) 2160 else if (map1->tile_map[3] == map2)
2344 { /* left */ 2161 { /* left */
2345 *dx = -MAP_WIDTH (map2); 2162 *dx = -map2->width;
2346 *dy = 0; 2163 *dy = 0;
2347 2164
2348 } 2165 }
2349 else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2) 2166 else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2)
2350 { /* up right */ 2167 { /* up right */
2351 *dx = MAP_WIDTH (map1->tile_map[0]); 2168 *dx = map1->tile_map[0]->width;
2352 *dy = -MAP_HEIGHT (map1->tile_map[0]); 2169 *dy = -map1->tile_map[0]->height;
2353 } 2170 }
2354 else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[3] == map2) 2171 else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[3] == map2)
2355 { /* up left */ 2172 { /* up left */
2356 *dx = -MAP_WIDTH (map2); 2173 *dx = -map2->width;
2357 *dy = -MAP_HEIGHT (map1->tile_map[0]); 2174 *dy = -map1->tile_map[0]->height;
2358 } 2175 }
2359 else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[0] == map2) 2176 else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[0] == map2)
2360 { /* right up */ 2177 { /* right up */
2361 *dx = MAP_WIDTH (map1); 2178 *dx = map1->width;
2362 *dy = -MAP_HEIGHT (map2); 2179 *dy = -map2->height;
2363 } 2180 }
2364 else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[2] == map2) 2181 else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[2] == map2)
2365 { /* right down */ 2182 { /* right down */
2366 *dx = MAP_WIDTH (map1); 2183 *dx = map1->width;
2367 *dy = MAP_HEIGHT (map1->tile_map[1]); 2184 *dy = map1->tile_map[1]->height;
2368 } 2185 }
2369 else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[1] == map2) 2186 else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[1] == map2)
2370 { /* down right */ 2187 { /* down right */
2371 *dx = MAP_WIDTH (map1->tile_map[2]); 2188 *dx = map1->tile_map[2]->width;
2372 *dy = MAP_HEIGHT (map1); 2189 *dy = map1->height;
2373 } 2190 }
2374 else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[3] == map2) 2191 else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[3] == map2)
2375 { /* down left */ 2192 { /* down left */
2376 *dx = -MAP_WIDTH (map2); 2193 *dx = -map2->width;
2377 *dy = MAP_HEIGHT (map1); 2194 *dy = map1->height;
2378 } 2195 }
2379 else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[0] == map2) 2196 else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[0] == map2)
2380 { /* left up */ 2197 { /* left up */
2381 *dx = -MAP_WIDTH (map1->tile_map[3]); 2198 *dx = -map1->tile_map[3]->width;
2382 *dy = -MAP_HEIGHT (map2); 2199 *dy = -map2->height;
2383 } 2200 }
2384 else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2) 2201 else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2)
2385 { /* left down */ 2202 { /* left down */
2386 *dx = -MAP_WIDTH (map1->tile_map[3]); 2203 *dx = -map1->tile_map[3]->width;
2387 *dy = MAP_HEIGHT (map1->tile_map[3]); 2204 *dy = map1->tile_map[3]->height;
2388 2205
2389 } 2206 }
2390 else 2207 else
2391 { /* not "adjacent" enough */ 2208 { /* not "adjacent" enough */
2392 return 0; 2209 return 0;
… …
2480 * for something in the future. Also, since no object is pasted, the best 2297 * for something in the future. Also, since no object is pasted, the best
2481 * field of the rv_vector is set to NULL. 2298 * field of the rv_vector is set to NULL.
2482 */ 2299 */
2483 2300
2484void 2301void
2485get_rangevector_from_mapcoord (const mapstruct *m, int x, int y, const object *op2, rv_vector * retval, int flags) 2302get_rangevector_from_mapcoord (const maptile *m, int x, int y, const object *op2, rv_vector * retval, int flags)
2486{ 2303{
2487 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y)) 2304 if (!adjacent_map (m, op2->map, &retval->distance_x, &retval->distance_y))
2488 { 2305 {
2489 /* be conservative and fill in _some_ data */ 2306 /* be conservative and fill in _some_ data */
2490 retval->distance = 100000; 2307 retval->distance = 100000;
… …
2517{ 2334{
2518 int dx, dy; 2335 int dx, dy;
2519 2336
2520 return adjacent_map (op1->map, op2->map, &dx, &dy); 2337 return adjacent_map (op1->map, op2->map, &dx, &dy);
2521} 2338}
2339
2340object *
2341maptile::insert (object *op, int x, int y, object *originator, int flags)
2342{
2343 if (!op->flag [FLAG_REMOVED])
2344 op->remove ();
2345
2346 return insert_ob_in_map_at (op, this, originator, flags, x, y);
2347}
2348

Diff Legend

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