void DialogueManager::nextAnswer() {
if (_q->_answers[0] == NULL) {
transitionToState(DIALOGUE_OVER);
return;
}
// try and check if there are any suitable answers,
// given the current game state.
addVisibleAnswers(_q);
if (!_numVisAnswers) {
// if there are no answers, then chicken out
transitionToState(DIALOGUE_OVER);
return;
}
if (_visAnswers[0]._a->textIsNull()) {
// if the first answer is null (it's implied that it's the
// only one because we already called addVisibleAnswers),
// then jump to the next question
_answerId = _visAnswers[0]._index;
transitionToState(NEXT_QUESTION);
} else {
// at this point we are sure there are non-null answers to show
displayAnswers();
transitionToState(RUN_ANSWER);
}
}
void WatchEntity::init( Actor &self )
{
SetSelf(&self);
if ( _time > 0 )
_time = level.time + _time;
_oldTurnSpeed = self.movementSubsystem->getTurnSpeed();
//Check if we have an entity to watch
if ( !_ent )
{
self.enemyManager->FindHighestHateEnemy();
_ent = self.enemyManager->GetCurrentEnemy();
if ( !_ent )
{
if ( _forcePlayer )
_ent = (Entity*)GetPlayer( 0 );
if ( !_ent )
{
transitionToState(WATCH_FAILED);
return;
}
}
}
transitionToState(WATCH_HOLD);
}
void DialogueManager::nextQuestion() {
_q = _dialogue->findQuestion(_q->_answers[_answerId]->_followingName);
if (_q == 0) {
transitionToState(DIALOGUE_OVER);
} else {
transitionToState(displayQuestion() ? RUN_QUESTION : NEXT_ANSWER);
}
}
void WatchEntity::think()
{
if ( _time > 0 && level.time >= _time )
transitionToState(WATCH_SUCCESS);
if ( _waitForAnim && _animDone )
transitionToState(WATCH_SUCCESS);
}
//--------------------------------------------------------------
// Name: Begin()
// Class: TorsoAimAndFireWeapon
//
// Description: Initializes the behavior
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: None
//--------------------------------------------------------------
void TorsoAimAndFireWeapon::Begin( Actor &self )
{
init( self );
if (_preFireAnim.length() && !_aimOnly )
transitionToState ( TORSO_AIM_AND_FIRE_PRE_FIRE );
else
transitionToState ( TORSO_AIM_AND_FIRE_AIM );
}
//--------------------------------------------------------------
// 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: WatchEntity
//
// Description: Evaluates the behavior
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: BehaviorReturnCode_t
//--------------------------------------------------------------
BehaviorReturnCode_t WatchEntity::Evaluate( Actor &self )
{
BehaviorReturnCode_t stateResult;
think();
switch ( _state )
{
//---------------------------------------------------------------------
case WATCH_HOLD:
//---------------------------------------------------------------------
stateResult = evaluateStateHold(self);
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( WATCH_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( WATCH_ROTATE );
break;
//---------------------------------------------------------------------
case WATCH_ROTATE:
//---------------------------------------------------------------------
stateResult = evaluateStateRotate(self);
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( WATCH_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( WATCH_HOLD );
break;
//---------------------------------------------------------------------
case WATCH_SUCCESS:
//---------------------------------------------------------------------
return BEHAVIOR_SUCCESS;
break;
//---------------------------------------------------------------------
case WATCH_FAILED:
//---------------------------------------------------------------------
return BEHAVIOR_FAILED;
break;
}
return BEHAVIOR_EVALUATING;
}
/**
This method is used to advance the controller in time. It takes in a list of the contact points, since they might be
used to determine when to transition to a new state. This method returns -1 if the controller does not advance to a new state,
or the index of the state that it transitions to otherwise.
*/
int SimBiController::advanceInTime(double dt, DynamicArray<ContactPoint> *cfs){
if (FSMStateIndex >= (int)states.size()){
tprintf("Warning: no FSM state was selected in the controller!\n");
return -1;
}
bodyTouchedTheGround = false;
//see if anything else other than the feet touch the ground...
for (uint i=0;i<cfs->size();i++){
//if neither of the bodies involved are articulated, it means they are just props so we can ignore them
if ((*cfs)[i].rb1->isArticulated() == false && (*cfs)[i].rb2->isArticulated() == false)
continue;
if (isFoot((*cfs)[i].rb1) || isFoot((*cfs)[i].rb2))
continue;
bodyTouchedTheGround = true;
}
//advance the phase of the controller
this->phi += dt/states[FSMStateIndex]->getStateTime();
//see if we have to transition to the next state in the FSM, and do it if so...
if (states[FSMStateIndex]->needTransition(phi, fabs(getForceOnFoot(swingFoot, cfs).dotProductWith(SimGlobals::up)), fabs(getForceOnFoot(stanceFoot, cfs).dotProductWith(SimGlobals::up)))){
int newStateIndex = states[FSMStateIndex]->getNextStateIndex();
transitionToState(newStateIndex);
return newStateIndex;
}
//if we didn't transition to a new state...
return -1;
}
void DialogueManager::runQuestion() {
if (_mouseButtons == kMouseLeftUp) {
_gfx->freeDialogueObjects();
transitionToState(NEXT_ANSWER);
}
}
void DialogueManager::runAnswer() {
_answerId = selectAnswer();
if (_answerId != NO_ANSWER_SELECTED) {
_cmdList = &_q->_answers[_answerId]->_commands;
_gfx->freeDialogueObjects();
transitionToState(NEXT_QUESTION);
}
}
//--------------------------------------------------------------
// 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: init()
// Class: Work
//
// Description: Initializes memeber variables
//
// Parameters: Actor &self -- Actor executing this behavior
//
// Returns: None
//--------------------------------------------------------------
void Work::init( Actor &self )
{
_self = &self;
_animDone = false;
_endTime = 0.0f;
_node = self.currentHelperNode.node;
transitionToState( WORK_FIND_NODE );
}
//--------------------------------------------------------------
//
// Name: Evaluate()
// Class: CloseInOnEnemyWhileFiringWeapon
//
// Description: Update for this behavior -- called every server frame
//
// Parameters: Actor &self -- Actor executing this behavior
//
// Returns: BehaviorReturnCode_t
//
//--------------------------------------------------------------
BehaviorReturnCode_t CloseInOnEnemyWhileFiringWeapon::Evaluate( Actor & )
{
BehaviorReturnCode_t stateResult;
think();
switch ( _state )
{
//---------------------------------------------------------------------
case CIWF_APPROACH_SETUP_APPROACH:
//---------------------------------------------------------------------
stateResult = evaluateStateSetupApproach();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( CIWF_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( CIWF_APPROACH_FIRE );
break;
//---------------------------------------------------------------------
case CIWF_APPROACH_FIRE:
//---------------------------------------------------------------------
stateResult = evaluateStateApproachFire();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( CIWF_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( CIWF_APPROACH_FIRE_PAUSE );
break;
//---------------------------------------------------------------------
case CIWF_APPROACH_FIRE_PAUSE:
//---------------------------------------------------------------------
stateResult = evaluateStateApproachFirePause();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( CIWF_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( CIWF_APPROACH_FIRE );
break;
//---------------------------------------------------------------------
case CIWF_SUCCESS:
//---------------------------------------------------------------------
return BEHAVIOR_SUCCESS;
break;
//---------------------------------------------------------------------
case CIWF_FAILED:
//---------------------------------------------------------------------
return BEHAVIOR_FAILED;
break;
}
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: updateEnemy()
// Class: CloseInOnEnemyWhileFiringWeapon
//
// Description: Sets our _currentEnemy
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CloseInOnEnemyWhileFiringWeapon::updateEnemy()
{
Entity *currentEnemy = _self->enemyManager->GetCurrentEnemy();
if ( !currentEnemy )
{
_self->enemyManager->FindHighestHateEnemy();
currentEnemy = _self->enemyManager->GetCurrentEnemy();
if ( !currentEnemy )
{
SetFailureReason( "CloseInOnEnemyWhileFiringWeapon::updateEnemy -- No Enemy" );
transitionToState( CIWF_FAILED );
}
}
_currentEnemy = currentEnemy;
}
void GetupModule::selectGetup() {
int tiltSideThreshold = 5;
if (numCrosses > 0) // be more confident after a cross
tiltSideThreshold = 2;
// decide which getup to do
if (walk_request_->tilt_fallen_counter_ < -tiltSideThreshold) {
setBackGetup();
} else if (walk_request_->tilt_fallen_counter_ > tiltSideThreshold) {
setFrontGetup();
} else if ((numCrosses == 0) && (walk_request_->roll_fallen_counter_ >= 2)) {
transitionToState(CROSS);
} else if (getTimeInState() < 0.2) {
// do nothing, maybe we'll end up somewhere good
} else {
setBackGetup(); // default to back in the end
}
}
//--------------------------------------------------------------
// Name: updateEnemy()
// Class: StationaryFireCombat
//
// Description: Sets our _currentEnemy
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void StationaryFireCombat::updateEnemy()
{
Entity *currentEnemy = _self->enemyManager->GetCurrentEnemy();
if ( !currentEnemy )
{
_self->enemyManager->FindHighestHateEnemy();
currentEnemy = _self->enemyManager->GetCurrentEnemy();
if ( !currentEnemy )
{
SetFailureReason( "STATIONARY_FIRE_FAILED::updateEnemy -- No Enemy" );
transitionToState( STATIONARY_FIRE_FAILED );
return;
}
}
_currentEnemy = currentEnemy;
//_self->turnTowardsEntity( _currentEnemy, 0.0f );
}
//--------------------------------------------------------------
// Name: init()
// Class: GeneralCombat
//
// Description: Initializes memeber variables
//
// Parameters: Actor &self -- Actor executing this behavior
//
// Returns: None
//--------------------------------------------------------------
void GeneralCombatWithRangedWeapon::init( Actor &self )
{
_self = &self;
_finishedPostureTransition = true;
_randomAdvanceLockOut = false;
_randomRetreatLockOut = false;
_nextRotateTime = 0.0f;
_nextStrafeAttemptTime = 0.0f;
_nextPostureChange = 0.0f;
_nextClearRetreatLockOutTime = 0.0f;
_nextClearAdvanceLockOutTime = 0.0f;
_nextFireTime = 0.0f;
_nextPauseTime = 0.0f;
_randomAdvanceFailures = 0;
_randomRetreatFailures = 0;
transitionToState(GC_WRW_STAND);
updateEnemy();
}
//--------------------------------------------------------------
// Name: updateEnemy()
// Class: GeneralCombatWithRangedWeapon
//
// Description: Sets our _currentEnemy
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void GeneralCombatWithRangedWeapon::updateEnemy()
{
Entity *currentEnemy = _self->enemyManager->GetCurrentEnemy();
if ( !currentEnemy )
{
_self->enemyManager->FindHighestHateEnemy();
currentEnemy = _self->enemyManager->GetCurrentEnemy();
if ( !currentEnemy )
{
SetFailureReason( "GeneralCombatWithRangedWeapon::updateEnemy -- No Enemy" );
transitionToState( GC_WRW_FAILED );
}
}
_currentEnemy = currentEnemy;
_self->SetHeadWatchTarget( _currentEnemy );
setupRotate();
}
//--------------------------------------------------------------
// 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: Evaluate()
// Class: GeneralCombatWithRangedWeapon
//
// Description: Evaluates the behavior
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: BehaviorReturnCode_t
//--------------------------------------------------------------
BehaviorReturnCode_t GeneralCombatWithRangedWeapon::Evaluate( Actor &self )
{
BehaviorReturnCode_t stateResult;
str currentPostureState = _self->postureController->getCurrentPostureName();
float distToEnemy = self.enemyManager->GetDistanceFromEnemy();
think();
switch ( _state )
{
//---------------------------------------------------------------------
case GC_WRW_CHANGE_POSTURE_TO_ADVANCE:
//---------------------------------------------------------------------
stateResult = evaluateStateChangePostureToAdvance();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( GC_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( GC_WRW_ADVANCE );
break;
//---------------------------------------------------------------------
case GC_WRW_CHANGE_POSTURE_TO_RETREAT:
//---------------------------------------------------------------------
stateResult = evaluateStateChangePostureToRetreat();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( GC_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( GC_WRW_RETREAT );
break;
//---------------------------------------------------------------------
case GC_WRW_ADVANCE:
//---------------------------------------------------------------------
if ( !checkShouldApproach( distToEnemy ) )
{
transitionToState( GC_WRW_STAND );
return BEHAVIOR_EVALUATING;
}
stateResult = evaluateStateAdvance();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( GC_WRW_STAND );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( GC_WRW_ADVANCE_FIRING );
break;
//---------------------------------------------------------------------
case GC_WRW_ADVANCE_FIRING:
//---------------------------------------------------------------------
if ( !checkShouldApproach( distToEnemy ) )
{
transitionToState( GC_WRW_STAND );
return BEHAVIOR_EVALUATING;
}
stateResult = evaluateStateAdvanceFiring();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( GC_WRW_STAND );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( GC_WRW_ADVANCE );
break;
//---------------------------------------------------------------------
case GC_WRW_RETREAT:
//---------------------------------------------------------------------
if ( !checkShouldRetreat( distToEnemy ) )
{
transitionToState( GC_WRW_STAND );
_self->movementSubsystem->setMovingBackwards( false );
return BEHAVIOR_EVALUATING;
}
stateResult = evaluateStateRetreat();
if ( stateResult == BEHAVIOR_FAILED )
{
transitionToState( GC_WRW_STAND );
_self->movementSubsystem->setMovingBackwards( false );
}
if ( stateResult == BEHAVIOR_SUCCESS )
{
_self->movementSubsystem->setMovingBackwards( false );
transitionToState( GC_WRW_RETREAT_FIRING );
}
break;
//---------------------------------------------------------------------
case GC_WRW_RETREAT_FIRING:
//---------------------------------------------------------------------
if ( !checkShouldRetreat( distToEnemy ) )
{
_self->movementSubsystem->setMovingBackwards( false );
transitionToState( GC_WRW_STAND );
return BEHAVIOR_EVALUATING;
}
stateResult = evaluateStateRetreatFiring();
if ( stateResult == BEHAVIOR_FAILED )
{
transitionToState( GC_WRW_STAND );
_self->movementSubsystem->setMovingBackwards( false );
}
if ( stateResult == BEHAVIOR_SUCCESS )
{
_self->movementSubsystem->setMovingBackwards( false );
transitionToState( GC_WRW_RETREAT );
}
break;
//---------------------------------------------------------------------
case GC_WRW_STRAFE:
//---------------------------------------------------------------------
stateResult = evaluateStateStrafe();
//It's perfectly understandable that strafe might
//fail, so instead of failing the behavior entirely
//we'll just change states
if ( stateResult != BEHAVIOR_EVALUATING )
{
if ( currentPostureState == "DUCK" )
transitionToState( GC_WRW_DUCKED );
if ( currentPostureState == "STAND" )
transitionToState( GC_WRW_STAND );
}
break;
//---------------------------------------------------------------------
case GC_WRW_CHANGE_POSTURE_DUCK:
//---------------------------------------------------------------------
stateResult = evaluateStateChangePostureDuck();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( GC_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( GC_WRW_DUCKED );
break;
//---------------------------------------------------------------------
case GC_WRW_DUCKED:
//---------------------------------------------------------------------
//
// First Check if we are within our _approachDist. If
// not, then we need to close in on our enemy
//
if ( checkShouldApproach( distToEnemy ) )
{
transitionToState( GC_WRW_CHANGE_POSTURE_TO_ADVANCE );
return BEHAVIOR_EVALUATING;
}
//
// Now Check if wer are within our _retreatDist. If
// we are, then we need to retreat in on our enemy
//
if ( checkShouldRetreat( distToEnemy ) )
{
transitionToState( GC_WRW_CHANGE_POSTURE_TO_RETREAT );
return BEHAVIOR_EVALUATING;
}
//
// Lets check if we need to strafe
//
if ( checkShouldStrafe( distToEnemy ) )
{
transitionToState( GC_WRW_STRAFE );
return BEHAVIOR_EVALUATING;
}
//
//Now let's check if we need to change posture
//
if ( checkShouldChangePosture( distToEnemy ) )
{
transitionToState( GC_WRW_CHANGE_POSTURE_STAND );
return BEHAVIOR_EVALUATING;
}
//
//Well we don't have anything else to do, so let's evaluate our state
//
stateResult = evaluateRotate();
if ( stateResult == BEHAVIOR_SUCCESS )
{
stateResult = evaluateStateStand();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( GC_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( GC_WRW_DUCKED_FIRING );
}
break;
//---------------------------------------------------------------------
case GC_WRW_DUCKED_FIRING:
//---------------------------------------------------------------------
stateResult = evaluateRotate();
stateResult = evaluateStateDuckedFiring();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( GC_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( GC_WRW_DUCKED );
break;
//---------------------------------------------------------------------
case GC_WRW_CHANGE_POSTURE_STAND:
//---------------------------------------------------------------------
stateResult = evaluateStateChangePostureStand();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( GC_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( GC_WRW_STAND );
break;
//---------------------------------------------------------------------
case GC_WRW_STAND:
//---------------------------------------------------------------------
//
// First Check if we are within our _approachDist. If
// not, then we need to close in on our enemy
//
if ( checkShouldApproach( distToEnemy ) )
{
transitionToState( GC_WRW_CHANGE_POSTURE_TO_ADVANCE );
return BEHAVIOR_EVALUATING;
}
//
// Now Check if wer are within our _retreatDist. If
// we are, then we need to retreat in on our enemy
//
if ( checkShouldRetreat( distToEnemy ) )
{
transitionToState( GC_WRW_CHANGE_POSTURE_TO_RETREAT );
return BEHAVIOR_EVALUATING;
}
//
// Lets check if we need to strafe
//
if ( checkShouldStrafe( distToEnemy ) )
{
transitionToState( GC_WRW_STRAFE );
return BEHAVIOR_EVALUATING;
}
//
//Now let's check if we need to change posture
//
if ( checkShouldChangePosture( distToEnemy ) )
{
transitionToState( GC_WRW_CHANGE_POSTURE_DUCK );
return BEHAVIOR_EVALUATING;
}
//
//Well we don't have anything else to do, so let's evaluate our state
//
stateResult = evaluateRotate();
if ( stateResult == BEHAVIOR_SUCCESS )
{
stateResult = evaluateStateStand();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( GC_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( GC_WRW_STAND_FIRING );
}
break;
//---------------------------------------------------------------------
case GC_WRW_STAND_FIRING:
//---------------------------------------------------------------------
stateResult = evaluateRotate();
stateResult = evaluateStateStandFiring();
if ( stateResult == BEHAVIOR_FAILED )
transitionToState( GC_WRW_FAILED );
if ( stateResult == BEHAVIOR_SUCCESS )
transitionToState( GC_WRW_STAND );
break;
}
return BEHAVIOR_EVALUATING;
}
/**
This method loads all the pertinent information regarding the simbicon controller from a file.
*/
void SimBiController::loadFromFile(char* fName){
if (fName == NULL)
throwError("NULL file name provided.");
FILE *f = fopen(fName, "r");
if (f == NULL)
throwError("Could not open file: %s", fName);
//to be able to load multiple controllers from multiple files,
//we will use this offset to make sure that the state numbers
//mentioned in each input file are updated correctly
int stateOffset = this->states.size();
SimBiConState* tempState;
int tempStateNr = -1;
//have a temporary buffer used to read the file line by line...
char buffer[200];
//this is where it happens.
while (!feof(f)){
//get a line from the file...
fgets(buffer, 200, f);
if (feof(f))
break;
if (strlen(buffer)>195)
throwError("The input file contains a line that is longer than ~200 characters - not allowed");
char *line = lTrim(buffer);
int lineType = getConLineType(line);
switch (lineType) {
case CON_PD_GAINS_START:
readGains(f);
break;
case CON_STATE_START:
tempState = new SimBiConState();
sscanf(line, "%d", &tempStateNr);
if (tempStateNr != stateOffset + this->states.size())
throwError("Inccorect state offset specified: %d", tempStateNr);
states.push_back(tempState);
tempState->readState(f, stateOffset);
//now we have to resolve all the joint names (i.e. figure out which joints they apply to).
resolveJoints(tempState);
break;
case CON_STANCE_HIP_DAMPING:
sscanf(line, "%lf", &stanceHipDamping);
break;
case CON_STANCE_HIP_MAX_VELOCITY:
sscanf(line, "%lf", &stanceHipMaxVelocity);
break;
case CON_ROOT_PRED_TORQUE_SCALE:
sscanf(line, "%lf", &rootPredictiveTorqueScale);
break;
case CON_CHARACTER_STATE:
character->loadReducedStateFromFile(trim(line));
strcpy(initialBipState, trim(line));
break;
case CON_START_AT_STATE:
if (sscanf(line, "%d", &tempStateNr) != 1)
throwError("A starting state must be specified!");
transitionToState(tempStateNr);
startingState = tempStateNr;
break;
case CON_COMMENT:
break;
case CON_STARTING_STANCE:
if (strncmp(trim(line), "left", 4) == 0){
setStance(LEFT_STANCE);
startingStance = LEFT_STANCE;
}
else if (strncmp(trim(line), "right", 5) == 0){
setStance(RIGHT_STANCE);
startingStance = RIGHT_STANCE;
}
else
throwError("When using the \'reverseTargetOnStance\' keyword, \'left\' or \'right\' must be specified!");
break;
case CON_NOT_IMPORTANT:
tprintf("Ignoring input line: \'%s\'\n", line);
break;
default:
throwError("Incorrect SIMBICON input file: \'%s\' - unexpected line.", buffer);
}
}
}
//--------------------------------------------------------------
// 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;
}
//--------------------------------------------------------------
// Name: Begin()
// Class: GotoCurrentHelperNode
//
// Description: Initializes the behavior
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: None
//--------------------------------------------------------------
void GotoCurrentHelperNode::Begin( Actor &self )
{
init( self );
transitionToState ( GOTO_HNODE_FIND_NODE );
}
//--------------------------------------------------------------
// 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: TorsoAimAndFireWeapon
//
// Description: Evaluates the behavior
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: BehaviorReturnCode_t
//--------------------------------------------------------------
BehaviorReturnCode_t TorsoAimAndFireWeapon::Evaluate( Actor &self )
{
BehaviorReturnCode_t stateResult;
think();
switch ( _state )
{
//---------------------------------------------------------------------
case TORSO_AIM_AND_FIRE_PRE_FIRE:
//---------------------------------------------------------------------
stateResult = evaluateStatePreFire();
if ( stateResult == BEHAVIOR_SUCCESS )
{
transitionToState( TORSO_AIM_AND_FIRE_AIM );
}
if ( stateResult == BEHAVIOR_FAILED )
{
transitionToState( TORSO_AIM_AND_FIRE_FAILED );
}
break;
//---------------------------------------------------------------------
case TORSO_AIM_AND_FIRE_AIM:
//---------------------------------------------------------------------
stateResult = evaluateStateAim();
if ( stateResult == BEHAVIOR_SUCCESS )
{
if ( _aimOnly )
transitionToState(TORSO_AIM_AND_FIRE_AIM);
else
transitionToState( TORSO_AIM_AND_FIRE_ATTACK );
}
if ( stateResult == BEHAVIOR_FAILED )
return BEHAVIOR_FAILED;
break;
//---------------------------------------------------------------------
case TORSO_AIM_AND_FIRE_ATTACK:
//---------------------------------------------------------------------
stateResult = evaluateStateAttack();
if ( stateResult == BEHAVIOR_FAILED )
{
_fireWeapon.End( *_self );
if ( _postFireAnim.length() )
transitionToState( TORSO_AIM_AND_FIRE_POST_FIRE );
else
transitionToState( TORSO_AIM_AND_FIRE_FAILED );
}
if ( stateResult == BEHAVIOR_SUCCESS )
{
_fireWeapon.End( *_self );
if ( _postFireAnim.length() )
transitionToState( TORSO_AIM_AND_FIRE_POST_FIRE );
else
transitionToState( TORSO_AIM_AND_FIRE_SUCCESS );
}
break;
//---------------------------------------------------------------------
case TORSO_AIM_AND_FIRE_POST_FIRE:
//---------------------------------------------------------------------
stateResult = evaluateStatePostFire();
if ( stateResult == BEHAVIOR_SUCCESS )
{
transitionToState( TORSO_AIM_AND_FIRE_SUCCESS );
}
break;
//---------------------------------------------------------------------
case TORSO_AIM_AND_FIRE_SUCCESS:
//---------------------------------------------------------------------
_self->SetControllerAngles( ActorTorsoTag, vec_zero );
if ( _repeat )
{
Begin(self);
return BEHAVIOR_EVALUATING;
}
return BEHAVIOR_SUCCESS;
break;
//---------------------------------------------------------------------
case TORSO_AIM_AND_FIRE_FAILED:
//---------------------------------------------------------------------
if ( _repeat )
{
Begin(self);
return BEHAVIOR_EVALUATING;
}
return BEHAVIOR_FAILED;
break;
}
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: Begin()
// Class: StationaryFireCombat
//
// Description: Initializes the behavior
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: None
//--------------------------------------------------------------
void StationaryFireCombat::Begin( Actor &self )
{
init( self );
transitionToState ( STATIONARY_FIRE_AIM );
}
//--------------------------------------------------------------
// Name: Evaluate()
// Class: StationaryFireCombat
//
// Description: Evaluates the behavior
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: BehaviorReturnCode_t
//--------------------------------------------------------------
BehaviorReturnCode_t StationaryFireCombat::Evaluate( Actor & )
{
BehaviorReturnCode_t stateResult;
think();
switch ( _state )
{
//---------------------------------------------------------------------
case STATIONARY_FIRE_AIM:
//---------------------------------------------------------------------
stateResult = evaluateStateAim();
if ( stateResult == BEHAVIOR_SUCCESS )
{
updateEnemy();
if ( _preFireAnim.length() )
transitionToState( STATIONARY_FIRE_PRE_FIRE );
else
transitionToState( STATIONARY_FIRE_ATTACK );
}
break;
//---------------------------------------------------------------------
case STATIONARY_FIRE_PRE_FIRE:
//---------------------------------------------------------------------
stateResult = evaluateStatePreFire();
if ( stateResult == BEHAVIOR_SUCCESS )
{
transitionToState( STATIONARY_FIRE_ATTACK );
}
if ( stateResult == BEHAVIOR_FAILED )
{
transitionToState( STATIONARY_FIRE_FAILED );
}
break;
//---------------------------------------------------------------------
case STATIONARY_FIRE_ATTACK:
//---------------------------------------------------------------------
stateResult = evaluateStateAttack();
if ( stateResult == BEHAVIOR_SUCCESS )
{
_fireWeapon.End( *_self );
if ( _postFireAnim.length() )
transitionToState( STATIONARY_FIRE_POST_FIRE );
else
transitionToState( STATIONARY_FIRE_SUCCESS );
}
if ( stateResult == BEHAVIOR_FAILED )
{
_fireWeapon.End( *_self );
if ( _postFireAnim.length() )
transitionToState( STATIONARY_FIRE_POST_FIRE );
else
transitionToState( STATIONARY_FIRE_SUCCESS );
}
break;
//---------------------------------------------------------------------
case STATIONARY_FIRE_POST_FIRE:
//---------------------------------------------------------------------
stateResult = evaluateStatePostFire();
if ( stateResult == BEHAVIOR_SUCCESS )
{
transitionToState( STATIONARY_FIRE_SUCCESS );
}
break;
//---------------------------------------------------------------------
case STATIONARY_FIRE_SUCCESS:
//---------------------------------------------------------------------
return BEHAVIOR_SUCCESS;
break;
//---------------------------------------------------------------------
case STATIONARY_FIRE_FAILED:
//---------------------------------------------------------------------
return BEHAVIOR_FAILED;
break;
}
return BEHAVIOR_EVALUATING;
}
void DialogueManager::start() {
assert(_dialogue);
_q = _dialogue->_questions[0];
_state = DIALOGUE_START;
transitionToState(displayQuestion() ? RUN_QUESTION : NEXT_ANSWER);
}
bool GetupModule::processFrameChild() {
//std::cout << frame_info_->frame_id << " " << getName(state) << std::endl;
// set getting up odometry
if (isGettingUp()){
// which way are we getting up?
odometry_->getting_up_side_ = getUpSide;
} else {
// no getup
odometry_->getting_up_side_ = Getup::NONE;
// set getup side back to unknown for the next getup
getUpSide = Getup::UNKNOWN;
}
bool fallenCountHigh = (abs(walk_request_->roll_fallen_counter_) >= 50) || (abs(walk_request_->tilt_fallen_counter_) >= 50);
switch (state) {
case INITIAL:
if (walk_request_->getup_from_keeper_dive_) {
transitionToState(CROSS); // goalie needs cross
} else {
if (fallenCountHigh)
transitionToState(STIFFNESS_ON);
else
transitionToState(PREPARE_ARMS);
}
break;
case PREPARE_ARMS:
if ((getTimeInState() > PREPARE_ARMS_TIME) || fallenCountHigh) { // if fallen count is high, it's too late to prepare arms
transitionToState(STIFFNESS_OFF);
} else {
if (getTimeInState() < 0.015) {
prepareArms();
}
// otherwise do nothing
}
break;
case STIFFNESS_OFF:
if ((getTimeInState() > STIFFNESS_OFF_TIME) || fallenCountHigh) { // if fallen count is high, it's too late to worry about the stiffness being off
transitionToState(STIFFNESS_ON);
} else {
commands_->setAllStiffness(0.0,10);
}
break;
case STIFFNESS_ON:
if (getTimeInState() > 0.001) {
//if (armsStuckBehindBack()) {
//std::cout << "Trying to free arms" << std::endl;
//transitionToState(FREE_ARMS);
//} else {
transitionToState(EXECUTE);
//}
} else {
commands_->setAllStiffness(1.0,10);
}
break;
case CROSS:
if (getTimeInState() < CROSS_TIME)
cross();
else {
transitionToState(EXECUTE);
numCrosses++;
}
break;
case EXECUTE:
if (currMotion == Getup) {
selectGetup();
if (currMotion == Getup) // didn't choose
return true; // don't do anything else
// yay! we chose a getup
std::cout << "Starting getup: " << getName(currMotion) << std::endl;
stateStartTime = frame_info_->seconds_since_start; // reset the time
}
if (isMotionDoneExecuting()) {
if ((abs(walk_request_->tilt_fallen_counter_) > 2) || (abs(walk_request_->roll_fallen_counter_) > 2)) {
// still fallen
selectGetup();
transitionToState(STIFFNESS_ON);
} else {
transitionToState(STAND);
}
} else {
if (getTimeInState() < 0.015)
commands_->setAllStiffness(1.0,10);
//if (shouldAbortGetup()) { // KG: for now, never abort. Consider adding it back in if needed, but will need to also update method for new getup states
// std::cout << "FAILED GETUP" << std::endl;
// numRestarts++;
// transitionToState(PAUSE_BEFORE_RESTART);
//}
executeMotionSequence();
}
break;
case STAND:
// do nothing, handled in MotionCore
if (getTimeInState() > 0.5)
transitionToState(FINISHED);
break;
case FREE_ARMS:
currMotion = backFreeArms;
if (isMotionDoneExecuting()) {
currMotion = Getup;
transitionToState(EXECUTE);
} else {
if (getTimeInState() < 0.015)
commands_->setAllStiffness(1.0,10);
executeMotionSequence();
}
break;
case PAUSE_BEFORE_RESTART:
if (getTimeInState() > PAUSE_BEFORE_RESTART_TIME) {
transitionToState(STIFFNESS_ON);
} else {
commands_->setAllStiffness(0.0,10);
}
break;
default:
return false;
break;
}
return true;
}
//--------------------------------------------------------------
// Name: init()
// Class: CloseInOnEnemyWhileFiringWeapon
//
// Description: Initializes the behavior
//
// Parameters: Actor &self
//
// Returns: None
//--------------------------------------------------------------
void CloseInOnEnemyWhileFiringWeapon::init( Actor &self )
{
_self = &self;
updateEnemy();
transitionToState(CIWF_APPROACH_SETUP_APPROACH);
}
