1 #ifndef strachnk_hpp 2 #define strachnk_hpp 1 3 4 5 #include "chunk.hpp" 6 #include "chnktype.hpp" 7 #include "ltfx_exp.h" 8 9 10 #define StratDoor 50 11 #define StratLift 51 12 #define StratBinSwitch 52 13 #define StratSimpleObject 53 14 #define StratPlatLift 54 15 #define StratAirlock 57 16 #define StratSwitchDoor 59 17 #define StratLiftNoTel 60 18 #define StratLinkSwitch 61 19 #define StratNewSimpleObject 62 20 #define StratConsole 63 21 #define StratLighting 64 22 #define StratMultiSwitch 66 23 #define StratTeleport 67 24 #define StratAreaSwitch 68 25 #define StratEnemy 69 26 #define StratMissionObjective 70 27 #define StratMissionHint 71 28 #define StratTrack 72 29 #define StratMessage 73 30 #define StratFan 75 31 #define StratHierarchy 76 32 #define StratDeathVolume 77 33 #define StratSelfDestruct 78 34 #define StratGenerator 79 35 #define StratTrackDestruct 80 36 37 #define StratSwingDoor 1000 38 #define StratPlacedBomb 1001 39 #define StratR6Switch 1002 40 #define StratR6SimpleObject 1003 41 42 #define StratMummyInanimate 2000 43 #define StratMummyPickup 2001 44 #define StratMummySimple 2002 45 #define StratMummyTriggerVolume 2003 46 #define StratMummyPivotObject_Old 2004 47 #define StratMummyChest 2005 48 #define StratMummyAlterCameraRange 2006 49 #define StratMummyPivotObject 2007 50 51 52 class AvpStrat; 53 54 class AVP_Strategy_Chunk :public Chunk 55 { 56 public: 57 AVP_Strategy_Chunk(Chunk_With_Children* ,const char*,size_t); 58 AVP_Strategy_Chunk(Chunk_With_Children*); 59 ~AVP_Strategy_Chunk(); 60 61 virtual BOOL output_chunk (HANDLE &hand); 62 virtual size_t size_chunk(); 63 virtual void fill_data_block(char* data_start); 64 65 int index;// for matching strategy up with the object it belongs to, currently only used by for light strategies 66 int spare2; 67 68 AvpStrat* Strategy; 69 }; 70 71 class AVP_External_Strategy_Chunk :public Chunk 72 { 73 public: 74 AVP_External_Strategy_Chunk(Chunk_With_Children* ,const char*,size_t); 75 AVP_External_Strategy_Chunk(Chunk_With_Children*); 76 ~AVP_External_Strategy_Chunk(); 77 78 virtual BOOL output_chunk (HANDLE &hand); 79 virtual size_t size_chunk(); 80 virtual void fill_data_block(char* data_start); 81 82 ObjectID ObjID; 83 int ExtEnvNum; 84 int ThisEnvNum; 85 int spare; 86 87 AvpStrat* Strategy; 88 }; 89 90 // for attaching strategies to 91 class Virtual_Object_Chunk :public Chunk_With_Children 92 { 93 public: 94 Virtual_Object_Chunk(Chunk_With_Children * parent)95 Virtual_Object_Chunk(Chunk_With_Children * parent) 96 : Chunk_With_Children (parent, "VIOBJECT") 97 {} 98 99 100 // constructor from buffer 101 Virtual_Object_Chunk (Chunk_With_Children * const parent,const char *, size_t const); 102 103 104 }; 105 class Virtual_Object_Properties_Chunk: public Chunk 106 { 107 public : 108 Virtual_Object_Properties_Chunk(Chunk_With_Children* parent,const char* _name); 109 Virtual_Object_Properties_Chunk(Chunk_With_Children* parent,const char*,size_t); 110 ~Virtual_Object_Properties_Chunk(); 111 112 virtual size_t size_chunk(); 113 virtual void fill_data_block(char* data_start); 114 115 116 ChunkVectorInt location; 117 int size; 118 char* name; 119 ObjectID ID; 120 int pad1,pad2; 121 122 ObjectID CalculateID(); 123 }; 124 125 126 class AvpStrat 127 { 128 public: 129 AvpStrat(const char* data_start); 130 AvpStrat(int _StrategyType); ~AvpStrat()131 virtual ~AvpStrat(){} 132 int StrategyType; 133 134 int Type,ExtraData; 135 virtual size_t GetStrategySize(); 136 virtual void fill_data_block(char* data); 137 }; 138 139 class MiscStrategy :public AvpStrat 140 { 141 public: 142 MiscStrategy(const char* data_start,size_t size); 143 virtual ~MiscStrategy(); 144 145 int blocksize; 146 char* datablock; 147 148 virtual size_t GetStrategySize(); 149 virtual void fill_data_block(char* data); 150 }; 151 152 153 #define SimStratFlag_NotifyTargetOnDestruction 0x00000001 154 #define SimStratFlag_NotifyTargetOnPickup 0x00000002 155 156 #define SimStratFlag_SmallExplosion 0x00000010 //explosive barrel type things 157 #define SimStratFlag_BigExplosion 0x00000020 158 #define SimStratFlag_MolotovExplosion 0x00000030 159 160 #define SimStratFlag_ExplosionMask 0x00000030 161 #define SimStratFlag_ExplosionShift 4 162 163 //contained within the integrity 164 #define SimpleStrategy_SparesDontContainJunk 0x80000000 165 166 //and for r6 167 #define SimpleStrategy_R6IntegrityValid 0x40000000 168 #define SimpleStrategy_R6IntegrityMask 0xffff 169 #define SimpleStrategy_R6DestTypeMask 0xff0000 170 #define SimpleStrategy_R6DestTypeShift 16 171 172 173 class SimpleStrategy : public AvpStrat 174 { 175 public: 176 SimpleStrategy(const char* data_start,size_t size); 177 178 int Type,ExtraData; 179 180 int mass; 181 int integrity; 182 183 int flags; 184 int target_request; 185 union 186 { 187 ObjectID targetID; 188 unsigned char R6_Linked_Guards[4]; 189 }; 190 191 virtual size_t GetStrategySize(); 192 virtual void fill_data_block(char* data); 193 get_integrity()194 unsigned int get_integrity() {return integrity &~ SimpleStrategy_SparesDontContainJunk;} 195 196 unsigned int get_r6_integrity(); 197 void set_r6_integrity(unsigned int); 198 unsigned int get_r6_destruction_type(); 199 void set_r6_destruction_type(unsigned int); 200 }; 201 202 class R6SimpleStrategy : public SimpleStrategy 203 { 204 public : 205 R6SimpleStrategy(const char* data_start,size_t); 206 207 ObjectID r6SoundID; // id of a linked sound 208 int r6_spare1; 209 int r6_spare2; 210 int r6_spare3; 211 int r6_spare4; 212 int r6_spare5; 213 int r6_spare6; 214 215 216 virtual size_t GetStrategySize(); 217 virtual void fill_data_block(char* data); 218 }; 219 220 221 222 #define LiftFlag_Here 0x00000001 223 #define LiftFlag_Airlock 0x00000002 224 #define LiftFlag_NoTel 0x00000004 //switches aren't teleported 225 #define LiftFlag_ExitOtherSide 0x00000008 226 struct ExtLift 227 { 228 int EnvNum; 229 int junk[4]; 230 ObjectID LiftID; 231 }; 232 233 class LiftStrategy :public AvpStrat 234 { 235 public: 236 LiftStrategy(const char* data_start,size_t size); 237 virtual ~LiftStrategy(); 238 239 int NumAssocLifts; 240 ObjectID* AssocLifts; 241 242 ObjectID AssocDoor; 243 ObjectID AssocCallSwitch; 244 ObjectID AssocFloorSwitch; 245 int LiftFlags; 246 int Floor; 247 int NumExternalLifts; 248 ExtLift* ExternalLifts; 249 250 int Facing; 251 252 virtual size_t GetStrategySize(); 253 virtual void fill_data_block(char* data); 254 }; 255 256 #define PlatformLiftFlags_Disabled 0x00000001 257 #define PlatformLiftFlags_OneUse 0x00000002 258 class PlatLiftStrategy :public AvpStrat 259 { 260 public: 261 PlatLiftStrategy(const char* data_start,size_t size); 262 263 int flags; 264 int spare[5]; 265 266 virtual size_t GetStrategySize(); 267 virtual void fill_data_block(char* data); 268 }; 269 270 #define DoorFlag_Locked 0x00000001 271 #define DoorFlag_Proximity 0x00000002 272 #define DoorFlag_Open 0x00000004 273 #define DoorFlag_Lift 0x00000008 274 #define DoorFlag_Horizontal 0x00000010 //door lying horizontal 275 276 class DoorStrategy :public AvpStrat 277 { 278 public: 279 DoorStrategy(const char* data_start,size_t); 280 281 int DoorFlags; 282 unsigned char TimeToOpen; //in tenths of a second 283 unsigned char TimeToClose; //in tenths of a second 284 short spare; 285 286 virtual size_t GetStrategySize(); 287 virtual void fill_data_block(char* data); 288 }; 289 290 #define R6SwitchDoorFlag_SwitchOperated 0x00000001 291 292 293 class SwitchDoorStrategy : public AvpStrat 294 { 295 public: 296 SwitchDoorStrategy(const char* data_start,size_t); 297 298 ObjectID AssocDoor; 299 //union 300 //{ 301 int spare1; 302 // struct 303 // { 304 // unsigned int r6_flags:20; 305 // unsigned int r6_open_time:6; //in tenths of a second 306 // unsigned int r6_close_time:6; //in tenths of a second 307 // }; 308 //}; 309 310 int spare2; 311 312 virtual size_t GetStrategySize(); 313 virtual void fill_data_block(char* data); 314 }; 315 316 struct SwitchTarget 317 { 318 ObjectID ID; 319 int request; 320 }; 321 322 #define BinSwitchFlag_StartsOn 0x00000001 323 #define BinSwitchFlag_OffMessageSame 0x00000002 324 #define BinSwitchFlag_OffMessageNone 0x00000004 325 326 class BinSwitchStrategy :public AvpStrat 327 { 328 public : 329 BinSwitchStrategy(const char* data_start,size_t); ~BinSwitchStrategy()330 virtual ~BinSwitchStrategy(){}; 331 332 int flags; 333 int Mode; 334 int Time; 335 int Security; 336 SwitchTarget Target; 337 338 virtual size_t GetStrategySize(); 339 virtual void fill_data_block(char* data); 340 }; 341 342 class LinkSwitchStrategy :public BinSwitchStrategy 343 { 344 public : 345 LinkSwitchStrategy(const char* data_start,size_t); 346 virtual ~LinkSwitchStrategy(); 347 348 int NumLinks; 349 ObjectID* LinkedSwitches; 350 351 virtual size_t GetStrategySize(); 352 virtual void fill_data_block(char* data); 353 }; 354 355 #define MultiSwitchFlag_SwitchUpdated 0x80000000 356 #define MultiSwitchFlag_OffMessageSame 0x00000002 357 #define MultiSwitchFlag_OffMessageNone 0x00000004 358 359 #define MultiSwitchRequest_LinkedSwitch 0x00000002 360 class MultiSwitchStrategy :public AvpStrat 361 { 362 public : 363 MultiSwitchStrategy(const char* data_start,size_t); 364 virtual ~MultiSwitchStrategy(); 365 366 int RestState; 367 int Mode; 368 int Time; 369 int Security; 370 371 int NumTargets; 372 SwitchTarget* Targets; 373 374 int NumLinks; 375 ObjectID* LinkedSwitches; 376 377 int pad1; //used to be UseRestStateAfter , so possible conversion upon load 378 int flags; 379 380 virtual size_t GetStrategySize(); 381 virtual void fill_data_block(char* data); 382 }; 383 384 class AreaSwitchStrategy :public MultiSwitchStrategy 385 { 386 public : 387 AreaSwitchStrategy(const char* data_start,size_t); 388 389 ChunkVectorInt trigger_min,trigger_max; 390 int area_pad1,area_pad2; 391 392 virtual size_t GetStrategySize(); 393 virtual void fill_data_block(char* data); 394 }; 395 396 397 398 class ConsoleStrategy :public AvpStrat 399 { 400 public : 401 ConsoleStrategy(const char* data_start,size_t); 402 403 int ConsoleNum; 404 int spare1,spare2; 405 406 virtual size_t GetStrategySize(); 407 virtual void fill_data_block(char* data); 408 }; 409 410 class LightingStrategy : public AvpStrat 411 { 412 public : 413 LightingStrategy(const char* data_start,size_t); 414 415 LightFXData LightData; 416 417 int pad1,pad2,pad3; 418 419 virtual size_t GetStrategySize(); 420 virtual void fill_data_block(char* data); 421 }; 422 423 #define Teleport_All 0 424 #define Teleport_Marine 1 425 #define Teleport_Alien 2 426 #define Teleport_Predator 3 427 428 class TeleportStrategy : public AvpStrat 429 { 430 public: 431 TeleportStrategy(const char* data_start,size_t); 432 433 ObjectID TeleportTo; 434 int Type; 435 int spare1,spare2; 436 437 virtual size_t GetStrategySize(); 438 virtual void fill_data_block(char* data); 439 }; 440 441 442 class EnemyStrategy : public AvpStrat 443 { 444 public: 445 EnemyStrategy(const char* data_start,size_t); 446 447 int MissionType; 448 int target_request; 449 ObjectID DeathTarget; 450 451 int ExtraMissionData; 452 int spares[3]; 453 454 455 virtual size_t GetStrategySize(); 456 virtual void fill_data_block(char* data); 457 }; 458 459 class GeneratorStrategy : public AvpStrat 460 { 461 public: 462 GeneratorStrategy(const char* data_start,size_t); 463 464 int MissionType; 465 int ExtraMissionData; 466 467 int spares[6]; 468 469 470 virtual size_t GetStrategySize(); 471 virtual void fill_data_block(char* data); 472 }; 473 474 475 #define MissionFlag_Visible 0x00000001 476 #define MissionFlag_CurrentlyPossible 0x00000002 477 478 #define MissionTrigger_MakeVisible 0x00000001 479 #define MissionTrigger_MakePossible 0x00000002 480 #define MissionTrigger_DontComplete 0x00000004 481 482 enum MissionCompletionEffects 483 { 484 MCE_None, 485 MCE_CompleteLevel, 486 MCE_Last, 487 }; 488 489 struct MissionMessage 490 { 491 ObjectID target_mission; 492 int effect_on_target; 493 }; 494 495 struct RequestTarget 496 { 497 ObjectID target; 498 int request; 499 }; 500 501 class MissionObjectiveStrategy : public AvpStrat 502 { 503 public: 504 MissionObjectiveStrategy(const char* data_start,size_t); 505 506 //indeces in english.txt 507 int mission_description_string; 508 int mission_complete_string; 509 int mission_number; 510 511 int flags; 512 513 int mission_completion_effect; 514 515 int num_mission_targets; 516 MissionMessage* mission_targets; 517 518 int num_request_targets; 519 RequestTarget* request_targets; 520 521 int pad1,pad2; 522 523 virtual size_t GetStrategySize(); 524 virtual void fill_data_block(char* data); 525 }; 526 527 class MissionHintStrategy : public AvpStrat 528 { 529 public: 530 MissionHintStrategy(const char* data_start,size_t); 531 532 int mission_hint_string; 533 int mission_number; 534 int flags; 535 536 int pad1,pad2; 537 538 virtual size_t GetStrategySize(); 539 virtual void fill_data_block(char* data); 540 }; 541 542 #define TextMessageFlag_NotActiveAtStart 0x00000001 543 544 class TextMessageStrategy : public AvpStrat 545 { 546 public: 547 TextMessageStrategy(const char* data_start,size_t); 548 549 int message_string; 550 551 int flags,pad2; 552 553 virtual size_t GetStrategySize(); 554 virtual void fill_data_block(char* data); 555 }; 556 557 558 #define TrackRequestFlag_ActiveForward 0x00000001 559 #define TrackRequestFlag_ActiveBackward 0x00000002 560 #define TrackRequestFlag_OppositeBackward 0x00000004 561 562 struct TrackRequestTarget 563 { 564 ObjectID targetID; 565 int request; 566 int flags; 567 }; 568 569 struct TrackPointEffect 570 { 571 int point_no; 572 int num_targets; 573 TrackRequestTarget* targets; 574 int pad1; 575 ~TrackPointEffectTrackPointEffect576 ~TrackPointEffect() 577 { 578 if(targets) delete [] targets; 579 } 580 581 582 }; 583 584 class TrackStrategy : public AvpStrat 585 { 586 public: 587 TrackStrategy(const char* data_start,size_t); 588 ~TrackStrategy(); 589 590 int num_point_effects; 591 TrackPointEffect** point_effects; 592 593 int pad1; 594 int pad2; 595 596 virtual size_t GetStrategySize(); 597 virtual void fill_data_block(char* data); 598 }; 599 600 class TrackDestructStrategy : public TrackStrategy 601 { 602 public: 603 TrackDestructStrategy(const char* data_start,size_t); 604 605 int integrity; 606 int target_request; 607 ObjectID targetID; //target when blown up 608 609 virtual size_t GetStrategySize(); 610 virtual void fill_data_block(char* data); 611 }; 612 613 class HierarchyStrategy : public AvpStrat 614 { 615 public: 616 HierarchyStrategy(const char* data_start,size_t); 617 ~HierarchyStrategy(); 618 619 int num_point_effects; 620 TrackPointEffect** point_effects; 621 622 int pad1; 623 int pad2; 624 625 virtual size_t GetStrategySize(); 626 virtual void fill_data_block(char* data); 627 }; 628 629 class FanStrategy : public AvpStrat 630 { 631 public: 632 FanStrategy(const char* data_start,size_t); 633 634 int speed_up_time; 635 int slow_down_time; 636 int fan_wind_strength; 637 int pad2; 638 639 virtual size_t GetStrategySize(); 640 virtual void fill_data_block(char* data); 641 }; 642 643 #define DeathVolumeFlag_StartsOn 0x00000001 644 #define DeathVolumeFlag_CollisionNotRequired 0x00000002 645 class DeathVolumeStrategy : public AvpStrat 646 { 647 public: 648 DeathVolumeStrategy(const char* data_start,size_t); 649 650 ChunkVectorInt volume_min; 651 ChunkVectorInt volume_max; 652 int flags; 653 int damage; //damage per second , 0 = infinite 654 int pad2; 655 656 virtual size_t GetStrategySize(); 657 virtual void fill_data_block(char* data); 658 }; 659 660 class SelfDestructStrategy : public AvpStrat 661 { 662 public: 663 SelfDestructStrategy(const char* data_start,size_t); 664 665 int timer;//in seconds 666 int pad[4]; 667 668 virtual size_t GetStrategySize(); 669 virtual void fill_data_block(char* data); 670 }; 671 672 673 674 675 676 677 /////////////////////rainbow 6 strategy alert///////////////////////// 678 679 #define SwingDoorFlag_Open 0x00000001 680 #define SwingDoorFlag_Locked 0x00000002 681 //flag set to show time_open has been set to the new default of 0 682 #define SwingDoorFlag_UpdatedTime 0x80000000 683 class SwingDoorStrategy : public AvpStrat 684 { 685 public: 686 SwingDoorStrategy(const char* data_start,size_t); 687 688 int time_open;//in milliseconds 689 ObjectID paired_door; 690 ObjectID doorway_module; 691 int flags; 692 int time_to_pick;//in milliseconds 693 int spare3; 694 int spare4; 695 696 virtual size_t GetStrategySize(); 697 virtual void fill_data_block(char* data); 698 }; 699 700 701 702 #define BombFlag_TerroristActivate 0x00000001 703 #define BombFlag_Armed 0x00000002 704 705 #define BombType_Bomb 0 706 #define BombType_SecurityConsole 1 707 #define BombType_VirusCapsule 2 708 #define BombType_Computer 3 709 #define BombType_NonCriticalAlarm 4 710 711 712 class PlacedBombStrategy : public AvpStrat 713 { 714 public: 715 PlacedBombStrategy(const char* data_start,size_t); 716 717 int type; 718 int time;//seconds 719 int flags; 720 int integrity; 721 722 723 unsigned char objective_number; //a value from 0 to 4 724 unsigned short time_to_pick; //seconds 725 unsigned char pad; 726 727 int spare2,spare3,spare4; 728 729 virtual size_t GetStrategySize(); 730 virtual void fill_data_block(char* data); 731 }; 732 733 class R6SwitchStrategy : public AvpStrat 734 { 735 public: 736 R6SwitchStrategy(const char* data_start,size_t); 737 738 ObjectID TargetID; 739 740 741 int spare1,spare2,spare3,spare4; 742 743 virtual size_t GetStrategySize(); 744 virtual void fill_data_block(char* data); 745 }; 746 747 /////////////////////Mummy strategy alert///////////////////////// 748 class MummyInanimateStrategy : public AvpStrat 749 { 750 public : 751 MummyInanimateStrategy(const char* data_start,size_t); 752 MummyInanimateStrategy(); 753 754 int destructionType; 755 int health; //0 to 100 756 char generatedPickups[4]; 757 ObjectID linkedSoundID; 758 ObjectID activateID; 759 760 int spare1,spare2,spare3,spare4; 761 762 763 virtual size_t GetStrategySize(); 764 virtual void fill_data_block(char* data); 765 }; 766 767 768 class MummyPickupStrategy : public AvpStrat 769 { 770 public : 771 MummyPickupStrategy(const char* data_start,size_t); 772 MummyPickupStrategy(); 773 774 int pickupType; 775 BOOL inactiveAtStart; 776 int spare1,spare2,spare3,spare4; 777 778 virtual size_t GetStrategySize(); 779 virtual void fill_data_block(char* data); 780 }; 781 782 class MummyTriggerVolumeStrategy : public AvpStrat 783 { 784 public : 785 MummyTriggerVolumeStrategy(const char* data_start,size_t); 786 787 ChunkVectorInt trigger_min,trigger_max; 788 ObjectID targetID; 789 790 int spare1,spare2,spare3,spare4; 791 792 virtual size_t GetStrategySize(); 793 virtual void fill_data_block(char* data); 794 }; 795 796 #define MummyPivotObject_Pillar 0 797 #define MummyPivotObject_Flagstone 1 798 799 class MummyPivotObjectStrategy : public AvpStrat 800 { 801 public : 802 MummyPivotObjectStrategy(const char* data_start,size_t); 803 804 int typeID; //pillar or flagstone 805 int triggerDelay; //in milliseconds (fixed point seconds in game) 806 ObjectID targetID; 807 808 int spare1,spare2; 809 810 ChunkVectorInt trigger_min,trigger_max; 811 812 virtual size_t GetStrategySize(); 813 virtual void fill_data_block(char* data); 814 }; 815 816 class MummyChestStrategy : public AvpStrat 817 { 818 public : 819 MummyChestStrategy(const char* data_start,size_t); 820 821 unsigned char objectives[4]; 822 823 ChunkVectorInt camera_location; 824 int spare; 825 826 virtual size_t GetStrategySize(); 827 virtual void fill_data_block(char* data); 828 }; 829 830 831 #define MUMMY_CAMERA_AXIS_MIN_X 0 832 #define MUMMY_CAMERA_AXIS_MAX_X 1 833 #define MUMMY_CAMERA_AXIS_MIN_Z 2 834 #define MUMMY_CAMERA_AXIS_MAX_Z 3 835 836 class MummyAlterCameraRangeStrategy : public AvpStrat 837 { 838 public : 839 MummyAlterCameraRangeStrategy(const char* data_start,size_t); 840 841 ChunkVectorInt zone_min,zone_max; 842 int enter_range; // camera range in mm for one side of he zone 843 int exit_range; // ditto for opposite side 844 845 int axis; //axis that the change happens across 846 847 int spare1,spare2,spare3,spare4; 848 849 850 virtual size_t GetStrategySize(); 851 virtual void fill_data_block(char* data); 852 }; 853 854 #endif 855