ubergames/ef2gamesource
0
0
Fork 0
mirror of https://github.com/UberGames/EF2GameSource.git synced 2024-11-10 06:31:42 +00:00
Code Issues Projects Releases Packages Wiki Activity
ef2gamesource/dlls/game/corridorCombatWithRangedWeapon.cpp

1450 lines
40 KiB
C++
Raw Normal View History

Initial code commit ...
2012-12-30 16:37:54 +00:00
//-----------------------------------------------------------------------------
//
// $Logfile:: /EF2/Code/DLLs/game/corridorCombatWithRangedWeapon.cpp $
// $Revision:: 8 $
// $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:
// CorridorCombatWithRangedWeapon Implementation
//
// PARAMETERS:
// str _movementAnim -- The animation to play while moving to the cover node
//
// ANIMATIONS:
// _movementAnim : PARAMETER
//--------------------------------------------------------------------------------
#include "actor.h"
#include "corridorCombatWithRangedWeapon.hpp"
extern Event EV_PostureChanged_Completed;
//--------------------------------------------------------------
//
// Init Static Vars
//
//--------------------------------------------------------------
const float CorridorCombatWithRangedWeapon::NODE_RADIUS = 32.0f;
//--------------------------------------------------------------
//
// Class Declaration and Event Registration
//
//--------------------------------------------------------------
CLASS_DECLARATION( Behavior, CorridorCombatWithRangedWeapon, NULL )
{
{ &EV_Behavior_Args, &CorridorCombatWithRangedWeapon::SetArgs },
{ &EV_Behavior_AnimDone, &CorridorCombatWithRangedWeapon::AnimDone },
{ &EV_PostureChanged_Completed, &CorridorCombatWithRangedWeapon::PostureDone },
{ NULL, NULL }
};
//--------------------------------------------------------------
// Name: CorridorCombatWithRangedWeapon()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Constructor
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
CorridorCombatWithRangedWeapon::CorridorCombatWithRangedWeapon()
{
_self = NULL;
_movementAnim = "idle";
_torsoAnim = "idle";
_fireAnim = "idle";
_preFireAnim = "idle";
_postFireAnim = "idle";
_postureChangeChance = 0.0f;
_maxDistance = 0.0f;
_retreatDistance = 0.0f;
_threatDistance = 0.0f;
_fireTimeMin = 0.0f;
_fireTimeMax = 0.0f;
_pauseTimeMin = 0.0f;
_pauseTimeMax = 0.0f;
}
//--------------------------------------------------------------
// Name: CorridorCombatWithRangedWeapon()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Destructor
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
CorridorCombatWithRangedWeapon::~CorridorCombatWithRangedWeapon()
{
}
//--------------------------------------------------------------
// Name: SetArgs()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets Arguments for this behavior
//
// Parameters: Event *ev -- Event holding the arguments
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::SetArgs( Event *ev )
{
int num = ev->NumArgs();
if ( num > 0 ) _movementAnim = ev->GetString( 1 );
if ( num > 1 ) _torsoAnim = ev->GetString( 2 );
if ( num > 2 ) _fireAnim = ev->GetString( 3 );
if ( num > 3 ) _preFireAnim = ev->GetString( 4 );
if ( num > 4 ) _postFireAnim = ev->GetString( 5 );
if ( num > 5 ) _postureChangeChance = ev->GetFloat ( 6 );
if ( num > 6 ) _maxDistance = ev->GetFloat ( 7 );
if ( num > 7 ) _retreatDistance = ev->GetFloat ( 8 );
if ( num > 8 ) _threatDistance = ev->GetFloat ( 9 );
if ( num > 9 ) _fireTimeMin = ev->GetFloat ( 10 );
if ( num > 10 ) _fireTimeMax = ev->GetFloat ( 11 );
if ( num > 11 ) _pauseTimeMin = ev->GetFloat ( 12 );
if ( num > 12 ) _pauseTimeMax = ev->GetFloat ( 13 );
}
//--------------------------------------------------------------
// Name: AnimDone()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Handles an animation completion
//
// Parameters: Event *ev -- Event holding the completion notification
//
// Returns: None
//--------------------------------------------------------------
Windows: more fixes for C4100
2012-12-31 15:32:52 +00:00
void CorridorCombatWithRangedWeapon::AnimDone( Event * )
Initial code commit ...
2012-12-30 16:37:54 +00:00
{
}
//--------------------------------------------------------------
// Name: PostureDone()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Handles a Posture Done Event
//
// Parameters: Event *ev
//
// Returns: None
//--------------------------------------------------------------
Windows: more fixes for C4100
2012-12-31 15:32:52 +00:00
void CorridorCombatWithRangedWeapon::PostureDone( Event * )
Initial code commit ...
2012-12-30 16:37:54 +00:00
{
_finishedPostureTransition = true;
}
//--------------------------------------------------------------
// Name: Begin()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Initializes the behavior
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::Begin( Actor &self )
{
init( self );
}
//--------------------------------------------------------------
// Name: Evaluate()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates the behavior
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: BehaviorReturnCode_t
//--------------------------------------------------------------
Windows: more fixes for C4100
2012-12-31 15:32:52 +00:00
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::Evaluate( Actor & )
Initial code commit ...
2012-12-30 16:37:54 +00:00
{
BehaviorReturnCode_t stateResult;
think();
switch ( _state )
{
//---------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_FINDNODE:
//---------------------------------------------------------------------
stateResult = evaluateStateFindNode();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( CORRIDORCOMBAT_WRW_STAND );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( CORRIDORCOMBAT_WRW_MOVETONODE );
break;
//---------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_MOVETONODE:
//---------------------------------------------------------------------
stateResult = evaluateStateMoveToNode();
if ( stateResult == BEHAVIOR_FAILED )
{
_self->SetAnim( "idle" , NULL , legs );
transitionToState( CORRIDORCOMBAT_WRW_STAND );
}
if ( stateResult == BEHAVIOR_SUCCESS )
{
_self->SetAnim( "idle" , NULL , legs );
stateResult = evaluateRotate();
if ( stateResult == BEHAVIOR_SUCCESS )
{
if ( checkShouldDuck() )
transitionToState( CORRIDORCOMBAT_WRW_CHANGEPOSTURE_DUCK );
else
transitionToState( CORRIDORCOMBAT_WRW_STAND );
}
}
break;
//---------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_BACKPEDAL:
//---------------------------------------------------------------------
stateResult = evaluateStateBackPedal();
if ( stateResult == BEHAVIOR_FAILED )
{
_self->movementSubsystem->setMovingBackwards( false );
_self->SetAnim( "idle" , NULL , legs );
_holdPositionTime = level.time + G_Random(2.0) + 2.0f;
transitionToState( CORRIDORCOMBAT_WRW_STAND );
return BEHAVIOR_EVALUATING;
}
if ( stateResult == BEHAVIOR_SUCCESS )
{
_self->movementSubsystem->setMovingBackwards( false );
_self->SetAnim( "idle" , NULL , legs );
transitionToState( CORRIDORCOMBAT_WRW_FINDBETTERNODE );
}
break;
//---------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_FINDBETTERNODE:
//---------------------------------------------------------------------
stateResult = evaluateStateFindBetterNode();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( CORRIDORCOMBAT_WRW_STAND );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( CORRIDORCOMBAT_WRW_MOVETOBETTERNODE );
break;
//---------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_MOVETOBETTERNODE:
//---------------------------------------------------------------------
stateResult = evaluateStateMoveToBetterNode();
if ( stateResult == BEHAVIOR_FAILED )
{
_self->SetAnim( "idle" , NULL , legs );
transitionToState( CORRIDORCOMBAT_WRW_FAILED );
}
if ( stateResult == BEHAVIOR_SUCCESS )
{
_self->SetAnim( "idle" , NULL , legs );
stateResult = evaluateRotate();
if ( stateResult == BEHAVIOR_SUCCESS )
{
if ( checkShouldDuck() )
transitionToState( CORRIDORCOMBAT_WRW_CHANGEPOSTURE_DUCK );
else
transitionToState( CORRIDORCOMBAT_WRW_STAND );
}
}
break;
//---------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_CHANGEPOSTURE_DUCK:
//---------------------------------------------------------------------
stateResult = evaluateStateChangePostureDuck();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( CORRIDORCOMBAT_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( CORRIDORCOMBAT_WRW_DUCKED );
break;
//---------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_CHANGEPOSTURE_STAND:
//---------------------------------------------------------------------
stateResult = evaluateStateChangePostureStand();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( CORRIDORCOMBAT_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( CORRIDORCOMBAT_WRW_STAND );
break;
//---------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_DUCKED:
//---------------------------------------------------------------------
if ( checkShouldStand() ) //Make sure we don't need to stand back up
{
transitionToState( CORRIDORCOMBAT_WRW_CHANGEPOSTURE_STAND );
return BEHAVIOR_EVALUATING;
}
stateResult = evaluateRotate();
stateResult = evaluateStateDucked();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( CORRIDORCOMBAT_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( CORRIDORCOMBAT_WRW_DUCKED_FIRING );
break;
//----------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_DUCKED_FIRING:
//----------------------------------------------------------------------
if ( checkShouldStand() ) //Make sure we don't need to stand back up
{
transitionToState( CORRIDORCOMBAT_WRW_CHANGEPOSTURE_STAND );
_fireWeapon.End(*_self);
return BEHAVIOR_EVALUATING;
}
stateResult = evaluateRotate();
if ( stateResult != BEHAVIOR_SUCCESS )
return BEHAVIOR_EVALUATING;
stateResult = evaluateStateFireDucked();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( CORRIDORCOMBAT_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( CORRIDORCOMBAT_WRW_DUCKED );
break;
//----------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_STAND:
//----------------------------------------------------------------------
if ( checkShouldRetreat() )
{
transitionToState( CORRIDORCOMBAT_WRW_BACKPEDAL );
return BEHAVIOR_EVALUATING;
}
stateResult = evaluateRotate();
stateResult = evaluateStateStanding();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( CORRIDORCOMBAT_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( CORRIDORCOMBAT_WRW_STAND_FIRING );
break;
//----------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_STAND_FIRING:
//----------------------------------------------------------------------
if ( checkShouldRetreat() )
{
transitionToState( CORRIDORCOMBAT_WRW_BACKPEDAL );
_fireWeapon.End(*_self);
return BEHAVIOR_EVALUATING;
}
stateResult = evaluateRotate();
if ( stateResult != BEHAVIOR_SUCCESS )
return BEHAVIOR_EVALUATING;
stateResult = evaluateStateFireStanding();
if ( stateResult == BEHAVIOR_FAILED )
{
_fireWeapon.End(*_self);
transitionToState( CORRIDORCOMBAT_WRW_FAILED );
}
if ( stateResult == BEHAVIOR_SUCCESS )
{
_fireWeapon.End(*_self);
transitionToState( CORRIDORCOMBAT_WRW_STAND );
}
break;
//---------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_HOLD_POSITION:
//---------------------------------------------------------------------
stateResult = evaluateStateHoldPosition();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( CORRIDORCOMBAT_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState(CORRIDORCOMBAT_WRW_FINDBETTERNODE);
break;
//----------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_SUCCESS:
//----------------------------------------------------------------------
return BEHAVIOR_SUCCESS;
break;
//----------------------------------------------------------------------
case CORRIDORCOMBAT_WRW_FAILED:
//----------------------------------------------------------------------
return BEHAVIOR_FAILED;
break;
}
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: End()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Cleans Up the behavior
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: None
//--------------------------------------------------------------
Windows: more fixes for C4100
2012-12-31 15:32:52 +00:00
void CorridorCombatWithRangedWeapon::End(Actor &)
Initial code commit ...
2012-12-30 16:37:54 +00:00
{
if ( !_self )
return;
_self->movementSubsystem->setMovingBackwards( false );
_fireWeapon.End(*_self);
}
//--------------------------------------------------------------
// Name: transitionToState()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Transitions the behaviors state
//
// Parameters: coverCombatStates_t state -- The state to transition to
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::transitionToState( corridorCombatStates_t state )
{
switch ( state )
{
case CORRIDORCOMBAT_WRW_FINDNODE:
setupStateFindNode();
setInternalState( state , "CORRIDORCOMBAT_WRW_FINDNODE" );
break;
case CORRIDORCOMBAT_WRW_MOVETONODE:
setupStateMoveToNode();
setInternalState( state , "CORRIDORCOMBAT_WRW_MOVETONODE" );
break;
case CORRIDORCOMBAT_WRW_BACKPEDAL:
setupStateBackPedal();
setInternalState( state , "CORRIDORCOMBAT_WRW_BACKPEDAL" );
break;
case CORRIDORCOMBAT_WRW_FINDBETTERNODE:
setupStateFindBetterNode();
setInternalState( state , "CORRIDORCOMBAT_WRW_FINDBETTERNODE" );
break;
case CORRIDORCOMBAT_WRW_MOVETOBETTERNODE:
setupStateMoveToBetterNode();
setInternalState( state , "CORRIDORCOMBAT_WRW_MOVETOBETTERNODE" );
break;
case CORRIDORCOMBAT_WRW_CHANGEPOSTURE_DUCK:
setupStateChangePostureDuck();
setInternalState( state , "CORRIDORCOMBAT_WRW_CHANGEPOSTURE_DUCK" );
break;
case CORRIDORCOMBAT_WRW_CHANGEPOSTURE_STAND:
setupStateChangePostureStand();
setInternalState( state , "CORRIDORCOMBAT_WRW_CHANGEPOSTURE_STAND" );
break;
case CORRIDORCOMBAT_WRW_DUCKED:
setupStateDucked();
setInternalState( state , "CORRIDORCOMBAT_WRW_DUCKED" );
break;
case CORRIDORCOMBAT_WRW_DUCKED_FIRING:
setupStateFireDucked();
setInternalState( state , "CORRIDORCOMBAT_WRW_DUCKED_FIRING" );
break;
case CORRIDORCOMBAT_WRW_STAND:
setupStateStanding();
setInternalState( state , "CORRIDORCOMBAT_WRW_STAND" );
break;
case CORRIDORCOMBAT_WRW_STAND_FIRING:
setupStateFireStanding();
setInternalState( state , "CORRIDORCOMBAT_WRW_STAND_FIRING" );
break;
case CORRIDORCOMBAT_WRW_HOLD_POSITION:
setupStateHoldPosition();
setInternalState( state , "CORRIDORCOMBAT_WRW_HOLD_POSITION" );
break;
case CORRIDORCOMBAT_WRW_SUCCESS:
setInternalState( state , "CORRIDORCOMBAT_WRW_SUCCESS" );
break;
case CORRIDORCOMBAT_WRW_FAILED:
setInternalState( state , "CORRIDORCOMBAT_WRW_FAILED" );
break;
}
}
//--------------------------------------------------------------
// Name: setInternalState()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets the internal state of the behavior
//
// Parameters: unsigned int state
// const str &stateName
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setInternalState( corridorCombatStates_t state , const str &stateName )
{
_state = state;
SetInternalStateName( stateName );
}
//--------------------------------------------------------------
// Name: init()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Initializes the behavior
//
// Parameters: Actor &self
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::init( Actor &self )
{
_self = &self;
transitionToState(CORRIDORCOMBAT_WRW_FINDNODE);
_finishedPostureTransition = true;
_holdPositionTime = 0.0f;
_enemyUpdateTime = 0.0f;
updateEnemy();
}
//--------------------------------------------------------------
// Name: think()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Does any processing required before evaluating states
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::think()
{
updateEnemy();
}
//--------------------------------------------------------------
// Name: updateEnemy()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets our _currentEnemy
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::updateEnemy()
{
if ( level.time < _enemyUpdateTime )
return;
Entity *currentEnemy = _self->enemyManager->GetCurrentEnemy();
if ( !currentEnemy )
{
_self->enemyManager->FindHighestHateEnemy();
currentEnemy = _self->enemyManager->GetCurrentEnemy();
if ( !currentEnemy )
{
SetFailureReason( "CorridorCombatWithRangedWeapon::updateEnemy -- No Enemy" );
transitionToState( CORRIDORCOMBAT_WRW_FAILED );
}
}
_currentEnemy = currentEnemy;
_enemyUpdateTime = level.time + G_Random() + 3.0f;
setupRotate();
}
//--------------------------------------------------------------
// Name: setupStateFindNode()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up the Find Cover State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateFindNode()
{
}
//--------------------------------------------------------------
// Name: evaluateStateFindNode()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates the Find Cover State
//
// Parameters: None
//
// Returns: BehaviorReturnCode_t
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::evaluateStateFindNode()
{
if ( _node )
_node->UnreserveNode();
_node = HelperNode::FindClosestHelperNode( *_self , NODETYPE_COMBAT , DESCRIPTOR_CORRIDOR , _maxDistance );
if ( !_node )
{
failureStateFindNode( "CorridorCombatWithRangedWeapon::evaluateStateFindCover() -- Cannot Find Suitable Cover Node" );
return BEHAVIOR_FAILED;
}
_node->ReserveNode();
return BEHAVIOR_SUCCESS;
}
//--------------------------------------------------------------
// Name: failureStateFindNode()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Failure Handler for Find Cover State
//
// Parameters: const str& failureReason
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::failureStateFindNode(const str& failureReason)
{
SetFailureReason( failureReason );
}
//--------------------------------------------------------------
// Name: setupStateMoveToNode()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up the Move To Cover State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateMoveToNode()
{
_gotoPoint.SetAnim( _movementAnim );
_gotoPoint.SetDistance( NODE_RADIUS );
_gotoPoint.SetPoint( _node->origin );
_gotoPoint.Begin( *_self );
setTorsoAnim();
}
//--------------------------------------------------------------
// Name: evaluateStateMoveToNode()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates the Move To Cover State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::evaluateStateMoveToNode()
{
BehaviorReturnCode_t result = _gotoPoint.Evaluate( *_self );
str failureReason = "CorridorCombatWithRangedWeapon::evaluateStateMoveToCover -- _gotoPoint component returned: " + _gotoPoint.GetFailureReason();
if ( result == BEHAVIOR_FAILED )
failureStateMoveToNode( failureReason );
return result;
}
//--------------------------------------------------------------
// Name: failureStateMoveToNode
// Class: CorridorCombatWithRangedWeapon
//
// Description: Failure Handler for State Move To Cover
//
// Parameters: const str &failureReason
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::failureStateMoveToNode( const str &failureReason )
{
SetFailureReason( failureReason );
}
//--------------------------------------------------------------
// Name: setupStateBackPedal()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up state
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateBackPedal()
{
Vector selfToEnemy;
float dist;
dist = G_Random ( 64.0f ) + 96.0f;
selfToEnemy = _currentEnemy->origin - _self->origin;
selfToEnemy = selfToEnemy.toAngles();
selfToEnemy[PITCH] = 0;
selfToEnemy[ROLL] = 0;
_self->setAngles( selfToEnemy );
selfToEnemy.AngleVectors( &selfToEnemy );
_self->movementSubsystem->setMoveDir( selfToEnemy );
_self->movementSubsystem->setAnimDir( selfToEnemy );
_moveRandomDir.SetDistance( dist );
_moveRandomDir.SetAnim( "backpedal" );
_moveRandomDir.SetMode(MoveRandomDirection::RANDOM_MOVE_IN_BACK);
_moveRandomDir.Begin(*_self);
_moveRandomDir.SetMinDistance( dist * .75 );
_self->movementSubsystem->setMovingBackwards( true );
}
//--------------------------------------------------------------
// Name: evaluateStateBackPedal()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::evaluateStateBackPedal()
{
BehaviorReturnCode_t moveResult = _moveRandomDir.Evaluate( *_self );
if ( moveResult == BEHAVIOR_SUCCESS )
{
return BEHAVIOR_SUCCESS;
}
if ( moveResult == BEHAVIOR_FAILED )
{
failureStateBackPedal( _moveRandomDir.GetFailureReason() );
return BEHAVIOR_FAILED;
}
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: failureStateBackPedal()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Failure Handler
//
// Parameters: const str& failureReason
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::failureStateBackPedal( const str& failureReason )
{
SetFailureReason( failureReason );
}
//--------------------------------------------------------------
// Name: setupStateFindBetterNode()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateFindBetterNode()
{
}
//--------------------------------------------------------------
// Name: evaluateStateFindBetterNode()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::evaluateStateFindBetterNode()
{
if ( _node )
_node->UnreserveNode();
_node = HelperNode::FindClosestHelperNodeAtDistanceFrom( *_self , _currentEnemy , NODETYPE_COMBAT , DESCRIPTOR_CORRIDOR , _maxDistance , _retreatDistance );
if ( !_node )
{
failureStateFindBetterNode( "CorridorCombatWithRangedWeapon::evaluateStateFindBetterNode() -- Cannot Find Suitable Cover Node" );
return BEHAVIOR_FAILED;
}
_node->ReserveNode();
return BEHAVIOR_SUCCESS;
}
//--------------------------------------------------------------
// Name: failureStateFindBetterNode()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates State
//
// Parameters: const str& failureReason
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::failureStateFindBetterNode( const str& failureReason )
{
SetFailureReason( failureReason );
}
//--------------------------------------------------------------
// Name: setupStateMoveToBetterNode()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateMoveToBetterNode()
{
_gotoPoint.SetAnim( _movementAnim );
_gotoPoint.SetDistance( NODE_RADIUS );
_gotoPoint.SetPoint( _node->origin );
_gotoPoint.Begin( *_self );
}
//--------------------------------------------------------------
// Name: evaluateStateMoveToBetterNode()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::evaluateStateMoveToBetterNode()
{
BehaviorReturnCode_t result = _gotoPoint.Evaluate( *_self );
str failureReason = "CorridorCombatWithRangedWeapon::evaluateStateMoveToBetterNode -- _gotoPoint component returned: " + _gotoPoint.GetFailureReason();
if ( result == BEHAVIOR_FAILED )
failureStateMoveToBetterNode( failureReason );
return result;
}
//--------------------------------------------------------------
// Name: failureStateMoveToBetterNode()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Failure Handler for state
//
// Parameters: const str& failureReason
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::failureStateMoveToBetterNode( const str& failureReason )
{
SetFailureReason( failureReason );
}
//--------------------------------------------------------------
// Name: setupStateChangePostureDuck()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up the ChangePostureDuck state
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateChangePostureDuck()
{
bool canChange = _self->postureController->requestPosture( "DUCK" , this );
if ( !canChange )
{
failureStateChangePostureDuck ( "Requested Posture is unavailable" );
return;
}
_finishedPostureTransition = false;
}
//--------------------------------------------------------------
// Name: evaluateStateChangePostureDuck()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates our ChangePostureDuck state
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::evaluateStateChangePostureDuck()
{
//Basically waiting for our check to come true
if ( _finishedPostureTransition )
return BEHAVIOR_SUCCESS;
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: failureStateChangePostureDuck()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Failure Handler for ChangePostureDuck State
//
// Parameters: const str &failureReason -- Why we're failing
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::failureStateChangePostureDuck( const str &failureReason )
{
SetFailureReason( failureReason );
}
//--------------------------------------------------------------
// Name: setupStateChangePostureStand()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up the ChangePostureStand state
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateChangePostureStand()
{
bool canChange = _self->postureController->requestPosture( "STAND" , this );
if ( !canChange )
{
failureStateChangePostureStand ( "Requested Posture is unavailable" );
return;
}
_finishedPostureTransition = false;
}
//--------------------------------------------------------------
// Name: evaluateStateChangePostureStand()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates our ChangePostureStand state
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::evaluateStateChangePostureStand()
{
//Basically waiting for our check to come true
if ( _finishedPostureTransition )
return BEHAVIOR_SUCCESS;
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: failureStateChangePostureStand()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Failure Handler for Change Posture Stand function
//
// Parameters: const str &failureReason
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::failureStateChangePostureStand( const str &failureReason )
{
SetFailureReason( failureReason );
}
//--------------------------------------------------------------
// Name: setupStateDucked()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up our Ducked State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateDucked()
{
_nextPauseTime = level.time + G_Random( _pauseTimeMax ) + _pauseTimeMin;
setTorsoAnim();
_self->SetAnim( "duck" , NULL , legs );
_fireWeapon.End(*_self);
}
//--------------------------------------------------------------
// Name: evaluateStateDucked()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates our Ducked State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::evaluateStateDucked()
{
if ( level.time > _nextPauseTime )
return BEHAVIOR_SUCCESS;
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: failureStateDucked()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Failure Handler for Ducked State
//
// Parameters: const str &failureReason -- Why we failed
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::failureStateDucked( const str &failureReason )
{
SetFailureReason( failureReason );
}
//--------------------------------------------------------------
// Name: setupStateFireDucked()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up state
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateFireDucked()
{
_nextFireTime = level.time + G_Random( _fireTimeMax ) + _fireTimeMin;
if ( _self->combatSubsystem->CanAttackEnemy() )
{
_fireWeapon.SetAnim( _fireAnim );
_fireWeapon.Begin( *_self );
}
}
//--------------------------------------------------------------
// Name: evaluateStateFireDucked()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::evaluateStateFireDucked()
{
_fireWeapon.Evaluate( *_self );
_self->combatSubsystem->AimWeaponTag(_currentEnemy);
if ( level.time > _nextFireTime )
return BEHAVIOR_SUCCESS;
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: failureStateFireDucked()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Failure Handler For State
//
// Parameters: const str &failureReason
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::failureStateFireDucked( const str& failureReason )
{
SetFailureReason( failureReason );
}
//--------------------------------------------------------------
// Name: setupStateStanding()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Setup for the Standing State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateStanding()
{
_self->SetAnim( "idle" , NULL , legs);
_nextPauseTime = level.time + G_Random( _pauseTimeMax ) + _pauseTimeMin;
setTorsoAnim();
}
//--------------------------------------------------------------
// Name: evaluateStateStanding()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates the Standing State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::evaluateStateStanding()
{
if ( level.time > _nextPauseTime )
return BEHAVIOR_SUCCESS;
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: failureStateStanding()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Failure Handler for the Standing State
//
// Parameters: const str &failureReason
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::failureStateStanding( const str &failureReason )
{
SetFailureReason( failureReason );
}
//--------------------------------------------------------------
// Name: setupStateFireStanding()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up our Fire Standing State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateFireStanding()
{
_self->SetAnim( "idle" , NULL , legs);
_nextFireTime = level.time + G_Random( _fireTimeMax ) + _fireTimeMin;
//if ( _self->combatSubsystem->CanAttackEnemy() )
if ( _self->combatSubsystem->CanAttackTarget( _currentEnemy ) )
{
_fireWeapon.SetAnim( _fireAnim );
_fireWeapon.Begin( *_self );
}
}
//--------------------------------------------------------------
// Name: evaluateStateFireStanding()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates our Fire Standing State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::evaluateStateFireStanding()
{
_fireWeapon.Evaluate( *_self );
_self->combatSubsystem->AimWeaponTag(_currentEnemy);
if ( level.time > _nextFireTime )
return BEHAVIOR_SUCCESS;
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: failureStateFireStanding()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Failure Handler for Fire Standing State
//
// Parameters: const str &failureReason -- Why we're failing
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::failureStateFireStanding( const str &failureReason )
{
SetFailureReason( failureReason );
}
//--------------------------------------------------------------
// Name: setupStateHoldPosition()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateHoldPosition()
{
_self->SetAnim( "idle" );
setTorsoAnim();
_holdPositionTime = level.time + G_Random() + 1.0f;
}
//--------------------------------------------------------------
// Name: evaluateStateHoldPosition()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::evaluateStateHoldPosition()
{
if ( level.time >= _holdPositionTime )
return BEHAVIOR_SUCCESS;
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: failureStateHoldPosition()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Failure Handler
//
// Parameters: const str& failureReason
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::failureStateHoldPosition( const str& failureReason )
{
SetFailureReason( failureReason );
}
//--------------------------------------------------------------
// Name: setupRotate
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up Rotate Component
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupRotate()
{
_rotate.SetTurnSpeed( 30.0f );
_rotate.SetEntity( _currentEnemy );
_rotate.Begin( *_self );
}
//--------------------------------------------------------------
// Name: evaluateRotate()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates our Rotate Component
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::evaluateRotate()
{
return _rotate.Evaluate( *_self );
}
//--------------------------------------------------------------
// Name: setTorsoAnim()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets our Torso Animation
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setTorsoAnim()
{
_self->SetAnim( _torsoAnim , NULL , torso );
}
//--------------------------------------------------------------
// Name: checkShouldDuck()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Checks if actor should duck
//
// Parameters: None
//
// Returns: true or false
//--------------------------------------------------------------
bool CorridorCombatWithRangedWeapon::checkShouldDuck()
{
// We don't duck if the enemy is too close
if ( _self->WithinDistanceXY( _currentEnemy , _threatDistance ) )
return false;
if ( G_Random() <= _postureChangeChance )
return true;
return false;
}
//--------------------------------------------------------------
// Name: checkShouldStand()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Checks if actor should stand
//
// Parameters: None
//
// Returns: true or false
//--------------------------------------------------------------
bool CorridorCombatWithRangedWeapon::checkShouldStand()
{
if ( _self->WithinDistanceXY( _currentEnemy , _threatDistance ) )
return true;
return false;
}
bool CorridorCombatWithRangedWeapon::checkShouldRetreat()
{
if ( level.time >= _holdPositionTime && _self->WithinDistanceXY( _currentEnemy , _retreatDistance ) )
return true;
return false;
}
//--------------------------------------------------------------
// Name: CanExecute()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Checks if the behavior can execute
//
// Parameters: float maxDistance
// Actor &self
//
// Returns: true or false
//--------------------------------------------------------------
bool CorridorCombatWithRangedWeapon::CanExecute( float maxDistance , Actor &self )
{
HelperNodePtr node;
node = HelperNode::FindClosestHelperNode( self , NODETYPE_COMBAT , DESCRIPTOR_CORRIDOR , maxDistance );
if ( node )
return true;
return false;
}
Reference in a new issue Copy permalink