| blob | 9b3beb39ad211093fab0a768ef710f3ab5913c53 |
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
48 #include <cmath>
49 #include <cassert>
53 // TODO: fix this hardcoded resource reference
63 };
72 {
74 }
77 {
81 }
84 }
88 }
90 inline static AnimationObjectType SelectObject(Actor *actor, int q, AreaAnimation *a, ScriptedAnimation *sca, Particles *spark, Projectile *pro)
91 {
98 }
105 }
112 }
116 //no idea if this should be plus or minus (or here at all)
120 }
127 }
138 }
140 //returns true if creature must be embedded in the area
141 //npcs in saved game shouldn't be embedded either
143 {
146 }
148 //check for familiars, summons?
150 }
152 //Preload spawn group entries (creature resrefs that reference groups of creatures)
154 {
155 ieResRef GroupName;
172 }
175 //difficulty
179 }
182 }
183 }
184 }
186 //Preload the searchmap configuration
188 {
198 }
205 }
206 }
209 {
216 }
219 }
220 }
223 {
226 //circle perimeter size for MaxVisibility
235 y++;
239 x--;
242 }
243 }
249 }
266 y++;
270 x--;
273 }
274 }
275 }
279 {
292 //no one needs this queue
293 //queue[PR_IGNORE] = NULL;
296 //no one needs this queue
297 //Qcount[PR_IGNORE] = 0;
300 //no one needs this
301 //lastActorCount[PR_IGNORE] = 0;
307 }
313 }
316 {
322 aniIterator aniidx;
325 }
329 //don't delete NPC/PC
332 }
333 }
337 }
340 }
348 }
350 proIterator pri;
354 }
356 scaIterator sci;
360 }
362 spaIterator spi;
366 }
370 }
373 }
375 //malloc-d in AREImp
381 }
383 }
385 }
388 {
396 }
399 {
400 // CHECKME: leaks? Should the old TMap, LightMap, etc... be freed?
408 //Filling Matrices
410 //converting searchmap to internal format
416 }
417 }
418 }
420 void Map::MoveToNewArea(const char *area, const char *entrance, unsigned int direction, int EveryOne, Actor *actor)
421 {
424 //change loader MOS image here
425 //check worldmap entry, if that doesn't contain anything,
426 //make a random pick
430 }
438 }
442 // no entrance found, try using direction flags
446 // ok, so the original engine tries these in a different order
447 // (north first, then south) but it doesn't seem to matter
461 // crashes in original engine
463 printf( "WARNING!!! EntryPoint '%s' does not exist and direction %d is invalid\n", entrance, direction );
466 }
471 }
472 //LeaveArea is the same in ALL engine versions
484 }
485 }
487 }
495 }
501 }
502 }
504 }
510 }
513 {
522 }
524 //no ingame message for these events
529 }
533 // 0 here is direction, can infopoints specify that or is an entrance always provided?
536 }
541 }
542 }
544 //Draw two overlapped animations to achieve the original effect
545 //PlayOnce makes sure that if we stop drawing them, they will go away
547 {
560 }
562 }
563 }
566 {
573 }
574 }
576 // if masterarea, then we allow 'any' actors
577 // if not masterarea, we allow only players
578 // if (!GetActorCount(MasterArea) ) {
579 // fuzzie changed this because the previous code was wrong
580 // (GetActorCount(false) returns only non-PCs) - it is not
581 // well-tested so feel free to change if there are problems
582 // (for example, the CanFree seems like it would be needed to
583 // check for any running scripts, such as following, but it seems
584 // to work ok anyway in my testing - if you change it you probably
585 // also want to change the actor updating code below so it doesn't
586 // add new actions while we are trying to get rid of the area!)
589 }
591 // fuzzie added this check because some area scripts (eg, AR1600 when
592 // escaping Brynnlaw) were executing after they were meant to be done,
593 // and this seems the nicest way of handling that for now - it's quite
594 // possibly wrong (so if you have problems, revert this and find
595 // another way)
597 //Run the Map Script
599 }
601 //Execute Pending Actions
602 //if it is only here, then the drawing will fail
605 // If scripts frozen, return.
606 // This fixes starting a new IWD game. The above ProcessActions pauses the
607 // game for a textscreen, but one of the actor->ProcessActions calls
608 // below starts a cutscene, hiding the mouse. - wjp, 20060805
611 //Run actor scripts (only for 0 priority)
618 // this is silly, the speed should be pre-calculated somewhere
619 //int *actor_speeds = (int *)calloc(Qcount[PR_SCRIPT], sizeof(int));
621 //bool *no_more_steps_for_actor = (bool *)calloc(Qcount[PR_SCRIPT], sizeof(bool));
625 //actor just moved away, don't run its script from this side
629 }
633 }
635 //Avenger moved this here from ApplyAllEffects (this one modifies the effect queue)
636 //.. but then fuzzie moved this here from UpdateActorState, because otherwise
637 //immobile actors (see check below) never become mobile again!
640 //if the actor is immobile, don't run the scripts
645 }
646 }
649 /*
650 * we run scripts all at once because one of the actions in ProcessActions
651 * might remove us from a cutscene and then bad things can happen when
652 * scripts are queued unexpectedly (such as an ogre in a cutscene -> dialog
653 * -> cutscene transition in the first bg1 cutscene exploiting the race
654 * condition to murder player1) - it is entirely possible that we should be
655 * doing this differently (for example by storing the cutscene state at the
656 * start of this function, or by changing the cutscene state at a later
657 * point, etc), but i did it this way for now because it seems least painful
658 * and we should probably be staggering the script executions anyway
659 */
662 }
676 //TODO:calculate actor speed!
680 }
685 }
693 //printf("no walkscale for anim %d!\n", actor->BaseStats[IE_ANIMATION_ID]);
694 }
695 }
696 }
698 }
700 // We need to step through the list of actors until all of them are done
701 // taking steps.
712 // try to exclude actors which only just died
713 // (shouldn't we not be stepping actors which don't have a path anyway?)
714 // following fails on Immobile creatures, don't think it's a problem, but replace with next line if it is
716 //if (actor->GetStat(IE_STATE_ID)&STATE_DEAD || actor->GetInternalFlag() & IF_JUSTDIED) continue;
720 }
721 }
723 //Check if we need to start some door scripts
731 //Execute Pending Actions
733 }
735 //Check if we need to start some container scripts
743 //Execute Pending Actions
745 }
747 //Check if we need to start some trap scripts
750 //For each InfoPoint in the map
754 //If this InfoPoint has no script and it is not a Travel Trigger, skip it
756 // InfoPoints of all types don't run scripts if TRAP_DEACTIVATED is set
757 // (eg, TriggerActivation changes this, see lightning room from SoA)
761 //If this InfoPoint is a Switch Trigger
763 //Check if this InfoPoint was activated
766 //Run the InfoPoint script
768 }
769 }
770 //Execute Pending Actions
773 }
777 }
785 //if trap triggered, then mark actor
787 }
789 //ST_TRAVEL
790 //don't move if doing something else
791 // added CurrentAction as part of blocking action fixes
794 }
795 //this is needed, otherwise the travel
796 //trigger would be activated anytime
797 //Well, i don't know why is it here, but lets try this
800 }
801 }
802 }
803 }
807 }
808 //Execute Pending Actions
810 }
811 }
821 //we should actually wait for a short time and check then
824 }
825 }
826 }
832 }
833 }
834 }
837 }
843 // Restore the searchmap areas of any nearby actors that could
844 // have been cleared by this BlockSearchMap(..., 0).
845 // (Necessary since blocked areas of actors may overlap.)
849 BlockSearchMap( nearActors[i]->Pos, nearActors[i]->size, nearActors[i]->InParty?PATH_MAP_PC:PATH_MAP_NPC);
851 }
853 }
856 {
872 }
876 }
877 }
878 }
884 }
890 }
891 }
894 {
895 retry:
900 q--;
905 q--;
910 }
911 }
914 {
915 retry:
918 }
922 }
925 }
927 }
930 {
933 }
935 }
937 //doesn't increase iterator, because we might need to erase it from the list
939 {
942 }
944 }
947 {
952 iter++;
953 //logic to determine dormant traps
954 //if (pro && pro->IsTrap()) break;
957 }
960 {
963 }
966 {
970 cnt++;
971 }
972 //
975 }
978 //doesn't increase iterator, because we might need to erase it from the list
980 {
983 }
985 }
989 //Draw the game area (including overlays, actors, animations, weather)
991 {
994 }
998 //area specific spawn.ini files (a PST feature)
1001 }
1005 //zero when the weather particles are all gone
1009 }
1012 //Blit the Background Map Animations (before actors)
1015 //Draw Outlines
1019 //if it is only here, then the scripting will fail?
1022 //drawing queues 1 and 0
1023 //starting with lower priority
1024 //so displayed, but inactive actors (dead) will be drawn over
1045 //draw animation
1050 {
1060 scaidx++;
1061 }
1062 }
1066 {
1072 }
1075 proidx++;
1079 }
1080 }
1084 {
1090 }
1093 spaidx++;
1097 }
1098 }
1103 }
1104 }
1111 }
1112 }
1116 //For each InfoPoint in the map
1121 }
1125 //For each Container in the map
1130 }
1134 //For each Door in the map
1139 }
1143 //For each Actor present
1144 //This must go AFTER the fog!
1145 //(maybe we should be using the queue?)
1148 }
1151 }
1154 {
1160 Region block;
1179 }
1180 }
1181 }
1182 }
1183 }
1185 //adding animation in order, based on its height parameter
1187 {
1188 //this hack is to make sure animations flagged with background
1189 //are always drawn first (-9999 seems sufficiently small)
1192 }
1194 aniIterator iter;
1195 for(iter=animations.begin(); (iter!=animations.end()) && ((*iter)->height<anim->height); iter++) ;
1197 /*
1198 Animation *a = anim->animation[0];
1199 anim->SetSpriteCover(BuildSpriteCover(anim->Pos.x, anim->Pos.y,-a->animArea.x,
1200 -a->animArea.y, a->animArea.w, a->animArea.h,0
1201 ));
1202 */
1203 }
1205 //reapplying all of the effects on the actors of this map
1206 //this might be unnecessary later
1208 {
1212 }
1213 }
1216 {
1224 }
1225 }
1231 }
1232 }
1233 }
1236 {
1244 }
1247 }
1250 }
1252 }
1254 }
1257 {
1264 }
1268 }
1269 }
1274 }
1275 }
1276 }
1279 {
1280 //setting the current area for the actor as this one
1282 //if actor->globalID was already set, don't change it
1286 //if a visible aggressive actor was put on the map, it is an autopause reason
1287 //guess game is always loaded? if not, then we'll crash
1292 }
1297 }
1299 }
1302 {
1310 }
1311 }
1312 }
1314 }
1316 //Make an actor gone for (almost) good
1317 //If the actor was in the party, it will be moved to the npc storage
1318 //If the actor is in the NPC storage, its area and some other fields
1319 //that are needed for proper reentry will be zeroed out
1320 //If the actor isn't in the NPC storage, it is destructed
1322 {
1326 //this makes sure that a PC will be demoted to NPC
1328 //this frees up the spot under the feet circle
1330 //remove the area reference from the actor
1332 //don't destroy the object in case it is a persistent object
1333 //otherwise there is a dead reference causing a crash on save
1336 }
1337 }
1338 //remove the actor from the area's actor list
1340 }
1343 {
1346 }
1347 //truncation is intentional
1355 }
1356 }
1358 }
1360 /** flags:
1361 GA_SELECT 16 - unselectable actors don't play
1362 GA_NO_DEAD 32 - dead actors don't play
1363 GA_POINT 64 - not actor specific
1364 GA_NO_HIDDEN 128 - hidden actors don't play
1365 */
1367 {
1377 }
1380 }
1382 }
1384 }
1387 {
1397 }
1400 }
1402 }
1404 }
1407 {
1420 }
1423 }
1424 count++;
1425 }
1437 }
1440 }
1442 }
1446 }
1450 {
1457 }
1459 }
1460 }
1462 }
1465 {
1468 }
1473 ret++;
1474 }
1475 }
1477 }
1480 {
1487 }
1489 }
1490 }
1491 }
1493 //before writing the area out, perform some cleanups
1495 {
1498 //1. remove dead actors without 'keep corpse' flag
1506 }
1507 //don't delete persistent actors
1510 }
1511 //even if you delete it, be very careful!
1513 }
1514 }
1515 //2. remove any non critical items
1525 }
1526 }
1528 }
1529 }
1530 }
1533 {
1536 }
1543 }
1544 }
1545 }
1547 }
1550 {
1554 //if a busy or hostile actor shouldn't be found
1555 //set this to GD_CHECK
1558 }
1559 }
1561 }
1563 //this function finds an actor by its original resref (not correct yet)
1565 {
1571 }
1572 }
1574 }
1577 {
1583 }
1584 }
1586 }
1589 {
1595 //use this function only for party?
1598 }
1599 // this is called by non-selection code..
1609 }
1612 }
1615 {
1616 //Ok, we use a non constant pointer here, so it is easy to disable
1617 //a faulty music list on the fly. I don't want to add a method just for that
1618 //crap when we already have that pointer at hand!
1622 //check if restart needed (either forced or the current song is different)
1625 //Here we disable the faulty musiclist entry
1627 //Apparently, the playlist manager prefers a *
1630 }
1633 }
1634 }
1637 {
1641 }
1644 }
1646 }
1649 {
1650 // We check a circle of radius size-2 around (px,py)
1651 // Note that this does not exactly match BG2. BG2's approximations of
1652 // these circles are slightly different for sizes 7 and up.
1668 }
1669 }
1670 }
1672 }
1675 {
1677 }
1679 //flags:0 - never dither (full cover)
1680 // 1 - dither if polygon wants it
1681 // 2 - always dither
1685 {
1701 {
1707 }
1710 }
1713 {
1718 }
1726 else
1729 }
1730 //all actors will have to generate a new spritecover
1734 }
1735 }
1738 //this function determines actor drawing order
1739 //it should be extended to wallgroups, animations, effects!
1741 {
1750 }
1753 }
1755 }
1764 }
1774 }
1776 //dead actors are always visible on the map, but run no scripts
1780 //isvisible flag is false (visibilitymap) here,
1781 //coz we want to reactivate creatures that
1782 //just became visible
1785 //more like activate!
1790 }
1791 }
1792 }
1794 //we ignore priority 2
1799 }
1800 }
1802 //the original qsort implementation was flawed
1804 {
1814 i--;
1817 n--;
1821 }
1828 }
1835 }
1837 }
1838 }
1839 }
1842 {
1843 proIterator iter;
1850 }
1852 //adding projectile in order, based on its height parameter
1854 {
1855 proIterator iter;
1862 }
1864 //returns the longest duration of the VVC cell named 'resource' (if it exists)
1865 //if P is empty, the position won't be checked
1867 {
1868 scaIterator iter;
1875 }
1880 }
1881 }
1883 }
1885 //adding videocell in order, based on its height parameter
1887 {
1888 scaIterator iter;
1892 }
1895 {
1896 aniIterator iter;
1903 }
1904 }
1906 }
1909 {
1914 }
1921 }
1924 }
1927 {
1934 }
1937 {
1944 }
1945 }
1947 }
1950 {
1955 }
1956 }
1958 }
1961 {
1965 //BlockSearchMap(actor->Pos, actor->size, PATH_MAP_FREE);
1969 }
1970 }
1972 }
1974 //returns true if none of the partymembers are on the map
1976 {
1981 }
1985 }
1986 }
1987 //we expect the area to be swapped out, so we simply remove the corpses now
1990 }
1993 {
2008 }
2009 }
2010 }
2011 }
2013 /******************************************************************************/
2017 {
2031 }
2038 }
2039 }
2042 {
2047 }
2051 }
2055 }
2058 }
2061 {
2075 }
2076 }
2082 }
2083 }
2084 }
2086 }
2089 {
2102 }
2103 }
2109 }
2110 }
2111 }
2113 }
2116 {
2120 }
2123 }
2126 }
2129 //lets make it slightly random where the actor will appear
2133 }
2136 }
2140 }
2143 }
2144 }
2145 }
2146 }
2148 //run away from dX, dY (ie.: find the best path of limited length that brings us the farthest from dX, dY)
2149 PathNode* Map::RunAway(const Point &s, const Point &d, unsigned int size, unsigned int PathLen, int flags)
2150 {
2155 //MapSet entries are made of 16 bits
2158 }
2166 }
2184 }
2188 //printf("Path not found!\n");
2190 }
2201 }
2203 //find path backwards from best to start
2213 }
2223 Point n;
2239 }
2243 }
2244 }
2247 }
2250 {
2259 }
2262 }
2283 }
2285 }
2287 /* Use this function when you target something by a straight line projectile (like a lightning bolt, arrow, etc)
2288 */
2291 {
2294 }
2297 {
2304 //FIXME: calculate dest based on distance and orientation
2306 }
2308 PathNode* Map::GetLine(const Point &start, const Point &dest, int Speed, int Orientation, int flags)
2309 {
2328 Count--;
2329 }
2331 Point p;
2335 //the path ends here as it would go off the screen, causing problems
2336 //maybe there is a better way, but i needed a quick hack to fix
2337 //the crash in projectiles
2340 }
2343 }
2352 //recalculate dest (mirror it)
2358 }
2359 }
2362 }
2364 /*
2365 * find a path from start to goal, ending at the specified distance from the
2366 * target (the goal must be in sight of the end, if 'sight' is specified)
2367 *
2368 * if you don't need to find an optimal path near the goal then use FindPath
2369 * instead, but don't change this one without testing with combat and dialog,
2370 * you can't predict the goal point for those, you *must* path!
2371 */
2372 PathNode* Map::FindPathNear(const Point &s, const Point &d, unsigned int size, unsigned int MinDistance, bool sight)
2373 {
2374 // adjust the start/goal points to be searchmap locations
2379 // re-initialise the path finding structures
2384 // set the start point in the path finding structures
2399 // we got all the way to the target!
2403 /* check minimum distance:
2404 * as an obvious optimisation we only check squared distance: this is a
2405 * possible overestimate since the sqrt Distance() rounds down
2406 * (some other optimisations could be made here, but you'd be better off
2407 * fixing the pathfinder to do A* properly)
2408 * caller should have already done PersonalDistance adjustments, this is
2409 * simply between the specified points
2410 */
2415 // we are within the minimum distance of the goal
2417 // sight check is *slow* :(
2419 // we got all the way to a suitable goal!
2423 }
2424 }
2425 }
2429 // cost is far too high, no path found
2431 }
2433 // diagonal movements
2439 // direct movements
2445 }
2447 // find path from goal to start
2453 // this is not really great, we should be finding the path that
2454 // went nearest to where we wanted
2459 }
2466 // we pathed all the way to original goal!
2467 // we don't know correct orientation until we find previous step
2470 }
2476 Point n;
2489 // don't change orientation at end of path? this seems best
2491 }
2502 }
2505 }
2508 {
2517 }
2530 //We've found _a_ path
2531 //printf("GOAL!!!\n");
2533 }
2536 //printf("Path not found!\n");
2538 }
2549 }
2551 //find path from start to goal
2561 }
2571 Point n;
2586 }
2587 //stepping back on the calculated path
2590 Point tar;
2597 }
2601 }
2602 }
2604 }
2606 //single point visible or not (visible/exploredbitmap)
2607 //if explored = true then explored otherwise currently visible
2609 {
2626 }
2628 //point a is visible from point b (searchmap)
2630 {
2638 // we basically draw a 'line' from (sX, sY) to (dX, dY)
2639 // we want to move along the larger axis, to make sure we don't miss anything
2641 // (sX - startX)/elevationy = (sX - startX)/fabs(diffx) * diffy
2644 // right to left
2646 // sX - startx >= 0, so subtract (due to sign of diffy)
2647 //if (GetBlocked( startx, sY - ( int ) ( ( sX - startx ) / elevationy ) ) & PATH_MAP_NO_SEE)
2650 }
2652 // left to right
2654 // sX - startx <= 0, so add (due to sign of diffy)
2655 //if (GetBlocked( startx, sY + ( int ) ( ( sX - startx ) / elevationy ) ) & PATH_MAP_NO_SEE)
2658 }
2659 }
2661 // (sY - startY)/elevationx = (sY - startY)/fabs(diffy) * diffx
2664 // bottom to top
2666 // sY - starty >= 0, so subtract (due to sign of diffx)
2667 //if (GetBlocked( sX - ( int ) ( ( sY - starty ) / elevationx ), starty ) & PATH_MAP_NO_SEE)
2670 }
2672 // top to bottom
2674 // sY - starty <= 0, so add (due to sign of diffx)
2675 //if (GetBlocked( sX + ( int ) ( ( sY - starty ) / elevationx ), starty ) & PATH_MAP_NO_SEE)
2678 }
2679 }
2680 }
2682 }
2684 //returns direction of area boundary, returns -1 if it isn't a boundary
2686 {
2693 }
2699 }
2701 }
2702 //south or west
2705 }
2707 }
2709 //--------ambients----------------
2711 {
2716 }
2717 //--------mapnotes----------------
2718 //text must be a pointer we can claim ownership of
2720 {
2729 }
2732 {
2739 }
2740 }
2741 }
2744 {
2749 }
2750 }
2752 }
2753 //--------spawning------------------
2755 {
2758 }
2761 {
2771 }
2773 }
2777 // if the difficulty is too high, distribute it equally over all the
2778 // critters and summon as many as the summed difficulty allows
2783 // a single critter is also too powerful
2785 }
2787 count++;
2789 }
2792 }
2800 }
2801 }
2802 }
2805 {
2806 //is it still active
2809 }
2810 //check schedule
2814 }
2816 //check day or night chance
2819 }
2820 // the difficulty check is done in SpawnCreature
2821 //create spawns
2824 }
2825 //disable spawnpoint
2827 }
2829 //--------restheader----------------
2830 /*
2831 Every spawn has a difficulty associated with it. For CREs this is the xp stat
2832 and for groups it's the value in the difficulty row.
2833 For every spawn, the difficulty sum of all spawns up to now (including the
2834 current) is compared against (party level * rest header difficulty). If it's
2835 greater, the spawning is aborted. If all the other conditions are true, at
2836 least one creature is summoned, regardless the difficulty cap.
2837 */
2839 {
2842 }
2844 //based on ingame timer
2854 // ensure a minimum power level, since many creatures have this as 0
2861 spawncount++;
2862 }
2864 }
2865 }
2867 }
2869 //--------explored bitmap-----------
2871 {
2875 x++;
2876 y++;
2877 }
2879 }
2882 {
2884 }
2887 {
2889 }
2891 // x, y are in tile coordinates
2893 {
2910 }
2913 {
2914 Point Tile;
2918 }
2936 {
2938 }
2939 }
2941 Pass--;
2943 }
2944 }
2946 }
2947 }
2948 }
2951 {
2955 }
2969 }
2970 }
2971 }
2973 //Valid values are - PATH_MAP_FREE, PATH_MAP_PC, PATH_MAP_NPC
2975 {
2976 // We block a circle of radius size-1 around (px,py)
2977 // Note that this does not exactly match BG2. BG2's approximations of
2978 // these circles are slightly different for sizes 6 and up.
2980 // Note: this is a larger circle than the one tested in GetBlocked.
2981 // This means that an actor can get closer to a wall than to another
2982 // actor. This matches the behaviour of the original BG2.
3006 }
3007 }
3008 }
3009 }
3012 {
3018 }
3020 }
3023 {
3029 }
3030 }
3032 }
3035 {
3043 }
3045 }
3047 }
3049 //Pos could be [-1,-1] in which case it copies the ground piles to their
3050 //original position in the second area
3052 {
3057 //creating (or grabbing) the container in the other map at the given position
3063 }
3064 //transfer the pile to the other container
3069 }
3070 }
3071 }
3072 }
3075 {
3076 //creating the container at the given position
3084 //transfer the pile to the other container
3089 }
3090 }
3091 }
3092 }
3095 {
3099 //converting to search square
3103 //pixel position is centered on search square
3108 //bounding box covers the search square
3120 }
3122 }
3125 {
3128 }
3132 {
3140 }
3143 {
3146 }
3154 }
3155 }
3158 {
3161 }
3163 }
3166 {
3170 }
3172 }
3175 }
3178 }
3180 }
3183 {
3184 spaIterator iter;
3189 //particles.erase(iter);
3193 }
3195 }
3196 }
3197 }
3199 void Map::Sparkle(ieDword duration, ieDword color, ieDword type, const Point &pos, unsigned int FragAnimID)
3200 {
3203 //the high word is ignored in the original engine (compatibility hack)
3233 }
3242 }
3245 }
3250 spaIterator iter;
3253 }
3255 //remove flags from actor if it has left the trigger area it had last entered
3257 {
3264 }
3265 }
3266 }
3269 {
3273 }
3276 {
3277 // this stat isn't saved
3278 // according to the HoW manual the chance of success is:
3279 // +5% for every three levels and +5% per point of wisdom
3285 }
3291 }
3294 }
3296 // returns a lightness level in the range of [0-100]
3297 // since the lightmap is much smaller than the area, we need to interpolate
3299 {
3301 // at night/dusk/dawn the lightmap color is adjusted by the color overlay. (Only get's darker.)
3305 }
3307 }
3309 ////////////////////AreaAnimation//////////////////
3310 //Area animation
3313 {
3318 }
3321 {
3325 }
3326 }
3332 }
3334 }
3335 }
3338 {
3345 }
3346 //this will make the animation stop when the game is stopped
3347 //a possible gemrb feature to have this flag settable in .are
3355 }
3358 }
3361 {
3367 }
3369 //freeing up the previous animation
3373 }
3374 }
3383 }
3388 }
3391 }
3394 }
3395 }
3398 {
3404 //re-blending after palette change
3406 }
3407 }
3410 {
3411 //Warning! This function will modify a shared palette
3413 // CHECKME: what should we do here? Currently copying palette
3414 // from first frame of first animation
3421 }
3423 }
3426 {
3429 }
3431 //check for schedule
3435 }
3437 }
3440 {
3444 //always draw the animation tinted because tint is also used for
3445 //transparency
3450 }
3454 }
3455 }
3461 if(!covers[ac] || !covers[ac]->Covers(Pos.x, Pos.y, frame->XPos, frame->YPos, frame->Width, frame->Height)) {
3465 }
3466 }
3469 }
3470 }
3472 //change the tileset if needed and possible, return true if changed
3474 {
3475 //no need of change if the area is not extended night
3477 //no need of change if the area already has the right tilemap
3481 //no need to open and read the .are file again
3482 //using the ARE class for this because ChangeMap is similar to LoadMap
3483 //it loads the lightmap and the minimap too, besides swapping the tileset
3486 }
3489 {
3492 }
3503 }
3504 }
3505 }