//-----------------------------------------------------------------------------
// Purpose: Finish ducking
//-----------------------------------------------------------------------------
void CHL2GameMovement::FinishDuck(void)
{
Vector hullSizeNormal = VEC_HULL_MAX - VEC_HULL_MIN;
Vector hullSizeCrouch = VEC_DUCK_HULL_MAX - VEC_DUCK_HULL_MIN;
Vector viewDelta = 0.5f * (hullSizeNormal - hullSizeCrouch);
player->SetViewOffset(GetPlayerViewOffset(true));
player->AddFlag(FL_DUCKING);
player->m_Local.m_bDucking = false;
if (!player->m_Local.m_bDucked)
{
Vector org = mv->GetAbsOrigin();
if (player->GetGroundEntity() != NULL)
{
org -= VEC_DUCK_HULL_MIN - VEC_HULL_MIN;
}
else
{
org += viewDelta;
}
mv->SetAbsOrigin(org);
player->m_Local.m_bDucked = true;
}
// See if we are stuck?
FixPlayerCrouchStuck(true);
// Recategorize position since ducking can change origin
CategorizePosition();
}
void CBPGameMovement::FullWalkMove( )
{
if (player->GetGroundEntity() != NULL)
{
mv->m_vecVelocity[2] = 0.0;
Friction();
}
CheckVelocity();
GetBPPlayer()->m_flTurnRate = 0;
if (player->GetGroundEntity() != NULL && !(mv->m_nButtons & IN_JUMP))
{
WalkMove();
}
else
{
FlyMove();
}
engine->Con_NPrintf( 0, " L: %.2f, R: %.2f", bpmv->m_flLTrigger, bpmv->m_flRTrigger );
engine->Con_NPrintf( 1, "SL: %.2f, SR: %.2f", m_flLTriggerAvg, m_flRTriggerAvg );
// Set final flags.
CategorizePosition();
}
//-----------------------------------------------------------------------------
// Purpose: Stop ducking
//-----------------------------------------------------------------------------
void CHL2GameMovement::FinishUnDuck(void)
{
trace_t trace;
Vector newOrigin;
VectorCopy(mv->GetAbsOrigin(), newOrigin);
if (player->GetGroundEntity() != NULL)
{
newOrigin += VEC_DUCK_HULL_MIN - VEC_HULL_MIN;
}
else
{
// If in air an letting go of croush, make sure we can offset origin to make
// up for uncrouching
Vector hullSizeNormal = VEC_HULL_MAX - VEC_HULL_MIN;
Vector hullSizeCrouch = VEC_DUCK_HULL_MAX - VEC_DUCK_HULL_MIN;
Vector viewDelta = -0.5f * (hullSizeNormal - hullSizeCrouch);
VectorAdd(newOrigin, viewDelta, newOrigin);
}
player->m_Local.m_bDucked = false;
player->RemoveFlag(FL_DUCKING);
player->m_Local.m_bDucking = false;
player->SetViewOffset(GetPlayerViewOffset(false));
player->m_Local.m_flDucktime = 0;
mv->SetAbsOrigin(newOrigin);
// Recategorize position since ducking can change origin
CategorizePosition();
}
void CSDKGameMovement::FinishUnProne( void )
{
m_pSDKPlayer->m_Shared.m_flUnProneTime = 0.0f;
SetProneEyeOffset( 0.0 );
Vector vHullMin = GetPlayerMins( player->m_Local.m_bDucked );
Vector vHullMax = GetPlayerMaxs( player->m_Local.m_bDucked );
if ( m_pSDKPlayer->m_bUnProneToDuck )
{
FinishDuck();
}
else
{
CategorizePosition();
if ( mv->m_nButtons & IN_DUCK && !( player->GetFlags() & FL_DUCKING ) )
{
// Use 1 second so super long jump will work
player->m_Local.m_flDucktime = 1000;
player->m_Local.m_bDucking = true;
}
}
}
void CTFGameMovement::FullWalkMoveUnderwater()
{
if ( player->GetWaterLevel() == WL_Waist )
{
CheckWaterJump();
}
// If we are falling again, then we must not trying to jump out of water any more.
if ( ( mv->m_vecVelocity.z < 0.0f ) && player->m_flWaterJumpTime )
{
player->m_flWaterJumpTime = 0.0f;
}
// Was jump button pressed?
if ( mv->m_nButtons & IN_JUMP )
{
CheckJumpButton();
}
else
{
mv->m_nOldButtons &= ~IN_JUMP;
}
// Perform regular water movement
WaterMove();
// Redetermine position vars
CategorizePosition();
// If we are on ground, no downward velocity.
if ( player->GetGroundEntity() != NULL )
{
mv->m_vecVelocity[2] = 0;
}
}
void CASW_Drone_Movement::ProcessMovement( CAI_BaseNPC *pNPC, CMoveData *pMove, float flInterval)
{
Assert( pMove && pNPC );
m_pNPC = pNPC;
mv = pMove;
m_flInterval = flInterval;
mv->m_outWishVel.Init();
mv->m_outJumpVel.Init();
Vector start = pMove->GetAbsOrigin();
CategorizePosition();
StartGravity();
WalkMove();
FinishGravity(); // pushes him down by gravity
CategorizePosition();
}
void CSDKGameMovement::FinishProne( void )
{
m_pSDKPlayer->m_Shared.SetProne( true );
m_pSDKPlayer->m_Shared.m_flGoProneTime = 0.0f;
FinishUnDuck(); // clear ducking
SetProneEyeOffset( 1.0 );
FixPlayerCrouchStuck(true);
CategorizePosition();
}
//-----------------------------------------------------------------------------
//
//-----------------------------------------------------------------------------
void UnitBaseAirLocomotion::FullAirMove()
{
CategorizePosition();
UpdateCurrentHeight();
if( mv->upmove == 0.0f )
{
// Get Ground distance and compare to desired height. Modify up/down velocity based on it.
float fDiff = m_fDesiredHeight - m_fCurrentHeight;
if( fDiff < 0.0f )
mv->velocity.z = Max(fDiff, -mv->maxspeed);
else
mv->velocity.z = Min(fDiff, mv->maxspeed);
if( m_fFlyNoiseZ > DIST_EPSILON && mv->sidemove == 0.0f && mv->forwardmove == 0.0f )
{
if( m_bFlyNoiseUp )
{
m_fFlyCurNoise += m_fFlyNoiseRate * mv->interval;
if( m_fFlyCurNoise > m_fFlyNoiseZ )
m_bFlyNoiseUp = !m_bFlyNoiseUp;
}
else
{
m_fFlyCurNoise -= m_fFlyNoiseRate * mv->interval;
if( m_fFlyCurNoise < -m_fFlyNoiseZ )
m_bFlyNoiseUp = !m_bFlyNoiseUp;
}
mv->velocity.z += m_fFlyCurNoise;
}
}
else
{
mv->velocity.z = Min(mv->upmove, mv->maxspeed);
}
// Always air move
AirMove();
mv->stopdistance = GetStopDistance();
// If we are on ground, no downward velocity.
if( GetGroundEntity() != NULL)
mv->velocity.z = 0.0f;
}
void CMomentumGameMovement::FullWalkMove()
{
if (!CheckWater())
{
StartGravity();
}
// If we are leaping out of the water, just update the counters.
if (player->m_flWaterJumpTime)
{
WaterJump();
TryPlayerMove();
// See if we are still in water?
CheckWater();
return;
}
// If we are swimming in the water, see if we are nudging against a place we can jump up out
// of, and, if so, start out jump. Otherwise, if we are not moving up, then reset jump timer to 0
if (player->GetWaterLevel() >= WL_Waist)
{
if (player->GetWaterLevel() == WL_Waist)
{
CheckWaterJump();
}
// If we are falling again, then we must not trying to jump out of water any more.
if (mv->m_vecVelocity[2] < 0 &&
player->m_flWaterJumpTime)
{
player->m_flWaterJumpTime = 0;
}
// Was jump button pressed?
if (mv->m_nButtons & IN_JUMP)
{
CheckJumpButton();
}
else
{
mv->m_nOldButtons &= ~IN_JUMP;
}
// Perform regular water movement
WaterMove();
// Redetermine position vars
CategorizePosition();
// If we are on ground, no downward velocity.
if (player->GetGroundEntity() != NULL)
{
mv->m_vecVelocity[2] = 0;
}
}
else
// Not fully underwater
{
// Was jump button pressed?
if (mv->m_nButtons & IN_JUMP)
{
CheckJumpButton();
}
else
{
mv->m_nOldButtons &= ~IN_JUMP;
}
// Fricion is handled before we add in any base velocity. That way, if we are on a conveyor,
// we don't slow when standing still, relative to the conveyor.
if (player->GetGroundEntity() != NULL)
{
mv->m_vecVelocity[2] = 0.0;
Friction();
}
// Make sure velocity is valid.
CheckVelocity();
// By default assume we did the reflect for WalkMove()
flReflectNormal = 1.0f;
if (player->GetGroundEntity() != NULL)
{
WalkMove();
}
else
{
AirMove(); // Take into account movement when in air.
}
// Set final flags.
CategorizePosition(flReflectNormal);
// Make sure velocity is valid.
CheckVelocity();
// Add any remaining gravitational component.
if (!CheckWater())
{
FinishGravity();
}
// If we are on ground, no downward velocity.
if (player->GetGroundEntity() != NULL)
{
mv->m_vecVelocity[2] = 0;
}
CheckFalling();
}
if ((m_nOldWaterLevel == WL_NotInWater && player->GetWaterLevel() != WL_NotInWater) ||
(m_nOldWaterLevel != WL_NotInWater && player->GetWaterLevel() == WL_NotInWater))
{
PlaySwimSound();
#if !defined( CLIENT_DLL )
player->Splash();
#endif
}
}
void CMomentumGameMovement::CategorizePosition(float flReflectNormal)
{
Vector point;
trace_t pm;
// Reset this each time we-recategorize, otherwise we have bogus friction when we jump into water and plunge downward really quickly
player->m_surfaceFriction = 1.0f;
// if the player hull point one unit down is solid, the player
// is on ground
// see if standing on something solid
// Doing this before we move may introduce a potential latency in water detection, but
// doing it after can get us stuck on the bottom in water if the amount we move up
// is less than the 1 pixel 'threshold' we're about to snap to. Also, we'll call
// this several times per frame, so we really need to avoid sticking to the bottom of
// water on each call, and the converse case will correct itself if called twice.
CheckWater();
// observers don't have a ground entity
if (player->IsObserver())
return;
float flOffset = 2.0f;
point[0] = mv->GetAbsOrigin()[0];
point[1] = mv->GetAbsOrigin()[1];
point[2] = mv->GetAbsOrigin()[2] - flOffset;
Vector bumpOrigin;
bumpOrigin = mv->GetAbsOrigin();
// Shooting up really fast. Definitely not on ground.
// On ladder moving up, so not on ground either
// NOTE: 145 is a jump.
#define NON_JUMP_VELOCITY 140.0f
float zvel = mv->m_vecVelocity[2];
bool bMovingUp = zvel > 0.0f;
bool bMovingUpRapidly = zvel > NON_JUMP_VELOCITY;
float flGroundEntityVelZ = 0.0f;
if (bMovingUpRapidly)
{
// Tracker 73219, 75878: ywb 8/2/07
// After save/restore (and maybe at other times), we can get a case where we were saved on a lift and
// after restore we'll have a high local velocity due to the lift making our abs velocity appear high.
// We need to account for standing on a moving ground object in that case in order to determine if we really
// are moving away from the object we are standing on at too rapid a speed. Note that CheckJump already sets
// ground entity to NULL, so this wouldn't have any effect unless we are moving up rapidly not from the jump button.
CBaseEntity *ground = player->GetGroundEntity();
if (ground)
{
flGroundEntityVelZ = ground->GetAbsVelocity().z;
bMovingUpRapidly = (zvel - flGroundEntityVelZ) > NON_JUMP_VELOCITY;
}
}
// Was on ground, but now suddenly am not
if (bMovingUpRapidly ||
(bMovingUp && player->GetMoveType() == MOVETYPE_LADDER))
{
SetGroundEntity(NULL);
}
else
{
// Try and move down.
TryTouchGround(bumpOrigin, point, GetPlayerMins(), GetPlayerMaxs(), MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm);
// Was on ground, but now suddenly am not. If we hit a steep plane, we are not on ground
if (!pm.m_pEnt || pm.plane.normal[2] < 0.7)
{
// Test four sub-boxes, to see if any of them would have found shallower slope we could actually stand on
TryTouchGroundInQuadrants(bumpOrigin, point, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm);
if (!pm.m_pEnt || pm.plane.normal[2] < 0.7)
{
SetGroundEntity(NULL);
// probably want to add a check for a +z velocity too!
if ((mv->m_vecVelocity.z > 0.0f) &&
(player->GetMoveType() != MOVETYPE_NOCLIP))
{
player->m_surfaceFriction = 0.25f;
}
}
else
{
if ( flReflectNormal == NO_REFL_NORMAL_CHANGE)
{
DoLateReflect();
CategorizePosition(1.0f);
return;
}
SetGroundEntity(&pm);
}
}
else
{
if ( flReflectNormal == NO_REFL_NORMAL_CHANGE )
{
DoLateReflect();
CategorizePosition(1.0f);
return;
}
SetGroundEntity(&pm); // Otherwise, point to index of ent under us.
}
#ifndef CLIENT_DLL
// If our gamematerial has changed, tell any player surface triggers that are watching
IPhysicsSurfaceProps *physprops = MoveHelper()->GetSurfaceProps();
surfacedata_t *pSurfaceProp = physprops->GetSurfaceData(pm.surface.surfaceProps);
char cCurrGameMaterial = pSurfaceProp->game.material;
if (!player->GetGroundEntity())
{
cCurrGameMaterial = 0;
}
// Changed?
if (player->m_chPreviousTextureType != cCurrGameMaterial)
{
CEnvPlayerSurfaceTrigger::SetPlayerSurface(player, cCurrGameMaterial);
}
player->m_chPreviousTextureType = cCurrGameMaterial;
#endif
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFGameMovement::FullWalkMove()
{
if ( !InWater() )
{
StartGravity();
}
// If we are leaping out of the water, just update the counters.
if ( player->m_flWaterJumpTime )
{
// Try to jump out of the water (and check to see if we still are).
WaterJump();
TryPlayerMove();
CheckWater();
return;
}
// If we are swimming in the water, see if we are nudging against a place we can jump up out
// of, and, if so, start out jump. Otherwise, if we are not moving up, then reset jump timer to 0
if ( InWater() )
{
FullWalkMoveUnderwater();
return;
}
if (mv->m_nButtons & IN_JUMP)
{
CheckJumpButton();
}
else
{
mv->m_nOldButtons &= ~IN_JUMP;
}
// Make sure velocity is valid.
CheckVelocity();
if (player->GetGroundEntity() != NULL)
{
mv->m_vecVelocity[2] = 0.0;
Friction();
WalkMove();
}
else
{
AirMove();
}
// Set final flags.
CategorizePosition();
// Add any remaining gravitational component if we are not in water.
if ( !InWater() )
{
FinishGravity();
}
// If we are on ground, no downward velocity.
if ( player->GetGroundEntity() != NULL )
{
mv->m_vecVelocity[2] = 0;
}
// Handling falling.
CheckFalling();
// Make sure velocity is valid.
CheckVelocity();
}
