| blob | 067cc6630bcf610adc1c434f4c52ff893c248e48 |
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
47 #include <cmath>
48 #include <cassert>
52 // TODO: fix this hardcoded resource reference
62 };
71 {
73 }
76 {
80 }
83 }
87 }
89 inline static AnimationObjectType SelectObject(Actor *actor, int q, AreaAnimation *a, ScriptedAnimation *sca, Particles *spark, Projectile *pro)
90 {
97 }
104 }
111 }
115 //no idea if this should be plus or minus (or here at all)
119 }
126 }
137 }
139 //returns true if creature must be embedded in the area
140 //npcs in saved game shouldn't be embedded either
142 {
145 }
147 //check for familiars, summons?
149 }
151 //Preload spawn group entries (creature resrefs that reference groups of creatures)
153 {
154 ieResRef GroupName;
171 }
174 //difficulty
178 }
181 }
182 }
183 }
185 //Preload the searchmap configuration
187 {
197 }
204 }
205 }
208 {
215 }
218 }
219 }
222 {
225 //circle perimeter size for MaxVisibility
234 y++;
238 x--;
241 }
242 }
248 }
265 y++;
269 x--;
272 }
273 }
274 }
278 {
291 //no one needs this queue
292 //queue[PR_IGNORE] = NULL;
295 //no one needs this queue
296 //Qcount[PR_IGNORE] = 0;
299 //no one needs this
300 //lastActorCount[PR_IGNORE] = 0;
306 }
312 }
315 {
321 aniIterator aniidx;
324 }
328 //don't delete NPC/PC
331 }
332 }
336 }
339 }
347 }
349 proIterator pri;
353 }
355 scaIterator sci;
359 }
361 spaIterator spi;
365 }
369 }
372 }
374 //malloc-d in AREImp
380 }
382 }
384 }
387 {
395 }
398 {
399 // CHECKME: leaks? Should the old TMap, LightMap, etc... be freed?
407 //Filling Matrices
409 //converting searchmap to internal format
415 }
416 }
417 }
419 void Map::MoveToNewArea(const char *area, const char *entrance, unsigned int direction, int EveryOne, Actor *actor)
420 {
423 //change loader MOS image here
424 //check worldmap entry, if that doesn't contain anything,
425 //make a random pick
429 }
437 }
441 // no entrance found, try using direction flags
445 // ok, so the original engine tries these in a different order
446 // (north first, then south) but it doesn't seem to matter
460 // crashes in original engine
462 printf( "WARNING!!! EntryPoint '%s' does not exist and direction %d is invalid\n", entrance, direction );
465 }
470 }
471 //LeaveArea is the same in ALL engine versions
483 }
484 }
486 }
494 }
500 }
501 }
503 }
509 }
512 {
521 }
523 //no ingame message for these events
528 }
532 // 0 here is direction, can infopoints specify that or is an entrance always provided?
535 }
540 }
541 }
543 //Draw two overlapped animations to achieve the original effect
544 //PlayOnce makes sure that if we stop drawing them, they will go away
546 {
559 }
561 }
562 }
565 {
572 }
573 }
575 // if masterarea, then we allow 'any' actors
576 // if not masterarea, we allow only players
577 // if (!GetActorCount(MasterArea) ) {
578 // fuzzie changed this because the previous code was wrong
579 // (GetActorCount(false) returns only non-PCs) - it is not
580 // well-tested so feel free to change if there are problems
581 // (for example, the CanFree seems like it would be needed to
582 // check for any running scripts, such as following, but it seems
583 // to work ok anyway in my testing - if you change it you probably
584 // also want to change the actor updating code below so it doesn't
585 // add new actions while we are trying to get rid of the area!)
588 }
590 // fuzzie added this check because some area scripts (eg, AR1600 when
591 // escaping Brynnlaw) were executing after they were meant to be done,
592 // and this seems the nicest way of handling that for now - it's quite
593 // possibly wrong (so if you have problems, revert this and find
594 // another way)
596 //Run the Map Script
598 }
600 //Execute Pending Actions
601 //if it is only here, then the drawing will fail
604 // If scripts frozen, return.
605 // This fixes starting a new IWD game. The above ProcessActions pauses the
606 // game for a textscreen, but one of the actor->ProcessActions calls
607 // below starts a cutscene, hiding the mouse. - wjp, 20060805
610 //Run actor scripts (only for 0 priority)
617 // this is silly, the speed should be pre-calculated somewhere
618 //int *actor_speeds = (int *)calloc(Qcount[PR_SCRIPT], sizeof(int));
620 //bool *no_more_steps_for_actor = (bool *)calloc(Qcount[PR_SCRIPT], sizeof(bool));
624 //actor just moved away, don't run its script from this side
628 }
632 }
634 //Avenger moved this here from ApplyAllEffects (this one modifies the effect queue)
635 //.. but then fuzzie moved this here from UpdateActorState, because otherwise
636 //immobile actors (see check below) never become mobile again!
639 //if the actor is immobile, don't run the scripts
644 }
645 }
648 /*
649 * we run scripts all at once because one of the actions in ProcessActions
650 * might remove us from a cutscene and then bad things can happen when
651 * scripts are queued unexpectedly (such as an ogre in a cutscene -> dialog
652 * -> cutscene transition in the first bg1 cutscene exploiting the race
653 * condition to murder player1) - it is entirely possible that we should be
654 * doing this differently (for example by storing the cutscene state at the
655 * start of this function, or by changing the cutscene state at a later
656 * point, etc), but i did it this way for now because it seems least painful
657 * and we should probably be staggering the script executions anyway
658 */
661 }
675 //TODO:calculate actor speed!
679 }
684 }
692 //printf("no walkscale for anim %d!\n", actor->BaseStats[IE_ANIMATION_ID]);
693 }
694 }
695 }
697 }
699 // We need to step through the list of actors until all of them are done
700 // taking steps.
711 // try to exclude actors which only just died
712 // (shouldn't we not be stepping actors which don't have a path anyway?)
713 // following fails on Immobile creatures, don't think it's a problem, but replace with next line if it is
715 //if (actor->GetStat(IE_STATE_ID)&STATE_DEAD || actor->GetInternalFlag() & IF_JUSTDIED) continue;
719 }
720 }
722 //Check if we need to start some door scripts
730 //Execute Pending Actions
732 }
734 //Check if we need to start some container scripts
742 //Execute Pending Actions
744 }
746 //Check if we need to start some trap scripts
749 //For each InfoPoint in the map
753 //If this InfoPoint has no script and it is not a Travel Trigger, skip it
755 // InfoPoints of all types don't run scripts if TRAP_DEACTIVATED is set
756 // (eg, TriggerActivation changes this, see lightning room from SoA)
760 //If this InfoPoint is a Switch Trigger
762 //Check if this InfoPoint was activated
765 //Run the InfoPoint script
767 }
768 }
769 //Execute Pending Actions
772 }
776 }
784 //if trap triggered, then mark actor
786 }
788 //ST_TRAVEL
789 //don't move if doing something else
790 // added CurrentAction as part of blocking action fixes
793 }
794 //this is needed, otherwise the travel
795 //trigger would be activated anytime
796 //Well, i don't know why is it here, but lets try this
799 }
800 }
801 }
802 }
806 }
807 //Execute Pending Actions
809 }
810 }
820 //we should actually wait for a short time and check then
823 }
824 }
825 }
831 }
832 }
833 }
836 }
842 // Restore the searchmap areas of any nearby actors that could
843 // have been cleared by this BlockSearchMap(..., 0).
844 // (Necessary since blocked areas of actors may overlap.)
848 BlockSearchMap( nearActors[i]->Pos, nearActors[i]->size, nearActors[i]->InParty?PATH_MAP_PC:PATH_MAP_NPC);
850 }
852 }
855 {
871 }
875 }
876 }
877 }
883 }
889 }
890 }
893 {
894 retry:
899 q--;
904 q--;
909 }
910 }
913 {
914 retry:
917 }
921 }
924 }
926 }
929 {
932 }
934 }
936 //doesn't increase iterator, because we might need to erase it from the list
938 {
941 }
943 }
946 {
951 iter++;
952 //logic to determine dormant traps
953 //if (pro && pro->IsTrap()) break;
956 }
959 {
962 }
965 {
969 cnt++;
970 }
971 //
974 }
977 //doesn't increase iterator, because we might need to erase it from the list
979 {
982 }
984 }
988 //Draw the game area (including overlays, actors, animations, weather)
990 {
993 }
997 //area specific spawn.ini files (a PST feature)
1000 }
1004 //zero when the weather particles are all gone
1008 }
1011 //Blit the Background Map Animations (before actors)
1014 //Draw Outlines
1018 //if it is only here, then the scripting will fail?
1021 //drawing queues 1 and 0
1022 //starting with lower priority
1023 //so displayed, but inactive actors (dead) will be drawn over
1044 //draw animation
1049 {
1059 scaidx++;
1060 }
1061 }
1065 {
1071 }
1074 proidx++;
1078 }
1079 }
1083 {
1089 }
1092 spaidx++;
1096 }
1097 }
1102 }
1103 }
1110 }
1111 }
1115 //For each InfoPoint in the map
1120 }
1124 //For each Container in the map
1129 }
1133 //For each Door in the map
1138 }
1142 //For each Actor present
1143 //This must go AFTER the fog!
1144 //(maybe we should be using the queue?)
1147 }
1150 }
1153 {
1157 Region block;
1170 }
1171 }
1172 }
1173 }
1175 //adding animation in order, based on its height parameter
1177 {
1178 //this hack is to make sure animations flagged with background
1179 //are always drawn first (-9999 seems sufficiently small)
1182 }
1184 aniIterator iter;
1185 for(iter=animations.begin(); (iter!=animations.end()) && ((*iter)->height<anim->height); iter++) ;
1187 /*
1188 Animation *a = anim->animation[0];
1189 anim->SetSpriteCover(BuildSpriteCover(anim->Pos.x, anim->Pos.y,-a->animArea.x,
1190 -a->animArea.y, a->animArea.w, a->animArea.h,0
1191 ));
1192 */
1193 }
1195 //reapplying all of the effects on the actors of this map
1196 //this might be unnecessary later
1198 {
1202 }
1203 }
1206 {
1214 }
1215 }
1221 }
1222 }
1223 }
1226 {
1234 }
1237 }
1240 }
1242 }
1244 }
1247 {
1254 }
1258 }
1259 }
1264 }
1265 }
1266 }
1269 {
1270 //setting the current area for the actor as this one
1272 //if actor->globalID was already set, don't change it
1276 //if a visible aggressive actor was put on the map, it is an autopause reason
1277 //guess game is always loaded? if not, then we'll crash
1282 }
1287 }
1289 }
1292 {
1300 }
1301 }
1302 }
1304 }
1307 {
1318 }
1321 {
1324 }
1325 //truncation is intentional
1333 }
1334 }
1336 }
1338 /** flags:
1339 GA_SELECT 16 - unselectable actors don't play
1340 GA_NO_DEAD 32 - dead actors don't play
1341 GA_POINT 64 - not actor specific
1342 GA_NO_HIDDEN 128 - hidden actors don't play
1343 */
1345 {
1355 }
1358 }
1360 }
1362 }
1365 {
1375 }
1378 }
1380 }
1382 }
1385 {
1398 }
1401 }
1402 count++;
1403 }
1415 }
1418 }
1420 }
1424 }
1428 {
1435 }
1437 }
1438 }
1440 }
1443 {
1446 }
1451 ret++;
1452 }
1453 }
1455 }
1458 {
1465 }
1467 }
1468 }
1469 }
1471 //before writing the area out, perform some cleanups
1473 {
1476 //1. remove dead actors without 'keep corpse' flag
1484 }
1487 }
1488 }
1489 //2. remove any non critical items
1499 }
1500 }
1502 }
1503 }
1504 }
1507 {
1510 }
1517 }
1518 }
1519 }
1521 }
1524 {
1528 //if a busy or hostile actor shouldn't be found
1529 //set this to GD_CHECK
1532 }
1533 }
1535 }
1537 //this function finds an actor by its original resref (not correct yet)
1539 {
1545 }
1546 }
1548 }
1551 {
1557 //use this function only for party?
1560 }
1568 }
1571 }
1574 {
1575 //Ok, we use a non constant pointer here, so it is easy to disable
1576 //a faulty music list on the fly. I don't want to add a method just for that
1577 //crap when we already have that pointer at hand!
1582 //Here we disable the faulty musiclist entry
1584 //Apparently, the playlist manager prefers a *
1586 }
1587 }
1590 {
1594 }
1597 }
1599 }
1602 {
1603 // We check a circle of radius size-2 around (px,py)
1604 // Note that this does not exactly match BG2. BG2's approximations of
1605 // these circles are slightly different for sizes 7 and up.
1621 }
1622 }
1623 }
1625 }
1628 {
1630 }
1632 //flags:0 - never dither (full cover)
1633 // 1 - dither if polygon wants it
1634 // 2 - always dither
1638 {
1654 {
1660 }
1663 }
1666 {
1671 }
1679 else
1682 }
1683 //all actors will have to generate a new spritecover
1687 }
1688 }
1691 //this function determines actor drawing order
1692 //it should be extended to wallgroups, animations, effects!
1694 {
1703 }
1706 }
1708 }
1717 }
1727 }
1729 //dead actors are always visible on the map, but run no scripts
1733 //isvisible flag is false (visibilitymap) here,
1734 //coz we want to reactivate creatures that
1735 //just became visible
1738 //more like activate!
1743 }
1744 }
1745 }
1747 //we ignore priority 2
1752 }
1753 }
1755 //the original qsort implementation was flawed
1757 {
1767 i--;
1770 n--;
1774 }
1781 }
1788 }
1790 }
1791 }
1792 }
1795 {
1796 proIterator iter;
1803 }
1805 //adding projectile in order, based on its height parameter
1807 {
1808 proIterator iter;
1815 }
1817 //returns the longest duration of the VVC cell named 'resource' (if it exists)
1818 //if P is empty, the position won't be checked
1820 {
1821 scaIterator iter;
1828 }
1833 }
1834 }
1836 }
1838 //adding videocell in order, based on its height parameter
1840 {
1841 scaIterator iter;
1845 }
1848 {
1849 aniIterator iter;
1856 }
1857 }
1859 }
1862 {
1867 }
1874 }
1877 }
1880 {
1887 }
1890 {
1897 }
1898 }
1900 }
1903 {
1908 }
1909 }
1911 }
1914 {
1918 //BlockSearchMap(actor->Pos, actor->size, PATH_MAP_FREE);
1922 }
1923 }
1925 }
1927 //returns true if none of the partymembers are on the map
1929 {
1934 }
1938 }
1939 }
1940 //we expect the area to be swapped out, so we simply remove the corpses now
1943 }
1946 {
1961 }
1962 }
1963 }
1964 }
1966 /******************************************************************************/
1970 {
1984 }
1991 }
1992 }
1995 {
2000 }
2004 }
2008 }
2011 }
2014 {
2028 }
2029 }
2035 }
2036 }
2037 }
2039 }
2042 {
2055 }
2056 }
2062 }
2063 }
2064 }
2066 }
2069 {
2073 }
2076 }
2079 }
2082 //lets make it slightly random where the actor will appear
2086 }
2089 }
2093 }
2096 }
2097 }
2098 }
2099 }
2101 //run away from dX, dY (ie.: find the best path of limited length that brings us the farthest from dX, dY)
2102 PathNode* Map::RunAway(const Point &s, const Point &d, unsigned int size, unsigned int PathLen, int flags)
2103 {
2108 //MapSet entries are made of 16 bits
2111 }
2119 }
2137 }
2141 //printf("Path not found!\n");
2143 }
2154 }
2156 //find path backwards from best to start
2166 }
2176 Point n;
2192 }
2196 }
2197 }
2200 }
2203 {
2212 }
2215 }
2236 }
2238 }
2240 /* Use this function when you target something by a straight line projectile (like a lightning bolt, arrow, etc)
2241 */
2244 {
2247 }
2250 {
2257 //FIXME: calculate dest based on distance and orientation
2259 }
2261 PathNode* Map::GetLine(const Point &start, const Point &dest, int Speed, int Orientation, int flags)
2262 {
2281 Count--;
2282 }
2284 Point p;
2288 //the path ends here as it would go off the screen, causing problems
2289 //maybe there is a better way, but i needed a quick hack to fix
2290 //the crash in projectiles
2293 }
2296 }
2305 //recalculate dest (mirror it)
2311 }
2312 }
2315 }
2317 /*
2318 * find a path from start to goal, ending at the specified distance from the
2319 * target (the goal must be in sight of the end, if 'sight' is specified)
2320 *
2321 * if you don't need to find an optimal path near the goal then use FindPath
2322 * instead, but don't change this one without testing with combat and dialog,
2323 * you can't predict the goal point for those, you *must* path!
2324 */
2325 PathNode* Map::FindPathNear(const Point &s, const Point &d, unsigned int size, unsigned int MinDistance, bool sight)
2326 {
2327 // adjust the start/goal points to be searchmap locations
2332 // re-initialise the path finding structures
2337 // set the start point in the path finding structures
2352 // we got all the way to the target!
2356 /* check minimum distance:
2357 * as an obvious optimisation we only check squared distance: this is a
2358 * possible overestimate since the sqrt Distance() rounds down
2359 * (some other optimisations could be made here, but you'd be better off
2360 * fixing the pathfinder to do A* properly)
2361 * caller should have already done PersonalDistance adjustments, this is
2362 * simply between the specified points
2363 */
2368 // we are within the minimum distance of the goal
2370 // sight check is *slow* :(
2372 // we got all the way to a suitable goal!
2376 }
2377 }
2378 }
2382 // cost is far too high, no path found
2384 }
2386 // diagonal movements
2392 // direct movements
2398 }
2400 // find path from goal to start
2406 // this is not really great, we should be finding the path that
2407 // went nearest to where we wanted
2412 }
2419 // we pathed all the way to original goal!
2420 // we don't know correct orientation until we find previous step
2423 }
2429 Point n;
2442 // don't change orientation at end of path? this seems best
2444 }
2455 }
2458 }
2461 {
2470 }
2483 //We've found _a_ path
2484 //printf("GOAL!!!\n");
2486 }
2489 //printf("Path not found!\n");
2491 }
2502 }
2504 //find path from start to goal
2514 }
2524 Point n;
2539 }
2540 //stepping back on the calculated path
2543 Point tar;
2550 }
2554 }
2555 }
2557 }
2559 //single point visible or not (visible/exploredbitmap)
2560 //if explored = true then explored otherwise currently visible
2562 {
2579 }
2581 //point a is visible from point b (searchmap)
2583 {
2591 //vertical
2597 }
2602 }
2603 }
2610 }
2615 }
2616 }
2617 }
2619 }
2621 //returns direction of area boundary, returns -1 if it isn't a boundary
2623 {
2630 }
2636 }
2638 }
2639 //south or west
2642 }
2644 }
2646 //--------ambients----------------
2648 {
2653 }
2654 //--------mapnotes----------------
2655 //text must be a pointer we can claim ownership of
2657 {
2666 }
2669 {
2676 }
2677 }
2678 }
2681 {
2686 }
2687 }
2689 }
2690 //--------spawning------------------
2692 {
2695 }
2698 {
2708 }
2710 }
2714 // if the difficulty is too high, distribute it equally over all the
2715 // critters and summon as many as the summed difficulty allows
2720 // a single critter is also too powerful
2722 }
2724 count++;
2726 }
2729 }
2737 }
2738 }
2739 }
2742 {
2743 //is it still active
2746 }
2747 //check schedule
2751 }
2753 //check day or night chance
2756 }
2757 // the difficulty check is done in SpawnCreature
2758 //create spawns
2761 }
2762 //disable spawnpoint
2764 }
2766 //--------restheader----------------
2767 /*
2768 Every spawn has a difficulty associated with it. For CREs this is the xp stat
2769 and for groups it's the value in the difficulty row.
2770 For every spawn, the difficulty sum of all spawns up to now (including the
2771 current) is compared against (party level * rest header difficulty). If it's
2772 greater, the spawning is aborted. If all the other conditions are true, at
2773 least one creature is summoned, regardless the difficulty cap.
2774 */
2776 {
2779 }
2781 //based on ingame timer
2791 // ensure a minimum power level, since many creatures have this as 0
2798 spawncount++;
2799 }
2801 }
2802 }
2804 }
2806 //--------explored bitmap-----------
2808 {
2812 x++;
2813 y++;
2814 }
2816 }
2819 {
2821 }
2824 {
2826 }
2828 // x, y are in tile coordinates
2830 {
2847 }
2850 {
2851 Point Tile;
2855 }
2873 {
2875 }
2876 }
2878 Pass--;
2880 }
2881 }
2883 }
2884 }
2885 }
2888 {
2892 }
2906 }
2907 }
2908 }
2910 //Valid values are - PATH_MAP_FREE, PATH_MAP_PC, PATH_MAP_NPC
2912 {
2913 // We block a circle of radius size-1 around (px,py)
2914 // Note that this does not exactly match BG2. BG2's approximations of
2915 // these circles are slightly different for sizes 6 and up.
2917 // Note: this is a larger circle than the one tested in GetBlocked.
2918 // This means that an actor can get closer to a wall than to another
2919 // actor. This matches the behaviour of the original BG2.
2943 }
2944 }
2945 }
2946 }
2949 {
2955 }
2957 }
2960 {
2966 }
2967 }
2969 }
2972 {
2980 }
2982 }
2984 }
2986 //Pos could be [-1,-1] in which case it copies the ground piles to their
2987 //original position in the second area
2989 {
2994 //creating (or grabbing) the container in the other map at the given position
3000 }
3001 //transfer the pile to the other container
3006 }
3007 }
3008 }
3009 }
3012 {
3016 //converting to search square
3020 //pixel position is centered on search square
3025 //bounding box covers the search square
3037 }
3039 }
3042 {
3045 }
3049 {
3057 }
3060 {
3063 }
3071 }
3072 }
3075 {
3078 }
3080 }
3083 {
3087 }
3089 }
3092 }
3095 }
3097 }
3100 {
3101 spaIterator iter;
3106 //particles.erase(iter);
3110 }
3112 }
3113 }
3114 }
3117 {
3120 //the high word is ignored in the original engine (compatibility hack)
3146 }
3154 }
3157 }
3164 //AddParticle(sparkles, pos);
3165 spaIterator iter;
3168 }
3170 //remove flags from actor if it has left the trigger area it had last entered
3172 {
3179 }
3180 }
3181 }
3184 {
3188 }
3191 {
3192 // this stat isn't saved
3193 // according to the HoW manual the chance of success is:
3194 // +5% for every three levels and +5% per point of wisdom
3200 }
3206 }
3209 }
3211 // returns a lightness level in the range of [0-100]
3212 // since the lightmap is much smaller than the area, we need to interpolate
3214 {
3216 // at night/dusk/dawn the lightmap color is adjusted by the color overlay. (Only get's darker.)
3220 }
3222 }
3224 ////////////////////AreaAnimation//////////////////
3225 //Area animation
3228 {
3233 }
3236 {
3240 }
3241 }
3247 }
3249 }
3250 }
3253 {
3260 }
3261 //this will make the animation stop when the game is stopped
3262 //a possible gemrb feature to have this flag settable in .are
3270 }
3273 }
3276 {
3282 }
3284 //freeing up the previous animation
3288 }
3289 }
3298 }
3303 }
3306 }
3309 }
3310 }
3313 {
3319 //re-blending after palette change
3321 }
3322 }
3325 {
3326 //Warning! This function will modify a shared palette
3328 // CHECKME: what should we do here? Currently copying palette
3329 // from first frame of first animation
3336 }
3338 }
3341 {
3344 }
3346 //check for schedule
3350 }
3352 }
3355 {
3359 //always draw the animation tinted because tint is also used for
3360 //transparency
3365 }
3369 }
3370 }
3376 if(!covers[ac] || !covers[ac]->Covers(Pos.x, Pos.y, frame->XPos, frame->YPos, frame->Width, frame->Height)) {
3380 }
3381 }
3384 }
3385 }
3387 //change the tileset if needed and possible, return true if changed
3389 {
3390 //no need of change if the area is not extended night
3392 //no need of change if the area already has the right tilemap
3396 //no need to open and read the .are file again
3397 //using the ARE class for this because ChangeMap is similar to LoadMap
3398 //it loads the lightmap and the minimap too, besides swapping the tileset
3401 }
3404 {
3407 }
3418 }
3419 }
3420 }