void CNPC_Zombine::RunTask( const Task_t *pTask )
{
switch ( pTask->iTask )
{
case TASK_WAIT_FOR_MOVEMENT_STEP:
case TASK_WAIT_FOR_MOVEMENT:
{
BaseClass::RunTask( pTask );
if ( IsOnFire() && IsSprinting() )
{
StopSprint();
}
//Only do this if I have an enemy
if ( GetEnemy() )
{
if ( AllowedToSprint() == true )
{
Sprint( ( GetHealth() <= GetMaxHealth() * 0.5f ) );
return;
}
if ( HasGrenade() )
{
if ( IsSprinting() )
{
GetNavigator()->SetMovementActivity( (Activity)ACT_ZOMBINE_GRENADE_RUN );
}
else
{
GetNavigator()->SetMovementActivity( (Activity)ACT_ZOMBINE_GRENADE_WALK );
}
return;
}
if ( GetNavigator()->GetMovementActivity() != ACT_WALK )
{
if ( IsSprinting() == false )
{
GetNavigator()->SetMovementActivity( ACT_WALK );
}
}
}
else
{
GetNavigator()->SetMovementActivity( ACT_WALK );
}
break;
}
default:
{
BaseClass::RunTask( pTask );
break;
}
}
}
//=========================================================
// Calcula la nueva velocidad del jugador dependiendo del
// peso de la arma.
//=========================================================
float CIN_Player::CalculateSpeed(CBaseCombatWeapon *pWeapon, float speed)
{
// No se especifico el arma, obtenerla automaticamente.
if ( pWeapon == NULL )
pWeapon = GetActiveWeapon();
ConVarRef hl2_sprintspeed("hl2_sprintspeed");
ConVarRef hl2_walkspeed("hl2_walkspeed");
// Obtenemos la velocidad inicial.
if ( speed == 0 && IsSprinting() )
speed = hl2_sprintspeed.GetFloat();
if ( speed == 0 && !IsSprinting() )
speed = hl2_walkspeed.GetFloat();
float newSpeed = speed;
// Arma válida.
if ( pWeapon )
{
// Obtenemos el peso del arma.
float weaponWeight = pWeapon->GetWpnData().m_WeaponWeight;
// El arma es muy ligera, te da velocidad.
if ( weaponWeight < 0 )
{
weaponWeight = fabs(weaponWeight);
newSpeed = newSpeed + weaponWeight;
}
else
newSpeed = newSpeed - weaponWeight;
}
// Menos de 40% de salud.
if ( GetHealth() <= 40 )
{
// Disminuimos más velocidad entre menos salud tengamos.
if ( GetHealth() <= 5 )
newSpeed = newSpeed - 10;
else if ( GetHealth() <= 10 )
newSpeed = newSpeed - 5;
else if ( GetHealth() <= 20 )
newSpeed = newSpeed - 3;
else if ( GetHealth() <= 40 )
newSpeed = newSpeed - 2;
}
if ( newSpeed < 10 )
newSpeed = 10;
return newSpeed;
}
void CNPC_Zombine::PrescheduleThink( void )
{
GatherGrenadeConditions();
if( gpGlobals->curtime > m_flNextMoanSound )
{
if( CanPlayMoanSound() )
{
// Classic guy idles instead of moans.
IdleSound();
m_flNextMoanSound = gpGlobals->curtime + random->RandomFloat( 10.0, 15.0 );
}
else
{
m_flNextMoanSound = gpGlobals->curtime + random->RandomFloat( 2.5, 5.0 );
}
}
if ( HasGrenade () )
{
CSoundEnt::InsertSound ( SOUND_DANGER, GetAbsOrigin() + GetSmoothedVelocity() * 0.5f , 256, 0.1, this, SOUNDENT_CHANNEL_ZOMBINE_GRENADE );
if( IsSprinting() && GetEnemy() && GetEnemy()->Classify() == CLASS_PLAYER_ALLY_VITAL && HasCondition( COND_SEE_ENEMY ) )
{
if( GetAbsOrigin().DistToSqr(GetEnemy()->GetAbsOrigin()) < Square( 144 ) )
{
StopSprint();
}
}
}
BaseClass::PrescheduleThink();
}
void CNPC_Zombine::GatherGrenadeConditions( void )
{
if ( m_iGrenadeCount <= 0 )
return;
if ( g_flZombineGrenadeTimes > gpGlobals->curtime )
return;
if ( m_flGrenadePullTime > gpGlobals->curtime )
return;
if ( m_flSuperFastAttackTime >= gpGlobals->curtime )
return;
if ( HasGrenade() )
return;
if ( GetEnemy() == NULL )
return;
if ( FVisible( GetEnemy() ) == false )
return;
if ( IsSprinting() )
return;
if ( IsOnFire() )
return;
if ( IsRunningDynamicInteraction() == true )
return;
if ( m_ActBusyBehavior.IsActive() )
return;
CBasePlayer *pPlayer = AI_GetSinglePlayer();
if ( pPlayer && pPlayer->FVisible( this ) )
{
float flLengthToPlayer = (pPlayer->GetAbsOrigin() - GetAbsOrigin()).Length();
float flLengthToEnemy = flLengthToPlayer;
if ( pPlayer != GetEnemy() )
{
flLengthToEnemy = ( GetEnemy()->GetAbsOrigin() - GetAbsOrigin()).Length();
}
if ( flLengthToPlayer <= GRENADE_PULL_MAX_DISTANCE && flLengthToEnemy <= GRENADE_PULL_MAX_DISTANCE )
{
float flPullChance = 1.0f - ( flLengthToEnemy / GRENADE_PULL_MAX_DISTANCE );
m_flGrenadePullTime = gpGlobals->curtime + 0.5f;
if ( flPullChance >= random->RandomFloat( 0.0f, 1.0f ) )
{
g_flZombineGrenadeTimes = gpGlobals->curtime + 10.0f;
SetCondition( COND_ZOMBINE_GRENADE );
}
}
}
}
bool CSDKPlayer::CanAttack( void )
{
#if defined ( SDK_USE_SPRINTING )
#if !defined ( SDK_SHOOT_WHILE_SPRINTING )
if ( IsSprinting() )
return false;
#endif // SDK_SHOOT_WHILE_SPRINTING
#endif // SDK_USE_SPRINTING
#if !defined ( SDK_SHOOT_ON_LADDERS )
if ( GetMoveType() == MOVETYPE_LADDER )
return false;
#endif //SDK_SHOOT_ON_LADDERS
#if !defined ( SDK_SHOOT_WHILE_JUMPING )
if ( m_Shared.IsJumping() )
return false;
#endif //SDK_SHOOT_WHILE_JUMPING
#if defined ( SDK_USE_PRONE )
// cannot attack while prone moving.
if ( m_Shared.IsProne() && GetAbsVelocity().LengthSqr() > 1 )
{
return false;
}
if( m_Shared.IsGoingProne() || m_Shared.IsGettingUpFromProne() )
{
return false;
}
#endif // SDK_USE_PRONE
return true;
}
void C_MSS_Player::PreThink( void )
{
QAngle vTempAngles = GetLocalAngles();
if ( GetLocalPlayer() == this )
{
vTempAngles[PITCH] = EyeAngles()[PITCH];
}
else
{
vTempAngles[PITCH] = m_angEyeAngles[PITCH];
}
if ( vTempAngles[YAW] < 0.0f )
{
vTempAngles[YAW] += 360.0f;
}
SetLocalAngles( vTempAngles );
BaseClass::PreThink();
HandleSpeedChanges();
if ( m_HL2Local.m_flSuitPower <= 0.0f )
{
if( IsSprinting() )
{
StopSprinting();
}
}
}
void CNPC_Zombine::ReleaseGrenade( Vector vPhysgunPos )
{
if ( HasGrenade() == false )
return;
Vector vDir = vPhysgunPos - m_hGrenade->GetAbsOrigin();
VectorNormalize( vDir );
Activity aActivity;
Vector vForward, vRight;
GetVectors( &vForward, &vRight, NULL );
float flDotForward = DotProduct( vForward, vDir );
float flDotRight = DotProduct( vRight, vDir );
bool bNegativeForward = false;
bool bNegativeRight = false;
if ( flDotForward < 0.0f )
{
bNegativeForward = true;
flDotForward = flDotForward * -1;
}
if ( flDotRight < 0.0f )
{
bNegativeRight = true;
flDotRight = flDotRight * -1;
}
if ( flDotRight > flDotForward )
{
if ( bNegativeRight == true )
aActivity = (Activity)ACT_ZOMBINE_GRENADE_FLINCH_WEST;
else
aActivity = (Activity)ACT_ZOMBINE_GRENADE_FLINCH_EAST;
}
else
{
if ( bNegativeForward == true )
aActivity = (Activity)ACT_ZOMBINE_GRENADE_FLINCH_BACK;
else
aActivity = (Activity)ACT_ZOMBINE_GRENADE_FLINCH_FRONT;
}
AddGesture( aActivity );
DropGrenade( vec3_origin );
if ( IsSprinting() )
{
StopSprint();
}
else
{
Sprint();
}
}
void CSDKPlayerShared::SetSprinting( bool bSprinting )
{
//ios if ( bSprinting && !m_bIsSprinting )
if ( bSprinting && !IsSprinting())
{
StartSprinting();
// only one penalty per key press
//ios always apply this penalty as we're predicting m_bSprinting
m_flStamina -= INITIAL_SPRINT_STAMINA_PENALTY;
}
//ios else if ( !bSprinting && m_bIsSprinting )
else if ( !bSprinting && IsSprinting() )
{
StopSprinting();
}
}
void ASCharacter::OnStartFire()
{
if (IsSprinting())
{
SetSprinting(false);
}
StartWeaponFire();
}
void C_HL2MP_Player::HandleSpeedChanges( void )
{
int buttonsChanged = m_afButtonPressed | m_afButtonReleased;
if( buttonsChanged & IN_SPEED )
{
// The state of the sprint/run button has changed.
if ( IsSuitEquipped() )
{
if ( !(m_afButtonPressed & IN_SPEED) && IsSprinting() )
{
StopSprinting();
}
else if ( (m_afButtonPressed & IN_SPEED) && !IsSprinting() )
{
if ( CanSprint() )
{
StartSprinting();
}
else
{
// Reset key, so it will be activated post whatever is suppressing it.
m_nButtons &= ~IN_SPEED;
}
}
}
}
else if( buttonsChanged & IN_WALK )
{
if ( IsSuitEquipped() )
{
// The state of the WALK button has changed.
if( IsWalking() && !(m_afButtonPressed & IN_WALK) )
{
StopWalking();
}
else if( !IsWalking() && !IsSprinting() && (m_afButtonPressed & IN_WALK) && !(m_nButtons & IN_DUCK) )
{
StartWalking();
}
}
}
if ( IsSuitEquipped() && m_fIsWalking && !(m_nButtons & IN_WALK) )
StopWalking();
}
bool CNPC_Zombine::AllowedToSprint( void )
{
if ( IsOnFire() )
return false;
//If you're sprinting then there's no reason to sprint again.
if ( IsSprinting() )
return false;
int iChance = SPRINT_CHANCE_VALUE;
//Secobmod FixMe ?? also changed to HL2MPRules
CHL2_Player *pPlayer = dynamic_cast <CHL2_Player*> ( UTIL_GetNearestPlayer(GetAbsOrigin() ));
//CHL2MP_Player *pPlayer = dynamic_cast<CHL2MP_Player *>( UTIL_GetNearestPlayer(GetAbsOrigin() );
if ( pPlayer )
{
#ifdef MFS
if ( HL2MPRules()->IsAlyxInDarknessMode() && pPlayer->FlashlightIsOn() == false )
#else
if (IsAlyxInDarknessMode() && pPlayer->FlashlightIsOn() == false)
#endif
{
iChance = SPRINT_CHANCE_VALUE_DARKNESS;
}
//Bigger chance of this happening if the player is not looking at the zombie
if ( pPlayer->FInViewCone( this ) == false )
{
iChance *= 2;
}
}
if ( HasGrenade() )
{
iChance *= 4;
}
//Below 25% health they'll always sprint
if ( ( GetHealth() > GetMaxHealth() * 0.5f ) )
{
if ( IsStrategySlotRangeOccupied( SQUAD_SLOT_ZOMBINE_SPRINT1, SQUAD_SLOT_ZOMBINE_SPRINT2 ) == true )
return false;
if ( random->RandomInt( 0, 100 ) > iChance )
return false;
if ( m_flSprintRestTime > gpGlobals->curtime )
return false;
}
float flLength = ( GetEnemy()->WorldSpaceCenter() - WorldSpaceCenter() ).Length();
if ( flLength > MAX_SPRINT_DISTANCE )
return false;
return true;
}
void C_HL2MP_Player::HandleSpeedChanges( void )
{
bool bCanSprint = CanSprint();
bool bIsSprinting = IsSprinting();
bool bWantSprint = (bCanSprint && IsSuitEquipped() && (m_nButtons & IN_SPEED));
if (bIsSprinting != bWantSprint)
{
// If someone wants to sprint, make sure they've pressed the button to do so. We want to prevent the
// case where a player can hold down the sprint key and burn tiny bursts of sprint as the suit recharges
// We want a full debounce of the key to resume sprinting after the suit is completely drained
if (bWantSprint)
{
StartSprinting();
}
else
{
StopSprinting();
}
}
bool bIsWalking = IsWalking();
// have suit, pressing button, not sprinting or ducking
bool bWantWalking;
if (IsSuitEquipped())
{
bWantWalking = (m_nButtons & IN_WALK) && !IsSprinting() && !(m_nButtons & IN_DUCK);
}
else
{
bWantWalking = true;
}
if (bIsWalking != bWantWalking)
{
if (bWantWalking)
{
StartWalking();
}
else
{
StopWalking();
}
}
}
void AShooterCharacter::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
if (bWantsToRun && !IsSprinting())
{
SetSprinting(true);
}
}
void CNPC_Zombine::OnScheduleChange( void )
{
if ( HasCondition( COND_CAN_MELEE_ATTACK1 ) && IsSprinting() == true )
{
m_flSuperFastAttackTime = gpGlobals->curtime + 1.0f;
}
BaseClass::OnScheduleChange();
}
void C_HL2MP_Player::PreThink( void )
{
BaseClass::PreThink();
HandleSpeedChanges();
if ( m_HL2Local.m_flSuitPower <= 0.0f )
{
if( IsSprinting() )
{
StopSprinting();
}
}
}
void cPlayer::ApplyFoodExhaustionFromMovement()
{
if (IsGameModeCreative())
{
return;
}
// If we have just teleported, apply no exhaustion
if (m_bIsTeleporting)
{
m_bIsTeleporting = false;
return;
}
// If riding anything, apply no food exhaustion
if (m_AttachedTo != NULL)
{
return;
}
// Process exhaustion every two ticks as that is how frequently m_LastPos is updated
// Otherwise, we apply exhaustion for a 'movement' every tick, one of which is an already processed value
if (GetWorld()->GetWorldAge() % 2 != 0)
{
return;
}
// Calculate the distance travelled, update the last pos:
Vector3d Movement(GetPosition() - m_LastPos);
Movement.y = 0; // Only take XZ movement into account
// Apply the exhaustion based on distance travelled:
double BaseExhaustion = Movement.Length();
if (IsSprinting())
{
// 0.1 pt per meter sprinted
BaseExhaustion = BaseExhaustion * 0.1;
}
else if (IsSwimming())
{
// 0.015 pt per meter swum
BaseExhaustion = BaseExhaustion * 0.015;
}
else
{
// 0.01 pt per meter walked / sneaked
BaseExhaustion = BaseExhaustion * 0.01;
}
m_FoodExhaustionLevel += BaseExhaustion;
}
int CSDKPlayer::GetPlayerStance()
{
#if defined ( SDK_USE_PRONE )
if (m_Shared.IsProne() || ( m_Shared.IsGoingProne() || m_Shared.IsGettingUpFromProne() ))
return PINFO_STANCE_PRONE;
#endif
#if defined ( SDK_USE_SPRINTING )
if (IsSprinting())
return PINFO_STANCE_SPRINTING;
#endif
if (m_Local.m_bDucking)
return PINFO_STANCE_DUCKING;
else
return PINFO_STANCE_STANDING;
}
bool CSDKPlayer::CanAttack( void )
{
#if defined ( SDK_USE_SPRINTING )
#if !defined ( SDK_SHOOT_WHILE_SPRINTING )
if ( IsSprinting() )
return false;
#endif // SDK_SHOOT_WHILE_SPRINTING
#endif // SDK_USE_SPRINTING
#if !defined ( SDK_SHOOT_WHILE_JUMPING )
if ( m_Shared.IsJumping() )
return false;
#endif //SDK_SHOOT_WHILE_JUMPING
return true;
}
void ASCharacter::OnStartFire()
{
if (IsSprinting())
{
SetSprinting(false);
}
if (CarriedObjectComp->GetIsCarryingActor())
{
StopWeaponFire();
CarriedObjectComp->Throw();
return;
}
StartWeaponFire();
}
void ASCharacter::OnCrouchToggle()
{
if (IsSprinting())
{
SetSprinting(false);
}
// If we are crouching then CanCrouch will return false. If we cannot crouch then calling Crouch() wont do anything
if (CanCrouch())
{
Crouch();
}
else
{
UnCrouch();
}
}
bool CDODPlayer::CanAttack( void )
{
if ( IsSprinting() )
return false;
if ( GetMoveType() == MOVETYPE_LADDER )
return false;
if ( m_Shared.IsJumping() )
return false;
if ( m_Shared.IsDefusing() )
return false;
// cannot attack while prone moving. except if you have a bazooka
if ( m_Shared.IsProne() && GetAbsVelocity().LengthSqr() > 1 )
{
return false;
}
if( m_Shared.IsGoingProne() || m_Shared.IsGettingUpFromProne() )
{
return false;
}
CDODGameRules *rules = DODGameRules();
Assert( rules );
DODRoundState state = rules->State_Get();
if ( dod_bonusround.GetBool() )
{
if ( GetTeamNumber() == TEAM_ALLIES )
{
return ( state == STATE_RND_RUNNING || state == STATE_ALLIES_WIN );
}
else
{
return ( state == STATE_RND_RUNNING || state == STATE_AXIS_WIN );
}
}
else
return ( state == STATE_RND_RUNNING );
}
bool CBliinkPlayer::CanAttack( void )
{
#if defined ( SDK_USE_SPRINTING )
#if !defined ( SDK_SHOOT_WHILE_SPRINTING )
if ( IsSprinting() )
return false;
#endif // SDK_SHOOT_WHILE_SPRINTING
#endif // SDK_USE_SPRINTING
#if !defined ( SDK_SHOOT_ON_LADDERS )
if ( GetMoveType() == MOVETYPE_LADDER )
return false;
#endif //SDK_SHOOT_ON_LADDERS
#if !defined ( SDK_SHOOT_WHILE_JUMPING )
if ( m_Shared.IsJumping() )
return false;
#endif //SDK_SHOOT_WHILE_JUMPING
return true;
}
void ASCharacter::Tick(float DeltaTime)
{
Super::Tick(DeltaTime);
if (bWantsToRun && !IsSprinting())
{
SetSprinting(true);
}
if (Controller && Controller->IsLocalController())
{
ASUsableActor* Usable = GetUsableInView();
// End Focus
if (FocusedUsableActor != Usable)
{
if (FocusedUsableActor)
{
FocusedUsableActor->OnEndFocus();
}
bHasNewFocus = true;
}
// Assign new Focus
FocusedUsableActor = Usable;
// Start Focus.
if (Usable)
{
if (bHasNewFocus)
{
Usable->OnBeginFocus();
bHasNewFocus = false;
}
}
}
}
void CNPC_Zombine::Sprint( bool bMadSprint )
{
if ( IsSprinting() )
return;
OccupyStrategySlotRange( SQUAD_SLOT_ZOMBINE_SPRINT1, SQUAD_SLOT_ZOMBINE_SPRINT2 );
GetNavigator()->SetMovementActivity( ACT_RUN );
float flSprintTime = random->RandomFloat( MIN_SPRINT_TIME, MAX_SPRINT_TIME );
//If holding a grenade then sprint until it blows up.
if ( HasGrenade() || bMadSprint == true )
{
flSprintTime = 9999;
}
m_flSprintTime = gpGlobals->curtime + flSprintTime;
//Don't sprint for this long after I'm done with this sprint run.
m_flSprintRestTime = m_flSprintTime + random->RandomFloat( 2.5f, 5.0f );
EmitSound( "Zombine.Charge" );
}
void cPlayer::ApplyFoodExhaustionFromMovement()
{
if (IsGameModeCreative())
{
return;
}
// Calculate the distance travelled, update the last pos:
Vector3d Movement(GetPosition() - m_LastFoodPos);
Movement.y = 0; // Only take XZ movement into account
m_LastFoodPos = GetPosition();
// If riding anything, apply no food exhaustion
if (m_AttachedTo != NULL)
{
return;
}
// Apply the exhaustion based on distance travelled:
double BaseExhaustion = Movement.Length();
if (IsSprinting())
{
// 0.1 pt per meter sprinted
BaseExhaustion = BaseExhaustion * 0.1;
}
else if (IsSwimming())
{
// 0.015 pt per meter swum
BaseExhaustion = BaseExhaustion * 0.015;
}
else
{
// 0.01 pt per meter walked / sneaked
BaseExhaustion = BaseExhaustion * 0.01;
}
m_FoodExhaustionLevel += BaseExhaustion;
}
float CActorControllerComponent::GetMovementBaseSpeed(TInputFlags movementDirectionFlags) const
{
const static float walkBaseSpeed { 2.1f };
const static float jogBaseSpeed { 4.2f };
const static float runBaseSpeed { 6.3f };
const static float crawlBaseSpeed { 1.2f };
const static float proneBaseSpeed { 0.4f };
const static float crouchBaseSpeed { 1.2f };
float baseSpeed { 0.0f };
float dirScale { 1.0f };
switch (GetStance())
{
case EActorStance::eAS_Standing:
// Work out a base for walking, jogging or sprinting.
if (IsSprinting())
{
baseSpeed = runBaseSpeed;
}
else
{
if (IsJogging())
baseSpeed = jogBaseSpeed;
else
baseSpeed = walkBaseSpeed;
}
break;
case EActorStance::eAS_Crawling:
baseSpeed = crawlBaseSpeed;
break;
case EActorStance::eAS_Prone:
baseSpeed = proneBaseSpeed;
break;
case EActorStance::eAS_Crouching:
baseSpeed = crouchBaseSpeed;
break;
case EActorStance::eAS_Swimming:
baseSpeed = walkBaseSpeed;
break;
case EActorStance::eAS_Flying:
baseSpeed = jogBaseSpeed;
break;
case EActorStance::eAS_Spellcasting:
baseSpeed = walkBaseSpeed;
break;
default:
// Don't let them control movement.
baseSpeed = 0.0f;
break;
}
// Scale it based on their movement direction.
switch (movementDirectionFlags)
{
case (TInputFlags)EInputFlag::Forward:
dirScale = 1.0f;
break;
case ((TInputFlags)EInputFlag::Forward | (TInputFlags)EInputFlag::Right):
dirScale = 0.9f;
break;
case ((TInputFlags)EInputFlag::Forward | (TInputFlags)EInputFlag::Left):
dirScale = 0.9f;
break;
case (TInputFlags)EInputFlag::Right:
dirScale = 0.85f;
break;
case (TInputFlags)EInputFlag::Left:
dirScale = 0.85f;
break;
case (TInputFlags)EInputFlag::Backward:
dirScale = 0.71f;
break;
case ((TInputFlags)EInputFlag::Backward | (TInputFlags)EInputFlag::Right):
dirScale = 0.71f;
break;
case ((TInputFlags)EInputFlag::Backward | (TInputFlags)EInputFlag::Left):
dirScale = 0.71f;
break;
default:
dirScale = 0.0f;
break;
}
return baseSpeed * dirScale;
}
