1074 lines
25 KiB
C++
1074 lines
25 KiB
C++
//-----------------------------------------------------------------------------
|
|
//
|
|
// $Logfile:: /Code/DLLs/game/behaviors_specific.cpp $
|
|
// $Revision:: 18 $
|
|
// $Author:: Steven $
|
|
// $Date:: 10/13/03 8:53a $
|
|
//
|
|
// Copyright (C) 2001 by Ritual Entertainment, Inc.
|
|
// All rights reserved.
|
|
//
|
|
// This source may not be distributed and/or modified without
|
|
// expressly written permission by Ritual Entertainment, Inc.
|
|
//
|
|
//
|
|
#include "_pch_cpp.h"
|
|
//#include "g_local.h"
|
|
#include "behavior.h"
|
|
#include "actor.h"
|
|
#include "doors.h"
|
|
#include "object.h"
|
|
#include "explosion.h"
|
|
#include "weaputils.h"
|
|
#include "player.h"
|
|
#include "behaviors_specific.h"
|
|
|
|
extern Container<HelperNode*> HelperNodes;
|
|
|
|
|
|
//==============================================================================
|
|
// PatrolWorkHibernate
|
|
//==============================================================================
|
|
|
|
// Init Static Vars
|
|
const float PatrolWorkHibernate::MIN_DISTANCE_TO_PATROL_NODE = 512.0f;
|
|
const float PatrolWorkHibernate::MIN_DISTANCE_TO_WORK_NODE = 512.0f;
|
|
const float PatrolWorkHibernate::MIN_DISTANCE_TO_HIBERNATE_NODE = 96.0f;
|
|
|
|
//--------------------------------------------------------------
|
|
//
|
|
// Class Declaration and Event Registration
|
|
//
|
|
//--------------------------------------------------------------
|
|
CLASS_DECLARATION( Behavior, PatrolWorkHibernate, NULL )
|
|
{
|
|
{ &EV_Behavior_Args, &PatrolWorkHibernate::SetArgs },
|
|
{ &EV_Behavior_AnimDone, &PatrolWorkHibernate::AnimDone },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: SetArgs()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Sets the arguments of the behavior
|
|
//
|
|
// Parameters: Event *ev
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkHibernate::SetArgs ( Event *ev)
|
|
{
|
|
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: AnimDone()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Handles an animation completion
|
|
//
|
|
// Parameters: Event *ev -- Event holding the completion notification
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkHibernate::AnimDone( Event *ev )
|
|
{
|
|
switch ( _state )
|
|
{
|
|
case PATROLWORKHIBERNATE_HIBERNATE:
|
|
_hibernateComponent.AnimDone( ev );
|
|
break;
|
|
|
|
case PATROLWORKHIBERNATE_HACK:
|
|
_state = PATROLWORKHIBERNATE_SELECT_STATE;
|
|
break;
|
|
|
|
case PATROLWORKHIBERNATE_HIBERNATE_HOLD:
|
|
_state = PATROLWORKHIBERNATE_SELECT_STATE;
|
|
break;
|
|
|
|
case PATROLWORKHIBERNATE_PATROL:
|
|
_patrolComponent.AnimDone( ev );
|
|
break;
|
|
|
|
case PATROLWORKHIBERNATE_WORK:
|
|
_workComponent.AnimDone( ev );
|
|
break;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: Begin()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Begins the Behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkHibernate::Begin( Actor &self )
|
|
{
|
|
_init( self );
|
|
if ( self.GetActorFlag ( ACTOR_FLAG_IN_ALCOVE ) )
|
|
_state = PATROLWORKHIBERNATE_HIBERNATE_HOLD;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _init()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Initializes memeber variables
|
|
//
|
|
// Parameters: Actor &self -- Actor executing this behavior
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkHibernate::_init( Actor &self )
|
|
{
|
|
_nextStateCheck = 0.0f;
|
|
_nextWorkCheck = 0.0f;
|
|
_nextHibernateCheck = 0.0f;
|
|
|
|
_state = PATROLWORKHIBERNATE_SELECT_STATE;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: Evaluate()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Returns True Or False, and is run every frame
|
|
// that the behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: True or False
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t PatrolWorkHibernate::Evaluate ( Actor &self )
|
|
{
|
|
float tendencyToHibernate;
|
|
|
|
switch ( _state )
|
|
{
|
|
case PATROLWORKHIBERNATE_SELECT_STATE:
|
|
_selectState( self );
|
|
break;
|
|
|
|
case PATROLWORKHIBERNATE_PATROL:
|
|
_patrol( self );
|
|
break;
|
|
|
|
case PATROLWORKHIBERNATE_WORK:
|
|
_work( self );
|
|
break;
|
|
|
|
case PATROLWORKHIBERNATE_HIBERNATE:
|
|
tendencyToHibernate = self.personality->GetTendency( "hibernate" );
|
|
|
|
if ( G_Random() > tendencyToHibernate )
|
|
{
|
|
self.SetAnim( "alcove_activate" , EV_Actor_NotifyBehavior );
|
|
_state = PATROLWORKHIBERNATE_HACK;
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
_hibernate( self );
|
|
break;
|
|
|
|
case PATROLWORKHIBERNATE_HOLD:
|
|
_hold( self );
|
|
break;
|
|
|
|
case PATROLWORKHIBERNATE_HIBERNATE_HOLD:
|
|
self.SetAnim( "alcove_idle" );
|
|
tendencyToHibernate = self.personality->GetTendency( "hibernate" );
|
|
|
|
if ( G_Random() > tendencyToHibernate )
|
|
{
|
|
self.SetAnim( "alcove_activate" , EV_Actor_NotifyBehavior );
|
|
}
|
|
|
|
break;
|
|
|
|
case PATROLWORKHIBERNATE_FAILED:
|
|
return BEHAVIOR_FAILED;
|
|
break;
|
|
}
|
|
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: End()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Ends the Behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkHibernate::End ( Actor &self )
|
|
{
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _setupPatrol()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Sets up our Patrol Component Behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkHibernate::_setupPatrol( Actor &self )
|
|
{
|
|
_patrolComponent.SetInitialNode( self.currentHelperNode.node );
|
|
_patrolComponent.Begin( self );
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _patrol()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Evaluates our Patrol Component
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkHibernate::_patrol( Actor &self )
|
|
{
|
|
// See if we want to hibernate
|
|
if ( _wantsToHibernate( self ) )
|
|
{
|
|
_state = PATROLWORKHIBERNATE_HIBERNATE;
|
|
_setupHibernate( self );
|
|
_patrolComponent.End( self);
|
|
return;
|
|
}
|
|
|
|
// See if we want to work
|
|
if ( _wantsToWork( self ) )
|
|
{
|
|
_state = PATROLWORKHIBERNATE_WORK;
|
|
_setupWork( self );
|
|
_patrolComponent.End( self);
|
|
return;
|
|
}
|
|
|
|
|
|
BehaviorReturnCode_t patrolResult;
|
|
patrolResult = _patrolComponent.Evaluate( self );
|
|
|
|
if ( patrolResult == BEHAVIOR_SUCCESS )
|
|
_state = PATROLWORKHIBERNATE_SELECT_STATE;
|
|
|
|
if ( patrolResult == BEHAVIOR_FAILED )
|
|
_state = PATROLWORKHIBERNATE_FAILED;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _setupHibernate()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Sets up our hibernate component
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkHibernate::_setupHibernate( Actor &self )
|
|
{
|
|
_hibernateComponent.Begin( self );
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _hibernate()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Evaluates our Hibernate Component
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkHibernate::_hibernate( Actor &self )
|
|
{
|
|
BehaviorReturnCode_t hibernateResult;
|
|
hibernateResult = _hibernateComponent.Evaluate( self );
|
|
|
|
if ( hibernateResult == BEHAVIOR_SUCCESS )
|
|
_state = PATROLWORKHIBERNATE_SELECT_STATE;
|
|
|
|
if ( hibernateResult == BEHAVIOR_FAILED )
|
|
_state = PATROLWORKHIBERNATE_FAILED;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _setupWork()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Sets up our Work Component
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkHibernate::_setupWork( Actor &self )
|
|
{
|
|
_workComponent.SetNode( self.currentHelperNode.node );
|
|
_workComponent.Begin( self );
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _work()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Evaluates our Work Component
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkHibernate::_work( Actor &self )
|
|
{
|
|
BehaviorReturnCode_t workResult;
|
|
workResult = _workComponent.Evaluate( self );
|
|
|
|
if ( workResult == BEHAVIOR_SUCCESS )
|
|
_state = PATROLWORKHIBERNATE_SELECT_STATE;
|
|
|
|
if ( workResult == BEHAVIOR_FAILED )
|
|
_state = PATROLWORKHIBERNATE_FAILED;
|
|
}
|
|
|
|
|
|
void PatrolWorkHibernate::_setupHold( Actor &self )
|
|
{
|
|
self.SetAnim( "idle" );
|
|
_nextStateCheck = level.time + G_Random() + 1.0f;
|
|
}
|
|
|
|
void PatrolWorkHibernate::_hold( Actor &self )
|
|
{
|
|
if ( level.time >= _nextStateCheck )
|
|
_state = PATROLWORKHIBERNATE_SELECT_STATE;
|
|
}
|
|
|
|
bool PatrolWorkHibernate::_wantsToHibernate( Actor &self )
|
|
{
|
|
float tendencyToHibernate;
|
|
|
|
if ( level.time > _nextHibernateCheck )
|
|
{
|
|
_nextHibernateCheck = level.time + G_Random() + 0.25f;
|
|
|
|
HelperNode* hibNode;
|
|
hibNode = HelperNode::FindClosestHelperNode( self , "hibernate" , MIN_DISTANCE_TO_HIBERNATE_NODE );
|
|
|
|
if ( !hibNode )
|
|
return false;
|
|
|
|
if ( !self.WithinDistance( hibNode->origin , MIN_DISTANCE_TO_HIBERNATE_NODE ) )
|
|
return false;
|
|
|
|
if ( hibNode == _lastHibernateNodeChecked )
|
|
return false;
|
|
|
|
_lastHibernateNodeChecked = hibNode;
|
|
|
|
tendencyToHibernate = self.personality->GetTendency( "hibernate" );
|
|
|
|
if ( G_Random() <= tendencyToHibernate )
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
bool PatrolWorkHibernate::_wantsToWork( Actor &self )
|
|
{
|
|
float tendencyToWork;
|
|
|
|
if ( level.time > _nextWorkCheck )
|
|
{
|
|
_nextWorkCheck = level.time + G_Random() + 0.25f;
|
|
|
|
tendencyToWork = self.personality->GetTendency( "work" );
|
|
if ( G_Random() > tendencyToWork )
|
|
return false;
|
|
|
|
HelperNode* workNode = HelperNode::FindClosestHelperNode( self , NODETYPE_WORK , MIN_DISTANCE_TO_WORK_NODE );
|
|
|
|
if ( !workNode )
|
|
return false;
|
|
|
|
if ( !self.WithinDistance( workNode->origin , MIN_DISTANCE_TO_WORK_NODE ) )
|
|
return false;
|
|
|
|
if ( workNode == _lastWorkNodeChecked )
|
|
{
|
|
self.currentHelperNode.node->UnreserveNode();
|
|
return false;
|
|
}
|
|
|
|
_lastWorkNodeChecked = workNode;
|
|
|
|
self.currentHelperNode.node->UnreserveNode();
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _selectState()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Selects the state of our behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkHibernate::_selectState( Actor &self )
|
|
{
|
|
// By default, we prefer to patrol.
|
|
// As we patrol, we'll keep looking for hibernate and work
|
|
// nodes, and change our state appropriately
|
|
HelperNode* patrolNode;
|
|
patrolNode = HelperNode::FindClosestHelperNode( self , NODETYPE_PATROL , MIN_DISTANCE_TO_PATROL_NODE );
|
|
|
|
if ( patrolNode && self.WithinDistance( patrolNode->origin , MIN_DISTANCE_TO_PATROL_NODE ) )
|
|
{
|
|
_state = PATROLWORKHIBERNATE_PATROL;
|
|
_setupPatrol( self );
|
|
return;
|
|
}
|
|
|
|
// See if we want to hibernate
|
|
if ( _wantsToHibernate( self ) )
|
|
{
|
|
_state = PATROLWORKHIBERNATE_HIBERNATE;
|
|
_setupHibernate( self );
|
|
return;
|
|
}
|
|
|
|
// See if we want to work
|
|
if ( _wantsToWork( self ) )
|
|
{
|
|
_state = PATROLWORKHIBERNATE_WORK;
|
|
_setupWork( self );
|
|
return;
|
|
}
|
|
|
|
_state = PATROLWORKHIBERNATE_HOLD;
|
|
_setupHold( self );
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
//==============================================================================
|
|
// PatrolWorkWander
|
|
//==============================================================================
|
|
|
|
// Init Static Vars
|
|
const float PatrolWorkWander::MIN_DISTANCE_TO_PATROL_NODE = 512.0f;
|
|
const float PatrolWorkWander::MIN_DISTANCE_TO_WORK_NODE = 512.0f;
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
//
|
|
// Class Declaration and Event Registration
|
|
//
|
|
//--------------------------------------------------------------
|
|
CLASS_DECLARATION( Behavior, PatrolWorkWander, NULL )
|
|
{
|
|
{ &EV_Behavior_Args, &PatrolWorkWander::SetArgs },
|
|
{ &EV_Behavior_AnimDone, &PatrolWorkWander::AnimDone },
|
|
{ NULL, NULL }
|
|
};
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: SetArgs()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Sets the arguments of the behavior
|
|
//
|
|
// Parameters: Event *ev
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::SetArgs ( Event *ev)
|
|
{
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: AnimDone()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Handles an animation completion
|
|
//
|
|
// Parameters: Event *ev -- Event holding the completion notification
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::AnimDone( Event *ev )
|
|
{
|
|
switch ( _state )
|
|
{
|
|
|
|
case PATROLWORKWANDER_PATROL:
|
|
_patrolComponent.AnimDone( ev );
|
|
break;
|
|
|
|
case PATROLWORKWANDER_WORK:
|
|
_workComponent.AnimDone( ev );
|
|
break;
|
|
|
|
}
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: Begin()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Begins the Behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::Begin( Actor &self )
|
|
{
|
|
_init( self );
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _init()
|
|
// Class: PatrolWorkHibernate
|
|
//
|
|
// Description: Initializes memeber variables
|
|
//
|
|
// Parameters: Actor &self -- Actor executing this behavior
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::_init( Actor &self )
|
|
{
|
|
_nextStateCheck = 0.0f;
|
|
_nextWorkCheck = 0.0f;
|
|
_nextPatrolCheck = 0.0f;
|
|
|
|
_wanderFailures = 0;
|
|
_patrolFailures = 0;
|
|
_workFailures = 0;
|
|
|
|
|
|
_state = PATROLWORKWANDER_SELECT_STATE;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: Evaluate()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Returns True Or False, and is run every frame
|
|
// that the behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: True or False
|
|
//--------------------------------------------------------------
|
|
BehaviorReturnCode_t PatrolWorkWander::Evaluate ( Actor &self )
|
|
{
|
|
switch ( _state )
|
|
{
|
|
case PATROLWORKWANDER_SELECT_STATE:
|
|
_selectState( self );
|
|
break;
|
|
|
|
case PATROLWORKWANDER_PATROL:
|
|
_patrol ( self );
|
|
break;
|
|
|
|
case PATROLWORKWANDER_WORK:
|
|
_work( self );
|
|
break;
|
|
|
|
case PATROLWORKWANDER_WANDER:
|
|
_wander( self );
|
|
break;
|
|
|
|
case PATROLWORKWANDER_HOLD:
|
|
_hold( self );
|
|
break;
|
|
|
|
case PATROLWORKWANDER_FAILED:
|
|
return BEHAVIOR_FAILED;
|
|
break;
|
|
}
|
|
|
|
return BEHAVIOR_EVALUATING;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: End()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Ends the Behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::End ( Actor &self )
|
|
{
|
|
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _setupWander()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Sets up our MoveRandomDirection Component Behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::_setupWander( Actor &self )
|
|
{
|
|
_wanderComponent.SetAnim( "walk" );
|
|
_wanderComponent.SetDistance( 256.0f );
|
|
_wanderComponent.SetMinDistance( 96.0f );
|
|
_wanderComponent.SetMode( MoveRandomDirection::RANDOM_MOVE_ANYWHERE );
|
|
_wanderComponent.Begin( self );
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _wander()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Evaluates our MoveRandomDirection Component
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::_wander( Actor &self )
|
|
{
|
|
// See if we want to work
|
|
if ( _wantsToWork( self ) )
|
|
{
|
|
_state = PATROLWORKWANDER_WORK;
|
|
_setupWork( self );
|
|
_wanderComponent.End( self);
|
|
return;
|
|
}
|
|
|
|
BehaviorReturnCode_t wanderResult;
|
|
wanderResult = _wanderComponent.Evaluate( self );
|
|
|
|
if ( wanderResult == BEHAVIOR_SUCCESS )
|
|
{
|
|
_wanderFailures = 0;
|
|
_setupHold( self );
|
|
_state = PATROLWORKWANDER_HOLD;
|
|
return;
|
|
}
|
|
|
|
if ( wanderResult == BEHAVIOR_FAILED )
|
|
{
|
|
_wanderFailed( self );
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _wanderFailed()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Failure Handler for the MoveRandomDirection Component
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::_wanderFailed( Actor &self )
|
|
{
|
|
_wanderFailures++;
|
|
|
|
_setupHold( self );
|
|
_state = PATROLWORKWANDER_HOLD;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _setupPatrol()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Sets up our Patrol Component Behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::_setupPatrol( Actor &self )
|
|
{
|
|
_patrolComponent.Begin( self );
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _patrol()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Evaluates our Patrol Component
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::_patrol( Actor &self )
|
|
{
|
|
// See if we want to work
|
|
if ( _wantsToWork( self ) )
|
|
{
|
|
_state = PATROLWORKWANDER_WORK;
|
|
_setupWork( self );
|
|
_patrolComponent.End( self);
|
|
return;
|
|
}
|
|
|
|
|
|
BehaviorReturnCode_t patrolResult;
|
|
patrolResult = _patrolComponent.Evaluate( self );
|
|
|
|
if ( patrolResult == BEHAVIOR_SUCCESS )
|
|
{
|
|
_patrolFailures = 0;
|
|
_setupHold( self );
|
|
_state = PATROLWORKWANDER_HOLD;
|
|
return;
|
|
}
|
|
|
|
|
|
if ( patrolResult == BEHAVIOR_FAILED )
|
|
{
|
|
_patrolFailed( self );
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _patrolFailed()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Failure Handler for
|
|
//
|
|
// Parameters:
|
|
//
|
|
// Returns:
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::_patrolFailed( Actor &self )
|
|
{
|
|
_patrolFailures++;
|
|
|
|
_setupHold( self );
|
|
_state = PATROLWORKWANDER_HOLD;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _setupWork()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Sets up our Work Component
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::_setupWork( Actor &self )
|
|
{
|
|
_workComponent.Begin( self );
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _work()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Evaluates our Work Component
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::_work( Actor &self )
|
|
{
|
|
BehaviorReturnCode_t workResult;
|
|
workResult = _workComponent.Evaluate( self );
|
|
|
|
if ( workResult == BEHAVIOR_SUCCESS )
|
|
{
|
|
_workFailures = 0;
|
|
_setupHold( self );
|
|
_state = PATROLWORKWANDER_HOLD;
|
|
return;
|
|
}
|
|
|
|
|
|
if ( workResult == BEHAVIOR_FAILED )
|
|
{
|
|
_workFailed( self );
|
|
return;
|
|
}
|
|
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _workFailed()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Failure Handler for the Work Component
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::_workFailed( Actor &self )
|
|
{
|
|
_workFailures++;
|
|
|
|
_setupHold( self );
|
|
_state = PATROLWORKWANDER_HOLD;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _setupHold()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Sets up Hold State
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::_setupHold( Actor &self )
|
|
{
|
|
self.SetAnim( "idle" );
|
|
_nextStateCheck = level.time + G_Random( 5.0f ) + 1.0f;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _hold()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Holds us in place until we need to change
|
|
// states
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::_hold( Actor &self )
|
|
{
|
|
if ( level.time >= _nextStateCheck )
|
|
_state = PATROLWORKWANDER_SELECT_STATE;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _wantsToWork()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Checks if the actor "wants" to work
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: True or False
|
|
//--------------------------------------------------------------
|
|
bool PatrolWorkWander::_wantsToWork( Actor &self )
|
|
{
|
|
float tendencyToWork;
|
|
|
|
if ( _workFailures > 5 )
|
|
return false;
|
|
|
|
if ( level.time > _nextWorkCheck )
|
|
{
|
|
_nextWorkCheck = level.time + G_Random() + 0.25f;
|
|
|
|
HelperNode* workNode;
|
|
workNode = HelperNode::FindClosestHelperNode( self , NODETYPE_WORK , MIN_DISTANCE_TO_WORK_NODE );
|
|
|
|
if ( !workNode )
|
|
return false;
|
|
|
|
if ( !self.WithinDistance( workNode->origin , MIN_DISTANCE_TO_WORK_NODE ) )
|
|
return false;
|
|
|
|
if ( workNode == _lastWorkNodeChecked )
|
|
return false;
|
|
|
|
_lastWorkNodeChecked = workNode;
|
|
|
|
tendencyToWork = self.personality->GetTendency( "work" );
|
|
|
|
if ( G_Random() <= tendencyToWork )
|
|
{
|
|
self.currentHelperNode.node->UnreserveNode();
|
|
return true;
|
|
}
|
|
|
|
|
|
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _wantsToPatrol()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Checks if the Actor "wants" to patrol
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: True or False
|
|
//--------------------------------------------------------------
|
|
bool PatrolWorkWander::_wantsToPatrol( Actor &self )
|
|
{
|
|
float tendencyToPatrol;
|
|
|
|
if ( _patrolFailures > 5 )
|
|
return false;
|
|
|
|
if ( level.time >= _nextPatrolCheck )
|
|
{
|
|
_nextPatrolCheck = level.time + G_Random() + 0.25f;
|
|
|
|
HelperNode* patrolNode;
|
|
patrolNode = HelperNode::FindClosestHelperNode( self , NODETYPE_PATROL , MIN_DISTANCE_TO_PATROL_NODE );
|
|
|
|
if ( !patrolNode )
|
|
return false;
|
|
|
|
if ( !self.WithinDistance( patrolNode->origin , MIN_DISTANCE_TO_PATROL_NODE ) )
|
|
return false;
|
|
|
|
if ( patrolNode == _lastPatrolNodeChecked )
|
|
return false;
|
|
|
|
_lastPatrolNodeChecked = patrolNode;
|
|
|
|
tendencyToPatrol = self.personality->GetTendency( "patrol" );
|
|
|
|
if ( G_Random() <= tendencyToPatrol )
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//--------------------------------------------------------------
|
|
// Name: _wantsToWander()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Checks if the Actor "wants" to Wander
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: True or False
|
|
//--------------------------------------------------------------
|
|
bool PatrolWorkWander::_wantsToWander( Actor &self )
|
|
{
|
|
if ( _wanderFailures > 5 )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
//--------------------------------------------------------------
|
|
// Name: _selectState()
|
|
// Class: PatrolWorkWander
|
|
//
|
|
// Description: Selects the state of our behavior
|
|
//
|
|
// Parameters: Actor &self
|
|
//
|
|
// Returns: None
|
|
//--------------------------------------------------------------
|
|
void PatrolWorkWander::_selectState( Actor &self )
|
|
{
|
|
|
|
if ( _wantsToPatrol( self ) )
|
|
{
|
|
_setupPatrol( self );
|
|
_state = PATROLWORKWANDER_PATROL;
|
|
return;
|
|
}
|
|
|
|
if ( _wantsToWork( self ) )
|
|
{
|
|
_setupWork( self );
|
|
_state = PATROLWORKWANDER_WORK;
|
|
return;
|
|
}
|
|
|
|
if ( _wantsToWander( self ) )
|
|
{
|
|
_setupWander( self );
|
|
_state = PATROLWORKWANDER_WANDER;
|
|
return;
|
|
}
|
|
|
|
// Nothing else is working, so we'll just stand and play our
|
|
// idle animation
|
|
_state = PATROLWORKWANDER_HOLD;
|
|
_setupHold( self );
|
|
}
|