629 lines
16 KiB
C++
629 lines
16 KiB
C++
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Logfile:: /EF2/Code/DLLs/game/useAlarm.cpp $
|
|
// $Revision:: 10 $
|
|
// $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 "useAlarm.hpp"
|
|
|
|
//--------------------------------------------------------------
|
|
//
|
|
// Class Declaration and Event Registration
|
|
//
|
|
//--------------------------------------------------------------
|
|
CLASS_DECLARATION( Behavior, UseAlarm, NULL )
|
|
{
|
|
{ &EV_Behavior_Args, &UseAlarm::SetArgs },
|
|
{ &EV_Behavior_AnimDone, &UseAlarm::AnimDone },
|
|
{ &EV_HelperNodeCommand, &UseAlarm::HandleNodeCommand },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: UseAlarm()
|
|
// Class: UseAlarm()
|
|
//
|
|
// Description: Constructor
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
UseAlarm::UseAlarm()
|
|
{
|
|
_movementAnimName = "walk";
|
|
_maxDistance = 1024.0f;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: ~UseAlarm()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Destructor
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
UseAlarm::~UseAlarm()
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: SetArgs()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Sets the arguments of the behavior
|
|
//
|
|
// Parameters: Event *ev
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::SetArgs ( Event *ev)
|
|
{
|
|
if (ev->NumArgs() == 1)
|
|
{
|
|
_movementAnimName = ev->GetString( 1 );
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: AnimDone()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Handles an animation completion
|
|
//
|
|
// Parameters: Event *ev -- Event holding the completion notification
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::AnimDone( Event * )
|
|
{
|
|
switch( _state )
|
|
{
|
|
case USE_ALARM_WAIT_ON_ANIM:
|
|
_animDone = true;
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: HandleNodeCommand()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Handles a command event from a helper node
|
|
//
|
|
// Parameters: Event *ev
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::HandleNodeCommand( Event * )
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: Begin()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Begins the Behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::Begin( Actor &self )
|
|
{
|
|
init( self );
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: Evaluate()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Returns True Or False, and is run every frame
|
|
// that the behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: True or False
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t UseAlarm::Evaluate ( Actor & )
|
|
{
|
|
BehaviorReturnCode_t stateResult;
|
|
|
|
think();
|
|
|
|
switch ( _state )
|
|
{
|
|
//---------------------------------------------------------------------
|
|
case USE_ALARM_FIND_NODE:
|
|
//---------------------------------------------------------------------
|
|
stateResult = evaluateStateFindNode();
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
transitionToState( USE_ALARM_FAILED );
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
transitionToState( USE_ALARM_MOVE_TO_NODE );
|
|
break;
|
|
|
|
|
|
//---------------------------------------------------------------------
|
|
case USE_ALARM_MOVE_TO_NODE:
|
|
//---------------------------------------------------------------------
|
|
stateResult = evaluateStateMoveToNode();
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
transitionToState( USE_ALARM_FAILED );
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
transitionToState( USE_ALARM_AT_NODE );
|
|
|
|
break;
|
|
|
|
//---------------------------------------------------------------------
|
|
case USE_ALARM_AT_NODE:
|
|
//---------------------------------------------------------------------
|
|
stateResult = evaluateStateAtNode();
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
transitionToState( USE_ALARM_FAILED );
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
transitionToState( USE_ALARM_WAIT_ON_ANIM );
|
|
|
|
break;
|
|
|
|
//---------------------------------------------------------------------
|
|
case USE_ALARM_WAIT_ON_ANIM:
|
|
//---------------------------------------------------------------------
|
|
stateResult = evaluateStateWaitOnAnim();
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
transitionToState( USE_ALARM_FAILED );
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
transitionToState( USE_ALARM_ROTATE_TO_ENEMY );
|
|
break;
|
|
|
|
//---------------------------------------------------------------------
|
|
case USE_ALARM_ROTATE_TO_ENEMY:
|
|
//---------------------------------------------------------------------
|
|
stateResult = evaluateStateRotateToEnemy();
|
|
if ( stateResult == BEHAVIOR_FAILED )
|
|
transitionToState( USE_ALARM_FAILED );
|
|
|
|
if ( stateResult == BEHAVIOR_SUCCESS )
|
|
transitionToState( USE_ALARM_SUCCESSFUL );
|
|
|
|
break;
|
|
|
|
//---------------------------------------------------------------------
|
|
case USE_ALARM_SUCCESSFUL:
|
|
//---------------------------------------------------------------------
|
|
_node->RunExitThread();
|
|
return BEHAVIOR_SUCCESS;
|
|
break;
|
|
|
|
//---------------------------------------------------------------------
|
|
case USE_ALARM_FAILED:
|
|
//---------------------------------------------------------------------
|
|
return BEHAVIOR_FAILED;
|
|
break;
|
|
|
|
}
|
|
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: End()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Ends the Behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::End ( Actor & )
|
|
{
|
|
if ( _node )
|
|
{
|
|
_node->SetUser( NULL );
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: transitionToState()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Transitions Internal State
|
|
//
|
|
// Parameters: workStates_t state
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::transitionToState ( useAlarmStates_t state )
|
|
{
|
|
switch ( state )
|
|
{
|
|
case USE_ALARM_FIND_NODE:
|
|
setupStateFindNode();
|
|
setInternalState( state , "USE_ALARM_FIND_NODE" );
|
|
break;
|
|
|
|
case USE_ALARM_MOVE_TO_NODE:
|
|
setupStateMoveToNode();
|
|
setInternalState( state , "USE_ALARM_MOVE_TO_NODE" );
|
|
break;
|
|
|
|
case USE_ALARM_AT_NODE:
|
|
setupStateAtNode();
|
|
setInternalState( state , "USE_ALARM_AT_NODE" );
|
|
break;
|
|
|
|
case USE_ALARM_WAIT_ON_ANIM:
|
|
setupStateWaitOnAnim();
|
|
setInternalState( state , "WORK_ANIMATE_WAIT_ON_ANIM" );
|
|
break;
|
|
|
|
case USE_ALARM_ROTATE_TO_ENEMY:
|
|
setupStateRotateToEnemy();
|
|
setInternalState( state, "USE_ALARM_ROTATE_TO_ENEMY" );
|
|
break;
|
|
|
|
case USE_ALARM_SUCCESSFUL:
|
|
setInternalState( state , "WORK_SUCCESSFUL" );
|
|
break;
|
|
|
|
case USE_ALARM_FAILED:
|
|
setInternalState( state , "WORK_FAILED" );
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setInternalState()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Sets internal state of the behavior
|
|
//
|
|
// Parameters: workStates_t state
|
|
// const str &stateName
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::setInternalState ( useAlarmStates_t state , const str &stateName )
|
|
{
|
|
_state = state;
|
|
SetInternalStateName( stateName );
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: init()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Initializes memeber variables
|
|
//
|
|
// Parameters: Actor &self -- Actor executing this behavior
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::init( Actor &self )
|
|
{
|
|
_self = &self;
|
|
_animDone = false;
|
|
transitionToState( USE_ALARM_FIND_NODE );
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: think()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Think function called every frame by evaluate
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::think()
|
|
{
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateFindNode()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Sets up State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::setupStateFindNode()
|
|
{
|
|
str currentNodeCustomType;
|
|
if ( _self->currentHelperNode.node )
|
|
currentNodeCustomType = _self->currentHelperNode.node->GetCustomType();
|
|
|
|
if ( currentNodeCustomType == "alarm" )
|
|
_node = &(*_self->currentHelperNode.node);
|
|
else
|
|
_node = HelperNode::FindClosestHelperNode( *_self , "alarm" , _maxDistance );
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateFindNode()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Evaluates State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t UseAlarm::evaluateStateFindNode()
|
|
{
|
|
if ( !_node )
|
|
return BEHAVIOR_FAILED;
|
|
|
|
return BEHAVIOR_SUCCESS;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateFindNode()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Failure Handler for State
|
|
//
|
|
// Parameters: const str& failureReason -- Why we failed
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::failureStateFindNode( const str& failureReason )
|
|
{
|
|
Q_UNUSED(failureReason);
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateMoveToNode()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Sets up State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::setupStateMoveToNode()
|
|
{
|
|
_gotoHelperNode.SetNode( _node );
|
|
_gotoHelperNode.SetMovementAnim ( _movementAnimName );
|
|
_gotoHelperNode.Begin( *_self );
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateMoveToNode()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Evaluates State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t UseAlarm::evaluateStateMoveToNode()
|
|
{
|
|
return _gotoHelperNode.Evaluate( *_self );
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateMoveToNode()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Failure Handler for State
|
|
//
|
|
// Parameters: const str& failureReason -- Why we failed
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::failureStateMoveToNode( const str& failureReason )
|
|
{
|
|
Q_UNUSED(failureReason);
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateAtNode()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Sets up State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::setupStateAtNode()
|
|
{
|
|
_self->SetAnim( "idle" );
|
|
_self->RunThread( _node->GetEntryThread() );
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateAtNode()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Evaluates State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t UseAlarm::evaluateStateAtNode()
|
|
{
|
|
Vector nodeAngles = _node->angles;
|
|
|
|
_self->movementSubsystem->setAnimDir( nodeAngles );
|
|
_self->setAngles( nodeAngles );
|
|
|
|
_node->SetUser( this );
|
|
return BEHAVIOR_SUCCESS;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateAtNode()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Failure Handler for State
|
|
//
|
|
// Parameters: const str& failureReason -- Why we failed
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::failureStateAtNode( const str& failureReason )
|
|
{
|
|
Q_UNUSED(failureReason);
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateWaitOnAnim()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Sets up State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::setupStateWaitOnAnim()
|
|
{
|
|
if( ! _self->SetAnim( _node->GetAnim() , EV_Actor_NotifyBehavior , legs ) )
|
|
{
|
|
// setanim returns false if the node-specified anim doesn't exist, so
|
|
// set _animDone=true to avoid them just standing there.
|
|
_animDone = true;
|
|
}
|
|
else
|
|
{
|
|
// anim was set successfully, so let the behavior know it should wait for the
|
|
// anim to finish before continuing.
|
|
_animDone = false;
|
|
}
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateWaitOnAnim()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Evaluates State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t UseAlarm::evaluateStateWaitOnAnim()
|
|
{
|
|
if ( _animDone )
|
|
return BEHAVIOR_SUCCESS;
|
|
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateWaitOnAnim()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Failure Handler for State
|
|
//
|
|
// Parameters: const str& failureReason -- Why we failed
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::failureStateWaitOnAnim( const str& failureReason )
|
|
{
|
|
Q_UNUSED(failureReason);
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: setupStateRotateToEnemy()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Sets up state
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::setupStateRotateToEnemy()
|
|
{
|
|
Entity *enemy = _self->enemyManager->GetCurrentEnemy();
|
|
|
|
if ( !enemy )
|
|
return;
|
|
|
|
_rotateToEntity.SetAnim( "idle" );
|
|
_rotateToEntity.SetEntity( enemy );
|
|
_rotateToEntity.SetTurnSpeed( 25.0f );
|
|
_rotateToEntity.Begin( *_self );
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: evaluateStateRotateToEnemy()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Evaluates State
|
|
//
|
|
// Parameters: None
|
|
//
|
|
// Returns: BehaviorReturnCode_t
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t UseAlarm::evaluateStateRotateToEnemy()
|
|
{
|
|
return _rotateToEntity.Evaluate( *_self );
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: failureStateRotateToEnemy()
|
|
// Class: UseAlarm
|
|
//
|
|
// Description: Failure Handler for State
|
|
//
|
|
// Parameters: const str &failureReason
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void UseAlarm::failureStateRotateToEnemy( const str &failureReason )
|
|
{
|
|
Q_UNUSED(failureReason);
|
|
}
|
|
|