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