| blob | 4920d5e734b302a2fc9b3492f4a0bc15a7ef7a7d |
1 /* GemRB - Infinity Engine Emulator
2 * Copyright (C) 2003-2004 The GemRB Project
3 *
4 * This program is free software; you can redistribute it and/or
5 * modify it under the terms of the GNU General Public License
6 * as published by the Free Software Foundation; either version 2
7 * of the License, or (at your option) any later version.
9 * This program is distributed in the hope that it will be useful,
10 * but WITHOUT ANY WARRANTY; without even the implied warranty of
11 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
12 * GNU General Public License for more details.
14 * You should have received a copy of the GNU General Public License
15 * along with this program; if not, write to the Free Software
16 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
17 *
18 *
19 */
21 // This class represents the .ARE (game area) files in the engine
23 #include <cmath>
24 #include <cassert>
49 // TODO: fix this hardcoded resource reference
59 };
68 {
70 }
73 {
77 }
80 }
84 }
86 inline static AnimationObjectType SelectObject(Actor *actor, int q, AreaAnimation *a, ScriptedAnimation *sca, Particles *spark, Projectile *pro)
87 {
94 }
101 }
108 }
112 //no idea if this should be plus or minus (or here at all)
116 }
123 }
134 }
136 //returns true if creature must be embedded in the area
137 //npcs in saved game shouldn't be embedded either
139 {
142 }
144 //check for familiars, summons?
146 }
148 //Preload spawn group entries (creature resrefs that reference groups of creatures)
150 {
151 ieResRef GroupName;
168 }
171 //difficulty
175 }
178 }
179 }
180 }
182 //Preload the searchmap configuration
184 {
194 }
201 }
202 }
205 {
212 }
215 }
216 }
219 {
222 //circle perimeter size for MaxVisibility
231 y++;
235 x--;
238 }
239 }
245 }
262 y++;
266 x--;
269 }
270 }
271 }
275 {
288 //no one needs this queue
289 //queue[PR_IGNORE] = NULL;
292 //no one needs this queue
293 //Qcount[PR_IGNORE] = 0;
296 //no one needs this
297 //lastActorCount[PR_IGNORE] = 0;
303 }
309 }
312 {
318 aniIterator aniidx;
321 }
325 //don't delete NPC/PC
328 }
329 }
333 }
336 }
344 }
346 proIterator pri;
350 }
352 scaIterator sci;
356 }
358 spaIterator spi;
362 }
366 }
369 }
371 //malloc-d in AREImp
377 }
379 }
381 }
384 {
392 }
395 {
396 // CHECKME: leaks? Should the old TMap, LightMap, etc... be freed?
404 //Filling Matrices
406 //converting searchmap to internal format
412 }
413 }
414 }
416 void Map::MoveToNewArea(const char *area, const char *entrance, unsigned int direction, int EveryOne, Actor *actor)
417 {
420 //change loader MOS image here
421 //check worldmap entry, if that doesn't contain anything,
422 //make a random pick
426 }
434 }
438 // no entrance found, try using direction flags
442 // ok, so the original engine tries these in a different order
443 // (north first, then south) but it doesn't seem to matter
457 // crashes in original engine
459 printf( "WARNING!!! EntryPoint '%s' does not exist and direction %d is invalid\n", entrance, direction );
462 }
467 }
468 //LeaveArea is the same in ALL engine versions
480 }
481 }
483 }
491 }
497 }
498 }
500 }
506 }
509 {
518 }
520 //no ingame message for these events
525 }
529 // 0 here is direction, can infopoints specify that or is an entrance always provided?
532 }
537 }
538 }
540 //Draw two overlapped animations to achieve the original effect
541 //PlayOnce makes sure that if we stop drawing them, they will go away
543 {
556 }
558 }
559 }
562 {
569 }
570 }
572 // if masterarea, then we allow 'any' actors
573 // if not masterarea, we allow only players
574 // if (!GetActorCount(MasterArea) ) {
575 // fuzzie changed this because the previous code was wrong
576 // (GetActorCount(false) returns only non-PCs) - it is not
577 // well-tested so feel free to change if there are problems
578 // (for example, the CanFree seems like it would be needed to
579 // check for any running scripts, such as following, but it seems
580 // to work ok anyway in my testing - if you change it you probably
581 // also want to change the actor updating code below so it doesn't
582 // add new actions while we are trying to get rid of the area!)
585 }
587 // fuzzie added this check because some area scripts (eg, AR1600 when
588 // escaping Brynnlaw) were executing after they were meant to be done,
589 // and this seems the nicest way of handling that for now - it's quite
590 // possibly wrong (so if you have problems, revert this and find
591 // another way)
593 //Run the Map Script
595 }
597 //Execute Pending Actions
598 //if it is only here, then the drawing will fail
601 // If scripts frozen, return.
602 // This fixes starting a new IWD game. The above ProcessActions pauses the
603 // game for a textscreen, but one of the actor->ProcessActions calls
604 // below starts a cutscene, hiding the mouse. - wjp, 20060805
607 //Run actor scripts (only for 0 priority)
614 // this is silly, the speed should be pre-calculated somewhere
615 //int *actor_speeds = (int *)calloc(Qcount[PR_SCRIPT], sizeof(int));
617 //bool *no_more_steps_for_actor = (bool *)calloc(Qcount[PR_SCRIPT], sizeof(bool));
621 //actor just moved away, don't run its script from this side
625 }
629 }
631 //Avenger moved this here from ApplyAllEffects (this one modifies the effect queue)
632 //.. but then fuzzie moved this here from UpdateActorState, because otherwise
633 //immobile actors (see check below) never become mobile again!
636 //if the actor is immobile, don't run the scripts
641 }
642 }
645 /*
646 * we run scripts all at once because one of the actions in ProcessActions
647 * might remove us from a cutscene and then bad things can happen when
648 * scripts are queued unexpectedly (such as an ogre in a cutscene -> dialog
649 * -> cutscene transition in the first bg1 cutscene exploiting the race
650 * condition to murder player1) - it is entirely possible that we should be
651 * doing this differently (for example by storing the cutscene state at the
652 * start of this function, or by changing the cutscene state at a later
653 * point, etc), but i did it this way for now because it seems least painful
654 * and we should probably be staggering the script executions anyway
655 */
658 }
672 //TODO:calculate actor speed!
676 }
681 }
689 //printf("no walkscale for anim %d!\n", actor->BaseStats[IE_ANIMATION_ID]);
690 }
691 }
692 }
694 }
696 // We need to step through the list of actors until all of them are done
697 // taking steps.
708 // try to exclude actors which only just died
709 // (shouldn't we not be stepping actors which don't have a path anyway?)
710 // following fails on Immobile creatures, don't think it's a problem, but replace with next line if it is
712 //if (actor->GetStat(IE_STATE_ID)&STATE_DEAD || actor->GetInternalFlag() & IF_JUSTDIED) continue;
716 }
717 }
719 //Check if we need to start some door scripts
727 //Execute Pending Actions
729 }
731 //Check if we need to start some container scripts
739 //Execute Pending Actions
741 }
743 //Check if we need to start some trap scripts
746 //For each InfoPoint in the map
750 //If this InfoPoint has no script and it is not a Travel Trigger, skip it
752 // InfoPoints of all types don't run scripts if TRAP_DEACTIVATED is set
753 // (eg, TriggerActivation changes this, see lightning room from SoA)
757 //If this InfoPoint is a Switch Trigger
759 //Check if this InfoPoint was activated
762 //Run the InfoPoint script
764 }
765 }
766 //Execute Pending Actions
769 }
773 }
781 //if trap triggered, then mark actor
783 }
785 //ST_TRAVEL
786 //don't move if doing something else
787 // added CurrentAction as part of blocking action fixes
790 }
791 //this is needed, otherwise the travel
792 //trigger would be activated anytime
793 //Well, i don't know why is it here, but lets try this
796 }
797 }
798 }
799 }
803 }
804 //Execute Pending Actions
806 }
807 }
817 //we should actually wait for a short time and check then
820 }
821 }
822 }
828 }
829 }
830 }
833 }
839 // Restore the searchmap areas of any nearby actors that could
840 // have been cleared by this BlockSearchMap(..., 0).
841 // (Necessary since blocked areas of actors may overlap.)
845 BlockSearchMap( nearActors[i]->Pos, nearActors[i]->size, nearActors[i]->InParty?PATH_MAP_PC:PATH_MAP_NPC);
847 }
849 }
852 {
868 }
872 }
873 }
874 }
880 }
886 }
887 }
890 {
891 retry:
896 q--;
901 q--;
906 }
907 }
910 {
911 retry:
914 }
918 }
921 }
923 }
926 {
929 }
931 }
933 //doesn't increase iterator, because we might need to erase it from the list
935 {
938 }
940 }
943 {
948 iter++;
949 //logic to determine dormant traps
950 //if (pro && pro->IsTrap()) break;
953 }
956 {
959 }
962 {
966 cnt++;
967 }
968 //
971 }
974 //doesn't increase iterator, because we might need to erase it from the list
976 {
979 }
981 }
985 //Draw the game area (including overlays, actors, animations, weather)
987 {
990 }
994 //area specific spawn.ini files (a PST feature)
997 }
1001 //zero when the weather particles are all gone
1005 }
1008 //Blit the Background Map Animations (before actors)
1011 //Draw Outlines
1015 //if it is only here, then the scripting will fail?
1018 //drawing queues 1 and 0
1019 //starting with lower priority
1020 //so displayed, but inactive actors (dead) will be drawn over
1041 //draw animation
1046 {
1056 scaidx++;
1057 }
1058 }
1062 {
1068 }
1071 proidx++;
1075 }
1076 }
1080 {
1086 }
1089 spaidx++;
1093 }
1094 }
1099 }
1100 }
1107 }
1108 }
1112 //For each InfoPoint in the map
1117 }
1121 //For each Container in the map
1126 }
1130 //For each Door in the map
1135 }
1139 //For each Actor present
1140 //This must go AFTER the fog!
1141 //(maybe we should be using the queue?)
1144 }
1147 }
1150 {
1154 Region block;
1167 }
1168 }
1169 }
1170 }
1172 //adding animation in order, based on its height parameter
1174 {
1175 //this hack is to make sure animations flagged with background
1176 //are always drawn first (-9999 seems sufficiently small)
1179 }
1181 aniIterator iter;
1182 for(iter=animations.begin(); (iter!=animations.end()) && ((*iter)->height<anim->height); iter++) ;
1184 /*
1185 Animation *a = anim->animation[0];
1186 anim->SetSpriteCover(BuildSpriteCover(anim->Pos.x, anim->Pos.y,-a->animArea.x,
1187 -a->animArea.y, a->animArea.w, a->animArea.h,0
1188 ));
1189 */
1190 }
1192 //reapplying all of the effects on the actors of this map
1193 //this might be unnecessary later
1195 {
1199 }
1200 }
1203 {
1211 }
1212 }
1218 }
1219 }
1220 }
1223 {
1231 }
1234 }
1237 }
1239 }
1241 }
1244 {
1251 }
1255 }
1256 }
1261 }
1262 }
1263 }
1266 {
1267 //setting the current area for the actor as this one
1269 //if actor->globalID was already set, don't change it
1273 //if a visible aggressive actor was put on the map, it is an autopause reason
1274 //guess game is always loaded? if not, then we'll crash
1279 }
1284 }
1286 }
1289 {
1297 }
1298 }
1299 }
1301 }
1304 {
1315 }
1318 {
1321 }
1322 //truncation is intentional
1330 }
1331 }
1333 }
1335 /** flags:
1336 GA_SELECT 16 - unselectable actors don't play
1337 GA_NO_DEAD 32 - dead actors don't play
1338 GA_POINT 64 - not actor specific
1339 GA_NO_HIDDEN 128 - hidden actors don't play
1340 */
1342 {
1352 }
1355 }
1357 }
1359 }
1362 {
1372 }
1375 }
1377 }
1379 }
1382 {
1395 }
1398 }
1399 count++;
1400 }
1412 }
1415 }
1417 }
1421 }
1425 {
1432 }
1434 }
1435 }
1437 }
1440 {
1443 }
1448 ret++;
1449 }
1450 }
1452 }
1455 {
1462 }
1464 }
1465 }
1466 }
1468 //before writing the area out, perform some cleanups
1470 {
1473 //1. remove dead actors without 'keep corpse' flag
1481 }
1484 }
1485 }
1486 //2. remove any non critical items
1496 }
1497 }
1499 }
1500 }
1501 }
1504 {
1507 }
1514 }
1515 }
1516 }
1518 }
1521 {
1525 //if a busy or hostile actor shouldn't be found
1526 //set this to GD_CHECK
1529 }
1530 }
1532 }
1534 //this function finds an actor by its original resref (not correct yet)
1536 {
1542 }
1543 }
1545 }
1548 {
1554 //use this function only for party?
1557 }
1565 }
1568 }
1571 {
1572 //Ok, we use a non constant pointer here, so it is easy to disable
1573 //a faulty music list on the fly. I don't want to add a method just for that
1574 //crap when we already have that pointer at hand!
1579 //Here we disable the faulty musiclist entry
1581 //Apparently, the playlist manager prefers a *
1583 }
1584 }
1587 {
1591 }
1594 }
1596 }
1599 {
1600 // We check a circle of radius size-2 around (px,py)
1601 // Note that this does not exactly match BG2. BG2's approximations of
1602 // these circles are slightly different for sizes 7 and up.
1618 }
1619 }
1620 }
1622 }
1625 {
1627 }
1629 //flags:0 - never dither (full cover)
1630 // 1 - dither if polygon wants it
1631 // 2 - always dither
1635 {
1651 {
1657 }
1660 }
1663 {
1668 }
1676 else
1679 }
1680 //all actors will have to generate a new spritecover
1684 }
1685 }
1688 //this function determines actor drawing order
1689 //it should be extended to wallgroups, animations, effects!
1691 {
1700 }
1703 }
1705 }
1714 }
1724 }
1726 //dead actors are always visible on the map, but run no scripts
1730 //isvisible flag is false (visibilitymap) here,
1731 //coz we want to reactivate creatures that
1732 //just became visible
1735 //more like activate!
1740 }
1741 }
1742 }
1744 //we ignore priority 2
1749 }
1750 }
1752 //the original qsort implementation was flawed
1754 {
1764 i--;
1767 n--;
1771 }
1778 }
1785 }
1787 }
1788 }
1789 }
1792 {
1793 proIterator iter;
1800 }
1802 //adding projectile in order, based on its height parameter
1804 {
1805 proIterator iter;
1812 }
1814 //returns the longest duration of the VVC cell named 'resource' (if it exists)
1815 //if P is empty, the position won't be checked
1817 {
1818 scaIterator iter;
1825 }
1830 }
1831 }
1833 }
1835 //adding videocell in order, based on its height parameter
1837 {
1838 scaIterator iter;
1842 }
1845 {
1846 aniIterator iter;
1853 }
1854 }
1856 }
1859 {
1864 }
1871 }
1874 }
1877 {
1884 }
1887 {
1894 }
1895 }
1897 }
1900 {
1905 }
1906 }
1908 }
1911 {
1915 //BlockSearchMap(actor->Pos, actor->size, PATH_MAP_FREE);
1919 }
1920 }
1922 }
1924 //returns true if none of the partymembers are on the map
1926 {
1931 }
1935 }
1936 }
1937 //we expect the area to be swapped out, so we simply remove the corpses now
1940 }
1943 {
1958 }
1959 }
1960 }
1961 }
1963 /******************************************************************************/
1967 {
1981 }
1988 }
1989 }
1992 {
1997 }
2001 }
2005 }
2008 }
2011 {
2025 }
2026 }
2032 }
2033 }
2034 }
2036 }
2039 {
2052 }
2053 }
2059 }
2060 }
2061 }
2063 }
2066 {
2070 }
2073 }
2076 }
2079 //lets make it slightly random where the actor will appear
2083 }
2086 }
2090 }
2093 }
2094 }
2095 }
2096 }
2098 //run away from dX, dY (ie.: find the best path of limited length that brings us the farthest from dX, dY)
2100 {
2105 //MapSet entries are made of 16 bits
2108 }
2116 }
2134 }
2138 //printf("Path not found!\n");
2140 }
2151 }
2153 //find path backwards from best to start
2163 }
2173 Point n;
2189 }
2193 }
2194 }
2197 }
2200 {
2209 }
2212 }
2233 }
2235 }
2237 /* Use this function when you target something by a straight line projectile (like a lightning bolt, arrow, etc)
2238 */
2241 {
2244 }
2247 {
2254 //FIXME: calculate dest based on distance and orientation
2256 }
2259 {
2278 Count--;
2279 }
2281 Point p;
2285 //the path ends here as it would go off the screen, causing problems
2286 //maybe there is a better way, but i needed a quick hack to fix
2287 //the crash in projectiles
2290 }
2293 }
2302 //recalculate dest (mirror it)
2308 }
2309 }
2312 }
2314 /*
2315 * find a path from start to goal, ending at the specified distance from the
2316 * target (the goal must be in sight of the end, if 'sight' is specified)
2317 *
2318 * if you don't need to find an optimal path near the goal then use FindPath
2319 * instead, but don't change this one without testing with combat and dialog,
2320 * you can't predict the goal point for those, you *must* path!
2321 */
2322 PathNode* Map::FindPathNear(const Point &s, const Point &d, unsigned int size, unsigned int MinDistance, bool sight)
2323 {
2324 // adjust the start/goal points to be searchmap locations
2329 // re-initialise the path finding structures
2334 // set the start point in the path finding structures
2349 // we got all the way to the target!
2353 /* check minimum distance:
2354 * as an obvious optimisation we only check squared distance: this is a
2355 * possible overestimate since the sqrt Distance() rounds down
2356 * (some other optimisations could be made here, but you'd be better off
2357 * fixing the pathfinder to do A* properly)
2358 * caller should have already done PersonalDistance adjustments, this is
2359 * simply between the specified points
2360 */
2365 // we are within the minimum distance of the goal
2367 // sight check is *slow* :(
2369 // we got all the way to a suitable goal!
2373 }
2374 }
2375 }
2379 // cost is far too high, no path found
2381 }
2383 // diagonal movements
2389 // direct movements
2395 }
2397 // find path from goal to start
2403 // this is not really great, we should be finding the path that
2404 // went nearest to where we wanted
2409 }
2416 // we pathed all the way to original goal!
2417 // we don't know correct orientation until we find previous step
2420 }
2426 Point n;
2439 // don't change orientation at end of path? this seems best
2441 }
2452 }
2455 }
2458 {
2467 }
2480 //We've found _a_ path
2481 //printf("GOAL!!!\n");
2483 }
2486 //printf("Path not found!\n");
2488 }
2499 }
2501 //find path from start to goal
2511 }
2521 Point n;
2536 }
2537 //stepping back on the calculated path
2540 Point tar;
2547 }
2551 }
2552 }
2554 }
2556 //single point visible or not (visible/exploredbitmap)
2557 //if explored = true then explored otherwise currently visible
2559 {
2576 }
2578 //point a is visible from point b (searchmap)
2580 {
2588 //vertical
2594 }
2599 }
2600 }
2607 }
2612 }
2613 }
2614 }
2616 }
2618 //returns direction of area boundary, returns -1 if it isn't a boundary
2620 {
2627 }
2633 }
2635 }
2636 //south or west
2639 }
2641 }
2643 //--------ambients----------------
2645 {
2650 }
2651 //--------mapnotes----------------
2652 //text must be a pointer we can claim ownership of
2654 {
2663 }
2666 {
2673 }
2674 }
2675 }
2678 {
2683 }
2684 }
2686 }
2687 //--------spawning------------------
2689 {
2692 }
2695 {
2705 }
2707 }
2711 // if the difficulty is too high, distribute it equally over all the
2712 // critters and summon as many as the summed difficulty allows
2717 // a single critter is also too powerful
2719 }
2721 count++;
2723 }
2726 }
2734 }
2735 }
2736 }
2739 {
2740 //is it still active
2743 }
2744 //check schedule
2748 }
2750 //check day or night chance
2753 }
2754 // the difficulty check is done in SpawnCreature
2755 //create spawns
2758 }
2759 //disable spawnpoint
2761 }
2763 //--------restheader----------------
2764 /*
2765 Every spawn has a difficulty associated with it. For CREs this is the xp stat
2766 and for groups it's the value in the difficulty row.
2767 For every spawn, the difficulty sum of all spawns up to now (including the
2768 current) is compared against (party level * rest header difficulty). If it's
2769 greater, the spawning is aborted. If all the other conditions are true, at
2770 least one creature is summoned, regardless the difficulty cap.
2771 */
2773 {
2776 }
2778 //based on ingame timer
2788 // ensure a minimum power level, since many creatures have this as 0
2795 spawncount++;
2796 }
2798 }
2799 }
2801 }
2803 //--------explored bitmap-----------
2805 {
2809 x++;
2810 y++;
2811 }
2813 }
2816 {
2818 }
2821 {
2823 }
2825 // x, y are in tile coordinates
2827 {
2844 }
2847 {
2848 Point Tile;
2852 }
2870 {
2872 }
2873 }
2875 Pass--;
2877 }
2878 }
2880 }
2881 }
2882 }
2885 {
2889 }
2903 }
2904 }
2905 }
2907 //Valid values are - PATH_MAP_FREE, PATH_MAP_PC, PATH_MAP_NPC
2909 {
2910 // We block a circle of radius size-1 around (px,py)
2911 // Note that this does not exactly match BG2. BG2's approximations of
2912 // these circles are slightly different for sizes 6 and up.
2914 // Note: this is a larger circle than the one tested in GetBlocked.
2915 // This means that an actor can get closer to a wall than to another
2916 // actor. This matches the behaviour of the original BG2.
2940 }
2941 }
2942 }
2943 }
2946 {
2952 }
2954 }
2957 {
2963 }
2964 }
2966 }
2969 {
2977 }
2979 }
2981 }
2983 //Pos could be [-1,-1] in which case it copies the ground piles to their
2984 //original position in the second area
2986 {
2991 //creating (or grabbing) the container in the other map at the given position
2997 }
2998 //transfer the pile to the other container
3003 }
3004 }
3005 }
3006 }
3009 {
3013 //converting to search square
3017 //pixel position is centered on search square
3022 //bounding box covers the search square
3034 }
3036 }
3039 {
3042 }
3046 {
3054 }
3057 {
3060 }
3068 }
3069 }
3072 {
3075 }
3077 }
3080 {
3084 }
3086 }
3089 }
3092 }
3094 }
3097 {
3098 spaIterator iter;
3103 //particles.erase(iter);
3107 }
3109 }
3110 }
3111 }
3114 {
3117 //the high word is ignored in the original engine (compatibility hack)
3143 }
3151 }
3154 }
3161 //AddParticle(sparkles, pos);
3162 spaIterator iter;
3165 }
3167 //remove flags from actor if it has left the trigger area it had last entered
3169 {
3176 }
3177 }
3178 }
3181 {
3185 }
3188 {
3189 // this stat isn't saved
3190 // according to the HoW manual the chance of success is:
3191 // +5% for every three levels and +5% per point of wisdom
3197 }
3203 }
3206 }
3208 // returns a lightness level in the range of [0-100]
3209 // since the lightmap is much smaller than the area, we need to interpolate
3211 {
3213 // at night/dusk/dawn the lightmap color is adjusted by the color overlay. (Only get's darker.)
3217 }
3219 }
3221 ////////////////////AreaAnimation//////////////////
3222 //Area animation
3225 {
3230 }
3233 {
3237 }
3238 }
3244 }
3246 }
3247 }
3250 {
3257 }
3258 //this will make the animation stop when the game is stopped
3259 //a possible gemrb feature to have this flag settable in .are
3267 }
3270 }
3273 {
3279 }
3281 //freeing up the previous animation
3285 }
3286 }
3295 }
3300 }
3303 }
3306 }
3307 }
3310 {
3316 //re-blending after palette change
3318 }
3319 }
3322 {
3323 //Warning! This function will modify a shared palette
3325 // CHECKME: what should we do here? Currently copying palette
3326 // from first frame of first animation
3333 }
3335 }
3338 {
3341 }
3343 //check for schedule
3347 }
3349 }
3352 {
3356 //always draw the animation tinted because tint is also used for
3357 //transparency
3362 }
3366 }
3367 }
3373 if(!covers[ac] || !covers[ac]->Covers(Pos.x, Pos.y, frame->XPos, frame->YPos, frame->Width, frame->Height)) {
3377 }
3378 }
3381 }
3382 }
3384 //change the tileset if needed and possible, return true if changed
3386 {
3387 //no need of change if the area is not extended night
3389 //no need of change if the area already has the right tilemap
3393 //no need to open and read the .are file again
3394 //using the ARE class for this because ChangeMap is similar to LoadMap
3395 //it loads the lightmap and the minimap too, besides swapping the tileset
3399 }
3402 {
3405 }
3416 }
3417 }
3418 }