1236 lines
33 KiB
C++
1236 lines
33 KiB
C++
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Logfile:: /EF2/Code/DLLs/game/coverCombatWithRangedWeapon.cpp $
|
|
// $Revision:: 12 $
|
|
// $Author:: Singlis $
|
|
// $Date:: 9/26/03 2:36p $
|
|
//
|
|
// Copyright (C) 2002 by Ritual Entertainment, Inc.
|
|
// All rights reserved.
|
|
//
|
|
// This source may not be distributed and/or modified without
|
|
// expressly written permission by Ritual Entertainment, Inc.
|
|
//
|
|
//
|
|
// DESCRIPTION:
|
|
// CoverCombatWithRangedWeapon Implementation
|
|
//
|
|
// PARAMETERS:
|
|
// str _movementAnim -- The animation to play while moving to the cover node
|
|
//
|
|
// ANIMATIONS:
|
|
// _movementAnim : PARAMETER
|
|
//--------------------------------------------------------------------------------
|
|
|
|
#include "actor.h"
|
|
#include "coverCombatWithRangedWeapon.hpp"
|
|
|
|
extern Event EV_PostureChanged_Completed;
|
|
|
|
//--------------------------------------------------------------
|
|
//
|
|
// Init Static Vars
|
|
//
|
|
//--------------------------------------------------------------
|
|
const float CoverCombatWithRangedWeapon::NODE_RADIUS = 32.0f;
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
//
|
|
// Class Declaration and Event Registration
|
|
//
|
|
//--------------------------------------------------------------
|
|
CLASS_DECLARATION( Behavior, CoverCombatWithRangedWeapon, NULL )
|
|
{
|
|
{ &EV_Behavior_Args, &CoverCombatWithRangedWeapon::SetArgs },
|
|
{ &EV_Behavior_AnimDone, &CoverCombatWithRangedWeapon::AnimDone },
|
|
{ &EV_PostureChanged_Completed, &CoverCombatWithRangedWeapon::PostureDone },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: CoverCombatWithRangedWeapon()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Constructor
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
CoverCombatWithRangedWeapon::CoverCombatWithRangedWeapon()
|
|
{
|
|
_self = NULL;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: CoverCombatWithRangedWeapon()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Destructor
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
CoverCombatWithRangedWeapon::~CoverCombatWithRangedWeapon()
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: SetArgs()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets Arguments for this behavior
|
|
//
|
|
// Parameters: Event *ev -- Event holding the arguments
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::SetArgs( Event *ev )
|
|
{
|
|
_torsoAnim = ev->GetString ( 1 );
|
|
_fireAnim = ev->GetString ( 2 );
|
|
_movementAnim = ev->GetString ( 3 );
|
|
_maxDistance = ev->GetFloat ( 4 );
|
|
_fireTimeMin = ev->GetFloat ( 5 );
|
|
_fireTimeMax = ev->GetFloat ( 6 );
|
|
_pauseTimeMin = ev->GetFloat ( 7 );
|
|
_pauseTimeMax = ev->GetFloat ( 8 );
|
|
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: AnimDone()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Handles an animation completion
|
|
//
|
|
// Parameters: Event *ev -- Event holding the completion notification
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::AnimDone( Event * )
|
|
{
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: PostureDone()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Handles a Posture Done Event
|
|
//
|
|
// Parameters: Event *ev
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::PostureDone( Event * )
|
|
{
|
|
_finishedPostureTransition = true;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: Begin()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Initializes the behavior
|
|
//
|
|
// Parameters: Actor &self -- The actor executing this behavior
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::Begin( Actor &self )
|
|
{
|
|
init( self );
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: Evaluate()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Evaluates the behavior
|
|
//
|
|
// Parameters: Actor &self -- The actor executing this behavior
|
|
//
|
|
// Returns: BehaviorReturnCode_t
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t CoverCombatWithRangedWeapon::Evaluate( Actor & )
|
|
{
|
|
BehaviorReturnCode_t stateResult;
|
|
|
|
|
|
think();
|
|
|
|
switch ( _state )
|
|
{
|
|
//---------------------------------------------------------------------
|
|
case COVERCOMBAT_WRW_FIND_COVER:
|
|
//---------------------------------------------------------------------
|
|
stateResult = evaluateStateFindCover();
|
|
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
transitionToState( COVERCOMBAT_WRW_FAILED );
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
transitionToState( COVERCOMBAT_WRW_MOVE_TO_COVER );
|
|
|
|
break;
|
|
|
|
//---------------------------------------------------------------------
|
|
case COVERCOMBAT_WRW_FIND_BETTER_COVER:
|
|
//---------------------------------------------------------------------
|
|
stateResult = evaluateStateFindBetterCover();
|
|
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
transitionToState( COVERCOMBAT_WRW_FAILED );
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
transitionToState( COVERCOMBAT_WRW_MOVE_TO_COVER );
|
|
break;
|
|
|
|
//---------------------------------------------------------------------
|
|
case COVERCOMBAT_WRW_MOVE_TO_COVER:
|
|
//---------------------------------------------------------------------
|
|
stateResult = evaluateStateMoveToCover();
|
|
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
transitionToState( COVERCOMBAT_WRW_FAILED );
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
transitionToState( COVERCOMBAT_WRW_CHANGE_POSTURE_DUCK );
|
|
|
|
break;
|
|
|
|
//---------------------------------------------------------------------
|
|
case COVERCOMBAT_WRW_CHANGE_POSTURE_DUCK:
|
|
//---------------------------------------------------------------------
|
|
if ( _spotted )
|
|
{
|
|
transitionToState( COVERCOMBAT_WRW_SPOTTED );
|
|
BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
stateResult = evaluateStateChangePostureDuck();
|
|
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
transitionToState( COVERCOMBAT_WRW_FAILED );
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
transitionToState( COVERCOMBAT_WRW_DUCKED );
|
|
break;
|
|
|
|
//---------------------------------------------------------------------
|
|
case COVERCOMBAT_WRW_CHANGE_POSTURE_STAND:
|
|
//---------------------------------------------------------------------
|
|
if ( _spotted )
|
|
{
|
|
transitionToState( COVERCOMBAT_WRW_SPOTTED );
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
stateResult = evaluateStateChangePostureStand();
|
|
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
transitionToState( COVERCOMBAT_WRW_FAILED );
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
transitionToState( COVERCOMBAT_WRW_STANDING );
|
|
|
|
break;
|
|
|
|
//----------------------------------------------------------------------
|
|
case COVERCOMBAT_WRW_FIRE_STANDING:
|
|
//----------------------------------------------------------------------
|
|
if ( _spotted )
|
|
{
|
|
_fireWeapon.End( *_self );
|
|
setTorsoAnim();
|
|
transitionToState( COVERCOMBAT_WRW_SPOTTED );
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
stateResult = evaluateRotate();
|
|
stateResult = evaluateStateFireStanding();
|
|
|
|
// Check if we need to stop firing
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
{
|
|
transitionToState( COVERCOMBAT_WRW_FAILED );
|
|
_fireWeapon.End( *_self );
|
|
setTorsoAnim();
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
{
|
|
transitionToState( COVERCOMBAT_WRW_FIRE_PAUSE_STANDING );
|
|
_fireWeapon.End( *_self );
|
|
setTorsoAnim();
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
// See if we just need to duck again
|
|
stateResult = evaluateStateStanding();
|
|
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
{
|
|
transitionToState( COVERCOMBAT_WRW_FAILED );
|
|
_fireWeapon.End( *_self );
|
|
setTorsoAnim();
|
|
}
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
{
|
|
transitionToState( COVERCOMBAT_WRW_CHANGE_POSTURE_DUCK );
|
|
_fireWeapon.End( *_self );
|
|
setTorsoAnim();
|
|
}
|
|
|
|
break;
|
|
|
|
//----------------------------------------------------------------------
|
|
case COVERCOMBAT_WRW_FIRE_PAUSE_STANDING:
|
|
//----------------------------------------------------------------------
|
|
if ( _spotted )
|
|
{
|
|
transitionToState( COVERCOMBAT_WRW_SPOTTED );
|
|
BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
stateResult = evaluateRotate();
|
|
stateResult = evaluateStateFirePauseStanding();
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
{
|
|
transitionToState( COVERCOMBAT_WRW_FAILED );
|
|
_fireWeapon.End( *_self );
|
|
setTorsoAnim();
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
{
|
|
transitionToState(COVERCOMBAT_WRW_FIRE_STANDING);
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
// See if we just need to duck again
|
|
stateResult = evaluateStateStanding();
|
|
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
{
|
|
transitionToState( COVERCOMBAT_WRW_FAILED );
|
|
_fireWeapon.End( *_self );
|
|
setTorsoAnim();
|
|
}
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
{
|
|
transitionToState( COVERCOMBAT_WRW_CHANGE_POSTURE_DUCK );
|
|
_fireWeapon.End( *_self );
|
|
setTorsoAnim();
|
|
}
|
|
|
|
break;
|
|
|
|
//----------------------------------------------------------------------
|
|
case COVERCOMBAT_WRW_DUCKED:
|
|
//----------------------------------------------------------------------
|
|
if ( _spotted )
|
|
{
|
|
transitionToState( COVERCOMBAT_WRW_SPOTTED );
|
|
BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
stateResult = evaluateStateDucked();
|
|
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
transitionToState( COVERCOMBAT_WRW_FAILED );
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
transitionToState( COVERCOMBAT_WRW_CHANGE_POSTURE_STAND );
|
|
break;
|
|
|
|
//----------------------------------------------------------------------
|
|
case COVERCOMBAT_WRW_STANDING:
|
|
//----------------------------------------------------------------------
|
|
if ( _spotted )
|
|
{
|
|
transitionToState( COVERCOMBAT_WRW_SPOTTED );
|
|
BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
stateResult = evaluateRotate();
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
transitionToState( COVERCOMBAT_WRW_FIRE_STANDING );
|
|
|
|
|
|
break;
|
|
|
|
//----------------------------------------------------------------------
|
|
case COVERCOMBAT_WRW_SPOTTED:
|
|
//----------------------------------------------------------------------
|
|
stateResult = evaluateStateSpotted();
|
|
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
transitionToState( COVERCOMBAT_WRW_FAILED );
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
transitionToState( COVERCOMBAT_WRW_FIND_BETTER_COVER );
|
|
break;
|
|
|
|
//----------------------------------------------------------------------
|
|
case COVERCOMBAT_WRW_SUCCESS:
|
|
//----------------------------------------------------------------------
|
|
return BEHAVIOR_SUCCESS;
|
|
|
|
break;
|
|
|
|
|
|
//----------------------------------------------------------------------
|
|
case COVERCOMBAT_WRW_FAILED:
|
|
//----------------------------------------------------------------------
|
|
return BEHAVIOR_FAILED;
|
|
|
|
break;
|
|
}
|
|
|
|
return BEHAVIOR_EVALUATING;
|
|
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: End()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Cleans Up the behavior
|
|
//
|
|
// Parameters: Actor &self -- The actor executing this behavior
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::End(Actor &)
|
|
{
|
|
if ( !_self )
|
|
return;
|
|
|
|
_self->movementSubsystem->setMovingBackwards( false );
|
|
_fireWeapon.End(*_self);
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: transitionToState()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Transitions the behaviors state
|
|
//
|
|
// Parameters: coverCombatStates_t state -- The state to transition to
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::transitionToState( coverCombatStates_t state )
|
|
{
|
|
switch ( state )
|
|
{
|
|
case COVERCOMBAT_WRW_FIND_COVER:
|
|
setupStateFindCover();
|
|
setInternalState( state , "COVERCOMBAT_WRW_FIND_COVER" );
|
|
break;
|
|
|
|
case COVERCOMBAT_WRW_FIND_BETTER_COVER:
|
|
setupStateFindBetterCover();
|
|
setInternalState( state , "COVERCOMBAT_WRW_FIND_BETTER_COVER" );
|
|
break;
|
|
|
|
case COVERCOMBAT_WRW_MOVE_TO_COVER:
|
|
setupStateMoveToCover();
|
|
setInternalState( state , "COVERCOMBAT_WRW_MOVE_TO_COVER" );
|
|
break;
|
|
|
|
case COVERCOMBAT_WRW_CHANGE_POSTURE_DUCK:
|
|
setupStateChangePostureDuck();
|
|
setInternalState( state , "COVERCOMBAT_WRW_CHANGE_POSTURE_DUCK" );
|
|
break;
|
|
|
|
case COVERCOMBAT_WRW_CHANGE_POSTURE_STAND:
|
|
setupStateChangePostureStand();
|
|
setInternalState( state , "COVERCOMBAT_WRW_CHANGE_POSTURE_DUCK" );
|
|
break;
|
|
|
|
case COVERCOMBAT_WRW_FIRE_STANDING:
|
|
setupStateFireStanding();
|
|
setInternalState( state , "COVERCOMBAT_WRW_FIRE_STANDING" );
|
|
break;
|
|
|
|
case COVERCOMBAT_WRW_FIRE_PAUSE_STANDING:
|
|
setupStateFirePauseStanding();
|
|
setInternalState( state , "COVERCOMBAT_WRW_FIRE_PAUSE_STANDING" );
|
|
break;
|
|
|
|
case COVERCOMBAT_WRW_DUCKED:
|
|
setupStateDucked();
|
|
setInternalState( state , "COVERCOMBAT_WRW_DUCKED" );
|
|
break;
|
|
|
|
case COVERCOMBAT_WRW_STANDING:
|
|
setupStateStanding();
|
|
setInternalState( state , "COVERCOMBAT_WRW_STANDING" );
|
|
break;
|
|
|
|
case COVERCOMBAT_WRW_SPOTTED:
|
|
setupStateSpotted();
|
|
setInternalState( state , "COVERCOMBAT_WRW_SPOTTED" );
|
|
break;
|
|
|
|
case COVERCOMBAT_WRW_SUCCESS:
|
|
setInternalState( state , "COVERCOMBAT_WRW_SUCCESS" );
|
|
break;
|
|
|
|
case COVERCOMBAT_WRW_FAILED:
|
|
setInternalState( state , "COVERCOMBAT_WRW_FAILED" );
|
|
break;
|
|
}
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setInternalState()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets the internal state of the behavior
|
|
//
|
|
// Parameters: unsigned int state
|
|
// const str &stateName
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::setInternalState( coverCombatStates_t state , const str &stateName )
|
|
{
|
|
_state = state;
|
|
SetInternalStateName( stateName );
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: init()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Initializes the behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::init( Actor &self )
|
|
{
|
|
_self = &self;
|
|
transitionToState(COVERCOMBAT_WRW_FIND_COVER);
|
|
_finishedPostureTransition = true;
|
|
_nextStandTime = 0.0f;
|
|
_nextDuckTime = 0.0f;
|
|
_nextSpotCheck = 0.0f;
|
|
updateEnemy();
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: think()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Does any processing required before evaluating states
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::think()
|
|
{
|
|
trace_t trace;
|
|
|
|
if ( level.time < _nextSpotCheck )
|
|
return;
|
|
|
|
if ( !_currentEnemy || !_node )
|
|
return;
|
|
|
|
updateEnemy();
|
|
trace = G_Trace( _node->origin , vec_zero , vec_zero , _currentEnemy->origin , NULL , MASK_SOLID, false, "CoverCombatWithRangedWeapon::think");
|
|
|
|
if ( trace.fraction >= .95 )
|
|
_spotted = true;
|
|
else
|
|
_spotted = false;
|
|
|
|
_nextSpotCheck = level.time + G_Random(0.5);
|
|
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: updateEnemy()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets our _currentEnemy
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::updateEnemy()
|
|
{
|
|
Entity *currentEnemy = _self->enemyManager->GetCurrentEnemy();
|
|
if ( !currentEnemy )
|
|
{
|
|
_self->enemyManager->FindHighestHateEnemy();
|
|
currentEnemy = _self->enemyManager->GetCurrentEnemy();
|
|
if ( !currentEnemy )
|
|
{
|
|
SetFailureReason( "CoverCombatWithRangedWeapon::updateEnemy -- No Enemy" );
|
|
transitionToState( COVERCOMBAT_WRW_FAILED );
|
|
}
|
|
|
|
}
|
|
|
|
_currentEnemy = currentEnemy;
|
|
setupRotate();
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateFindCover()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets up the Find Cover State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::setupStateFindCover()
|
|
{
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateFindCover()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Evaluates the Find Cover State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: BehaviorReturnCode_t
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t CoverCombatWithRangedWeapon::evaluateStateFindCover()
|
|
{
|
|
//This Behavior's not being used anymore and should be removed
|
|
//_node = HelperNode::FindClosestHelperNodeThatCannotSeeEntity( *_self , NODETYPE_COVER , _self->edict->clipmask , _maxDistance , 0.0f , _currentEnemy );
|
|
|
|
if ( !_node )
|
|
{
|
|
failureStateFindCover( "CoverCombatWithRangedWeapon::evaluateStateFindCover() -- Cannot Find Suitable Cover Node" );
|
|
return BEHAVIOR_FAILED;
|
|
}
|
|
|
|
return BEHAVIOR_SUCCESS;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateFindCover()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Failure Handler for Find Cover State
|
|
//
|
|
// Parameters: const str& failureReason
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::failureStateFindCover(const str& failureReason)
|
|
{
|
|
SetFailureReason( failureReason );
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateMoveToCover()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets up the Move To Cover State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::setupStateMoveToCover()
|
|
{
|
|
_gotoPoint.SetAnim( _movementAnim );
|
|
_gotoPoint.SetDistance( NODE_RADIUS );
|
|
_gotoPoint.SetPoint( _node->origin );
|
|
_gotoPoint.Begin( *_self );
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateMoveToCover()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Evaluates the Move To Cover State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t CoverCombatWithRangedWeapon::evaluateStateMoveToCover()
|
|
{
|
|
BehaviorReturnCode_t result = _gotoPoint.Evaluate( *_self );
|
|
str failureReason = "CoverCombatWithRangedWeapon::evaluateStateMoveToCover -- _gotoPoint component returned: " + _gotoPoint.GetFailureReason();
|
|
|
|
if ( result == BEHAVIOR_FAILED )
|
|
failureStateMoveToCover( failureReason );
|
|
|
|
return result;
|
|
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateMoveToCover
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Failure Handler for State Move To Cover
|
|
//
|
|
// Parameters: const str &failureReason
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::failureStateMoveToCover( const str &failureReason )
|
|
{
|
|
Q_UNUSED(failureReason);
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateChangePostureDuck()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets up the ChangePostureDuck state
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::setupStateChangePostureDuck()
|
|
{
|
|
bool canChange = _self->postureController->requestPosture( "DUCK" , this );
|
|
|
|
if ( !canChange )
|
|
{
|
|
failureStateChangePostureDuck ( "Requested Posture is unavailable" );
|
|
return;
|
|
}
|
|
|
|
_finishedPostureTransition = false;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateChangePostureDuck()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Evaluates our ChangePostureDuck state
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t CoverCombatWithRangedWeapon::evaluateStateChangePostureDuck()
|
|
{
|
|
//Basically waiting for our check to come true
|
|
if ( _finishedPostureTransition )
|
|
return BEHAVIOR_SUCCESS;
|
|
|
|
return BEHAVIOR_EVALUATING;
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateChangePostureDuck()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Failure Handler for ChangePostureDuck State
|
|
//
|
|
// Parameters: const str &failureReason -- Why we're failing
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::failureStateChangePostureDuck( const str &failureReason )
|
|
{
|
|
Q_UNUSED(failureReason);
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateChangePostureStand()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets up the ChangePostureStand state
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::setupStateChangePostureStand()
|
|
{
|
|
bool canChange = _self->postureController->requestPosture( "STAND" , this );
|
|
|
|
if ( !canChange )
|
|
{
|
|
failureStateChangePostureStand ( "Requested Posture is unavailable" );
|
|
return;
|
|
}
|
|
|
|
_finishedPostureTransition = false;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateChangePostureStand()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Evaluates our ChangePostureStand state
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t CoverCombatWithRangedWeapon::evaluateStateChangePostureStand()
|
|
{
|
|
//Basically waiting for our check to come true
|
|
if ( _finishedPostureTransition )
|
|
return BEHAVIOR_SUCCESS;
|
|
|
|
return BEHAVIOR_EVALUATING;
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateChangePostureStand()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Failure Handler for Change Posture Stand function
|
|
//
|
|
// Parameters: const str &failureReason
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::failureStateChangePostureStand( const str &failureReason )
|
|
{
|
|
Q_UNUSED(failureReason);
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateSpotted()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets up the Spotted State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::setupStateSpotted()
|
|
{
|
|
bool canChange = _self->postureController->requestPosture( "STAND" , this );
|
|
|
|
if ( !canChange )
|
|
{
|
|
failureStateChangePostureStand ( "Requested Posture is unavailable" );
|
|
return;
|
|
}
|
|
|
|
_finishedPostureTransition = false;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateSpotted()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Evaluates our Spotted State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t CoverCombatWithRangedWeapon::evaluateStateSpotted()
|
|
{
|
|
//Basically waiting for our check to come true
|
|
if ( _finishedPostureTransition )
|
|
return BEHAVIOR_SUCCESS;
|
|
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateSpotted()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Failure Handler for Spotted State
|
|
//
|
|
// Parameters: const str &failureReason -- Why we failed
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::failureStateSpotted( const str &failureReason )
|
|
{
|
|
Q_UNUSED(failureReason);
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateDucked()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets up our Ducked State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::setupStateDucked()
|
|
{
|
|
_nextStandTime = level.time + G_Random() + 3.0f;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateDucked()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Evaluates our Ducked State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t CoverCombatWithRangedWeapon::evaluateStateDucked()
|
|
{
|
|
if ( level.time > _nextStandTime )
|
|
return BEHAVIOR_SUCCESS;
|
|
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateDucked()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Failure Handler for Ducked State
|
|
//
|
|
// Parameters: const str &failureReason -- Why we failed
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::failureStateDucked( const str &failureReason )
|
|
{
|
|
Q_UNUSED(failureReason);
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateStanding()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Setup for the Standing State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::setupStateStanding()
|
|
{
|
|
_nextDuckTime = level.time + G_Random() + 5.0f;
|
|
_nextFireTime = 0.0f;
|
|
_nextPauseTime = level.time + G_Random(_pauseTimeMax ) + _pauseTimeMin;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateStanding()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Evaluates the Standing State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t CoverCombatWithRangedWeapon::evaluateStateStanding()
|
|
{
|
|
if ( level.time > _nextDuckTime )
|
|
return BEHAVIOR_SUCCESS;
|
|
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateStanding()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Failure Handler for the Standing State
|
|
//
|
|
// Parameters: const str &failureReason
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::failureStateStanding( const str &failureReason )
|
|
{
|
|
Q_UNUSED(failureReason);
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateFindBetterCover()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets up the Find Better Cover State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::setupStateFindBetterCover()
|
|
{
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateFindBetterCover()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Evaluates the Find Better Cover State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: BehaviorReturnCode_t
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t CoverCombatWithRangedWeapon::evaluateStateFindBetterCover()
|
|
{
|
|
//Behavior Needs to be removed
|
|
// _node = HelperNode::FindClosestHelperNodeThatCannotSeeEntity( *_self , NODETYPE_COVER , _self->edict->clipmask , _maxDistance , 512.0f , _currentEnemy );
|
|
|
|
if ( !_node )
|
|
{
|
|
failureStateFindCover( "CoverCombatWithRangedWeapon::evaluateStateFindBetterCover() -- Cannot Find Suitable Cover Node" );
|
|
return BEHAVIOR_FAILED;
|
|
}
|
|
|
|
return BEHAVIOR_SUCCESS;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateFindBetterCover()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Failure Handler for Find Cover State
|
|
//
|
|
// Parameters: const str& failureReason
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::failureStateFindBetterCover(const str& failureReason)
|
|
{
|
|
SetFailureReason( failureReason );
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupRotate
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets up Rotate Component
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::setupRotate()
|
|
{
|
|
_rotate.SetEntity( _currentEnemy );
|
|
_rotate.Begin( *_self );
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateRotate()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Evaluates our Rotate Component
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t CoverCombatWithRangedWeapon::evaluateRotate()
|
|
{
|
|
return _rotate.Evaluate( *_self );
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateFireStanding()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets up our Fire Standing State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::setupStateFireStanding()
|
|
{
|
|
_nextFireTime = level.time + G_Random( _fireTimeMax ) + _fireTimeMin;
|
|
if ( _self->combatSubsystem->CanAttackEnemy() )
|
|
{
|
|
_fireWeapon.SetAnim( _fireAnim );
|
|
_fireWeapon.Begin( *_self );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateFireStanding()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Evaluates our Fire Standing State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t CoverCombatWithRangedWeapon::evaluateStateFireStanding()
|
|
{
|
|
_fireWeapon.Evaluate( *_self );
|
|
_self->combatSubsystem->AimWeaponTag(_currentEnemy);
|
|
|
|
if ( level.time > _nextFireTime )
|
|
return BEHAVIOR_SUCCESS;
|
|
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateFireStanding()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Failure Handler for Fire Standing State
|
|
//
|
|
// Parameters: const str &failureReason -- Why we're failing
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::failureStateFireStanding( const str &failureReason )
|
|
{
|
|
Q_UNUSED(failureReason);
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateFirePauseStanding()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets up our Pause Fire State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::setupStateFirePauseStanding()
|
|
{
|
|
_nextPauseTime = level.time + G_Random( _pauseTimeMax ) + _pauseTimeMin;
|
|
setTorsoAnim();
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateFirePauseStanding()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Evaluates our Pause Fire State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t CoverCombatWithRangedWeapon::evaluateStateFirePauseStanding()
|
|
{
|
|
if ( level.time > _nextPauseTime )
|
|
return BEHAVIOR_SUCCESS;
|
|
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateFirePauseStanding()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Failure Handler for our Pause Standing State
|
|
//
|
|
// Parameters: const str &failureReason -- Why we're failing
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::failureStateFirePauseStanding( const str &failureReason )
|
|
{
|
|
Q_UNUSED(failureReason);
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setTorsoAnim()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Sets our Torso Animation
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void CoverCombatWithRangedWeapon::setTorsoAnim()
|
|
{
|
|
_self->SetAnim( _torsoAnim , NULL , torso );
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: CanExecute()
|
|
// Class: CoverCombatWithRangedWeapon
|
|
//
|
|
// Description: Checks if the Behavior can execute
|
|
//
|
|
// Parameters: Actor &self,
|
|
// float maxDistance
|
|
//
|
|
// Returns: true or false;
|
|
//--------------------------------------------------------------
|
|
bool CoverCombatWithRangedWeapon::CanExecute( Actor &self , float maxDistance )
|
|
{
|
|
//HelperNode* node;
|
|
Entity* currentEnemy;
|
|
|
|
Q_UNUSED(maxDistance);
|
|
|
|
currentEnemy = self.enemyManager->GetCurrentEnemy();
|
|
|
|
if ( !currentEnemy )
|
|
return false;
|
|
|
|
//behavior needs to be removed
|
|
// node = HelperNode::FindClosestHelperNodeThatCannotSeeEntity( self , NODETYPE_COVER , self.edict->clipmask , maxDistance , 0.0f , currentEnemy );
|
|
|
|
//if ( node )
|
|
// return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|