… | |
… | |
19 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
19 | Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. |
20 | |
20 | |
21 | The authors can be reached via e-mail at <crossfire@schmorp.de> |
21 | The authors can be reached via e-mail at <crossfire@schmorp.de> |
22 | */ |
22 | */ |
23 | |
23 | |
24 | |
|
|
25 | #include <global.h> |
24 | #include <global.h> |
26 | #include <funcpoint.h> |
25 | #include <funcpoint.h> |
27 | |
26 | |
28 | #include <loader.h> |
27 | #include <loader.h> |
29 | #include <unistd.h> |
28 | #include <unistd.h> |
… | |
… | |
32 | |
31 | |
33 | /* |
32 | /* |
34 | * Returns the maptile which has a name matching the given argument. |
33 | * Returns the maptile which has a name matching the given argument. |
35 | * return NULL if no match is found. |
34 | * return NULL if no match is found. |
36 | */ |
35 | */ |
37 | |
|
|
38 | maptile * |
36 | maptile * |
39 | has_been_loaded (const char *name) |
37 | has_been_loaded (const char *name) |
40 | { |
38 | { |
41 | maptile *map; |
|
|
42 | |
|
|
43 | if (!name || !*name) |
39 | if (!name || !*name) |
44 | return 0; |
40 | return 0; |
45 | for (map = first_map; map; map = map->next) |
41 | |
|
|
42 | for_all_maps (map) |
46 | if (!strcmp (name, map->path)) |
43 | if (!strcmp (name, map->path)) |
47 | break; |
|
|
48 | return (map); |
44 | return map; |
|
|
45 | |
|
|
46 | return 0; |
49 | } |
47 | } |
50 | |
48 | |
51 | /* |
49 | /* |
52 | * This makes a path absolute outside the world of Crossfire. |
50 | * This makes a path absolute outside the world of Crossfire. |
53 | * In other words, it prepends LIBDIR/MAPDIR/ to the given path |
51 | * In other words, it prepends LIBDIR/MAPDIR/ to the given path |
… | |
… | |
196 | |
194 | |
197 | void |
195 | void |
198 | dump_map (const maptile *m) |
196 | dump_map (const maptile *m) |
199 | { |
197 | { |
200 | LOG (llevError, "Map %s status: %d.\n", m->path, m->in_memory); |
198 | LOG (llevError, "Map %s status: %d.\n", m->path, m->in_memory); |
201 | LOG (llevError, "Size: %dx%d Start: %d,%d\n", MAP_WIDTH (m), MAP_HEIGHT (m), MAP_ENTER_X (m), MAP_ENTER_Y (m)); |
199 | LOG (llevError, "Size: %dx%d Start: %d,%d\n", m->width, m->height, m->enter_x, m->enter_y); |
202 | |
200 | |
203 | if (m->msg != NULL) |
201 | if (m->msg != NULL) |
204 | LOG (llevError, "Message:\n%s", m->msg); |
202 | LOG (llevError, "Message:\n%s", m->msg); |
205 | |
203 | |
206 | if (m->maplore != NULL) |
204 | if (m->maplore != NULL) |
… | |
… | |
220 | */ |
218 | */ |
221 | |
219 | |
222 | void |
220 | void |
223 | dump_all_maps (void) |
221 | dump_all_maps (void) |
224 | { |
222 | { |
225 | maptile *m; |
223 | for_all_maps (m) |
226 | |
|
|
227 | for (m = first_map; m; m = m->next) |
|
|
228 | dump_map (m); |
224 | dump_map (m); |
229 | } |
225 | } |
230 | |
226 | |
231 | /* This rolls up wall, blocks_magic, blocks_view, etc, all into |
227 | /* This rolls up wall, blocks_magic, blocks_view, etc, all into |
232 | * one function that just returns a P_.. value (see map.h) |
228 | * one function that just returns a P_.. value (see map.h) |
… | |
… | |
475 | * for objects whose arch says they are multipart yet according to the |
471 | * 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 |
472 | * 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 |
473 | * 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. |
474 | * the more sections and not re-add sections for them. |
479 | */ |
475 | */ |
480 | |
|
|
481 | static void |
476 | static void |
482 | link_multipart_objects (maptile *m) |
477 | link_multipart_objects (maptile *m) |
483 | { |
478 | { |
484 | int x, y; |
479 | int x, y; |
485 | object *tmp, *op, *last, *above; |
480 | object *tmp, *op, *last, *above; |
486 | archetype *at; |
481 | archetype *at; |
487 | |
482 | |
488 | for (x = 0; x < MAP_WIDTH (m); x++) |
483 | for (x = 0; x < m->width; x++) |
489 | for (y = 0; y < MAP_HEIGHT (m); y++) |
484 | for (y = 0; y < m->height; y++) |
490 | for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = above) |
485 | for (tmp = GET_MAP_OB (m, x, y); tmp != NULL; tmp = above) |
491 | { |
486 | { |
492 | above = tmp->above; |
487 | above = tmp->above; |
493 | |
488 | |
494 | /* already multipart - don't do anything more */ |
489 | /* already multipart - don't do anything more */ |
… | |
… | |
600 | * Modified by MSW 2001-07-01 to do in a single pass - reduces code, |
595 | * 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 |
596 | * and we only save the head of multi part objects - this is needed |
602 | * in order to do map tiling properly. |
597 | * in order to do map tiling properly. |
603 | */ |
598 | */ |
604 | void |
599 | void |
605 | save_objects (maptile *m, object_freezer & fp, object_freezer & fp2, int flag) |
600 | save_objects (maptile *m, object_freezer &fp, object_freezer &fp2, int flag) |
606 | { |
601 | { |
607 | int i, j = 0, unique = 0; |
602 | int i, j = 0, unique = 0; |
608 | object *op; |
603 | object *op; |
609 | |
604 | |
610 | /* first pass - save one-part objects */ |
605 | /* first pass - save one-part objects */ |
611 | for (i = 0; i < MAP_WIDTH (m); i++) |
606 | for (i = 0; i < m->width; i++) |
612 | for (j = 0; j < MAP_HEIGHT (m); j++) |
607 | for (j = 0; j < m->height; j++) |
613 | { |
608 | { |
614 | unique = 0; |
609 | unique = 0; |
|
|
610 | |
615 | for (op = GET_MAP_OB (m, i, j); op; op = op->above) |
611 | for (op = m->at (i, j).bot; op; op = op->above) |
616 | { |
612 | { |
617 | if (QUERY_FLAG (op, FLAG_IS_FLOOR) && QUERY_FLAG (op, FLAG_UNIQUE)) |
613 | if (op->flag [FLAG_UNIQUE] && op->flag [FLAG_IS_FLOOR]) |
618 | unique = 1; |
614 | unique = 1; |
619 | |
615 | |
620 | if (op->type == PLAYER) |
616 | if (!op->can_map_save ()) |
621 | continue; |
617 | continue; |
622 | |
618 | |
623 | if (op->head || op->owner) |
|
|
624 | continue; |
|
|
625 | |
|
|
626 | if (unique || QUERY_FLAG (op, FLAG_UNIQUE)) |
619 | if (unique || op->flag [FLAG_UNIQUE]) |
627 | save_object (fp2, op, 3); |
620 | save_object (fp2, op, 1); |
628 | else if (flag == 0 || (flag == 2 && (!QUERY_FLAG (op, FLAG_OBJ_ORIGINAL) && !QUERY_FLAG (op, FLAG_UNPAID)))) |
621 | else if (flag == 0 || (flag == 2 && (!op->flag [FLAG_OBJ_ORIGINAL] && !op->flag [FLAG_UNPAID]))) |
629 | save_object (fp, op, 3); |
622 | save_object (fp, op, 1); |
630 | } |
623 | } |
631 | } |
624 | } |
632 | } |
625 | } |
633 | |
626 | |
634 | maptile::maptile () |
627 | maptile::maptile () |
635 | { |
628 | { |
636 | in_memory = MAP_SWAPPED; |
629 | in_memory = MAP_SWAPPED; |
|
|
630 | |
637 | /* The maps used to pick up default x and y values from the |
631 | /* The maps used to pick up default x and y values from the |
638 | * map archetype. Mimic that behaviour. |
632 | * map archetype. Mimic that behaviour. |
639 | */ |
633 | */ |
640 | MAP_WIDTH (this) = 16; |
634 | width = 16; |
641 | MAP_HEIGHT (this) = 16; |
635 | height = 16; |
642 | MAP_RESET_TIMEOUT (this) = 0; |
636 | reset_timeout = 0; |
643 | MAP_TIMEOUT (this) = 300; |
637 | timeout = 300; |
644 | MAP_ENTER_X (this) = 0; |
638 | enter_x = 0; |
645 | MAP_ENTER_Y (this) = 0; |
639 | enter_y = 0; |
646 | /*set part to -1 indicating conversion to weather map not yet done */ |
640 | /*set part to -1 indicating conversion to weather map not yet done */ |
647 | MAP_WORLDPARTX (this) = -1; |
641 | worldpartx = -1; |
648 | MAP_WORLDPARTY (this) = -1; |
642 | worldparty = -1; |
|
|
643 | } |
|
|
644 | |
|
|
645 | void |
|
|
646 | maptile::link () |
|
|
647 | { |
|
|
648 | next = first_map; |
|
|
649 | first_map = this; |
|
|
650 | } |
|
|
651 | |
|
|
652 | void |
|
|
653 | maptile::unlink () |
|
|
654 | { |
|
|
655 | if (first_map == this) |
|
|
656 | first_map = next; |
|
|
657 | else |
|
|
658 | { |
|
|
659 | for_all_maps (m) |
|
|
660 | if (m->next = this) |
|
|
661 | { |
|
|
662 | m->next = next; |
|
|
663 | return; |
|
|
664 | } |
|
|
665 | |
|
|
666 | LOG (llevError, "maptile::unlink() map not on list: %s\n", path); |
|
|
667 | } |
649 | } |
668 | } |
650 | |
669 | |
651 | /* |
670 | /* |
652 | * Allocates, initialises, and returns a pointer to a maptile. |
671 | * Allocates, initialises, and returns a pointer to a maptile. |
653 | * Modified to no longer take a path option which was not being |
672 | * Modified to no longer take a path option which was not being |
654 | * used anyways. MSW 2001-07-01 |
673 | * used anyways. MSW 2001-07-01 |
655 | */ |
674 | */ |
656 | maptile * |
675 | maptile * |
657 | get_linked_map (void) |
676 | get_linked_map (void) |
658 | { |
677 | { |
659 | maptile *mp, *map = new maptile; |
678 | maptile *map = new maptile; |
660 | |
679 | map->link (); |
661 | for (mp = first_map; mp && mp->next; mp = mp->next); |
|
|
662 | |
|
|
663 | if (mp == NULL) |
|
|
664 | first_map = map; |
|
|
665 | else |
|
|
666 | mp->next = map; |
|
|
667 | |
|
|
668 | return map; |
680 | return map; |
669 | } |
681 | } |
670 | |
682 | |
671 | /* |
683 | /* |
672 | * Allocates the arrays contained in a maptile. |
684 | * Allocates the arrays contained in a maptile. |
… | |
… | |
683 | * that is their poor assumption. |
695 | * that is their poor assumption. |
684 | */ |
696 | */ |
685 | if (spaces) |
697 | if (spaces) |
686 | { |
698 | { |
687 | LOG (llevError, "allocate_map called with already allocated map (%s)\n", path); |
699 | LOG (llevError, "allocate_map called with already allocated map (%s)\n", path); |
688 | free (spaces); |
700 | sfree (spaces, size ()); |
689 | } |
701 | } |
690 | |
702 | |
691 | spaces = (mapspace *) |
703 | spaces = salloc0<mapspace> (size ()); |
692 | calloc (1, width * height * sizeof (mapspace)); |
|
|
693 | |
|
|
694 | if (!spaces) |
|
|
695 | fatal (OUT_OF_MEMORY); |
|
|
696 | } |
704 | } |
697 | |
705 | |
698 | /* Create and returns a map of the specific size. Used |
706 | /* Create and returns a map of the specific size. Used |
699 | * in random map code and the editor. |
707 | * in random map code and the editor. |
700 | */ |
708 | */ |
701 | maptile * |
709 | maptile * |
702 | get_empty_map (int sizex, int sizey) |
710 | get_empty_map (int sizex, int sizey) |
703 | { |
711 | { |
704 | maptile *m = get_linked_map (); |
712 | maptile *m = get_linked_map (); |
705 | |
713 | |
706 | m->width = sizex; |
714 | m->width = sizex; |
707 | m->height = sizey; |
715 | m->height = sizey; |
708 | m->in_memory = MAP_SWAPPED; |
716 | m->in_memory = MAP_SWAPPED; |
|
|
717 | |
709 | m->allocate (); |
718 | m->allocate (); |
710 | |
719 | |
711 | return m; |
720 | return m; |
712 | } |
721 | } |
713 | |
722 | |
714 | /* Takes a string from a map definition and outputs a pointer to the array of shopitems |
723 | /* Takes a string from a map definition and outputs a pointer to the array of shopitems |
715 | * corresponding to that string. Memory is allocated for this, it must be freed |
724 | * corresponding to that string. Memory is allocated for this, it must be freed |
716 | * at a later date. |
725 | * at a later date. |
717 | * Called by parse_map_headers below. |
726 | * Called by parse_map_headers below. |
718 | */ |
727 | */ |
719 | |
|
|
720 | static shopitems * |
728 | static shopitems * |
721 | parse_shop_string (const char *input_string) |
729 | parse_shop_string (const char *input_string) |
722 | { |
730 | { |
723 | char *shop_string, *p, *q, *next_semicolon, *next_colon; |
731 | char *shop_string, *p, *q, *next_semicolon, *next_colon; |
724 | shopitems *items = NULL; |
732 | shopitems *items = NULL; |
… | |
… | |
733 | p = strchr (p, ';'); |
741 | p = strchr (p, ';'); |
734 | number_of_entries++; |
742 | number_of_entries++; |
735 | if (p) |
743 | if (p) |
736 | p++; |
744 | p++; |
737 | } |
745 | } |
|
|
746 | |
738 | p = shop_string; |
747 | p = shop_string; |
739 | strip_endline (p); |
748 | strip_endline (p); |
740 | items = new shopitems[number_of_entries + 1]; |
749 | items = new shopitems[number_of_entries + 1]; |
741 | for (i = 0; i < number_of_entries; i++) |
750 | for (i = 0; i < number_of_entries; i++) |
742 | { |
751 | { |
743 | if (!p) |
752 | if (!p) |
744 | { |
753 | { |
745 | LOG (llevError, "parse_shop_string: I seem to have run out of string, that shouldn't happen.\n"); |
754 | LOG (llevError, "parse_shop_string: I seem to have run out of string, that shouldn't happen.\n"); |
746 | break; |
755 | break; |
747 | } |
756 | } |
|
|
757 | |
748 | next_semicolon = strchr (p, ';'); |
758 | next_semicolon = strchr (p, ';'); |
749 | next_colon = strchr (p, ':'); |
759 | next_colon = strchr (p, ':'); |
750 | /* if there is a stregth specified, figure out what it is, we'll need it soon. */ |
760 | /* if there is a stregth specified, figure out what it is, we'll need it soon. */ |
751 | if (next_colon && (!next_semicolon || next_colon < next_semicolon)) |
761 | if (next_colon && (!next_semicolon || next_colon < next_semicolon)) |
752 | items[i].strength = atoi (strchr (p, ':') + 1); |
762 | items[i].strength = atoi (strchr (p, ':') + 1); |
… | |
… | |
779 | * the next entry while we're at it, better print a warning |
789 | * the next entry while we're at it, better print a warning |
780 | */ |
790 | */ |
781 | LOG (llevError, "invalid type %s defined in shopitems in string %s\n", p, input_string); |
791 | LOG (llevError, "invalid type %s defined in shopitems in string %s\n", p, input_string); |
782 | } |
792 | } |
783 | } |
793 | } |
|
|
794 | |
784 | items[i].index = number_of_entries; |
795 | items[i].index = number_of_entries; |
785 | if (next_semicolon) |
796 | if (next_semicolon) |
786 | p = ++next_semicolon; |
797 | p = ++next_semicolon; |
787 | else |
798 | else |
788 | p = NULL; |
799 | p = NULL; |
789 | } |
800 | } |
|
|
801 | |
790 | free (shop_string); |
802 | free (shop_string); |
791 | return items; |
803 | return items; |
792 | } |
804 | } |
793 | |
805 | |
794 | /* opposite of parse string, this puts the string that was originally fed in to |
806 | /* opposite of parse string, this puts the string that was originally fed in to |
… | |
… | |
803 | for (i = 0; i < m->shopitems[0].index; i++) |
815 | for (i = 0; i < m->shopitems[0].index; i++) |
804 | { |
816 | { |
805 | if (m->shopitems[i].typenum) |
817 | if (m->shopitems[i].typenum) |
806 | { |
818 | { |
807 | if (m->shopitems[i].strength) |
819 | if (m->shopitems[i].strength) |
808 | { |
|
|
809 | sprintf (tmp, "%s:%d;", m->shopitems[i].name, m->shopitems[i].strength); |
820 | sprintf (tmp, "%s:%d;", m->shopitems[i].name, m->shopitems[i].strength); |
810 | } |
|
|
811 | else |
821 | else |
812 | sprintf (tmp, "%s;", m->shopitems[i].name); |
822 | sprintf (tmp, "%s;", m->shopitems[i].name); |
813 | } |
823 | } |
814 | else |
824 | else |
815 | { |
825 | { |
816 | if (m->shopitems[i].strength) |
826 | if (m->shopitems[i].strength) |
817 | { |
|
|
818 | sprintf (tmp, "*:%d;", m->shopitems[i].strength); |
827 | sprintf (tmp, "*:%d;", m->shopitems[i].strength); |
819 | } |
|
|
820 | else |
828 | else |
821 | sprintf (tmp, "*"); |
829 | sprintf (tmp, "*"); |
822 | } |
830 | } |
|
|
831 | |
823 | strcat (output_string, tmp); |
832 | strcat (output_string, tmp); |
824 | } |
833 | } |
825 | } |
834 | } |
826 | |
835 | |
827 | /* This loads the header information of the map. The header |
836 | /* This loads the header information of the map. The header |
… | |
… | |
1095 | * MAP_BLOCK, in which case we block on this load. This happens in all |
1104 | * MAP_BLOCK, in which case we block on this load. This happens in all |
1096 | * cases, no matter if this flag is set or not. |
1105 | * cases, no matter if this flag is set or not. |
1097 | * MAP_STYLE: style map - don't add active objects, don't add to server |
1106 | * MAP_STYLE: style map - don't add active objects, don't add to server |
1098 | * managed map list. |
1107 | * managed map list. |
1099 | */ |
1108 | */ |
1100 | |
|
|
1101 | maptile * |
1109 | maptile * |
1102 | load_original_map (const char *filename, int flags) |
1110 | load_original_map (const char *filename, int flags) |
1103 | { |
1111 | { |
1104 | maptile *m; |
1112 | maptile *m; |
1105 | char pathname[MAX_BUF]; |
1113 | char pathname[MAX_BUF]; |
… | |
… | |
1132 | |
1140 | |
1133 | m->in_memory = MAP_LOADING; |
1141 | m->in_memory = MAP_LOADING; |
1134 | load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE)); |
1142 | load_objects (m, thawer, flags & (MAP_BLOCK | MAP_STYLE)); |
1135 | |
1143 | |
1136 | m->in_memory = MAP_IN_MEMORY; |
1144 | m->in_memory = MAP_IN_MEMORY; |
1137 | if (!MAP_DIFFICULTY (m)) |
1145 | if (!m->difficulty) |
1138 | MAP_DIFFICULTY (m) = calculate_difficulty (m); |
1146 | m->difficulty = calculate_difficulty (m); |
1139 | set_map_reset_time (m); |
1147 | set_map_reset_time (m); |
1140 | m->instantiate (); |
1148 | m->instantiate (); |
1141 | return (m); |
1149 | return (m); |
1142 | } |
1150 | } |
1143 | |
1151 | |
1144 | /* |
1152 | /* |
1145 | * Loads a map, which has been loaded earlier, from file. |
1153 | * Loads a map, which has been loaded earlier, from file. |
1146 | * Return the map object we load into (this can change from the passed |
1154 | * Return the map object we load into (this can change from the passed |
1147 | * option if we can't find the original map) |
1155 | * option if we can't find the original map) |
1148 | */ |
1156 | */ |
1149 | |
|
|
1150 | static maptile * |
1157 | static maptile * |
1151 | load_temporary_map (maptile *m) |
1158 | load_temporary_map (maptile *m) |
1152 | { |
1159 | { |
1153 | char buf[MAX_BUF]; |
1160 | char buf[MAX_BUF]; |
1154 | |
1161 | |
… | |
… | |
1198 | /* |
1205 | /* |
1199 | * Loads a map, which has been loaded earlier, from file. |
1206 | * Loads a map, which has been loaded earlier, from file. |
1200 | * Return the map object we load into (this can change from the passed |
1207 | * Return the map object we load into (this can change from the passed |
1201 | * option if we can't find the original map) |
1208 | * option if we can't find the original map) |
1202 | */ |
1209 | */ |
1203 | |
|
|
1204 | maptile * |
1210 | maptile * |
1205 | load_overlay_map (const char *filename, maptile *m) |
1211 | load_overlay_map (const char *filename, maptile *m) |
1206 | { |
1212 | { |
1207 | char pathname[MAX_BUF]; |
1213 | char pathname[MAX_BUF]; |
1208 | |
1214 | |
… | |
… | |
1238 | delete_unique_items (maptile *m) |
1244 | delete_unique_items (maptile *m) |
1239 | { |
1245 | { |
1240 | int i, j, unique; |
1246 | int i, j, unique; |
1241 | object *op, *next; |
1247 | object *op, *next; |
1242 | |
1248 | |
1243 | for (i = 0; i < MAP_WIDTH (m); i++) |
1249 | for (i = 0; i < m->width; i++) |
1244 | for (j = 0; j < MAP_HEIGHT (m); j++) |
1250 | for (j = 0; j < m->height; j++) |
1245 | { |
1251 | { |
1246 | unique = 0; |
1252 | unique = 0; |
1247 | |
1253 | |
1248 | for (op = GET_MAP_OB (m, i, j); op; op = next) |
1254 | for (op = GET_MAP_OB (m, i, j); op; op = next) |
1249 | { |
1255 | { |
… | |
… | |
1259 | } |
1265 | } |
1260 | } |
1266 | } |
1261 | } |
1267 | } |
1262 | } |
1268 | } |
1263 | |
1269 | |
1264 | |
|
|
1265 | /* |
1270 | /* |
1266 | * Loads unique objects from file(s) into the map which is in memory |
1271 | * Loads unique objects from file(s) into the map which is in memory |
1267 | * m is the map to load unique items into. |
1272 | * m is the map to load unique items into. |
1268 | */ |
1273 | */ |
1269 | static void |
1274 | static void |
… | |
… | |
1288 | return; |
1293 | return; |
1289 | |
1294 | |
1290 | m->in_memory = MAP_LOADING; |
1295 | m->in_memory = MAP_LOADING; |
1291 | if (m->tmpname == NULL) /* if we have loaded unique items from */ |
1296 | if (m->tmpname == NULL) /* if we have loaded unique items from */ |
1292 | delete_unique_items (m); /* original map before, don't duplicate them */ |
1297 | delete_unique_items (m); /* original map before, don't duplicate them */ |
|
|
1298 | |
1293 | load_objects (m, thawer, 0); |
1299 | load_objects (m, thawer, 0); |
1294 | |
1300 | |
1295 | m->in_memory = MAP_IN_MEMORY; |
1301 | m->in_memory = MAP_IN_MEMORY; |
1296 | } |
1302 | } |
1297 | |
|
|
1298 | |
1303 | |
1299 | /* |
1304 | /* |
1300 | * Saves a map to file. If flag is set, it is saved into the same |
1305 | * 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 |
1306 | * file it was (originally) loaded from. Otherwise a temporary |
1302 | * filename will be genarated, and the file will be stored there. |
1307 | * filename will be genarated, and the file will be stored there. |
1303 | * The temporary filename will be stored in the maptileure. |
1308 | * The temporary filename will be stored in the maptileure. |
1304 | * If the map is unique, we also save to the filename in the map |
1309 | * If the map is unique, we also save to the filename in the map |
1305 | * (this should have been updated when first loaded) |
1310 | * (this should have been updated when first loaded) |
1306 | */ |
1311 | */ |
1307 | |
|
|
1308 | int |
1312 | int |
1309 | new_save_map (maptile *m, int flag) |
1313 | new_save_map (maptile *m, int flag) |
1310 | { |
1314 | { |
1311 | char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF]; |
1315 | char filename[MAX_BUF], buf[MAX_BUF], shop[MAX_BUF]; |
1312 | int i; |
1316 | int i; |
… | |
… | |
1453 | free_all_objects (maptile *m) |
1457 | free_all_objects (maptile *m) |
1454 | { |
1458 | { |
1455 | if (!m->spaces) |
1459 | if (!m->spaces) |
1456 | return; |
1460 | return; |
1457 | |
1461 | |
1458 | for (int i = 0; i < MAP_WIDTH (m); i++) |
1462 | for (int i = 0; i < m->width; i++) |
1459 | for (int j = 0; j < MAP_HEIGHT (m); j++) |
1463 | for (int j = 0; j < m->height; j++) |
1460 | { |
1464 | { |
1461 | mapspace &ms = m->at (i, j); |
1465 | mapspace &ms = m->at (i, j); |
1462 | |
1466 | |
1463 | while (object *op = ms.bottom) |
1467 | while (object *op = ms.bot) |
1464 | { |
1468 | { |
1465 | if (op->head) |
1469 | if (op->head) |
1466 | op = op->head; |
1470 | op = op->head; |
1467 | |
1471 | |
1468 | op->destroy_inv (false); |
1472 | op->destroy_inv (false); |
… | |
… | |
1476 | * don't free tmpname - our caller is left to do that |
1480 | * don't free tmpname - our caller is left to do that |
1477 | */ |
1481 | */ |
1478 | void |
1482 | void |
1479 | free_map (maptile *m, int flag) |
1483 | free_map (maptile *m, int flag) |
1480 | { |
1484 | { |
1481 | if (m->in_memory != MAP_IN_MEMORY) |
1485 | if (!m->in_memory) //TODO: makes no sense to me? |
1482 | return; |
1486 | return; |
1483 | |
1487 | |
1484 | m->in_memory = MAP_SAVING; |
1488 | m->in_memory = MAP_SAVING; |
1485 | |
1489 | |
1486 | // TODO: use new/delete |
1490 | // TODO: use new/delete |
1487 | #define FREE_AND_CLEAR(p) { free (p); p = NULL; } |
|
|
1488 | |
1491 | |
1489 | if (flag && m->spaces) |
1492 | if (flag && m->spaces) |
1490 | free_all_objects (m); |
1493 | 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 | |
1494 | |
1500 | delete [] m->shopitems; |
1495 | sfree (m->spaces, m->size ()), m->spaces = 0; |
1501 | m->shopitems = 0; |
|
|
1502 | |
1496 | |
1503 | if (m->shoprace) |
1497 | free (m->name), m->name = 0; |
1504 | FREE_AND_CLEAR (m->shoprace); |
1498 | free (m->msg), m->msg = 0; |
|
|
1499 | free (m->maplore), m->maplore = 0; |
|
|
1500 | free (m->shoprace), m->shoprace = 0; |
|
|
1501 | delete [] m->shopitems, m->shopitems = 0; |
1505 | |
1502 | |
1506 | if (m->buttons) |
1503 | if (m->buttons) |
1507 | free_objectlinkpt (m->buttons); |
1504 | free_objectlinkpt (m->buttons), m->buttons = 0; |
1508 | |
|
|
1509 | m->buttons = NULL; |
|
|
1510 | |
1505 | |
1511 | for (int i = 0; i < 4; i++) |
1506 | for (int i = 0; i < 4; i++) |
1512 | { |
1507 | 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 | |
1508 | |
1519 | m->in_memory = MAP_SWAPPED; |
1509 | m->in_memory = MAP_SWAPPED; |
1520 | |
|
|
1521 | #undef FREE_AND_CLEAR |
|
|
1522 | } |
1510 | } |
1523 | |
1511 | |
1524 | maptile::~maptile () |
1512 | maptile::~maptile () |
1525 | { |
1513 | { |
1526 | free_map (this, 1); |
1514 | assert (destroyed ()); |
1527 | free (tmpname); |
|
|
1528 | } |
1515 | } |
1529 | |
1516 | |
1530 | void |
1517 | void |
1531 | maptile::do_destroy () |
1518 | maptile::do_destroy () |
1532 | { |
1519 | { |
1533 | attachable::do_destroy (); |
1520 | attachable::do_destroy (); |
1534 | |
1521 | |
1535 | free_all_objects (this); |
1522 | unlink (); |
|
|
1523 | |
|
|
1524 | free_map (this, 1); |
|
|
1525 | free (tmpname), tmpname = 0; |
1536 | |
1526 | |
1537 | /* We need to look through all the maps and see if any maps |
1527 | /* We need to look through all the maps and see if any maps |
1538 | * are pointing at this one for tiling information. Since |
1528 | * are pointing at this one for tiling information. Since |
1539 | * tiling can be asymetric, we just can not look to see which |
1529 | * tiling can be asymetric, we just can not look to see which |
1540 | * maps this map tiles with and clears those. |
1530 | * maps this map tiles with and clears those. |
1541 | */ |
1531 | */ |
1542 | //TODO: non-euclidean-tiling MUST GO |
1532 | //TODO: non-euclidean-tiling MUST GO |
1543 | for (maptile *m = first_map; m; m = m->next) |
1533 | for_all_maps (m) |
1544 | for (int i = 0; i < 4; i++) |
1534 | for (int i = 0; i < 4; i++) |
1545 | if (m->tile_map[i] == this) |
1535 | if (m->tile_map[i] == this) |
1546 | m->tile_map[i] = 0; |
1536 | m->tile_map[i] = 0; |
1547 | |
|
|
1548 | if (first_map == this) |
|
|
1549 | first_map = next; |
|
|
1550 | else |
|
|
1551 | for (maptile *m = first_map; m; m = m->next) |
|
|
1552 | if (m->next = this) |
|
|
1553 | { |
|
|
1554 | m->next = next; |
|
|
1555 | break; |
|
|
1556 | } |
|
|
1557 | } |
1537 | } |
1558 | |
1538 | |
1559 | //TODO: must go |
1539 | //TODO: must go |
1560 | void |
1540 | void |
1561 | delete_map (maptile *m) |
1541 | delete_map (maptile *m) |
… | |
… | |
1609 | if (flags & MAP_PLAYER_UNIQUE) |
1589 | if (flags & MAP_PLAYER_UNIQUE) |
1610 | LOG (llevDebug, "Trying to load map %s.\n", name); |
1590 | LOG (llevDebug, "Trying to load map %s.\n", name); |
1611 | else |
1591 | else |
1612 | LOG (llevDebug, "Trying to load map %s.\n", create_pathname (name)); |
1592 | LOG (llevDebug, "Trying to load map %s.\n", create_pathname (name)); |
1613 | |
1593 | |
1614 | //eval_pv ("$x = Event::time", 1);//D |
|
|
1615 | if (!(m = load_original_map (name, (flags & MAP_PLAYER_UNIQUE)))) |
1594 | if (!(m = load_original_map (name, (flags & MAP_PLAYER_UNIQUE)))) |
1616 | return (NULL); |
1595 | return (NULL); |
1617 | //eval_pv ("warn \"LOAD \", Event::time - $x", 1);//D |
|
|
1618 | |
1596 | |
1619 | fix_auto_apply (m); /* Chests which open as default */ |
1597 | fix_auto_apply (m); /* Chests which open as default */ |
1620 | |
1598 | |
1621 | /* If a player unique map, no extra unique object file to load. |
1599 | /* If a player unique map, no extra unique object file to load. |
1622 | * if from the editor, likewise. |
1600 | * if from the editor, likewise. |
… | |
… | |
1692 | int x, y, i; |
1670 | int x, y, i; |
1693 | long monster_cnt = 0; |
1671 | long monster_cnt = 0; |
1694 | double avgexp = 0; |
1672 | double avgexp = 0; |
1695 | sint64 total_exp = 0; |
1673 | sint64 total_exp = 0; |
1696 | |
1674 | |
1697 | if (MAP_DIFFICULTY (m)) |
1675 | if (m->difficulty) |
1698 | { |
1676 | { |
1699 | LOG (llevDebug, "Using stored map difficulty: %d\n", MAP_DIFFICULTY (m)); |
1677 | LOG (llevDebug, "Using stored map difficulty: %d\n", m->difficulty); |
1700 | return MAP_DIFFICULTY (m); |
1678 | return m->difficulty; |
1701 | } |
1679 | } |
1702 | |
1680 | |
1703 | for (x = 0; x < MAP_WIDTH (m); x++) |
1681 | for (x = 0; x < m->width; x++) |
1704 | for (y = 0; y < MAP_HEIGHT (m); y++) |
1682 | for (y = 0; y < m->height; y++) |
1705 | for (op = GET_MAP_OB (m, x, y); op != NULL; op = op->above) |
1683 | for (op = GET_MAP_OB (m, x, y); op != NULL; op = op->above) |
1706 | { |
1684 | { |
1707 | if (QUERY_FLAG (op, FLAG_MONSTER)) |
1685 | if (QUERY_FLAG (op, FLAG_MONSTER)) |
1708 | { |
1686 | { |
1709 | total_exp += op->stats.exp; |
1687 | total_exp += op->stats.exp; |
… | |
… | |
1758 | if (first_map->in_memory == MAP_SAVING) |
1736 | if (first_map->in_memory == MAP_SAVING) |
1759 | first_map->in_memory = MAP_IN_MEMORY; |
1737 | first_map->in_memory = MAP_IN_MEMORY; |
1760 | delete_map (first_map); |
1738 | delete_map (first_map); |
1761 | real_maps++; |
1739 | real_maps++; |
1762 | } |
1740 | } |
|
|
1741 | |
1763 | LOG (llevDebug, "free_all_maps: Freed %d maps\n", real_maps); |
1742 | LOG (llevDebug, "free_all_maps: Freed %d maps\n", real_maps); |
1764 | } |
1743 | } |
1765 | |
1744 | |
1766 | /* change_map_light() - used to change map light level (darkness) |
1745 | /* change_map_light() - used to change map light level (darkness) |
1767 | * up or down. Returns true if successful. It should now be |
1746 | * up or down. Returns true if successful. It should now be |
… | |
… | |
1826 | |
1805 | |
1827 | middle_obj = 0; |
1806 | middle_obj = 0; |
1828 | top_obj = 0; |
1807 | top_obj = 0; |
1829 | floor_obj = 0; |
1808 | floor_obj = 0; |
1830 | |
1809 | |
1831 | for (tmp = bottom; tmp; last = tmp, tmp = tmp->above) |
1810 | for (tmp = bot; tmp; last = tmp, tmp = tmp->above) |
1832 | { |
1811 | { |
1833 | /* This could be made additive I guess (two lights better than |
1812 | /* This could be made additive I guess (two lights better than |
1834 | * one). But if so, it shouldn't be a simple additive - 2 |
1813 | * one). But if so, it shouldn't be a simple additive - 2 |
1835 | * light bulbs do not illuminate twice as far as once since |
1814 | * light bulbs do not illuminate twice as far as once since |
1836 | * it is a dissapation factor that is cubed. |
1815 | * it is a dissapation factor that is cubed. |
… | |
… | |
1984 | } |
1963 | } |
1985 | |
1964 | |
1986 | void |
1965 | void |
1987 | set_map_reset_time (maptile *map) |
1966 | set_map_reset_time (maptile *map) |
1988 | { |
1967 | { |
1989 | int timeout; |
1968 | int timeout = map->reset_timeout; |
1990 | |
1969 | |
1991 | timeout = MAP_RESET_TIMEOUT (map); |
|
|
1992 | if (timeout <= 0) |
1970 | if (timeout <= 0) |
1993 | timeout = MAP_DEFAULTRESET; |
1971 | timeout = MAP_DEFAULTRESET; |
1994 | if (timeout >= MAP_MAXRESET) |
1972 | if (timeout >= MAP_MAXRESET) |
1995 | timeout = MAP_MAXRESET; |
1973 | timeout = MAP_MAXRESET; |
1996 | MAP_WHEN_RESET (map) = time (0) + timeout; |
1974 | |
|
|
1975 | map->reset_time = time (0) + timeout; |
1997 | } |
1976 | } |
1998 | |
1977 | |
1999 | /* this updates the orig_map->tile_map[tile_num] value after loading |
1978 | /* 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 |
1979 | * 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 |
1980 | * maps tile_map values if it tiles back to this one. It returns |
… | |
… | |
2044 | return 1; |
2023 | return 1; |
2045 | |
2024 | |
2046 | if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY) |
2025 | if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY) |
2047 | load_and_link_tiled_map (m, 3); |
2026 | load_and_link_tiled_map (m, 3); |
2048 | |
2027 | |
2049 | return (out_of_map (m->tile_map[3], x + MAP_WIDTH (m->tile_map[3]), y)); |
2028 | return (out_of_map (m->tile_map[3], x + m->tile_map[3]->width, y)); |
2050 | } |
2029 | } |
2051 | |
2030 | |
2052 | if (x >= MAP_WIDTH (m)) |
2031 | if (x >= m->width) |
2053 | { |
2032 | { |
2054 | if (!m->tile_path[1]) |
2033 | if (!m->tile_path[1]) |
2055 | return 1; |
2034 | return 1; |
2056 | |
2035 | |
2057 | if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY) |
2036 | if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY) |
2058 | load_and_link_tiled_map (m, 1); |
2037 | load_and_link_tiled_map (m, 1); |
2059 | |
2038 | |
2060 | return (out_of_map (m->tile_map[1], x - MAP_WIDTH (m), y)); |
2039 | return (out_of_map (m->tile_map[1], x - m->width, y)); |
2061 | } |
2040 | } |
2062 | |
2041 | |
2063 | if (y < 0) |
2042 | if (y < 0) |
2064 | { |
2043 | { |
2065 | if (!m->tile_path[0]) |
2044 | if (!m->tile_path[0]) |
2066 | return 1; |
2045 | return 1; |
2067 | |
2046 | |
2068 | if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY) |
2047 | if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY) |
2069 | load_and_link_tiled_map (m, 0); |
2048 | load_and_link_tiled_map (m, 0); |
2070 | |
2049 | |
2071 | return (out_of_map (m->tile_map[0], x, y + MAP_HEIGHT (m->tile_map[0]))); |
2050 | return (out_of_map (m->tile_map[0], x, y + m->tile_map[0]->height)); |
2072 | } |
2051 | } |
2073 | |
2052 | |
2074 | if (y >= MAP_HEIGHT (m)) |
2053 | if (y >= m->height) |
2075 | { |
2054 | { |
2076 | if (!m->tile_path[2]) |
2055 | if (!m->tile_path[2]) |
2077 | return 1; |
2056 | return 1; |
2078 | |
2057 | |
2079 | if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY) |
2058 | if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY) |
2080 | load_and_link_tiled_map (m, 2); |
2059 | load_and_link_tiled_map (m, 2); |
2081 | |
2060 | |
2082 | return (out_of_map (m->tile_map[2], x, y - MAP_HEIGHT (m))); |
2061 | return (out_of_map (m->tile_map[2], x, y - m->height)); |
2083 | } |
2062 | } |
2084 | |
2063 | |
2085 | /* Simple case - coordinates are within this local |
2064 | /* Simple case - coordinates are within this local |
2086 | * map. |
2065 | * map. |
2087 | */ |
2066 | */ |
… | |
… | |
2105 | if (!m->tile_path[3]) |
2084 | if (!m->tile_path[3]) |
2106 | return 0; |
2085 | return 0; |
2107 | if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY) |
2086 | if (!m->tile_map[3] || m->tile_map[3]->in_memory != MAP_IN_MEMORY) |
2108 | load_and_link_tiled_map (m, 3); |
2087 | load_and_link_tiled_map (m, 3); |
2109 | |
2088 | |
2110 | *x += MAP_WIDTH (m->tile_map[3]); |
2089 | *x += m->tile_map[3]->width; |
2111 | return (get_map_from_coord (m->tile_map[3], x, y)); |
2090 | return (get_map_from_coord (m->tile_map[3], x, y)); |
2112 | } |
2091 | } |
2113 | |
2092 | |
2114 | if (*x >= MAP_WIDTH (m)) |
2093 | if (*x >= m->width) |
2115 | { |
2094 | { |
2116 | if (!m->tile_path[1]) |
2095 | if (!m->tile_path[1]) |
2117 | return 0; |
2096 | return 0; |
2118 | |
2097 | |
2119 | if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY) |
2098 | if (!m->tile_map[1] || m->tile_map[1]->in_memory != MAP_IN_MEMORY) |
2120 | load_and_link_tiled_map (m, 1); |
2099 | load_and_link_tiled_map (m, 1); |
2121 | |
2100 | |
2122 | *x -= MAP_WIDTH (m); |
2101 | *x -= m->width; |
2123 | return (get_map_from_coord (m->tile_map[1], x, y)); |
2102 | return (get_map_from_coord (m->tile_map[1], x, y)); |
2124 | } |
2103 | } |
2125 | |
2104 | |
2126 | if (*y < 0) |
2105 | if (*y < 0) |
2127 | { |
2106 | { |
… | |
… | |
2129 | return 0; |
2108 | return 0; |
2130 | |
2109 | |
2131 | if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY) |
2110 | if (!m->tile_map[0] || m->tile_map[0]->in_memory != MAP_IN_MEMORY) |
2132 | load_and_link_tiled_map (m, 0); |
2111 | load_and_link_tiled_map (m, 0); |
2133 | |
2112 | |
2134 | *y += MAP_HEIGHT (m->tile_map[0]); |
2113 | *y += m->tile_map[0]->height; |
2135 | return (get_map_from_coord (m->tile_map[0], x, y)); |
2114 | return (get_map_from_coord (m->tile_map[0], x, y)); |
2136 | } |
2115 | } |
2137 | |
2116 | |
2138 | if (*y >= MAP_HEIGHT (m)) |
2117 | if (*y >= m->height) |
2139 | { |
2118 | { |
2140 | if (!m->tile_path[2]) |
2119 | if (!m->tile_path[2]) |
2141 | return 0; |
2120 | return 0; |
2142 | |
2121 | |
2143 | if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY) |
2122 | if (!m->tile_map[2] || m->tile_map[2]->in_memory != MAP_IN_MEMORY) |
2144 | load_and_link_tiled_map (m, 2); |
2123 | load_and_link_tiled_map (m, 2); |
2145 | |
2124 | |
2146 | *y -= MAP_HEIGHT (m); |
2125 | *y -= m->height; |
2147 | return (get_map_from_coord (m->tile_map[2], x, y)); |
2126 | return (get_map_from_coord (m->tile_map[2], x, y)); |
2148 | } |
2127 | } |
2149 | |
2128 | |
2150 | /* Simple case - coordinates are within this local |
2129 | /* Simple case - coordinates are within this local |
2151 | * map. |
2130 | * map. |
… | |
… | |
2171 | |
2150 | |
2172 | } |
2151 | } |
2173 | else if (map1->tile_map[0] == map2) |
2152 | else if (map1->tile_map[0] == map2) |
2174 | { /* up */ |
2153 | { /* up */ |
2175 | *dx = 0; |
2154 | *dx = 0; |
2176 | *dy = -MAP_HEIGHT (map2); |
2155 | *dy = -map2->height; |
2177 | } |
2156 | } |
2178 | else if (map1->tile_map[1] == map2) |
2157 | else if (map1->tile_map[1] == map2) |
2179 | { /* right */ |
2158 | { /* right */ |
2180 | *dx = MAP_WIDTH (map1); |
2159 | *dx = map1->width; |
2181 | *dy = 0; |
2160 | *dy = 0; |
2182 | } |
2161 | } |
2183 | else if (map1->tile_map[2] == map2) |
2162 | else if (map1->tile_map[2] == map2) |
2184 | { /* down */ |
2163 | { /* down */ |
2185 | *dx = 0; |
2164 | *dx = 0; |
2186 | *dy = MAP_HEIGHT (map1); |
2165 | *dy = map1->height; |
2187 | } |
2166 | } |
2188 | else if (map1->tile_map[3] == map2) |
2167 | else if (map1->tile_map[3] == map2) |
2189 | { /* left */ |
2168 | { /* left */ |
2190 | *dx = -MAP_WIDTH (map2); |
2169 | *dx = -map2->width; |
2191 | *dy = 0; |
2170 | *dy = 0; |
2192 | |
2171 | |
2193 | } |
2172 | } |
2194 | else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2) |
2173 | else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[1] == map2) |
2195 | { /* up right */ |
2174 | { /* up right */ |
2196 | *dx = MAP_WIDTH (map1->tile_map[0]); |
2175 | *dx = map1->tile_map[0]->width; |
2197 | *dy = -MAP_HEIGHT (map1->tile_map[0]); |
2176 | *dy = -map1->tile_map[0]->height; |
2198 | } |
2177 | } |
2199 | else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[3] == map2) |
2178 | else if (map1->tile_map[0] && map1->tile_map[0]->tile_map[3] == map2) |
2200 | { /* up left */ |
2179 | { /* up left */ |
2201 | *dx = -MAP_WIDTH (map2); |
2180 | *dx = -map2->width; |
2202 | *dy = -MAP_HEIGHT (map1->tile_map[0]); |
2181 | *dy = -map1->tile_map[0]->height; |
2203 | } |
2182 | } |
2204 | else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[0] == map2) |
2183 | else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[0] == map2) |
2205 | { /* right up */ |
2184 | { /* right up */ |
2206 | *dx = MAP_WIDTH (map1); |
2185 | *dx = map1->width; |
2207 | *dy = -MAP_HEIGHT (map2); |
2186 | *dy = -map2->height; |
2208 | } |
2187 | } |
2209 | else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[2] == map2) |
2188 | else if (map1->tile_map[1] && map1->tile_map[1]->tile_map[2] == map2) |
2210 | { /* right down */ |
2189 | { /* right down */ |
2211 | *dx = MAP_WIDTH (map1); |
2190 | *dx = map1->width; |
2212 | *dy = MAP_HEIGHT (map1->tile_map[1]); |
2191 | *dy = map1->tile_map[1]->height; |
2213 | } |
2192 | } |
2214 | else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[1] == map2) |
2193 | else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[1] == map2) |
2215 | { /* down right */ |
2194 | { /* down right */ |
2216 | *dx = MAP_WIDTH (map1->tile_map[2]); |
2195 | *dx = map1->tile_map[2]->width; |
2217 | *dy = MAP_HEIGHT (map1); |
2196 | *dy = map1->height; |
2218 | } |
2197 | } |
2219 | else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[3] == map2) |
2198 | else if (map1->tile_map[2] && map1->tile_map[2]->tile_map[3] == map2) |
2220 | { /* down left */ |
2199 | { /* down left */ |
2221 | *dx = -MAP_WIDTH (map2); |
2200 | *dx = -map2->width; |
2222 | *dy = MAP_HEIGHT (map1); |
2201 | *dy = map1->height; |
2223 | } |
2202 | } |
2224 | else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[0] == map2) |
2203 | else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[0] == map2) |
2225 | { /* left up */ |
2204 | { /* left up */ |
2226 | *dx = -MAP_WIDTH (map1->tile_map[3]); |
2205 | *dx = -map1->tile_map[3]->width; |
2227 | *dy = -MAP_HEIGHT (map2); |
2206 | *dy = -map2->height; |
2228 | } |
2207 | } |
2229 | else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2) |
2208 | else if (map1->tile_map[3] && map1->tile_map[3]->tile_map[2] == map2) |
2230 | { /* left down */ |
2209 | { /* left down */ |
2231 | *dx = -MAP_WIDTH (map1->tile_map[3]); |
2210 | *dx = -map1->tile_map[3]->width; |
2232 | *dy = MAP_HEIGHT (map1->tile_map[3]); |
2211 | *dy = map1->tile_map[3]->height; |
2233 | |
2212 | |
2234 | } |
2213 | } |
2235 | else |
2214 | else |
2236 | { /* not "adjacent" enough */ |
2215 | { /* not "adjacent" enough */ |
2237 | return 0; |
2216 | return 0; |
… | |
… | |
2362 | { |
2341 | { |
2363 | int dx, dy; |
2342 | int dx, dy; |
2364 | |
2343 | |
2365 | return adjacent_map (op1->map, op2->map, &dx, &dy); |
2344 | return adjacent_map (op1->map, op2->map, &dx, &dy); |
2366 | } |
2345 | } |
|
|
2346 | |
|
|
2347 | object * |
|
|
2348 | maptile::insert (object *op, int x, int y, object *originator, int flags) |
|
|
2349 | { |
|
|
2350 | if (!op->flag [FLAG_REMOVED]) |
|
|
2351 | op->remove (); |
|
|
2352 | |
|
|
2353 | return insert_ob_in_map_at (op, this, originator, flags, x, y); |
|
|
2354 | } |
|
|
2355 | |