//--------------------------------------------------------------
// Name: Evaluate()
// Class: GotoCurrentHelperNode
//
// Description: Evaluates the behavior
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: BehaviorReturnCode_t
//--------------------------------------------------------------
BehaviorReturnCode_t GotoCurrentHelperNode::Evaluate( Actor & )
{
BehaviorReturnCode_t stateResult;
think();
switch ( _state )
{
//---------------------------------------------------------------------
case GOTO_HNODE_FIND_NODE:
//---------------------------------------------------------------------
stateResult = evaluateStateFindNode();
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( GOTO_HNODE_MOVE_TO_NODE );
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( GOTO_HNODE_FAILED );
break;
//---------------------------------------------------------------------
case GOTO_HNODE_MOVE_TO_NODE:
//---------------------------------------------------------------------
stateResult = evaluateStateMoveToNode();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( GOTO_HNODE_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( GOTO_HNODE_SUCCESS );
break;
//---------------------------------------------------------------------
case GOTO_HNODE_SUCCESS:
//---------------------------------------------------------------------
return BEHAVIOR_SUCCESS;
break;
//---------------------------------------------------------------------
case GOTO_HNODE_FAILED:
//---------------------------------------------------------------------
return BEHAVIOR_FAILED;
break;
}
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: Evaluate()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Evaluates the behavior
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: BehaviorReturnCode_t
//--------------------------------------------------------------
BehaviorReturnCode_t CorridorCombatWithRangedWeapon::Evaluate( Actor & )
{
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: Evaluate()
// Class: Work
//
// Description: Returns True Or False, and is run every frame
// that the behavior
//
// Parameters: Actor &self
//
// Returns: True or False
//--------------------------------------------------------------
BehaviorReturnCode_t Work::Evaluate ( Actor &self )
{
BehaviorReturnCode_t stateResult;
think();
switch ( _state )
{
//---------------------------------------------------------------------
case WORK_FIND_NODE:
//---------------------------------------------------------------------
stateResult = evaluateStateFindNode();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( WORK_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( WORK_MOVE_TO_NODE );
break;
//---------------------------------------------------------------------
case WORK_MOVE_TO_NODE:
//---------------------------------------------------------------------
stateResult = evaluateStateMoveToNode();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( WORK_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( WORK_AT_NODE );
break;
//---------------------------------------------------------------------
case WORK_AT_NODE:
//---------------------------------------------------------------------
stateResult = evaluateStateAtNode();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( WORK_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( WORK_SELECT_ANIM_MODE );
break;
//---------------------------------------------------------------------
case WORK_SELECT_ANIM_MODE:
//---------------------------------------------------------------------
if ( _node->isUsingAnimList() )
{
customAnimListEntry_t* animEntry = _node->GetCurrentAnimEntryFromList();
if ( !animEntry )
{
transitionToState( WORK_FAILED );
return BEHAVIOR_EVALUATING;
}
if ( animEntry->waitType == WAITTYPE_EVENT )
transitionToState( WORK_ANIMATE_LIST_WAIT_ON_SIGNAL );
if ( animEntry->waitType == WAITTYPE_ANIM )
transitionToState( WORK_ANIMATE_LIST_WAIT_ON_ANIM );
if ( animEntry->waitType == WAITTYPE_TIME )
transitionToState( WORK_ANIMATE_LIST_WAIT_ON_TIME );
return BEHAVIOR_EVALUATING;
}
if ( _node->isWaitForAnim() )
{
transitionToState( WORK_ANIMATE_WAIT_ON_ANIM );
return BEHAVIOR_EVALUATING;
}
if ( _node->GetWaitTime() > 0 )
{
transitionToState( WORK_ANIMATE_WAIT_ON_TIME );
return BEHAVIOR_EVALUATING;
}
// We default to constant working
transitionToState( WORK_ANIMATE_CONSTANT );
break;
//---------------------------------------------------------------------
case WORK_ANIMATE_WAIT_ON_TIME:
//---------------------------------------------------------------------
stateResult = evaluateStateAnimateWaitOnTime();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( WORK_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( WORK_SUCCESSFUL );
break;
//---------------------------------------------------------------------
case WORK_ANIMATE_WAIT_ON_ANIM:
//---------------------------------------------------------------------
stateResult = evaluateStateAnimateWaitOnAnim();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( WORK_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( WORK_SUCCESSFUL );
break;
//---------------------------------------------------------------------
case WORK_ANIMATE_WAIT_ON_SIGNAL:
//---------------------------------------------------------------------
stateResult = evaluateStateAnimateWaitOnSignal();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( WORK_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( WORK_SUCCESSFUL );
break;
//---------------------------------------------------------------------
case WORK_ANIMATE_CONSTANT:
//---------------------------------------------------------------------
stateResult = evaluateStateAnimateConstant();
//
// Should Never get to either of these
//
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( WORK_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( WORK_SUCCESSFUL );
break;
//---------------------------------------------------------------------
case WORK_ANIMATE_LIST_WAIT_ON_TIME:
//---------------------------------------------------------------------
stateResult = evaluateStateAnimateListWaitOnTime();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( WORK_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
{
if (_node->isAnimListFinished() )
transitionToState( WORK_SUCCESSFUL );
else
transitionToState( WORK_SELECT_ANIM_MODE );
}
break;
//---------------------------------------------------------------------
case WORK_ANIMATE_LIST_WAIT_ON_ANIM:
//---------------------------------------------------------------------
stateResult = evaluateStateAnimateListWaitOnAnim();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( WORK_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
{
if (_node->isAnimListFinished() )
transitionToState( WORK_SUCCESSFUL );
else
transitionToState( WORK_SELECT_ANIM_MODE );
}
break;
//---------------------------------------------------------------------
case WORK_ANIMATE_LIST_WAIT_ON_SIGNAL:
//---------------------------------------------------------------------
stateResult = evaluateStateAnimateListWaitOnSignal();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( WORK_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
{
if (_node->isAnimListFinished() )
transitionToState( WORK_SUCCESSFUL );
else
transitionToState( WORK_SELECT_ANIM_MODE );
}
break;
//---------------------------------------------------------------------
case WORK_SUCCESSFUL:
//---------------------------------------------------------------------
_node->RunExitThread();
self.ignoreHelperNode.node = _node;
return BEHAVIOR_SUCCESS;
break;
//---------------------------------------------------------------------
case WORK_FAILED:
//---------------------------------------------------------------------
return BEHAVIOR_FAILED;
break;
}
return BEHAVIOR_EVALUATING;
}
