596 lines
17 KiB
C++
596 lines
17 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Auto Repair
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#include "cbase.h"
|
|
#include "tf_gamemovement_recon.h"
|
|
#include "tf_movedata.h"
|
|
#include "in_buttons.h"
|
|
|
|
#define TIME_WALL_SUPPRESSION_JUMP 100
|
|
#define TIME_WALL_SUPPRESSION_IMPACT 400
|
|
#define TIME_WALL_STICK 50
|
|
#define TIME_STRAFE_STICK 50
|
|
#define TIME_LEAP_STICK 300
|
|
#define TIME_WALL_ACTIVATE_JUMP 300
|
|
#define TIME_WALL_INVALID -99999
|
|
#define MAX_VERTICAL_SPEED 400
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CTFGameMovementRecon::CTFGameMovementRecon()
|
|
{
|
|
m_pReconData = NULL;
|
|
|
|
m_vStandMins = RECONCLASS_HULL_STAND_MIN;
|
|
m_vStandMaxs = RECONCLASS_HULL_STAND_MAX;
|
|
m_vStandViewOffset = RECONCLASS_VIEWOFFSET_STAND;
|
|
|
|
m_vDuckMins = RECONCLASS_HULL_DUCK_MIN;
|
|
m_vDuckMaxs = RECONCLASS_HULL_DUCK_MAX;
|
|
m_vDuckViewOffset = RECONCLASS_VIEWOFFSET_DUCK;
|
|
|
|
m_bPerformingAirMove = false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFGameMovementRecon::ProcessClassMovement( CBaseTFPlayer *pPlayer, CTFMoveData *pTFMove )
|
|
{
|
|
// Get the class specific data from the TFMoveData structure
|
|
Assert( PlayerClassReconData_t::PLAYERCLASS_ID == pTFMove->m_nClassID );
|
|
m_pReconData = &pTFMove->ReconData();
|
|
|
|
// to test pass it through!!
|
|
BaseClass::ProcessMovement( (CBasePlayer *)pPlayer, pTFMove );
|
|
|
|
// Set the jump count appropriately...
|
|
// If we've hit the ground, we can double jump again...
|
|
if ((player->GetGroundEntity() != NULL) && (pTFMove->ReconData().m_flStickTime == TIME_WALL_INVALID))
|
|
{
|
|
m_pReconData->m_nJumpCount = 0;
|
|
ResetWallImpact( (CTFMoveData*)mv );
|
|
}
|
|
}
|
|
|
|
void CTFGameMovementRecon::PostPlayerMove( void )
|
|
{
|
|
BaseClass::PostPlayerMove( );
|
|
|
|
if (m_pReconData->m_flStickTime != TIME_WALL_INVALID)
|
|
{
|
|
// We're stuck, so stick!
|
|
mv->m_vecVelocity.Init( 0.0f, 0.0f, 0.0f );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFGameMovementRecon::UpdateTimers( void )
|
|
{
|
|
BaseClass::UpdateTimers();
|
|
|
|
CTFMoveData *pTFMove = TFMove();
|
|
if ( !pTFMove )
|
|
return;
|
|
|
|
float frame_msec = 1000.0f * gpGlobals->frametime;
|
|
|
|
// Decrement the recon timers.
|
|
if ( pTFMove->ReconData().m_flSuppressionJumpTime != TIME_WALL_INVALID )
|
|
{
|
|
pTFMove->ReconData().m_flSuppressionJumpTime -= frame_msec;
|
|
if ( pTFMove->ReconData().m_flSuppressionJumpTime <= 0.0f )
|
|
{
|
|
pTFMove->ReconData().m_flSuppressionJumpTime = TIME_WALL_INVALID;
|
|
}
|
|
}
|
|
|
|
if ( pTFMove->ReconData().m_flSuppressionImpactTime != TIME_WALL_INVALID )
|
|
{
|
|
pTFMove->ReconData().m_flSuppressionImpactTime -= frame_msec;
|
|
if ( pTFMove->ReconData().m_flSuppressionImpactTime <= 0.0f )
|
|
{
|
|
pTFMove->ReconData().m_flSuppressionImpactTime = TIME_WALL_INVALID;
|
|
}
|
|
}
|
|
|
|
if ( pTFMove->ReconData().m_flActiveJumpTime != TIME_WALL_INVALID )
|
|
{
|
|
pTFMove->ReconData().m_flActiveJumpTime -= frame_msec;
|
|
if ( pTFMove->ReconData().m_flActiveJumpTime <= 0.0f )
|
|
{
|
|
pTFMove->ReconData().m_flActiveJumpTime = TIME_WALL_INVALID;
|
|
}
|
|
}
|
|
|
|
if ( pTFMove->ReconData().m_flStickTime != TIME_WALL_INVALID )
|
|
{
|
|
pTFMove->ReconData().m_flStickTime -= frame_msec;
|
|
if ( pTFMove->ReconData().m_flStickTime <= 0.0f )
|
|
{
|
|
pTFMove->ReconData().m_flStickTime = TIME_WALL_INVALID;
|
|
|
|
// Restore velocity at this time
|
|
pTFMove->m_vecVelocity = pTFMove->ReconData().m_vecUnstickVelocity;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Implement this if you want to know when the player collides during OnPlayerMove
|
|
//-----------------------------------------------------------------------------
|
|
void CTFGameMovementRecon::OnTryPlayerMoveCollision( trace_t &tr )
|
|
{
|
|
if ( !m_bPerformingAirMove )
|
|
return;
|
|
|
|
// Only keep track of world collisions
|
|
if ( tr.DidHitWorld() )
|
|
{
|
|
CTFMoveData *pTFMove = TFMove();
|
|
if ( pTFMove )
|
|
{
|
|
if ( ( pTFMove->ReconData().m_flSuppressionJumpTime == TIME_WALL_INVALID ) &&
|
|
( pTFMove->ReconData().m_flSuppressionImpactTime == TIME_WALL_INVALID ) )
|
|
{
|
|
// No walljumps off of mostly horizontal surfaces...
|
|
if ( fabs( tr.plane.normal.z ) > 0.9f )
|
|
return;
|
|
|
|
// No walljumps off of the same plane as the last one...
|
|
if ( (pTFMove->ReconData().m_flImpactDist == tr.plane.dist) &&
|
|
(VectorsAreEqual(pTFMove->ReconData().m_vecImpactNormal, tr.plane.normal, 1e-2) ) )
|
|
{
|
|
return;
|
|
}
|
|
|
|
// If you hit a wall, no double jumps for you
|
|
pTFMove->ReconData().m_nJumpCount = 2;
|
|
|
|
// Play an impact sound
|
|
MoveHelper()->StartSound( pTFMove->m_vecAbsOrigin, "Recon.WallJump" );
|
|
|
|
pTFMove->ReconData().m_vecImpactNormal = tr.plane.normal;
|
|
pTFMove->ReconData().m_flImpactDist = tr.plane.dist;
|
|
|
|
pTFMove->ReconData().m_flActiveJumpTime = TIME_WALL_ACTIVATE_JUMP;
|
|
pTFMove->ReconData().m_flSuppressionImpactTime = TIME_WALL_SUPPRESSION_IMPACT;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFGameMovementRecon::AirMove()
|
|
{
|
|
m_bPerformingAirMove = true;
|
|
|
|
// When in the air, recon travels ballistically
|
|
if ( TFMove()->ReconData().m_nJumpCount )
|
|
{
|
|
// Add in any base velocity to the current velocity.
|
|
VectorAdd( mv->m_vecVelocity, player->GetBaseVelocity(), mv->m_vecVelocity );
|
|
|
|
TryPlayerMove();
|
|
}
|
|
else
|
|
{
|
|
// But if we're falling (or coming up off ladders), treat it normally
|
|
BaseClass::AirMove();
|
|
}
|
|
|
|
m_bPerformingAirMove = false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Check the jump button to make various jumps
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFGameMovementRecon::CheckWaterJump()
|
|
{
|
|
// See if we are waterjumping. If so, decrement count and return.
|
|
if (player->m_flWaterJumpTime)
|
|
{
|
|
player->m_flWaterJumpTime -= gpGlobals->frametime;
|
|
if (player->m_flWaterJumpTime < 0)
|
|
player->m_flWaterJumpTime = 0;
|
|
|
|
return true;
|
|
}
|
|
|
|
// If we are in the water most of the way...
|
|
if ( player->GetWaterLevel() >= 2 )
|
|
{
|
|
// swimming, not jumping
|
|
SetGroundEntity( NULL );
|
|
|
|
if(player->GetWaterType() == CONTENTS_WATER) // We move up a certain amount
|
|
mv->m_vecVelocity[2] = 100;
|
|
else if (player->GetWaterType() == CONTENTS_SLIME)
|
|
mv->m_vecVelocity[2] = 80;
|
|
|
|
// play swiming sound
|
|
if ( player->m_flSwimSoundTime <= 0 )
|
|
{
|
|
// Don't play sound again for 1 second
|
|
player->m_flSwimSoundTime = 1000;
|
|
PlaySwimSound();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Resets the impact time
|
|
//-----------------------------------------------------------------------------
|
|
void CTFGameMovementRecon::ResetWallImpact( CTFMoveData *pTFMove )
|
|
{
|
|
if ( pTFMove->ReconData().m_flActiveJumpTime != TIME_WALL_INVALID )
|
|
{
|
|
pTFMove->ReconData().m_flActiveJumpTime = TIME_WALL_INVALID;
|
|
pTFMove->ReconData().m_flSuppressionImpactTime = TIME_WALL_INVALID;
|
|
pTFMove->ReconData().m_vecImpactNormal.Init( 9999, 9999, 9999 );
|
|
pTFMove->ReconData().m_flImpactDist = -9999.0f;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Check the jump button to make various jumps
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFGameMovementRecon::CheckWallJump( CTFMoveData *pTFMove )
|
|
{
|
|
if ( player->GetGroundEntity() != NULL )
|
|
return false;
|
|
|
|
if ( pTFMove->ReconData().m_flActiveJumpTime == TIME_WALL_INVALID )
|
|
return false;
|
|
|
|
// Play a jump sound
|
|
PlayStepSound( m_pSurfaceData, 1.0, true );
|
|
|
|
Vector jumpDir;
|
|
if ( ( pTFMove->m_nButtons & ( IN_MOVELEFT | IN_MOVERIGHT ) ) )
|
|
{
|
|
AngleVectors( pTFMove->m_vecViewAngles, NULL, &jumpDir, NULL );
|
|
|
|
// Apply strafe jump...
|
|
jumpDir *= ( pTFMove->m_nButtons & IN_MOVELEFT ) ? -1.0f : 1.0f;
|
|
jumpDir.z = 0.0f;
|
|
|
|
if ( pTFMove->m_nButtons & ( IN_FORWARD | IN_BACK ) )
|
|
{
|
|
Vector forward;
|
|
AngleVectors( pTFMove->m_vecViewAngles, &forward, NULL, NULL );
|
|
forward *= 0.5f;
|
|
forward *= ( pTFMove->m_nButtons & IN_BACK ) ? -1.0f : 1.0f;
|
|
forward.z = 0.0;
|
|
jumpDir += forward;
|
|
}
|
|
|
|
VectorNormalize( jumpDir );
|
|
jumpDir *= 400;
|
|
}
|
|
else
|
|
{
|
|
AngleVectors( pTFMove->m_vecViewAngles, &jumpDir, NULL, NULL );
|
|
jumpDir *= ( pTFMove->m_nButtons & IN_BACK ) ? -1.0f : 1.0f;
|
|
jumpDir.z = 0.0;
|
|
|
|
VectorNormalize( jumpDir );
|
|
jumpDir *= 400;
|
|
}
|
|
|
|
pTFMove->ReconData().m_flStickTime = TIME_WALL_STICK;
|
|
pTFMove->ReconData().m_vecUnstickVelocity.Init( jumpDir.x, jumpDir.y,
|
|
pTFMove->m_vecVelocity[2] + 1.5 * sqrt(2 * 800 * 45.0) );
|
|
if (pTFMove->ReconData().m_vecUnstickVelocity.GetZ() > MAX_VERTICAL_SPEED)
|
|
pTFMove->ReconData().m_vecUnstickVelocity.SetZ( MAX_VERTICAL_SPEED );
|
|
|
|
pTFMove->m_vecVelocity.Init( 0, 0, 0 );
|
|
|
|
// Don't allow jump into wall
|
|
float normalComponent = DotProduct( pTFMove->ReconData().m_vecUnstickVelocity, pTFMove->ReconData().m_vecImpactNormal );
|
|
if ( normalComponent < 0 )
|
|
{
|
|
Vector vUnstickVel;
|
|
VectorMA( pTFMove->ReconData().m_vecUnstickVelocity, -normalComponent,
|
|
pTFMove->ReconData().m_vecImpactNormal, vUnstickVel );
|
|
pTFMove->ReconData().m_vecUnstickVelocity = vUnstickVel;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Check the jump button to make various jumps
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFGameMovementRecon::CheckBackJump( bool bWasInAir )
|
|
{
|
|
if ((mv->m_nButtons & IN_BACK) == 0)
|
|
return false;
|
|
|
|
Vector jumpDir, right;
|
|
AngleVectors( mv->m_vecViewAngles, &jumpDir, &right, NULL );
|
|
jumpDir.z = 0.0f;
|
|
jumpDir *= -1.0f;
|
|
|
|
if (mv->m_nButtons & (IN_MOVELEFT | IN_MOVERIGHT))
|
|
{
|
|
// Apply strafe jump...
|
|
right *= (mv->m_nButtons & IN_MOVELEFT) ? -1.0f : 1.0f;
|
|
right.z = 0.0f;
|
|
|
|
// Make us not jump quite at a 45% angle if both are selected
|
|
right *= 0.5f;
|
|
jumpDir += right;
|
|
}
|
|
|
|
VectorNormalize( jumpDir );
|
|
|
|
float flGroundFactor = 1.0f;
|
|
if ((m_pSurfaceData) /*&& (!bWasInAir)*/ )
|
|
{
|
|
flGroundFactor = m_pSurfaceData->game.jumpFactor;
|
|
}
|
|
|
|
jumpDir *= 150 * flGroundFactor;
|
|
|
|
// Dampen current motion
|
|
mv->m_vecVelocity[0] *= 0.5f;
|
|
mv->m_vecVelocity[1] *= 0.5f;
|
|
|
|
float flSideFactor = (bWasInAir) ? 2.0f : 1.0f;
|
|
float flUpFactor = (bWasInAir) ? 0.5f : 1.5f;
|
|
flSideFactor *= flGroundFactor;
|
|
flUpFactor *= flGroundFactor;
|
|
|
|
mv->m_vecVelocity[0] += flSideFactor * jumpDir.x;
|
|
mv->m_vecVelocity[1] += flSideFactor * jumpDir.y;
|
|
mv->m_vecVelocity[2] += flUpFactor * sqrt(2 * 800 * 45.0);
|
|
|
|
mv->m_vecVelocity[0] = clamp( mv->m_vecVelocity[0], -200, 200 );
|
|
mv->m_vecVelocity[1] = clamp( mv->m_vecVelocity[1], -200, 200 );
|
|
if (mv->m_vecVelocity[2] > MAX_VERTICAL_SPEED)
|
|
mv->m_vecVelocity[2] = MAX_VERTICAL_SPEED;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Check the jump button to make various jumps
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFGameMovementRecon::CheckStrafeJump( bool bWasInAir )
|
|
{
|
|
if ( (mv->m_nButtons & (IN_MOVELEFT | IN_MOVERIGHT)) == 0 )
|
|
return false;
|
|
|
|
if (mv->m_nButtons & IN_FORWARD)
|
|
return false;
|
|
|
|
Vector jumpDir;
|
|
AngleVectors( mv->m_vecViewAngles, NULL, &jumpDir, NULL );
|
|
|
|
// Apply strafe jump...
|
|
jumpDir *= (mv->m_nButtons & IN_MOVELEFT) ? -1.0f : 1.0f;
|
|
jumpDir.z = 0.0f;
|
|
VectorNormalize( jumpDir );
|
|
|
|
float flGroundFactor = 1.0f;
|
|
if ((m_pSurfaceData) /*&& (!bWasInAir)*/ )
|
|
{
|
|
flGroundFactor = m_pSurfaceData->game.jumpFactor;
|
|
}
|
|
|
|
jumpDir *= 300 * flGroundFactor;
|
|
|
|
// Dampen current motion
|
|
mv->m_vecVelocity[0] *= 0.5f;
|
|
mv->m_vecVelocity[1] *= 0.5f;
|
|
mv->m_vecVelocity[0] += jumpDir.x;
|
|
mv->m_vecVelocity[1] += jumpDir.y;
|
|
|
|
if (!bWasInAir)
|
|
mv->m_vecVelocity[2] += flGroundFactor * sqrt(2 * 800 * 45.0); // 2 * gravity * height
|
|
else
|
|
mv->m_vecVelocity[2] += 0.5f * sqrt(2 * 800 * 45.0); // 2 * gravity * height
|
|
|
|
mv->m_vecVelocity[0] = clamp( mv->m_vecVelocity[0], -400, 400 );
|
|
mv->m_vecVelocity[1] = clamp( mv->m_vecVelocity[1], -400, 400 );
|
|
if (mv->m_vecVelocity[2] > MAX_VERTICAL_SPEED)
|
|
mv->m_vecVelocity[2] = MAX_VERTICAL_SPEED;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Check the jump button to make various jumps
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFGameMovementRecon::CheckForwardJump( bool bWasInAir )
|
|
{
|
|
// If we are ducking...
|
|
if ( ( player->m_Local.m_bDucking ) || ( player->GetFlags() & FL_DUCKING ) )
|
|
{
|
|
// d = 0.5 * g * t^2 - distance traveled with linear accel
|
|
// t = sqrt(2.0 * 45 / g) - how long to fall 45 units
|
|
// v = g * t - velocity at the end (just invert it to jump up that high)
|
|
// v = g * sqrt(2.0 * 45 / g )
|
|
// v^2 = g * g * 2.0 * 45 / g
|
|
// v = sqrt( g * 2.0 * 45 )
|
|
mv->m_vecVelocity[2] = sqrt(2 * 800 * 45.0); // 2 * gravity * height
|
|
}
|
|
else
|
|
{
|
|
Vector forward, right;
|
|
AngleVectors( mv->m_vecViewAngles, &forward, &right, NULL );
|
|
forward.z = 0.0;
|
|
|
|
if ((mv->m_nButtons & IN_FORWARD) == 0)
|
|
{
|
|
forward.x = forward.y = 0.0f;
|
|
}
|
|
|
|
if (mv->m_nButtons & (IN_MOVELEFT | IN_MOVERIGHT))
|
|
{
|
|
// Apply strafe jump...
|
|
right *= (mv->m_nButtons & IN_MOVELEFT) ? -1.0f : 1.0f;
|
|
right.z = 0.0f;
|
|
|
|
// Make us not jump quite at a 45% angle if both are selected
|
|
right *= 0.5f;
|
|
forward += right;
|
|
}
|
|
|
|
VectorNormalize( forward );
|
|
|
|
// Slow down by the speed factor
|
|
float flGroundFactor = 1.0f;
|
|
if ((m_pSurfaceData) /* && (!bWasInAir) */ )
|
|
{
|
|
flGroundFactor = m_pSurfaceData->game.jumpFactor;
|
|
}
|
|
|
|
forward *= 400 * flGroundFactor;
|
|
|
|
// Dampen current motion
|
|
mv->m_vecVelocity[0] *= 0.5f;
|
|
mv->m_vecVelocity[1] *= 0.5f;
|
|
mv->m_vecVelocity[0] += forward.x;
|
|
mv->m_vecVelocity[1] += forward.y;
|
|
|
|
float flUpFactor = (bWasInAir) ? 0.7f : 1.0f;
|
|
flUpFactor *= flGroundFactor;
|
|
|
|
mv->m_vecVelocity[2] += flUpFactor * MAX_VERTICAL_SPEED;
|
|
|
|
// Limit their velocity in X and Y. We don't want to just clamp because that will change the
|
|
// direction we're moving in.
|
|
for ( int i=0; i < 2; i++ )
|
|
{
|
|
float flAbs = fabs( mv->m_vecVelocity[i] );
|
|
if ( flAbs > 400 )
|
|
{
|
|
mv->m_vecVelocity[0] *= (400.0f / flAbs);
|
|
mv->m_vecVelocity[1] *= (400.0f / flAbs);
|
|
}
|
|
}
|
|
|
|
if (mv->m_vecVelocity[2] > MAX_VERTICAL_SPEED)
|
|
mv->m_vecVelocity[2] = MAX_VERTICAL_SPEED;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Check the jump button to make various jumps
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFGameMovementRecon::CheckJumpButton()
|
|
{
|
|
// FIXME: Refactor this so we don't have this complicated duplicate
|
|
// code here + in gamemovement.cpp
|
|
|
|
if ( player->pl.deadflag )
|
|
{
|
|
mv->m_nOldButtons |= IN_JUMP ; // don't jump again until released
|
|
return false;
|
|
}
|
|
|
|
// Water jumps!
|
|
if ( CheckWaterJump() )
|
|
return false;
|
|
|
|
if ( mv->m_nOldButtons & IN_JUMP )
|
|
return false; // don't pogo stick
|
|
|
|
CTFMoveData *pTFMove = static_cast<CTFMoveData*>( mv );
|
|
|
|
// Check for wall jump...
|
|
if ( !CheckWallJump( pTFMove ) )
|
|
{
|
|
// If we already did one air jump, can't do another
|
|
if ( (player->GetGroundEntity() == NULL ) && ( pTFMove->ReconData().m_nJumpCount > 1) )
|
|
{
|
|
mv->m_nOldButtons |= IN_JUMP;
|
|
return false; // in air, so no effect
|
|
}
|
|
|
|
pTFMove->ReconData().m_nJumpCount += 1;
|
|
|
|
// Am I doing a double-jump?
|
|
bool bWasInAir = (player->GetGroundEntity() == NULL);
|
|
|
|
// In the air now.
|
|
SetGroundEntity( NULL );
|
|
|
|
PlayStepSound( m_pSurfaceData, 1.0, true );
|
|
|
|
if (!CheckBackJump(bWasInAir))
|
|
{
|
|
if (CheckStrafeJump(bWasInAir))
|
|
{
|
|
// Can't double jump out of a roll....
|
|
pTFMove->ReconData().m_nJumpCount += 1;
|
|
}
|
|
else
|
|
{
|
|
CheckForwardJump(bWasInAir);
|
|
}
|
|
}
|
|
}
|
|
|
|
pTFMove->ReconData().m_flSuppressionJumpTime = TIME_WALL_SUPPRESSION_JUMP;
|
|
|
|
FinishGravity();
|
|
|
|
mv->m_outWishVel = mv->m_vecVelocity;
|
|
mv->m_outStepHeight += 0.1f;
|
|
|
|
// Flag that we jumped.
|
|
mv->m_nOldButtons |= IN_JUMP; // don't jump again until released
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const Vector &CTFGameMovementRecon::GetPlayerMins( bool bDucked ) const
|
|
{
|
|
return bDucked ? m_vDuckMins : m_vStandMins;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const Vector &CTFGameMovementRecon::GetPlayerMaxs( bool bDucked ) const
|
|
{
|
|
return bDucked ? m_vDuckMaxs : m_vStandMaxs;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const Vector &CTFGameMovementRecon::GetPlayerViewOffset( bool bDucked ) const
|
|
{
|
|
return bDucked ? m_vDuckViewOffset : m_vStandViewOffset;
|
|
}
|