//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CASW_PropJeep::EnterVehicle( CBasePlayer *pPlayer )
{
if ( !pPlayer )
return;
CheckWater();
BaseClass::EnterVehicle( pPlayer );
m_hLastPlayerInVehicle = m_hPlayer;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CPropJeep::EnterVehicle( CBasePlayer *pPlayer )
{
if ( !pPlayer )
return;
CheckWater();
BaseClass::EnterVehicle( pPlayer );
// Start looking for seagulls to land
m_hLastPlayerInVehicle = m_hPlayer;
}
void JohanCity::UpdateTime(float dt) {
clock->Start();
// Optimized version of power checking...
CheckPower(); // crawls from power plant outward...
// Optimized version of water checking...
CheckWater(); // crawls from water source outward...
// TODO: optimize?
CheckConnection();
checktilems = clock->Reset() * 1000.0f;
// Then apply tile info to buildings
CheckBuildingRequisites();
checkbuildingms = clock->Reset() * 1000.0f;
// Done checking for required items? Spend the RCI
for(int i = 0;i < tiles.size();i++) {
for(int j = 0;j < tiles[i].size();j++) {
TileType type = tiles[i][j]->type;
if(type == ttResidential || type == ttCommercial || type == ttIndustrial) {
tiles[i][j]->UpdateTime(dt);
}
// Undo checks (so they won't get invalid)?
tiles[i][j]->checkid = -1;
// tiles[i][j]->powered = false;
// tiles[i][j]->watered = false;
// tiles[i][j]->connected = false;
}
}
updatetilems = clock->Reset() * 1000.0f;
for(std::list<Building*>::iterator i = buildings.begin();i != buildings.end();i++) {
Building* building = *i;
building->UpdateTime(dt);
}
updatebuildingms = clock->Reset() * 1000.0f;
snprintf(timingreport,256,
"Check tile time: %.2f ms\r\nCheck building time: %.2f ms\r\nUpdate tile time: %.2f ms\r\nUpdate building time: %.2f ms\r\n",
checktilems,
checkbuildingms,
updatetilems,
updatebuildingms);
UpdateBuffers();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CASW_PropJeep::HandleWater( void )
{
// Only check the wheels and engine in water if we have a driver (player).
if ( !GetDriver() )
return;
// Check to see if we are in water.
if ( CheckWater() )
{
for ( int iWheel = 0; iWheel < ASW_JEEP_WHEEL_COUNT; ++iWheel )
{
// Create an entry/exit splash!
if ( m_WaterData.m_bWheelInWater[iWheel] != m_WaterData.m_bWheelWasInWater[iWheel] )
{
CreateSplash( m_WaterData.m_vecWheelContactPoints[iWheel] );
CreateRipple( m_WaterData.m_vecWheelContactPoints[iWheel] );
}
// Create ripples.
if ( m_WaterData.m_bWheelInWater[iWheel] && m_WaterData.m_bWheelWasInWater[iWheel] )
{
if ( m_WaterData.m_flNextRippleTime[iWheel] < gpGlobals->curtime )
{
// Stagger ripple times
m_WaterData.m_flNextRippleTime[iWheel] = gpGlobals->curtime + RandomFloat( 0.1, 0.3 );
CreateRipple( m_WaterData.m_vecWheelContactPoints[iWheel] );
}
}
}
}
// Save of data from last think.
for ( int iWheel = 0; iWheel < ASW_JEEP_WHEEL_COUNT; ++iWheel )
{
m_WaterData.m_bWheelWasInWater[iWheel] = m_WaterData.m_bWheelInWater[iWheel];
}
}
//-----------------------------------------------------------------------------
// Purpose:
// Input : bOnLadder -
//-----------------------------------------------------------------------------
void CHL2GameMovement::FullLadderMove()
{
#if !defined( CLIENT_DLL )
CFuncLadder *ladder = GetLadder();
Assert( ladder );
if ( !ladder )
{
return;
}
CheckWater();
// Was jump button pressed? If so, don't do anything here
if ( mv->m_nButtons & IN_JUMP )
{
CheckJumpButton();
return;
}
else
{
mv->m_nOldButtons &= ~IN_JUMP;
}
player->SetGroundEntity( NULL );
// Remember old positions in case we cancel this movement
Vector oldVelocity = mv->m_vecVelocity;
Vector oldOrigin = mv->GetAbsOrigin();
Vector topPosition;
Vector bottomPosition;
ladder->GetTopPosition( topPosition );
ladder->GetBottomPosition( bottomPosition );
// Compute parametric distance along ladder vector...
float oldt;
CalcDistanceSqrToLine( mv->GetAbsOrigin(), topPosition, bottomPosition, &oldt );
// Perform the move accounting for any base velocity.
VectorAdd (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
TryPlayerMove();
VectorSubtract (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
// Pressed buttons are "changed(xor)" and'ed with the mask of currently held buttons
int buttonsChanged = ( mv->m_nOldButtons ^ mv->m_nButtons ); // These buttons have changed this frame
int buttonsPressed = buttonsChanged & mv->m_nButtons;
bool pressed_use = ( buttonsPressed & IN_USE ) ? true : false;
bool pressing_forward_or_side = mv->m_flForwardMove != 0.0f || mv->m_flSideMove != 0.0f;
Vector ladderVec = topPosition - bottomPosition;
float LadderLength = VectorNormalize( ladderVec );
// This test is not perfect by any means, but should help a bit
bool moving_along_ladder = false;
if ( pressing_forward_or_side )
{
float fwdDot = m_vecForward.Dot( ladderVec );
if ( fabs( fwdDot ) > 0.9f )
{
moving_along_ladder = true;
}
}
// Compute parametric distance along ladder vector...
float newt;
CalcDistanceSqrToLine( mv->GetAbsOrigin(), topPosition, bottomPosition, &newt );
// Fudge of 2 units
float tolerance = 1.0f / LadderLength;
bool wouldleaveladder = false;
// Moving pPast top or bottom?
if ( newt < -tolerance )
{
wouldleaveladder = newt < oldt;
}
else if ( newt > ( 1.0f + tolerance ) )
{
wouldleaveladder = newt > oldt;
}
// See if we are near the top or bottom but not moving
float dist1sqr, dist2sqr;
dist1sqr = ( topPosition - mv->GetAbsOrigin() ).LengthSqr();
dist2sqr = ( bottomPosition - mv->GetAbsOrigin() ).LengthSqr();
float dist = MIN( dist1sqr, dist2sqr );
bool neardismountnode = ( dist < 16.0f * 16.0f ) ? true : false;
float ladderUnitsPerTick = ( MAX_CLIMB_SPEED * gpGlobals->interval_per_tick );
bool neardismountnode2 = ( dist < ladderUnitsPerTick * ladderUnitsPerTick ) ? true : false;
// Really close to node, cvar is set, and pressing a key, then simulate a +USE
bool auto_dismount_use = ( neardismountnode2 &&
sv_autoladderdismount.GetBool() &&
pressing_forward_or_side &&
!moving_along_ladder );
bool fully_underwater = ( player->GetWaterLevel() == WL_Eyes ) ? true : false;
// If the user manually pressed use or we're simulating it, then use_dismount will occur
bool use_dismount = pressed_use || auto_dismount_use;
if ( fully_underwater && !use_dismount )
{
// If fully underwater, we require looking directly at a dismount node
/// to "float off" a ladder mid way...
if ( ExitLadderViaDismountNode( ladder, true ) )
{
// See if they +used a dismount point mid-span..
return;
}
}
// If the movement would leave the ladder and they're not automated or pressing use, disallow the movement
if ( !use_dismount )
{
if ( wouldleaveladder )
{
// Don't let them leave the ladder if they were on it
mv->m_vecVelocity = oldVelocity;
mv->SetAbsOrigin( oldOrigin );
}
return;
}
// If the move would not leave the ladder and we're near close to the end, then just accept the move
if ( !wouldleaveladder && !neardismountnode )
{
// Otherwise, if the move would leave the ladder, disallow it.
if ( pressed_use )
{
if ( ExitLadderViaDismountNode( ladder, false, IsX360() ) )
{
// See if they +used a dismount point mid-span..
return;
}
player->SetMoveType( MOVETYPE_WALK );
player->SetMoveCollide( MOVECOLLIDE_DEFAULT );
SetLadder( NULL );
GetHL2Player()->m_bPlayUseDenySound = false;
// Dismount with a bit of velocity in facing direction
VectorScale( m_vecForward, USE_DISMOUNT_SPEED, mv->m_vecVelocity );
mv->m_vecVelocity.z = 50;
}
return;
}
// Debounce the use key
if ( pressed_use )
{
SwallowUseKey();
}
// Try auto exit, if possible
if ( ExitLadderViaDismountNode( ladder, false, pressed_use ) )
{
return;
}
if ( wouldleaveladder )
{
// Otherwise, if the move would leave the ladder, disallow it.
if ( pressed_use )
{
player->SetMoveType( MOVETYPE_WALK );
player->SetMoveCollide( MOVECOLLIDE_DEFAULT );
SetLadder( NULL );
// Dismount with a bit of velocity in facing direction
VectorScale( m_vecForward, USE_DISMOUNT_SPEED, mv->m_vecVelocity );
mv->m_vecVelocity.z = 50;
}
else
{
mv->m_vecVelocity = oldVelocity;
mv->SetAbsOrigin( oldOrigin );
}
}
#endif
}
void CSDKGameMovement::CategorizePosition( void )
{
// Observer.
if ( player->IsObserver() )
return;
// 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;
// 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();
// If standing on a ladder we are not on ground.
if ( player->GetMoveType() == MOVETYPE_LADDER )
{
SetGroundEntity( NULL );
return;
}
// Check for a jump.
if ( mv->m_vecVelocity.z > 250.0f )
{
SetGroundEntity( NULL );
return;
}
// Calculate the start and end position.
Vector vecStartPos = mv->GetAbsOrigin();
Vector vecEndPos( mv->GetAbsOrigin().x, mv->GetAbsOrigin().y, ( mv->GetAbsOrigin().z - 2.0f ) );
// NOTE YWB 7/5/07: Since we're already doing a traceline here, we'll subsume the StayOnGround (stair debouncing) check into the main traceline we do here to see what we're standing on
bool bUnderwater = ( player->GetWaterLevel() >= WL_Eyes );
bool bMoveToEndPos = false;
if ( player->GetMoveType() == MOVETYPE_WALK &&
player->GetGroundEntity() != NULL && !bUnderwater )
{
// if walking and still think we're on ground, we'll extend trace down by stepsize so we don't bounce down slopes
vecEndPos.z -= player->GetStepSize();
bMoveToEndPos = true;
}
trace_t trace;
TracePlayerBBox( vecStartPos, vecEndPos, PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, trace );
// Steep plane, not on ground.
if ( trace.plane.normal.z < 0.7f )
{
// Test four sub-boxes, to see if any of them would have found shallower slope we could actually stand on.
TracePlayerBBoxForGround( vecStartPos, vecEndPos, GetPlayerMins(), GetPlayerMaxs(), mv->m_nPlayerHandle.Get(), PlayerSolidMask(), COLLISION_GROUP_PLAYER_MOVEMENT, trace );
if ( trace.plane.normal[2] < 0.7f )
{
// Too steep.
SetGroundEntity( NULL );
if ( ( mv->m_vecVelocity.z > 0.0f ) &&
( player->GetMoveType() != MOVETYPE_NOCLIP ) )
{
player->m_surfaceFriction = 0.25f;
}
}
else
{
SetGroundEntity( &trace );
}
}
else
{
// YWB: This logic block essentially lifted from StayOnGround implementation
if ( bMoveToEndPos &&
!trace.startsolid && // not sure we need this check as fraction would == 0.0f?
trace.fraction > 0.0f && // must go somewhere
trace.fraction < 1.0f ) // must hit something
{
float flDelta = fabs( mv->GetAbsOrigin().z - trace.endpos.z );
// HACK HACK: The real problem is that trace returning that strange value
// we can't network over based on bit precision of networking origins
if ( flDelta > 0.5f * COORD_RESOLUTION )
{
Vector org = mv->GetAbsOrigin();
org.z = trace.endpos.z;
mv->SetAbsOrigin( org );
}
}
SetGroundEntity( &trace );
}
}
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:
// Input : &input -
//-----------------------------------------------------------------------------
void CPortalGameMovement::CategorizePosition( void )
{
Vector point;
trace_t pm;
// 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;
point[0] = mv->GetAbsOrigin()[0];
point[1] = mv->GetAbsOrigin()[1];
point[2] = mv->GetAbsOrigin()[2] - 2;
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.
if ( mv->m_vecVelocity[2] > 140 ||
( mv->m_vecVelocity[2] > 0.0f && player->GetMoveType() == MOVETYPE_LADDER ) )
{
SetGroundEntity( NULL );
}
else
{
// Try and move down.
TracePlayerBBox( bumpOrigin, point, MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm );
// If we hit a steep plane, we are not on ground
if ( 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
TracePlayerBBoxForGround2( bumpOrigin, point, GetPlayerMins(), GetPlayerMaxs(), mv->m_nPlayerHandle.Get(), MASK_PLAYERSOLID, COLLISION_GROUP_PLAYER_MOVEMENT, pm );
if ( pm.plane.normal[2] < 0.7)
{
SetGroundEntity( NULL ); // too steep
// 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
{
SetGroundEntity( &pm ); // Otherwise, point to index of ent under us.
}
}
else
{
SetGroundEntity( &pm ); // Otherwise, point to index of ent under us.
}
// If we are on something...
if (player->GetGroundEntity() != NULL)
{
// Then we are not in water jump sequence
player->m_flWaterJumpTime = 0;
// If we could make the move, drop us down that 1 pixel
if ( player->GetWaterLevel() < WL_Waist && !pm.startsolid && !pm.allsolid )
{
// check distance we would like to move -- this is supposed to just keep up
// "on the ground" surface not stap us back to earth (i.e. on move origin to
// end position when the ground is within .5 units away) (2 units)
if( pm.fraction )
// if( pm.fraction < 0.5)
{
mv->SetAbsOrigin( pm.endpos );
}
}
}
#ifndef CLIENT_DLL
//Adrian: vehicle code handles for us.
if ( player->IsInAVehicle() == false )
{
// 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::FullTossMove( void )
{
trace_t pm;
Vector move;
// add velocity if player is moving
if ( (mv->m_flForwardMove != 0.0f) || (mv->m_flSideMove != 0.0f) || (mv->m_flUpMove != 0.0f))
{
Vector forward, right, up;
float fmove, smove;
Vector wishdir, wishvel;
float wishspeed;
int i;
AngleVectors (mv->m_vecViewAngles, &forward, &right, &up); // Determine movement angles
// Copy movement amounts
fmove = mv->m_flForwardMove;
smove = mv->m_flSideMove;
VectorNormalize (forward); // Normalize remainder of vectors.
VectorNormalize (right); //
for (i=0 ; i<3 ; i++) // Determine x and y parts of velocity
wishvel[i] = forward[i]*fmove + right[i]*smove;
wishvel[2] += mv->m_flUpMove;
VectorCopy (wishvel, wishdir); // Determine maginitude of speed of move
wishspeed = VectorNormalize(wishdir);
//
// Clamp to server defined max speed
//
if (wishspeed > mv->m_flMaxSpeed)
{
VectorScale (wishvel, mv->m_flMaxSpeed/wishspeed, wishvel);
wishspeed = mv->m_flMaxSpeed;
}
// Set pmove velocity
Accelerate ( wishdir, wishspeed, sv_accelerate.GetFloat() );
}
if ( mv->m_vecVelocity[2] > 0 )
{
SetGroundEntity( NULL );
}
// If on ground and not moving, return.
if ( player->GetGroundEntity() != NULL )
{
if (VectorCompare(player->GetBaseVelocity(), vec3_origin) &&
VectorCompare(mv->m_vecVelocity, vec3_origin))
return;
}
CheckVelocity();
// add gravity
if ( player->GetMoveType() == MOVETYPE_FLYGRAVITY )
{
AddGravity();
}
// move origin
// Base velocity is not properly accounted for since this entity will move again after the bounce without
// taking it into account
VectorAdd (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
CheckVelocity();
VectorScale (mv->m_vecVelocity, gpGlobals->frametime, move);
VectorSubtract (mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity);
PushEntity( move, &pm ); // Should this clear basevelocity
CheckVelocity();
if (pm.allsolid)
{
// entity is trapped in another solid
SetGroundEntity( &pm );
mv->m_vecVelocity.Init();
return;
}
if ( pm.fraction != 1.0f )
{
PerformFlyCollisionResolution( pm, move );
}
// Check for in water
CheckWater();
}
//-----------------------------------------------------------------------------
// 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();
}
