raven/quake4-sdk
0
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity
quake4-sdk/source/game/ai/Monster_BossMakron.cpp

2348 lines
62 KiB
C++
Raw Permalink Normal View History

as released 2007-06-15
2007-06-15 00:00:00 +00:00
#include "../../idlib/precompiled.h"
#pragma hdrstop
#include "../Game_local.h"
class rvMonsterBossMakron : public idAI {
public:
CLASS_PROTOTYPE( rvMonsterBossMakron );
rvMonsterBossMakron ( void );
void Spawn ( void );
void InitSpawnArgsVariables ( void );
bool CanTurn ( void ) const;
void Save ( idSaveGame *savefile ) const;
void Restore ( idRestoreGame *savefile );
void BuildActionArray ( void );
//void ScriptedFace ( idEntity* faceEnt, bool endWithIdle );
protected:
bool CheckActions ( void );
bool CheckTurnActions ( void );
void Killed ( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location );
void Damage ( idEntity *inflictor, idEntity *attacker, const idVec3 &dir, const char *damageDefName, const float damageScale, const int location );
//The Makron behaves differently, and we don't always need him sinking back into an idle after every attack
//This version is actually overridden
void PerformAction ( const char* stateName, int blendFrames, bool noPain );
//This just calls the parent version
bool PerformAction ( rvAIAction* action, bool (idAI::*condition)(rvAIAction*,int), rvAIActionTimer* timer );
//This performs a patterned action
void PerformPatternedAction ( );
//For debug, may not need this.
void OnStopAction ( void );
//stops all effects
void StopAllEffects ( void );
//for the cannon fire
int shots;
//determines if the Makron will enter idles between attacks
bool noIdle;
//changes Makron from patterned, script controlled to normal AI
bool patternedMode;
//store the ideal yaw, because somehow between here and the state we set it gets stomped.
float facingIdealYaw;
float facingTime;
float turnRate;
//flag to indicate whether or not the Makron is in the corner of the map when he takes an action.
bool flagCornerState;
//tallies up the number of consecutive actions the Makron has taken in the corner of the map.
//If the tally gets too high, teleport him to the map center.
int cornerCount;
//in the state of teleporting
bool flagTeleporting;
//for flying mode ----------------------------------------------------------------------------------------
void BeginSeparation ( void );
void CompleteSeparation ( void );
bool flagFlyingMode;
bool flagFakeDeath;
int flagUndying;
rvClientEffectPtr effectHover;
jointHandle_t jointHoverEffect;
//for the stomp attack ----------------------------------------------------------------------------------------
float stompMaxRadius;
float stompWidth;
float stompSpeed;
float stompRadius;
//for the lightning bolt sweep attacks -------------------------------------------------------------------
void MaintainBoltSweep ( void );
void InitBoltSweep ( idVec3 idealTarget );
void LightningSweep ( idVec3 attackVector, rvClientEffectPtr& boltEffect, rvClientEffectPtr& impactEffect );
void StopAllBoltEffects ( void );
rvClientEffectPtr leftBoltEffect;
rvClientEffectPtr rightBoltEffect;
rvClientEffectPtr leftBoltImpact;
rvClientEffectPtr rightBoltImpact;
rvClientEffectPtr boltMuzzleFlash;
idStr boltEffectName;
idVec3 leftBoltVector;
idVec3 rightBoltVector;
idVec3 boltVectorMin;
idVec3 boltVectorMax;
idMat3 boltAimMatrix;
bool flagSweepDone;
//these are grabbed from the def file
float boltSweepTime;
float boltWaitTime;
//used internally
float boltSweepStartTime;
float boltTime;
float boltNextStateTime;
int stateBoltSweep;
jointHandle_t jointLightningBolt;
//end lightning bolt sweep attacks -------------------------------------------------------------------
//changed by script event, allows for grenades to spawn baddies.
bool flagAllowSpawns;
enum { MAKRON_ACTION_DMG,
MAKRON_ACTION_MELEE,
MAKRON_ACTION_CANNON,
MAKRON_ACTION_CANNON_SWEEP,
MAKRON_ACTION_GRENADE,
MAKRON_ACTION_LIGHTNING_1,
MAKRON_ACTION_LIGHTNING_2,
MAKRON_ACTION_STOMP,
MAKRON_ACTION_HEAL,
MAKRON_ACTION_CHARGE,
MAKRON_ACTION_KILLPLAYER,
MAKRON_ACTION_COUNT, };
rvAIAction actionDMGAttack;
rvAIAction actionMeleeAttack;
rvAIAction actionCannonAttack;
rvAIAction actionCannonSweepAttack;
rvAIAction actionGrenadeAttack;
rvAIAction actionLightningPattern1Attack;
rvAIAction actionLightningPattern2Attack;
rvAIAction actionStompAttack;
rvAIAction actionHeal;
rvAIAction actionCharge;
rvAIAction actionKillPlayer;
rvAIAction * actionArray[ MAKRON_ACTION_COUNT ];
int actionPatterned;
//when the Makron is low on health, he'll use this.
rvScriptFuncUtility scriptRecharge;
rvScriptFuncUtility scriptTeleport;
stateResult_t State_Torso_DMGAttack ( const stateParms_t& parms );
stateResult_t State_Torso_GrenadeAttack ( const stateParms_t& parms );
stateResult_t State_Torso_MeleeAttack ( const stateParms_t& parms );
stateResult_t State_Torso_CannonAttack ( const stateParms_t& parms );
stateResult_t State_Torso_CannonSweepAttack ( const stateParms_t& parms );
stateResult_t State_Torso_Lightning1Attack ( const stateParms_t& parms );
stateResult_t State_Torso_Lightning2Attack ( const stateParms_t& parms );
stateResult_t State_Torso_StompAttack ( const stateParms_t& parms );
stateResult_t State_Torso_Recharge ( const stateParms_t& parms );
stateResult_t State_Torso_Charge ( const stateParms_t& parms );
stateResult_t State_Torso_KillPlayer ( const stateParms_t& parms );
stateResult_t State_Torso_Teleport ( const stateParms_t& parms );
//used when killed
stateResult_t State_Killed ( const stateParms_t& parms );
//walking turn anims
stateResult_t State_Torso_TurnRight90 ( const stateParms_t& parms );
stateResult_t State_Torso_TurnLeft90 ( const stateParms_t& parms );
//flying turn anims
stateResult_t State_Torso_RotateToAngle ( const stateParms_t& parms );
stateResult_t State_ScriptedFace ( const stateParms_t& parms );
//like jesus, except with robot parts
stateResult_t State_Torso_FirstDeath ( const stateParms_t& parms );
stateResult_t State_Torso_Resurrection ( const stateParms_t& parms );
//These two frames activate and deactivate the second lightning sweep
stateResult_t Frame_BeginLightningSweep2 ( const stateParms_t& parms );
stateResult_t Frame_EndLightningSweep2 ( const stateParms_t& parms );
stateResult_t Frame_StompAttack ( const stateParms_t& parms );
stateResult_t Frame_Teleport ( const stateParms_t& parms );
void Event_AllowMoreSpawns ( void );
void Event_SetNextAction ( const char* actionString );
void Event_EnablePatternMode ( void );
void Event_DisablePatternMode ( void );
void Event_StompAttack ( idVec3 &origin );
void Event_Separate ( void );
void Event_FlyingRotate ( idVec3 &vecOrg );
void Event_ToggleCornerState ( float f );
CLASS_STATES_PROTOTYPE ( rvMonsterBossMakron );
};
const idEventDef EV_AllowMoreSpawns( "allowMoreSpawns" );
const idEventDef EV_SetNextAction( "setNextAction", "s", 'f' );
const idEventDef EV_EnablePatternMode( "enablePatternMode" );
const idEventDef EV_DisablePatternMode( "disablePatternMode" );
const idEventDef EV_StompAttack( "stompAttack", "v" );
const idEventDef EV_Separate( "separate" );
const idEventDef EV_FlyingRotate( "flyingRotate", "v");
const idEventDef AI_ScriptedFace ( "scriptedFace", "ed" );
const idEventDef EV_ToggleCornerState( "toggleCornerState", "f" );
CLASS_DECLARATION( idAI, rvMonsterBossMakron )
EVENT( EV_AllowMoreSpawns, rvMonsterBossMakron::Event_AllowMoreSpawns )
EVENT( EV_SetNextAction, rvMonsterBossMakron::Event_SetNextAction )
EVENT( EV_EnablePatternMode, rvMonsterBossMakron::Event_EnablePatternMode )
EVENT( EV_DisablePatternMode, rvMonsterBossMakron::Event_DisablePatternMode )
EVENT( EV_StompAttack, rvMonsterBossMakron::Event_StompAttack )
EVENT( EV_Separate, rvMonsterBossMakron::Event_Separate )
EVENT( EV_FlyingRotate, rvMonsterBossMakron::Event_FlyingRotate )
EVENT( AI_ScriptedFace, rvMonsterBossMakron::ScriptedFace )
EVENT( EV_ToggleCornerState, rvMonsterBossMakron::Event_ToggleCornerState )
END_CLASS
/*
================
rvMonsterBossMakron::rvMonsterBossMakron
================
*/
rvMonsterBossMakron::rvMonsterBossMakron ( void ) {
//set up this action array
}
/*
================
rvMonsterBossMakron::BuildActionArray ( void )
================
*/
void rvMonsterBossMakron::BuildActionArray ( void ) {
actionArray[ MAKRON_ACTION_DMG ] = &actionDMGAttack;
actionArray[ MAKRON_ACTION_MELEE ] = &actionMeleeAttack;
actionArray[ MAKRON_ACTION_CANNON ] = &actionCannonAttack;
actionArray[ MAKRON_ACTION_CANNON_SWEEP ] = &actionCannonSweepAttack;
actionArray[ MAKRON_ACTION_GRENADE ] = &actionGrenadeAttack;
actionArray[ MAKRON_ACTION_LIGHTNING_1 ] = &actionLightningPattern1Attack;
actionArray[ MAKRON_ACTION_LIGHTNING_2 ] = &actionLightningPattern2Attack;
actionArray[ MAKRON_ACTION_STOMP ] = &actionStompAttack;
actionArray[ MAKRON_ACTION_HEAL ] = &actionHeal;
actionArray[ MAKRON_ACTION_CHARGE ] = &actionCharge;
actionArray[ MAKRON_ACTION_KILLPLAYER ] = &actionKillPlayer;
}
/*
================
rvMonsterBossMakron::Save
================
*/
void rvMonsterBossMakron::Save ( idSaveGame *savefile ) const {
savefile->WriteInt( shots);
savefile->WriteFloat( facingIdealYaw);
savefile->WriteFloat( facingTime);
savefile->WriteBool( noIdle);
savefile->WriteBool( patternedMode);
savefile->WriteBool( flagFlyingMode);
savefile->WriteBool( flagFakeDeath);
savefile->WriteInt( flagUndying );
effectHover.Save( savefile );
savefile->WriteJoint( jointHoverEffect ); // cnicholson: added unsaved var
savefile->WriteFloat( stompRadius);
leftBoltEffect.Save( savefile );
rightBoltEffect.Save( savefile );
leftBoltImpact.Save( savefile );
rightBoltImpact.Save( savefile );
boltMuzzleFlash.Save( savefile );
savefile->WriteString( boltEffectName);
savefile->WriteVec3( leftBoltVector);
savefile->WriteVec3( rightBoltVector);
savefile->WriteVec3( boltVectorMin);
savefile->WriteVec3( boltVectorMax);
savefile->WriteMat3( boltAimMatrix);
savefile->WriteBool( flagSweepDone);
savefile->WriteFloat( boltSweepTime);
savefile->WriteFloat( boltSweepStartTime);
savefile->WriteFloat( boltTime);
savefile->WriteFloat( boltNextStateTime);
savefile->WriteInt( stateBoltSweep);
savefile->WriteBool( flagAllowSpawns);
savefile->WriteBool( flagCornerState );
savefile->WriteInt( cornerCount );
savefile->WriteBool( flagTeleporting );
actionDMGAttack.Save( savefile );
actionMeleeAttack.Save( savefile );
actionCannonAttack.Save( savefile );
actionCannonSweepAttack.Save( savefile );
actionGrenadeAttack.Save( savefile );
actionLightningPattern1Attack.Save( savefile );
actionLightningPattern2Attack.Save( savefile );
actionStompAttack.Save( savefile );
actionHeal.Save( savefile );
actionCharge.Save( savefile );
actionKillPlayer.Save( savefile );
savefile->WriteInt( actionPatterned);
scriptRecharge.Save( savefile );
scriptTeleport.Save( savefile );
// cnicholson: No need to save actionArry, its rebuilt during restore
}
/*
================
rvMonsterBossMakron::Restore
================
*/
void rvMonsterBossMakron::Restore ( idRestoreGame *savefile ) {
savefile->ReadInt( shots);
savefile->ReadFloat( facingIdealYaw);
savefile->ReadFloat( facingTime);
savefile->ReadBool( noIdle);
savefile->ReadBool( patternedMode);
savefile->ReadBool( flagFlyingMode);
savefile->ReadBool( flagFakeDeath);
savefile->ReadInt( flagUndying );
effectHover.Restore( savefile );
savefile->ReadJoint( jointHoverEffect ); // cnicholson: added unrestoed var
savefile->ReadFloat( stompRadius);
leftBoltEffect.Restore( savefile );
rightBoltEffect.Restore( savefile );
leftBoltImpact.Restore( savefile );
rightBoltImpact.Restore( savefile );
boltMuzzleFlash.Restore( savefile );
savefile->ReadString( boltEffectName);
savefile->ReadVec3( leftBoltVector);
savefile->ReadVec3( rightBoltVector);
savefile->ReadVec3( boltVectorMin);
savefile->ReadVec3( boltVectorMax);
savefile->ReadMat3( boltAimMatrix);
savefile->ReadBool( flagSweepDone);
savefile->ReadFloat( boltSweepTime);
savefile->ReadFloat( boltSweepStartTime);
savefile->ReadFloat( boltTime);
savefile->ReadFloat( boltNextStateTime);
savefile->ReadInt( stateBoltSweep);
savefile->ReadBool( flagAllowSpawns);
savefile->ReadBool( flagCornerState );
savefile->ReadInt( cornerCount );
savefile->ReadBool( flagTeleporting );
actionDMGAttack.Restore( savefile );
actionMeleeAttack.Restore( savefile );
actionCannonAttack.Restore( savefile );
actionCannonSweepAttack.Restore( savefile );
actionGrenadeAttack.Restore( savefile );
actionLightningPattern1Attack.Restore( savefile );
actionLightningPattern2Attack.Restore( savefile );
actionStompAttack.Restore( savefile );
actionHeal.Restore( savefile );
actionCharge.Restore( savefile );
actionKillPlayer.Restore( savefile );
savefile->ReadInt( actionPatterned);
scriptRecharge.Restore( savefile );
scriptTeleport.Restore( savefile );
//reload the action array, this is done in the init section but if we don't do it here our array is bunk.
BuildActionArray();
InitSpawnArgsVariables();
// pre-cache decls
gameLocal.FindEntityDefDict ( "monster_makron_legs" );
}
/*
================
rvMonsterBossMakron::StopAllEffects
================
*/
void rvMonsterBossMakron::StopAllEffects ( void ) {
StopAllBoltEffects();
//stop the over effect
if( effectHover ) {
effectHover.GetEntity()->Stop();
effectHover = 0;
}
}
/*
================
rvMonsterBossMakron::StopAllBoltEffects
================
*/
void rvMonsterBossMakron::StopAllBoltEffects ( void ) {
if( leftBoltEffect ) {
leftBoltEffect.GetEntity()->Stop();
leftBoltEffect = 0;
}
if( rightBoltEffect ) {
rightBoltEffect.GetEntity()->Stop();
rightBoltEffect = 0;
}
if( leftBoltImpact ) {
leftBoltImpact.GetEntity()->Stop();
leftBoltImpact = 0;
}
if( rightBoltImpact ) {
rightBoltImpact.GetEntity()->Stop();
rightBoltImpact = 0;
}
if( boltMuzzleFlash ) {
boltMuzzleFlash .GetEntity()->Stop();
boltMuzzleFlash = 0;
}
}
void rvMonsterBossMakron::InitSpawnArgsVariables ( void ) {
//slick!
jointLightningBolt = animator.GetJointHandle ( spawnArgs.GetString ( "joint_lightningBolt", "claw_muzzle" ) );
stompMaxRadius = spawnArgs.GetFloat( "stomp_max_range", "1600");
stompWidth = spawnArgs.GetFloat( "stomp_width", "32");
stompSpeed = spawnArgs.GetFloat( "stomp_speed", "32");
boltWaitTime = spawnArgs.GetFloat( "lightingsweep_wait_time", "1");
turnRate = spawnArgs.GetFloat( "fly_turnRate", "180");
}
/*
================
rvMonsterBossMakron::Spawn
================
*/
void rvMonsterBossMakron::Spawn ( void ) {
if( spawnArgs.GetBool("passive")) {
flagFakeDeath = true;
} else {
flagFakeDeath = false;
}
if( spawnArgs.GetBool("furniture") ) {
fl.takedamage = false;
}
if( spawnArgs.GetBool("junior") ) {
flagUndying = 1;
} else {
flagUndying = 0;
}
flagAllowSpawns = false;
flagFlyingMode = false;
patternedMode = false;
noIdle = false;
flagCornerState = false;
cornerCount = 0;
flagTeleporting = false;
//start clean
actionPatterned = -1;
boltTime = 0;
boltSweepTime = spawnArgs.GetFloat( "lightningsweep_sweep_time", "3");
InitSpawnArgsVariables();
actionDMGAttack.Init ( spawnArgs, "action_DMGAttack", "Torso_DMGAttack", AIACTIONF_ATTACK );
actionCannonAttack.Init ( spawnArgs, "action_cannonAttack", "Torso_CannonAttack", AIACTIONF_ATTACK );
actionCannonSweepAttack.Init ( spawnArgs, "action_cannonsweepAttack", "Torso_CannonSweepAttack", AIACTIONF_ATTACK );
actionGrenadeAttack.Init ( spawnArgs, "action_grenadeAttack", "Torso_GrenadeAttack", AIACTIONF_ATTACK );
actionLightningPattern1Attack.Init( spawnArgs, "action_lightningPattern1Attack", "Torso_Lightning1Attack", AIACTIONF_ATTACK );
actionLightningPattern2Attack.Init( spawnArgs, "action_lightningPattern2Attack", "Torso_Lightning2Attack", AIACTIONF_ATTACK );
actionStompAttack.Init ( spawnArgs, "action_stompAttack", "Torso_StompAttack", AIACTIONF_ATTACK );
actionHeal.Init( spawnArgs, "action_heal", "Torso_Recharge", AIACTIONF_ATTACK );
actionCharge.Init( spawnArgs, "action_charge", "Torso_Charge", AIACTIONF_ATTACK );
actionKillPlayer.Init( spawnArgs, "action_lightningPattern3Attack", "Torso_KillPlayer", AIACTIONF_ATTACK );
actionMeleeAttack.Init ( spawnArgs, "action_meleeAttack", "Torso_MeleeAttack", AIACTIONF_ATTACK );
const char *func;
if ( spawnArgs.GetString( "script_recharge", "", &func ) )
{
scriptRecharge.Init( func );
}
if ( spawnArgs.GetString( "script_teleport", "", &func ) )
{
scriptTeleport.Init( func );
}
//build the action array
BuildActionArray();
// pre-cache decls
gameLocal.FindEntityDefDict ( "monster_makron_legs" );
}
/*
================
rvMonsterBossMakron::CheckTurnActions
================
*/
bool rvMonsterBossMakron::CheckTurnActions ( void ) {
if ( !flagFakeDeath && !move.fl.moving && !move.anim_turn_angles ) { //&& gameLocal.time > combat.investigateTime ) {
float turnYaw = idMath::AngleNormalize180 ( move.ideal_yaw - move.current_yaw ) ;
if ( turnYaw > lookMax[YAW] * 0.75f ) {
PerformAction ( "Torso_TurnRight90", 4, true );
return true;
} else if ( turnYaw < -lookMax[YAW] * 0.75f ) {
PerformAction ( "Torso_TurnLeft90", 4, true );
return true;
}
////gameLocal.Printf(" turn yaw == %f \n", turnYaw);
}
return false;
}
/*
================
rvMonsterBossMakron::CheckActions
================
*/
bool rvMonsterBossMakron::CheckActions ( void ) {
if( spawnArgs.GetFloat("furniture", "0")) {
return true;
}
//if in the middle of teleporting, do nothing
if( flagTeleporting ) {
return true;
}
//gameLocal.Printf("Begin CheckActions \n");
if( CheckTurnActions() ) {
//gameLocal.Printf("---CheckActions: TurnActions was true \n");
return true;
}
//If we need more baddies, do it right now regardless of range or player FOV
if ( flagAllowSpawns ) {
PerformAction ( actionGrenadeAttack.state,actionGrenadeAttack.blendFrames, actionGrenadeAttack.fl.noPain );
//gameLocal.Printf("---CheckActions: Spawned in more fellas \n");
return true;
}
//melee attacks
if ( PerformAction ( &actionMeleeAttack, (checkAction_t)&idAI::CheckAction_MeleeAttack, NULL ) ||
PerformAction ( &actionStompAttack, (checkAction_t)&idAI::CheckAction_MeleeAttack, NULL ) ) {
//gameLocal.Printf("---CheckActions: Melee attacks \n");
return true;
}
//cannon sweep is good to check if we're up close.
//if ( PerformAction ( &actionCannonSweepAttack, (checkAction_t)&idAI::CheckAction_RangedAttack, &actionTimerRangedAttack ) ) {
// return true;
//}
//If we're in total patterned mode, then don't relay on timers or ranges to perform actions.
if ( patternedMode && !flagFakeDeath ) {
//gameLocal.Printf("**CheckActions: PerformPatternedAction called \n");
PerformPatternedAction ( );
return true;
}
//gameLocal.Printf("---CheckActions: FlagFakeDeath: %d \n", flagFakeDeath );
//gameLocal.Printf("---CheckActions: PatternedMode: %d \n", patternedMode );
//ranged attacks
if ( PerformAction ( &actionDMGAttack, (checkAction_t)&idAI::CheckAction_RangedAttack, &actionTimerRangedAttack ) ||
PerformAction ( &actionLightningPattern1Attack, (checkAction_t)&idAI::CheckAction_RangedAttack, &actionTimerRangedAttack ) ||
PerformAction ( &actionGrenadeAttack, (checkAction_t)&idAI::CheckAction_RangedAttack, &actionTimerRangedAttack ) ||
PerformAction ( &actionCannonAttack, (checkAction_t)&idAI::CheckAction_RangedAttack, &actionTimerRangedAttack ) ) {
//gameLocal.Printf("---CheckActions: Ranged attack called \n");
return true;
}
//gameLocal.Printf("---CheckActions: Defaulting to AI CheckActions \n");
return idAI::CheckActions ( );
}
/*
================
rvMonsterMakron::PerformPatternedAction
================
*/
void rvMonsterBossMakron::PerformPatternedAction( ) {
//gameLocal.Printf("PerformPatternedAction::Begin--\n");
//if we don't have an action to perform, don't.
if( actionPatterned == -1) {
//gameLocal.Printf("actionPatterned = -1\n");
//gameLocal.Printf("PerformPatternedAction::End--\n");
return;
}
//if we're in a corner, right now, then add to the corner tally.
if( flagCornerState ) {
cornerCount++;
} else {
cornerCount = 0;
}
//if this is our third consecutive action in the corner, maybe we should teleport?
if( cornerCount == 3 ) {
gameLocal.Warning("Makron is stuck in a corner!");
cornerCount = 0;
SetState( "Torso_Teleport" );
PostAnimState ( ANIMCHANNEL_TORSO, "Torso_FinishAction", 0, 0, SFLAG_ONCLEAR );
PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", 0, 0 );
PostAnimState ( ANIMCHANNEL_LEGS, "Torso_Idle", 0, 0 );
PostState( "State_Combat" );
return;
}
rvAIAction* action;
rvAIActionTimer* timer;
action = actionArray[ actionPatterned];
timer = &actionTimerRangedAttack;
//if the attack is variable length, then do all this jive...
float scale;
scale = 1.0f;
//gameLocal.Printf("performing the action\n");
// Perform the raw action
PerformAction ( action->state, action->blendFrames, action->fl.noPain );
//Clear this out so the next attack can be queued up.
actionPatterned = -1;
// Restart the action timer using the length of the animation being played
// Even though we don't use the action timer for this instance, we need to keep it updated and fresh.
action->timer.Reset ( actionTime, action->diversity, scale );
// Restart the global action timer using the length of the animation being played
if ( timer ) {
timer->Reset ( actionTime, action->diversity, scale );
}
}
/*
================
rvMonsterMakron::CanTurn
================
*/
bool rvMonsterBossMakron::CanTurn ( void ) const {
if( !flagFlyingMode ) {
if ( !idAI::CanTurn ( ) ) {
return false;
}
return move.anim_turn_angles != 0.0f || move.fl.moving;
} else {
return idAI::CanTurn ( );
}
}
/*
================
rvMonsterMakron::InitBoltSweep
================
*/
void rvMonsterBossMakron::InitBoltSweep ( idVec3 idealTarget ) {
idVec3 origin;
idMat3 axis;
trace_t tr;
idVec3 fwd;
idVec3 right;
idVec3 worldup(0,0,1);
idVec3 targetPoint;
//init all the lightning bolt stuff
boltTime = 0;
flagSweepDone = false;
stateBoltSweep = 0;
//get the vector from makron's gun to the target point.
GetJointWorldTransform( jointLightningBolt, gameLocal.time, origin, axis);
targetPoint = idealTarget; //enemy.lastVisibleChestPosition;
fwd = targetPoint - origin;
fwd.Normalize();
right = fwd.Cross( worldup);
boltAimMatrix[0] = fwd;
boltAimMatrix[1] = right;
boltAimMatrix[2] = worldup;
targetPoint = origin + (fwd * 2400);
//left
targetPoint = targetPoint - (right * 1800);
boltVectorMin = targetPoint - origin;
boltVectorMin.Normalize();
leftBoltVector = boltVectorMin;
//right
targetPoint = targetPoint + (right * 1800 * 2);
boltVectorMax = targetPoint - origin;
boltVectorMax.Normalize();
rightBoltVector = boltVectorMax;
}
/*
================
rvMonsterMakron::MaintainBoltSweep
================
*/
void rvMonsterBossMakron::MaintainBoltSweep ( void ) {
enum {
STATE_START,
STATE_WAIT1,
STATE_SWEEP1,
STATE_WAIT2,
STATE_SWEEP2,
STATE_END,
};
//advance the state when time is up.
switch( stateBoltSweep ) {
//init vars
case STATE_START:
flagSweepDone = false;
boltNextStateTime = gameLocal.time + SEC2MS( boltWaitTime);
StopAllBoltEffects();
stateBoltSweep = STATE_WAIT1;
return;
//blast at the waiting points, vectors do not move
case STATE_WAIT1:
LightningSweep( leftBoltVector, leftBoltEffect, leftBoltImpact);
LightningSweep( rightBoltVector, rightBoltEffect, rightBoltImpact );
//check for state advance
if( gameLocal.time > boltNextStateTime) {
stateBoltSweep++;
boltNextStateTime = gameLocal.time + SEC2MS( boltSweepTime);
boltTime = 0;
boltSweepStartTime = gameLocal.time;
}
return;
case STATE_SWEEP1:
//lerp the lightning bolt vectors
boltTime = gameLocal.time - boltSweepStartTime;
leftBoltVector.Lerp( boltVectorMin, boltVectorMax, boltTime / SEC2MS(boltSweepTime));
rightBoltVector.Lerp( boltVectorMax, boltVectorMin, boltTime / SEC2MS(boltSweepTime));
//sweep
LightningSweep( leftBoltVector, leftBoltEffect, leftBoltImpact);
LightningSweep( rightBoltVector, rightBoltEffect, rightBoltImpact );
//check for state advance
if( gameLocal.time > boltNextStateTime) {
stateBoltSweep++;
boltNextStateTime = gameLocal.time + SEC2MS( boltWaitTime);
}
return;
case STATE_WAIT2:
LightningSweep( leftBoltVector, leftBoltEffect, leftBoltImpact);
LightningSweep( rightBoltVector, rightBoltEffect, rightBoltImpact );
//check for state advance
if( gameLocal.time > boltNextStateTime) {
stateBoltSweep++;
boltNextStateTime = gameLocal.time + SEC2MS( boltSweepTime);
boltTime = 0;
boltSweepStartTime = gameLocal.time;
}
return;
case STATE_SWEEP2:
//lerp the lightning bolt vectors
boltTime = gameLocal.time - boltSweepStartTime;
//min and max are reversed here.
leftBoltVector.Lerp( boltVectorMax, boltVectorMin, boltTime / SEC2MS(boltSweepTime));
rightBoltVector.Lerp( boltVectorMin, boltVectorMax, boltTime / SEC2MS(boltSweepTime));
//sweep
LightningSweep( leftBoltVector, leftBoltEffect, leftBoltImpact);
LightningSweep( rightBoltVector, rightBoltEffect, rightBoltImpact );
//check for state advance
if( gameLocal.time > boltNextStateTime) {
stateBoltSweep++;
boltNextStateTime = 0;
StopAllBoltEffects();
}
return;
case STATE_END:
flagSweepDone = 1;
return;
}
}
/*
================
rvMonsterBossMakron::LightningSweep
================
*/
void rvMonsterBossMakron::LightningSweep ( idVec3 attackVector, rvClientEffectPtr& boltEffect, rvClientEffectPtr& impactEffect ) {
idVec3 origin;
idMat3 axis;
trace_t tr;
GetJointWorldTransform( jointLightningBolt, gameLocal.time, origin, axis);
//trace out from origin along attackVector
attackVector.Normalize();
gameLocal.TracePoint( this, tr, origin, origin + (attackVector * 25600), MASK_SHOT_RENDERMODEL, this);
//gameRenderWorld->DebugLine( colorRed, origin, tr.c.point, 100, true);
if ( !boltEffect ) {
boltEffect = gameLocal.PlayEffect ( gameLocal.GetEffect ( this->spawnArgs, "fx_sweep_fly" ), origin, attackVector.ToMat3(), true, tr.c.point);
} else {
boltEffect->SetOrigin ( origin );
boltEffect->SetAxis ( attackVector.ToMat3() );
boltEffect->SetEndOrigin ( tr.c.point );
}
if ( !impactEffect ) {
impactEffect = gameLocal.PlayEffect ( gameLocal.GetEffect ( this->spawnArgs, "fx_sweep_impact" ), tr.c.point, tr.c.normal.ToMat3(), true, tr.c.point);
} else {
impactEffect->SetOrigin ( tr.c.point );
impactEffect->SetAxis ( tr.c.normal.ToMat3() );
impactEffect->SetEndOrigin ( tr.c.point );
}
if ( !boltMuzzleFlash ) {
boltMuzzleFlash = gameLocal.PlayEffect ( gameLocal.GetEffect ( this->spawnArgs, "fx_sweep_muzzle" ), origin, attackVector.ToMat3(), true, origin);
} else {
boltMuzzleFlash->SetOrigin ( origin );
boltMuzzleFlash->SetAxis ( attackVector.ToMat3() );
boltMuzzleFlash->SetEndOrigin ( origin );
}
//hurt anything in the way
idEntity* ent = gameLocal.entities[tr.c.entityNum];
if( ent) {
ent->Damage ( this, this, attackVector, spawnArgs.GetString ( "def_makron_sweep_damage" ), 1.0f, 0 );
}
}
/*
================
rvMonsterBossMakron::PerformAction
================
*/
void rvMonsterBossMakron::PerformAction ( const char* stateName, int blendFrames, bool noPain ) {
// Allow movement in actions
move.fl.allowAnimMove = true;
// Start the action
SetAnimState ( ANIMCHANNEL_TORSO, stateName, blendFrames );
// Always call finish action when the action is done, it will clear the action flag
aifl.action = true;
PostAnimState ( ANIMCHANNEL_TORSO, "Torso_FinishAction", 0, 0, SFLAG_ONCLEAR );
// Go back to idle when done-- sometimes.
if ( !noIdle ) {
PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", blendFrames );
}
// Main state will wait until action is finished before continuing
InterruptState ( "Wait_ActionNoPain" );
OnStartAction ( );
}
/*
================
rvMonsterBossMakron::PerformAction
================
*/
bool rvMonsterBossMakron::PerformAction( rvAIAction* action, bool (idAI::*condition)(rvAIAction*,int), rvAIActionTimer* timer ) {
return idAI::PerformAction( action, condition ,timer );
}
/*
================
rvMonsterBossMakron::PerformAction
================
*/
void rvMonsterBossMakron::OnStopAction( void ) {
////gameLocal.Printf("\n\nAction stopped ----------- \n");
}
/*
================
rvMonsterBossMakron::Damage
================
*/
void rvMonsterBossMakron::Damage( idEntity *inflictor, idEntity *attacker, const idVec3 &dir,
const char *damageDefName, const float damageScale, const int location ) {
//Deal damage here,
idAI::Damage( inflictor, attacker, dir, damageDefName, damageScale, location );
//if the Makron has 0 or less health, make sure he's killed
///if ( health <= 0 && !flagFlyingMode && !flagFakeDeath ) {
// Killed( this, this, 1, dir, location);
//}
}
/*
================
rvMonsterBossMakron::Killed
================
*/
void rvMonsterBossMakron::Killed( idEntity *inflictor, idEntity *attacker, int damage, const idVec3 &dir, int location ) {
//if this is the undying Makron Jr, don't worry about death. Stop what we're doing,
//Call the script function and let it ride.
if( flagUndying == 1) {
flagUndying = 2;
ExecScriptFunction( funcs.death );
StopAnimState ( ANIMCHANNEL_TORSO );
StopAnimState ( ANIMCHANNEL_LEGS );
PerformAction ( actionKillPlayer.state, actionKillPlayer.blendFrames, actionKillPlayer.fl.noPain );
return;
}
if( flagUndying == 2) {
return;
}
//stop all effects.
StopAllEffects();
//if the makron isn't in flying mode, it is now.
if( flagFlyingMode ) {
//play the falling animation, then die.
StopAnimState ( ANIMCHANNEL_TORSO );
StopAnimState ( ANIMCHANNEL_LEGS );
//SetState( "Torso_Death_Fall" );
idAI::Killed( inflictor, attacker, damage, dir, location);
return;
}
//the Makron is in undying mode until he finishes getting up.
//gameLocal.Warning("First form defeated!");
health = 1;
aifl.undying = true;
fl.takedamage = false;
SetMoveType ( MOVETYPE_DEAD );
StopMove( MOVE_STATUS_DONE );
//gameLocal.Printf("************\n************\n************\n************\n---flagFakeDeath set to TRUE! ************\n************\n************\n************\n" );
flagFakeDeath = true;
//play the death anim
StopAnimState ( ANIMCHANNEL_TORSO );
StopAnimState ( ANIMCHANNEL_LEGS );
if ( head ) {
StopAnimState ( ANIMCHANNEL_HEAD );
}
//Call this anyway-- hopefully the script is prepared to handle multiple Makron deaths...
ExecScriptFunction( funcs.death );
//make sure he goes through deadness, but we need to post FinishAction afterwards
// SetState( "Torso_FirstDeath" );
// aifl.action = true;
SetState( "Torso_FirstDeath" );
// PostAnimState ( ANIMCHANNEL_TORSO, "Torso_FinishAction", 0, 0, SFLAG_ONCLEAR );
// PostAnimState ( ANIMCHANNEL_TORSO, "Torso_FirstDeath", 30, 0, SFLAG_ONCLEAR );
}
/*
================
rvMonsterBossMakron::BeginSeparation( void )
================
*/
void rvMonsterBossMakron::BeginSeparation( void ) {
//spawn in a new Makron leg,
idDict args;
idEntity* newLegs;
//We may need to do this at a later point
//SetSkin ( declManager->FindSkin ( spawnArgs.GetString ( "skin_legs" ) ) );
args.Copy ( *gameLocal.FindEntityDefDict ( "monster_makron_legs" ) );
args.SetVector ( "origin", GetPhysics()->GetOrigin() );
args.SetInt ( "angle", move.current_yaw );
gameLocal.SpawnEntityDef ( args, &newLegs );
//store the name of the entity in the Makron's keys so we can burn it out as well.
spawnArgs.Set( "legs_name", newLegs->GetName() );
}
/*
================
rvMonsterBossMakron::CompleteSeparation( void )
================
*/
void rvMonsterBossMakron::CompleteSeparation( void ) {
//flying mode now
flagFlyingMode = true;
SetMoveType ( MOVETYPE_FLY );
move.fl.noGravity = true;
animPrefix = "fly";
//is there a cooler way to do this? Heal over time?
//health = spawnArgs.GetFloat("health_flying", "5000" );
ExecScriptFunction( funcs.init);
//makron is once again pwnable.
aifl.undying = false;
fl.takedamage = true;
flagFakeDeath = false;
patternedMode = true;
//make sure he cleans up.
// PostAnimState ( ANIMCHANNEL_ALL, "Torso_FinishAction", 0, 0, SFLAG_ONCLEAR );
// PostAnimState ( ANIMCHANNEL_TORSO, "Torso_FinishAction", 0, 0, SFLAG_ONCLEAR );
// PostAnimState ( ANIMCHANNEL_LEGS, "Torso_FinishAction", 0, 0, SFLAG_ONCLEAR );
//gameLocal.Printf("*****\n*****\n*****\nPast 'PostAnimState' flagFakeDeath is: %d \n*****\n*****\n*****\n", flagFakeDeath);
// These four lines work!
PostAnimState ( ANIMCHANNEL_TORSO, "Torso_FinishAction", 0, 0, SFLAG_ONCLEAR );
PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Idle", 0, 0 );
PostAnimState ( ANIMCHANNEL_LEGS, "Torso_Idle", 0, 0 );
PostState( "State_Combat" );
}
/*
================
rvMonsterBossMakron::ScriptedFace( idEntity* faceEnt, bool endWithIdle )
================
*/
/*
void rvMonsterBossMakron::ScriptedFace ( idEntity* faceEnt, bool endWithIdle ) {
//set the ideal yaw, the change to the facing state.
FaceEntity( faceEnt );
//store the ideal yaw, because somehow between here and the state we set it gets stomped.
facingIdealYaw = move.ideal_yaw;
//become scripted
aifl.scripted = true;
//This will get us close to facing the entity correctly.
SetState( "State_ScriptedFace", SFLAG_ONCLEAR);
}
*/
/*
===============================================================================
Events
===============================================================================
*/
/*
================
rvMonsterBossMakron::Event_AllowMoreSpawns
================
*/
// this will allow Makron to spawn more baddies.
void rvMonsterBossMakron::Event_AllowMoreSpawns( void ) {
flagAllowSpawns = true;
}
/*
================
rvMonsterBossMakron::Event_EnablePatternMode
================
*/
// When set, the Makron will now only fight via scripted patterns
void rvMonsterBossMakron::Event_EnablePatternMode( void ) {
patternedMode = true;
noIdle = true;
flagTeleporting = false;
}
/*
================
rvMonsterBossMakron::Event_DisablePatternMode
================
*/
void rvMonsterBossMakron::Event_DisablePatternMode( void ) {
patternedMode = false;
noIdle = false;
}
/*
================
rvMonsterBossMakron::Event_Separate
================
*/
void rvMonsterBossMakron::Event_Separate( void ) {
//all we need to do here is post the separation state, right?
BeginSeparation();
PostAnimState ( ANIMCHANNEL_TORSO, "Torso_Resurrection", 0, 5000, SFLAG_ONCLEAR );
}
/*
================
rvMonsterBossMakron::Event_Separate
================
*/
void rvMonsterBossMakron::Event_FlyingRotate( idVec3& vecOrg ) {
//set move.ideal_yaw
TurnToward( vecOrg );
//copy it over
facingIdealYaw = move.ideal_yaw;
aifl.scripted = true;
//set the state
SetState( "Torso_RotateToAngle");
}
/*
================
rvMonsterBossMakron::Event_SetNextAction
================
*/
void rvMonsterBossMakron::Event_SetNextAction( const char * actionString) {
//if the next action is occupied, return false
if( actionPatterned != -1) {
idThread::ReturnFloat(0);
return;
}
//otherwise, select the action from a list
if( !idStr::Cmp( actionString, "actionCannon")) {
actionPatterned = MAKRON_ACTION_CANNON;
}
else if( !idStr::Cmp( actionString, "actionCannonSweep")) {
actionPatterned = MAKRON_ACTION_CANNON_SWEEP;
}
else if( !idStr::Cmp( actionString, "actionDMG")) {
actionPatterned = MAKRON_ACTION_DMG;
}
else if( !idStr::Cmp( actionString, "actionDMGrenades")) {
actionPatterned = MAKRON_ACTION_GRENADE;
}
else if( !idStr::Cmp( actionString, "actionLightningSweep1")) {
actionPatterned = MAKRON_ACTION_LIGHTNING_1;
}
else if( !idStr::Cmp( actionString, "actionLightningSweep2")) {
actionPatterned = MAKRON_ACTION_LIGHTNING_2;
}
else if( !idStr::Cmp( actionString, "actionStomp")) {
actionPatterned = MAKRON_ACTION_STOMP;
}
else if( !idStr::Cmp( actionString, "actionHeal")) {
actionPatterned = MAKRON_ACTION_HEAL;
}
else if( !idStr::Cmp( actionString, "actionCharge")) {
actionPatterned = MAKRON_ACTION_CHARGE;
}
else if( !idStr::Cmp( actionString, "actionKillPlayer")) {
actionPatterned = MAKRON_ACTION_KILLPLAYER;
}
else if( !idStr::Cmp( actionString, "actionEndPattern")) {
actionPatterned = -1;
}
else {
gameLocal.Error(" Bad action %s passed into MonsterMakron::SetNextAction", actionString);
idThread::ReturnFloat(0);
return;
}
idThread::ReturnFloat(1);
return;
}
/*
===============================================================================
States
===============================================================================
*/
CLASS_STATES_DECLARATION ( rvMonsterBossMakron )
STATE ( "Torso_DMGAttack", rvMonsterBossMakron::State_Torso_DMGAttack )
STATE ( "Torso_MeleeAttack", rvMonsterBossMakron::State_Torso_MeleeAttack )
STATE ( "Torso_CannonAttack", rvMonsterBossMakron::State_Torso_CannonAttack )
STATE ( "Torso_GrenadeAttack", rvMonsterBossMakron::State_Torso_GrenadeAttack )
STATE ( "Torso_CannonSweepAttack", rvMonsterBossMakron::State_Torso_CannonSweepAttack )
STATE ( "Torso_Lightning1Attack", rvMonsterBossMakron::State_Torso_Lightning1Attack )
STATE ( "Torso_Lightning2Attack", rvMonsterBossMakron::State_Torso_Lightning2Attack )
STATE ( "Torso_StompAttack", rvMonsterBossMakron::State_Torso_StompAttack )
STATE ( "Torso_Recharge", rvMonsterBossMakron::State_Torso_Recharge )
STATE ( "Torso_Charge", rvMonsterBossMakron::State_Torso_Charge )
STATE ( "Torso_KillPlayer", rvMonsterBossMakron::State_Torso_KillPlayer )
STATE ( "Torso_FirstDeath", rvMonsterBossMakron::State_Torso_FirstDeath )
STATE ( "Torso_Resurrection", rvMonsterBossMakron::State_Torso_Resurrection )
STATE ( "State_Killed", rvMonsterBossMakron::State_Killed )
STATE ( "Torso_Teleport", rvMonsterBossMakron::State_Torso_Teleport )
STATE ( "Torso_TurnRight90", rvMonsterBossMakron::State_Torso_TurnRight90 )
STATE ( "Torso_TurnLeft90", rvMonsterBossMakron::State_Torso_TurnLeft90 )
STATE ( "Torso_RotateToAngle", rvMonsterBossMakron::State_Torso_RotateToAngle )
STATE ( "Frame_BeginLightningSweep2", rvMonsterBossMakron::Frame_BeginLightningSweep2 )
STATE ( "Frame_EndLightningSweep2", rvMonsterBossMakron::Frame_EndLightningSweep2 )
STATE ( "Frame_StompAttack", rvMonsterBossMakron::Frame_StompAttack )
STATE ( "Frame_Teleport", rvMonsterBossMakron::Frame_Teleport )
STATE ( "State_ScriptedFace", rvMonsterBossMakron::State_ScriptedFace )
END_CLASS_STATES
/*
================
rvBossMakron::State_Torso_DMGAttack
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_DMGAttack ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT
};
switch( parms.stage ) {
case STAGE_INIT:
//gameLocal.Warning("Makron DMG Go!");
//fire the DMG
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "range_attack_dmg", parms.blendFrames );
return SRESULT_STAGE ( STAGE_WAIT);
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvBossMakron::State_Torso_Charge
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_Charge ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT
};
switch( parms.stage ) {
case STAGE_INIT:
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "run", parms.blendFrames );
return SRESULT_STAGE ( STAGE_WAIT);
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvBossMakron::State_ScriptedFace
================
*/
stateResult_t rvMonsterBossMakron::State_ScriptedFace ( const stateParms_t& parms ) {
//note this uses the Makron's version of FacingIdeal,
if( !flagFlyingMode) {
if ( !aifl.scripted || (!CheckTurnActions( ) && (!move.anim_turn_angles))) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
} else {
if ( !aifl.scripted || FacingIdeal() ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
}
/*
enum {
STAGE_INIT,
STAGE_WAIT
};
idStr turnAnim;
float turnYaw;
switch( parms.stage ) {
case STAGE_INIT:
DisableAnimState ( ANIMCHANNEL_LEGS );
//which way do we need to face?
turnYaw = idMath::AngleNormalize180 ( facingIdealYaw - move.current_yaw ) ;
if ( turnYaw > lookMax[YAW] * 0.75f ) {
turnAnim = "turn_right_90";
} else if ( turnYaw < -lookMax[YAW] * 0.75f ) {
turnAnim = "turn_left_90";
} else {
//guess we don't need to turn? We're done.
aifl.scripted = false;
return SRESULT_DONE;
}
PlayAnim ( ANIMCHANNEL_TORSO, turnAnim, 4 );
AnimTurn ( 90.0f, true );
return SRESULT_WAIT;
case STAGE_WAIT:
if ( move.fl.moving || AnimDone ( ANIMCHANNEL_TORSO, 0 )) {
AnimTurn ( 0, true );
combat.investigateTime = gameLocal.time + 250;
//back to the start to make sure we're facing the right way.
return SRESULT_STAGE ( STAGE_INIT );
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
*/
/*
================
rvBossMakron::State_Torso_FirstDeath
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_FirstDeath ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT
};
switch( parms.stage ) {
case STAGE_INIT:
DisableAnimState ( ANIMCHANNEL_LEGS );
//force a long blend on this anim since it will be sudden
PlayAnim ( ANIMCHANNEL_TORSO, "separation_start", 30 );
return SRESULT_STAGE ( STAGE_WAIT);
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvBossMakron::State_Torso_Resurrection
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_Resurrection ( const stateParms_t& parms ) {
/* enum {
STAGE_INIT,
STAGE_WAIT_FIRST,
STAGE_RISE,
STAGE_WAIT_SECOND
};
switch( parms.stage ) {
case STAGE_INIT:
DisableAnimState ( ANIMCHANNEL_LEGS );
//force a long blend on this anim since it will be sudden
PlayAnim ( ANIMCHANNEL_TORSO, "separation_start", 30 );
return SRESULT_STAGE ( STAGE_WAIT_FIRST);
case STAGE_WAIT_FIRST:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_STAGE ( STAGE_RISE);
}
return SRESULT_WAIT;
case STAGE_RISE:
//hide the leg surface
const idKeyValue* kv;
kv = spawnArgs.MatchPrefix ( "surface_legs" );
HideSurface ( kv->GetValue() );
//start the effect
jointHoverEffect = animator.GetJointHandle ( spawnArgs.GetString("joint_hover","thruster") );
effectHover = PlayEffect ( "fx_hover", jointHoverEffect, true );
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "separation_rise", parms.blendFrames );
return SRESULT_STAGE ( STAGE_WAIT_SECOND);
case STAGE_WAIT_SECOND:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
CompleteSeparation();
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
*/
enum {
STAGE_RISE,
STAGE_WAIT,
};
switch( parms.stage ) {
case STAGE_RISE:
//hide the leg surface
const idKeyValue* kv;
kv = spawnArgs.MatchPrefix ( "surface_legs" );
HideSurface ( kv->GetValue() );
//start the effect
jointHoverEffect = animator.GetJointHandle ( spawnArgs.GetString("joint_hover","thruster") );
effectHover = PlayEffect ( "fx_hover", jointHoverEffect, true );
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "separation_rise", parms.blendFrames );
return SRESULT_STAGE ( STAGE_WAIT);
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
CompleteSeparation();
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvBossMakron::State_Lightning2Attack
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_Lightning2Attack ( const stateParms_t& parms ) {
idVec3 boltVector;
enum {
STAGE_INIT,
STAGE_WAIT,
};
switch( parms.stage ) {
case STAGE_INIT:
//prep up for the bolt
//gameLocal.Warning("Prepping sweep 2");
//init these values
StopAllBoltEffects();
stateBoltSweep = 0;
flagSweepDone = false;
//set up bolt targeting at a little above the players chest-- make him duck this one.
boltVector = enemy.lastVisibleEyePosition;
boltVector.z += 8;
InitBoltSweep( boltVector );
//play the anim
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "claw_sweep", parms.blendFrames );
return SRESULT_STAGE ( STAGE_WAIT);
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_DONE;
}
if( stateBoltSweep == 1) {
//fire the bolt out from the claw based on where the claw is pointing, sort of.
boltTime = gameLocal.time - boltSweepStartTime;
leftBoltVector.Lerp( boltVectorMax, boltVectorMin, boltTime / SEC2MS(boltSweepTime));
LightningSweep( leftBoltVector, leftBoltEffect, leftBoltImpact );
}
else if( stateBoltSweep == 2) {
//gameLocal.Warning("Sweep 2 done.");
StopAllBoltEffects();
stateBoltSweep = 0;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterBossMakron::State_Torso_StompAttack
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_StompAttack( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT,
};
switch( parms.stage ) {
case STAGE_INIT:
//can't do the stomp attack while flying-- ain't got no legs!!
if ( flagFlyingMode ) {
return SRESULT_DONE;
}
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "shockwave_stomp", parms.blendFrames );
return SRESULT_STAGE ( STAGE_WAIT);
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterBossMakron::State_Torso_Teleport
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_Teleport( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT,
};
switch( parms.stage ) {
case STAGE_INIT:
//No teleporting in flying mode.
if ( flagFlyingMode ) {
return SRESULT_DONE;
}
DisableAnimState ( ANIMCHANNEL_LEGS );
//can't take damage in teleport anim, bad things happen!
aifl.undying = true;
PlayAnim ( ANIMCHANNEL_TORSO, "teleport_stomp", parms.blendFrames );
return SRESULT_STAGE ( STAGE_WAIT);
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
//restore former state, which is killable unless some other effect renders Makron unkillable.
if( !flagUndying ) {
aifl.undying = false;
}
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvBossMakron::State_Torso_GrenadeAttack
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_GrenadeAttack ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT
};
switch( parms.stage ) {
case STAGE_INIT:
//gameLocal.Warning("Grenades!");
//fire the DMG
DisableAnimState ( ANIMCHANNEL_LEGS );
//only allow spawns if the script tells us we can
if( !flagAllowSpawns) {
PlayAnim ( ANIMCHANNEL_TORSO, "range_attack_grenade_dm", parms.blendFrames );
}
else {
flagAllowSpawns = false;
PlayAnim ( ANIMCHANNEL_TORSO, "range_attack_grenade_spawn", parms.blendFrames );
}
return SRESULT_STAGE ( STAGE_WAIT);
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvBossMakron::State_Torso_Recharge
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_Recharge ( const stateParms_t& parms ) {
ExecScriptFunction( scriptRecharge );
return SRESULT_DONE;
}
/*
================
rvBossMakron::State_Torso_MeleeAttack
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_MeleeAttack ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT
};
switch( parms.stage ) {
case STAGE_INIT:
//swing!
//gameLocal.Warning("Makron Melee Attack");
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "melee_attack", parms.blendFrames );
return SRESULT_STAGE ( STAGE_WAIT);
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterBossMakron::State_Torso_RotateToAngle
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_RotateToAngle ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT_LOOP,
};
float facingTimeDelta;
float turnYaw;
switch ( parms.stage ) {
case STAGE_INIT:
DisableAnimState ( ANIMCHANNEL_LEGS );
turnYaw = idMath::AngleNormalize180 ( facingIdealYaw - move.current_yaw ) ;
if( turnYaw > 1.0f || turnYaw < -1.0f) {
facingTime = MS2SEC( gameLocal.time);
aifl.scripted = true;
return SRESULT_STAGE ( STAGE_WAIT_LOOP );
}
aifl.scripted = false;
return SRESULT_DONE;
case STAGE_WAIT_LOOP:
turnYaw = idMath::AngleNormalize180 ( facingIdealYaw - move.current_yaw ) ;
if( turnYaw > 1.0f || turnYaw < -1.0f) {
facingTimeDelta = MS2SEC( gameLocal.time) - facingTime;
idAngles ang = GetPhysics()->GetAxis().ToAngles();
ang.yaw += ( turnRate * facingTimeDelta );
SetAngles( ang);
move.current_yaw = ang.yaw;
return SRESULT_STAGE( STAGE_WAIT_LOOP);
}
aifl.scripted = false;
return SRESULT_DONE;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterBossMakron::State_Torso_TurnRight90
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_TurnRight90 ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT
};
switch ( parms.stage ) {
case STAGE_INIT:
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "turn_right_90", parms.blendFrames );
AnimTurn ( 90.0f, true );
return SRESULT_STAGE ( STAGE_WAIT );
case STAGE_WAIT:
if ( move.fl.moving || AnimDone ( ANIMCHANNEL_TORSO, 0 )) {
AnimTurn ( 0, true );
combat.investigateTime = gameLocal.time + 250;
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterBossMakron::State_Torso_TurnLeft90
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_TurnLeft90 ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT
};
switch ( parms.stage ) {
case STAGE_INIT:
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "turn_left_90", parms.blendFrames );
AnimTurn ( 90.0f, true );
return SRESULT_STAGE ( STAGE_WAIT );
case STAGE_WAIT:
if ( move.fl.moving || AnimDone ( ANIMCHANNEL_TORSO, 0 )) {
AnimTurn ( 0, true );
combat.investigateTime = gameLocal.time + 250;
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterBossMakron::State_Torso_CannonAttack
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_CannonAttack ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAITSTART,
STAGE_LOOP,
STAGE_WAITLOOP,
STAGE_WAITEND
};
//once an anim starts with the legs disabled, the rest of the anims should match that.
static bool noLegs;
switch ( parms.stage ) {
case STAGE_INIT:
//if flying, do not override legs
if( !flagFlyingMode || ( flagFlyingMode && !move.fl.moving )) {
noLegs = true;
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "range_cannon_start", parms.blendFrames );
} else {
noLegs = false;
PlayAnim ( ANIMCHANNEL_TORSO, "range_cannon_start", parms.blendFrames );
PlayAnim ( ANIMCHANNEL_LEGS, "range_cannon_start", parms.blendFrames );
}
shots = (gameLocal.random.RandomInt ( 8 ) + 4) * combat.aggressiveScale;
return SRESULT_STAGE ( STAGE_WAITSTART );
case STAGE_WAITSTART:
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
return SRESULT_STAGE ( STAGE_LOOP );
}
return SRESULT_WAIT;
case STAGE_LOOP:
//if we're flying, and moving, fire fast!
//if( flagFlyingMode && move.fl.moving ) {
if( !noLegs ) {
PlayAnim ( ANIMCHANNEL_TORSO, "range_cannon_fire_fast", 0 );
PlayAnim ( ANIMCHANNEL_LEGS, "range_cannon_fire_fast", 0 );
} else {
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "range_cannon_fire", 0 );
}
return SRESULT_STAGE ( STAGE_WAITLOOP );
case STAGE_WAITLOOP:
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
if ( --shots <= 0 || (IsEnemyVisible() && !enemy.fl.inFov) ) {
//if( flagFlyingMode && move.fl.moving ) {
if( !noLegs ) {
PlayAnim ( ANIMCHANNEL_TORSO, "range_cannon_end", 0 );
PlayAnim ( ANIMCHANNEL_LEGS, "range_cannon_end", 0 );
} else {
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "range_cannon_end", 0 );
}
return SRESULT_STAGE ( STAGE_WAITEND );
}
return SRESULT_STAGE ( STAGE_LOOP );
}
return SRESULT_WAIT;
case STAGE_WAITEND:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterBossMakron::State_Torso_Lightning1Attack
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_Lightning1Attack ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAITSTART,
STAGE_INIT_BOLT,
STAGE_LOOP,
STAGE_WAITLOOP,
STAGE_WAITEND
};
idVec3 origin;
idVec3 targetPoint;
idMat3 axis;
trace_t tr;
switch ( parms.stage ) {
case STAGE_INIT:
//gameLocal.Warning( "Lightningbolt!");
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "range_blast_start", parms.blendFrames );
shots = (gameLocal.random.RandomInt ( 3 ) + 2) * combat.aggressiveScale;
return SRESULT_STAGE ( STAGE_WAITSTART );
case STAGE_WAITSTART:
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
return SRESULT_STAGE ( STAGE_INIT_BOLT );
}
return SRESULT_WAIT;
case STAGE_INIT_BOLT:
//aim a little below the player's chest
targetPoint = enemy.lastVisibleChestPosition;
targetPoint.z -= 24;
InitBoltSweep( targetPoint );
return SRESULT_STAGE ( STAGE_LOOP );
case STAGE_LOOP:
PlayAnim ( ANIMCHANNEL_TORSO, "range_blast_loop", 0 );
return SRESULT_STAGE ( STAGE_WAITLOOP );
case STAGE_WAITLOOP:
//sweep the blasts back and forth
MaintainBoltSweep();
//keep playing the anim until the sweeping is done.
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) || flagFakeDeath ) {
if ( flagSweepDone ) {
PlayAnim ( ANIMCHANNEL_TORSO, "range_blast_end", 0 );
return SRESULT_STAGE ( STAGE_WAITEND );
}
else {
PlayAnim ( ANIMCHANNEL_TORSO, "range_blast_loop", 0 );
}
}
return SRESULT_WAIT;
case STAGE_WAITEND:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterBossMakron::State_Torso_KillPlayer
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_KillPlayer ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAITSTART,
STAGE_LOOP,
STAGE_WAITLOOP,
STAGE_WAITEND
};
switch ( parms.stage ) {
case STAGE_INIT:
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "range_blast_start", parms.blendFrames );
shots = 8;
return SRESULT_STAGE ( STAGE_WAITSTART );
case STAGE_WAITSTART:
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
return SRESULT_STAGE ( STAGE_LOOP );
}
return SRESULT_WAIT;
case STAGE_LOOP:
PlayAnim ( ANIMCHANNEL_TORSO, "range_blast_loop_killplayer", 0 );
return SRESULT_STAGE ( STAGE_WAITLOOP );
case STAGE_WAITLOOP:
//keep playing the anim until the sweeping is done.
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) || flagFakeDeath ) {
shots--;
if ( shots < 1) {
PlayAnim ( ANIMCHANNEL_TORSO, "range_blast_end", 0 );
return SRESULT_STAGE ( STAGE_WAITEND );
}
else {
PlayAnim ( ANIMCHANNEL_TORSO, "range_blast_loop_killplayer", 0 );
}
}
return SRESULT_WAIT;
case STAGE_WAITEND:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvBossMakron::State_Torso_CannonSweepAttack
================
*/
stateResult_t rvMonsterBossMakron::State_Torso_CannonSweepAttack ( const stateParms_t& parms ) {
enum {
STAGE_INIT,
STAGE_WAIT
};
switch( parms.stage ) {
case STAGE_INIT:
//gameLocal.Warning("Makron CannonSweep Go!");
//sweep across with the cannon
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "range_attack_cannonsweep", parms.blendFrames );
return SRESULT_STAGE ( STAGE_WAIT);
case STAGE_WAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
return SRESULT_DONE;
}
//if the flag is up, fire.
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterBossMakron::State_Killed
================
*/
stateResult_t rvMonsterBossMakron::State_Killed ( const stateParms_t& parms ) {
enum {
STAGE_FALLSTART,
STAGE_FALLSTARTWAIT,
STAGE_FALLLOOPWAIT,
STAGE_FALLENDWAIT
};
switch ( parms.stage ) {
case STAGE_FALLSTART:
DisableAnimState ( ANIMCHANNEL_LEGS );
PlayAnim ( ANIMCHANNEL_TORSO, "death_start", parms.blendFrames );
return SRESULT_STAGE ( STAGE_FALLSTARTWAIT );
case STAGE_FALLSTARTWAIT:
if ( move.fl.onGround ) {
PlayAnim ( ANIMCHANNEL_TORSO, "death_end", 4 );
return SRESULT_STAGE ( STAGE_FALLENDWAIT );
}
if ( AnimDone ( ANIMCHANNEL_TORSO, 0 ) ) {
PlayAnim ( ANIMCHANNEL_TORSO, "death_loop", 0 );
return SRESULT_STAGE ( STAGE_FALLLOOPWAIT );
}
return SRESULT_WAIT;
case STAGE_FALLLOOPWAIT:
if ( move.fl.onGround ) {
PlayAnim ( ANIMCHANNEL_TORSO, "death_end", 0 );
return SRESULT_STAGE ( STAGE_FALLENDWAIT );
}
return SRESULT_WAIT;
case STAGE_FALLENDWAIT:
if ( AnimDone ( ANIMCHANNEL_TORSO, 4 ) ) {
disablePain = true;
// At this point the Makron is killed!
// Make sure all animation stops
//StopAnimState ( ANIMCHANNEL_TORSO );
//StopAnimState ( ANIMCHANNEL_LEGS );
//if ( head ) {
// StopAnimState ( ANIMCHANNEL_HEAD );
//}
// Make sure all animations stop
//animator.ClearAllAnims ( gameLocal.time, 0 );
if( spawnArgs.GetBool ( "remove_on_death" ) ){
PostState ( "State_Remove" );
} else {
PostState ( "State_Dead" );
}
return SRESULT_DONE;
}
return SRESULT_WAIT;
}
return SRESULT_ERROR;
}
/*
================
rvMonsterBossMakron::Frame_BeginLightningSweep2
================
*/
stateResult_t rvMonsterBossMakron::Frame_BeginLightningSweep2 ( const stateParms_t& parms ) {
//begin the sweep with this flag
stateBoltSweep = 1;
boltSweepStartTime = gameLocal.time;
boltSweepTime = 1;
return SRESULT_OK;
}
/*
================
rvMonsterBossMakron::Frame_BeginLightningSweep2
================
*/
stateResult_t rvMonsterBossMakron::Frame_EndLightningSweep2 ( const stateParms_t& parms ) {
//end the sweep with this flag
stateBoltSweep = 2;
return SRESULT_OK;
}
/*
================
rvMonsterBossMakron::Frame_Teleport
================
*/
stateResult_t rvMonsterBossMakron::Frame_Teleport ( const stateParms_t& parms ) {
//hide
Hide();
//turn on the do-nothing teleport flag
flagTeleporting = true;
//call some script.
ExecScriptFunction( scriptTeleport );
return SRESULT_DONE;
}
/*
================
rvMonsterBossMakron::Frame_StompAttack
================
*/
stateResult_t rvMonsterBossMakron::Frame_StompAttack ( const stateParms_t& parms ) {
idVec3 origin;
idVec3 worldUp(0, 0, 1);
// Eminate from Makron origin
origin = this->GetPhysics()->GetOrigin();
//start radius at 256;
stompRadius = spawnArgs.GetFloat("stomp_start_size", "64");
//stomp
gameLocal.PlayEffect ( gameLocal.GetEffect ( this->spawnArgs, "fx_stomp_wave" ), origin, worldUp.ToMat3(), false, origin);
//bamf!
PostEventMS( &EV_StompAttack, 0, origin);
return SRESULT_OK;
}
/*
================
rvMonsterBossMakron::Event_ToggleCornerState
================
*/
void rvMonsterBossMakron::Event_ToggleCornerState ( float f ) {
if( f == 1.0f) {
flagCornerState = true;
} else {
flagCornerState = false;
}
}
/*
================
rvMonsterBossMakron::Event_StompAttack
================
*/
void rvMonsterBossMakron::Event_StompAttack (idVec3& origin) {
idVec3 targetOrigin;
idVec3 worldUp;
idEntity* entities[ 1024 ];
int count;
int i;
float stompZ;
idVec3 dir;
modelTrace_t result;
stompZ = origin.z;
worldUp.x = 0;
worldUp.y = 0;
worldUp.z = 1;
//if the radius is too big, stop.
if ( stompRadius > stompMaxRadius ) {
return;
}
//get all enemies within radius. If they are:
// within radius,
// more than (radius - stompWidth) units away,
// Z valued within 16 of the the stomp Z
//they take stomp damage.
count = gameLocal.EntitiesWithinRadius ( origin, stompRadius, entities, 1024 );
//gameRenderWorld->DebugCircle( colorRed,origin,worldUp,stompRadius,24,20,false);
//gameRenderWorld->DebugCircle( colorBlue,origin,worldUp,stompRadius - stompWidth,24,20,false);
for ( i = 0; i < count; i ++ ) {
idEntity* ent = entities[i];
//don't stomp ourself, derp...
if ( !ent || ent == this ) {
continue;
}
// Must be an actor that takes damage to be affected
if ( !ent->fl.takedamage || !ent->IsType ( idActor::GetClassType() ) ) {
continue;
}
// Are they Z equal (about?)
targetOrigin = ent->GetPhysics()->GetOrigin();
if( idMath::Abs( targetOrigin.z - origin.z) > 16) {
continue;
}
// are they within the stomp width?
if( targetOrigin.Dist( origin) < ( stompRadius - stompWidth) ||
targetOrigin.Dist( origin) > stompRadius ) {
continue;
}
if( gameRenderWorld->FastWorldTrace(result, origin, ent->GetPhysics()->GetCenterMass()) ) {
continue;
}
//ok, damage them
dir = targetOrigin - origin;
dir.NormalizeFast ( );
ent->Damage ( this, this, dir, spawnArgs.GetString ( "def_makron_stomp_damage" ), 1.0f, 0 );
//gameRenderWorld->DebugArrow( colorYellow, origin, targetOrigin, 5, 1000);
}
//move the radius along
stompRadius += stompSpeed;
//run it back
PostEventSec( &EV_StompAttack, stompSpeed / stompMaxRadius , origin );
}
Reference in a new issue Copy permalink