… | |
… | |
32 | |
32 | |
33 | /* |
33 | /* |
34 | * Returns the maptile which has a name matching the given argument. |
34 | * Returns the maptile which has a name matching the given argument. |
35 | * return NULL if no match is found. |
35 | * return NULL if no match is found. |
36 | */ |
36 | */ |
37 | |
|
|
38 | maptile * |
37 | maptile * |
39 | has_been_loaded (const char *name) |
38 | has_been_loaded (const char *name) |
40 | { |
39 | { |
41 | maptile *map; |
|
|
42 | |
|
|
43 | if (!name || !*name) |
40 | if (!name || !*name) |
44 | return 0; |
41 | return 0; |
45 | for (map = first_map; map; map = map->next) |
42 | |
|
|
43 | for_all_maps (map) |
46 | if (!strcmp (name, map->path)) |
44 | if (!strcmp (name, map->path)) |
47 | break; |
|
|
48 | return (map); |
45 | return map; |
|
|
46 | |
|
|
47 | return 0; |
49 | } |
48 | } |
50 | |
49 | |
51 | /* |
50 | /* |
52 | * This makes a path absolute outside the world of Crossfire. |
51 | * This makes a path absolute outside the world of Crossfire. |
53 | * In other words, it prepends LIBDIR/MAPDIR/ to the given path |
52 | * In other words, it prepends LIBDIR/MAPDIR/ to the given path |
… | |
… | |
196 | |
195 | |
197 | void |
196 | void |
198 | dump_map (const maptile *m) |
197 | dump_map (const maptile *m) |
199 | { |
198 | { |
200 | 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); |
201 | LOG (llevError, "Size: %dx%d Start: %d,%d\n", m->width, m->height, 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); |
202 | |
201 | |
203 | if (m->msg != NULL) |
202 | if (m->msg != NULL) |
204 | LOG (llevError, "Message:\n%s", m->msg); |
203 | LOG (llevError, "Message:\n%s", m->msg); |
205 | |
204 | |
206 | if (m->maplore != NULL) |
205 | if (m->maplore != NULL) |
… | |
… | |
220 | */ |
219 | */ |
221 | |
220 | |
222 | void |
221 | void |
223 | dump_all_maps (void) |
222 | dump_all_maps (void) |
224 | { |
223 | { |
225 | maptile *m; |
224 | for_all_maps (m) |
226 | |
|
|
227 | for (m = first_map; m; m = m->next) |
|
|
228 | dump_map (m); |
225 | dump_map (m); |
229 | } |
226 | } |
230 | |
227 | |
231 | /* This rolls up wall, blocks_magic, blocks_view, etc, all into |
228 | /* This rolls up wall, blocks_magic, blocks_view, etc, all into |
232 | * one function that just returns a P_.. value (see map.h) |
229 | * one function that just returns a P_.. value (see map.h) |
… | |
… | |
475 | * 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 |
476 | * 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 |
477 | * 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 |
478 | * the more sections and not re-add sections for them. |
475 | * the more sections and not re-add sections for them. |
479 | */ |
476 | */ |
480 | |
|
|
481 | static void |
477 | static void |
482 | link_multipart_objects (maptile *m) |
478 | link_multipart_objects (maptile *m) |
483 | { |
479 | { |
484 | int x, y; |
480 | int x, y; |
485 | object *tmp, *op, *last, *above; |
481 | object *tmp, *op, *last, *above; |
… | |
… | |
600 | * 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, |
601 | * 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 |
602 | * in order to do map tiling properly. |
598 | * in order to do map tiling properly. |
603 | */ |
599 | */ |
604 | void |
600 | void |
605 | save_objects (maptile *m, object_freezer & fp, object_freezer & fp2, int flag) |
601 | save_objects (maptile *m, object_freezer &fp, object_freezer &fp2, int flag) |
606 | { |
602 | { |
607 | int i, j = 0, unique = 0; |
603 | int i, j = 0, unique = 0; |
608 | object *op; |
604 | object *op; |
609 | |
605 | |
610 | /* first pass - save one-part objects */ |
606 | /* first pass - save one-part objects */ |
611 | for (i = 0; i < m->width; i++) |
607 | for (i = 0; i < m->width; i++) |
612 | for (j = 0; j < m->height; j++) |
608 | for (j = 0; j < m->height; j++) |
613 | { |
609 | { |
614 | unique = 0; |
610 | unique = 0; |
|
|
611 | |
615 | for (op = m->at (i, j).bottom; op; op = op->above) |
612 | for (op = m->at (i, j).bot; op; op = op->above) |
616 | { |
613 | { |
617 | if (op->flag [FLAG_IS_FLOOR] && op->flag [FLAG_UNIQUE]) |
614 | if (op->flag [FLAG_UNIQUE] && op->flag [FLAG_IS_FLOOR]) |
618 | unique = 1; |
615 | unique = 1; |
619 | |
616 | |
620 | if (op->type == PLAYER) |
617 | if (op->type == PLAYER) |
621 | continue; |
618 | continue; |
622 | |
619 | |
623 | if (op->head || op->owner) |
620 | if (op->head || op->owner) |
624 | continue; |
621 | continue; |
625 | |
622 | |
626 | if (unique || op->flag [FLAG_UNIQUE]) |
623 | if (unique || op->flag [FLAG_UNIQUE]) |
627 | save_object (fp2, op, 3); |
624 | save_object (fp2, op, 1); |
628 | else if (flag == 0 || (flag == 2 && (!op->flag [FLAG_OBJ_ORIGINAL] && !op->flag [FLAG_UNPAID]))) |
625 | else if (flag == 0 || (flag == 2 && (!op->flag [FLAG_OBJ_ORIGINAL] && !op->flag [FLAG_UNPAID]))) |
629 | save_object (fp, op, 3); |
626 | save_object (fp, op, 1); |
630 | } |
627 | } |
631 | } |
628 | } |
632 | } |
629 | } |
633 | |
630 | |
634 | maptile::maptile () |
631 | maptile::maptile () |
635 | { |
632 | { |
636 | in_memory = MAP_SWAPPED; |
633 | in_memory = MAP_SWAPPED; |
637 | /* 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 |
638 | * map archetype. Mimic that behaviour. |
635 | * map archetype. Mimic that behaviour. |
639 | */ |
636 | */ |
640 | this->width = 16; |
637 | width = 16; |
641 | this->height = 16; |
638 | height = 16; |
642 | MAP_RESET_TIMEOUT (this) = 0; |
639 | reset_timeout = 0; |
643 | MAP_TIMEOUT (this) = 300; |
640 | timeout = 300; |
644 | MAP_ENTER_X (this) = 0; |
641 | enter_x = 0; |
645 | MAP_ENTER_Y (this) = 0; |
642 | enter_y = 0; |
646 | /*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 */ |
647 | MAP_WORLDPARTX (this) = -1; |
644 | worldpartx = -1; |
648 | MAP_WORLDPARTY (this) = -1; |
645 | worldparty = -1; |
649 | } |
646 | } |
650 | |
647 | |
651 | /* |
648 | /* |
652 | * Allocates, initialises, and returns a pointer to a maptile. |
649 | * Allocates, initialises, and returns a pointer to a maptile. |
653 | * Modified to no longer take a path option which was not being |
650 | * Modified to no longer take a path option which was not being |
654 | * used anyways. MSW 2001-07-01 |
651 | * used anyways. MSW 2001-07-01 |
655 | */ |
652 | */ |
656 | maptile * |
653 | maptile * |
657 | get_linked_map (void) |
654 | get_linked_map (void) |
658 | { |
655 | { |
659 | maptile *mp, *map = new maptile; |
656 | maptile *map = new maptile; |
660 | |
657 | |
661 | for (mp = first_map; mp && mp->next; mp = mp->next); |
658 | map->next = first_map; |
662 | |
|
|
663 | if (mp == NULL) |
|
|
664 | first_map = map; |
659 | first_map = map; |
665 | else |
|
|
666 | mp->next = map; |
|
|
667 | |
660 | |
668 | return map; |
661 | return map; |
669 | } |
662 | } |
670 | |
663 | |
671 | /* |
664 | /* |
… | |
… | |
683 | * that is their poor assumption. |
676 | * that is their poor assumption. |
684 | */ |
677 | */ |
685 | if (spaces) |
678 | if (spaces) |
686 | { |
679 | { |
687 | LOG (llevError, "allocate_map called with already allocated map (%s)\n", path); |
680 | LOG (llevError, "allocate_map called with already allocated map (%s)\n", path); |
688 | free (spaces); |
681 | sfree (spaces, size ()); |
689 | } |
682 | } |
690 | |
683 | |
691 | spaces = (mapspace *) |
684 | spaces = salloc0<mapspace> (size ()); |
692 | calloc (1, width * height * sizeof (mapspace)); |
|
|
693 | |
|
|
694 | if (!spaces) |
|
|
695 | fatal (OUT_OF_MEMORY); |
|
|
696 | } |
685 | } |
697 | |
686 | |
698 | /* Create and returns a map of the specific size. Used |
687 | /* Create and returns a map of the specific size. Used |
699 | * in random map code and the editor. |
688 | * in random map code and the editor. |
700 | */ |
689 | */ |
… | |
… | |
1132 | |
1121 | |
1133 | m->in_memory = MAP_LOADING; |
1122 | m->in_memory = MAP_LOADING; |
1134 | load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE)); |
1123 | load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE)); |
1135 | |
1124 | |
1136 | m->in_memory = MAP_IN_MEMORY; |
1125 | m->in_memory = MAP_IN_MEMORY; |
1137 | if (!MAP_DIFFICULTY (m)) |
1126 | if (!m->difficulty) |
1138 | MAP_DIFFICULTY (m) = calculate_difficulty (m); |
1127 | m->difficulty = calculate_difficulty (m); |
1139 | set_map_reset_time (m); |
1128 | set_map_reset_time (m); |
1140 | m->instantiate (); |
1129 | m->instantiate (); |
1141 | return (m); |
1130 | return (m); |
1142 | } |
1131 | } |
1143 | |
1132 | |
… | |
… | |
1259 | } |
1248 | } |
1260 | } |
1249 | } |
1261 | } |
1250 | } |
1262 | } |
1251 | } |
1263 | |
1252 | |
1264 | |
|
|
1265 | /* |
1253 | /* |
1266 | * 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 |
1267 | * m is the map to load unique items into. |
1255 | * m is the map to load unique items into. |
1268 | */ |
1256 | */ |
1269 | static void |
1257 | static void |
… | |
… | |
1288 | return; |
1276 | return; |
1289 | |
1277 | |
1290 | m->in_memory = MAP_LOADING; |
1278 | m->in_memory = MAP_LOADING; |
1291 | if (m->tmpname == NULL) /* if we have loaded unique items from */ |
1279 | if (m->tmpname == NULL) /* if we have loaded unique items from */ |
1292 | delete_unique_items (m); /* original map before, don't duplicate them */ |
1280 | delete_unique_items (m); /* original map before, don't duplicate them */ |
|
|
1281 | |
1293 | load_objects (m, thawer, 0); |
1282 | load_objects (m, thawer, 0); |
1294 | |
1283 | |
1295 | m->in_memory = MAP_IN_MEMORY; |
1284 | m->in_memory = MAP_IN_MEMORY; |
1296 | } |
1285 | } |
1297 | |
|
|
1298 | |
1286 | |
1299 | /* |
1287 | /* |
1300 | * 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 |
1301 | * file it was (originally) loaded from. Otherwise a temporary |
1289 | * file it was (originally) loaded from. Otherwise a temporary |
1302 | * filename will be genarated, and the file will be stored there. |
1290 | * filename will be genarated, and the file will be stored there. |
1303 | * The temporary filename will be stored in the maptileure. |
1291 | * The temporary filename will be stored in the maptileure. |
1304 | * 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 |
1305 | * (this should have been updated when first loaded) |
1293 | * (this should have been updated when first loaded) |
1306 | */ |
1294 | */ |
1307 | |
|
|
1308 | int |
1295 | int |
1309 | new_save_map (maptile *m, int flag) |
1296 | new_save_map (maptile *m, int flag) |
1310 | { |
1297 | { |
1311 | char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF]; |
1298 | char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF]; |
1312 | int i; |
1299 | int i; |
… | |
… | |
1458 | for (int i = 0; i < m->width; i++) |
1445 | for (int i = 0; i < m->width; i++) |
1459 | for (int j = 0; j < m->height; j++) |
1446 | for (int j = 0; j < m->height; j++) |
1460 | { |
1447 | { |
1461 | mapspace &ms = m->at (i, j); |
1448 | mapspace &ms = m->at (i, j); |
1462 | |
1449 | |
1463 | while (object *op = ms.bottom) |
1450 | while (object *op = ms.bot) |
1464 | { |
1451 | { |
1465 | if (op->head) |
1452 | if (op->head) |
1466 | op = op->head; |
1453 | op = op->head; |
1467 | |
1454 | |
1468 | op->destroy_inv (false); |
1455 | op->destroy_inv (false); |
… | |
… | |
1476 | * don't free tmpname - our caller is left to do that |
1463 | * don't free tmpname - our caller is left to do that |
1477 | */ |
1464 | */ |
1478 | void |
1465 | void |
1479 | free_map (maptile *m, int flag) |
1466 | free_map (maptile *m, int flag) |
1480 | { |
1467 | { |
1481 | if (m->in_memory != MAP_IN_MEMORY) |
1468 | if (!m->in_memory) //TODO: makes no sense to me? |
1482 | return; |
1469 | return; |
1483 | |
1470 | |
1484 | m->in_memory = MAP_SAVING; |
1471 | m->in_memory = MAP_SAVING; |
1485 | |
1472 | |
1486 | // TODO: use new/delete |
1473 | // TODO: use new/delete |
1487 | #define FREE_AND_CLEAR(p) { free (p); p = NULL; } |
|
|
1488 | |
1474 | |
1489 | if (flag && m->spaces) |
1475 | if (flag && m->spaces) |
1490 | free_all_objects (m); |
1476 | free_all_objects (m); |
1491 | if (m->name) |
|
|
1492 | FREE_AND_CLEAR (m->name); |
|
|
1493 | if (m->spaces) |
|
|
1494 | FREE_AND_CLEAR (m->spaces); |
|
|
1495 | if (m->msg) |
|
|
1496 | FREE_AND_CLEAR (m->msg); |
|
|
1497 | if (m->maplore) |
|
|
1498 | FREE_AND_CLEAR (m->maplore); |
|
|
1499 | |
1477 | |
1500 | delete [] m->shopitems; |
1478 | sfree (m->spaces, m->size ()), m->spaces = 0; |
1501 | m->shopitems = 0; |
|
|
1502 | |
1479 | |
1503 | if (m->shoprace) |
1480 | free (m->name), m->name = 0; |
1504 | FREE_AND_CLEAR (m->shoprace); |
1481 | free (m->msg), m->msg = 0; |
|
|
1482 | free (m->maplore), m->maplore = 0; |
|
|
1483 | free (m->shoprace), m->shoprace = 0; |
|
|
1484 | delete [] m->shopitems, m->shopitems = 0; |
1505 | |
1485 | |
1506 | if (m->buttons) |
1486 | if (m->buttons) |
1507 | free_objectlinkpt (m->buttons); |
1487 | free_objectlinkpt (m->buttons), m->buttons = 0; |
1508 | |
|
|
1509 | m->buttons = NULL; |
|
|
1510 | |
1488 | |
1511 | for (int i = 0; i < 4; i++) |
1489 | for (int i = 0; i < 4; i++) |
1512 | { |
1490 | free (m->tile_path[i]), m->tile_path[i] = 0; |
1513 | if (m->tile_path[i]) |
|
|
1514 | FREE_AND_CLEAR (m->tile_path[i]); |
|
|
1515 | |
|
|
1516 | m->tile_map[i] = 0; |
|
|
1517 | } |
|
|
1518 | |
1491 | |
1519 | m->in_memory = MAP_SWAPPED; |
1492 | m->in_memory = MAP_SWAPPED; |
1520 | |
|
|
1521 | #undef FREE_AND_CLEAR |
|
|
1522 | } |
1493 | } |
1523 | |
1494 | |
1524 | maptile::~maptile () |
1495 | maptile::~maptile () |
1525 | { |
1496 | { |
1526 | free_map (this, 1); |
1497 | assert (destroyed ()); |
1527 | free (tmpname); |
|
|
1528 | } |
1498 | } |
1529 | |
1499 | |
1530 | void |
1500 | void |
1531 | maptile::do_destroy () |
1501 | maptile::do_destroy () |
1532 | { |
1502 | { |
1533 | attachable::do_destroy (); |
1503 | attachable::do_destroy (); |
1534 | |
1504 | |
1535 | free_all_objects (this); |
1505 | free_map (this, 1); |
|
|
1506 | free (tmpname), tmpname = 0; |
1536 | |
1507 | |
1537 | /* 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 |
1538 | * are pointing at this one for tiling information. Since |
1509 | * are pointing at this one for tiling information. Since |
1539 | * tiling can be asymetric, we just can not look to see which |
1510 | * tiling can be asymetric, we just can not look to see which |
1540 | * maps this map tiles with and clears those. |
1511 | * maps this map tiles with and clears those. |
1541 | */ |
1512 | */ |
1542 | //TODO: non-euclidean-tiling MUST GO |
1513 | //TODO: non-euclidean-tiling MUST GO |
1543 | for (maptile *m = first_map; m; m = m->next) |
1514 | for_all_maps (m) |
1544 | for (int i = 0; i < 4; i++) |
1515 | for (int i = 0; i < 4; i++) |
1545 | if (m->tile_map[i] == this) |
1516 | if (m->tile_map[i] == this) |
1546 | m->tile_map[i] = 0; |
1517 | m->tile_map[i] = 0; |
1547 | |
1518 | |
1548 | if (first_map == this) |
1519 | if (first_map == this) |
1549 | first_map = next; |
1520 | first_map = next; |
1550 | else |
1521 | else |
1551 | for (maptile *m = first_map; m; m = m->next) |
1522 | for_all_maps (m) |
1552 | if (m->next = this) |
1523 | if (m->next = this) |
1553 | { |
1524 | { |
1554 | m->next = next; |
1525 | m->next = next; |
1555 | break; |
1526 | break; |
1556 | } |
1527 | } |
… | |
… | |
1692 | int x, y, i; |
1663 | int x, y, i; |
1693 | long monster_cnt = 0; |
1664 | long monster_cnt = 0; |
1694 | double avgexp = 0; |
1665 | double avgexp = 0; |
1695 | sint64 total_exp = 0; |
1666 | sint64 total_exp = 0; |
1696 | |
1667 | |
1697 | if (MAP_DIFFICULTY (m)) |
1668 | if (m->difficulty) |
1698 | { |
1669 | { |
1699 | LOG (llevDebug, "Using stored map difficulty: %d\n", MAP_DIFFICULTY (m)); |
1670 | LOG (llevDebug, "Using stored map difficulty: %d\n", m->difficulty); |
1700 | return MAP_DIFFICULTY (m); |
1671 | return m->difficulty; |
1701 | } |
1672 | } |
1702 | |
1673 | |
1703 | for (x = 0; x < m->width; x++) |
1674 | for (x = 0; x < m->width; x++) |
1704 | for (y = 0; y < m->height; y++) |
1675 | for (y = 0; y < m->height; y++) |
1705 | 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) |
… | |
… | |
1758 | if (first_map->in_memory == MAP_SAVING) |
1729 | if (first_map->in_memory == MAP_SAVING) |
1759 | first_map->in_memory = MAP_IN_MEMORY; |
1730 | first_map->in_memory = MAP_IN_MEMORY; |
1760 | delete_map (first_map); |
1731 | delete_map (first_map); |
1761 | real_maps++; |
1732 | real_maps++; |
1762 | } |
1733 | } |
|
|
1734 | |
1763 | LOG (llevDebug, "free_all_maps: Freed %d maps\n", real_maps); |
1735 | LOG (llevDebug, "free_all_maps: Freed %d maps\n", real_maps); |
1764 | } |
1736 | } |
1765 | |
1737 | |
1766 | /* change_map_light() - used to change map light level (darkness) |
1738 | /* change_map_light() - used to change map light level (darkness) |
1767 | * up or down. Returns true if successful. It should now be |
1739 | * up or down. Returns true if successful. It should now be |
… | |
… | |
1826 | |
1798 | |
1827 | middle_obj = 0; |
1799 | middle_obj = 0; |
1828 | top_obj = 0; |
1800 | top_obj = 0; |
1829 | floor_obj = 0; |
1801 | floor_obj = 0; |
1830 | |
1802 | |
1831 | for (tmp = bottom; tmp; last = tmp, tmp = tmp->above) |
1803 | for (tmp = bot; tmp; last = tmp, tmp = tmp->above) |
1832 | { |
1804 | { |
1833 | /* This could be made additive I guess (two lights better than |
1805 | /* This could be made additive I guess (two lights better than |
1834 | * 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 |
1835 | * light bulbs do not illuminate twice as far as once since |
1807 | * light bulbs do not illuminate twice as far as once since |
1836 | * it is a dissapation factor that is cubed. |
1808 | * it is a dissapation factor that is cubed. |
… | |
… | |
1986 | void |
1958 | void |
1987 | set_map_reset_time (maptile *map) |
1959 | set_map_reset_time (maptile *map) |
1988 | { |
1960 | { |
1989 | int timeout; |
1961 | int timeout; |
1990 | |
1962 | |
1991 | timeout = MAP_RESET_TIMEOUT (map); |
1963 | timeout = map->reset_timeout; |
1992 | if (timeout <= 0) |
1964 | if (timeout <= 0) |
1993 | timeout = MAP_DEFAULTRESET; |
1965 | timeout = MAP_DEFAULTRESET; |
1994 | if (timeout >= MAP_MAXRESET) |
1966 | if (timeout >= MAP_MAXRESET) |
1995 | timeout = MAP_MAXRESET; |
1967 | timeout = MAP_MAXRESET; |
1996 | MAP_WHEN_RESET (map) = time (0) + timeout; |
1968 | map->reset_time = time (0) + timeout; |
1997 | } |
1969 | } |
1998 | |
1970 | |
1999 | /* 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 |
2000 | * 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 |
2001 | * 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 |
… | |
… | |
2362 | { |
2334 | { |
2363 | int dx, dy; |
2335 | int dx, dy; |
2364 | |
2336 | |
2365 | return adjacent_map (op1->map, op2->map, &dx, &dy); |
2337 | return adjacent_map (op1->map, op2->map, &dx, &dy); |
2366 | } |
2338 | } |
|
|
2339 | |
|
|
2340 | object * |
|
|
2341 | maptile::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 | |