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; }