| | 1 | #include "system.h" |
| | 2 | #include "prototyp.h" |
| | 3 | #include "stratdef.h" |
| | 4 | #include "bh_types.h" |
| | 5 | #include "dynamics.h" |
| | 6 | #include "pvisible.h" |
| | 7 | #include "npc_queen.h" |
| | 8 | #include "weapons.h" |
| | 9 | #include "extents.h" |
| | 10 | #include "sequnces.h" |
| | 11 | #include "targeting.h" |
| | 12 | #include "los.h" |
| | 13 | #include "bh_track.h" |
| | 14 | #include "sfx.h" |
| | 15 | #include "scream.h" |
| | 16 | #include <math.h> |
| | 17 | #include <assert.h> |
| | 18 | #include <stdlib.h> |
| | 19 | #include <stdio.h> |
| | 20 | #include <string.h> |
| | 21 | |
| | 22 | enum QueenLeftStanceTemplateSubSequences |
| | 23 | { |
| | 24 | QLSTSS_Standard, |
| | 25 | QLSTSS_Forward_L2R, |
| | 26 | QLSTSS_Backward_L2R, |
| | 27 | QLSTSS_Right_L2L, |
| | 28 | QLSTSS_Left_L2L, |
| | 29 | QLSTSS_LeftSwipe, |
| | 30 | QLSTSS_RightSwipe, |
| | 31 | QLSTSS_RightHit, |
| | 32 | QLSTSS_LeftHit, |
| | 33 | QLSTSS_end |
| | 34 | }; |
| | 35 | |
| | 36 | enum QueenLeftStanceFull_SubSequences |
| | 37 | { |
| | 38 | QLSFSS_Standard_Hiss, |
| | 39 | QLSFSS_Taunt, |
| | 40 | QLSFSS_Forward_L2R, |
| | 41 | QLSFSS_Backward_L2R, |
| | 42 | QLSFSS_Right_L2L, |
| | 43 | QLSFSS_Left_L2L, |
| | 44 | QLSFSS_end |
| | 45 | }; |
| | 46 | |
| | 47 | enum QueenRightStanceTemplateSubSequences |
| | 48 | { |
| | 49 | QRSTSS_Standard, |
| | 50 | QRSTSS_Forward_R2L, |
| | 51 | QRSTSS_Backward_R2L, |
| | 52 | QRSTSS_Right_R2R, |
| | 53 | QRSTSS_Left_R2R, |
| | 54 | QRSTSS_LeftSwipe, |
| | 55 | QRSTSS_RightSwipe, |
| | 56 | QRSTSS_RightHit, |
| | 57 | QRSTSS_LeftHit, |
| | 58 | QRSTSS_LeftSwipe_Low, |
| | 59 | QRSTSS_RightSwipe_Low, |
| | 60 | QRSTSS_end |
| | 61 | }; |
| | 62 | |
| | 63 | enum QueenRightStanceFull_SubSequences |
| | 64 | { |
| | 65 | QRSFSS_Standard_Hiss, |
| | 66 | QRSFSS_Taunt, |
| | 67 | QRSFSS_Forward_R2L, |
| | 68 | QRSFSS_Backward_R2L, |
| | 69 | QRSFSS_Right_R2R, |
| | 70 | QRSFSS_Left_R2R, |
| | 71 | QRSFSS_end |
| | 72 | }; |
| | 73 | |
| | 74 | enum QueenGeneral_SubSequences |
| | 75 | { |
| | 76 | QGSS_SquashDeath, |
| | 77 | QGSS_FaceDeath, |
| | 78 | QGSS_FallDeath, |
| | 79 | QGSS_ButtConnect, |
| | 80 | QGSS_RunButtAttack, |
| | 81 | QGSS_Walk, |
| | 82 | QGSS_Explode_Death, |
| | 83 | QGSS_Sprint, |
| | 84 | QGSS_Stop_To_Left, |
| | 85 | QGSS_Stop_To_Right, |
| | 86 | QGSS_Walk_II, |
| | 87 | QGSS_Sprint_II, |
| | 88 | QGSS_Spine_Elevation, |
| | 89 | QGSS_Search_Floor, |
| | 90 | QGSS_Fire_Flinch, |
| | 91 | QGSS_Fire_Steps, |
| | 92 | QGSS_Sprint_Full, |
| | 93 | QGSS_Explosion_Stun, |
| | 94 | QGSS_ClimbOut, |
| | 95 | QGSS_end |
| | 96 | }; |
| | 97 | |
| | 98 | extern SECTION * GetNamedHierarchyFromLibrary(const char * rif_name, const char * hier_name); |
| | 99 | extern void AssignNewSBName(STRATEGYBLOCK *sbPtr); |
| | 100 | extern uint8_t Null_Name[8]; |
| | 101 | extern const MATRIXCH IdentityMatrix; |
| | 102 | |
| | 103 | #define QueenAttackRange 3500 |
| | 104 | |
| | 105 | /*minimum time for flamethrower before queen takes notice*/ |
| | 106 | #define QueenMinimumFireTime ONE_FIXED/8 |
| | 107 | |
| | 108 | static int PlayerInTrench = 0; |
| | 109 | static int PlayerInLocker = 0; |
| | 110 | static int AirlockTimeOpen = 0; |
| | 111 | |
| | 112 | /*special hangar airlock state stuff*/ |
| | 113 | static int UpperAirlockDoorOpen = 0; |
| | 114 | static int LowerAirlockDoorOpen = 0; |
| | 115 | static STRATEGYBLOCK* UpperAirlockDoorSbptr = 0; |
| | 116 | static VECTORCH UpperAirlockDoorStart; |
| | 117 | static STRATEGYBLOCK* LowerAirlockDoorSbptr = 0; |
| | 118 | static VECTORCH LowerAirlockDoorStart; |
| | 119 | static STRATEGYBLOCK* LockerDoorSbptr = 0; |
| | 120 | |
| | 121 | #define QUEEN_MAX_OBJECT 10 |
| | 122 | int NumQueenObjects; |
| | 123 | STRATEGYBLOCK* QueenObjectList[QUEEN_MAX_OBJECT]; |
| | 124 | |
| | 125 | QUEEN_MANOEUVRE Queen_Next_Command; |
| | 126 | |
| | 127 | int Queen_Next_Waypoint = 0; |
| | 128 | int Queen_Walk_Rate = 100000; |
| | 129 | int Queen_Walk_Step_Speed = ONE_FIXED/4.5; |
| | 130 | int Queen_ButtCharge_Rate = 30000; |
| | 131 | int Queen_Step_Time = 50000; |
| | 132 | int Queen_Charge_Step_Speed = 7500; |
| | 133 | int Queen_Turn_Rate = (NPC_TURNRATE>>2); |
| | 134 | |
| | 135 | #define QUEEN_BUTTCHARGE_SPEED 16000 |
| | 136 | #define QUEEN_CHARGE_SPEED 12000 |
| | 137 | #define QUEEN_CLOSE_SPEED 3000 |
| | 138 | #define QUEEN_WALK_SPEED 7000 |
| | 139 | #define QUEEN_THROWN_OBJECT_SPEED 60000 |
| | 140 | |
| | 141 | const VECTORCH Queen_Waypoints[] = |
| | 142 | { |
| | 143 | {37361,2900,-51942}, |
| | 144 | {32937,2900,-19959}, |
| | 145 | {62809,2900,-28509}, |
| | 146 | {64658,2900,-13328}, |
| | 147 | {64658,0,-13328}, |
| | 148 | {64991,2900,-50362}, |
| | 149 | {32239,2900,-53578}, |
| | 150 | {-1,-1,-1} |
| | 151 | }; |
| | 152 | |
| | 153 | static void MakeNonFragable_Recursion(SECTION_DATA *this_section_data) |
| | 154 | { |
| | 155 | /* flag this section. */ |
| | 156 | this_section_data->sempai->flags |= section_flag_never_frag; |
| | 157 | |
| | 158 | /* Now call recursion... */ |
| | 159 | |
| | 160 | if (this_section_data->First_Child != NULL) |
| | 161 | { |
| | 162 | SECTION_DATA *child_list_ptr = this_section_data->First_Child; |
| | 163 | |
| | 164 | while (child_list_ptr != NULL) |
| | 165 | { |
| | 166 | MakeNonFragable_Recursion(child_list_ptr); |
| | 167 | child_list_ptr = child_list_ptr->Next_Sibling; |
| | 168 | } |
| | 169 | } |
| | 170 | } |
| | 171 | |
| | 172 | static void MakeNonFragable(HMODELCONTROLLER *controller) |
| | 173 | { |
| | 174 | MakeNonFragable_Recursion(controller->section_data); |
| | 175 | } |
| | 176 | |
| | 177 | static int make_new_queen(STRATEGYBLOCK *sbPtr) |
| | 178 | { |
| | 179 | sbPtr->dataptr = malloc(sizeof(QUEEN_STATUS_BLOCK)); |
| | 180 | sbPtr->maintainVisibility = 1; |
| | 181 | sbPtr->containingModule = ModuleFromPosition(&sbPtr->DynPtr->Position, NULL); |
| | 182 | |
| | 183 | if(NULL == sbPtr->dataptr) |
| | 184 | { |
| | 185 | RemoveBehaviourStrategy(sbPtr); |
| | 186 | return 0; |
| | 187 | } |
| | 188 | |
| | 189 | { |
| | 190 | const NPC_DATA *NpcData = &NpcDataList[I_NPC_AlienQueen]; |
| | 191 | sbPtr->DamageBlock = NpcData->StartingStats; |
| | 192 | sbPtr->DamageBlock.Health = NpcData->StartingStats.Health << ONE_FIXED_SHIFT; |
| | 193 | sbPtr->DamageBlock.Armour = NpcData->StartingStats.Armour << ONE_FIXED_SHIFT; |
| | 194 | } |
| | 195 | |
| | 196 | QUEEN_STATUS_BLOCK *new_queen = (QUEEN_STATUS_BLOCK *)sbPtr->dataptr; |
| | 197 | |
| | 198 | NPC_InitMovementData(&new_queen->moveData); |
| | 199 | NPC_InitWanderData(&new_queen->wanderData); |
| | 200 | |
| | 201 | new_queen->HModelController.Deltas = NULL; |
| | 202 | new_queen->HModelController.Root_Section = NULL; |
| | 203 | new_queen->HModelController.section_data = NULL; |
| | 204 | new_queen->QueenState = QBS_Reconsider; |
| | 205 | new_queen->current_move = QM_Standby; |
| | 206 | new_queen->next_move = QM_Standby; |
| | 207 | new_queen->fixed_foot = RightFoot; |
| | 208 | new_queen->fixed_foot_section = NULL; |
| | 209 | new_queen->fixed_foot_oldpos.vx = new_queen->fixed_foot_oldpos.vy = new_queen->fixed_foot_oldpos.vz = 0; |
| | 210 | new_queen->TargetPos.vx = new_queen->TargetPos.vy = new_queen->TargetPos.vz = 0; |
| | 211 | new_queen->moveTimer = 0; |
| | 212 | |
| | 213 | new_queen->attack_delta = NULL; |
| | 214 | new_queen->hit_delta = NULL; |
| | 215 | new_queen->TargetPos.vx = 0; |
| | 216 | new_queen->TargetPos.vy = 0; |
| | 217 | new_queen->TargetPos.vz = 0; |
| | 218 | |
| | 219 | { |
| | 220 | int i; |
| | 221 | for(i=0; i < SB_NAME_LENGTH; i++) |
| | 222 | new_queen->death_target_ID[i] = 0; |
| | 223 | } |
| | 224 | |
| | 225 | new_queen->death_target_sbptr = NULL; |
| | 226 | new_queen->death_target_request = 0; |
| | 227 | |
| | 228 | new_queen->TempTarget = 0; |
| | 229 | new_queen->TempTargetTimer = 0; |
| | 230 | new_queen->CurrentQueenObject = 0; |
| | 231 | new_queen->QueenStateTimer = 0; |
| | 232 | new_queen->QueenObjectBias = 1; |
| | 233 | new_queen->QueenPlayerBias = 5; |
| | 234 | new_queen->QueenTauntTimer = 0; |
| | 235 | new_queen->QueenFireTimer = 0; |
| | 236 | new_queen->LastVelocity.vx = 0; |
| | 237 | new_queen->LastVelocity.vy = 0; |
| | 238 | new_queen->LastVelocity.vz = 0; |
| | 239 | |
| | 240 | new_queen->QueenRightHand = NULL; |
| | 241 | new_queen->QueenTargetSB = NULL; |
| | 242 | |
| | 243 | new_queen->BeenInAirlock = 0; |
| | 244 | new_queen->QueenActivated = 0; //queen is inactive until seen |
| | 245 | |
| | 246 | new_queen->TargetInfoValid = 0; //have the next three items been set |
| | 247 | new_queen->TargetDistance = 0; //distance of current target from queen |
| | 248 | new_queen->TargetRelSpeed = 0; //targets speed in queen's direction |
| | 249 | new_queen->TargetDirection.vx = 0; |
| | 250 | new_queen->TargetDirection.vy = 0; |
| | 251 | new_queen->TargetDirection.vz = 0; |
| | 252 | new_queen->VectToTarget.vx = 0; |
| | 253 | new_queen->VectToTarget.vy = 0; |
| | 254 | new_queen->VectToTarget.vz = 0; |
| | 255 | |
| | 256 | new_queen->PlayingHitDelta = 0; |
| | 257 | |
| | 258 | new_queen->SwerveTimer = 0; |
| | 259 | new_queen->SwerveDirection = 0; |
| | 260 | |
| | 261 | new_queen->ClimbStartPosition.vx = 0; |
| | 262 | new_queen->ClimbStartPosition.vy = 0; |
| | 263 | new_queen->ClimbStartPosition.vz = 0; |
| | 264 | new_queen->AttackDoneItsDamage = 0; |
| | 265 | |
| | 266 | new_queen->upper_airlockdoor_sbptr = NULL; |
| | 267 | new_queen->upper_airlockdoor_start.vx = 0; |
| | 268 | new_queen->upper_airlockdoor_start.vy = 0; |
| | 269 | new_queen->upper_airlockdoor_start.vz = 0; |
| | 270 | new_queen->lower_airlockdoor_sbptr = NULL; |
| | 271 | new_queen->lower_airlockdoor_start.vx = 0; |
| | 272 | new_queen->lower_airlockdoor_start.vy = 0; |
| | 273 | new_queen->lower_airlockdoor_start.vz = 0; |
| | 274 | |
| | 275 | new_queen->soundHandle = SOUND_NOACTIVEINDEX; |
| | 276 | new_queen->lastSoundCategory = QSC_Hiss; |
| | 277 | |
| | 278 | SECTION *root_section = GetNamedHierarchyFromLibrary("queen", "Template"); |
| | 279 | |
| | 280 | if((NULL == root_section) || !sbPtr->containingModule) |
| | 281 | { |
| | 282 | RemoveBehaviourStrategy(sbPtr); |
| | 283 | printf("Failed to load queen hmodel\n"); |
| | 284 | return 0; |
| | 285 | } |
| | 286 | |
| | 287 | Create_HModel(&new_queen->HModelController, root_section); |
| | 288 | InitHModelSequence(&new_queen->HModelController, (int)HMSQT_QueenRightStanceTemplate, (int)QRSTSS_Standard, ONE_FIXED); |
| | 289 | |
| | 290 | new_queen->HModelController.Looped = 1; |
| | 291 | new_queen->attack_delta = Add_Delta_Sequence(&new_queen->HModelController, "attack", (int)HMSQT_QueenRightStanceTemplate,
(int)QRSTSS_LeftSwipe, Queen_Step_Time); |
| | 292 | new_queen->attack_delta->Playing = 0; |
| | 293 | new_queen->hit_delta = Add_Delta_Sequence(&new_queen->HModelController, "hit", (int)HMSQT_QueenRightStanceTemplate, (int)QRSTSS_LeftHit,
Queen_Step_Time); |
| | 294 | new_queen->attack_delta->Playing = 0; |
| | 295 | |
| | 296 | if(AvP.PlayerType == I_Marine) |
| | 297 | MakeNonFragable(&new_queen->HModelController); |
| | 298 | |
| | 299 | NumQueenObjects = -1; |
| | 300 | |
| | 301 | return 1; |
| | 302 | } |
| | 303 | |
| | 304 | void SetQueenFoot(STRATEGYBLOCK *sbPtr, QUEEN_FOOT foot) |
| | 305 | { |
| | 306 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 307 | DISPLAYBLOCK *dPtr = sbPtr->DisplayBlock; |
| | 308 | assert(dPtr); |
| | 309 | |
| | 310 | ProveHModel(dPtr->HModelControlBlock,dPtr); |
| | 311 | |
| | 312 | switch (foot) |
| | 313 | { |
| | 314 | case LeftFoot: |
| | 315 | queenStatusPointer->fixed_foot = LeftFoot; |
| | 316 | queenStatusPointer->fixed_foot_section = GetThisSectionData(queenStatusPointer->HModelController.section_data, "left foot"); |
| | 317 | assert(queenStatusPointer->fixed_foot_section); |
| | 318 | queenStatusPointer->fixed_foot_oldpos = queenStatusPointer->fixed_foot_section->World_Offset; |
| | 319 | break; |
| | 320 | case RightFoot: |
| | 321 | queenStatusPointer->fixed_foot = RightFoot; |
| | 322 | queenStatusPointer->fixed_foot_section = GetThisSectionData(queenStatusPointer->HModelController.section_data, "right foot"); |
| | 323 | assert(queenStatusPointer->fixed_foot_section); |
| | 324 | queenStatusPointer->fixed_foot_oldpos = queenStatusPointer->fixed_foot_section->World_Offset; |
| | 325 | break; |
| | 326 | default: |
| | 327 | assert(0); |
| | 328 | break; |
| | 329 | } |
| | 330 | } |
| | 331 | |
| | 332 | void MakeQueenNear(STRATEGYBLOCK *sbPtr) |
| | 333 | { |
| | 334 | DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr; |
| | 335 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 336 | |
| | 337 | assert(queenStatusPointer); |
| | 338 | assert(dynPtr); |
| | 339 | |
| | 340 | DISPLAYBLOCK *dPtr = CreateActiveObject(); |
| | 341 | |
| | 342 | if(dPtr == NULL) |
| | 343 | return; |
| | 344 | |
| | 345 | sbPtr->DisplayBlock = dPtr; |
| | 346 | dPtr->ObStrategyBlock = sbPtr; |
| | 347 | |
| | 348 | /* also need to initialise positional information in the new display block, |
| | 349 | from the existing dynamics block. |
| | 350 | NB this necessary because this function is (usually) called between the |
| | 351 | dynamics and rendering systems so it is not initialised by the dynamics |
| | 352 | system the first frame it is drawn. */ |
| | 353 | dPtr->ObWorld = dynPtr->Position; |
| | 354 | dPtr->ObEuler = dynPtr->OrientEuler; |
| | 355 | dPtr->ObMat = dynPtr->OrientMat; |
| | 356 | |
| | 357 | /* init state timers */ |
| | 358 | |
| | 359 | /* initialise our sequence data */ |
| | 360 | dPtr->HModelControlBlock = &queenStatusPointer->HModelController; |
| | 361 | |
| | 362 | SetQueenFoot(sbPtr, RightFoot); |
| | 363 | |
| | 364 | /* Calls ProveHModel. */ |
| | 365 | } |
| | 366 | |
| | 367 | void CreateQueenBot(VECTORCH *Position) |
| | 368 | { |
| | 369 | STRATEGYBLOCK* sbPtr = CreateActiveStrategyBlock(I_BehaviourQueenAlien); |
| | 370 | |
| | 371 | if(!sbPtr) |
| | 372 | { |
| | 373 | GADGET_NewOnScreenMessage("FAILED TO CREATE BOT: SB CREATION FAILURE"); |
| | 374 | return; |
| | 375 | } |
| | 376 | |
| | 377 | AssignNewSBName(sbPtr); |
| | 378 | |
| | 379 | sbPtr->DynPtr = AllocateDynamicsBlock(DYNAMICS_TEMPLATE_DEFAULT); |
| | 380 | |
| | 381 | if(sbPtr->DynPtr) |
| | 382 | { |
| | 383 | DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr; |
| | 384 | |
| | 385 | dynPtr->PrevPosition = dynPtr->Position = *Position; |
| | 386 | CreateEulerMatrix(&dynPtr->OrientEuler, &dynPtr->OrientMat); |
| | 387 | TransposeMatrixCH(&dynPtr->OrientMat); |
| | 388 | /* zero linear velocity in dynamics block */ |
| | 389 | dynPtr->Displacement.vx = dynPtr->Displacement.vy = dynPtr->Displacement.vz = 0; |
| | 390 | dynPtr->UseDisplacement = 1; |
| | 391 | dynPtr->Mass = 60000; /* No knockback, please. */ |
| | 392 | make_new_queen(sbPtr); |
| | 393 | } |
| | 394 | else |
| | 395 | { |
| | 396 | /* dynamics block allocation failed... */ |
| | 397 | RemoveBehaviourStrategy(sbPtr); |
| | 398 | GADGET_NewOnScreenMessage("FAILED TO CREATE BOT: DYNBLOCK CREATION FAILURE"); |
| | 399 | } |
| | 400 | } |
| | 401 | |
| | 402 | void CastQueenBot() |
| | 403 | { |
| | 404 | #define BOTRANGE 4000 |
| | 405 | |
| | 406 | VECTORCH position; |
| | 407 | position = PlayerStatus.sbptr->DynPtr->Position; |
| | 408 | position.vx += MUL_FIXED(PlayerStatus.sbptr->DynPtr->OrientMat.mat31, BOTRANGE); |
| | 409 | position.vy += MUL_FIXED(PlayerStatus.sbptr->DynPtr->OrientMat.mat32, BOTRANGE); |
| | 410 | position.vz += MUL_FIXED(PlayerStatus.sbptr->DynPtr->OrientMat.mat33, BOTRANGE); |
| | 411 | |
| | 412 | CreateQueenBot(&position); |
| | 413 | } |
| | 414 | |
| | 415 | static void QueenSoundHiss(STRATEGYBLOCK* sbPtr) |
| | 416 | { |
| | 417 | assert(sbPtr); |
| | 418 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 419 | |
| | 420 | if(queenStatusPointer->soundHandle == SOUND_NOACTIVEINDEX) |
| | 421 | { |
| | 422 | PlayQueenSound(0,QSC_Hiss,0,&queenStatusPointer->soundHandle,&sbPtr->DynPtr->Position); |
| | 423 | queenStatusPointer->lastSoundCategory = QSC_Hiss; |
| | 424 | } |
| | 425 | } |
| | 426 | |
| | 427 | static void QueenSoundHurt(STRATEGYBLOCK* sbPtr) |
| | 428 | { |
| | 429 | assert(sbPtr); |
| | 430 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 431 | |
| | 432 | /* If the queen is currently playing a non-hurt sound then cancel it. */ |
| | 433 | |
| | 434 | if(queenStatusPointer->soundHandle != SOUND_NOACTIVEINDEX) |
| | 435 | { |
| | 436 | if(queenStatusPointer->lastSoundCategory != QSC_Scream_Hurt) |
| | 437 | Sound_Stop(queenStatusPointer->soundHandle); |
| | 438 | } |
| | 439 | |
| | 440 | if(queenStatusPointer->soundHandle == SOUND_NOACTIVEINDEX) |
| | 441 | { |
| | 442 | PlayQueenSound(0,QSC_Scream_Hurt,0,&queenStatusPointer->soundHandle,&sbPtr->DynPtr->Position); |
| | 443 | queenStatusPointer->lastSoundCategory = QSC_Scream_Hurt; |
| | 444 | } |
| | 445 | } |
| | 446 | |
| | 447 | static void ThrownObjectBounceNoise(int object_index, VECTORCH* location) |
| | 448 | { |
| | 449 | static int QueenObjectSoundHandles[QUEEN_MAX_OBJECT] = |
| | 450 | {SOUND_NOACTIVEINDEX,SOUND_NOACTIVEINDEX,SOUND_NOACTIVEINDEX,SOUND_NOACTIVEINDEX,SOUND_NOACTIVEINDEX,SOUND_NOACTIVEINDEX,SOUND_NOACTIVEINDEX,SOUND_NOACTIVEINDEX
,SOUND_NOACTIVEINDEX,SOUND_NOACTIVEINDEX}; |
| | 451 | assert(location); |
| | 452 | |
| | 453 | PlayQueenSound(0,QSC_Object_Bounce,0,&QueenObjectSoundHandles[object_index],location); |
| | 454 | } |
| | 455 | |
| | 456 | void InitQueenBehaviour(void* bhdata, STRATEGYBLOCK *sbPtr) |
| | 457 | { |
| | 458 | assert(bhdata); |
| | 459 | TOOLS_DATA_QUEEN *toolsData = (TOOLS_DATA_QUEEN *)bhdata; |
| | 460 | |
| | 461 | /* Reset command interface. */ |
| | 462 | |
| | 463 | Queen_Next_Command = QM_Standby; |
| | 464 | |
| | 465 | { |
| | 466 | int i; |
| | 467 | for(i=0; i < SB_NAME_LENGTH; i++) |
| | 468 | sbPtr->SBname[i] = toolsData->nameID[i]; |
| | 469 | } |
| | 470 | |
| | 471 | /* create, initialise and attach a dynamics block */ |
| | 472 | sbPtr->DynPtr = AllocateDynamicsBlock(DYNAMICS_TEMPLATE_DEFAULT); |
| | 473 | |
| | 474 | if(sbPtr->DynPtr) |
| | 475 | { |
| | 476 | DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr; |
| | 477 | dynPtr->PrevPosition = dynPtr->Position = toolsData->position; |
| | 478 | CreateEulerMatrix(&dynPtr->OrientEuler, &dynPtr->OrientMat); |
| | 479 | TransposeMatrixCH(&dynPtr->OrientMat); |
| | 480 | dynPtr->UseDisplacement = 1; |
| | 481 | dynPtr->Mass = 60000; /* No knockback, please. */ |
| | 482 | |
| | 483 | if(make_new_queen(sbPtr)) |
| | 484 | { |
| | 485 | QUEEN_STATUS_BLOCK *queenStatus = (QUEEN_STATUS_BLOCK *)sbPtr->dataptr; |
| | 486 | |
| | 487 | int i = 0; |
| | 488 | for(; i < SB_NAME_LENGTH; i++) |
| | 489 | queenStatus->death_target_ID[i] = toolsData->death_target_ID[i]; |
| | 490 | |
| | 491 | queenStatus->death_target_request = toolsData->death_target_request; |
| | 492 | |
| | 493 | //int he predator version , make it more likely for the queen to go after the player |
| | 494 | queenStatus->QueenPlayerBias = (AVP_ENVIRONMENT_TYRARGOHANGAR == AvP.level) ? 1 : 5; |
| | 495 | queenStatus->QueenTargetSB = PlayerStatus.sbptr; |
| | 496 | |
| | 497 | NumQueenObjects = -1; |
| | 498 | } |
| | 499 | } |
| | 500 | else |
| | 501 | { |
| | 502 | RemoveBehaviourStrategy(sbPtr); |
| | 503 | } |
| | 504 | } |
| | 505 | |
| | 506 | static int QueenPlayingStunAnimation(HMODELCONTROLLER* HModelController) |
| | 507 | { |
| | 508 | assert(HModelController); |
| | 509 | |
| | 510 | return(HModelController->Sequence_Type == HMSQT_QueenGeneral && HModelController->Sub_Sequence == QGSS_Explosion_Stun &&
!HModelAnimation_IsFinished(HModelController)); |
| | 511 | } |
| | 512 | |
| | 513 | void MakeQueenFar(STRATEGYBLOCK *sbPtr) |
| | 514 | { |
| | 515 | DestroyActiveObject(&sbPtr->DisplayBlock); |
| | 516 | |
| | 517 | /* zero linear velocity in dynamics block */ |
| | 518 | sbPtr->DynPtr->LinVelocity.vx = sbPtr->DynPtr->LinVelocity.vy = sbPtr->DynPtr->LinVelocity.vz = 0; |
| | 519 | } |
| | 520 | |
| | 521 | void SetQueenMovement_FromFoot(STRATEGYBLOCK *sbPtr) |
| | 522 | { |
| | 523 | VECTORCH delta_offset; |
| | 524 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 525 | DISPLAYBLOCK *dPtr = sbPtr->DisplayBlock; |
| | 526 | assert(dPtr); |
| | 527 | |
| | 528 | //VECTORCH real_pos = queenStatusPointer->fixed_foot_section->World_Offset; |
| | 529 | |
| | 530 | ProveHModel(dPtr->HModelControlBlock,dPtr); |
| | 531 | |
| | 532 | delta_offset.vx = queenStatusPointer->fixed_foot_oldpos.vx-queenStatusPointer->fixed_foot_section->World_Offset.vx; |
| | 533 | delta_offset.vy = 0;//queenStatusPointer->fixed_foot_oldpos.vy-queenStatusPointer->fixed_foot_section->World_Offset.vy; |
| | 534 | delta_offset.vz = queenStatusPointer->fixed_foot_oldpos.vz-queenStatusPointer->fixed_foot_section->World_Offset.vz; |
| | 535 | |
| | 536 | delta_offset.vx = DIV_FIXED(delta_offset.vx,NormalFrameTime); |
| | 537 | delta_offset.vy = 0;//DIV_FIXED(delta_offset.vy,NormalFrameTime); |
| | 538 | delta_offset.vz = DIV_FIXED(delta_offset.vz,NormalFrameTime); |
| | 539 | |
| | 540 | sbPtr->DynPtr->LinVelocity.vx = delta_offset.vx; |
| | 541 | sbPtr->DynPtr->LinVelocity.vy = delta_offset.vy; |
| | 542 | sbPtr->DynPtr->LinVelocity.vz = delta_offset.vz; |
| | 543 | |
| | 544 | { |
| | 545 | int facex = sbPtr->DynPtr->OrientMat.mat31; |
| | 546 | int facez = sbPtr->DynPtr->OrientMat.mat33; |
| | 547 | |
| | 548 | if(MUL_FIXED(facex,sbPtr->DynPtr->LinVelocity.vx)+MUL_FIXED(facez,sbPtr->DynPtr->LinVelocity.vz) < 0) |
| | 549 | { |
| | 550 | //don't want queen to move backwards |
| | 551 | sbPtr->DynPtr->LinVelocity.vx = sbPtr->DynPtr->LinVelocity.vy = sbPtr->DynPtr->LinVelocity.vz = 0; |
| | 552 | |
| | 553 | switch (queenStatusPointer->fixed_foot) |
| | 554 | { |
| | 555 | case LeftFoot: |
| | 556 | SetQueenFoot(sbPtr,LeftFoot); |
| | 557 | break; |
| | 558 | case RightFoot: |
| | 559 | SetQueenFoot(sbPtr,RightFoot); |
| | 560 | break; |
| | 561 | default: |
| | 562 | assert(0); |
| | 563 | break; |
| | 564 | } |
| | 565 | } |
| | 566 | } |
| | 567 | } |
| | 568 | |
| | 569 | void SetQueenShapeAnimSequence_Core(STRATEGYBLOCK *sbPtr,HMODEL_SEQUENCE_TYPES type, int subtype, int length, int tweeningtime) |
| | 570 | { |
| | 571 | QUEEN_STATUS_BLOCK *queenStatus = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 572 | |
| | 573 | assert(length!=0); |
| | 574 | |
| | 575 | if (tweeningtime <= 0) |
| | 576 | InitHModelSequence(&queenStatus->HModelController,(int)type,subtype,length); |
| | 577 | else |
| | 578 | InitHModelTweening(&queenStatus->HModelController, tweeningtime, (int)type,subtype,length, 0); |
| | 579 | |
| | 580 | queenStatus->HModelController.Looped = 0; |
| | 581 | } |
| | 582 | |
| | 583 | void QueenMove_Standby(STRATEGYBLOCK *sbPtr) |
| | 584 | { |
| | 585 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 586 | |
| | 587 | /* Verify correct sequence. */ |
| | 588 | |
| | 589 | sbPtr->DynPtr->LinVelocity.vx = sbPtr->DynPtr->LinVelocity.vy = sbPtr->DynPtr->LinVelocity.vz = 0; |
| | 590 | |
| | 591 | if(queenStatusPointer->PlayingHitDelta) |
| | 592 | { |
| | 593 | if(QueenPlayingStunAnimation(&queenStatusPointer->HModelController)) |
| | 594 | return; //queen is in the process of playing stun animation |
| | 595 | } |
| | 596 | |
| | 597 | if(!queenStatusPointer->moveTimer) |
| | 598 | { |
| | 599 | //start tweening to standing position |
| | 600 | switch(queenStatusPointer->fixed_foot) |
| | 601 | { |
| | 602 | case LeftFoot: |
| | 603 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenLeftStanceTemplate, (int)QLSTSS_Standard,-1,ONE_FIXED>>2); |
| | 604 | break; |
| | 605 | case RightFoot: |
| | 606 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenRightStanceTemplate, (int)QRSTSS_Standard,-1,ONE_FIXED>>2); |
| | 607 | break; |
| | 608 | default: |
| | 609 | assert(0); |
| | 610 | break; |
| | 611 | } |
| | 612 | |
| | 613 | queenStatusPointer->moveTimer = 1; |
| | 614 | } |
| | 615 | } |
| | 616 | |
| | 617 | void QueenMove_StepForward(STRATEGYBLOCK *sbPtr) |
| | 618 | { |
| | 619 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 620 | |
| | 621 | /* First movement function. */ |
| | 622 | |
| | 623 | assert(queenStatusPointer->current_move == QM_StepForward); |
| | 624 | |
| | 625 | if (!queenStatusPointer->moveTimer) |
| | 626 | { |
| | 627 | /* Do setup. */ |
| | 628 | int tweeiningtime = (ONE_FIXED>>3); |
| | 629 | |
| | 630 | switch (queenStatusPointer->fixed_foot) |
| | 631 | { |
| | 632 | case LeftFoot: |
| | 633 | SetQueenFoot(sbPtr,LeftFoot); |
| | 634 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenLeftStanceTemplate, (int)QLSTSS_Forward_L2R,Queen_Step_Time,tweeiningtime); |
| | 635 | break; |
| | 636 | case RightFoot: |
| | 637 | SetQueenFoot(sbPtr,RightFoot); |
| | 638 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenRightStanceTemplate, (int)QRSTSS_Forward_R2L,Queen_Step_Time,tweeiningtime); |
| | 639 | break; |
| | 640 | default: |
| | 641 | assert(0); |
| | 642 | break; |
| | 643 | } |
| | 644 | } |
| | 645 | |
| | 646 | #if DEBUG |
| | 647 | if (queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 648 | { |
| | 649 | assert(!queenStatusPointer->HModelController.Looped); |
| | 650 | } |
| | 651 | #endif |
| | 652 | |
| | 653 | /* Now... move forward? */ |
| | 654 | |
| | 655 | SetQueenMovement_FromFoot(sbPtr); |
| | 656 | |
| | 657 | if ((queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 658 | &&(queenStatusPointer->HModelController.sequence_timer==(ONE_FIXED-1))) |
| | 659 | { |
| | 660 | queenStatusPointer->current_move = QM_Standby; |
| | 661 | |
| | 662 | switch (queenStatusPointer->fixed_foot) |
| | 663 | { |
| | 664 | case LeftFoot: |
| | 665 | SetQueenFoot(sbPtr,RightFoot); |
| | 666 | break; |
| | 667 | case RightFoot: |
| | 668 | SetQueenFoot(sbPtr,LeftFoot); |
| | 669 | break; |
| | 670 | default: |
| | 671 | assert(0); |
| | 672 | break; |
| | 673 | } |
| | 674 | } |
| | 675 | |
| | 676 | queenStatusPointer->moveTimer += NormalFrameTime; |
| | 677 | } |
| | 678 | |
| | 679 | void QueenMove_StepBack(STRATEGYBLOCK *sbPtr) |
| | 680 | { |
| | 681 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 682 | |
| | 683 | /* First movement function. */ |
| | 684 | |
| | 685 | assert(queenStatusPointer->current_move == QM_StepBack); |
| | 686 | |
| | 687 | if (!queenStatusPointer->moveTimer) |
| | 688 | { |
| | 689 | /* Do setup. */ |
| | 690 | int tweeiningtime = (ONE_FIXED>>3); |
| | 691 | |
| | 692 | switch (queenStatusPointer->fixed_foot) |
| | 693 | { |
| | 694 | case LeftFoot: |
| | 695 | SetQueenFoot(sbPtr,RightFoot); |
| | 696 | /* Wrong Foot w.r.t. Forward. */ |
| | 697 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenLeftStanceFull, (int)QLSFSS_Backward_L2R,Queen_Step_Time,tweeiningtime); |
| | 698 | break; |
| | 699 | case RightFoot: |
| | 700 | SetQueenFoot(sbPtr,LeftFoot); |
| | 701 | /* Wrong Foot w.r.t. Forward. */ |
| | 702 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenRightStanceFull, (int)QRSFSS_Backward_R2L,Queen_Step_Time,tweeiningtime); |
| | 703 | break; |
| | 704 | default: |
| | 705 | assert(0); |
| | 706 | break; |
| | 707 | } |
| | 708 | } |
| | 709 | |
| | 710 | #if DEBUG |
| | 711 | if (queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 712 | { |
| | 713 | assert(queenStatusPointer->HModelController.Looped == 0); |
| | 714 | } |
| | 715 | #endif |
| | 716 | |
| | 717 | /* Now... move forward? */ |
| | 718 | |
| | 719 | SetQueenMovement_FromFoot(sbPtr); |
| | 720 | |
| | 721 | queenStatusPointer->moveTimer += NormalFrameTime; |
| | 722 | |
| | 723 | if ((queenStatusPointer->HModelController.Tweening == Controller_NoTweening) && (queenStatusPointer->HModelController.sequence_timer ==
(ONE_FIXED-1))) |
| | 724 | { |
| | 725 | queenStatusPointer->current_move = QM_Standby; |
| | 726 | /* Already changed foot. */ |
| | 727 | } |
| | 728 | } |
| | 729 | |
| | 730 | void QueenMove_ComeToPoint(STRATEGYBLOCK *sbPtr) |
| | 731 | { |
| | 732 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 733 | VECTORCH vectotarget; |
| | 734 | |
| | 735 | /* Complex movement function. */ |
| | 736 | |
| | 737 | assert(queenStatusPointer->current_move == QM_ComeToPoint); |
| | 738 | |
| | 739 | if (!queenStatusPointer->moveTimer) |
| | 740 | { |
| | 741 | /* Do setup. */ |
| | 742 | int tweeiningtime = 0; |
| | 743 | |
| | 744 | switch (queenStatusPointer->fixed_foot) |
| | 745 | { |
| | 746 | case LeftFoot: |
| | 747 | SetQueenFoot(sbPtr,LeftFoot); |
| | 748 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenLeftStanceFull, (int)QLSFSS_Forward_L2R,Queen_Step_Time,tweeiningtime); |
| | 749 | break; |
| | 750 | case RightFoot: |
| | 751 | SetQueenFoot(sbPtr,RightFoot); |
| | 752 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenRightStanceFull, (int)QRSFSS_Forward_R2L,Queen_Step_Time,tweeiningtime); |
| | 753 | break; |
| | 754 | default: |
| | 755 | assert(0); |
| | 756 | break; |
| | 757 | } |
| | 758 | } |
| | 759 | |
| | 760 | #if DEBUG |
| | 761 | if (queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 762 | { |
| | 763 | assert(!queenStatusPointer->HModelController.Looped); |
| | 764 | } |
| | 765 | #endif |
| | 766 | |
| | 767 | vectotarget.vx = queenStatusPointer->TargetPos.vx-sbPtr->DynPtr->Position.vx; |
| | 768 | vectotarget.vy = queenStatusPointer->TargetPos.vy-sbPtr->DynPtr->Position.vy; |
| | 769 | vectotarget.vz = queenStatusPointer->TargetPos.vz-sbPtr->DynPtr->Position.vz; |
| | 770 | |
| | 771 | /* Now... turn to face. */ |
| | 772 | |
| | 773 | { |
| | 774 | DISPLAYBLOCK *dPtr = sbPtr->DisplayBlock; |
| | 775 | assert(dPtr); |
| | 776 | |
| | 777 | ProveHModel(dPtr->HModelControlBlock,dPtr); |
| | 778 | |
| | 779 | NPCOrientateToVector(sbPtr, &vectotarget, Queen_Turn_Rate); |
| | 780 | |
| | 781 | SetQueenMovement_FromFoot(sbPtr); |
| | 782 | } |
| | 783 | |
| | 784 | queenStatusPointer->moveTimer += NormalFrameTime; |
| | 785 | |
| | 786 | if ((queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 787 | &&(queenStatusPointer->HModelController.sequence_timer == (ONE_FIXED-1))) |
| | 788 | { |
| | 789 | /* Comsider next step. */ |
| | 790 | |
| | 791 | int range = Approximate3dMagnitude(&vectotarget); |
| | 792 | |
| | 793 | if (range < 5000) |
| | 794 | queenStatusPointer->current_move = QM_Standby; |
| | 795 | else |
| | 796 | queenStatusPointer->moveTimer = 0; |
| | 797 | |
| | 798 | switch (queenStatusPointer->fixed_foot) |
| | 799 | { |
| | 800 | case LeftFoot: |
| | 801 | SetQueenFoot(sbPtr,RightFoot); |
| | 802 | break; |
| | 803 | case RightFoot: |
| | 804 | SetQueenFoot(sbPtr,LeftFoot); |
| | 805 | break; |
| | 806 | default: |
| | 807 | assert(0); |
| | 808 | break; |
| | 809 | } |
| | 810 | } |
| | 811 | } |
| | 812 | |
| | 813 | static void QueenCalculateTargetInfo(STRATEGYBLOCK *sbPtr) |
| | 814 | { |
| | 815 | assert(sbPtr); |
| | 816 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 817 | assert(queenStatusPointer); |
| | 818 | |
| | 819 | if(queenStatusPointer->TargetInfoValid) |
| | 820 | return; |
| | 821 | |
| | 822 | //get vector from queen to target |
| | 823 | |
| | 824 | queenStatusPointer->VectToTarget.vx = queenStatusPointer->TargetPos.vx - sbPtr->DynPtr->Position.vx; |
| | 825 | //queenStatusPointer->VectToTarget.vy = queenStatusPointer->TargetPos.vy - sbPtr->DynPtr->Position.vy; |
| | 826 | queenStatusPointer->VectToTarget.vy = 0; |
| | 827 | queenStatusPointer->VectToTarget.vz = queenStatusPointer->TargetPos.vz - sbPtr->DynPtr->Position.vz; |
| | 828 | |
| | 829 | //get length of vector, and then normalise it |
| | 830 | queenStatusPointer->TargetDistance = Approximate3dMagnitude(&queenStatusPointer->VectToTarget); |
| | 831 | Normalise(&queenStatusPointer->VectToTarget); |
| | 832 | |
| | 833 | //rotate vector to queen's local space to get relative direction |
| | 834 | queenStatusPointer->TargetDirection = queenStatusPointer->VectToTarget; |
| | 835 | MATRIXCH WtoL = sbPtr->DynPtr->OrientMat; |
| | 836 | TransposeMatrixCH(&WtoL); |
| | 837 | RotateVector(&queenStatusPointer->TargetDirection,&WtoL); |
| | 838 | |
| | 839 | queenStatusPointer->TargetRelSpeed = 0; |
| | 840 | |
| | 841 | if(!queenStatusPointer->TempTarget && queenStatusPointer->QueenTargetSB) |
| | 842 | { |
| | 843 | if(queenStatusPointer->QueenTargetSB->DynPtr) |
| | 844 | { |
| | 845 | VECTORCH facing; |
| | 846 | facing.vx = sbPtr->DynPtr->OrientMat.mat31; |
| | 847 | facing.vy = sbPtr->DynPtr->OrientMat.mat32; |
| | 848 | facing.vz = sbPtr->DynPtr->OrientMat.mat33; |
| | 849 | |
| | 850 | queenStatusPointer->TargetRelSpeed = DotProduct(&facing,&queenStatusPointer->QueenTargetSB->DynPtr->LinVelocity); |
| | 851 | } |
| | 852 | } |
| | 853 | |
| | 854 | queenStatusPointer->TargetInfoValid = 1; |
| | 855 | } |
| | 856 | |
| | 857 | void QueenMove_Walk(STRATEGYBLOCK *sbPtr) |
| | 858 | { |
| | 859 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 860 | int ChangingFoot = 0; |
| | 861 | |
| | 862 | /* Very complex movement function... */ |
| | 863 | |
| | 864 | assert(queenStatusPointer->current_move == QM_ComeToPoint); |
| | 865 | |
| | 866 | if (!queenStatusPointer->moveTimer) |
| | 867 | { |
| | 868 | /* Do setup. */ |
| | 869 | int tweeiningtime = (Queen_Step_Time >> 2); |
| | 870 | |
| | 871 | switch (queenStatusPointer->fixed_foot) |
| | 872 | { |
| | 873 | case LeftFoot: |
| | 874 | SetQueenFoot(sbPtr,LeftFoot); |
| | 875 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenGeneral, (int)QGSS_Walk,-1,tweeiningtime); |
| | 876 | queenStatusPointer->HModelController.LoopAfterTweening = 1; |
| | 877 | queenStatusPointer->moveTimer = 1; /* It's something of a state flag here. */ |
| | 878 | break; |
| | 879 | case RightFoot: |
| | 880 | /* Argh! Can't start from right foot! */ |
| | 881 | queenStatusPointer->current_move = QM_Close; |
| | 882 | queenStatusPointer->moveTimer = 0; |
| | 883 | queenStatusPointer->next_move = QM_ComeToPoint; |
| | 884 | return; |
| | 885 | break; |
| | 886 | default: |
| | 887 | assert(0); |
| | 888 | break; |
| | 889 | } |
| | 890 | } |
| | 891 | |
| | 892 | /* Check for change foot? */ |
| | 893 | |
| | 894 | if (queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 895 | { |
| | 896 | if (queenStatusPointer->HModelController.keyframe_flags) |
| | 897 | { |
| | 898 | if (queenStatusPointer->HModelController.keyframe_flags & 1) |
| | 899 | { |
| | 900 | SetQueenFoot(sbPtr,LeftFoot); |
| | 901 | ChangingFoot = 1; |
| | 902 | } |
| | 903 | |
| | 904 | if (queenStatusPointer->HModelController.keyframe_flags & 2) |
| | 905 | { |
| | 906 | SetQueenFoot(sbPtr,RightFoot); |
| | 907 | ChangingFoot = 1; |
| | 908 | } |
| | 909 | |
| | 910 | if(queenStatusPointer->moveTimer == 1) |
| | 911 | queenStatusPointer->moveTimer = 3; |
| | 912 | } |
| | 913 | |
| | 914 | HModel_SetToolsRelativeSpeed(&queenStatusPointer->HModelController,(512*ONE_FIXED)/QUEEN_WALK_SPEED); |
| | 915 | } |
| | 916 | |
| | 917 | /* Now... turn to face. */ |
| | 918 | |
| | 919 | { |
| | 920 | //DISPLAYBLOCK *dPtr = sbPtr->DisplayBlock; |
| | 921 | //assert(dPtr); |
| | 922 | |
| | 923 | //ProveHModel(dPtr->HModelControlBlock,dPtr); |
| | 924 | |
| | 925 | NPCOrientateToVector(sbPtr, &queenStatusPointer->VectToTarget, Queen_Turn_Rate); |
| | 926 | |
| | 927 | //SetQueenMovement_FromFoot(sbPtr); |
| | 928 | |
| | 929 | if (queenStatusPointer->moveTimer != 2) |
| | 930 | { |
| | 931 | if(queenStatusPointer->moveTimer == 1) |
| | 932 | { |
| | 933 | SetQueenMovement_FromFoot(sbPtr); |
| | 934 | } |
| | 935 | else |
| | 936 | { |
| | 937 | VECTORCH velocity; |
| | 938 | //int walkSpeed; |
| | 939 | |
| | 940 | velocity.vx = sbPtr->DynPtr->OrientMat.mat31; |
| | 941 | velocity.vy = 0; |
| | 942 | velocity.vz = sbPtr->DynPtr->OrientMat.mat33; |
| | 943 | |
| | 944 | if ( !velocity.vx && !velocity.vy && !velocity.vz) |
| | 945 | { |
| | 946 | sbPtr->DynPtr->LinVelocity.vx = sbPtr->DynPtr->LinVelocity.vy = sbPtr->DynPtr->LinVelocity.vz = 0; |
| | 947 | return; |
| | 948 | } |
| | 949 | |
| | 950 | Normalise(&velocity); |
| | 951 | |
| | 952 | //walkSpeed=DIV_FIXED(Queen_Walk_Step_Speed,Queen_Walk_Rate); |
| | 953 | |
| | 954 | sbPtr->DynPtr->LinVelocity.vx = MUL_FIXED(velocity.vx,QUEEN_WALK_SPEED); |
| | 955 | sbPtr->DynPtr->LinVelocity.vy = MUL_FIXED(velocity.vy,QUEEN_WALK_SPEED); |
| | 956 | sbPtr->DynPtr->LinVelocity.vz = MUL_FIXED(velocity.vz,QUEEN_WALK_SPEED); |
| | 957 | } |
| | 958 | } |
| | 959 | } |
| | 960 | |
| | 961 | /* Consider exit state. */ |
| | 962 | |
| | 963 | if ((queenStatusPointer->HModelController.Tweening == Controller_NoTweening) && (queenStatusPointer->moveTimer == 2)) |
| | 964 | { |
| | 965 | /* Finished coming to a stop. */ |
| | 966 | |
| | 967 | queenStatusPointer->current_move = QM_Standby; |
| | 968 | queenStatusPointer->next_move = QM_Standby; |
| | 969 | queenStatusPointer->moveTimer = 0; |
| | 970 | |
| | 971 | switch (queenStatusPointer->fixed_foot) |
| | 972 | { |
| | 973 | case RightFoot: |
| | 974 | SetQueenFoot(sbPtr,RightFoot); |
| | 975 | break; |
| | 976 | case LeftFoot: |
| | 977 | SetQueenFoot(sbPtr,LeftFoot); |
| | 978 | break; |
| | 979 | default: |
| | 980 | assert(0); |
| | 981 | break; |
| | 982 | } |
| | 983 | |
| | 984 | /* Would you believe the end's in the middle? :-) */ |
| | 985 | } |
| | 986 | |
| | 987 | //only check for exiting charge , when changing foot |
| | 988 | { |
| | 989 | QueenCalculateTargetInfo(sbPtr); |
| | 990 | int range = queenStatusPointer->TargetDistance; |
| | 991 | |
| | 992 | if(range < 3000) |
| | 993 | queenStatusPointer->next_move = QM_Close; |
| | 994 | |
| | 995 | if(ChangingFoot) |
| | 996 | { |
| | 997 | if(queenStatusPointer->PlayingHitDelta) |
| | 998 | { |
| | 999 | queenStatusPointer->HModelController.Playing = 0; |
| | 1000 | queenStatusPointer->current_move = QM_Standby; |
| | 1001 | queenStatusPointer->moveTimer = 0; |
| | 1002 | queenStatusPointer->next_move = QM_Standby; |
| | 1003 | return; |
| | 1004 | } |
| | 1005 | |
| | 1006 | if(queenStatusPointer->moveTimer != 2) |
| | 1007 | { |
| | 1008 | if (queenStatusPointer->next_move != QM_Standby && queenStatusPointer->next_move != QM_ComeToPoint) |
| | 1009 | { |
| | 1010 | //exit without tweening to stopped position |
| | 1011 | queenStatusPointer->HModelController.Playing = 0; |
| | 1012 | queenStatusPointer->current_move = queenStatusPointer->next_move; |
| | 1013 | queenStatusPointer->next_move = QM_Standby; |
| | 1014 | queenStatusPointer->moveTimer = 0; |
| | 1015 | } |
| | 1016 | else if(range > 10000 && queenStatusPointer->fixed_foot == LeftFoot && !PlayerInTrench) |
| | 1017 | { |
| | 1018 | //go into a charge |
| | 1019 | queenStatusPointer->current_move = QM_Charge; |
| | 1020 | queenStatusPointer->next_move = QM_Standby; |
| | 1021 | queenStatusPointer->moveTimer = 0; |
| | 1022 | } |
| | 1023 | |
| | 1024 | if(range < 5000) |
| | 1025 | { |
| | 1026 | /*if the queen is near but facing the wrong way need to go into close mode |
| | 1027 | (turning circle is too large in walk mode) */ |
| | 1028 | |
| | 1029 | if (queenStatusPointer->TargetDirection.vz < queenStatusPointer->TargetDirection.vx || |
| | 1030 | queenStatusPointer->TargetDirection.vz < -queenStatusPointer->TargetDirection.vx) |
| | 1031 | { |
| | 1032 | //need to switch to close mode |
| | 1033 | queenStatusPointer->HModelController.Playing = 0; |
| | 1034 | queenStatusPointer->current_move = QM_Close; |
| | 1035 | queenStatusPointer->moveTimer = 0; |
| | 1036 | queenStatusPointer->next_move = QM_Standby; |
| | 1037 | } |
| | 1038 | } |
| | 1039 | } |
| | 1040 | } |
| | 1041 | } |
| | 1042 | } |
| | 1043 | |
| | 1044 | void QueenMove_Taunt(STRATEGYBLOCK *sbPtr) |
| | 1045 | { |
| | 1046 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 1047 | |
| | 1048 | /* First movement function. */ |
| | 1049 | |
| | 1050 | assert(queenStatusPointer->current_move==QM_Taunt); |
| | 1051 | |
| | 1052 | if (!queenStatusPointer->moveTimer) |
| | 1053 | { |
| | 1054 | /* Do setup. */ |
| | 1055 | int tweeiningtime = (ONE_FIXED >> 3); |
| | 1056 | |
| | 1057 | switch (queenStatusPointer->fixed_foot) |
| | 1058 | { |
| | 1059 | case LeftFoot: |
| | 1060 | SetQueenFoot(sbPtr,LeftFoot); |
| | 1061 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenLeftStanceFull, (int)QLSFSS_Taunt,-1,tweeiningtime); |
| | 1062 | break; |
| | 1063 | case RightFoot: |
| | 1064 | SetQueenFoot(sbPtr,RightFoot); |
| | 1065 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenRightStanceFull, (int)QRSFSS_Taunt,-1,tweeiningtime); |
| | 1066 | break; |
| | 1067 | default: |
| | 1068 | assert(0); |
| | 1069 | break; |
| | 1070 | } |
| | 1071 | } |
| | 1072 | |
| | 1073 | #if DEBUG |
| | 1074 | if (queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 1075 | { |
| | 1076 | assert(!queenStatusPointer->HModelController.Looped); |
| | 1077 | } |
| | 1078 | #endif |
| | 1079 | |
| | 1080 | /* Now... move forward? */ |
| | 1081 | |
| | 1082 | SetQueenMovement_FromFoot(sbPtr); |
| | 1083 | |
| | 1084 | if ((queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 1085 | &&(queenStatusPointer->HModelController.sequence_timer == (ONE_FIXED-1))) |
| | 1086 | { |
| | 1087 | queenStatusPointer->current_move = QM_Standby; |
| | 1088 | |
| | 1089 | /* Same foot. */ |
| | 1090 | } |
| | 1091 | |
| | 1092 | queenStatusPointer->moveTimer += NormalFrameTime; |
| | 1093 | } |
| | 1094 | |
| | 1095 | void QueenMove_Hiss(STRATEGYBLOCK *sbPtr) |
| | 1096 | { |
| | 1097 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 1098 | |
| | 1099 | /* First movement function. */ |
| | 1100 | |
| | 1101 | assert(queenStatusPointer->current_move == QM_Hiss); |
| | 1102 | |
| | 1103 | if (!queenStatusPointer->moveTimer) |
| | 1104 | { |
| | 1105 | /* Do setup. */ |
| | 1106 | int tweeiningtime = (ONE_FIXED >> 3); |
| | 1107 | |
| | 1108 | switch (queenStatusPointer->fixed_foot) |
| | 1109 | { |
| | 1110 | case LeftFoot: |
| | 1111 | SetQueenFoot(sbPtr,LeftFoot); |
| | 1112 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenLeftStanceFull, (int)QLSFSS_Standard_Hiss,Queen_Step_Time,tweeiningtime); |
| | 1113 | queenStatusPointer->HModelController.LoopAfterTweening = 1; |
| | 1114 | break; |
| | 1115 | case RightFoot: |
| | 1116 | SetQueenFoot(sbPtr,RightFoot); |
| | 1117 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenRightStanceFull, (int)QRSFSS_Standard_Hiss,Queen_Step_Time,tweeiningtime); |
| | 1118 | queenStatusPointer->HModelController.LoopAfterTweening = 1; |
| | 1119 | break; |
| | 1120 | default: |
| | 1121 | assert(0); |
| | 1122 | break; |
| | 1123 | } |
| | 1124 | } |
| | 1125 | |
| | 1126 | /* |
| | 1127 | if (queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 1128 | { |
| | 1129 | assert(queenStatusPointer->HModelController.Looped == 0); |
| | 1130 | } |
| | 1131 | */ |
| | 1132 | |
| | 1133 | /* Now... move forward? */ |
| | 1134 | |
| | 1135 | SetQueenMovement_FromFoot(sbPtr); |
| | 1136 | |
| | 1137 | queenStatusPointer->moveTimer += NormalFrameTime; |
| | 1138 | } |
| | 1139 | |
| | 1140 | void QueenMove_LeftSwipe(STRATEGYBLOCK *sbPtr) |
| | 1141 | { |
| | 1142 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 1143 | |
| | 1144 | /* First movement function. */ |
| | 1145 | |
| | 1146 | assert(queenStatusPointer->current_move==QM_LeftSwipe); |
| | 1147 | |
| | 1148 | if (!queenStatusPointer->moveTimer) |
| | 1149 | { |
| | 1150 | /* Do setup. */ |
| | 1151 | int tweeiningtime = (ONE_FIXED >> 3); |
| | 1152 | |
| | 1153 | switch (queenStatusPointer->fixed_foot) |
| | 1154 | { |
| | 1155 | case LeftFoot: |
| | 1156 | SetQueenFoot(sbPtr,LeftFoot); |
| | 1157 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenLeftStanceFull, (int)QLSFSS_Standard_Hiss,Queen_Step_Time,tweeiningtime); |
| | 1158 | |
| | 1159 | Start_Delta_Sequence(queenStatusPointer->attack_delta, (int)HMSQT_QueenLeftStanceTemplate,(int)QLSTSS_LeftSwipe,Queen_Step_Time); |
| | 1160 | queenStatusPointer->attack_delta->Playing = 1; |
| | 1161 | |
| | 1162 | break; |
| | 1163 | case RightFoot: |
| | 1164 | SetQueenFoot(sbPtr,RightFoot); |
| | 1165 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenRightStanceFull, (int)QRSFSS_Standard_Hiss,Queen_Step_Time,tweeiningtime); |
| | 1166 | |
| | 1167 | Start_Delta_Sequence(queenStatusPointer->attack_delta, (int)HMSQT_QueenRightStanceTemplate,(int)QRSTSS_LeftSwipe,Queen_Step_Time); |
| | 1168 | queenStatusPointer->attack_delta->Playing = 1; |
| | 1169 | |
| | 1170 | break; |
| | 1171 | default: |
| | 1172 | assert(0); |
| | 1173 | break; |
| | 1174 | } |
| | 1175 | } |
| | 1176 | |
| | 1177 | #if DEBUG |
| | 1178 | if (queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 1179 | { |
| | 1180 | assert(!queenStatusPointer->HModelController.Looped); |
| | 1181 | } |
| | 1182 | #endif |
| | 1183 | |
| | 1184 | /* Now... move forward? */ |
| | 1185 | |
| | 1186 | SetQueenMovement_FromFoot(sbPtr); |
| | 1187 | |
| | 1188 | if ((queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 1189 | &&(queenStatusPointer->HModelController.sequence_timer == (ONE_FIXED-1))) |
| | 1190 | { |
| | 1191 | queenStatusPointer->current_move = QM_Standby; |
| | 1192 | } |
| | 1193 | |
| | 1194 | queenStatusPointer->moveTimer += NormalFrameTime; |
| | 1195 | } |
| | 1196 | |
| | 1197 | void QueenMove_RightSwipe(STRATEGYBLOCK *sbPtr) |
| | 1198 | { |
| | 1199 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 1200 | |
| | 1201 | /* First movement function. */ |
| | 1202 | |
| | 1203 | assert(queenStatusPointer->current_move==QM_RightSwipe); |
| | 1204 | |
| | 1205 | if (!queenStatusPointer->moveTimer) |
| | 1206 | { |
| | 1207 | /* Do setup. */ |
| | 1208 | int tweeiningtime = (ONE_FIXED >> 3); |
| | 1209 | |
| | 1210 | switch (queenStatusPointer->fixed_foot) |
| | 1211 | { |
| | 1212 | case LeftFoot: |
| | 1213 | SetQueenFoot(sbPtr,LeftFoot); |
| | 1214 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenLeftStanceFull, (int)QLSFSS_Standard_Hiss,Queen_Step_Time,tweeiningtime); |
| | 1215 | |
| | 1216 | Start_Delta_Sequence(queenStatusPointer->attack_delta, (int)HMSQT_QueenLeftStanceTemplate,(int)QLSTSS_RightSwipe,Queen_Step_Time); |
| | 1217 | queenStatusPointer->attack_delta->Playing = 1; |
| | 1218 | |
| | 1219 | break; |
| | 1220 | case RightFoot: |
| | 1221 | SetQueenFoot(sbPtr,RightFoot); |
| | 1222 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenRightStanceFull, (int)QRSFSS_Standard_Hiss,Queen_Step_Time,tweeiningtime); |
| | 1223 | |
| | 1224 | Start_Delta_Sequence(queenStatusPointer->attack_delta, (int)HMSQT_QueenRightStanceTemplate,(int)QRSTSS_RightSwipe,Queen_Step_Time); |
| | 1225 | queenStatusPointer->attack_delta->Playing = 1; |
| | 1226 | |
| | 1227 | break; |
| | 1228 | default: |
| | 1229 | assert(0); |
| | 1230 | break; |
| | 1231 | } |
| | 1232 | } |
| | 1233 | |
| | 1234 | #if DEBUG |
| | 1235 | if (queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 1236 | { |
| | 1237 | assert(queenStatusPointer->HModelController.Looped==0); |
| | 1238 | } |
| | 1239 | #endif |
| | 1240 | |
| | 1241 | /* Now... move forward? */ |
| | 1242 | |
| | 1243 | SetQueenMovement_FromFoot(sbPtr); |
| | 1244 | |
| | 1245 | if ((queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 1246 | && (queenStatusPointer->HModelController.sequence_timer == (ONE_FIXED-1))) |
| | 1247 | { |
| | 1248 | queenStatusPointer->current_move = QM_Standby; |
| | 1249 | } |
| | 1250 | |
| | 1251 | queenStatusPointer->moveTimer += NormalFrameTime; |
| | 1252 | } |
| | 1253 | |
| | 1254 | void QueenMove_Charge(STRATEGYBLOCK *sbPtr) |
| | 1255 | { |
| | 1256 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 1257 | int ChangingFoot = 0; |
| | 1258 | |
| | 1259 | /* Very different movement function... */ |
| | 1260 | |
| | 1261 | assert(queenStatusPointer->current_move == QM_Charge); |
| | 1262 | |
| | 1263 | /* Charge at the player. */ |
| | 1264 | if(!queenStatusPointer->TempTarget) |
| | 1265 | { |
| | 1266 | // queenStatusPointer->TargetPos = PlayerStatus.sbptr->DynPtr->Position; |
| | 1267 | queenStatusPointer->TargetPos = queenStatusPointer->QueenTargetSB->DynPtr->Position; |
| | 1268 | } |
| | 1269 | |
| | 1270 | if (!queenStatusPointer->moveTimer) |
| | 1271 | { |
| | 1272 | /* Do setup. */ |
| | 1273 | int tweeiningtime = (Queen_Step_Time >> 2); |
| | 1274 | |
| | 1275 | sbPtr->DynPtr->LinVelocity.vx = sbPtr->DynPtr->LinVelocity.vy = sbPtr->DynPtr->LinVelocity.vz = 0; |
| | 1276 | |
| | 1277 | switch (queenStatusPointer->fixed_foot) |
| | 1278 | { |
| | 1279 | case LeftFoot: |
| | 1280 | SetQueenFoot(sbPtr,LeftFoot); |
| | 1281 | { |
| | 1282 | //which version of sprint should we use |
| | 1283 | if(DeltaAnimation_IsFinished(queenStatusPointer->attack_delta)) |
| | 1284 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenGeneral, (int)QGSS_Sprint_Full,-1,tweeiningtime); |
| | 1285 | else |
| | 1286 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenGeneral, (int)QGSS_Sprint,-1,tweeiningtime); |
| | 1287 | |
| | 1288 | queenStatusPointer->HModelController.LoopAfterTweening = 1; |
| | 1289 | queenStatusPointer->moveTimer=1; /* It's something of a state flag here. */ |
| | 1290 | } |
| | 1291 | break; |
| | 1292 | case RightFoot: |
| | 1293 | /* Argh! Can't start from right foot! */ |
| | 1294 | queenStatusPointer->current_move = QM_Close; |
| | 1295 | queenStatusPointer->moveTimer = 0; |
| | 1296 | queenStatusPointer->next_move = QM_Charge; |
| | 1297 | return; |
| | 1298 | break; |
| | 1299 | default: |
| | 1300 | assert(0); |
| | 1301 | break; |
| | 1302 | } |
| | 1303 | queenStatusPointer->SwerveTimer = (ONE_FIXED/2)+(FastRandom() & 0xffff)*2; |
| | 1304 | return; |
| | 1305 | } |
| | 1306 | |
| | 1307 | /* Check for change foot? */ |
| | 1308 | |
| | 1309 | if (queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 1310 | { |
| | 1311 | if (queenStatusPointer->HModelController.keyframe_flags) |
| | 1312 | { |
| | 1313 | if (queenStatusPointer->HModelController.keyframe_flags & 1) |
| | 1314 | { |
| | 1315 | SetQueenFoot(sbPtr,LeftFoot); |
| | 1316 | ChangingFoot = 1; |
| | 1317 | } |
| | 1318 | |
| | 1319 | if (queenStatusPointer->HModelController.keyframe_flags & 2) |
| | 1320 | { |
| | 1321 | SetQueenFoot(sbPtr,RightFoot); |
| | 1322 | ChangingFoot = 1; |
| | 1323 | } |
| | 1324 | |
| | 1325 | if(queenStatusPointer->moveTimer == 1) |
| | 1326 | queenStatusPointer->moveTimer = 3; |
| | 1327 | } |
| | 1328 | |
| | 1329 | HModel_SetToolsRelativeSpeed(&queenStatusPointer->HModelController,(512*ONE_FIXED)/QUEEN_CHARGE_SPEED); |
| | 1330 | } |
| | 1331 | |
| | 1332 | /* Now... turn to face. */ |
| | 1333 | |
| | 1334 | if (queenStatusPointer->moveTimer != 2) |
| | 1335 | { |
| | 1336 | DISPLAYBLOCK *dPtr = sbPtr->DisplayBlock; |
| | 1337 | assert(dPtr); |
| | 1338 | |
| | 1339 | ProveHModel(dPtr->HModelControlBlock,dPtr); |
| | 1340 | |
| | 1341 | { |
| | 1342 | VECTORCH v; |
| | 1343 | |
| | 1344 | if(queenStatusPointer->QueenTargetSB == PlayerStatus.sbptr && !queenStatusPointer->TempTarget &&
queenStatusPointer->TargetDistance > 5000) |
| | 1345 | { |
| | 1346 | //if charging at player don't go in a straight line |
| | 1347 | #define QUEEN_COS 63302 |
| | 1348 | #define QUEEN_SIN 16961 |
| | 1349 | |
| | 1350 | if(queenStatusPointer->SwerveDirection) |
| | 1351 | { |
| | 1352 | v.vx = MUL_FIXED(queenStatusPointer->VectToTarget.vx,QUEEN_COS)+MUL_FIXED(queenStatusPointer->VectToTarget.vz,QUEEN_SIN); |
| | 1353 | v.vy = 0; |
| | 1354 | v.vz = MUL_FIXED(queenStatusPointer->VectToTarget.vz,QUEEN_COS)-MUL_FIXED(queenStatusPointer->VectToTarget.vx,QUEEN_SIN); |
| | 1355 | } |
| | 1356 | else |
| | 1357 | { |
| | 1358 | v.vx = MUL_FIXED(queenStatusPointer->VectToTarget.vx,QUEEN_COS)-MUL_FIXED(queenStatusPointer->VectToTarget.vz,QUEEN_SIN); |
| | 1359 | v.vy = 0; |
| | 1360 | v.vz = MUL_FIXED(queenStatusPointer->VectToTarget.vz,QUEEN_COS)+MUL_FIXED(queenStatusPointer->VectToTarget.vx,QUEEN_SIN); |
| | 1361 | } |
| | 1362 | |
| | 1363 | queenStatusPointer->SwerveTimer -= NormalFrameTime; |
| | 1364 | |
| | 1365 | if(queenStatusPointer->SwerveTimer <= 0) |
| | 1366 | { |
| | 1367 | //alter swerve direction , and keep it for the next .5 to 2.5 seconds |
| | 1368 | queenStatusPointer->SwerveTimer = (ONE_FIXED/2)+(FastRandom() & 0xffff)*2; |
| | 1369 | queenStatusPointer->SwerveDirection = !queenStatusPointer->SwerveDirection; |
| | 1370 | } |
| | 1371 | } |
| | 1372 | else |
| | 1373 | { |
| | 1374 | v = queenStatusPointer->VectToTarget; |
| | 1375 | } |
| | 1376 | |
| | 1377 | NPCOrientateToVector(sbPtr, &v, Queen_Turn_Rate); |
| | 1378 | |
| | 1379 | //NPCOrientateToVector(sbPtr, &queenStatusPointer->VectToTarget, Queen_Turn_Rate); |
| | 1380 | } |
| | 1381 | /* Now, just a normal lin velocity. */ |
| | 1382 | |
| | 1383 | if(queenStatusPointer->moveTimer == 1) |
| | 1384 | { |
| | 1385 | SetQueenMovement_FromFoot(sbPtr); |
| | 1386 | } |
| | 1387 | else |
| | 1388 | { |
| | 1389 | VECTORCH velocity; |
| | 1390 | |
| | 1391 | velocity.vx = sbPtr->DynPtr->OrientMat.mat31; |
| | 1392 | velocity.vy = 0; |
| | 1393 | velocity.vz = sbPtr->DynPtr->OrientMat.mat33; |
| | 1394 | |
| | 1395 | if ( !velocity.vx && !velocity.vy && !velocity.vz) |
| | 1396 | { |
| | 1397 | sbPtr->DynPtr->LinVelocity.vx = sbPtr->DynPtr->LinVelocity.vy = sbPtr->DynPtr->LinVelocity.vz = 0; |
| | 1398 | return; |
| | 1399 | } |
| | 1400 | |
| | 1401 | Normalise(&velocity); |
| | 1402 | |
| | 1403 | sbPtr->DynPtr->LinVelocity.vx = MUL_FIXED(velocity.vx,QUEEN_CHARGE_SPEED); |
| | 1404 | sbPtr->DynPtr->LinVelocity.vy = MUL_FIXED(velocity.vy,QUEEN_CHARGE_SPEED); |
| | 1405 | sbPtr->DynPtr->LinVelocity.vz = MUL_FIXED(velocity.vz,QUEEN_CHARGE_SPEED); |
| | 1406 | } |
| | 1407 | } |
| | 1408 | |
| | 1409 | /* Consider exit state. */ |
| | 1410 | |
| | 1411 | if ((queenStatusPointer->HModelController.Tweening == Controller_NoTweening) && (queenStatusPointer->moveTimer == 2)) |
| | 1412 | { |
| | 1413 | /* We must have finished. */ |
| | 1414 | |
| | 1415 | queenStatusPointer->current_move = QM_Standby; |
| | 1416 | |
| | 1417 | switch (queenStatusPointer->fixed_foot) |
| | 1418 | { |
| | 1419 | case LeftFoot: |
| | 1420 | SetQueenFoot(sbPtr,RightFoot); |
| | 1421 | break; |
| | 1422 | case RightFoot: |
| | 1423 | SetQueenFoot(sbPtr,LeftFoot); |
| | 1424 | break; |
| | 1425 | default: |
| | 1426 | assert(0); |
| | 1427 | break; |
| | 1428 | } |
| | 1429 | /* Would you believe the end's in the middle? :-) */ |
| | 1430 | } |
| | 1431 | |
| | 1432 | if(ChangingFoot) |
| | 1433 | { |
| | 1434 | QueenCalculateTargetInfo(sbPtr); |
| | 1435 | |
| | 1436 | if(queenStatusPointer->PlayingHitDelta) |
| | 1437 | { |
| | 1438 | queenStatusPointer->HModelController.Playing = 0; |
| | 1439 | queenStatusPointer->current_move = QM_Standby; |
| | 1440 | queenStatusPointer->moveTimer = 0; |
| | 1441 | queenStatusPointer->next_move = QM_Standby; |
| | 1442 | return; |
| | 1443 | } |
| | 1444 | |
| | 1445 | //only check for exiting charge , when changing foot |
| | 1446 | /* Only charge if we're facing the right way. */ |
| | 1447 | |
| | 1448 | if (queenStatusPointer->TargetDirection.vz < queenStatusPointer->TargetDirection.vx || |
| | 1449 | queenStatusPointer->TargetDirection.vz < -queenStatusPointer->TargetDirection.vx) |
| | 1450 | { |
| | 1451 | /* Spin round a bit more. */ |
| | 1452 | queenStatusPointer->HModelController.Playing = 0; |
| | 1453 | queenStatusPointer->current_move = QM_Close; |
| | 1454 | queenStatusPointer->moveTimer = 0; |
| | 1455 | queenStatusPointer->next_move = QM_Charge; |
| | 1456 | return; |
| | 1457 | } |
| | 1458 | |
| | 1459 | if (((queenStatusPointer->TargetDistance < 8000 && queenStatusPointer->fixed_foot == LeftFoot |
| | 1460 | && queenStatusPointer->TargetRelSpeed<QUEEN_CLOSE_SPEED) ||queenStatusPointer->next_move != QM_Standby) &&
(queenStatusPointer->moveTimer != 2)) |
| | 1461 | { |
| | 1462 | queenStatusPointer->HModelController.Playing = 0; |
| | 1463 | queenStatusPointer->current_move = queenStatusPointer->next_move; |
| | 1464 | queenStatusPointer->moveTimer = 0; |
| | 1465 | |
| | 1466 | if(queenStatusPointer->current_move == QM_Standby) |
| | 1467 | { |
| | 1468 | if(queenStatusPointer->QueenTargetSB == PlayerStatus.sbptr && !queenStatusPointer->TempTarget) |
| | 1469 | queenStatusPointer->current_move = QM_Close; |
| | 1470 | else |
| | 1471 | queenStatusPointer->current_move = QM_ComeToPoint; |
| | 1472 | } |
| | 1473 | |
| | 1474 | queenStatusPointer->next_move = QM_Standby; |
| | 1475 | return; |
| | 1476 | } |
| | 1477 | |
| | 1478 | //check to see if queen should change between sprints |
| | 1479 | if(queenStatusPointer->fixed_foot == LeftFoot) |
| | 1480 | { |
| | 1481 | if(DeltaAnimation_IsFinished(queenStatusPointer->attack_delta)) |
| | 1482 | { |
| | 1483 | //switch to full sprint if not already doing it |
| | 1484 | if(queenStatusPointer->HModelController.Sub_Sequence != QGSS_Sprint_Full) |
| | 1485 | { |
| | 1486 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenGeneral, (int)QGSS_Sprint_Full,-1,ONE_FIXED>>3); |
| | 1487 | queenStatusPointer->HModelController.LoopAfterTweening = 1; |
| | 1488 | } |
| | 1489 | } |
| | 1490 | else |
| | 1491 | { |
| | 1492 | //switch to template sprint if not already doing it |
| | 1493 | if(queenStatusPointer->HModelController.Sub_Sequence != QGSS_Sprint) |
| | 1494 | { |
| | 1495 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenGeneral, (int)QGSS_Sprint,-1,ONE_FIXED>>3); |
| | 1496 | queenStatusPointer->HModelController.LoopAfterTweening = 1; |
| | 1497 | } |
| | 1498 | } |
| | 1499 | } |
| | 1500 | } |
| | 1501 | } |
| | 1502 | |
| | 1503 | void QueenMove_ButtAttack(STRATEGYBLOCK* sbPtr) |
| | 1504 | { |
| | 1505 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 1506 | |
| | 1507 | /* First movement function. */ |
| | 1508 | |
| | 1509 | assert(queenStatusPointer->current_move == QM_ButtAttack); |
| | 1510 | |
| | 1511 | if (!queenStatusPointer->moveTimer) |
| | 1512 | { |
| | 1513 | /* Do setup. */ |
| | 1514 | int tweeiningtime = (ONE_FIXED >> 3); |
| | 1515 | |
| | 1516 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenGeneral, (int)QGSS_ButtConnect,-1,tweeiningtime); |
| | 1517 | } |
| | 1518 | |
| | 1519 | #if DEBUG |
| | 1520 | if (queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 1521 | { |
| | 1522 | assert(!queenStatusPointer->HModelController.Looped); |
| | 1523 | } |
| | 1524 | #endif |
| | 1525 | |
| | 1526 | if ((queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 1527 | && (queenStatusPointer->HModelController.sequence_timer == (ONE_FIXED-1))) |
| | 1528 | { |
| | 1529 | queenStatusPointer->current_move = QM_Standby; |
| | 1530 | //finished attack switch back to reconsider |
| | 1531 | queenStatusPointer->QueenState = QBS_Reconsider; |
| | 1532 | |
| | 1533 | //queen ends this sequence with right foot forward |
| | 1534 | SetQueenFoot(sbPtr,RightFoot); |
| | 1535 | } |
| | 1536 | |
| | 1537 | sbPtr->DynPtr->LinVelocity.vx = sbPtr->DynPtr->LinVelocity.vy = sbPtr->DynPtr->LinVelocity.vz = 0; |
| | 1538 | |
| | 1539 | queenStatusPointer->moveTimer += NormalFrameTime; |
| | 1540 | } |
| | 1541 | |
| | 1542 | void QueenMove_ButtCharge(STRATEGYBLOCK* sbPtr) |
| | 1543 | { |
| | 1544 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 1545 | int ChangingFoot = 0; |
| | 1546 | |
| | 1547 | /* Very different movement function... */ |
| | 1548 | |
| | 1549 | assert(queenStatusPointer->current_move == QM_ButtCharge); |
| | 1550 | |
| | 1551 | /* Charge at the player. */ |
| | 1552 | //queenStatusPointer->TargetPos = queenStatusPointer->QueenTargetSB->DynPtr->Position; |
| | 1553 | |
| | 1554 | if (!queenStatusPointer->moveTimer) |
| | 1555 | { |
| | 1556 | /* Do setup. */ |
| | 1557 | int tweeiningtime = (Queen_Step_Time>>2); |
| | 1558 | |
| | 1559 | sbPtr->DynPtr->LinVelocity.vx = sbPtr->DynPtr->LinVelocity.vy = sbPtr->DynPtr->LinVelocity.vz = 0; |
| | 1560 | |
| | 1561 | switch (queenStatusPointer->fixed_foot) |
| | 1562 | { |
| | 1563 | case LeftFoot: |
| | 1564 | SetQueenFoot(sbPtr,LeftFoot); |
| | 1565 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenGeneral, (int)QGSS_RunButtAttack,-1,tweeiningtime); |
| | 1566 | queenStatusPointer->HModelController.LoopAfterTweening = 1; |
| | 1567 | queenStatusPointer->moveTimer=1; /* It's something of a state flag here. */ |
| | 1568 | |
| | 1569 | break; |
| | 1570 | case RightFoot: |
| | 1571 | /* Argh! Can't start from right foot! */ |
| | 1572 | queenStatusPointer->current_move = QM_Close; |
| | 1573 | queenStatusPointer->moveTimer = 0; |
| | 1574 | queenStatusPointer->next_move = QM_Charge; |
| | 1575 | return; |
| | 1576 | break; |
| | 1577 | default: |
| | 1578 | assert(0); |
| | 1579 | break; |
| | 1580 | } |
| | 1581 | return; |
| | 1582 | } |
| | 1583 | |
| | 1584 | /* Check for change foot? */ |
| | 1585 | |
| | 1586 | if (queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 1587 | { |
| | 1588 | if (queenStatusPointer->HModelController.keyframe_flags) |
| | 1589 | { |
| | 1590 | if (queenStatusPointer->HModelController.keyframe_flags & 1) |
| | 1591 | { |
| | 1592 | SetQueenFoot(sbPtr,LeftFoot); |
| | 1593 | ChangingFoot = 1; |
| | 1594 | } |
| | 1595 | |
| | 1596 | if (queenStatusPointer->HModelController.keyframe_flags & 2) |
| | 1597 | { |
| | 1598 | SetQueenFoot(sbPtr,RightFoot); |
| | 1599 | ChangingFoot = 1; |
| | 1600 | } |
| | 1601 | |
| | 1602 | if(queenStatusPointer->moveTimer == 1) |
| | 1603 | queenStatusPointer->moveTimer = 3; |
| | 1604 | } |
| | 1605 | |
| | 1606 | HModel_SetToolsRelativeSpeed(&queenStatusPointer->HModelController,(512*ONE_FIXED)/QUEEN_BUTTCHARGE_SPEED); |
| | 1607 | } |
| | 1608 | |
| | 1609 | /* Now... turn to face. */ |
| | 1610 | |
| | 1611 | if (queenStatusPointer->moveTimer != 2) |
| | 1612 | { |
| | 1613 | DISPLAYBLOCK *dPtr = sbPtr->DisplayBlock; |
| | 1614 | assert(dPtr); |
| | 1615 | |
| | 1616 | ProveHModel(dPtr->HModelControlBlock,dPtr); |
| | 1617 | |
| | 1618 | NPCOrientateToVector(sbPtr, &queenStatusPointer->VectToTarget,Queen_Turn_Rate); |
| | 1619 | |
| | 1620 | /* Now, just a normal lin velocity. */ |
| | 1621 | if(queenStatusPointer->moveTimer == 1) |
| | 1622 | { |
| | 1623 | SetQueenMovement_FromFoot(sbPtr); |
| | 1624 | } |
| | 1625 | else |
| | 1626 | { |
| | 1627 | VECTORCH velocity; |
| | 1628 | |
| | 1629 | velocity.vx = sbPtr->DynPtr->OrientMat.mat31; |
| | 1630 | velocity.vy = 0; |
| | 1631 | velocity.vz = sbPtr->DynPtr->OrientMat.mat33; |
| | 1632 | |
| | 1633 | if ( !velocity.vx && !velocity.vy && !velocity.vz) |
| | 1634 | { |
| | 1635 | sbPtr->DynPtr->LinVelocity.vx = sbPtr->DynPtr->LinVelocity.vy = sbPtr->DynPtr->LinVelocity.vz = 0; |
| | 1636 | return; |
| | 1637 | } |
| | 1638 | |
| | 1639 | Normalise(&velocity); |
| | 1640 | |
| | 1641 | //runSpeed=DIV_FIXED(Queen_Charge_Step_Speed,Queen_ButtCharge_Rate); |
| | 1642 | |
| | 1643 | sbPtr->DynPtr->LinVelocity.vx = MUL_FIXED(velocity.vx,QUEEN_BUTTCHARGE_SPEED); |
| | 1644 | sbPtr->DynPtr->LinVelocity.vy = MUL_FIXED(velocity.vy,QUEEN_BUTTCHARGE_SPEED); |
| | 1645 | sbPtr->DynPtr->LinVelocity.vz = MUL_FIXED(velocity.vz,QUEEN_BUTTCHARGE_SPEED); |
| | 1646 | } |
| | 1647 | } |
| | 1648 | |
| | 1649 | if(ChangingFoot) |
| | 1650 | { |
| | 1651 | QueenCalculateTargetInfo(sbPtr); |
| | 1652 | //int range = queenStatusPointer->TargetDistance; |
| | 1653 | //only check for exiting charge , when changing foot |
| | 1654 | |
| | 1655 | if(queenStatusPointer->PlayingHitDelta) |
| | 1656 | { |
| | 1657 | queenStatusPointer->HModelController.Playing = 0; |
| | 1658 | queenStatusPointer->current_move = QM_Standby; |
| | 1659 | queenStatusPointer->moveTimer = 0; |
| | 1660 | queenStatusPointer->next_move = QM_Standby; |
| | 1661 | return; |
| | 1662 | } |
| | 1663 | |
| | 1664 | if(PlayerInLocker) |
| | 1665 | { |
| | 1666 | //stop using butt charge , since the queen can't actually get to the player |
| | 1667 | queenStatusPointer->moveTimer = 0; |
| | 1668 | queenStatusPointer->current_move = QM_Charge; |
| | 1669 | queenStatusPointer->next_move = QM_Standby; |
| | 1670 | return; |
| | 1671 | } |
| | 1672 | |
| | 1673 | if (queenStatusPointer->TargetDirection.vz < queenStatusPointer->TargetDirection.vx || |
| | 1674 | queenStatusPointer->TargetDirection.vz < -queenStatusPointer->TargetDirection.vx) |
| | 1675 | { |
| | 1676 | /* Spin round a bit more. */ |
| | 1677 | queenStatusPointer->HModelController.Playing = 0; |
| | 1678 | queenStatusPointer->current_move = QM_Close; |
| | 1679 | queenStatusPointer->moveTimer = 0; |
| | 1680 | queenStatusPointer->next_move = QM_Standby; |
| | 1681 | return; |
| | 1682 | } |
| | 1683 | |
| | 1684 | if (queenStatusPointer->moveTimer != 2 && queenStatusPointer->next_move != QM_Standby) |
| | 1685 | { |
| | 1686 | queenStatusPointer->HModelController.Playing = 0; |
| | 1687 | queenStatusPointer->current_move = queenStatusPointer->next_move; |
| | 1688 | queenStatusPointer->next_move = QM_Standby; |
| | 1689 | queenStatusPointer->moveTimer = 0; |
| | 1690 | } |
| | 1691 | } |
| | 1692 | } |
| | 1693 | |
| | 1694 | void QueenForceReconsider(STRATEGYBLOCK* sbPtr) |
| | 1695 | { |
| | 1696 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 1697 | |
| | 1698 | if(queenStatusPointer->QueenState == QBS_Reconsider) |
| | 1699 | return; |
| | 1700 | |
| | 1701 | if(queenStatusPointer->QueenState == QBS_CarryingObject) |
| | 1702 | { |
| | 1703 | //need to drop the object |
| | 1704 | if(queenStatusPointer->CurrentQueenObject != -1) |
| | 1705 | { |
| | 1706 | //if the object has been destroyed anywa, don't need to worry about dropping it |
| | 1707 | if(!QueenObjectList[queenStatusPointer->CurrentQueenObject]->destroyed_but_preserved) |
| | 1708 | { |
| | 1709 | //put gravity back on |
| | 1710 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->GravityOn = 1; |
| | 1711 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->OnlyCollideWithEnvironment = 0; |
| | 1712 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->OrientMat = IdentityMatrix; |
| | 1713 | //give the object a slight impulse away from the queen |
| | 1714 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->LinImpulse.vx += sbPtr->DynPtr->OrientMat.mat31/10; |
| | 1715 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->LinImpulse.vz += sbPtr->DynPtr->OrientMat.mat33/10; |
| | 1716 | } |
| | 1717 | } |
| | 1718 | } |
| | 1719 | |
| | 1720 | queenStatusPointer->CurrentQueenObject = -1; |
| | 1721 | queenStatusPointer->QueenState = QBS_Reconsider; |
| | 1722 | queenStatusPointer->QueenTargetSB = PlayerStatus.sbptr; |
| | 1723 | queenStatusPointer->TempTarget = 0; |
| | 1724 | queenStatusPointer->TargetInfoValid = 0; |
| | 1725 | queenStatusPointer->TargetPos = queenStatusPointer->QueenTargetSB->DynPtr->Position; |
| | 1726 | } |
| | 1727 | |
| | 1728 | void QueenMove_Climb(STRATEGYBLOCK* sbPtr) |
| | 1729 | { |
| | 1730 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 1731 | |
| | 1732 | assert(queenStatusPointer->current_move == QM_Climbing); |
| | 1733 | |
| | 1734 | if (!queenStatusPointer->moveTimer) |
| | 1735 | { |
| | 1736 | //just starting to climb out , so start the animation sequence |
| | 1737 | int tweeiningtime = (Queen_Step_Time >> 2); |
| | 1738 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenGeneral, (int)QGSS_ClimbOut,-1,tweeiningtime); |
| | 1739 | |
| | 1740 | queenStatusPointer->HModelController.Playing = 1; |
| | 1741 | |
| | 1742 | //set the start position of this maneuver |
| | 1743 | queenStatusPointer->ClimbStartPosition = sbPtr->DynPtr->Position; |
| | 1744 | |
| | 1745 | //while climbing out queen needs to ignore gravity and collisions |
| | 1746 | sbPtr->DynPtr->GravityOn = 0; |
| | 1747 | sbPtr->DynPtr->OnlyCollideWithObjects = 1; |
| | 1748 | |
| | 1749 | /*moveTimer is being used as a state flag again*/ |
| | 1750 | queenStatusPointer->moveTimer = 1; |
| | 1751 | } |
| | 1752 | |
| | 1753 | /*Adjust the queen's facing*/ |
| | 1754 | { |
| | 1755 | VECTORCH direction = {-ONE_FIXED,0,0}; |
| | 1756 | NPCOrientateToVector(sbPtr, &direction,Queen_Turn_Rate); |
| | 1757 | } |
| | 1758 | |
| | 1759 | /*If the queen has stopped tweening , then we need to deal with her movement*/ |
| | 1760 | if (queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 1761 | { |
| | 1762 | #define QueenClimbTime1 7598 |
| | 1763 | #define QueenClimbTime2 16146 |
| | 1764 | #define QueenClimbTime3 42740 |
| | 1765 | |
| | 1766 | ProveHModel(sbPtr->DisplayBlock->HModelControlBlock,sbPtr->DisplayBlock); |
| | 1767 | |
| | 1768 | { |
| | 1769 | VECTORCH StageOneMovement = {0,-6771,0}; |
| | 1770 | VECTORCH StageTwoMovement = {-3266,0,-372}; |
| | 1771 | |
| | 1772 | //work out where the queen should be |
| | 1773 | VECTORCH newPosition = queenStatusPointer->ClimbStartPosition; |
| | 1774 | int timer = queenStatusPointer->HModelController.sequence_timer; |
| | 1775 | |
| | 1776 | if(timer < QueenClimbTime1) |
| | 1777 | { |
| | 1778 | //no movement |
| | 1779 | } |
| | 1780 | else if(timer < QueenClimbTime2) |
| | 1781 | { |
| | 1782 | int scale = DIV_FIXED(timer-QueenClimbTime1,QueenClimbTime2-QueenClimbTime1); |
| | 1783 | |
| | 1784 | newPosition.vx += MUL_FIXED(StageOneMovement.vx,scale); |
| | 1785 | newPosition.vy += MUL_FIXED(StageOneMovement.vy,scale); |
| | 1786 | newPosition.vz += MUL_FIXED(StageOneMovement.vz,scale); |
| | 1787 | } |
| | 1788 | else if(timer < QueenClimbTime3) |
| | 1789 | { |
| | 1790 | int scale = DIV_FIXED(timer-QueenClimbTime2, QueenClimbTime3-QueenClimbTime2); |
| | 1791 | |
| | 1792 | newPosition.vx += StageOneMovement.vx; |
| | 1793 | newPosition.vy += StageOneMovement.vy; |
| | 1794 | newPosition.vz += StageOneMovement.vz; |
| | 1795 | |
| | 1796 | newPosition.vx += MUL_FIXED(StageTwoMovement.vx,scale); |
| | 1797 | newPosition.vy += MUL_FIXED(StageTwoMovement.vy,scale); |
| | 1798 | newPosition.vz += MUL_FIXED(StageTwoMovement.vz,scale); |
| | 1799 | } |
| | 1800 | else |
| | 1801 | { |
| | 1802 | newPosition.vx += StageOneMovement.vx; |
| | 1803 | newPosition.vy += StageOneMovement.vy; |
| | 1804 | newPosition.vz += StageOneMovement.vz; |
| | 1805 | |
| | 1806 | newPosition.vx += StageTwoMovement.vx; |
| | 1807 | newPosition.vy += StageTwoMovement.vy; |
| | 1808 | newPosition.vz += StageTwoMovement.vz; |
| | 1809 | } |
| | 1810 | |
| | 1811 | sbPtr->DynPtr->Displacement.vx = newPosition.vx - sbPtr->DynPtr->Position.vx; |
| | 1812 | sbPtr->DynPtr->Displacement.vy = newPosition.vy - sbPtr->DynPtr->Position.vy; |
| | 1813 | sbPtr->DynPtr->Displacement.vz = newPosition.vz - sbPtr->DynPtr->Position.vz; |
| | 1814 | } |
| | 1815 | |
| | 1816 | if(queenStatusPointer->HModelController.sequence_timer > 62000) |
| | 1817 | { |
| | 1818 | //the queen has finished getting out |
| | 1819 | queenStatusPointer->current_move = QM_Standby; |
| | 1820 | queenStatusPointer->next_move = QM_Standby; |
| | 1821 | queenStatusPointer->moveTimer = 0; |
| | 1822 | |
| | 1823 | QueenForceReconsider(sbPtr); |
| | 1824 | |
| | 1825 | sbPtr->DynPtr->GravityOn = 1; |
| | 1826 | sbPtr->DynPtr->OnlyCollideWithObjects = 0; |
| | 1827 | |
| | 1828 | //the queen ends in right stance |
| | 1829 | queenStatusPointer->fixed_foot = RightFoot; |
| | 1830 | } |
| | 1831 | } |
| | 1832 | } |
| | 1833 | |
| | 1834 | #define Queen_Swipe_Left 0 |
| | 1835 | #define Queen_Swipe_Right 1 |
| | 1836 | #define Queen_Swipe_Left_Low 2 |
| | 1837 | #define Queen_Swipe_Right_Low 3 |
| | 1838 | |
| | 1839 | void Queen_Do_Swipe(STRATEGYBLOCK *sbPtr,int side) |
| | 1840 | { |
| | 1841 | VECTORCH vectohand,targetpos; |
| | 1842 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 1843 | |
| | 1844 | /*Is the queen already doing a swipe?*/ |
| | 1845 | if ((queenStatusPointer->attack_delta->timer == (ONE_FIXED-1)) || !queenStatusPointer->attack_delta->timer) |
| | 1846 | { |
| | 1847 | /* She isn't , so start it */ |
| | 1848 | switch (side) |
| | 1849 | { |
| | 1850 | case Queen_Swipe_Left: |
| | 1851 | Start_Delta_Sequence(queenStatusPointer->attack_delta, (int)HMSQT_QueenRightStanceTemplate,(int)QRSTSS_LeftSwipe,ONE_FIXED); |
| | 1852 | break; |
| | 1853 | case Queen_Swipe_Right: |
| | 1854 | Start_Delta_Sequence(queenStatusPointer->attack_delta, (int)HMSQT_QueenRightStanceTemplate,(int)QRSTSS_RightSwipe,ONE_FIXED); |
| | 1855 | break; |
| | 1856 | case Queen_Swipe_Left_Low: |
| | 1857 | Start_Delta_Sequence(queenStatusPointer->attack_delta, (int)HMSQT_QueenRightStanceTemplate,(int)QRSTSS_LeftSwipe_Low,ONE_FIXED); |
| | 1858 | break; |
| | 1859 | case Queen_Swipe_Right_Low: |
| | 1860 | Start_Delta_Sequence(queenStatusPointer->attack_delta, (int)HMSQT_QueenRightStanceTemplate,(int)QRSTSS_RightSwipe_Low,ONE_FIXED); |
| | 1861 | break; |
| | 1862 | default : |
| | 1863 | assert(1==0); |
| | 1864 | break; |
| | 1865 | |
| | 1866 | } |
| | 1867 | |
| | 1868 | queenStatusPointer->attack_delta->Playing = 1; |
| | 1869 | queenStatusPointer->attack_delta->Looped = 0; |
| | 1870 | queenStatusPointer->AttackDoneItsDamage = 0; |
| | 1871 | } |
| | 1872 | |
| | 1873 | if(queenStatusPointer->attack_delta->timer > 37000 && !queenStatusPointer->AttackDoneItsDamage) |
| | 1874 | { |
| | 1875 | SECTION_DATA *hand_section; |
| | 1876 | queenStatusPointer->AttackDoneItsDamage = 1; |
| | 1877 | |
| | 1878 | //get the hand corresponding to the currently playing swipe |
| | 1879 | switch(queenStatusPointer->attack_delta->sub_sequence) |
| | 1880 | { |
| | 1881 | case QRSTSS_RightSwipe: |
| | 1882 | case QRSTSS_RightSwipe_Low: |
| | 1883 | hand_section = GetThisSectionData(queenStatusPointer->HModelController.section_data,"right hand"); |
| | 1884 | break; |
| | 1885 | |
| | 1886 | case QRSTSS_LeftSwipe: |
| | 1887 | case QRSTSS_LeftSwipe_Low: |
| | 1888 | hand_section = GetThisSectionData(queenStatusPointer->HModelController.section_data,"left hand"); |
| | 1889 | break; |
| | 1890 | |
| | 1891 | default: |
| | 1892 | assert(1==0); |
| | 1893 | } |
| | 1894 | |
| | 1895 | GetTargetingPointOfObject(PlayerStatus.DisplayBlock, &targetpos); |
| | 1896 | vectohand.vx = targetpos.vx-hand_section->World_Offset.vx; |
| | 1897 | vectohand.vy = 0;//targetpos.vy-hand_section->World_Offset.vy; |
| | 1898 | vectohand.vz = targetpos.vz-hand_section->World_Offset.vz; |
| | 1899 | |
| | 1900 | int range_to_player = Approximate3dMagnitude(&vectohand); |
| | 1901 | |
| | 1902 | //see if queen hit an intervening object |
| | 1903 | { |
| | 1904 | VECTORCH direction; |
| | 1905 | |
| | 1906 | direction.vx = targetpos.vx - hand_section->World_Offset.vx; |
| | 1907 | direction.vy = targetpos.vy - hand_section->World_Offset.vy; |
| | 1908 | direction.vz = targetpos.vz - hand_section->World_Offset.vz; |
| | 1909 | |
| | 1910 | Normalise(&direction); |
| | 1911 | |
| | 1912 | FindPolygonInLineOfSight(&direction, &hand_section->World_Offset, 1, sbPtr->DisplayBlock); |
| | 1913 | |
| | 1914 | if(LOS_ObjectHitPtr) |
| | 1915 | { |
| | 1916 | if(LOS_ObjectHitPtr->ObStrategyBlock) |
| | 1917 | { |
| | 1918 | if(LOS_ObjectHitPtr->ObStrategyBlock->type == I_BehaviourInanimateObject || |
| | 1919 | LOS_ObjectHitPtr->ObStrategyBlock->type == I_BehaviourTrackObject) |
| | 1920 | { |
| | 1921 | //damage the object instead of the player |
| | 1922 | //if(LOS_Lambda < QueenAttackRange) |
| | 1923 | // { |
| | 1924 | CauseDamageToObject(LOS_ObjectHitPtr->ObStrategyBlock,&TemplateAmmo[AMMO_NPC_PAQ_CLAW].MaxDamage, ONE_FIXED,NULL); |
| | 1925 | // } |
| | 1926 | return; |
| | 1927 | } |
| | 1928 | } |
| | 1929 | } |
| | 1930 | } |
| | 1931 | |
| | 1932 | /* ATM, target is always player. */ |
| | 1933 | |
| | 1934 | if (range_to_player < QueenAttackRange) |
| | 1935 | { |
| | 1936 | //do from .75 to 1.25 times base damage |
| | 1937 | CauseDamageToObject(PlayerStatus.sbptr, &TemplateAmmo[AMMO_NPC_PAQ_CLAW].MaxDamage, (ONE_FIXED*.75)+(FastRandom()&0x7fff), NULL); |
| | 1938 | queenStatusPointer->QueenTauntTimer=ONE_FIXED/2; |
| | 1939 | } |
| | 1940 | } |
| | 1941 | } |
| | 1942 | |
| | 1943 | void QueenMove_Close(STRATEGYBLOCK *sbPtr) |
| | 1944 | { |
| | 1945 | QUEEN_STATUS_BLOCK *queenStatusPointer= (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 1946 | |
| | 1947 | /* First movement function. */ |
| | 1948 | |
| | 1949 | assert(queenStatusPointer->current_move == QM_Close); |
| | 1950 | |
| | 1951 | if (!queenStatusPointer->moveTimer) |
| | 1952 | { |
| | 1953 | /* Do setup. */ |
| | 1954 | int tweeiningtime = (ONE_FIXED >> 3); |
| | 1955 | |
| | 1956 | sbPtr->DynPtr->LinVelocity.vx = sbPtr->DynPtr->LinVelocity.vy = sbPtr->DynPtr->LinVelocity.vz = 0; |
| | 1957 | |
| | 1958 | switch (queenStatusPointer->fixed_foot) |
| | 1959 | { |
| | 1960 | case LeftFoot: |
| | 1961 | SetQueenFoot(sbPtr,LeftFoot); |
| | 1962 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenLeftStanceTemplate, (int)QLSTSS_Forward_L2R,-1,tweeiningtime); |
| | 1963 | queenStatusPointer->HModelController.LoopAfterTweening = 0; |
| | 1964 | break; |
| | 1965 | case RightFoot: |
| | 1966 | SetQueenFoot(sbPtr,RightFoot); |
| | 1967 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenRightStanceTemplate, (int)QRSTSS_Forward_R2L,-1,tweeiningtime); |
| | 1968 | queenStatusPointer->HModelController.LoopAfterTweening = 0; |
| | 1969 | break; |
| | 1970 | default: |
| | 1971 | assert(0); |
| | 1972 | break; |
| | 1973 | } |
| | 1974 | |
| | 1975 | /* Go! */ |
| | 1976 | queenStatusPointer->moveTimer++; |
| | 1977 | assert(queenStatusPointer->HModelController.Looped == 0); |
| | 1978 | return; |
| | 1979 | } |
| | 1980 | |
| | 1981 | if (queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 1982 | { |
| | 1983 | int moveHalfSpeed = 0; |
| | 1984 | |
| | 1985 | #if DEBUG |
| | 1986 | if (queenStatusPointer->HModelController.Looped != 0) |
| | 1987 | { |
| | 1988 | /* Quirkafleeg */ |
| | 1989 | assert(!queenStatusPointer->HModelController.Looped); |
| | 1990 | } |
| | 1991 | #endif |
| | 1992 | |
| | 1993 | QueenCalculateTargetInfo(sbPtr); |
| | 1994 | //if the queen is close to her target , and the target is not in front of her |
| | 1995 | //then she needs to slow down to reduce her turning circle |
| | 1996 | |
| | 1997 | if(queenStatusPointer->TargetDistance < 3000) |
| | 1998 | { |
| | 1999 | if(queenStatusPointer->TargetDirection.vz < queenStatusPointer->TargetDirection.vx || |
| | 2000 | queenStatusPointer->TargetDirection.vz < -queenStatusPointer->TargetDirection.vx) |
| | 2001 | { |
| | 2002 | moveHalfSpeed = 1; |
| | 2003 | } |
| | 2004 | } |
| | 2005 | |
| | 2006 | if(moveHalfSpeed) |
| | 2007 | HModel_SetToolsRelativeSpeed(&queenStatusPointer->HModelController,(512*ONE_FIXED)/(QUEEN_CLOSE_SPEED/2)); |
| | 2008 | else |
| | 2009 | HModel_SetToolsRelativeSpeed(&queenStatusPointer->HModelController,(512*ONE_FIXED)/QUEEN_CLOSE_SPEED); |
| | 2010 | } |
| | 2011 | |
| | 2012 | /* Now... turn to face. */ |
| | 2013 | |
| | 2014 | { |
| | 2015 | //DISPLAYBLOCK *dPtr = sbPtr->DisplayBlock; assert(dPtr); |
| | 2016 | |
| | 2017 | NPCOrientateToVector(sbPtr, &queenStatusPointer->VectToTarget, Queen_Turn_Rate); |
| | 2018 | |
| | 2019 | SetQueenMovement_FromFoot(sbPtr); |
| | 2020 | } |
| | 2021 | |
| | 2022 | queenStatusPointer->moveTimer += NormalFrameTime; |
| | 2023 | |
| | 2024 | if ((queenStatusPointer->HModelController.Tweening == Controller_NoTweening) |
| | 2025 | && (queenStatusPointer->HModelController.sequence_timer == (ONE_FIXED-1))) |
| | 2026 | { |
| | 2027 | queenStatusPointer->current_move = QM_Standby; |
| | 2028 | |
| | 2029 | switch (queenStatusPointer->fixed_foot) |
| | 2030 | { |
| | 2031 | case LeftFoot: |
| | 2032 | SetQueenFoot(sbPtr,RightFoot); |
| | 2033 | break; |
| | 2034 | case RightFoot: |
| | 2035 | SetQueenFoot(sbPtr,LeftFoot); |
| | 2036 | break; |
| | 2037 | default: |
| | 2038 | assert(0); |
| | 2039 | break; |
| | 2040 | } |
| | 2041 | |
| | 2042 | queenStatusPointer->moveTimer = 0; |
| | 2043 | queenStatusPointer->current_move = queenStatusPointer->next_move; |
| | 2044 | queenStatusPointer->next_move = QM_Standby; |
| | 2045 | } |
| | 2046 | } |
| | 2047 | |
| | 2048 | void KillQueen(STRATEGYBLOCK *sbPtr, const DAMAGE_PROFILE *damage, int multiple, SECTION_DATA *Section, VECTORCH *incoming) |
| | 2049 | { |
| | 2050 | /* Oh my God! They've killed Queenie! */ |
| | 2051 | |
| | 2052 | assert(sbPtr); |
| | 2053 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 2054 | assert(queenStatusPointer); |
| | 2055 | |
| | 2056 | /* make a sound. Just this once without a check. */ |
| | 2057 | Sound_Play(SID_ALIEN_KILL, "d", &sbPtr->DynPtr->Position); |
| | 2058 | |
| | 2059 | /*If queen has a death target ,send a request*/ |
| | 2060 | if(queenStatusPointer->death_target_sbptr) |
| | 2061 | RequestState(queenStatusPointer->death_target_sbptr,queenStatusPointer->death_target_request, 0); |
| | 2062 | |
| | 2063 | /* Queens never gibb, they're that hard. */ |
| | 2064 | |
| | 2065 | /* Deal with sequence. */ |
| | 2066 | RemoveAllDeltas(&queenStatusPointer->HModelController); |
| | 2067 | |
| | 2068 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenGeneral,QGSS_FaceDeath,(ONE_FIXED),(ONE_FIXED>>2)); |
| | 2069 | |
| | 2070 | //if the queen is carrying an object , release it and reset gravity on it |
| | 2071 | |
| | 2072 | if(queenStatusPointer->QueenState == QBS_CarryingObject) |
| | 2073 | { |
| | 2074 | if(!QueenObjectList[queenStatusPointer->CurrentQueenObject]->destroyed_but_preserved) |
| | 2075 | { |
| | 2076 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->GravityOn = 1; |
| | 2077 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->OnlyCollideWithEnvironment = 0; |
| | 2078 | queenStatusPointer->CurrentQueenObject = -1; |
| | 2079 | } |
| | 2080 | } |
| | 2081 | |
| | 2082 | /* More restrained death than before... */ |
| | 2083 | { |
| | 2084 | queenStatusPointer->QueenState = QBS_Dead; |
| | 2085 | |
| | 2086 | /* stop motion */ |
| | 2087 | assert(sbPtr->DynPtr); |
| | 2088 | sbPtr->DynPtr->Friction = 400000; |
| | 2089 | sbPtr->DynPtr->LinImpulse.vx += sbPtr->DynPtr->LinVelocity.vx; |
| | 2090 | sbPtr->DynPtr->LinImpulse.vy += sbPtr->DynPtr->LinVelocity.vy; |
| | 2091 | sbPtr->DynPtr->LinImpulse.vz += sbPtr->DynPtr->LinVelocity.vz; |
| | 2092 | sbPtr->DynPtr->LinVelocity.vx = sbPtr->DynPtr->LinVelocity.vy = sbPtr->DynPtr->LinVelocity.vz = 0; |
| | 2093 | |
| | 2094 | sbPtr->DynPtr->IgnoreSameObjectsAsYou = 1; |
| | 2095 | /* Experiment... */ |
| | 2096 | sbPtr->DynPtr->UseStandardGravity = 1; |
| | 2097 | } |
| | 2098 | } |
| | 2099 | |
| | 2100 | void QueenIsDamaged(STRATEGYBLOCK *sbPtr, const DAMAGE_PROFILE *damage, int multiple,SECTION_DATA *Section, VECTORCH *incoming, VECTORCH *point) |
| | 2101 | { |
| | 2102 | assert(sbPtr); |
| | 2103 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 2104 | assert(queenStatusPointer); |
| | 2105 | |
| | 2106 | /* Ouch. */ |
| | 2107 | if (sbPtr->DamageBlock.Health <= 0) |
| | 2108 | { |
| | 2109 | if (queenStatusPointer->QueenState!=QBS_Dead) |
| | 2110 | KillQueen(sbPtr,damage,multiple,Section,incoming); |
| | 2111 | return; |
| | 2112 | } |
| | 2113 | |
| | 2114 | QueenSoundHurt(sbPtr); |
| | 2115 | |
| | 2116 | if(damage->ExplosivePower && incoming) |
| | 2117 | { |
| | 2118 | /* |
| | 2119 | Don't allow the queen to be stunned if she is climbing out of the airlock. |
| | 2120 | This would screw up the sequence to much. |
| | 2121 | */ |
| | 2122 | if(queenStatusPointer->current_move != QM_Climbing) |
| | 2123 | { |
| | 2124 | if(!QueenPlayingStunAnimation(&queenStatusPointer->HModelController)) |
| | 2125 | { |
| | 2126 | if(EXPLOSIONFIRE_BLAST == damage->Id) |
| | 2127 | { |
| | 2128 | //big explosion, play fall over anim |
| | 2129 | SetQueenShapeAnimSequence_Core(sbPtr,HMSQT_QueenGeneral,(int)QGSS_Explosion_Stun,-1,ONE_FIXED>>3); |
| | 2130 | queenStatusPointer->HModelController.LoopAfterTweening = 0; |
| | 2131 | queenStatusPointer->current_move = QM_Stun; |
| | 2132 | queenStatusPointer->PlayingHitDelta = 1; |
| | 2133 | QueenForceReconsider(sbPtr); |
| | 2134 | |
| | 2135 | //the queen ends in right stance |
| | 2136 | queenStatusPointer->fixed_foot = RightFoot; |
| | 2137 | } |
| | 2138 | else |
| | 2139 | { |
| | 2140 | //play a hit delta if not already doing so |
| | 2141 | if ((queenStatusPointer->hit_delta->timer == (ONE_FIXED-1)) ||!queenStatusPointer->hit_delta->timer) |
| | 2142 | { |
| | 2143 | VECTORCH dir = *incoming; |
| | 2144 | MATRIXCH WtoL = sbPtr->DynPtr->OrientMat; |
| | 2145 | |
| | 2146 | TransposeMatrixCH(&WtoL); |
| | 2147 | RotateVector(&dir,&WtoL); |
| | 2148 | |
| | 2149 | if(dir.vx > 0) |
| | 2150 | Start_Delta_Sequence(queenStatusPointer->hit_delta, (int)HMSQT_QueenRightStanceTemplate,(int)QRSTSS_RightHit,-1); |
| | 2151 | else |
| | 2152 | Start_Delta_Sequence(queenStatusPointer->hit_delta, (int)HMSQT_QueenRightStanceTemplate,(int)QRSTSS_LeftHit,-1); |
| | 2153 | |
| | 2154 | queenStatusPointer->hit_delta->Playing = 1; |
| | 2155 | queenStatusPointer->PlayingHitDelta = 1; |
| | 2156 | QueenForceReconsider(sbPtr); |
| | 2157 | } |
| | 2158 | } |
| | 2159 | } |
| | 2160 | } |
| | 2161 | } |
| | 2162 | |
| | 2163 | if(AvP.PlayerType == I_Marine && Section) |
| | 2164 | { |
| | 2165 | //don't allow the marine to completely destroy a section |
| | 2166 | if(Section->current_damage.Health <= 0) |
| | 2167 | Section->current_damage.Health = 1; |
| | 2168 | } |
| | 2169 | } |
| | 2170 | |
| | 2171 | static void Execute_Queen_Dying(STRATEGYBLOCK *sbPtr) |
| | 2172 | { |
| | 2173 | /* Here for completeness. Queens never melt away. */ |
| | 2174 | /* |
| | 2175 | assert(sbPtr); |
| | 2176 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 2177 | assert(queenStatusPointer); |
| | 2178 | |
| | 2179 | if(AVP_ENVIRONMENT_TYRARGOHANGAR == AvP.level) |
| | 2180 | { |
| | 2181 | DISPLAYBLOCK *dispPtr = sbPtr->DisplayBlock; |
| | 2182 | |
| | 2183 | if (dispPtr) |
| | 2184 | { |
| | 2185 | //dispPtr->SpecialFXFlags |= SFXFLAG_MELTINGINTOGROUND; |
| | 2186 | //dispPtr->ObFlags2 = queenStatusPointer->NearStateTimer / 2; |
| | 2187 | } |
| | 2188 | } |
| | 2189 | */ |
| | 2190 | } |
| | 2191 | |
| | 2192 | void FindQueenObjects() |
| | 2193 | { |
| | 2194 | int sbIndex = 0; |
| | 2195 | NumQueenObjects = 0; |
| | 2196 | |
| | 2197 | //search through all the strategies for the throwable objects |
| | 2198 | //also look for the special airlock doors |
| | 2199 | UpperAirlockDoorSbptr = 0; |
| | 2200 | LowerAirlockDoorSbptr = 0; |
| | 2201 | LockerDoorSbptr = 0; |
| | 2202 | UpperAirlockDoorOpen = 0; |
| | 2203 | LowerAirlockDoorOpen = 0; |
| | 2204 | |
| | 2205 | while(sbIndex < NumActiveStBlocks) |
| | 2206 | { |
| | 2207 | STRATEGYBLOCK *sbPtr = ActiveStBlockList[sbIndex++]; |
| | 2208 | |
| | 2209 | if(sbPtr->name) |
| | 2210 | { |
| | 2211 | if(strstr(sbPtr->name, "QueenAmmo")) |
| | 2212 | { |
| | 2213 | if(NumQueenObjects < QUEEN_MAX_OBJECT) |
| | 2214 | { |
| | 2215 | QueenObjectList[NumQueenObjects++] = sbPtr; |
| | 2216 | assert(sbPtr->DynPtr); |
| | 2217 | sbPtr->preserve_until_end_of_level = 1; |
| | 2218 | } |
| | 2219 | } |
| | 2220 | else if(!strcmp(sbPtr->name, "a1door")) |
| | 2221 | { |
| | 2222 | UpperAirlockDoorSbptr = sbPtr; |
| | 2223 | UpperAirlockDoorStart = sbPtr->DynPtr->Position; |
| | 2224 | } |
| | 2225 | else if(!strcmp(sbPtr->name, "a3door")) |
| | 2226 | { |
| | 2227 | LowerAirlockDoorSbptr = sbPtr; |
| | 2228 | LowerAirlockDoorStart = sbPtr->DynPtr->Position; |
| | 2229 | } |
| | 2230 | else if(!strcmp(sbPtr->name, "locker door")) |
| | 2231 | { |
| | 2232 | LockerDoorSbptr = sbPtr; |
| | 2233 | sbPtr->preserve_until_end_of_level = 1; |
| | 2234 | } |
| | 2235 | } |
| | 2236 | } |
| | 2237 | } |
| | 2238 | |
| | 2239 | int CalculateTrajectory(VECTORCH* start,VECTORCH* dest,VECTORCH* velocity,int obj_speed,VECTORCH* result) |
| | 2240 | { |
| | 2241 | VECTORCH rotated_vel; |
| | 2242 | VECTORCH rotated_result; |
| | 2243 | VECTORCH normal; |
| | 2244 | |
| | 2245 | //get a normalised vector from start to destination |
| | 2246 | |
| | 2247 | normal.vx = dest->vx - start->vx; |
| | 2248 | //normal.vy = dest->vy - start->vy; |
| | 2249 | normal.vy = 0; |
| | 2250 | normal.vz = dest->vz - start->vz; |
| | 2251 | |
| | 2252 | int vertical_distance = normal.vy-1000; |
| | 2253 | |
| | 2254 | if(!normal.vx && !normal.vz) |
| | 2255 | return 0; |
| | 2256 | |
| | 2257 | int distance = Magnitude(&normal); |
| | 2258 | |
| | 2259 | Normalise(&normal); |
| | 2260 | |
| | 2261 | //apply rotation to velocity that would rotate the normal to (ONE_FIXED,0,0) |
| | 2262 | rotated_vel.vx = MUL_FIXED(velocity->vx,normal.vx)+MUL_FIXED(velocity->vz,normal.vz); |
| | 2263 | rotated_vel.vy = 0; |
| | 2264 | rotated_vel.vz = MUL_FIXED(velocity->vx,-normal.vz)+MUL_FIXED(velocity->vz,normal.vx); |
| | 2265 | |
| | 2266 | if(rotated_vel.vz >= obj_speed || -rotated_vel.vz >= obj_speed) |
| | 2267 | return 0; //no hope of hitting |
| | 2268 | |
| | 2269 | rotated_result.vz = rotated_vel.vz; |
| | 2270 | |
| | 2271 | //calculate x component using floats |
| | 2272 | { |
| | 2273 | float z =(float)rotated_result.vz; |
| | 2274 | float speed = (float)obj_speed; |
| | 2275 | |
| | 2276 | float x = sqrt(speed*speed-z*z); |
| | 2277 | |
| | 2278 | rotated_result.vx = x; |
| | 2279 | } |
| | 2280 | |
| | 2281 | int closing_speed = rotated_result.vx-rotated_vel.vx; |
| | 2282 | |
| | 2283 | if(closing_speed <= 0) |
| | 2284 | return 0; //can't hit |
| | 2285 | |
| | 2286 | int time_to_target = DIV_FIXED(distance, closing_speed); |
| | 2287 | |
| | 2288 | if(time_to_target > (3*ONE_FIXED)) |
| | 2289 | { |
| | 2290 | //take to long to hit target |
| | 2291 | return 0; |
| | 2292 | } |
| | 2293 | |
| | 2294 | //rotate result back |
| | 2295 | result->vx = MUL_FIXED(rotated_result.vx,normal.vx)+MUL_FIXED(rotated_result.vz,-normal.vz); |
| | 2296 | result->vy = 0; |
| | 2297 | result->vz = MUL_FIXED(rotated_result.vx,normal.vz)+MUL_FIXED(rotated_result.vz,normal.vx); |
| | 2298 | |
| | 2299 | //calculate required up component |
| | 2300 | //u=s/t - a*t/2 |
| | 2301 | result->vy = DIV_FIXED(vertical_distance,time_to_target)-MUL_FIXED(time_to_target,GRAVITY_STRENGTH/2); |
| | 2302 | |
| | 2303 | //we have a targeting solution. |
| | 2304 | return 1; |
| | 2305 | } |
| | 2306 | |
| | 2307 | #define AirlockMinX 33882 |
| | 2308 | #define AirlockMaxX 45542 |
| | 2309 | #define AirlockMinZ -13936 |
| | 2310 | #define AirlockMaxZ -6266 |
| | 2311 | #define AirlockCentreX ((AirlockMinX+AirlockMaxX)/2) |
| | 2312 | #define AirlockCentreZ ((AirlockMinZ+AirlockMaxZ)/2) |
| | 2313 | #define AirlockY 12000 |
| | 2314 | #define HangarFloorLevel 3950 |
| | 2315 | #define AirlockOpeningDistance 2500 |
| | 2316 | #define AirlockOffset 1000 |
| | 2317 | |
| | 2318 | void QueenCheckForAvoidAirlock(STRATEGYBLOCK *sbPtr) |
| | 2319 | { |
| | 2320 | //only need to look out for the airlock in hangar |
| | 2321 | if(AVP_ENVIRONMENT_TYRARGOHANGAR == AvP.level) |
| | 2322 | { |
| | 2323 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 2324 | VECTORCH* qpos = &sbPtr->DynPtr->Position; |
| | 2325 | VECTORCH* tpos = &queenStatusPointer->TargetPos; |
| | 2326 | |
| | 2327 | if(!UpperAirlockDoorOpen) |
| | 2328 | return; |
| | 2329 | |
| | 2330 | if(PlayerInTrench) |
| | 2331 | return; |
| | 2332 | |
| | 2333 | if(queenStatusPointer->QueenState == QBS_ClimbingOutOfAirlock) |
| | 2334 | { |
| | 2335 | //not much point in trying to avoid airlock now! |
| | 2336 | return; |
| | 2337 | } |
| | 2338 | |
| | 2339 | if(!queenStatusPointer->BeenInAirlock) |
| | 2340 | { |
| | 2341 | //if the queen hasn't fallen in yet , then she isn't careful while |
| | 2342 | //charging at the player |
| | 2343 | if(queenStatusPointer->current_move == QM_ButtCharge) |
| | 2344 | return; |
| | 2345 | } |
| | 2346 | |
| | 2347 | if(qpos->vx > AirlockMaxX - 1000) |
| | 2348 | { |
| | 2349 | if(tpos->vx < AirlockMaxX - 1000) |
| | 2350 | { |
| | 2351 | //queen and target are on opposite sides of the max X side |
| | 2352 | //find out where the queen's path will intersect the side |
| | 2353 | |
| | 2354 | int scale = DIV_FIXED((AirlockMaxX-1000)-qpos->vx,tpos->vx-qpos->vx); |
| | 2355 | int zintercept = MUL_FIXED(tpos->vz-qpos->vz,scale)+qpos->vz; |
| | 2356 | |
| | 2357 | if(zintercept >= AirlockMinZ && zintercept <= AirlockMaxZ) |
| | 2358 | { |
| | 2359 | //printf("Airlock Max X\n"); |
| | 2360 | |
| | 2361 | //head for the corner that is closest to the current target |
| | 2362 | queenStatusPointer->TargetPos.vx = AirlockMaxX; |
| | 2363 | |
| | 2364 | if(abs(AirlockMinZ-tpos->vz) < abs(AirlockMaxZ-tpos->vz)) |
| | 2365 | queenStatusPointer->TargetPos.vz = AirlockMinZ; |
| | 2366 | else |
| | 2367 | queenStatusPointer->TargetPos.vz = AirlockMaxZ; |
| | 2368 | |
| | 2369 | queenStatusPointer->TempTarget = 1; |
| | 2370 | queenStatusPointer->TempTargetTimer = ONE_FIXED; |
| | 2371 | queenStatusPointer->TargetInfoValid = 0; |
| | 2372 | return; |
| | 2373 | } |
| | 2374 | } |
| | 2375 | } |
| | 2376 | else if(qpos->vx < AirlockMinX + 1000) |
| | 2377 | { |
| | 2378 | if(tpos->vx > AirlockMinX + 1000) |
| | 2379 | { |
| | 2380 | //queen and target are on opposite sides of the min X side |
| | 2381 | //find out where the queen's path will intersect the side |
| | 2382 | int scale = DIV_FIXED(AirlockMinX+1000-qpos->vx,tpos->vx-qpos->vx); |
| | 2383 | int zintercept = MUL_FIXED(tpos->vz-qpos->vz,scale)+qpos->vz; |
| | 2384 | |
| | 2385 | if(zintercept >= AirlockMinZ && zintercept <= AirlockMaxZ) |
| | 2386 | { |
| | 2387 | // printf("Airlock Min X\n"); |
| | 2388 | //head for the corner that is closest to the current target |
| | 2389 | queenStatusPointer->TargetPos.vx = AirlockMinX; |
| | 2390 | |
| | 2391 | if(abs(AirlockMinZ-tpos->vz) < abs(AirlockMaxZ-tpos->vz)) |
| | 2392 | queenStatusPointer->TargetPos.vz = AirlockMinZ; |
| | 2393 | else |
| | 2394 | queenStatusPointer->TargetPos.vz = AirlockMaxZ; |
| | 2395 | |
| | 2396 | queenStatusPointer->TempTarget = 1; |
| | 2397 | queenStatusPointer->TempTargetTimer = ONE_FIXED; |
| | 2398 | queenStatusPointer->TargetInfoValid = 0; |
| | 2399 | return; |
| | 2400 | } |
| | 2401 | } |
| | 2402 | } |
| | 2403 | |
| | 2404 | if(qpos->vz > AirlockMaxZ - 1000) |
| | 2405 | { |
| | 2406 | if(tpos->vz < AirlockMaxZ - 1000) |
| | 2407 | { |
| | 2408 | //queen and target are on opposite sides of the max Z side |
| | 2409 | //find out where the queen's path will intersect the side |
| | 2410 | int scale = DIV_FIXED((AirlockMaxZ-1000)-qpos->vz,tpos->vz-qpos->vz); |
| | 2411 | int xintercept = MUL_FIXED(tpos->vx-qpos->vx,scale)+qpos->vx; |
| | 2412 | |
| | 2413 | if(xintercept >= AirlockMinX && xintercept <= AirlockMaxX) |
| | 2414 | { |
| | 2415 | // printf("Airlock Max Z\n"); |
| | 2416 | //head for the corner that is closest to the current target |
| | 2417 | queenStatusPointer->TargetPos.vz = AirlockMaxZ; |
| | 2418 | |
| | 2419 | if(abs(AirlockMinX-tpos->vx) < abs(AirlockMaxX-tpos->vx)) |
| | 2420 | queenStatusPointer->TargetPos.vx = AirlockMinX; |
| | 2421 | else |
| | 2422 | queenStatusPointer->TargetPos.vx = AirlockMaxX; |
| | 2423 | |
| | 2424 | queenStatusPointer->TempTarget = 1; |
| | 2425 | queenStatusPointer->TempTargetTimer = ONE_FIXED; |
| | 2426 | queenStatusPointer->TargetInfoValid = 0; |
| | 2427 | return; |
| | 2428 | } |
| | 2429 | } |
| | 2430 | } |
| | 2431 | else if(qpos->vz < AirlockMinZ + 1000) |
| | 2432 | { |
| | 2433 | if(tpos->vz > AirlockMinZ + 1000) |
| | 2434 | { |
| | 2435 | //queen and target are on opposite sides of the min Z side |
| | 2436 | //find out where the queen's path will intersect the side |
| | 2437 | int scale = DIV_FIXED(AirlockMinZ+1000-qpos->vz,tpos->vz-qpos->vz); |
| | 2438 | int xintercept = MUL_FIXED(tpos->vx-qpos->vx,scale)+qpos->vx; |
| | 2439 | |
| | 2440 | if(xintercept >= AirlockMinX && xintercept <= AirlockMaxX) |
| | 2441 | { |
| | 2442 | // printf("Airlock Min Z\n"); |
| | 2443 | //head for the corner that is closest to the current target |
| | 2444 | queenStatusPointer->TargetPos.vz = AirlockMinZ; |
| | 2445 | |
| | 2446 | if(abs(AirlockMinX-tpos->vx) < abs(AirlockMaxX-tpos->vx)) |
| | 2447 | queenStatusPointer->TargetPos.vx = AirlockMinX; |
| | 2448 | else |
| | 2449 | queenStatusPointer->TargetPos.vx = AirlockMaxX; |
| | 2450 | |
| | 2451 | queenStatusPointer->TempTarget = 1; |
| | 2452 | queenStatusPointer->TempTargetTimer = ONE_FIXED; |
| | 2453 | queenStatusPointer->TargetInfoValid = 0; |
| | 2454 | return; |
| | 2455 | } |
| | 2456 | } |
| | 2457 | } |
| | 2458 | //printf("Airlock not in the way\n"); |
| | 2459 | } |
| | 2460 | } |
| | 2461 | |
| | 2462 | #define HangarLockerMinX 17104 |
| | 2463 | #define HangarLockerMaxX 19680 |
| | 2464 | #define HangarLockerMinZ -32700 |
| | 2465 | #define HangarLockerMaxZ -29661 |
| | 2466 | #define HangarLockerCentreZ ((HangarLockerMinZ+HangarLockerMaxZ)/2) |
| | 2467 | |
| | 2468 | int ObjectIsInAirlock(STRATEGYBLOCK* sbPtr) |
| | 2469 | { |
| | 2470 | assert(sbPtr); |
| | 2471 | assert(sbPtr->DynPtr); |
| | 2472 | |
| | 2473 | if(sbPtr->DynPtr->Position.vx > AirlockMinX && sbPtr->DynPtr->Position.vx < AirlockMaxX && |
| | 2474 | sbPtr->DynPtr->Position.vz > AirlockMinZ && sbPtr->DynPtr->Position.vz < AirlockMaxZ && |
| | 2475 | sbPtr->DynPtr->Position.vy > (HangarFloorLevel+1000)) |
| | 2476 | { |
| | 2477 | return 1; |
| | 2478 | } |
| | 2479 | |
| | 2480 | return 0; |
| | 2481 | } |
| | 2482 | |
| | 2483 | void QueenPickupTargetObject(STRATEGYBLOCK *sbPtr) |
| | 2484 | { |
| | 2485 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 2486 | |
| | 2487 | //queen must be going for an object |
| | 2488 | if(queenStatusPointer->QueenState != QBS_GoingForObject) |
| | 2489 | return; |
| | 2490 | |
| | 2491 | //disable gravity for object , while it is being carried |
| | 2492 | queenStatusPointer->QueenTargetSB->DynPtr->GravityOn = 0; |
| | 2493 | |
| | 2494 | //also stop it colliding with the queen |
| | 2495 | queenStatusPointer->QueenTargetSB->DynPtr->OnlyCollideWithEnvironment = 1; |
| | 2496 | |
| | 2497 | //change queen's state |
| | 2498 | queenStatusPointer->QueenState = QBS_CarryingObject; |
| | 2499 | queenStatusPointer->QueenStateTimer = 0; |
| | 2500 | |
| | 2501 | //now heading for the player |
| | 2502 | queenStatusPointer->QueenTargetSB = PlayerStatus.sbptr; |
| | 2503 | queenStatusPointer->TargetPos = queenStatusPointer->QueenTargetSB->DynPtr->Position; |
| | 2504 | queenStatusPointer->TargetInfoValid = 0; |
| | 2505 | queenStatusPointer->next_move = QM_Close; |
| | 2506 | } |
| | 2507 | |
| | 2508 | static int TargetIsFiringFlamethrowerAtQueen(STRATEGYBLOCK *sbPtr) |
| | 2509 | { |
| | 2510 | assert(sbPtr); |
| | 2511 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 2512 | |
| | 2513 | //only marine has flamethrower |
| | 2514 | if(AvP.PlayerType != I_Marine) |
| | 2515 | return 0; |
| | 2516 | |
| | 2517 | //queen must be heading for the player |
| | 2518 | if(queenStatusPointer->QueenTargetSB != PlayerStatus.sbptr) |
| | 2519 | return 0; |
| | 2520 | |
| | 2521 | if(queenStatusPointer->TempTarget) |
| | 2522 | return 0; |
| | 2523 | |
| | 2524 | QueenCalculateTargetInfo(sbPtr); |
| | 2525 | |
| | 2526 | if(queenStatusPointer->TargetDistance > 30000) |
| | 2527 | return 0; //queen is too far away to be harmed |
| | 2528 | |
| | 2529 | //if(queenStatusPointer->TargetDistance < 3000) return 0; //queen close enough to attack , so she may as well go ahead |
| | 2530 | |
| | 2531 | /* |
| | 2532 | if (queenStatusPointer->attack_delta->timer != (ONE_FIXED-1) && |
| | 2533 | queenStatusPointer->attack_delta->timer != 0) |
| | 2534 | { |
| | 2535 | //currently attacking |
| | 2536 | return 0; |
| | 2537 | } |
| | 2538 | */ |
| | 2539 | |
| | 2540 | /* Is the player firing a flamethrower? */ |
| | 2541 | |
| | 2542 | if (PlayerStatus.SelectedWeapon->WeaponIDNumber != WEAPON_FLAMETHROWER) |
| | 2543 | return 0; |
| | 2544 | |
| | 2545 | if (PlayerStatus.WeaponState != WEAPONSTATE_FIRING_PRIMARY) |
| | 2546 | return 0; |
| | 2547 | |
| | 2548 | //The player is firing the flamethrower. |
| | 2549 | //are the queen and player facing each other |
| | 2550 | |
| | 2551 | { |
| | 2552 | MATRIXCH WtoL = sbPtr->DynPtr->OrientMat; |
| | 2553 | VECTORCH offset; |
| | 2554 | |
| | 2555 | offset.vx = sbPtr->DynPtr->Position.vx - PlayerStatus.DisplayBlock->ObWorld.vx; |
| | 2556 | offset.vy = sbPtr->DynPtr->Position.vy - PlayerStatus.DisplayBlock->ObWorld.vy; |
| | 2557 | offset.vz = sbPtr->DynPtr->Position.vz - PlayerStatus.DisplayBlock->ObWorld.vz; |
| | 2558 | |
| | 2559 | TransposeMatrixCH(&WtoL); |
| | 2560 | RotateVector(&offset, &WtoL); |
| | 2561 | |
| | 2562 | if ( (offset.vz < 0) |
| | 2563 | && (offset.vz < offset.vx) |
| | 2564 | && (offset.vz < -offset.vx) |
| | 2565 | && (offset.vz < offset.vy) |
| | 2566 | && (offset.vz < -offset.vy) ) |
| | 2567 | { |
| | 2568 | |
| | 2569 | /* 90 horizontal, 90 vertical... continue. */ |
| | 2570 | } |
| | 2571 | else |
| | 2572 | { |
| | 2573 | return 0; |
| | 2574 | } |
| | 2575 | |
| | 2576 | /* Now test it for the other way round. */ |
| | 2577 | |
| | 2578 | WtoL = PlayerStatus.DisplayBlock->ObMat; |
| | 2579 | |
| | 2580 | offset.vx = PlayerStatus.DisplayBlock->ObWorld.vx - sbPtr->DynPtr->Position.vx; |
| | 2581 | offset.vy = PlayerStatus.DisplayBlock->ObWorld.vy - sbPtr->DynPtr->Position.vy; |
| | 2582 | offset.vz = PlayerStatus.DisplayBlock->ObWorld.vz - sbPtr->DynPtr->Position.vz; |
| | 2583 | |
| | 2584 | TransposeMatrixCH(&WtoL); |
| | 2585 | RotateVector(&offset,&WtoL); |
| | 2586 | |
| | 2587 | if ( (offset.vz < 0) |
| | 2588 | && (offset.vz < offset.vx) |
| | 2589 | && (offset.vz < -offset.vx) |
| | 2590 | && (offset.vz < offset.vy) |
| | 2591 | && (offset.vz < -offset.vy) ) |
| | 2592 | { |
| | 2593 | |
| | 2594 | /* 90 horizontal, 90 vertical... continue. */ |
| | 2595 | } |
| | 2596 | else |
| | 2597 | { |
| | 2598 | return 0; |
| | 2599 | } |
| | 2600 | } |
| | 2601 | |
| | 2602 | /* If here, then it must be true! */ |
| | 2603 | return 1; |
| | 2604 | } |
| | 2605 | |
| | 2606 | static int LockerDoorIsClosed() |
| | 2607 | { |
| | 2608 | assert(LockerDoorSbptr); |
| | 2609 | |
| | 2610 | if(LockerDoorSbptr->destroyed_but_preserved) |
| | 2611 | return 0; |
| | 2612 | |
| | 2613 | assert(LockerDoorSbptr->dataptr); |
| | 2614 | |
| | 2615 | TRACK_OBJECT_BEHAV_BLOCK* door = (TRACK_OBJECT_BEHAV_BLOCK*)LockerDoorSbptr->dataptr; |
| | 2616 | |
| | 2617 | assert(door->to_track); |
| | 2618 | |
| | 2619 | if(door->to_track->reverse && !door->to_track->playing) |
| | 2620 | return 1; |
| | 2621 | |
| | 2622 | return 0; |
| | 2623 | } |
| | 2624 | |
| | 2625 | void HandleHangarAirlock() |
| | 2626 | { |
| | 2627 | //only need to look out for the airlock in hangar |
| | 2628 | int wind_multiplier = 0; |
| | 2629 | |
| | 2630 | if(AVP_ENVIRONMENT_TYRARGOHANGAR == AvP.level) |
| | 2631 | { |
| | 2632 | assert(UpperAirlockDoorSbptr); |
| | 2633 | assert(UpperAirlockDoorSbptr->DynPtr); |
| | 2634 | assert(LowerAirlockDoorSbptr); |
| | 2635 | assert(LowerAirlockDoorSbptr->DynPtr); |
| | 2636 | |
| | 2637 | //check to see which of the airlock doors are open |
| | 2638 | { |
| | 2639 | VECTORCH* door_pos = &UpperAirlockDoorSbptr->DynPtr->Position; |
| | 2640 | int upper_open_amount = 0; |
| | 2641 | int lower_open_amount = 0; |
| | 2642 | |
| | 2643 | if(door_pos->vz == UpperAirlockDoorStart.vz) |
| | 2644 | { |
| | 2645 | UpperAirlockDoorOpen = 0; |
| | 2646 | } |
| | 2647 | else |
| | 2648 | { |
| | 2649 | UpperAirlockDoorOpen = 1; |
| | 2650 | upper_open_amount = DIV_FIXED(door_pos->vz-UpperAirlockDoorStart.vz,AirlockOpeningDistance); |
| | 2651 | } |
| | 2652 | |
| | 2653 | door_pos = &LowerAirlockDoorSbptr->DynPtr->Position; |
| | 2654 | |
| | 2655 | if(door_pos->vz == LowerAirlockDoorStart.vz) |
| | 2656 | { |
| | 2657 | LowerAirlockDoorOpen = 0; |
| | 2658 | } |
| | 2659 | else |
| | 2660 | { |
| | 2661 | LowerAirlockDoorOpen = 1; |
| | 2662 | lower_open_amount = DIV_FIXED(door_pos->vz-LowerAirlockDoorStart.vz,AirlockOpeningDistance); |
| | 2663 | } |
| | 2664 | |
| | 2665 | wind_multiplier = MUL_FIXED(upper_open_amount,lower_open_amount); |
| | 2666 | |
| | 2667 | if(wind_multiplier < 0) |
| | 2668 | wind_multiplier = -wind_multiplier; |
| | 2669 | |
| | 2670 | //get a multiplier for the wind strength , based on how far the two pairs of doors are open |
| | 2671 | if(wind_multiplier > ONE_FIXED) |
| | 2672 | wind_multiplier = ONE_FIXED; |
| | 2673 | |
| | 2674 | if(wind_multiplier >= ONE_FIXED) |
| | 2675 | AirlockTimeOpen += NormalFrameTime; |
| | 2676 | else |
| | 2677 | AirlockTimeOpen = 0; |
| | 2678 | } |
| | 2679 | |
| | 2680 | if(LowerAirlockDoorOpen && UpperAirlockDoorOpen) |
| | 2681 | { |
| | 2682 | extern int NumActiveBlocks; |
| | 2683 | |
| | 2684 | int i = NumActiveBlocks; |
| | 2685 | extern DISPLAYBLOCK *ActiveBlockList[]; |
| | 2686 | |
| | 2687 | printf("Wind strength %d\n",wind_multiplier); |
| | 2688 | |
| | 2689 | for(i=0; i < NumActiveBlocks; i++) |
| | 2690 | { |
| | 2691 | STRATEGYBLOCK *sbPtr = ActiveBlockList[i]->ObStrategyBlock; |
| | 2692 | |
| | 2693 | if(sbPtr && sbPtr->DynPtr && !sbPtr->DynPtr->IsStatic) |
| | 2694 | { |
| | 2695 | VECTORCH* pos = &sbPtr->DynPtr->Position; |
| | 2696 | VECTORCH* cur_impulse = &sbPtr->DynPtr->LinImpulse; |
| | 2697 | VECTORCH impulse; |
| | 2698 | int above_airlock = 0; |
| | 2699 | static const DAMAGE_PROFILE vacuum_damage = {0,0,0,0,20,0,0,0,0,0,0,AMMO_NONE}; |
| | 2700 | |
| | 2701 | if(pos->vx > HangarLockerMinX && pos->vx < HangarLockerMaxX && pos->vz > HangarLockerMinZ &&
pos->vz < HangarLockerMaxZ) |
| | 2702 | { |
| | 2703 | if(LockerDoorIsClosed()) |
| | 2704 | continue; |
| | 2705 | } |
| | 2706 | |
| | 2707 | if(pos->vy > 20000) |
| | 2708 | { |
| | 2709 | //outside , so damage this object |
| | 2710 | if(sbPtr->type == I_BehaviourQueenAlien) |
| | 2711 | //the queen has loads of health , so need to damage her quicker |
| | 2712 | CauseDamageToObject(sbPtr, &vacuum_damage, NormalFrameTime*30, NULL); |
| | 2713 | else |
| | 2714 | CauseDamageToObject(sbPtr, &vacuum_damage, NormalFrameTime, NULL); |
| | 2715 | |
| | 2716 | if(pos->vy > 21000) |
| | 2717 | { |
| | 2718 | //turn off gravity |
| | 2719 | sbPtr->DynPtr->GravityOn = 0; |
| | 2720 | } |
| | 2721 | continue; |
| | 2722 | } |
| | 2723 | else if(AirlockTimeOpen > 10*ONE_FIXED) |
| | 2724 | { |
| | 2725 | /* |
| | 2726 | After 10 seconds start doing damage to objects even if they aren't outside yet. |
| | 2727 | Scale damage so it increases linearly until 30 seconds have passed |
| | 2728 | */ |
| | 2729 | |
| | 2730 | AirlockTimeOpen = max(AirlockTimeOpen, 30*ONE_FIXED); |
| | 2731 | int multiplier=MUL_FIXED(NormalFrameTime, (AirlockTimeOpen-10*ONE_FIXED)/20); |
| | 2732 | |
| | 2733 | CauseDamageToObject(sbPtr, &vacuum_damage, multiplier, NULL); |
| | 2734 | } |
| | 2735 | |
| | 2736 | if(pos->vx > AirlockMinX && pos->vx < AirlockMaxX && pos->vz > AirlockMinZ && pos->vz <
AirlockMaxZ) |
| | 2737 | above_airlock = 1; |
| | 2738 | |
| | 2739 | impulse.vx = AirlockCentreX-pos->vx; |
| | 2740 | impulse.vy = 0; |
| | 2741 | impulse.vz = AirlockCentreZ-pos->vz; |
| | 2742 | |
| | 2743 | if(!above_airlock && impulse.vx < 0) |
| | 2744 | { |
| | 2745 | if(impulse.vz*2 > impulse.vx && impulse.vz*2 < -impulse.vx) |
| | 2746 | { |
| | 2747 | if(impulse.vz > 0) |
| | 2748 | impulse.vz -= 12000; |
| | 2749 | else |
| | 2750 | impulse.vz += 12000; |
| | 2751 | } |
| | 2752 | } |
| | 2753 | |
| | 2754 | Normalise(&impulse); |
| | 2755 | |
| | 2756 | impulse.vx /= 2; |
| | 2757 | |
| | 2758 | if(above_airlock) |
| | 2759 | impulse.vy = 30000; |
| | 2760 | else |
| | 2761 | impulse.vy = 0; |
| | 2762 | |
| | 2763 | impulse.vz /= 2; |
| | 2764 | |
| | 2765 | if(wind_multiplier < ONE_FIXED) |
| | 2766 | { |
| | 2767 | impulse.vx = MUL_FIXED(impulse.vx,wind_multiplier); |
| | 2768 | impulse.vy = MUL_FIXED(impulse.vy,wind_multiplier); |
| | 2769 | impulse.vz = MUL_FIXED(impulse.vz,wind_multiplier); |
| | 2770 | } |
| | 2771 | |
| | 2772 | if(impulse.vx > 0) |
| | 2773 | { |
| | 2774 | if(impulse.vx > cur_impulse->vx) |
| | 2775 | { |
| | 2776 | cur_impulse->vx += MUL_FIXED(impulse.vx,NormalFrameTime); |
| | 2777 | cur_impulse->vx = min(cur_impulse->vx,impulse.vx); |
| | 2778 | } |
| | 2779 | } |
| | 2780 | else |
| | 2781 | { |
| | 2782 | if(impulse.vx < cur_impulse->vx) |
| | 2783 | { |
| | 2784 | cur_impulse->vx += MUL_FIXED(impulse.vx,NormalFrameTime); |
| | 2785 | cur_impulse->vx = max(cur_impulse->vx,impulse.vx); |
| | 2786 | } |
| | 2787 | } |
| | 2788 | |
| | 2789 | if(impulse.vy > 0) |
| | 2790 | { |
| | 2791 | if(impulse.vy > cur_impulse->vy) |
| | 2792 | { |
| | 2793 | cur_impulse->vy += MUL_FIXED(impulse.vy,NormalFrameTime); |
| | 2794 | cur_impulse->vy = min(cur_impulse->vy,impulse.vy); |
| | 2795 | } |
| | 2796 | } |
| | 2797 | else |
| | 2798 | { |
| | 2799 | if(impulse.vy < cur_impulse->vy) |
| | 2800 | { |
| | 2801 | cur_impulse->vy += MUL_FIXED(impulse.vy,NormalFrameTime); |
| | 2802 | cur_impulse->vy = max(cur_impulse->vy,impulse.vy); |
| | 2803 | } |
| | 2804 | } |
| | 2805 | |
| | 2806 | if(impulse.vz > 0) |
| | 2807 | { |
| | 2808 | if(impulse.vz > cur_impulse->vz) |
| | 2809 | { |
| | 2810 | cur_impulse->vz += MUL_FIXED(impulse.vz,NormalFrameTime); |
| | 2811 | cur_impulse->vz = min(cur_impulse->vz,impulse.vz); |
| | 2812 | } |
| | 2813 | } |
| | 2814 | else |
| | 2815 | { |
| | 2816 | if(impulse.vz < cur_impulse->vz) |
| | 2817 | { |
| | 2818 | cur_impulse->vz += MUL_FIXED(impulse.vz,NormalFrameTime); |
| | 2819 | cur_impulse->vz = max(cur_impulse->vz,impulse.vz); |
| | 2820 | } |
| | 2821 | } |
| | 2822 | |
| | 2823 | if((pos->vy + ActiveBlockList[i]->extent.max_y) > 3950 && !above_airlock) |
| | 2824 | { |
| | 2825 | if(sbPtr->DynPtr->UseStandardGravity) |
| | 2826 | cur_impulse->vy -= MUL_FIXED(MUL_FIXED(GRAVITY_STRENGTH+5000,NormalFrameTime),wind_multiplier); |
| | 2827 | else |
| | 2828 | cur_impulse->vy -= MUL_FIXED(MUL_FIXED(5000,NormalFrameTime),wind_multiplier); |
| | 2829 | } |
| | 2830 | } |
| | 2831 | } |
| | 2832 | } |
| | 2833 | } |
| | 2834 | } |
| | 2835 | |
| | 2836 | void QueenBehaviour(STRATEGYBLOCK *sbPtr) |
| | 2837 | { |
| | 2838 | DYNAMICSBLOCK *dynPtr = sbPtr->DynPtr; |
| | 2839 | QUEEN_STATUS_BLOCK *queenStatusPointer = (QUEEN_STATUS_BLOCK *)(sbPtr->dataptr); |
| | 2840 | int JumpDesired = 0; |
| | 2841 | int ConsiderJumping = 0; |
| | 2842 | int DistanceToPlayer; |
| | 2843 | |
| | 2844 | if(NumQueenObjects == -1) |
| | 2845 | { |
| | 2846 | //first frame... |
| | 2847 | //find all objects that the queen can chuck |
| | 2848 | FindQueenObjects(); |
| | 2849 | queenStatusPointer->CurrentQueenObject = -1; |
| | 2850 | //get the queens hand section |
| | 2851 | queenStatusPointer->QueenRightHand = GetThisSectionData(queenStatusPointer->HModelController.section_data,"rrrr fing"); |
| | 2852 | assert(queenStatusPointer->QueenRightHand); |
| | 2853 | } |
| | 2854 | |
| | 2855 | if(!queenStatusPointer->QueenActivated) |
| | 2856 | { |
| | 2857 | //is the queen in a visible module? |
| | 2858 | assert(sbPtr->containingModule); |
| | 2859 | |
| | 2860 | if(ModuleCurrVisArray[sbPtr->containingModule->m_index] == 2) |
| | 2861 | queenStatusPointer->QueenActivated = 1; |
| | 2862 | else |
| | 2863 | return; |
| | 2864 | } |
| | 2865 | |
| | 2866 | HandleHangarAirlock(); |
| | 2867 | |
| | 2868 | if(queenStatusPointer->QueenState == QBS_Dead) |
| | 2869 | { |
| | 2870 | //check for victory on marine level. |
| | 2871 | if(AVP_ENVIRONMENT_TYRARGOHANGAR == AvP.level) |
| | 2872 | { |
| | 2873 | //is the player in the locker ('hangar') |
| | 2874 | if(PlayerStatus.DisplayBlock->ObWorld.vx > HangarLockerMinX && PlayerStatus.DisplayBlock->ObWorld.vx < HangarLockerMaxX
&& |
| | 2875 | PlayerStatus.DisplayBlock->ObWorld.vz > HangarLockerMinZ && PlayerStatus.DisplayBlock->ObWorld.vz < HangarLockerMaxZ) |
| | 2876 | PlayerInLocker = 1; |
| | 2877 | else |
| | 2878 | PlayerInLocker = 0; |
| | 2879 | |
| | 2880 | //In the marine level the player can only win if he is inside the locker room area ,and |
| | 2881 | //the locker door is shut |
| | 2882 | |
| | 2883 | if((PlayerInLocker && LockerDoorIsClosed()) || !(LowerAirlockDoorOpen && UpperAirlockDoorOpen)) |
| | 2884 | { |
| | 2885 | AvP.LevelCompleted = 1; |
| | 2886 | AvP.MainLoopRunning = 0; |
| | 2887 | } |
| | 2888 | } |
| | 2889 | |
| | 2890 | Execute_Queen_Dying(sbPtr); |
| | 2891 | return; |
| | 2892 | } |
| | 2893 | |
| | 2894 | /*----------------------------------** |
| | 2895 | ** Check state of delta animations ** |
| | 2896 | **----------------------------------*/ |
| | 2897 | |
| | 2898 | if(queenStatusPointer->PlayingHitDelta) |
| | 2899 | { |
| | 2900 | //check to see if the queen is still stunned from an explosion |
| | 2901 | |
| | 2902 | if (!QueenPlayingStunAnimation(&queenStatusPointer->HModelController) && DeltaAnimation_IsFinished(queenStatusPointer->hit_delta)) |
| | 2903 | { |
| | 2904 | queenStatusPointer->hit_delta->Playing = 0; |
| | 2905 | queenStatusPointer->hit_delta->timer = 0; |
| | 2906 | queenStatusPointer->PlayingHitDelta = 0; |
| | 2907 | queenStatusPointer->current_move = QM_Close; |
| | 2908 | queenStatusPointer->next_move = QM_Standby; |
| | 2909 | queenStatusPointer->moveTimer = 0; |
| | 2910 | } |
| | 2911 | } |
| | 2912 | |
| | 2913 | if(DeltaAnimation_IsFinished(queenStatusPointer->attack_delta)) |
| | 2914 | { |
| | 2915 | queenStatusPointer->attack_delta->Playing = 0; |
| | 2916 | queenStatusPointer->attack_delta->timer = 0; |
| | 2917 | } |
| | 2918 | |
| | 2919 | queenStatusPointer->TargetInfoValid = 0; |
| | 2920 | |
| | 2921 | if(queenStatusPointer->CurrentQueenObject != -1) |
| | 2922 | { |
| | 2923 | if(QueenObjectList[queenStatusPointer->CurrentQueenObject]->destroyed_but_preserved) |
| | 2924 | { |
| | 2925 | //the object that the queen was going for has been destroyed |
| | 2926 | queenStatusPointer->CurrentQueenObject = -1; |
| | 2927 | queenStatusPointer->QueenState = QBS_Reconsider; |
| | 2928 | } |
| | 2929 | } |
| | 2930 | |
| | 2931 | if (sbPtr->DisplayBlock == NULL) |
| | 2932 | return; /* No far behaviour. */ |
| | 2933 | |
| | 2934 | if(!dynPtr->IsInContactWithFloor && queenStatusPointer->current_move != QM_Jump && queenStatusPointer->current_move != QM_Climbing) |
| | 2935 | { |
| | 2936 | //if queen is not on the ground , and not currently jumping switch to standby |
| | 2937 | queenStatusPointer->current_move = QM_Standby; |
| | 2938 | } |
| | 2939 | |
| | 2940 | if(dynPtr->IsInContactWithFloor) |
| | 2941 | { |
| | 2942 | if(AVP_ENVIRONMENT_TYRARGOHANGAR == AvP.level) |
| | 2943 | { |
| | 2944 | //is the player in the trench |
| | 2945 | if((dynPtr->Position.vy + 1500) < PlayerStatus.DisplayBlock->ObWorld.vy) |
| | 2946 | { |
| | 2947 | PlayerInTrench = 1; |
| | 2948 | if(queenStatusPointer->QueenState != QBS_Engagement) |
| | 2949 | QueenForceReconsider(sbPtr); |
| | 2950 | } |
| | 2951 | else |
| | 2952 | { |
| | 2953 | PlayerInTrench = 0; |
| | 2954 | } |
| | 2955 | |
| | 2956 | //is the player in the locker ('hangar') |
| | 2957 | if(PlayerStatus.DisplayBlock->ObWorld.vx > HangarLockerMinX && PlayerStatus.DisplayBlock->ObWorld.vx < HangarLockerMaxX
&& |
| | 2958 | PlayerStatus.DisplayBlock->ObWorld.vz > HangarLockerMinZ && PlayerStatus.DisplayBlock->ObWorld.vz < HangarLockerMaxZ) |
| | 2959 | PlayerInLocker = 1; |
| | 2960 | else |
| | 2961 | PlayerInLocker = 0; |
| | 2962 | |
| | 2963 | //is the queen in the airlock? |
| | 2964 | if(UpperAirlockDoorOpen && !LowerAirlockDoorOpen) |
| | 2965 | { |
| | 2966 | //has the queen fallen into the airlock |
| | 2967 | if(ObjectIsInAirlock(sbPtr) && !ObjectIsInAirlock(PlayerStatus.sbptr) && queenStatusPointer->QueenState !=
QBS_ClimbingOutOfAirlock) |
| | 2968 | QueenForceReconsider(sbPtr); |
| | 2969 | } |
| | 2970 | } |
| | 2971 | } |
| | 2972 | |
| | 2973 | queenStatusPointer->QueenStateTimer += NormalFrameTime; |
| | 2974 | |
| | 2975 | { |
| | 2976 | VECTORCH pos = PlayerStatus.DisplayBlock->ObWorld; |
| | 2977 | |
| | 2978 | pos.vx -= dynPtr->Position.vx; |
| | 2979 | pos.vy -= dynPtr->Position.vy; |
| | 2980 | pos.vz -= dynPtr->Position.vz; |
| | 2981 | |
| | 2982 | DistanceToPlayer = Approximate3dMagnitude(&pos); |
| | 2983 | } |
| | 2984 | |
| | 2985 | /*-------------------------------------------------------** |
| | 2986 | ** Check collision reports , and check for need to jump ** |
| | 2987 | **-------------------------------------------------------*/ |
| | 2988 | |
| | 2989 | { |
| | 2990 | int ignore_obstacles = 0; |
| | 2991 | |
| | 2992 | if(queenStatusPointer->LastVelocity.vx || queenStatusPointer->LastVelocity.vz || queenStatusPointer->current_move == QM_Climbing) |
| | 2993 | { |
| | 2994 | /* Now, smash stuff. */ |
| | 2995 | |
| | 2996 | COLLISIONREPORT *nextReport = dynPtr->CollisionReportPtr; |
| | 2997 | |
| | 2998 | while(nextReport) |
| | 2999 | { |
| | 3000 | int normalDotWithVelocity; |
| | 3001 | int ConsiderJumpingForThisObject = 0; |
| | 3002 | |
| | 3003 | { |
| | 3004 | VECTORCH normVelocity = sbPtr->DynPtr->LinVelocity; |
| | 3005 | normVelocity.vy = 0; |
| | 3006 | Normalise(&normVelocity); |
| | 3007 | normalDotWithVelocity = DotProduct(&(nextReport->ObstacleNormal),&(normVelocity)); |
| | 3008 | } |
| | 3009 | |
| | 3010 | if(normalDotWithVelocity < -20000)//is the object in the way |
| | 3011 | { |
| | 3012 | if(nextReport->ObstacleNormal.vy < 20000 && nextReport->ObstacleNormal.vy > -20000) |
| | 3013 | { |
| | 3014 | //obstacle is reasonably vertical , may need to jump |
| | 3015 | ConsiderJumpingForThisObject = 1; |
| | 3016 | } |
| | 3017 | |
| | 3018 | if (nextReport->ObstacleSBPtr) |
| | 3019 | { |
| | 3020 | if(nextReport->ObstacleSBPtr->type == I_BehaviourInanimateObject) |
| | 3021 | { |
| | 3022 | if(!nextReport->ObstacleSBPtr->DamageBlock.Indestructable) |
| | 3023 | { |
| | 3024 | INANIMATEOBJECT_STATUSBLOCK* objectstatusptr = nextReport->ObstacleSBPtr->dataptr; |
| | 3025 | |
| | 3026 | if(objectstatusptr) |
| | 3027 | { |
| | 3028 | int i=0; |
| | 3029 | int AllowedToDestroy = 1; |
| | 3030 | //is this one of the queen's objects? |
| | 3031 | |
| | 3032 | for(;i < NumQueenObjects; i++) |
| | 3033 | { |
| | 3034 | if(QueenObjectList[i] == nextReport->ObstacleSBPtr) |
| | 3035 | AllowedToDestroy = 0; |
| | 3036 | } |
| | 3037 | |
| | 3038 | if(AllowedToDestroy) |
| | 3039 | { |
| | 3040 | /* aha: an object which the queen can destroy... */ |
| | 3041 | CauseDamageToObject(nextReport->ObstacleSBPtr,&TemplateAmmo[AMMO_NPC_PAQ_CLAW].MaxDamage, ONE_FIXED,NULL); |
| | 3042 | //no need to jump over this |
| | 3043 | ConsiderJumpingForThisObject = 0; |
| | 3044 | } |
| | 3045 | } |
| | 3046 | } |
| | 3047 | } |
| | 3048 | else if(nextReport->ObstacleSBPtr->type == I_BehaviourTrackObject) |
| | 3049 | { |
| | 3050 | /* aha: an object which the queen can destroy... */ |
| | 3051 | CauseDamageToObject(nextReport->ObstacleSBPtr,&TemplateAmmo[AMMO_NPC_PAQ_CLAW].MaxDamage, ONE_FIXED,NULL); |
| | 3052 | //no need to jump over this |
| | 3053 | ConsiderJumpingForThisObject = 0; |
| | 3054 | } |
| | 3055 | else |
| | 3056 | { |
| | 3057 | ConsiderJumpingForThisObject = 0; |
| | 3058 | } |
| | 3059 | |
| | 3060 | if(queenStatusPointer->QueenState == QBS_GoingForObject) |
| | 3061 | { |
| | 3062 | //is this the object that the queen was heading for? |
| | 3063 | if(nextReport->ObstacleSBPtr == queenStatusPointer->QueenTargetSB) |
| | 3064 | { |
| | 3065 | QueenPickupTargetObject(sbPtr); |
| | 3066 | |
| | 3067 | //no need to jump over this |
| | 3068 | ConsiderJumpingForThisObject = 0; |
| | 3069 | } |
| | 3070 | } |
| | 3071 | else if(queenStatusPointer->QueenState == QBS_CarryingObject) |
| | 3072 | { |
| | 3073 | //if the queen is colliding with the object she is carrying , ignore it |
| | 3074 | |
| | 3075 | if(QueenObjectList[queenStatusPointer->CurrentQueenObject] == nextReport->ObstacleSBPtr) |
| | 3076 | { |
| | 3077 | //no need to jump over this |
| | 3078 | ConsiderJumpingForThisObject = 0; |
| | 3079 | } |
| | 3080 | } |
| | 3081 | |
| | 3082 | if(nextReport->ObstacleSBPtr == PlayerStatus.sbptr) |
| | 3083 | { |
| | 3084 | ConsiderJumpingForThisObject = 0; |
| | 3085 | |
| | 3086 | //have we connected with a butt attack |
| | 3087 | if(queenStatusPointer->current_move == QM_ButtCharge) |
| | 3088 | { |
| | 3089 | queenStatusPointer->current_move = QM_ButtAttack; |
| | 3090 | queenStatusPointer->next_move = QM_Standby; |
| | 3091 | queenStatusPointer->moveTimer = 0; |
| | 3092 | |
| | 3093 | { |
| | 3094 | //knock the player back |
| | 3095 | VECTORCH* player_impulse; |
| | 3096 | player_impulse = &PlayerStatus.sbptr->DynPtr->LinImpulse; |
| | 3097 | player_impulse->vx += dynPtr->OrientMat.mat31/4; |
| | 3098 | player_impulse->vy -= 6000; |
| | 3099 | player_impulse->vz += dynPtr->OrientMat.mat33/4; |
| | 3100 | } |
| | 3101 | |
| | 3102 | static const DAMAGE_PROFILE queen_butt = {40,0,0,0,0,0,0,0,0,0,0,AMMO_NONE}; |
| | 3103 | CauseDamageToObject(PlayerStatus.sbptr, &queen_butt, ONE_FIXED,NULL); |
| | 3104 | } |
| | 3105 | else if(queenStatusPointer->current_move == QM_Climbing) |
| | 3106 | { |
| | 3107 | //need to push he player out of the way |
| | 3108 | PlayerStatus.sbptr->DynPtr->LinImpulse.vx = min(PlayerStatus.sbptr->DynPtr->LinImpulse.vx, -3000); |
| | 3109 | } |
| | 3110 | else if(queenStatusPointer->QueenState != QBS_Engagement && queenStatusPointer->QueenState != QBS_CarryingObject) |
| | 3111 | { |
| | 3112 | QueenForceReconsider(sbPtr); |
| | 3113 | } |
| | 3114 | } |
| | 3115 | } |
| | 3116 | |
| | 3117 | /*Queen climbing out of the airlock?*/ |
| | 3118 | if(queenStatusPointer->QueenState == QBS_ClimbingOutOfAirlock && queenStatusPointer->current_move != QM_Climbing) |
| | 3119 | { |
| | 3120 | QueenCalculateTargetInfo(sbPtr); |
| | 3121 | |
| | 3122 | if((dynPtr->Position.vx-AirlockMinX) < 2800) |
| | 3123 | { |
| | 3124 | //queen has hit the end wall , so start climbing |
| | 3125 | queenStatusPointer->current_move = QM_Climbing; |
| | 3126 | queenStatusPointer->moveTimer = 0; |
| | 3127 | } |
| | 3128 | } |
| | 3129 | } |
| | 3130 | |
| | 3131 | if(ConsiderJumpingForThisObject) |
| | 3132 | ConsiderJumping = 1; |
| | 3133 | |
| | 3134 | nextReport = nextReport->NextCollisionReportPtr; |
| | 3135 | } |
| | 3136 | } |
| | 3137 | |
| | 3138 | //if the queen is approaching the player in the locker |
| | 3139 | //ignore obstacles to allow the quuen to get to the player |
| | 3140 | |
| | 3141 | if(PlayerInLocker && !queenStatusPointer->TempTarget && queenStatusPointer->QueenTargetSB == PlayerStatus.sbptr) |
| | 3142 | { |
| | 3143 | QueenCalculateTargetInfo(sbPtr); |
| | 3144 | |
| | 3145 | if(queenStatusPointer->TargetDistance < 12000) |
| | 3146 | ignore_obstacles = 1; |
| | 3147 | } |
| | 3148 | |
| | 3149 | /*If the queen is trying to get out of the airlock , then we don't want to deviate because of walls getting in the way*/ |
| | 3150 | |
| | 3151 | if(queenStatusPointer->QueenState == QBS_ClimbingOutOfAirlock) |
| | 3152 | ignore_obstacles = 1; |
| | 3153 | |
| | 3154 | //check for nearby obstacles , and decide whether to jump. |
| | 3155 | if(!ignore_obstacles) |
| | 3156 | { |
| | 3157 | VECTORCH direction; |
| | 3158 | VECTORCH position = sbPtr->DisplayBlock->ObWorld; |
| | 3159 | |
| | 3160 | QueenCalculateTargetInfo(sbPtr); |
| | 3161 | |
| | 3162 | direction.vx = dynPtr->OrientMat.mat31; |
| | 3163 | direction.vy = 0; |
| | 3164 | direction.vz = dynPtr->OrientMat.mat33; |
| | 3165 | Normalise(&direction); |
| | 3166 | |
| | 3167 | //only bother to think of jumping if the queen is facing her target |
| | 3168 | |
| | 3169 | if(queenStatusPointer->TargetDirection.vz > (queenStatusPointer->TargetDirection.vx*2) && |
| | 3170 | queenStatusPointer->TargetDirection.vz > -(queenStatusPointer->TargetDirection.vx*2)) |
| | 3171 | { |
| | 3172 | int left_dist,centre_dist,right_dist; |
| | 3173 | VECTORCH left_point,centre_point,right_point; |
| | 3174 | int distance; |
| | 3175 | |
| | 3176 | //do several line of sight tests one metre above ground , in front of queen. |
| | 3177 | //if there is nothing near by , then queen should be able to jump over |
| | 3178 | |
| | 3179 | position.vy -= 1000; |
| | 3180 | |
| | 3181 | FindPolygonInLineOfSight(&queenStatusPointer->VectToTarget, &position, 1, sbPtr->DisplayBlock); |
| | 3182 | centre_dist = LOS_Lambda; |
| | 3183 | centre_point = LOS_Point; |
| | 3184 | |
| | 3185 | if(LOS_ObjectHitPtr && LOS_ObjectHitPtr->ObStrategyBlock) |
| | 3186 | { |
| | 3187 | if(LOS_ObjectHitPtr->ObStrategyBlock->type == I_BehaviourInanimateObject || |
| | 3188 | LOS_ObjectHitPtr->ObStrategyBlock->type == I_BehaviourTrackObject || |
| | 3189 | LOS_ObjectHitPtr == PlayerStatus.DisplayBlock) |
| | 3190 | { |
| | 3191 | //not an obstacle |
| | 3192 | centre_dist = 1000000; |
| | 3193 | } |
| | 3194 | } |
| | 3195 | |
| | 3196 | //check on the right |
| | 3197 | position.vx += dynPtr->OrientMat.mat11/32; |
| | 3198 | position.vy += dynPtr->OrientMat.mat12/32; |
| | 3199 | position.vz += dynPtr->OrientMat.mat13/32; |
| | 3200 | |
| | 3201 | FindPolygonInLineOfSight(&queenStatusPointer->VectToTarget, &position, 1, sbPtr->DisplayBlock); |
| | 3202 | right_dist = LOS_Lambda; |
| | 3203 | right_point = LOS_Point; |
| | 3204 | |
| | 3205 | if(LOS_ObjectHitPtr && LOS_ObjectHitPtr->ObStrategyBlock) |
| | 3206 | { |
| | 3207 | if(LOS_ObjectHitPtr->ObStrategyBlock->type == I_BehaviourInanimateObject || |
| | 3208 | LOS_ObjectHitPtr->ObStrategyBlock->type == I_BehaviourTrackObject || |
| | 3209 | LOS_ObjectHitPtr == PlayerStatus.DisplayBlock) |
| | 3210 | { |
| | 3211 | //not an obstacle |
| | 3212 | right_dist = 1000000; |
| | 3213 | } |
| | 3214 | } |
| | 3215 | |
| | 3216 | //check on the left |
| | 3217 | position.vx -= dynPtr->OrientMat.mat11/16; |
| | 3218 | position.vy -= dynPtr->OrientMat.mat12/16; |
| | 3219 | position.vz -= dynPtr->OrientMat.mat13/16; |
| | 3220 | |
| | 3221 | FindPolygonInLineOfSight(&queenStatusPointer->VectToTarget, &position, 1, sbPtr->DisplayBlock); |
| | 3222 | left_dist = LOS_Lambda; |
| | 3223 | left_point = LOS_Point; |
| | 3224 | |
| | 3225 | if(LOS_ObjectHitPtr && LOS_ObjectHitPtr->ObStrategyBlock) |
| | 3226 | { |
| | 3227 | if(LOS_ObjectHitPtr->ObStrategyBlock->type == I_BehaviourInanimateObject || |
| | 3228 | LOS_ObjectHitPtr->ObStrategyBlock->type == I_BehaviourTrackObject || |
| | 3229 | LOS_ObjectHitPtr == PlayerStatus.DisplayBlock) |
| | 3230 | { |
| | 3231 | //not an obstacle |
| | 3232 | left_dist = 1000000; |
| | 3233 | } |
| | 3234 | } |
| | 3235 | |
| | 3236 | distance = queenStatusPointer->TargetDistance; |
| | 3237 | |
| | 3238 | if(distance > 10000) |
| | 3239 | distance = 10000; |
| | 3240 | |
| | 3241 | if(right_dist < distance || centre_dist < distance || left_dist < distance) |
| | 3242 | { |
| | 3243 | if(centre_dist < left_dist && centre_dist < right_dist) |
| | 3244 | { |
| | 3245 | queenStatusPointer->TargetPos = centre_point; |
| | 3246 | } |
| | 3247 | else if(right_dist < left_dist) |
| | 3248 | { |
| | 3249 | queenStatusPointer->TargetPos = right_point; |
| | 3250 | } |
| | 3251 | else |
| | 3252 | { |
| | 3253 | queenStatusPointer->TargetPos = left_point; |
| | 3254 | } |
| | 3255 | /* |
| | 3256 | if(right_dist < left_dist) |
| | 3257 | { |
| | 3258 | queenStatusPointer->TargetPos.vx -= dynPtr->OrientMat.mat11/8; |
| | 3259 | queenStatusPointer->TargetPos.vz -= dynPtr->OrientMat.mat13/8; |
| | 3260 | } |
| | 3261 | else |
| | 3262 | { |
| | 3263 | queenStatusPointer->TargetPos.vx += dynPtr->OrientMat.mat11/8; |
| | 3264 | queenStatusPointer->TargetPos.vz += dynPtr->OrientMat.mat13/8; |
| | 3265 | } |
| | 3266 | |
| | 3267 | queenStatusPointer->TempTarget = 1; |
| | 3268 | queenStatusPointer->TempTargetTimer = 6*ONE_FIXED; |
| | 3269 | queenStatusPointer->TargetInfoValid = 0; |
| | 3270 | */ |
| | 3271 | } |
| | 3272 | else if(ConsiderJumping) |
| | 3273 | { |
| | 3274 | JumpDesired = 1; |
| | 3275 | } |
| | 3276 | } |
| | 3277 | } |
| | 3278 | } |
| | 3279 | |
| | 3280 | if(queenStatusPointer->QueenState == QBS_GoingForObject) |
| | 3281 | { |
| | 3282 | //if the queen is close enought to the object she is going for |
| | 3283 | //pick it up even without a collision |
| | 3284 | QueenCalculateTargetInfo(sbPtr); |
| | 3285 | |
| | 3286 | if(queenStatusPointer->TargetDistance < 1000) |
| | 3287 | QueenPickupTargetObject(sbPtr); |
| | 3288 | } |
| | 3289 | |
| | 3290 | /*---------------------------------------------------** |
| | 3291 | ** consider if queen should change her current plan ** |
| | 3292 | **---------------------------------------------------*/ |
| | 3293 | |
| | 3294 | switch(queenStatusPointer->QueenState) |
| | 3295 | { |
| | 3296 | case QBS_Reconsider: |
| | 3297 | { |
| | 3298 | //find closest object that is on the ground |
| | 3299 | int closest = -1; |
| | 3300 | int DistanceToObject = 1000000000; |
| | 3301 | int i; |
| | 3302 | |
| | 3303 | //printf("Queen Reconsider\n"); |
| | 3304 | if(queenStatusPointer->PlayingHitDelta) |
| | 3305 | break; |
| | 3306 | |
| | 3307 | if(UpperAirlockDoorOpen && !LowerAirlockDoorOpen) |
| | 3308 | { |
| | 3309 | //has the queen fallen into the airlock |
| | 3310 | if(ObjectIsInAirlock(sbPtr)) |
| | 3311 | { |
| | 3312 | //the queen is in the airlock |
| | 3313 | if(ObjectIsInAirlock(PlayerStatus.sbptr)) |
| | 3314 | { |
| | 3315 | //player is in the airlock with the queen |
| | 3316 | //splat him |
| | 3317 | queenStatusPointer->QueenState = QBS_Engagement; |
| | 3318 | queenStatusPointer->QueenTargetSB = PlayerStatus.sbptr; |
| | 3319 | queenStatusPointer->TargetPos = queenStatusPointer->QueenTargetSB->DynPtr->Position; |
| | 3320 | } |
| | 3321 | else |
| | 3322 | { |
| | 3323 | //go into get out of airlock mode in that case |
| | 3324 | queenStatusPointer->QueenState = QBS_ClimbingOutOfAirlock; |
| | 3325 | queenStatusPointer->TempTarget = 1; |
| | 3326 | queenStatusPointer->TempTargetTimer = 50*ONE_FIXED; |
| | 3327 | queenStatusPointer->TargetPos.vx = AirlockMinX-6000; |
| | 3328 | queenStatusPointer->TargetPos.vz = AirlockCentreZ; |
| | 3329 | queenStatusPointer->BeenInAirlock = 1; |
| | 3330 | } |
| | 3331 | queenStatusPointer->QueenStateTimer = 0; |
| | 3332 | queenStatusPointer->TargetInfoValid = 0; |
| | 3333 | break; |
| | 3334 | } |
| | 3335 | } |
| | 3336 | |
| | 3337 | for(i=0; i < NumQueenObjects;i++) |
| | 3338 | { |
| | 3339 | if(!QueenObjectList[i]->destroyed_but_preserved) |
| | 3340 | { |
| | 3341 | if(QueenObjectList[i]->DynPtr->IsInContactWithFloor) |
| | 3342 | { |
| | 3343 | VECTORCH pos = QueenObjectList[i]->DynPtr->Position; |
| | 3344 | |
| | 3345 | pos.vx -= dynPtr->Position.vx; |
| | 3346 | pos.vy -= dynPtr->Position.vy; |
| | 3347 | pos.vz -= dynPtr->Position.vz; |
| | 3348 | |
| | 3349 | if(AVP_ENVIRONMENT_TYRARGOHANGAR == AvP.level) |
| | 3350 | { |
| | 3351 | //In battle , the objects near the egg sack are hard for the queen to get to. |
| | 3352 | //So best ignore them. |
| | 3353 | if(QueenObjectList[i]->DynPtr->Position.vz > 0) |
| | 3354 | continue; |
| | 3355 | } |
| | 3356 | |
| | 3357 | //if the y distance is more than 1500 , the object is probably inaccesible |
| | 3358 | if(pos.vy <= 1500) |
| | 3359 | { |
| | 3360 | int dist = Approximate3dMagnitude(&pos); |
| | 3361 | |
| | 3362 | if(dist < DistanceToObject) |
| | 3363 | { |
| | 3364 | DistanceToObject = dist; |
| | 3365 | closest = i; |
| | 3366 | } |
| | 3367 | } |
| | 3368 | } |
| | 3369 | } |
| | 3370 | } |
| | 3371 | |
| | 3372 | { |
| | 3373 | int player_value = MUL_FIXED(FastRandom() & 0xffff, DistanceToPlayer / queenStatusPointer->QueenPlayerBias); |
| | 3374 | int object_value = MUL_FIXED(FastRandom() & 0xffff, DistanceToObject / queenStatusPointer->QueenObjectBias); |
| | 3375 | |
| | 3376 | if(object_value < player_value && closest != -1 && !PlayerInTrench) |
| | 3377 | { |
| | 3378 | //go for the object |
| | 3379 | queenStatusPointer->QueenState = QBS_GoingForObject; |
| | 3380 | queenStatusPointer->CurrentQueenObject = closest; |
| | 3381 | queenStatusPointer->QueenTargetSB = QueenObjectList[queenStatusPointer->CurrentQueenObject]; |
| | 3382 | |
| | 3383 | if(AVP_ENVIRONMENT_TYRARGOHANGAR == AvP.level) |
| | 3384 | { |
| | 3385 | queenStatusPointer->QueenPlayerBias++; |
| | 3386 | } |
| | 3387 | else |
| | 3388 | { |
| | 3389 | //int he predator version , make it more likely for the queen to go after the player |
| | 3390 | queenStatusPointer->QueenPlayerBias += 3; |
| | 3391 | } |
| | 3392 | |
| | 3393 | queenStatusPointer->QueenObjectBias--; |
| | 3394 | |
| | 3395 | if(!queenStatusPointer->QueenObjectBias) |
| | 3396 | queenStatusPointer->QueenObjectBias = 1; |
| | 3397 | } |
| | 3398 | else |
| | 3399 | { |
| | 3400 | //go for the player |
| | 3401 | queenStatusPointer->QueenState = QBS_Engagement; |
| | 3402 | queenStatusPointer->CurrentQueenObject = -1; |
| | 3403 | queenStatusPointer->QueenTargetSB = PlayerStatus.sbptr; |
| | 3404 | queenStatusPointer->QueenObjectBias++; |
| | 3405 | queenStatusPointer->QueenPlayerBias--; |
| | 3406 | |
| | 3407 | if(!queenStatusPointer->QueenPlayerBias) |
| | 3408 | queenStatusPointer->QueenPlayerBias = 1; |
| | 3409 | } |
| | 3410 | |
| | 3411 | queenStatusPointer->TargetPos = queenStatusPointer->QueenTargetSB->DynPtr->Position; |
| | 3412 | queenStatusPointer->QueenStateTimer = 0; |
| | 3413 | queenStatusPointer->TargetInfoValid = 0; |
| | 3414 | } |
| | 3415 | } |
| | 3416 | break; |
| | 3417 | case QBS_Engagement: |
| | 3418 | { |
| | 3419 | if(queenStatusPointer->QueenStateTimer > 10*ONE_FIXED && DistanceToPlayer > 4000) |
| | 3420 | { |
| | 3421 | queenStatusPointer->QueenState = QBS_Reconsider; |
| | 3422 | queenStatusPointer->QueenStateTimer = 0; |
| | 3423 | } |
| | 3424 | } |
| | 3425 | //printf("Queen Engagement\n"); |
| | 3426 | break; |
| | 3427 | case QBS_GoingForObject: |
| | 3428 | { |
| | 3429 | if(queenStatusPointer->QueenStateTimer > 15*ONE_FIXED) |
| | 3430 | QueenForceReconsider(sbPtr); |
| | 3431 | } |
| | 3432 | //printf("Queen Going for object\n"); |
| | 3433 | break; |
| | 3434 | case QBS_CarryingObject : |
| | 3435 | { |
| | 3436 | if(queenStatusPointer->QueenStateTimer > 15*ONE_FIXED) |
| | 3437 | QueenForceReconsider(sbPtr); |
| | 3438 | } |
| | 3439 | //printf("Queen Carrying object\n"); |
| | 3440 | break; |
| | 3441 | case QBS_ClimbingOutOfAirlock : |
| | 3442 | printf("Queen climbing out of airlock\n"); |
| | 3443 | break; |
| | 3444 | default: ; |
| | 3445 | } |
| | 3446 | //printf("Queen Bias - Object %d Player %d\n", queenStatusPointer->QueenObjectBias, queenStatusPointer->QueenPlayerBias); |
| | 3447 | //printf("Queen Health %d\n",sbPtr->DamageBlock.Health>>16); |
| | 3448 | |
| | 3449 | /*--------------------** |
| | 3450 | ** Can queen attack? ** |
| | 3451 | **--------------------*/ |
| | 3452 | |
| | 3453 | //queen must be in engagement mode , and not avoiding stuff |
| | 3454 | if(!queenStatusPointer->TempTarget && queenStatusPointer->QueenState == QBS_Engagement) |
| | 3455 | { |
| | 3456 | //player must be close enough and in front 90 degree arc |
| | 3457 | QueenCalculateTargetInfo(sbPtr); |
| | 3458 | |
| | 3459 | if (queenStatusPointer->TargetDistance < 4000 || |
| | 3460 | (queenStatusPointer->TargetDistance < 8000 && queenStatusPointer->TargetRelSpeed < 1000)) |
| | 3461 | { |
| | 3462 | switch(queenStatusPointer->current_move) |
| | 3463 | { |
| | 3464 | case QM_Standby: |
| | 3465 | case QM_Close: |
| | 3466 | case QM_Charge: |
| | 3467 | { |
| | 3468 | |
| | 3469 | if(queenStatusPointer->TargetDirection.vz > queenStatusPointer->TargetDirection.vx && |
| | 3470 | queenStatusPointer->TargetDirection.vz > -queenStatusPointer->TargetDirection.vx) |
| | 3471 | { |
| | 3472 | int x = queenStatusPointer->TargetDirection.vx; |
| | 3473 | x += (FastRandom() % 80000); |
| | 3474 | x -= 40000; |
| | 3475 | |
| | 3476 | if (x > 0) |
| | 3477 | { |
| | 3478 | if(PlayerInTrench) |
| | 3479 | Queen_Do_Swipe(sbPtr,Queen_Swipe_Right_Low); |
| | 3480 | else |
| | 3481 | Queen_Do_Swipe(sbPtr,Queen_Swipe_Right); |
| | 3482 | } |
| | 3483 | else |
| | 3484 | { |
| | 3485 | if(PlayerInTrench) |
| | 3486 | Queen_Do_Swipe(sbPtr,Queen_Swipe_Left_Low); |
| | 3487 | else |
| | 3488 | Queen_Do_Swipe(sbPtr,Queen_Swipe_Left); |
| | 3489 | } |
| | 3490 | } |
| | 3491 | } |
| | 3492 | default: |
| | 3493 | break; |
| | 3494 | } |
| | 3495 | } |
| | 3496 | } |
| | 3497 | |
| | 3498 | /*------------------------------------------** |
| | 3499 | ** Decide if new movement state is required ** |
| | 3500 | **------------------------------------------*/ |
| | 3501 | |
| | 3502 | if(queenStatusPointer->QueenState == QBS_CarryingObject) |
| | 3503 | { |
| | 3504 | //Queen is lining up to throw object |
| | 3505 | QueenCalculateTargetInfo(sbPtr); |
| | 3506 | |
| | 3507 | if(queenStatusPointer->TargetDirection.vz > (queenStatusPointer->TargetDirection.vx*2) && |
| | 3508 | queenStatusPointer->TargetDirection.vz > -(queenStatusPointer->TargetDirection.vx*2) && !queenStatusPointer->TempTarget) |
| | 3509 | { |
| | 3510 | //Time to throw object at player. |
| | 3511 | VECTORCH impulse; |
| | 3512 | |
| | 3513 | if(CalculateTrajectory(&QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->Position, |
| | 3514 | &PlayerStatus.sbptr->DynPtr->Position, |
| | 3515 | &PlayerStatus.sbptr->DynPtr->LinVelocity, |
| | 3516 | QUEEN_THROWN_OBJECT_SPEED, |
| | 3517 | &impulse)) |
| | 3518 | { |
| | 3519 | //give the object an impulse ,and reinstate gravity |
| | 3520 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->LinImpulse = impulse; |
| | 3521 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->GravityOn = 1; |
| | 3522 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->OnlyCollideWithEnvironment = 0; |
| | 3523 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->OrientMat = IdentityMatrix; |
| | 3524 | //queen will need to choose a new objective |
| | 3525 | queenStatusPointer->QueenState = QBS_Reconsider; |
| | 3526 | queenStatusPointer->QueenTargetSB = PlayerStatus.sbptr; |
| | 3527 | queenStatusPointer->TargetInfoValid = 0; |
| | 3528 | } |
| | 3529 | else |
| | 3530 | { |
| | 3531 | //continue heading for target |
| | 3532 | if(queenStatusPointer->current_move == QM_Standby) |
| | 3533 | queenStatusPointer->next_move = QM_Close; |
| | 3534 | } |
| | 3535 | } |
| | 3536 | else |
| | 3537 | { |
| | 3538 | //Queen needs to turn some more |
| | 3539 | if(queenStatusPointer->current_move == QM_Standby) |
| | 3540 | queenStatusPointer->next_move=QM_Close; |
| | 3541 | } |
| | 3542 | } |
| | 3543 | //if in standby , need to choose a move |
| | 3544 | else if(queenStatusPointer->current_move == QM_Standby && queenStatusPointer->QueenState != QBS_Reconsider) |
| | 3545 | { |
| | 3546 | QueenCalculateTargetInfo(sbPtr); |
| | 3547 | //queen is heading towards object , or player |
| | 3548 | |
| | 3549 | if(((queenStatusPointer->TargetDistance > 8000)||(queenStatusPointer->TargetDistance > 2000 && queenStatusPointer->TargetRelSpeed
> QUEEN_CLOSE_SPEED)) && |
| | 3550 | queenStatusPointer->TargetDirection.vz > queenStatusPointer->TargetDirection.vx && |
| | 3551 | queenStatusPointer->TargetDirection.vz > -queenStatusPointer->TargetDirection.vx) |
| | 3552 | { |
| | 3553 | queenStatusPointer->next_move = QM_Charge; |
| | 3554 | if(queenStatusPointer->QueenTargetSB == PlayerStatus.sbptr) |
| | 3555 | { |
| | 3556 | //going for player. possibility of butting player |
| | 3557 | //Nb. queen can't actually colide with player , if the player is in the locker area |
| | 3558 | |
| | 3559 | if((FastRandom()&0xffff) < (ONE_FIXED/2) && !PlayerInLocker) |
| | 3560 | queenStatusPointer->next_move = QM_ButtCharge; |
| | 3561 | } |
| | 3562 | |
| | 3563 | if(PlayerInTrench) |
| | 3564 | queenStatusPointer->next_move = QM_ComeToPoint; |
| | 3565 | } |
| | 3566 | else if (queenStatusPointer->TargetDistance > 3000 || queenStatusPointer->TargetRelSpeed > 0) |
| | 3567 | { |
| | 3568 | if(queenStatusPointer->QueenTargetSB == PlayerStatus.sbptr && !queenStatusPointer->TempTarget) |
| | 3569 | queenStatusPointer->next_move = QM_Close; |
| | 3570 | else |
| | 3571 | queenStatusPointer->next_move = QM_ComeToPoint; |
| | 3572 | } |
| | 3573 | else |
| | 3574 | { |
| | 3575 | if(queenStatusPointer->QueenState != QBS_ClimbingOutOfAirlock) |
| | 3576 | { |
| | 3577 | if(queenStatusPointer->TempTarget) |
| | 3578 | { |
| | 3579 | queenStatusPointer->TempTarget = 0; |
| | 3580 | queenStatusPointer->TargetInfoValid = 0; |
| | 3581 | } |
| | 3582 | } |
| | 3583 | |
| | 3584 | if(queenStatusPointer->QueenState == QBS_GoingForObject) |
| | 3585 | { |
| | 3586 | //have to keep going until queen hits object |
| | 3587 | queenStatusPointer->next_move = QM_Close; |
| | 3588 | } |
| | 3589 | else |
| | 3590 | { |
| | 3591 | //queen right next to target now , so wait |
| | 3592 | queenStatusPointer->next_move = QM_Standby; |
| | 3593 | //assuming queen is facing her target , that is. |
| | 3594 | |
| | 3595 | if(queenStatusPointer->TargetDirection.vz < queenStatusPointer->TargetDirection.vx*2 || |
| | 3596 | queenStatusPointer->TargetDirection.vz < -queenStatusPointer->TargetDirection.vx*2) |
| | 3597 | { |
| | 3598 | //queen isn't facing target , so she needs to continue closing after all |
| | 3599 | queenStatusPointer->next_move = QM_Close; |
| | 3600 | } |
| | 3601 | } |
| | 3602 | } |
| | 3603 | } |
| | 3604 | //printf("Queen target distance %d\n",queenStatusPointer->TargetDistance); |
| | 3605 | //printf("Queen target position %d : %d :
%d\n",queenStatusPointer->TargetPos.vx,queenStatusPointer->TargetPos.vy,queenStatusPointer->TargetPos.vz); |
| | 3606 | |
| | 3607 | QueenCheckForAvoidAirlock(sbPtr); |
| | 3608 | |
| | 3609 | if(queenStatusPointer->TempTarget) |
| | 3610 | { |
| | 3611 | QueenCalculateTargetInfo(sbPtr); |
| | 3612 | |
| | 3613 | if(queenStatusPointer->TargetDistance < 4000) |
| | 3614 | { |
| | 3615 | queenStatusPointer->TempTarget = 0; |
| | 3616 | queenStatusPointer->TargetInfoValid = 0; |
| | 3617 | } |
| | 3618 | |
| | 3619 | queenStatusPointer->TempTargetTimer -= NormalFrameTime; |
| | 3620 | |
| | 3621 | if(queenStatusPointer->TempTargetTimer < 0) |
| | 3622 | { |
| | 3623 | queenStatusPointer->TempTarget = 0; |
| | 3624 | queenStatusPointer->TargetInfoValid = 0; |
| | 3625 | } |
| | 3626 | } |
| | 3627 | |
| | 3628 | /*-------------------------------------------------------------------** |
| | 3629 | ** check for redirecting the queen , if the player is in the locker ** |
| | 3630 | **-------------------------------------------------------------------*/ |
| | 3631 | |
| | 3632 | if(!queenStatusPointer->TempTarget && queenStatusPointer->QueenTargetSB == PlayerStatus.sbptr && PlayerInLocker) |
| | 3633 | { |
| | 3634 | //is the queen in line with the locker area? |
| | 3635 | if((dynPtr->Position.vz-HangarLockerMaxZ)*2 > dynPtr->Position.vx-HangarLockerMaxX || |
| | 3636 | (HangarLockerMinZ-dynPtr->Position.vz)*2 > dynPtr->Position.vx-HangarLockerMaxX) |
| | 3637 | { |
| | 3638 | //nope |
| | 3639 | queenStatusPointer->TempTarget = 1; |
| | 3640 | queenStatusPointer->TempTargetTimer = 2*ONE_FIXED; |
| | 3641 | queenStatusPointer->TargetInfoValid = 0; |
| | 3642 | |
| | 3643 | //move the queen so that she is lined up with the locker |
| | 3644 | queenStatusPointer->TargetPos.vx = dynPtr->Position.vx; |
| | 3645 | queenStatusPointer->TargetPos.vy = dynPtr->Position.vy; |
| | 3646 | queenStatusPointer->TargetPos.vz = HangarLockerCentreZ; |
| | 3647 | } |
| | 3648 | } |
| | 3649 | |
| | 3650 | if(queenStatusPointer->QueenTauntTimer > 0) |
| | 3651 | { |
| | 3652 | queenStatusPointer->QueenTauntTimer -= NormalFrameTime; |
| | 3653 | |
| | 3654 | if(queenStatusPointer->QueenTargetSB == PlayerStatus.sbptr && DistanceToPlayer > 10000) |
| | 3655 | { |
| | 3656 | QueenCalculateTargetInfo(sbPtr); |
| | 3657 | |
| | 3658 | if(queenStatusPointer->TargetDirection.vz > queenStatusPointer->TargetDirection.vx && |
| | 3659 | queenStatusPointer->TargetDirection.vz > -queenStatusPointer->TargetDirection.vx) |
| | 3660 | { |
| | 3661 | queenStatusPointer->QueenTauntTimer = 0; |
| | 3662 | //Queen has recently hit player , and is facing player time to taunt |
| | 3663 | queenStatusPointer->next_move = QM_Taunt; |
| | 3664 | } |
| | 3665 | } |
| | 3666 | } |
| | 3667 | |
| | 3668 | /*-------------------------------** |
| | 3669 | ** Flamethrower avoidance stuff ** |
| | 3670 | **-------------------------------*/ |
| | 3671 | |
| | 3672 | //only if queen is trying to attack the player in close combat |
| | 3673 | if(queenStatusPointer->QueenState == QBS_Engagement) |
| | 3674 | { |
| | 3675 | if(queenStatusPointer->QueenFireTimer > QueenMinimumFireTime) |
| | 3676 | { |
| | 3677 | /*stop and hiss for a bit*/ |
| | 3678 | switch(queenStatusPointer->current_move) |
| | 3679 | { |
| | 3680 | case QM_Standby: |
| | 3681 | case QM_ComeToPoint: |
| | 3682 | case QM_ButtCharge: |
| | 3683 | case QM_Charge: |
| | 3684 | case QM_Close: |
| | 3685 | queenStatusPointer->current_move = QM_Hiss; |
| | 3686 | queenStatusPointer->moveTimer = 0; |
| | 3687 | default: |
| | 3688 | break; |
| | 3689 | } |
| | 3690 | } |
| | 3691 | else if(!queenStatusPointer->QueenFireTimer) |
| | 3692 | { |
| | 3693 | if(queenStatusPointer->next_move == QM_Hiss) |
| | 3694 | queenStatusPointer->next_move = QM_Standby; |
| | 3695 | |
| | 3696 | if(queenStatusPointer->current_move == QM_Hiss) |
| | 3697 | { |
| | 3698 | queenStatusPointer->moveTimer = 0; |
| | 3699 | queenStatusPointer->current_move = queenStatusPointer->next_move; |
| | 3700 | queenStatusPointer->next_move = QM_Standby; |
| | 3701 | } |
| | 3702 | } |
| | 3703 | |
| | 3704 | //update the timer |
| | 3705 | if(TargetIsFiringFlamethrowerAtQueen(sbPtr)) |
| | 3706 | { |
| | 3707 | queenStatusPointer->QueenFireTimer+=NormalFrameTime; |
| | 3708 | |
| | 3709 | if(queenStatusPointer->QueenFireTimer > 2*ONE_FIXED) |
| | 3710 | queenStatusPointer->QueenFireTimer = 2*ONE_FIXED; |
| | 3711 | } |
| | 3712 | else |
| | 3713 | { |
| | 3714 | queenStatusPointer->QueenFireTimer -= NormalFrameTime; |
| | 3715 | |
| | 3716 | if(queenStatusPointer->QueenFireTimer < 0) |
| | 3717 | queenStatusPointer->QueenFireTimer = 0; |
| | 3718 | } |
| | 3719 | } |
| | 3720 | else |
| | 3721 | { |
| | 3722 | //make sure queen isn't hissing |
| | 3723 | if(queenStatusPointer->next_move == QM_Hiss) |
| | 3724 | queenStatusPointer->next_move = QM_Standby; |
| | 3725 | |
| | 3726 | if(queenStatusPointer->current_move == QM_Hiss) |
| | 3727 | { |
| | 3728 | queenStatusPointer->moveTimer = 0; |
| | 3729 | queenStatusPointer->current_move = queenStatusPointer->next_move; |
| | 3730 | queenStatusPointer->next_move = QM_Standby; |
| | 3731 | } |
| | 3732 | |
| | 3733 | queenStatusPointer->QueenFireTimer = 0; |
| | 3734 | } |
| | 3735 | |
| | 3736 | if(!queenStatusPointer->TempTarget) |
| | 3737 | { |
| | 3738 | //update target location |
| | 3739 | queenStatusPointer->TargetPos = queenStatusPointer->QueenTargetSB->DynPtr->Position; |
| | 3740 | } |
| | 3741 | |
| | 3742 | /*---------------------------** |
| | 3743 | ** Handle Queeen's movement ** |
| | 3744 | **---------------------------*/ |
| | 3745 | |
| | 3746 | dynPtr->Displacement.vx = dynPtr->Displacement.vy = dynPtr->Displacement.vz = 0; |
| | 3747 | |
| | 3748 | if (queenStatusPointer->QueenState != QBS_Dead) |
| | 3749 | { |
| | 3750 | switch (queenStatusPointer->current_move) |
| | 3751 | { |
| | 3752 | case QM_Standby: |
| | 3753 | { |
| | 3754 | //printf("Queen State: Standby\n"); |
| | 3755 | |
| | 3756 | if (queenStatusPointer->next_move == QM_Standby || queenStatusPointer->PlayingHitDelta) |
| | 3757 | { |
| | 3758 | /* Do not much. */ |
| | 3759 | QueenMove_Standby(sbPtr); |
| | 3760 | } |
| | 3761 | else |
| | 3762 | { |
| | 3763 | queenStatusPointer->current_move = queenStatusPointer->next_move; |
| | 3764 | queenStatusPointer->next_move = QM_Standby; |
| | 3765 | queenStatusPointer->moveTimer = 0; |
| | 3766 | } |
| | 3767 | |
| | 3768 | } |
| | 3769 | break; |
| | 3770 | case QM_Stun: |
| | 3771 | { |
| | 3772 | //printf("Queen State: Stunned\n"); |
| | 3773 | //don't do anything |
| | 3774 | sbPtr->DynPtr->LinVelocity.vx = sbPtr->DynPtr->LinVelocity.vy = sbPtr->DynPtr->LinVelocity.vz = 0; |
| | 3775 | } |
| | 3776 | break; |
| | 3777 | case QM_StepForward: |
| | 3778 | { |
| | 3779 | //printf("Queen State: Step Forward\n"); |
| | 3780 | /* Move function. */ |
| | 3781 | // QueenMove_StepForward(sbPtr); |
| | 3782 | } |
| | 3783 | break; |
| | 3784 | case QM_StepBack: |
| | 3785 | { |
| | 3786 | //printf("Queen State: Step Back\n"); |
| | 3787 | /* Move function. */ |
| | 3788 | QueenMove_StepBack(sbPtr); |
| | 3789 | } |
| | 3790 | break; |
| | 3791 | case QM_TurnLeft: |
| | 3792 | { |
| | 3793 | //printf("Queen State: Turn Left\n"); |
| | 3794 | /* Move function. */ |
| | 3795 | } |
| | 3796 | break; |
| | 3797 | case QM_TurnRight: |
| | 3798 | { |
| | 3799 | //printf("Queen State: Turn Right\n"); |
| | 3800 | /* Move function. */ |
| | 3801 | } |
| | 3802 | break; |
| | 3803 | case QM_ComeToPoint: |
| | 3804 | { |
| | 3805 | //printf("Queen State: Come To Point\n"); |
| | 3806 | /* Move function. */ |
| | 3807 | |
| | 3808 | if(JumpDesired) |
| | 3809 | { |
| | 3810 | printf("Jumping\n"); |
| | 3811 | sbPtr->DynPtr->LinImpulse.vy -= 10000; |
| | 3812 | queenStatusPointer->next_move = QM_Standby; |
| | 3813 | queenStatusPointer->current_move = QM_Jump; |
| | 3814 | } |
| | 3815 | else |
| | 3816 | { |
| | 3817 | QueenMove_Walk(sbPtr); |
| | 3818 | } |
| | 3819 | |
| | 3820 | } |
| | 3821 | break; |
| | 3822 | case QM_Taunt: |
| | 3823 | { |
| | 3824 | //printf("Queen State: Taunt\n"); |
| | 3825 | /* Move function. */ |
| | 3826 | QueenMove_Taunt(sbPtr); |
| | 3827 | } |
| | 3828 | break; |
| | 3829 | case QM_Hiss: |
| | 3830 | { |
| | 3831 | //printf("Queen State: Hiss\n"); |
| | 3832 | /* Move function. */ |
| | 3833 | QueenMove_Hiss(sbPtr); |
| | 3834 | } |
| | 3835 | break; |
| | 3836 | case QM_LeftSwipe: |
| | 3837 | { |
| | 3838 | //printf("Queen State: Left Swipe\n"); |
| | 3839 | // QueenMove_LeftSwipe(sbPtr); |
| | 3840 | } |
| | 3841 | break; |
| | 3842 | case QM_RightSwipe: |
| | 3843 | { |
| | 3844 | //printf("Queen State: Right Swipe\n"); |
| | 3845 | // QueenMove_RightSwipe(sbPtr); |
| | 3846 | } |
| | 3847 | break; |
| | 3848 | case QM_ButtAttack: |
| | 3849 | { |
| | 3850 | //printf("Queen State: Butt attack\n"); |
| | 3851 | QueenMove_ButtAttack(sbPtr); |
| | 3852 | } |
| | 3853 | break; |
| | 3854 | case QM_Charge: |
| | 3855 | { |
| | 3856 | //printf("Queen State: Charging\n"); |
| | 3857 | /* Move function. */ |
| | 3858 | |
| | 3859 | if(JumpDesired) |
| | 3860 | { |
| | 3861 | //printf("Jumping\n"); |
| | 3862 | sbPtr->DynPtr->LinImpulse.vy-=10000; |
| | 3863 | queenStatusPointer->next_move=QM_Standby; |
| | 3864 | queenStatusPointer->current_move=QM_Jump; |
| | 3865 | } |
| | 3866 | else |
| | 3867 | { |
| | 3868 | QueenMove_Charge(sbPtr); |
| | 3869 | } |
| | 3870 | |
| | 3871 | } |
| | 3872 | break; |
| | 3873 | case QM_Close: |
| | 3874 | { |
| | 3875 | //printf("Queen State: Closing\n"); |
| | 3876 | /* Move function. */ |
| | 3877 | |
| | 3878 | if(JumpDesired) |
| | 3879 | { |
| | 3880 | printf("Jumping\n"); |
| | 3881 | sbPtr->DynPtr->LinImpulse.vy -= 10000; |
| | 3882 | queenStatusPointer->next_move = QM_Standby; |
| | 3883 | queenStatusPointer->current_move = QM_Jump; |
| | 3884 | } |
| | 3885 | else |
| | 3886 | { |
| | 3887 | QueenMove_Close(sbPtr); |
| | 3888 | } |
| | 3889 | } |
| | 3890 | break; |
| | 3891 | case QM_ButtCharge: |
| | 3892 | { |
| | 3893 | //printf("Queen State: Butt charging\n"); |
| | 3894 | /* Move function. */ |
| | 3895 | |
| | 3896 | if(JumpDesired) |
| | 3897 | { |
| | 3898 | printf("Jumping\n"); |
| | 3899 | sbPtr->DynPtr->LinImpulse.vy -= 10000; |
| | 3900 | queenStatusPointer->next_move = QM_Standby; |
| | 3901 | queenStatusPointer->current_move = QM_Jump; |
| | 3902 | } |
| | 3903 | else |
| | 3904 | { |
| | 3905 | QueenMove_ButtCharge(sbPtr); |
| | 3906 | } |
| | 3907 | } |
| | 3908 | break; |
| | 3909 | case QM_Jump: |
| | 3910 | { |
| | 3911 | //printf("Queen State: Jumping\n"); |
| | 3912 | //stay in jump mode until queen hits the floor again |
| | 3913 | |
| | 3914 | if(!dynPtr->IsInContactWithFloor) |
| | 3915 | { |
| | 3916 | sbPtr->DynPtr->LinVelocity.vx = sbPtr->DynPtr->OrientMat.mat31/10; |
| | 3917 | sbPtr->DynPtr->LinVelocity.vy = 0; |
| | 3918 | sbPtr->DynPtr->LinVelocity.vz = sbPtr->DynPtr->OrientMat.mat33/10; |
| | 3919 | } |
| | 3920 | else |
| | 3921 | { |
| | 3922 | queenStatusPointer->current_move = queenStatusPointer->next_move; |
| | 3923 | queenStatusPointer->next_move = QM_Standby; |
| | 3924 | queenStatusPointer->moveTimer = 0; |
| | 3925 | } |
| | 3926 | } |
| | 3927 | break; |
| | 3928 | case QM_Climbing: |
| | 3929 | { |
| | 3930 | //printf("Queen State: Climbing\n"); |
| | 3931 | sbPtr->DynPtr->LinVelocity.vx = 0; |
| | 3932 | sbPtr->DynPtr->LinVelocity.vy = 0; |
| | 3933 | sbPtr->DynPtr->LinVelocity.vz = 0; |
| | 3934 | QueenMove_Climb(sbPtr); |
| | 3935 | } |
| | 3936 | break; |
| | 3937 | default: |
| | 3938 | { |
| | 3939 | assert(0); |
| | 3940 | return; |
| | 3941 | } |
| | 3942 | } |
| | 3943 | |
| | 3944 | HModel_Regen(&queenStatusPointer->HModelController,(20*ONE_FIXED)); |
| | 3945 | } |
| | 3946 | |
| | 3947 | queenStatusPointer->LastVelocity = dynPtr->LinVelocity; |
| | 3948 | |
| | 3949 | /*----------------------------------** |
| | 3950 | ** Update object queen is carrying ** |
| | 3951 | **----------------------------------*/ |
| | 3952 | |
| | 3953 | if(queenStatusPointer->QueenState == QBS_CarryingObject) |
| | 3954 | { |
| | 3955 | ProveHModel(sbPtr->DisplayBlock->HModelControlBlock,sbPtr->DisplayBlock); |
| | 3956 | |
| | 3957 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->Position = queenStatusPointer->QueenRightHand->World_Offset; |
| | 3958 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->PrevPosition = queenStatusPointer->QueenRightHand->World_Offset; |
| | 3959 | QueenObjectList[queenStatusPointer->CurrentQueenObject]->DynPtr->OrientMat = queenStatusPointer->QueenRightHand->SecMat; |
| | 3960 | } |
| | 3961 | |
| | 3962 | sbPtr->DamageBlock.IsOnFire = 0; |
| | 3963 | /* That would be silly. */ |
| | 3964 | |
| | 3965 | /*----------------------------------------------------------------------------------------** |
| | 3966 | ** Monitor the queen's objects , and check for any high speed collisions with the player ** |
| | 3967 | **----------------------------------------------------------------------------------------*/ |
| | 3968 | { |
| | 3969 | int i=0; |
| | 3970 | for(; i < NumQueenObjects; i++) |
| | 3971 | { |
| | 3972 | if(!QueenObjectList[i]->destroyed_but_preserved) |
| | 3973 | { |
| | 3974 | int doneBounceNoise = 0; |
| | 3975 | COLLISIONREPORT *nextReport = QueenObjectList[i]->DynPtr->CollisionReportPtr; |
| | 3976 | |
| | 3977 | while(nextReport) |
| | 3978 | { |
| | 3979 | int impulse = Approximate3dMagnitude(&QueenObjectList[i]->DynPtr->LinImpulse); |
| | 3980 | |
| | 3981 | if(impulse > 10000) |
| | 3982 | { |
| | 3983 | //object hit something while moving quickly , so play a bounce sound |
| | 3984 | if(!doneBounceNoise) |
| | 3985 | { |
| | 3986 | ThrownObjectBounceNoise(i,&nextReport->ObstaclePoint); |
| | 3987 | doneBounceNoise = 1; |
| | 3988 | } |
| | 3989 | |
| | 3990 | if(nextReport->ObstacleSBPtr) |
| | 3991 | { |
| | 3992 | if(nextReport->ObstacleSBPtr == PlayerStatus.sbptr || |
| | 3993 | nextReport->ObstacleSBPtr->type == I_BehaviourInanimateObject || |
| | 3994 | (nextReport->ObstacleSBPtr->name && !strcmp(nextReport->ObstacleSBPtr->name, "locker door"))) |
| | 3995 | { |
| | 3996 | //object has hit the player at speed. |
| | 3997 | |
| | 3998 | DAMAGE_PROFILE impact_damage = {0,0,0,0,0,0,0,0,0,0,0,AMMO_NONE}; |
| | 3999 | VECTORCH direction; |
| | 4000 | VECTORCH hit_object_direction; |
| | 4001 | int dotproduct; |
| | 4002 | |
| | 4003 | //adjust the object's position so it is ear the player |
| | 4004 | //back in the direction that it came from |
| | 4005 | |
| | 4006 | direction = QueenObjectList[i]->DynPtr->Position; |
| | 4007 | |
| | 4008 | direction.vx -= QueenObjectList[i]->DynPtr->PrevPosition.vx; |
| | 4009 | direction.vy -= QueenObjectList[i]->DynPtr->PrevPosition.vy; |
| | 4010 | direction.vz -= QueenObjectList[i]->DynPtr->PrevPosition.vz; |
| | 4011 | |
| | 4012 | if(direction.vx || direction.vy || direction.vz) |
| | 4013 | Normalise(&direction); |
| | 4014 | |
| | 4015 | hit_object_direction.vx = nextReport->ObstacleSBPtr->DynPtr->Position.vx -
nextReport->ObstacleSBPtr->DynPtr->PrevPosition.vx; |
| | 4016 | hit_object_direction.vy = nextReport->ObstacleSBPtr->DynPtr->Position.vy -
nextReport->ObstacleSBPtr->DynPtr->PrevPosition.vy; |
| | 4017 | hit_object_direction.vz = nextReport->ObstacleSBPtr->DynPtr->Position.vz -
nextReport->ObstacleSBPtr->DynPtr->PrevPosition.vz; |
| | 4018 | |
| | 4019 | if(hit_object_direction.vx || hit_object_direction.vy || hit_object_direction.vz) |
| | 4020 | Normalise(&hit_object_direction); |
| | 4021 | |
| | 4022 | dotproduct = DotProduct(&direction,&hit_object_direction); |
| | 4023 | |
| | 4024 | //damage the player |
| | 4025 | impact_damage.Impact = 40+MUL_FIXED(15,dotproduct); |
| | 4026 | CauseDamageToObject(nextReport->ObstacleSBPtr, &impact_damage, ONE_FIXED,NULL); |
| | 4027 | |
| | 4028 | //damage the thrown object as well (almost certainly destroying it) |
| | 4029 | impact_damage.Impact *= 10; |
| | 4030 | CauseDamageToObject(QueenObjectList[i], &impact_damage, ONE_FIXED,NULL); |
| | 4031 | |
| | 4032 | { |
| | 4033 | //knock the object back |
| | 4034 | VECTORCH* impulse; |
| | 4035 | impulse = &nextReport->ObstacleSBPtr->DynPtr->LinImpulse; |
| | 4036 | impulse->vx += direction.vx/4; |
| | 4037 | impulse->vz += direction.vz/4; |
| | 4038 | } |
| | 4039 | |
| | 4040 | QueenObjectList[i]->DynPtr->Position.vx=nextReport->ObstacleSBPtr->DynPtr->Position.vx+direction.vx/100; |
| | 4041 | QueenObjectList[i]->DynPtr->Position.vz=nextReport->ObstacleSBPtr->DynPtr->Position.vz+direction.vz/100; |
| | 4042 | QueenObjectList[i]->DynPtr->PrevPosition.vx=QueenObjectList[i]->DynPtr->Position.vx; |
| | 4043 | QueenObjectList[i]->DynPtr->PrevPosition.vz=QueenObjectList[i]->DynPtr->Position.vz; |
| | 4044 | |
| | 4045 | //set the taunt timer |
| | 4046 | queenStatusPointer->QueenTauntTimer = ONE_FIXED/2; |
| | 4047 | |
| | 4048 | break; |
| | 4049 | } |
| | 4050 | } |
| | 4051 | } |
| | 4052 | nextReport = nextReport->NextCollisionReportPtr; |
| | 4053 | } |
| | 4054 | } |
| | 4055 | } |
| | 4056 | } |
| | 4057 | |
| | 4058 | QueenSoundHiss(sbPtr); |
| | 4059 | } |
| | 4060 | |
| | 4061 | /*--------------------** |
| | 4062 | ** Loading and Saving ** |
| | 4063 | **--------------------*/ |
| | 4064 | #include "savegame.h" |
| | 4065 | |
| | 4066 | typedef struct queen_save_block |
| | 4067 | { |
| | 4068 | SAVE_BLOCK_STRATEGY_HEADER header; |
| | 4069 | |
| | 4070 | //behaviour block stuff |
| | 4071 | |
| | 4072 | QUEEN_BEHAVIOUR_STATE QueenState; |
| | 4073 | QUEEN_MANOEUVRE current_move; |
| | 4074 | QUEEN_MANOEUVRE next_move; |
| | 4075 | |
| | 4076 | QUEEN_FOOT fixed_foot; |
| | 4077 | VECTORCH fixed_foot_oldpos; |
| | 4078 | |
| | 4079 | VECTORCH TargetPos; |
| | 4080 | |
| | 4081 | int moveTimer; |
| | 4082 | |
| | 4083 | NPC_WANDERDATA wanderData; |
| | 4084 | |
| | 4085 | int TempTarget;//going for an intermediate point |
| | 4086 | int TempTargetTimer;//time before queen gives up going for intermediate point |
| | 4087 | int CurrentQueenObject; |
| | 4088 | int QueenStateTimer; |
| | 4089 | int QueenObjectBias; |
| | 4090 | int QueenPlayerBias; |
| | 4091 | int QueenTauntTimer; |
| | 4092 | int QueenFireTimer; |
| | 4093 | VECTORCH LastVelocity; |
| | 4094 | int BeenInAirlock; |
| | 4095 | int QueenActivated; //queen is inactive until seen |
| | 4096 | |
| | 4097 | int TargetInfoValid; //have the next three items been set |
| | 4098 | int TargetDistance; //distance of current target from queen |
| | 4099 | int TargetRelSpeed; //targets speed in queen's direction |
| | 4100 | VECTORCH TargetDirection; //targets direction relative to queen |
| | 4101 | VECTORCH VectToTarget; |
| | 4102 | |
| | 4103 | unsigned int PlayingHitDelta :1; |
| | 4104 | |
| | 4105 | int SwerveTimer; |
| | 4106 | int SwerveDirection; |
| | 4107 | |
| | 4108 | QUEEN_SOUND_CATEGORY lastSoundCategory; |
| | 4109 | |
| | 4110 | VECTORCH ClimbStartPosition; //used when climing out of the airlock |
| | 4111 | int AttackDoneItsDamage; |
| | 4112 | |
| | 4113 | //and now those evil globals... |
| | 4114 | int PlayerInTrench; |
| | 4115 | int PlayerInLocker; |
| | 4116 | int AirlockTimeOpen; |
| | 4117 | int UpperAirlockDoorOpen; |
| | 4118 | int LowerAirlockDoorOpen; |
| | 4119 | VECTORCH UpperAirlockDoorStart; |
| | 4120 | VECTORCH LowerAirlockDoorStart; |
| | 4121 | |
| | 4122 | //annoying pointer related things |
| | 4123 | char Target_SBname[SB_NAME_LENGTH]; |
| | 4124 | |
| | 4125 | SECTION_DATA *fixed_foot_section; |
| | 4126 | SECTION_DATA* QueenRightHand; |
| | 4127 | |
| | 4128 | //strategyblock stuff |
| | 4129 | DAMAGEBLOCK DamageBlock; |
| | 4130 | DYNAMICSBLOCK dynamics; |
| | 4131 | |
| | 4132 | } QUEEN_SAVE_BLOCK; |
| | 4133 | |
| | 4134 | //defines for load/save macros |
| | 4135 | #define SAVELOAD_BLOCK block |
| | 4136 | #define SAVELOAD_BEHAV queenStatusPointer |
| | 4137 | |
| | 4138 | void LoadStrategy_Queen(SAVE_BLOCK_STRATEGY_HEADER* header) |
| | 4139 | { |
| | 4140 | STRATEGYBLOCK* sbPtr; |
| | 4141 | QUEEN_STATUS_BLOCK* queenStatusPointer; |
| | 4142 | QUEEN_SAVE_BLOCK* block = (QUEEN_SAVE_BLOCK*) header; |
| | 4143 | |
| | 4144 | //check the size of the save block |
| | 4145 | if(header->size != sizeof(*block)) |
| | 4146 | return; |
| | 4147 | |
| | 4148 | //find the existing strategy block |
| | 4149 | sbPtr = FindSBWithName(header->SBname); |
| | 4150 | |
| | 4151 | if(!sbPtr) |
| | 4152 | return; |
| | 4153 | |
| | 4154 | //make sure the strategy found is of the right type |
| | 4155 | if(sbPtr->type != I_BehaviourQueenAlien) |
| | 4156 | return; |
| | 4157 | |
| | 4158 | queenStatusPointer =(QUEEN_STATUS_BLOCK*) sbPtr->dataptr; |
| | 4159 | |
| | 4160 | //normally done on first frame , but need to do this here when loading |
| | 4161 | FindQueenObjects(); |
| | 4162 | |
| | 4163 | //start copying stuff |
| | 4164 | COPYELEMENT_LOAD(QueenState) |
| | 4165 | COPYELEMENT_LOAD(current_move) |
| | 4166 | COPYELEMENT_LOAD(next_move) |
| | 4167 | |
| | 4168 | COPYELEMENT_LOAD(fixed_foot) |
| | 4169 | COPYELEMENT_LOAD(fixed_foot_oldpos) |
| | 4170 | |
| | 4171 | COPYELEMENT_LOAD(TargetPos) |
| | 4172 | |
| | 4173 | COPYELEMENT_LOAD(moveTimer) |
| | 4174 | |
| | 4175 | COPYELEMENT_LOAD(wanderData) |
| | 4176 | |
| | 4177 | COPYELEMENT_LOAD(TempTarget)//going for an intermediate point |
| | 4178 | COPYELEMENT_LOAD(TempTargetTimer)//time before queen gives up going for intermediate point |
| | 4179 | |
| | 4180 | COPYELEMENT_LOAD(CurrentQueenObject) |
| | 4181 | COPYELEMENT_LOAD(QueenStateTimer) |
| | 4182 | COPYELEMENT_LOAD(QueenObjectBias) |
| | 4183 | COPYELEMENT_LOAD(QueenPlayerBias) |
| | 4184 | COPYELEMENT_LOAD(QueenTauntTimer) |
| | 4185 | COPYELEMENT_LOAD(QueenFireTimer) |
| | 4186 | COPYELEMENT_LOAD(LastVelocity) |
| | 4187 | |
| | 4188 | COPYELEMENT_LOAD(BeenInAirlock) |
| | 4189 | COPYELEMENT_LOAD(QueenActivated) //queen is inactive until seen |
| | 4190 | |
| | 4191 | COPYELEMENT_LOAD(TargetInfoValid) //have the next three items been set |
| | 4192 | COPYELEMENT_LOAD(TargetDistance) //distance of current target from queen |
| | 4193 | COPYELEMENT_LOAD(TargetRelSpeed) //targets speed in queen's direction |
| | 4194 | COPYELEMENT_LOAD(TargetDirection) //targets direction relative to queen |
| | 4195 | COPYELEMENT_LOAD(VectToTarget) |
| | 4196 | |
| | 4197 | COPYELEMENT_LOAD(PlayingHitDelta) |
| | 4198 | COPYELEMENT_LOAD(SwerveTimer) |
| | 4199 | COPYELEMENT_LOAD(SwerveDirection) |
| | 4200 | COPYELEMENT_LOAD(lastSoundCategory) |
| | 4201 | |
| | 4202 | COPYELEMENT_LOAD(ClimbStartPosition) //used when climing out of the airlock |
| | 4203 | COPYELEMENT_LOAD(AttackDoneItsDamage) |
| | 4204 | |
| | 4205 | //load globals |
| | 4206 | PlayerInTrench = block->PlayerInTrench; |
| | 4207 | PlayerInLocker = block->PlayerInLocker; |
| | 4208 | AirlockTimeOpen = block->AirlockTimeOpen; |
| | 4209 | UpperAirlockDoorOpen = block->UpperAirlockDoorOpen; |
| | 4210 | LowerAirlockDoorOpen = block->LowerAirlockDoorOpen; |
| | 4211 | UpperAirlockDoorStart = block->UpperAirlockDoorStart; |
| | 4212 | LowerAirlockDoorStart = block->LowerAirlockDoorStart; |
| | 4213 | |
| | 4214 | //load target |
| | 4215 | queenStatusPointer->QueenTargetSB = FindSBWithName(block->Target_SBname); |
| | 4216 | |
| | 4217 | //copy strategy block stuff |
| | 4218 | *sbPtr->DynPtr = block->dynamics; |
| | 4219 | sbPtr->DamageBlock = block->DamageBlock; |
| | 4220 | |
| | 4221 | //load hierarchy |
| | 4222 | { |
| | 4223 | SAVE_BLOCK_HEADER* hier_header = GetNextBlockIfOfType(SaveBlock_Hierarchy); |
| | 4224 | if(hier_header) |
| | 4225 | LoadHierarchy(hier_header,&queenStatusPointer->HModelController); |
| | 4226 | } |
| | 4227 | |
| | 4228 | //get delta controller pointers |
| | 4229 | queenStatusPointer->attack_delta = Get_Delta_Sequence(&queenStatusPointer->HModelController,"attack"); |
| | 4230 | queenStatusPointer->hit_delta = Get_Delta_Sequence(&queenStatusPointer->HModelController,"hit"); |
| | 4231 | |
| | 4232 | //get section data pointers |
| | 4233 | |
| | 4234 | if(queenStatusPointer->fixed_foot == LeftFoot) |
| | 4235 | queenStatusPointer->fixed_foot_section = GetThisSectionData(queenStatusPointer->HModelController.section_data, "left foot"); |
| | 4236 | else |
| | 4237 | queenStatusPointer->fixed_foot_section = GetThisSectionData(queenStatusPointer->HModelController.section_data, "right foot"); |
| | 4238 | |
| | 4239 | queenStatusPointer->QueenRightHand = GetThisSectionData(queenStatusPointer->HModelController.section_data,"rrrr fing"); |
| | 4240 | |
| | 4241 | Load_SoundState(&queenStatusPointer->soundHandle); |
| | 4242 | } |
| | 4243 | |
| | 4244 | void SaveStrategy_Queen(STRATEGYBLOCK* sbPtr) |
| | 4245 | { |
| | 4246 | QUEEN_STATUS_BLOCK* queenStatusPointer; |
| | 4247 | QUEEN_SAVE_BLOCK* block; |
| | 4248 | |
| | 4249 | GET_STRATEGY_SAVE_BLOCK(block,sbPtr); |
| | 4250 | queenStatusPointer = (QUEEN_STATUS_BLOCK*) sbPtr->dataptr; |
| | 4251 | |
| | 4252 | //start copying stuff |
| | 4253 | COPYELEMENT_SAVE(QueenState) |
| | 4254 | COPYELEMENT_SAVE(current_move) |
| | 4255 | COPYELEMENT_SAVE(next_move) |
| | 4256 | |
| | 4257 | COPYELEMENT_SAVE(fixed_foot) |
| | 4258 | COPYELEMENT_SAVE(fixed_foot_oldpos) |
| | 4259 | |
| | 4260 | COPYELEMENT_SAVE(TargetPos) |
| | 4261 | |
| | 4262 | COPYELEMENT_SAVE(moveTimer) |
| | 4263 | |
| | 4264 | COPYELEMENT_SAVE(wanderData) |
| | 4265 | |
| | 4266 | COPYELEMENT_SAVE(TempTarget)//going for an intermediate point |
| | 4267 | COPYELEMENT_SAVE(TempTargetTimer)//time before queen gives up going for intermediate point |
| | 4268 | |
| | 4269 | COPYELEMENT_SAVE(CurrentQueenObject) |
| | 4270 | COPYELEMENT_SAVE(QueenStateTimer) |
| | 4271 | COPYELEMENT_SAVE(QueenObjectBias) |
| | 4272 | COPYELEMENT_SAVE(QueenPlayerBias) |
| | 4273 | COPYELEMENT_SAVE(QueenTauntTimer) |
| | 4274 | COPYELEMENT_SAVE(QueenFireTimer) |
| | 4275 | COPYELEMENT_SAVE(LastVelocity) |
| | 4276 | |
| | 4277 | COPYELEMENT_SAVE(BeenInAirlock) |
| | 4278 | COPYELEMENT_SAVE(QueenActivated) //queen is inactive until seen |
| | 4279 | |
| | 4280 | COPYELEMENT_SAVE(TargetInfoValid) //have the next three items been set |
| | 4281 | COPYELEMENT_SAVE(TargetDistance) //distance of current target from queen |
| | 4282 | COPYELEMENT_SAVE(TargetRelSpeed) //targets speed in queen's direction |
| | 4283 | COPYELEMENT_SAVE(TargetDirection) //targets direction relative to queen |
| | 4284 | COPYELEMENT_SAVE(VectToTarget) |
| | 4285 | |
| | 4286 | COPYELEMENT_SAVE(PlayingHitDelta) |
| | 4287 | COPYELEMENT_SAVE(SwerveTimer) |
| | 4288 | COPYELEMENT_SAVE(SwerveDirection) |
| | 4289 | COPYELEMENT_SAVE(lastSoundCategory) |
| | 4290 | |
| | 4291 | COPYELEMENT_SAVE(ClimbStartPosition) //used when climing out of the airlock |
| | 4292 | COPYELEMENT_SAVE(AttackDoneItsDamage) |
| | 4293 | |
| | 4294 | //save globals |
| | 4295 | block->PlayerInTrench = PlayerInTrench; |
| | 4296 | block->PlayerInLocker = PlayerInLocker; |
| | 4297 | block->AirlockTimeOpen = AirlockTimeOpen; |
| | 4298 | block->UpperAirlockDoorOpen = UpperAirlockDoorOpen; |
| | 4299 | block->LowerAirlockDoorOpen = LowerAirlockDoorOpen; |
| | 4300 | block->UpperAirlockDoorStart = UpperAirlockDoorStart; |
| | 4301 | block->LowerAirlockDoorStart = LowerAirlockDoorStart; |
| | 4302 | |
| | 4303 | //save target |
| | 4304 | if(queenStatusPointer->QueenTargetSB) |
| | 4305 | { |
| | 4306 | COPY_NAME(block->Target_SBname,queenStatusPointer->QueenTargetSB->SBname); |
| | 4307 | } |
| | 4308 | else |
| | 4309 | { |
| | 4310 | COPY_NAME(block->Target_SBname,Null_Name); |
| | 4311 | } |
| | 4312 | |
| | 4313 | //save strategy block stuff |
| | 4314 | block->dynamics = *sbPtr->DynPtr; |
| | 4315 | block->dynamics.CollisionReportPtr=0; |
| | 4316 | block->DamageBlock = sbPtr->DamageBlock; |
| | 4317 | |
| | 4318 | //save the hierarchy |
| | 4319 | SaveHierarchy(&queenStatusPointer->HModelController); |
| | 4320 | |
| | 4321 | Save_SoundState(&queenStatusPointer->soundHandle); |
| | 4322 | } |