1 #ifndef __ACTOR_DEFINITIONS_H__
2 #define __ACTOR_DEFINITIONS_H__
3 
4 #include "Interfaces.h"
5 
6 #ifndef cond_assert
7 #define cond_assert(enabled, body) { if (enabled) { assert(body); } else { body; } }
8 #endif
9 
10 //---------------------------------------------------------------------------------------------------------------------
11 // This class represents a single point in 2D space
12 //---------------------------------------------------------------------------------------------------------------------
13 class Point
14 {
15 public:
16     double x, y;
17 
18     // construction
Point(void)19     Point(void) { x = y = 0; }
Point(const double newX,const double newY)20     Point(const double newX, const double newY) { x = newX; y = newY; }
Point(const Point & newPoint)21     Point(const Point& newPoint) { x = newPoint.x; y = newPoint.y; }
Point(const Point * pNewPoint)22     Point(const Point* pNewPoint) { x = pNewPoint->x; y = pNewPoint->y; }
23 
24     // assignment
25     Point& operator=(const Point& newPoint) { x = newPoint.x; y = newPoint.y; return (*this); }
26     Point& operator=(const Point* pNewPoint) { x = pNewPoint->x; y = pNewPoint->y; return (*this); }
27 
28     // addition/subtraction
29     Point& operator+=(const Point& newPoint) { x += newPoint.x; y += newPoint.y; return (*this); }
30     Point& operator-=(const Point& newPoint) { x -= newPoint.x; y -= newPoint.y; return (*this); }
31     Point& operator+=(const Point* pNewPoint) { x += pNewPoint->x; y += pNewPoint->y; return (*this); }
32     Point& operator-=(const Point* pNewPoint) { x -= pNewPoint->x; y -= pNewPoint->y; return (*this); }
33     Point operator+(const Point& other) { Point temp(this); temp += other; return temp; }
34     Point operator-(const Point& other) { Point temp(this); temp -= other; return temp; }
35 
36     // comparison
37     bool operator==(const Point& other) const { return ((x == other.x) && (y == other.y)); }
38     bool operator!=(const Point& other) const { return (!((x == other.x) && (y == other.y))); }
39 
40     // accessors (needed for Lua)
GetX()41     double GetX() const { return x; }
GetY()42     double GetY() const { return y; }
SetX(const double newX)43     void SetX(const double newX) { x = newX; }
SetY(const double newY)44     void SetY(const double newY) { y = newY; }
Set(const double newX,const double newY)45     void Set(const double newX, const double newY) { x = newX; y = newY; }
46 
47     // somewhat hacky vector emulation (maybe I should just write my own vector class)
Length()48     float Length() const { return sqrt((float)(x*x + y*y)); }
49 
IsZero()50     bool IsZero() { return (std::fabs(x) < DBL_EPSILON || std::fabs(y) < DBL_EPSILON); }
IsZeroXY()51     bool IsZeroXY() { return (std::fabs(x) < DBL_EPSILON && std::fabs(y) < DBL_EPSILON); }
52 
ToString()53     std::string ToString() { return ("[X: " + ToStr(x) + ", Y: " + ToStr(y) + "]"); }
54 };
55 
56 inline Point operator-(const Point& left, const Point& right) { Point temp(left); temp -= right; return temp; }
57 inline Point operator+(const Point& left, const Point& right) { Point temp(left); temp += right; return temp; }
58 
59 //-------------------------------------------------------------------------------------------------
60 // ActorFixtureDef - Physics
61 //-------------------------------------------------------------------------------------------------
62 
63 struct ActorFixtureDef
64 {
ActorFixtureDefActorFixtureDef65     ActorFixtureDef()
66     {
67         fixtureType = FixtureType_None;
68         collisionShape = "Rectangle";
69         isSensor = false;
70         size = Point(0, 0);
71         offset = Point(0, 0);
72 
73         friction = 0.0f;
74         density = 0.0f;
75         restitution = 0.0f;
76 
77         collisionFlag = CollisionFlag_None;
78         collisionMask = 0x0;
79     }
80 
81     FixtureType fixtureType;
82     std::string collisionShape;
83     bool isSensor;
84     Point size;
85     Point offset;
86 
87     float friction;
88     float density;
89     float restitution;
90 
91     CollisionFlag collisionFlag;
92     uint32 collisionMask;
93 };
94 
95 //-------------------------------------------------------------------------------------------------
96 // ActorBodyDef - Physics
97 //-------------------------------------------------------------------------------------------------
98 
99 struct ActorBodyDef
100 {
ActorBodyDefActorBodyDef101     ActorBodyDef()
102     {
103         bodyType = b2_dynamicBody;
104         addFootSensor = false;
105         makeCapsule = false;
106         makeBullet = false;
107         makeSensor = true;
108         fixtureType = FixtureType_None;
109         position = Point(0, 0);
110         positionOffset = Point(0, 0);
111         collisionShape = "Rectangle";
112         size = Point(0, 0);
113         gravityScale = 1.0f;
114         setInitialSpeed = false;
115         setInitialImpulse = false;
116         initialSpeed = Point(0, 0);
117         collisionFlag = CollisionFlag_None;
118         collisionMask = 0x0;
119         prefabType = "";
120 
121         friction = 0.0f;
122         density = 0.0f;
123         restitution = 0.0f;
124 
125         isActive = true;
126     }
127 
128     WeakActorPtr pActor;
129     b2BodyType bodyType;
130     bool addFootSensor;
131     bool makeCapsule;
132     bool makeBullet;
133     bool makeSensor;
134     FixtureType fixtureType;
135     Point position;
136     Point positionOffset;
137     std::string collisionShape;
138     Point size;
139     float gravityScale;
140     bool setInitialSpeed;
141     bool setInitialImpulse;
142     Point initialSpeed;
143     CollisionFlag collisionFlag;
144     uint32 collisionMask;
145     float friction;
146     float density;
147     float restitution;
148     std::string prefabType;
149     // TODO: This is a bit hacky - used for ducking
150     bool isActive;
151 
152     std::vector<ActorFixtureDef> fixtureList;
153 };
154 
155 //-------------------------------------------------------------------------------------------------
156 // ElevatorDef - KinematicComponent
157 //-------------------------------------------------------------------------------------------------
158 
159 struct ElevatorDef
160 {
ElevatorDefElevatorDef161     ElevatorDef()
162     {
163         hasTriggerBehaviour = false;
164         hasStartBehaviour = false;
165         hasStopBehaviour = false;
166         hasOneWayBehaviour = false;
167     }
168 
ToXmlElevatorDef169     TiXmlElement* ToXml()
170     {
171         TiXmlElement* pElevatorComponent = new TiXmlElement("KinematicComponent");
172 
173         XML_ADD_2_PARAM_ELEMENT("Speed", "x", ToStr(speed.x).c_str(), "y", ToStr(speed.y).c_str(), pElevatorComponent);
174         XML_ADD_2_PARAM_ELEMENT("MinPosition", "x", ToStr(minPosition.x).c_str(), "y", ToStr(minPosition.y).c_str(), pElevatorComponent);
175         XML_ADD_2_PARAM_ELEMENT("MaxPosition", "x", ToStr(maxPosition.x).c_str(), "y", ToStr(maxPosition.y).c_str(), pElevatorComponent);
176         XML_ADD_TEXT_ELEMENT("HasTriggerBehaviour", ToStr(hasTriggerBehaviour).c_str(), pElevatorComponent);
177         XML_ADD_TEXT_ELEMENT("HasStartBehaviour", ToStr(hasStartBehaviour).c_str(), pElevatorComponent);
178         XML_ADD_TEXT_ELEMENT("HasStopBehaviour", ToStr(hasStopBehaviour).c_str(), pElevatorComponent);
179         XML_ADD_TEXT_ELEMENT("HasOneWayBehaviour", ToStr(hasOneWayBehaviour).c_str(), pElevatorComponent);
180 
181         return pElevatorComponent;
182     }
183 
CreateFromXmlElevatorDef184     static ElevatorDef CreateFromXml(TiXmlElement* pElem)
185     {
186         ElevatorDef def;
187         def.LoadFromXml(pElem);
188         return def;
189     }
190 
LoadFromXmlElevatorDef191     void LoadFromXml(TiXmlElement* pElem)
192     {
193         SetPointIfDefined(&speed, pElem->FirstChildElement("Speed"), "x", "y");
194         SetPointIfDefined(&minPosition, pElem->FirstChildElement("MinPosition"), "x", "y");
195         SetPointIfDefined(&maxPosition, pElem->FirstChildElement("MaxPosition"), "x", "y");
196         ParseValueFromXmlElem(&hasTriggerBehaviour, pElem->FirstChildElement("HasTriggerBehaviour"));
197         ParseValueFromXmlElem(&hasStartBehaviour, pElem->FirstChildElement("HasStartBehaviour"));
198         ParseValueFromXmlElem(&hasStopBehaviour, pElem->FirstChildElement("HasStopBehaviour"));
199         ParseValueFromXmlElem(&hasOneWayBehaviour, pElem->FirstChildElement("HasOneWayBehaviour"));
200     }
201 
202     Point speed;
203     Point minPosition;
204     Point maxPosition;
205 
206     bool hasTriggerBehaviour;
207     bool hasStartBehaviour;
208     bool hasStopBehaviour;
209     bool hasOneWayBehaviour;
210 };
211 
212 //-------------------------------------------------------------------------------------------------
213 // TogglePegDef - TogglePegAIComponent
214 //-------------------------------------------------------------------------------------------------
215 
216 struct TogglePegDef
217 {
TogglePegDefTogglePegDef218     TogglePegDef()
219     {
220         isAlwaysOn = false;
221         timeOff = 0;
222         timeOn = 0;
223         toggleFrameIdx = 0;
224         delay = 0;
225     }
226 
ToXmlTogglePegDef227     TiXmlElement* ToXml()
228     {
229         TiXmlElement* pTogglePegComponent = new TiXmlElement("TogglePegAIComponent");
230 
231         XML_ADD_TEXT_ELEMENT("AlwaysOn", ToStr(isAlwaysOn).c_str(), pTogglePegComponent);
232         XML_ADD_TEXT_ELEMENT("TimeOff", ToStr(timeOff).c_str(), pTogglePegComponent);
233         XML_ADD_TEXT_ELEMENT("TimeOn", ToStr(timeOn).c_str(), pTogglePegComponent);
234         XML_ADD_TEXT_ELEMENT("ToggleFrameIdx", ToStr(toggleFrameIdx).c_str(), pTogglePegComponent);
235         XML_ADD_TEXT_ELEMENT("Delay", ToStr(delay).c_str(), pTogglePegComponent);
236 
237         return pTogglePegComponent;
238     }
239 
CreateFromXmlTogglePegDef240     static TogglePegDef CreateFromXml(TiXmlElement* pElem, bool strict)
241     {
242         TogglePegDef def;
243         def.LoadFromXml(pElem, strict);
244         return def;
245     }
246 
LoadFromXmlTogglePegDef247     void LoadFromXml(TiXmlElement* pElem, bool strict)
248     {
249         assert(pElem != NULL);
250 
251         cond_assert(strict, ParseValueFromXmlElem(&isAlwaysOn, pElem->FirstChildElement("AlwaysOn")));
252         cond_assert(strict, ParseValueFromXmlElem(&timeOff, pElem->FirstChildElement("TimeOff")));
253         cond_assert(strict, ParseValueFromXmlElem(&timeOn, pElem->FirstChildElement("TimeOn")));
254         cond_assert(strict, ParseValueFromXmlElem(&toggleFrameIdx, pElem->FirstChildElement("ToggleFrameIdx")));
255         cond_assert(strict, ParseValueFromXmlElem(&toggleSound, pElem->FirstChildElement("ToggleSound")));
256         cond_assert(strict, ParseValueFromXmlElem(&delay, pElem->FirstChildElement("Delay")));
257     }
258 
259     // All time values in miliseconds (ms)
260 
261     bool isAlwaysOn;
262     int timeOff;
263     int timeOn;
264     int toggleFrameIdx;
265     std::string toggleSound;
266     int delay;
267 };
268 
269 //-------------------------------------------------------------------------------------------------
270 // CrumblingPegDef - CrumblingPegAIComponent
271 //-------------------------------------------------------------------------------------------------
272 
273 struct CrumblingPegDef
274 {
CrumblingPegDefCrumblingPegDef275     CrumblingPegDef()
276     {
277         crumbleDelay = 0;
278         crumbleFrameIdx = 0;
279     }
280 
ToXmlCrumblingPegDef281     TiXmlElement* ToXml()
282     {
283         TiXmlElement* pTogglePegComponent = new TiXmlElement("CrumblingPegAIComponent");
284 
285         assert(false && "Unimplemented");
286 
287         return pTogglePegComponent;
288     }
289 
CreateFromXmlCrumblingPegDef290     static CrumblingPegDef CreateFromXml(TiXmlElement* pElem, bool strict)
291     {
292         CrumblingPegDef def;
293         def.LoadFromXml(pElem, strict);
294         return def;
295     }
296 
LoadFromXmlCrumblingPegDef297     void LoadFromXml(TiXmlElement* pElem, bool strict)
298     {
299         assert(pElem != NULL);
300 
301         cond_assert(strict, ParseValueFromXmlElem(&crumbleDelay, pElem->FirstChildElement("CrumbleDelay")));
302         cond_assert(strict, ParseValueFromXmlElem(&crumbleFrameIdx, pElem->FirstChildElement("CrumbleFrameIdx")));
303         cond_assert(strict, ParseValueFromXmlElem(&crumbleSound, pElem->FirstChildElement("CrumbleSound")));
304     }
305 
306     int crumbleDelay;
307     int crumbleFrameIdx;
308     std::string crumbleSound;
309 };
310 
311 //-------------------------------------------------------------------------------------------------
312 // ProjectileDef - ProjectileAIComponent
313 //-------------------------------------------------------------------------------------------------
314 
315 struct ProjectileDef
316 {
ProjectileDefProjectileDef317     ProjectileDef()
318     {
319         damage = 0;
320         damageTypeStr = "DamageType_None";
321     }
322 
ToXmlProjectileDef323     TiXmlElement* ToXml()
324     {
325         TiXmlElement* pProjectileComponent = new TiXmlElement("ProjectileAIComponent");
326 
327         XML_ADD_TEXT_ELEMENT("Damage", ToStr(damage).c_str(), pProjectileComponent);
328         XML_ADD_TEXT_ELEMENT("ProjectileType", damageTypeStr.c_str(), pProjectileComponent);
329         XML_ADD_2_PARAM_ELEMENT("ProjectileSpeed", "x", ToStr(projectileSpeed.x).c_str(), "y", ToStr(projectileSpeed.y).c_str(), pProjectileComponent);
330 
331         return pProjectileComponent;
332     }
333 
CreateFromXmlProjectileDef334     static ProjectileDef CreateFromXml(TiXmlElement* pElem, bool strict)
335     {
336         ProjectileDef def;
337         def.LoadFromXml(pElem, strict);
338         return def;
339     }
340 
LoadFromXmlProjectileDef341     void LoadFromXml(TiXmlElement* pElem, bool strict)
342     {
343         assert(pElem != NULL);
344 
345         cond_assert(strict, ParseValueFromXmlElem(&damage, pElem->FirstChildElement("Damage")));
346         cond_assert(strict, ParseValueFromXmlElem(&damageTypeStr, pElem->FirstChildElement("ProjectileType")));
347         cond_assert(strict, ParseValueFromXmlElem(&projectileSpeed, pElem->FirstChildElement("ProjectileSpeed"), "x", "y"));
348     }
349 
350     int damage;
351     std::string damageTypeStr;
352     Point projectileSpeed;
353 };
354 
355 //-------------------------------------------------------------------------------------------------
356 // ProjectileSpawnerDef - ProjectileSpawnerComponent
357 //-------------------------------------------------------------------------------------------------
358 
359 struct ProjectileSpawnerDef
360 {
ProjectileSpawnerDefProjectileSpawnerDef361     ProjectileSpawnerDef()
362     {
363         isAlwaysOn = false;
364         projectileProto = ActorPrototype_None;
365         projectileDirection = Direction_None;
366     }
367 
CreateFromXmlProjectileSpawnerDef368     static ProjectileSpawnerDef CreateFromXml(TiXmlElement* pElem, bool strict)
369     {
370         ProjectileSpawnerDef def;
371         def.LoadFromXml(pElem, strict);
372         return def;
373     }
374 
ToXmlProjectileSpawnerDef375     TiXmlElement* ToXml()
376     {
377         // TODO:
378         return NULL;
379     }
380 
LoadFromXmlProjectileSpawnerDef381     void LoadFromXml(TiXmlElement* pElem, bool strict)
382     {
383         assert(pElem != NULL);
384 
385         cond_assert(strict, ParseValueFromXmlElem(&idleAnim, pElem->FirstChildElement("IdleAnim")));
386         cond_assert(strict, ParseValueFromXmlElem(&fireAnim, pElem->FirstChildElement("FireAnim")));
387         cond_assert(strict, ParseValueFromXmlElem(&isAlwaysOn, pElem->FirstChildElement("IsAlwaysOn")));
388         cond_assert(strict, ParseValueFromXmlElem(&startSpawnDelay, pElem->FirstChildElement("StartSpawnDelay")));
389         cond_assert(strict, ParseValueFromXmlElem(&minSpawnDelay, pElem->FirstChildElement("MinSpawnDelay")));
390         cond_assert(strict, ParseValueFromXmlElem(&maxSpawnDelay, pElem->FirstChildElement("MaxSpawnDelay")));
391 
392         cond_assert(strict, ParseValueFromXmlElem(&triggerAreaSize, pElem->FirstChildElement("TriggerAreaSize"), "width", "height"));
393         cond_assert(strict, ParseValueFromXmlElem(&triggerAreaOffset, pElem->FirstChildElement("TriggerAreaOffset"), "x", "y"));
394         cond_assert(strict, ParseValueFromXmlElem(&triggerCollisionMask, pElem->FirstChildElement("TriggerCollisionMask")));
395 
396         cond_assert(strict, ParseValueFromXmlElem(&projectileSpawnAnimFrameIdx, pElem->FirstChildElement("ProjectileSpawnAnimFrameIdx")));
397 
398         std::string projectileProtoStr;
399         cond_assert(strict, ParseValueFromXmlElem(&projectileProtoStr, pElem->FirstChildElement("ProjectilePrototype")));
400         projectileProto = StringToEnum_ActorPrototype(projectileProtoStr);
401 
402         std::string directionStr;
403         cond_assert(strict, ParseValueFromXmlElem(&directionStr, pElem->FirstChildElement("ProjectileDirection")));
404         projectileDirection = StringToEnum_Direction(directionStr);
405 
406         cond_assert(strict, ParseValueFromXmlElem(&projectileSpawnOffset, pElem->FirstChildElement("ProjectileSpawnOffset"), "x", "y"));
407     }
408 
409     std::string idleAnim;
410     std::string fireAnim;
411     bool isAlwaysOn;
412     int startSpawnDelay;
413     int minSpawnDelay;
414     int maxSpawnDelay;
415     Point triggerAreaSize;
416     Point triggerAreaOffset;
417     uint32 triggerCollisionMask;
418     int projectileSpawnAnimFrameIdx;
419     ActorPrototype projectileProto;
420     Direction projectileDirection;
421     Point projectileSpawnOffset;
422 };
423 
424 struct LocalAmbientSoundDef
425 {
LocalAmbientSoundDefLocalAmbientSoundDef426     LocalAmbientSoundDef()
427     {
428     }
429 
CreateFromXmlLocalAmbientSoundDef430     static LocalAmbientSoundDef CreateFromXml(TiXmlElement* pElem, bool strict)
431     {
432         LocalAmbientSoundDef def;
433         def.LoadFromXml(pElem, strict);
434         return def;
435     }
436 
ToXmlLocalAmbientSoundDef437     TiXmlElement* ToXml()
438     {
439         // TODO:
440         return NULL;
441     }
442 
LoadFromXmlLocalAmbientSoundDef443     void LoadFromXml(TiXmlElement* pElem, bool strict)
444     {
445         assert(pElem != NULL);
446 
447         cond_assert(strict, ParseValueFromXmlElem(&sound, pElem->FirstChildElement("Sound")));
448         cond_assert(strict, ParseValueFromXmlElem(&volume, pElem->FirstChildElement("Volume")));
449         cond_assert(strict, ParseValueFromXmlElem(&soundAreaSize, pElem->FirstChildElement("SoundAreaSize"), "width", "height"));
450         cond_assert(strict, ParseValueFromXmlElem(&soundAreaOffset, pElem->FirstChildElement("SoundAreaOffset"), "x", "y"));
451     }
452 
453     std::string sound;
454     int volume;
455     Point soundAreaSize;
456     Point soundAreaOffset;
457 };
458 
459 //-------------------------------------------------------------------------------------------------
460 // DestroyableComponentDef - DestroyableComponent
461 //-------------------------------------------------------------------------------------------------
462 
463 struct DestroyableComponentDef
464 {
DestroyableComponentDefDestroyableComponentDef465     DestroyableComponentDef()
466     {
467         deleteImmediately = false;
468         deleteDelay = 0;
469         blinkOnDestruction = false;
470         deleteOnDestruction = true;
471         removeFromPhysics = true;
472         deathAnimationName = "";
473     }
474 
475     bool deleteImmediately;
476     int deleteDelay;
477     bool blinkOnDestruction;
478     bool deleteOnDestruction;
479     bool removeFromPhysics;
480     std::string deathAnimationName;
481     std::vector<std::string> deathSoundList;
482 };
483 
484 //-------------------------------------------------------------------------------------------------
485 // ElevatorStepDef - PathElevatorComponent
486 //-------------------------------------------------------------------------------------------------
487 
488 struct ElevatorStepDef
489 {
ElevatorStepDefElevatorStepDef490     ElevatorStepDef()
491     {
492         direction = Direction_None;
493         isWaiting = false;
494         waitMsTime = 0;
495     }
496 
CreateFromXmlElevatorStepDef497     static ElevatorStepDef CreateFromXml(TiXmlElement* pElem, bool strict)
498     {
499         ElevatorStepDef def;
500         def.LoadFromXml(pElem, strict);
501         return def;
502     }
503 
ToXmlElevatorStepDef504     TiXmlElement* ToXml()
505     {
506         TiXmlElement* pElevatorStepElem = new TiXmlElement("ElevatorStep");
507 
508         AddXmlTextElement("Direction", EnumToString_Direction(direction), pElevatorStepElem);
509         AddXmlTextElement("StepDeltaDistance", stepDeltaDistance, pElevatorStepElem);
510         AddXmlTextElement("IsWaiting", isWaiting, pElevatorStepElem);
511         AddXmlTextElement("WaitTime", waitMsTime, pElevatorStepElem);
512 
513         return pElevatorStepElem;
514     }
515 
LoadFromXmlElevatorStepDef516     void LoadFromXml(TiXmlElement* pElem, bool strict)
517     {
518         assert(pElem != NULL);
519 
520         std::string directionStr;
521         cond_assert(strict, ParseValueFromXmlElem(&directionStr, pElem->FirstChildElement("Direction")));
522         direction = StringToEnum_Direction(directionStr);
523 
524         cond_assert(strict, ParseValueFromXmlElem(&stepDeltaDistance, pElem->FirstChildElement("StepDeltaDistance")));
525         cond_assert(strict, ParseValueFromXmlElem(&isWaiting, pElem->FirstChildElement("IsWaiting")));
526         cond_assert(strict, ParseValueFromXmlElem(&waitMsTime, pElem->FirstChildElement("WaitTime")));
527     }
528 
529     Direction direction;
530     int stepDeltaDistance;
531 
532     bool isWaiting;
533     int waitMsTime;
534 
535     Point destinationPosition;
536 };
537 
538 //-------------------------------------------------------------------------------------------------
539 // PathElevatorDef - PathElevatorComponent
540 //-------------------------------------------------------------------------------------------------
541 
542 struct PathElevatorDef
543 {
PathElevatorDefPathElevatorDef544     PathElevatorDef()
545     {
546         speed = 0.0;
547     }
548 
CreateFromXmlPathElevatorDef549     static PathElevatorDef CreateFromXml(TiXmlElement* pElem, bool strict)
550     {
551         PathElevatorDef def;
552         def.LoadFromXml(pElem, strict);
553         return def;
554     }
555 
ToXmlPathElevatorDef556     TiXmlElement* ToXml()
557     {
558         TiXmlElement* pPathElevatorComponent = new TiXmlElement("PathElevatorComponent");
559 
560         AddXmlTextElement("Speed", speed, pPathElevatorComponent);
561 
562         TiXmlElement* pPathElem = new TiXmlElement("ElevatorSteps");
563         pPathElevatorComponent->LinkEndChild(pPathElem);
564 
565         for (ElevatorStepDef& step : elevatorPath)
566         {
567             pPathElem->LinkEndChild(step.ToXml());
568         }
569 
570         return pPathElevatorComponent;
571     }
572 
LoadFromXmlPathElevatorDef573     void LoadFromXml(TiXmlElement* pElem, bool strict)
574     {
575         assert(pElem != NULL);
576 
577         cond_assert(strict, ParseValueFromXmlElem(&speed, pElem->FirstChildElement("Speed")));
578 
579         TiXmlElement* pElevatorStepsElem = pElem->FirstChildElement("ElevatorSteps");
580         assert(pElevatorStepsElem != NULL);
581         for (TiXmlElement* pStepElem = pElevatorStepsElem->FirstChildElement("ElevatorStep");
582             pStepElem != NULL;
583             pStepElem = pStepElem->NextSiblingElement("ElevatorStep"))
584         {
585             ElevatorStepDef def;
586             def.LoadFromXml(pStepElem, strict);
587 
588             elevatorPath.push_back(def);
589         }
590     }
591 
592     double speed;
593     std::vector<ElevatorStepDef> elevatorPath;
594 };
595 
596 //-------------------------------------------------------------------------------------------------
597 // FloorSpikeDef - FloorSpikeComponent
598 //-------------------------------------------------------------------------------------------------
599 
600 struct FloorSpikeDef
601 {
FloorSpikeDefFloorSpikeDef602     FloorSpikeDef()
603     {
604         activeFrameIdx = 0;
605         damage = 0;
606         damagePulseInterval = 0;
607         cycleDuration = 0;
608         startDelay = 0;
609         timeOn = 0;
610     }
611 
CreateFromXmlFloorSpikeDef612     static FloorSpikeDef CreateFromXml(TiXmlElement* pElem, bool strict)
613     {
614         FloorSpikeDef def;
615         def.LoadFromXml(pElem, strict);
616         return def;
617     }
618 
ToXmlFloorSpikeDef619     TiXmlElement* ToXml()
620     {
621         assert(false);
622         return NULL;
623     }
624 
LoadFromXmlFloorSpikeDef625     void LoadFromXml(TiXmlElement* pElem, bool strict)
626     {
627         assert(pElem != NULL);
628 
629         cond_assert(strict, ParseValueFromXmlElem(&activeFrameIdx, pElem->FirstChildElement("ActiveFrameIdx")));
630         cond_assert(strict, ParseValueFromXmlElem(&damage, pElem->FirstChildElement("Damage")));
631         cond_assert(strict, ParseValueFromXmlElem(&damagePulseInterval, pElem->FirstChildElement("DamagePulseInterval")));
632         cond_assert(strict, ParseValueFromXmlElem(&cycleDuration, pElem->FirstChildElement("CycleDuration")));
633         cond_assert(strict, ParseValueFromXmlElem(&startDelay, pElem->FirstChildElement("StartDelay")));
634         cond_assert(strict, ParseValueFromXmlElem(&activateSound, pElem->FirstChildElement("ActivateSound")));
635         cond_assert(strict, ParseValueFromXmlElem(&deactivateSound, pElem->FirstChildElement("DeactivateSound")));
636     }
637 
638     int activeFrameIdx;
639     int timeOn;
640     int damage;
641     int damagePulseInterval;
642     int cycleDuration;
643     int startDelay;
644     std::string activateSound;
645     std::string deactivateSound;
646 };
647 
648 //-------------------------------------------------------------------------------------------------
649 // RopeDef - RopeComponent
650 //-------------------------------------------------------------------------------------------------
651 
652 struct RopeDef
653 {
RopeDefRopeDef654     RopeDef()
655     {
656         timeToFlayBackAndForth = 0;
657     }
658 
CreateFromXmlRopeDef659     static RopeDef CreateFromXml(TiXmlElement* pElem, bool strict)
660     {
661         RopeDef def;
662         def.LoadFromXml(pElem, strict);
663         return def;
664     }
665 
ToXmlRopeDef666     TiXmlElement* ToXml()
667     {
668         assert(false);
669         return NULL;
670     }
671 
LoadFromXmlRopeDef672     void LoadFromXml(TiXmlElement* pElem, bool strict)
673     {
674         assert(pElem != NULL);
675 
676         cond_assert(strict, ParseValueFromXmlElem(&timeToFlayBackAndForth, pElem->FirstChildElement("TimeToFlayBackAndForth")));
677     }
678 
679     int timeToFlayBackAndForth;
680 };
681 
682 //-------------------------------------------------------------------------------------------------
683 // SteppingGroundDef - SteppingGroundComponent
684 //-------------------------------------------------------------------------------------------------
685 
686 struct SteppingGroundDef
687 {
SteppingGroundDefSteppingGroundDef688     SteppingGroundDef()
689     {
690         toggleFrameIdx = 0;
691         timeOn = 0;
692         timeOff = 0;
693     }
694 
CreateFromXmlSteppingGroundDef695     static SteppingGroundDef CreateFromXml(TiXmlElement* pElem, bool strict)
696     {
697         SteppingGroundDef def;
698         def.LoadFromXml(pElem, strict);
699         return def;
700     }
701 
ToXmlSteppingGroundDef702     TiXmlElement* ToXml()
703     {
704         assert(false);
705         return NULL;
706     }
707 
LoadFromXmlSteppingGroundDef708     void LoadFromXml(TiXmlElement* pElem, bool strict)
709     {
710         assert(pElem != NULL);
711 
712         cond_assert(strict, ParseValueFromXmlElem(&toggleFrameIdx, pElem->FirstChildElement("ToggleFrameIdx")));
713         cond_assert(strict, ParseValueFromXmlElem(&timeOn, pElem->FirstChildElement("TimeOn")));
714         cond_assert(strict, ParseValueFromXmlElem(&timeOff, pElem->FirstChildElement("TimeOff")));
715         cond_assert(strict, ParseValueFromXmlElem(&toggleSound, pElem->FirstChildElement("ToggleSound")));
716     }
717 
718     int toggleFrameIdx;
719     int timeOn;
720     int timeOff;
721     std::string toggleSound;
722 };
723 
724 //-------------------------------------------------------------------------------------------------
725 // SpringBoardDef - SpringBoardComponent
726 //-------------------------------------------------------------------------------------------------
727 
728 struct SpringBoardDef
729 {
SpringBoardDefSpringBoardDef730     SpringBoardDef()
731     {
732         springHeight = 0.0;
733         springFrameIdx = 0;
734         springDelay = 0;
735         springSound = "/GAME/SOUNDS/NULL.WAV";
736     }
737 
CreateFromXmlSpringBoardDef738     static SpringBoardDef CreateFromXml(TiXmlElement* pElem, bool strict)
739     {
740         SpringBoardDef def;
741         def.LoadFromXml(pElem, strict);
742         return def;
743     }
744 
ToXmlSpringBoardDef745     TiXmlElement* ToXml()
746     {
747         assert(false);
748         return NULL;
749     }
750 
LoadFromXmlSpringBoardDef751     void LoadFromXml(TiXmlElement* pElem, bool strict)
752     {
753         assert(pElem != NULL);
754 
755         cond_assert(strict, ParseValueFromXmlElem(&springHeight, pElem->FirstChildElement("SpringHeight")));
756         cond_assert(strict, ParseValueFromXmlElem(&springFrameIdx, pElem->FirstChildElement("SpringFrameIdx")));
757         cond_assert(strict, ParseValueFromXmlElem(&idleAnimName, pElem->FirstChildElement("IdleAnimName")));
758         cond_assert(strict, ParseValueFromXmlElem(&springAnimName, pElem->FirstChildElement("SpringAnimName")));
759         cond_assert(strict, ParseValueFromXmlElem(&springDelay, pElem->FirstChildElement("SpringDelay")));
760         ParseValueFromXmlElem(&springSound, pElem->FirstChildElement("SpringSound"));
761     }
762 
763     double springHeight;
764     int springFrameIdx;
765     int springDelay;
766     std::string idleAnimName;
767     std::string springAnimName;
768     std::string springSound;
769 };
770 
771 //-------------------------------------------------------------------------------------------------
772 // AnimationDef - AnimationComponent
773 //-------------------------------------------------------------------------------------------------
774 
775 struct AnimationDef
776 {
AnimationDefAnimationDef777     AnimationDef()
778     {
779         hasAnimation = false;
780         isCycleAnimation = false;
781         cycleAnimationDuration = 0;
782     }
783 
784     bool hasAnimation;
785     bool isCycleAnimation;
786     int cycleAnimationDuration;
787     std::string animationPath;
788 };
789 
790 //-------------------------------------------------------------------------------------------------
791 // CollisionInfo - Contains collisonFlag an collisionMask for PhysicsComponent
792 //-------------------------------------------------------------------------------------------------
793 
794 struct CollisionInfo
795 {
CollisionInfoCollisionInfo796     CollisionInfo()
797     {
798         collisionFlag = CollisionFlag_None;
799         collisionMask = 0xFFFFFFFF;
800     }
801 
CollisionInfoCollisionInfo802     CollisionInfo(CollisionFlag colFlag, uint32 colMask)
803     {
804         collisionFlag = colFlag;
805         collisionMask = colMask;
806     }
807 
808     CollisionFlag collisionFlag;
809     uint32 collisionMask;
810 };
811 
812 //-------------------------------------------------------------------------------------------------
813 // EnemyAttackAction - EnemyAIComponent, EnemyAIStateComponent
814 //-------------------------------------------------------------------------------------------------
815 
816 struct EnemyAttackAction
817 {
EnemyAttackActionEnemyAttackAction818     EnemyAttackAction()
819     {
820         attackAnimFrameIdx = 0;
821         attackDamageType = DamageType_None;
822         projectileProto = ActorPrototype_None;
823         attackFxImageSet = "NONE";
824         isMirrored = false;
825     }
826 
827     ActorPrototype projectileProto;
828 
829     std::string animation;
830     uint32 attackAnimFrameIdx;
831     std::string attackFxImageSet;
832     bool isMirrored;
833 
834     DamageType attackDamageType;
835 
836     // Used to spawn area damage
837 
838     // Considering enemy is looking left
839     Point attackSpawnPositionOffset;
840 
841     // Applicable only to melee attacks
842     Point attackAreaSize;
843 
844     // Damage which the attack will deal to enemies
845     uint32 damage;
846 
847     // Enemy agro range bound to this attack action - attack action
848     // can only be performed when enemy is within it
849     ActorFixtureDef agroSensorFixture;
850 };
851 
852 //-------------------------------------------------------------------------------------------------
853 // PredefinedMove - EnemyAIComponent, EnemyAIStateComponent
854 //-------------------------------------------------------------------------------------------------
855 
856 struct PredefinedMove
857 {
PredefinedMovePredefinedMove858     PredefinedMove()
859     {
860         msDuration = 0;
861         pixelsPerSecond = Point(0, 0);
862         soundToPlay = "";
863     }
864 
865     uint32 msDuration;
866     Point pixelsPerSecond;
867     std::string soundToPlay;
868 };
869 
870 //-------------------------------------------------------------------------------------------------
871 // SoundInfo - Used as definition of sound being played
872 //-------------------------------------------------------------------------------------------------
873 
874 struct SoundInfo
875 {
SoundInfoSoundInfo876     SoundInfo()
877     {
878         isMusic = false;
879         soundVolume = 100;
880         loops = 0;
881         setPositionEffect = false;
882         setDistanceEffect = false;
883         maxHearDistance = 0;
884         attentuationFactor = 1.0f;
885     }
886 
SoundInfoSoundInfo887     SoundInfo(std::string sound) : SoundInfo()
888     {
889         soundToPlay = sound;
890     }
891 
892     std::string soundToPlay;
893     bool isMusic;
894     int soundVolume;
895     int loops;
896     bool setPositionEffect;
897     bool setDistanceEffect;
898     float maxHearDistance;
899     float attentuationFactor;
900     Point soundSourcePosition;
901 };
902 
903 struct SoundProperties
904 {
SoundPropertiesSoundProperties905     SoundProperties()
906     {
907         volume = 100;
908         loops = 0;
909         angle = 0;
910         distance = 0;
911     }
912 
913     int volume;
914     int loops;
915     int angle;
916     int distance;
917 };
918 
919 struct ActorSpawnInfo
920 {
ActorSpawnInfoActorSpawnInfo921     ActorSpawnInfo()
922     {
923         actorProto = ActorPrototype_None;
924     }
925 
926     ActorPrototype actorProto;
927     Point spawnPositionOffset;
928     Point initialVelocity;
929 };
930 
931 #endif