//--------------------------------------------------------------
// Name: setupStateStand()
// Class: GeneralCombatWithRangedWeapon
//
// Description: Sets up Stand State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void GeneralCombatWithRangedWeapon::setupStateStand()
{
_nextPauseTime = level.time + G_Random( _pauseTimeMax ) + _pauseTimeMin;
setTorsoAnim();
_self->SetAnim( _torsoAnim , NULL , legs );
_fireWeapon.End(*_self);
}
void Gib::SprayBlood
(
Vector start
)
{
Vector norm;
trace_t trace;
Vector trace_end;
trace_end = velocity;
trace_end.normalize();
trace_end *= 1000;
trace_end += start;
trace = G_Trace( start, vec_zero, vec_zero, trace_end, this, MASK_SOLID, false, "Gib::SprayBlood" );
if ( HitSky( &level.impact_trace ) || ( !level.impact_trace.ent ) || ( level.impact_trace.ent->solid != SOLID_BSP ) )
{
return;
}
// Do a bloodsplat
if ( blood_splat_name.length() )
{
Decal *decal = new Decal;
decal->setShader( blood_splat_name );
decal->setOrigin( Vector( trace.endpos ) + ( Vector( level.impact_trace.plane.normal ) * 0.2f ) );
decal->setDirection( level.impact_trace.plane.normal );
decal->setOrientation( "random" );
decal->setRadius( blood_splat_size + G_Random( blood_splat_size ) );
}
}
//--------------------------------------------------------------
// Name: setupStateDucked()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up our Ducked State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateDucked()
{
_nextPauseTime = level.time + G_Random( _pauseTimeMax ) + _pauseTimeMin;
setTorsoAnim();
_self->SetAnim( "duck" , NULL , legs );
_fireWeapon.End(*_self);
}
//--------------------------------------------------------------
// Name: checkShouldStrafe()
// Class: GeneralCombatWithRangedWeapon
//
// Description: Checks if we should strafe
//
// Parameters: float distToEnemy
//
// Returns: true or false
//--------------------------------------------------------------
bool GeneralCombatWithRangedWeapon::checkShouldStrafe( float distToEnemy )
{
//
// First Check Timer
//
if ( level.time < _nextStrafeAttemptTime )
return false;
//
//Next check if we need to strafe because we're too close to the enemy and our retreats have
//have been locked.
//
if ( distToEnemy <= _retreatDist && _randomRetreatLockOut )
return true;
//
//Now let's check if we need to strafe based on fire line
//
if ( _self->enemyManager->InEnemyLineOfFire() && G_Random() < _strafeChance )
return true;
return false;
}
//--------------------------------------------------------------
// Name: setupStateAdvance()
// Class: GeneralCombatWithRangedWeapon
//
// Description: Sets up the Advance State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void GeneralCombatWithRangedWeapon::setupStateAdvance()
{
Vector selfToEnemy;
float dist;
dist = G_Random ( 64.0f ) + 96.0f;
if ( !_currentEnemy )
{
updateEnemy();
return;
}
// Lets get oriented towards our enemy
selfToEnemy = _currentEnemy->origin - _self->origin;
selfToEnemy = selfToEnemy.toAngles();
_self->setAngles( selfToEnemy );
selfToEnemy.AngleVectors( &selfToEnemy );
_self->movementSubsystem->setMoveDir( selfToEnemy );
_self->movementSubsystem->setAnimDir( selfToEnemy );
_moveRandomDir.SetDistance( dist );
_moveRandomDir.SetAnim( "run" );
_moveRandomDir.SetMode(MoveRandomDirection::RANDOM_MOVE_IN_FRONT);
_moveRandomDir.Begin(*_self);
_moveRandomDir.SetMinDistance( dist * .75 );
}
//--------------------------------------------------------------
// Name: setupHold()
// Class: GeneralCombatWithMeleeWeapon
//
// Description: Set ourselves up to execute the HOLD state
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: true or false
//--------------------------------------------------------------
bool GeneralCombatWithMeleeWeapon::setupHold( Actor &self )
{
self.SetAnim( _primaryTorsoAnim );
_exitHoldTime = level.time + G_Random ( 0.15f ) + 0.25f;
return true;
}
//
// Name: CanShootTargetFrom()
// Parameters: Entity *target
// Vector &startPos
// Description: Checks if the Actor can shoot the target from startPos
//
bool CombatSubsystem::CanAttackTargetFrom(Entity* target, const Vector& startPos)
{
if (_activeWeapon.weapon && !IsTargetInWeaponRange(target) || !target)
return false;
//Make sure target isn't too far "behind" us.
auto startToTarget = target->centroid - startPos;
startToTarget.normalize();
if (_activeWeapon.weapon && DotProduct(startToTarget, act->movementSubsystem->getAnimDir()) <= -.10)
{
return false;
}
//We don't want to check constantly
if (level.time < _nextTimeTracedToTarget)
return _canShootTarget;
_canShootTarget = _traceHitTarget(target, startPos);
_nextTimeTracedToTarget = level.time + _traceInterval + G_Random();
//_nextTimeTracedToTarget = 0.0f;
return _canShootTarget;
}
//--------------------------------------------------------------
// Name: setupStatePause()
// Class: StationaryFireCombat
//
// Description: Sets up our Pause State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void StationaryFireCombat::setupStateAim()
{
faceEnemy();
_endAimTime = level.time + G_Random(_aimTimeMax - _aimTimeMin ) + _aimTimeMin;
_self->SetAnim( _aimAnim , NULL , torso );
_self->SetAnim( _stance , NULL , legs );
}
//--------------------------------------------------------------
// Name: setupStateStandFiring()
// Class: GeneralCombatWithRangedWeapon
//
// Description: Sets up Stand Firing State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void GeneralCombatWithRangedWeapon::setupStateStandFiring()
{
_nextFireTime = level.time + G_Random( _fireTimeMax ) + _fireTimeMin;
if ( _self->combatSubsystem->CanAttackEnemy() )
{
_fireWeapon.SetAnim( _fireAnim );
_fireWeapon.Begin( *_self );
}
}
//--------------------------------------------------------------
// Name: setupStateFireDucked()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up state
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateFireDucked()
{
_nextFireTime = level.time + G_Random( _fireTimeMax ) + _fireTimeMin;
if ( _self->combatSubsystem->CanAttackEnemy() )
{
_fireWeapon.SetAnim( _fireAnim );
_fireWeapon.Begin( *_self );
}
}
void Gib::SetVelocity
(
float damage
)
{
velocity[0] = 100.0 * crandom();
velocity[1] = 100.0 * crandom();
velocity[2] = 200.0 + 100.0 * random();
avelocity = Vector( G_Random( 600 ), G_Random( 600 ), G_Random( 600 ) );
if ( ( damage < -150 ) && ( G_Random() > 0.95f ) )
velocity *= 2.0f;
else if ( damage < -100 )
velocity *= 1.5f;
ClipGibVelocity();
}
//--------------------------------------------------------------
// Name: setupStateAnimateWaitOnTime()
// Class: Work
//
// Description: Sets up State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void Work::setupStateAnimateWaitOnTime()
{
if ( _node->isWaitRandom() )
_endTime = level.time + G_Random(_node->GetWaitTime());
else
_endTime = level.time + _node->GetWaitTime();
_self->SetAnim( _node->GetAnim() , EV_Actor_NotifyBehavior , legs );
}
//--------------------------------------------------------------
// Name: failureStateAdvance()
// Class: GeneralCombatWithRangedWeapon
//
// Description: Failure Handler for the Advance State
//
// Parameters: const str& failureReason
//
// Returns: None
//--------------------------------------------------------------
void GeneralCombatWithRangedWeapon::failureStateAdvance( const str& failureReason )
{
str FailureReason = "_moveRandomDir returned: " + failureReason;
_randomAdvanceFailures++;
if ( _randomAdvanceFailures > 10 )
{
_randomAdvanceLockOut = true;
_nextClearAdvanceLockOutTime = level.time + G_Random( 2.0f ) + 1.0f;
}
}
//--------------------------------------------------------------
// Name: evaluateStateChangePostureToRetreat()
// Class: GeneralCombatWithRangedWeapon
//
// Description: Evaluates the ChangePostureToRetreat State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t GeneralCombatWithRangedWeapon::evaluateStateChangePostureToRetreat()
{
//Basically waiting for our check to come true
if ( _finishedPostureTransition )
{
_nextPostureChange = level.time + G_Random() + 2.5f;
return BEHAVIOR_SUCCESS;
}
return BEHAVIOR_EVALUATING;
}
//--------------------------------------------------------------
// Name: checkShouldDuck()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Checks if actor should duck
//
// Parameters: None
//
// Returns: true or false
//--------------------------------------------------------------
bool CorridorCombatWithRangedWeapon::checkShouldDuck()
{
// We don't duck if the enemy is too close
if ( _self->WithinDistanceXY( _currentEnemy , _threatDistance ) )
return false;
if ( G_Random() <= _postureChangeChance )
return true;
return false;
}
//--------------------------------------------------------------
// Name: setupStateFireStanding()
// Class: CorridorCombatWithRangedWeapon
//
// Description: Sets up our Fire Standing State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void CorridorCombatWithRangedWeapon::setupStateFireStanding()
{
_self->SetAnim( "idle" , NULL , legs);
_nextFireTime = level.time + G_Random( _fireTimeMax ) + _fireTimeMin;
//if ( _self->combatSubsystem->CanAttackEnemy() )
if ( _self->combatSubsystem->CanAttackTarget( _currentEnemy ) )
{
_fireWeapon.SetAnim( _fireAnim );
_fireWeapon.Begin( *_self );
}
}
//--------------------------------------------------------------
// Name: setupStateAim()
// Class: TorsoAimAndFireWeapon
//
// Description: Sets up the Aim State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void TorsoAimAndFireWeapon::setupStateAim()
{
_animDone = false;
if ( _aimTimeMax + _aimTimeMin > 0 )
_endAimTime = level.time + G_Random(_aimTimeMax - _aimTimeMin ) + _aimTimeMin;
else
_endAimTime = -1.0;
_self->SetAnim( _aimAnim , EV_Actor_NotifyTorsoBehavior , torso );
}
//--------------------------------------------------------------
// Name: setupStateRetreatFiring()
// Class: GeneralCombatWithRangedWeapon
//
// Description: Sets up Retreat Firing State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void GeneralCombatWithRangedWeapon::setupStateRetreatFiring()
{
setupStateRetreat();
_nextFireTime = level.time + G_Random( _fireTimeMax ) + _fireTimeMin;
if ( _self->combatSubsystem->CanAttackEnemy() )
{
_fireWeapon.SetAnim( _fireAnim );
_fireWeapon.Begin( *_self );
}
_self->movementSubsystem->setMovingBackwards( true );
}
//--------------------------------------------------------------
// Name: StationaryFireCombat()
// Class: setupStateAttack
//
// Description: Sets up our Attack State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void StationaryFireCombat::setupStateAttack()
{
faceEnemy();
_endFireTime = level.time + G_Random(_fireTimeMax - _fireTimeMin) + _fireTimeMin;
if ( _self->combatSubsystem->CanAttackEnemy() )
{
_fireWeapon.SetAnim( _fireAnim );
_fireWeapon.Begin( *_self );
}
}
//--------------------------------------------------------------
// Name: setupRushEnemyFailed()
// Class: GeneralCombatWithMeleeWeapon
//
// Description: Failure Handler for _setupRushEnemy
//
// Parameters: Actor &self
//
// Returns: None
//--------------------------------------------------------------
void GeneralCombatWithMeleeWeapon::setupRushEnemyFailed ( Actor & )
{
if ( !_allowRushFailure )
{
SetFailureReason( "RushToEnemy Failed" );
_state = GENERAL_COMBAT_MELEE_FAILED;
return;
}
_nextRushAttemptTime = level.time + G_Random( 0.25 ) + 1.25f;
_state = GENERAL_COMBAT_MELEE_SELECT_STATE;
}
//--------------------------------------------------------------
// Name: checkShouldChangePosture()
// Class: GeneralCombatWithRangedWeapon
//
// Description: Checks if we should change posture
//
// Parameters: float distToEnemy
//
// Returns: true or false
//--------------------------------------------------------------
bool GeneralCombatWithRangedWeapon::checkShouldChangePosture( float distToEnemy )
{
//
// First Check Timer
//
if ( level.time < _nextPostureChange )
return false;
if ( G_Random() < _postureChangeChance && distToEnemy > _retreatDist )
return true;
return false;
}
qboolean Personality::_wantsToExecutePackage(PackageTendency_t *tendency )
{
float percent_chance;
float chance;
tendency->lastTendencyCheck = level.time;
percent_chance = tendency->tendency;
chance = G_Random();
return ( chance < percent_chance );
}
void Gib::Throw
(
Event *ev
)
{
Entity *ent;
ent = ev->GetEntity(1);
setOrigin(ent->centroid);
origin.copyTo(edict->s.origin2);
SetVelocity(ev->GetInteger(2));
edict->s.scale = ev->GetFloat(3);
PostEvent(EV_FadeOut, 10 + G_Random(5));
}
Vector CombatSubsystem::GetLeadingTargetPos(float projSpeed, Vector originalTargetPos, Entity* target)
{
auto newTargetPos = originalTargetPos;
if (!target)
return newTargetPos;
if (target->groundentity)
{
// Here we're going to try and lead the target;
auto targetVelocity = target->velocity;
if (projSpeed <= 0)
projSpeed = 1;
auto selfToTarget = originalTargetPos - act->centroid;
auto distToTarget = selfToTarget.length();
auto timeToTarget = distToTarget / projSpeed;
auto enemyMoveDir = targetVelocity;
auto targetSpeed = targetVelocity.length();
enemyMoveDir.normalize();
// Parameterize aim leading over the interval [minLeadFactor,maxLeadFactor]
// such that 0 is targetPos and 1 is newTargetPos.
//
// Select a random parameter value in that range and interpolate
// between the two positions.
// Essentially, the shot will aim at some random point between
// where the target is now and where it (presumably) will be
// given the lead distance.
//
// When <leadFraction> is 0, shots aim at the current position
// of the target. When <leadFracation> is 1, shots aim at
// the best-guess lead-position of the target. When <leadFraction>
// is greater than 1, shots will over-lead the player. Note
// that in the latter case shots may actually hit the player
// if he is circle-strafing or moving closer/farther in addition
// to his lateral movement.
//
auto leadFraction = act->minLeadFactor + G_Random(act->maxLeadFactor - act->minLeadFactor);
auto leadVector = enemyMoveDir * targetSpeed * timeToTarget;
newTargetPos = originalTargetPos + leadFraction * leadVector;
}
return newTargetPos;
}
//--------------------------------------------------------------
// Name: setupRushEnemy
// Class: GeneralCombatWithMeleeWeapon
//
// Description: Sets up the GotoEntity Component Behavior
//
// Parameters: Actor &self
//
// Returns: true or false
//--------------------------------------------------------------
bool GeneralCombatWithMeleeWeapon::setupRushEnemy( Actor &self )
{
Entity *currentEnemy;
currentEnemy = self.enemyManager->GetCurrentEnemy();
if ( !currentEnemy )
return false;
_nextRushAttemptTime = level.time + G_Random( 0.25 ) + 1.25f;
_rush.SetAnim ( _rushAnim );
_rush.SetEntity( self, currentEnemy );
_rush.SetDistance ( 96.0f );
_rush.Begin( self );
return true;
}
//--------------------------------------------------------------
// Name: evaluateStateStrafe()
// Class: GeneralCombatWithRangedWeapon
//
// Description: Evaluates Strafe State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
BehaviorReturnCode_t GeneralCombatWithRangedWeapon::evaluateStateStrafe()
{
BehaviorReturnCode_t result;
result = _strafeComponent.Evaluate( *_self );
if ( result == BEHAVIOR_FAILED )
{
failureStateStrafe( _strafeComponent.GetFailureReason() );
return BEHAVIOR_FAILED;
}
else if ( result == BEHAVIOR_SUCCESS )
{
_nextStrafeAttemptTime = level.time + G_Random( 1.0 ) + 1.0f;
return BEHAVIOR_SUCCESS;
}
return BEHAVIOR_EVALUATING;
}
//
// Name: SenseEnemies()
// Parameters: None
// Description: Checks for players and teammates, to see if the actor
// needs to wake up
//
void SensoryPerception::SenseEnemies()
{
if ( _nextSenseTime > level.time )
return;
_nextSenseTime = level.time + 0.5f + G_Random( 0.2f );
//_nextSenseTime = 0;
//Well, who your enemies are depends on what side your on
if ( act->actortype == IS_ENEMY || act->actortype == IS_MONSTER )
{
//
//If we an ENEMY or a MONSTER than teammates are our enemies
//
Sentient *teammate;
for ( auto i = 1 ; i <= TeamMateList.NumObjects() ; i++ )
{
teammate = TeamMateList.ObjectAt( i );
if ( _SenseEntity( teammate ) ) return;
}
}
else
{
//
//If we an CIVILIAN, FRIEND, or TEAMMATE our potential enemies are active monsters
//
for (auto i = 1 ; i <= ActiveList.NumObjects() ; i++ )
{
_SenseEntity(ActiveList.ObjectAt(i));
}
//In case we didn't find an enemy, but if the players nearby, we want to wake up anyway
_SenseEntity( GetPlayer( 0 ) );
}
}
//--------------------------------------------------------------
// Name: setupChangePosture()
// Class: GeneralCombatWithMeleeWeapon
//
// Description: Sets ourselves up to execute the CHANGE_POSTURE state
//
// Parameters: Actor &self -- The actor executing this behavior
//
// Returns: true or false
//--------------------------------------------------------------
bool GeneralCombatWithMeleeWeapon::setupChangePosture( Actor & )
{
float chance;
chance = G_Random();
/*
if ( chance < .5 )
{
_postureTransitionAnim = "lean_left_dual_stand_start";
_nextPostureState = POSTURE_TRANSITION_STAND_TO_LEAN_LEFT_DUAL;
}
else
{
_postureTransitionAnim = "lean_right_dual_stand_start";
_nextPostureState = POSTURE_TRANSITION_STAND_TO_LEAN_RIGHT_DUAL;
}
self.SetAnim( _postureTransitionAnim , EV_Actor_NotifyBehavior );
self.movementSubsystem->setPostureState( (PostureStates_t)_nextPostureState );
*/
return true;
}
//--------------------------------------------------------------
// 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: setupStateAttack()
// Class: TorsoAimAndFireWeapon
//
// Description: Setup Attack State
//
// Parameters: None
//
// Returns: None
//--------------------------------------------------------------
void TorsoAimAndFireWeapon::setupStateAttack()
{
_animDone = false;
if ( _fireTimeMax + _fireTimeMax > 0 )
_endFireTime = level.time + G_Random(_fireTimeMax - _fireTimeMax) + _fireTimeMin;
else
_endFireTime = -1.0;
if ( _self->combatSubsystem->CanAttackEnemy() || _forceAttack )
{
_fireWeapon.SetTarget(_currentEnemy);
_fireWeapon.SetAnim( _fireAnim );
_fireWeapon.Begin( *_self );
}
else
{
_fireWeapon.End( *_self );
_fireFailed = true;
}
}
