1654 lines
45 KiB
C++
1654 lines
45 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Player for .
|
|
//
|
|
//===========================================================================//
|
|
|
|
#include "cbase.h"
|
|
#include "vcollide_parse.h"
|
|
#include "c_portal_player.h"
|
|
#include "view.h"
|
|
#include "c_basetempentity.h"
|
|
#include "takedamageinfo.h"
|
|
#include "in_buttons.h"
|
|
#include "iviewrender_beams.h"
|
|
#include "r_efx.h"
|
|
#include "dlight.h"
|
|
#include "PortalRender.h"
|
|
#include "toolframework/itoolframework.h"
|
|
#include "toolframework_client.h"
|
|
#include "tier1/KeyValues.h"
|
|
#include "ScreenSpaceEffects.h"
|
|
#include "portal_shareddefs.h"
|
|
#include "ivieweffects.h" // for screenshake
|
|
#include "prop_portal_shared.h"
|
|
|
|
// NVNT for fov updates
|
|
#include "haptics/ihaptics.h"
|
|
|
|
|
|
// Don't alias here
|
|
#if defined( CPortal_Player )
|
|
#undef CPortal_Player
|
|
#endif
|
|
|
|
|
|
#define REORIENTATION_RATE 120.0f
|
|
#define REORIENTATION_ACCELERATION_RATE 400.0f
|
|
|
|
#define ENABLE_PORTAL_EYE_INTERPOLATION_CODE
|
|
|
|
|
|
#define DEATH_CC_LOOKUP_FILENAME "materials/correction/cc_death.raw"
|
|
#define DEATH_CC_FADE_SPEED 0.05f
|
|
|
|
|
|
ConVar cl_reorient_in_air("cl_reorient_in_air", "1", FCVAR_ARCHIVE, "Allows the player to only reorient from being upside down while in the air." );
|
|
|
|
|
|
// -------------------------------------------------------------------------------- //
|
|
// Player animation event. Sent to the client when a player fires, jumps, reloads, etc..
|
|
// -------------------------------------------------------------------------------- //
|
|
|
|
class C_TEPlayerAnimEvent : public C_BaseTempEntity
|
|
{
|
|
public:
|
|
DECLARE_CLASS( C_TEPlayerAnimEvent, C_BaseTempEntity );
|
|
DECLARE_CLIENTCLASS();
|
|
|
|
virtual void PostDataUpdate( DataUpdateType_t updateType )
|
|
{
|
|
// Create the effect.
|
|
C_Portal_Player *pPlayer = dynamic_cast< C_Portal_Player* >( m_hPlayer.Get() );
|
|
if ( pPlayer && !pPlayer->IsDormant() )
|
|
{
|
|
pPlayer->DoAnimationEvent( (PlayerAnimEvent_t)m_iEvent.Get(), m_nData );
|
|
}
|
|
}
|
|
|
|
public:
|
|
CNetworkHandle( CBasePlayer, m_hPlayer );
|
|
CNetworkVar( int, m_iEvent );
|
|
CNetworkVar( int, m_nData );
|
|
};
|
|
|
|
IMPLEMENT_CLIENTCLASS_EVENT( C_TEPlayerAnimEvent, DT_TEPlayerAnimEvent, CTEPlayerAnimEvent );
|
|
|
|
BEGIN_RECV_TABLE_NOBASE( C_TEPlayerAnimEvent, DT_TEPlayerAnimEvent )
|
|
RecvPropEHandle( RECVINFO( m_hPlayer ) ),
|
|
RecvPropInt( RECVINFO( m_iEvent ) ),
|
|
RecvPropInt( RECVINFO( m_nData ) )
|
|
END_RECV_TABLE()
|
|
|
|
|
|
//=================================================================================
|
|
//
|
|
// Ragdoll Entity
|
|
//
|
|
class C_PortalRagdoll : public C_BaseFlex
|
|
{
|
|
public:
|
|
|
|
DECLARE_CLASS( C_PortalRagdoll, C_BaseFlex );
|
|
DECLARE_CLIENTCLASS();
|
|
|
|
C_PortalRagdoll();
|
|
~C_PortalRagdoll();
|
|
|
|
virtual void OnDataChanged( DataUpdateType_t type );
|
|
|
|
int GetPlayerEntIndex() const;
|
|
IRagdoll* GetIRagdoll() const;
|
|
|
|
virtual void SetupWeights( const matrix3x4_t *pBoneToWorld, int nFlexWeightCount, float *pFlexWeights, float *pFlexDelayedWeights );
|
|
|
|
private:
|
|
|
|
C_PortalRagdoll( const C_PortalRagdoll & ) {}
|
|
|
|
void Interp_Copy( C_BaseAnimatingOverlay *pSourceEntity );
|
|
void CreatePortalRagdoll();
|
|
|
|
private:
|
|
|
|
EHANDLE m_hPlayer;
|
|
CNetworkVector( m_vecRagdollVelocity );
|
|
CNetworkVector( m_vecRagdollOrigin );
|
|
|
|
};
|
|
|
|
IMPLEMENT_CLIENTCLASS_DT_NOBASE( C_PortalRagdoll, DT_PortalRagdoll, CPortalRagdoll )
|
|
RecvPropVector( RECVINFO(m_vecRagdollOrigin) ),
|
|
RecvPropEHandle( RECVINFO( m_hPlayer ) ),
|
|
RecvPropInt( RECVINFO( m_nModelIndex ) ),
|
|
RecvPropInt( RECVINFO(m_nForceBone) ),
|
|
RecvPropVector( RECVINFO(m_vecForce) ),
|
|
RecvPropVector( RECVINFO( m_vecRagdollVelocity ) ),
|
|
END_RECV_TABLE()
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : -
|
|
//-----------------------------------------------------------------------------
|
|
C_PortalRagdoll::C_PortalRagdoll()
|
|
{
|
|
m_hPlayer = NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : -
|
|
//-----------------------------------------------------------------------------
|
|
C_PortalRagdoll::~C_PortalRagdoll()
|
|
{
|
|
( this );
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : *pSourceEntity -
|
|
//-----------------------------------------------------------------------------
|
|
void C_PortalRagdoll::Interp_Copy( C_BaseAnimatingOverlay *pSourceEntity )
|
|
{
|
|
if ( !pSourceEntity )
|
|
return;
|
|
|
|
VarMapping_t *pSrc = pSourceEntity->GetVarMapping();
|
|
VarMapping_t *pDest = GetVarMapping();
|
|
|
|
// Find all the VarMapEntry_t's that represent the same variable.
|
|
for ( int i = 0; i < pDest->m_Entries.Count(); i++ )
|
|
{
|
|
VarMapEntry_t *pDestEntry = &pDest->m_Entries[i];
|
|
for ( int j=0; j < pSrc->m_Entries.Count(); j++ )
|
|
{
|
|
VarMapEntry_t *pSrcEntry = &pSrc->m_Entries[j];
|
|
if ( !Q_strcmp( pSrcEntry->watcher->GetDebugName(), pDestEntry->watcher->GetDebugName() ) )
|
|
{
|
|
pDestEntry->watcher->Copy( pSrcEntry->watcher );
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Setup vertex weights for drawing
|
|
//-----------------------------------------------------------------------------
|
|
void C_PortalRagdoll::SetupWeights( const matrix3x4_t *pBoneToWorld, int nFlexWeightCount, float *pFlexWeights, float *pFlexDelayedWeights )
|
|
{
|
|
// While we're dying, we want to mimic the facial animation of the player. Once they're dead, we just stay as we are.
|
|
if ( (m_hPlayer && m_hPlayer->IsAlive()) || !m_hPlayer )
|
|
{
|
|
BaseClass::SetupWeights( pBoneToWorld, nFlexWeightCount, pFlexWeights, pFlexDelayedWeights );
|
|
}
|
|
else if ( m_hPlayer )
|
|
{
|
|
m_hPlayer->SetupWeights( pBoneToWorld, nFlexWeightCount, pFlexWeights, pFlexDelayedWeights );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : -
|
|
//-----------------------------------------------------------------------------
|
|
void C_PortalRagdoll::CreatePortalRagdoll()
|
|
{
|
|
// First, initialize all our data. If we have the player's entity on our client,
|
|
// then we can make ourselves start out exactly where the player is.
|
|
C_Portal_Player *pPlayer = dynamic_cast<C_Portal_Player*>( m_hPlayer.Get() );
|
|
|
|
if ( pPlayer && !pPlayer->IsDormant() )
|
|
{
|
|
// Move my current model instance to the ragdoll's so decals are preserved.
|
|
pPlayer->SnatchModelInstance( this );
|
|
|
|
VarMapping_t *varMap = GetVarMapping();
|
|
|
|
// This is the local player, so set them in a default
|
|
// pose and slam their velocity, angles and origin
|
|
SetAbsOrigin( /* m_vecRagdollOrigin : */ pPlayer->GetRenderOrigin() );
|
|
SetAbsAngles( pPlayer->GetRenderAngles() );
|
|
SetAbsVelocity( m_vecRagdollVelocity );
|
|
|
|
// Hack! Find a neutral standing pose or use the idle.
|
|
int iSeq = LookupSequence( "ragdoll" );
|
|
if ( iSeq == -1 )
|
|
{
|
|
Assert( false );
|
|
iSeq = 0;
|
|
}
|
|
SetSequence( iSeq );
|
|
SetCycle( 0.0 );
|
|
|
|
Interp_Reset( varMap );
|
|
|
|
m_nBody = pPlayer->GetBody();
|
|
SetModelIndex( m_nModelIndex );
|
|
// Make us a ragdoll..
|
|
m_nRenderFX = kRenderFxRagdoll;
|
|
|
|
matrix3x4_t boneDelta0[MAXSTUDIOBONES];
|
|
matrix3x4_t boneDelta1[MAXSTUDIOBONES];
|
|
matrix3x4_t currentBones[MAXSTUDIOBONES];
|
|
const float boneDt = 0.05f;
|
|
|
|
pPlayer->GetRagdollInitBoneArrays( boneDelta0, boneDelta1, currentBones, boneDt );
|
|
|
|
InitAsClientRagdoll( boneDelta0, boneDelta1, currentBones, boneDt );
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : -
|
|
// Output : IRagdoll*
|
|
//-----------------------------------------------------------------------------
|
|
IRagdoll* C_PortalRagdoll::GetIRagdoll() const
|
|
{
|
|
return m_pRagdoll;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : type -
|
|
//-----------------------------------------------------------------------------
|
|
void C_PortalRagdoll::OnDataChanged( DataUpdateType_t type )
|
|
{
|
|
BaseClass::OnDataChanged( type );
|
|
|
|
if ( type == DATA_UPDATE_CREATED )
|
|
{
|
|
CreatePortalRagdoll();
|
|
}
|
|
}
|
|
|
|
|
|
LINK_ENTITY_TO_CLASS( player, C_Portal_Player );
|
|
|
|
IMPLEMENT_CLIENTCLASS_DT(C_Portal_Player, DT_Portal_Player, CPortal_Player)
|
|
RecvPropFloat( RECVINFO( m_angEyeAngles[0] ) ),
|
|
RecvPropFloat( RECVINFO( m_angEyeAngles[1] ) ),
|
|
RecvPropEHandle( RECVINFO( m_hRagdoll ) ),
|
|
RecvPropInt( RECVINFO( m_iSpawnInterpCounter ) ),
|
|
RecvPropInt( RECVINFO( m_iPlayerSoundType ) ),
|
|
RecvPropBool( RECVINFO( m_bHeldObjectOnOppositeSideOfPortal ) ),
|
|
RecvPropEHandle( RECVINFO( m_pHeldObjectPortal ) ),
|
|
RecvPropBool( RECVINFO( m_bPitchReorientation ) ),
|
|
RecvPropEHandle( RECVINFO( m_hPortalEnvironment ) ),
|
|
RecvPropEHandle( RECVINFO( m_hSurroundingLiquidPortal ) ),
|
|
RecvPropBool( RECVINFO( m_bSuppressingCrosshair ) ),
|
|
END_RECV_TABLE()
|
|
|
|
|
|
BEGIN_PREDICTION_DATA( C_Portal_Player )
|
|
END_PREDICTION_DATA()
|
|
|
|
#define _WALK_SPEED 150
|
|
#define _NORM_SPEED 190
|
|
#define _SPRINT_SPEED 320
|
|
|
|
static ConVar cl_playermodel( "cl_playermodel", "none", FCVAR_USERINFO | FCVAR_ARCHIVE | FCVAR_SERVER_CAN_EXECUTE, "Default Player Model");
|
|
|
|
extern bool g_bUpsideDown;
|
|
|
|
//EHANDLE g_eKillTarget1;
|
|
//EHANDLE g_eKillTarget2;
|
|
|
|
void SpawnBlood (Vector vecSpot, const Vector &vecDir, int bloodColor, float flDamage);
|
|
|
|
C_Portal_Player::C_Portal_Player()
|
|
: m_iv_angEyeAngles( "C_Portal_Player::m_iv_angEyeAngles" )
|
|
{
|
|
m_PlayerAnimState = CreatePortalPlayerAnimState( this );
|
|
|
|
m_iIDEntIndex = 0;
|
|
m_iSpawnInterpCounterCache = 0;
|
|
m_flDeathCCWeight = 0.0f;
|
|
|
|
m_hRagdoll.Set( NULL );
|
|
m_flStartLookTime = 0.0f;
|
|
|
|
m_bHeldObjectOnOppositeSideOfPortal = false;
|
|
m_pHeldObjectPortal = 0;
|
|
|
|
m_bPitchReorientation = false;
|
|
m_fReorientationRate = 0.0f;
|
|
|
|
m_angEyeAngles.Init();
|
|
|
|
AddVar( &m_angEyeAngles, &m_iv_angEyeAngles, LATCH_SIMULATION_VAR );
|
|
|
|
m_EntClientFlags |= ENTCLIENTFLAG_DONTUSEIK;
|
|
m_blinkTimer.Invalidate();
|
|
|
|
m_CCDeathHandle = INVALID_CLIENT_CCHANDLE;
|
|
}
|
|
|
|
C_Portal_Player::~C_Portal_Player( void )
|
|
{
|
|
if ( m_PlayerAnimState )
|
|
{
|
|
m_PlayerAnimState->Release();
|
|
}
|
|
|
|
g_pColorCorrectionMgr->RemoveColorCorrection( m_CCDeathHandle );
|
|
}
|
|
|
|
int C_Portal_Player::GetIDTarget() const
|
|
{
|
|
return m_iIDEntIndex;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Update this client's target entity
|
|
//-----------------------------------------------------------------------------
|
|
void C_Portal_Player::UpdateIDTarget()
|
|
{
|
|
if ( !IsLocalPlayer() )
|
|
return;
|
|
|
|
// Clear old target and find a new one
|
|
m_iIDEntIndex = 0;
|
|
|
|
// don't show IDs in chase spec mode
|
|
if ( GetObserverMode() == OBS_MODE_CHASE ||
|
|
GetObserverMode() == OBS_MODE_DEATHCAM )
|
|
return;
|
|
|
|
trace_t tr;
|
|
Vector vecStart, vecEnd;
|
|
VectorMA( MainViewOrigin(), 1500, MainViewForward(), vecEnd );
|
|
VectorMA( MainViewOrigin(), 10, MainViewForward(), vecStart );
|
|
UTIL_TraceLine( vecStart, vecEnd, MASK_SOLID, this, COLLISION_GROUP_NONE, &tr );
|
|
|
|
if ( !tr.startsolid && tr.DidHitNonWorldEntity() )
|
|
{
|
|
C_BaseEntity *pEntity = tr.m_pEnt;
|
|
|
|
if ( pEntity && (pEntity != this) )
|
|
{
|
|
m_iIDEntIndex = pEntity->entindex();
|
|
}
|
|
}
|
|
}
|
|
|
|
void C_Portal_Player::TraceAttack( const CTakeDamageInfo &info, const Vector &vecDir, trace_t *ptr )
|
|
{
|
|
Vector vecOrigin = ptr->endpos - vecDir * 4;
|
|
|
|
float flDistance = 0.0f;
|
|
|
|
if ( info.GetAttacker() )
|
|
{
|
|
flDistance = (ptr->endpos - info.GetAttacker()->GetAbsOrigin()).Length();
|
|
}
|
|
|
|
if ( m_takedamage )
|
|
{
|
|
AddMultiDamage( info, this );
|
|
|
|
int blood = BloodColor();
|
|
|
|
if ( blood != DONT_BLEED )
|
|
{
|
|
SpawnBlood( vecOrigin, vecDir, blood, flDistance );// a little surface blood.
|
|
TraceBleed( flDistance, vecDir, ptr, info.GetDamageType() );
|
|
}
|
|
}
|
|
}
|
|
|
|
void C_Portal_Player::Initialize( void )
|
|
{
|
|
m_headYawPoseParam = LookupPoseParameter( "head_yaw" );
|
|
GetPoseParameterRange( m_headYawPoseParam, m_headYawMin, m_headYawMax );
|
|
|
|
m_headPitchPoseParam = LookupPoseParameter( "head_pitch" );
|
|
GetPoseParameterRange( m_headPitchPoseParam, m_headPitchMin, m_headPitchMax );
|
|
|
|
CStudioHdr *hdr = GetModelPtr();
|
|
for ( int i = 0; i < hdr->GetNumPoseParameters() ; i++ )
|
|
{
|
|
SetPoseParameter( hdr, i, 0.0 );
|
|
}
|
|
}
|
|
|
|
CStudioHdr *C_Portal_Player::OnNewModel( void )
|
|
{
|
|
CStudioHdr *hdr = BaseClass::OnNewModel();
|
|
|
|
Initialize( );
|
|
|
|
return hdr;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
* Orient head and eyes towards m_lookAt.
|
|
*/
|
|
void C_Portal_Player::UpdateLookAt( void )
|
|
{
|
|
// head yaw
|
|
if (m_headYawPoseParam < 0 || m_headPitchPoseParam < 0)
|
|
return;
|
|
|
|
// This is buggy with dt 0, just skip since there is no work to do.
|
|
if ( gpGlobals->frametime <= 0.0f )
|
|
return;
|
|
|
|
// Player looks at themselves through portals. Pick the portal we're turned towards.
|
|
const int iPortalCount = CProp_Portal_Shared::AllPortals.Count();
|
|
CProp_Portal **pPortals = CProp_Portal_Shared::AllPortals.Base();
|
|
float *fPortalDot = (float *)stackalloc( sizeof( float ) * iPortalCount );
|
|
float flLowDot = 1.0f;
|
|
int iUsePortal = -1;
|
|
|
|
// defaults if no portals are around
|
|
Vector vPlayerForward;
|
|
GetVectors( &vPlayerForward, NULL, NULL );
|
|
Vector vCurLookTarget = EyePosition();
|
|
|
|
if ( !IsAlive() )
|
|
{
|
|
m_viewtarget = EyePosition() + vPlayerForward*10.0f;
|
|
return;
|
|
}
|
|
|
|
bool bNewTarget = false;
|
|
if ( UTIL_IntersectEntityExtentsWithPortal( this ) != NULL )
|
|
{
|
|
// player is in a portal
|
|
vCurLookTarget = EyePosition() + vPlayerForward*10.0f;
|
|
}
|
|
else if ( pPortals && pPortals[0] )
|
|
{
|
|
// Test through any active portals: This may be a shorter distance to the target
|
|
for( int i = 0; i != iPortalCount; ++i )
|
|
{
|
|
CProp_Portal *pTempPortal = pPortals[i];
|
|
|
|
if( pTempPortal && pTempPortal->m_bActivated && pTempPortal->m_hLinkedPortal.Get() )
|
|
{
|
|
Vector vEyeForward, vPortalForward;
|
|
EyeVectors( &vEyeForward );
|
|
pTempPortal->GetVectors( &vPortalForward, NULL, NULL );
|
|
fPortalDot[i] = vEyeForward.Dot( vPortalForward );
|
|
if ( fPortalDot[i] < flLowDot )
|
|
{
|
|
flLowDot = fPortalDot[i];
|
|
iUsePortal = i;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( iUsePortal >= 0 )
|
|
{
|
|
C_Prop_Portal* pPortal = pPortals[iUsePortal];
|
|
if ( pPortal )
|
|
{
|
|
vCurLookTarget = pPortal->MatrixThisToLinked()*vCurLookTarget;
|
|
if ( vCurLookTarget != m_vLookAtTarget )
|
|
{
|
|
bNewTarget = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No other look targets, look straight ahead
|
|
vCurLookTarget += vPlayerForward*10.0f;
|
|
}
|
|
|
|
// Figure out where we want to look in world space.
|
|
QAngle desiredAngles;
|
|
Vector to = vCurLookTarget - EyePosition();
|
|
VectorAngles( to, desiredAngles );
|
|
QAngle aheadAngles;
|
|
VectorAngles( vCurLookTarget, aheadAngles );
|
|
|
|
// Figure out where our body is facing in world space.
|
|
QAngle bodyAngles( 0, 0, 0 );
|
|
bodyAngles[YAW] = GetLocalAngles()[YAW];
|
|
|
|
m_flLastBodyYaw = bodyAngles[YAW];
|
|
|
|
// Set the head's yaw.
|
|
float desiredYaw = AngleNormalize( desiredAngles[YAW] - bodyAngles[YAW] );
|
|
desiredYaw = clamp( desiredYaw, m_headYawMin, m_headYawMax );
|
|
|
|
float desiredPitch = AngleNormalize( desiredAngles[PITCH] );
|
|
desiredPitch = clamp( desiredPitch, m_headPitchMin, m_headPitchMax );
|
|
|
|
if ( bNewTarget )
|
|
{
|
|
m_flStartLookTime = gpGlobals->curtime;
|
|
}
|
|
|
|
float dt = (gpGlobals->frametime);
|
|
float flSpeed = 1.0f - ExponentialDecay( 0.7f, 0.033f, dt );
|
|
|
|
m_flCurrentHeadYaw = m_flCurrentHeadYaw + flSpeed * ( desiredYaw - m_flCurrentHeadYaw );
|
|
m_flCurrentHeadYaw = AngleNormalize( m_flCurrentHeadYaw );
|
|
SetPoseParameter( m_headYawPoseParam, m_flCurrentHeadYaw );
|
|
|
|
m_flCurrentHeadPitch = m_flCurrentHeadPitch + flSpeed * ( desiredPitch - m_flCurrentHeadPitch );
|
|
m_flCurrentHeadPitch = AngleNormalize( m_flCurrentHeadPitch );
|
|
SetPoseParameter( m_headPitchPoseParam, m_flCurrentHeadPitch );
|
|
|
|
// This orients the eyes
|
|
m_viewtarget = m_vLookAtTarget = vCurLookTarget;
|
|
}
|
|
|
|
void C_Portal_Player::ClientThink( void )
|
|
{
|
|
//PortalEyeInterpolation.m_bNeedToUpdateEyePosition = true;
|
|
|
|
Vector vForward;
|
|
AngleVectors( GetLocalAngles(), &vForward );
|
|
|
|
// Allow sprinting
|
|
HandleSpeedChanges();
|
|
|
|
FixTeleportationRoll();
|
|
|
|
//QAngle vAbsAngles = EyeAngles();
|
|
|
|
// Look at the thing that killed you
|
|
//if ( !IsAlive() )
|
|
//{
|
|
// C_BaseEntity *pEntity1 = g_eKillTarget1.Get();
|
|
// C_BaseEntity *pEntity2 = g_eKillTarget2.Get();
|
|
|
|
// if ( pEntity2 && pEntity1 )
|
|
// {
|
|
// //engine->GetViewAngles( vAbsAngles );
|
|
|
|
// Vector vLook = pEntity1->GetAbsOrigin() - pEntity2->GetAbsOrigin();
|
|
// VectorNormalize( vLook );
|
|
|
|
// QAngle qLook;
|
|
// VectorAngles( vLook, qLook );
|
|
|
|
// if ( qLook[PITCH] > 180.0f )
|
|
// {
|
|
// qLook[PITCH] -= 360.0f;
|
|
// }
|
|
|
|
// if ( vAbsAngles[YAW] < 0.0f )
|
|
// {
|
|
// vAbsAngles[YAW] += 360.0f;
|
|
// }
|
|
|
|
// if ( vAbsAngles[PITCH] < qLook[PITCH] )
|
|
// {
|
|
// vAbsAngles[PITCH] += gpGlobals->frametime * 120.0f;
|
|
// if ( vAbsAngles[PITCH] > qLook[PITCH] )
|
|
// vAbsAngles[PITCH] = qLook[PITCH];
|
|
// }
|
|
// else if ( vAbsAngles[PITCH] > qLook[PITCH] )
|
|
// {
|
|
// vAbsAngles[PITCH] -= gpGlobals->frametime * 120.0f;
|
|
// if ( vAbsAngles[PITCH] < qLook[PITCH] )
|
|
// vAbsAngles[PITCH] = qLook[PITCH];
|
|
// }
|
|
|
|
// if ( vAbsAngles[YAW] < qLook[YAW] )
|
|
// {
|
|
// vAbsAngles[YAW] += gpGlobals->frametime * 240.0f;
|
|
// if ( vAbsAngles[YAW] > qLook[YAW] )
|
|
// vAbsAngles[YAW] = qLook[YAW];
|
|
// }
|
|
// else if ( vAbsAngles[YAW] > qLook[YAW] )
|
|
// {
|
|
// vAbsAngles[YAW] -= gpGlobals->frametime * 240.0f;
|
|
// if ( vAbsAngles[YAW] < qLook[YAW] )
|
|
// vAbsAngles[YAW] = qLook[YAW];
|
|
// }
|
|
|
|
// if ( vAbsAngles[YAW] > 180.0f )
|
|
// {
|
|
// vAbsAngles[YAW] -= 360.0f;
|
|
// }
|
|
|
|
// engine->SetViewAngles( vAbsAngles );
|
|
// }
|
|
//}
|
|
|
|
// If dead, fade in death CC lookup
|
|
if ( m_CCDeathHandle != INVALID_CLIENT_CCHANDLE )
|
|
{
|
|
if ( m_lifeState != LIFE_ALIVE )
|
|
{
|
|
if ( m_flDeathCCWeight < 1.0f )
|
|
{
|
|
m_flDeathCCWeight += DEATH_CC_FADE_SPEED;
|
|
clamp( m_flDeathCCWeight, 0.0f, 1.0f );
|
|
}
|
|
}
|
|
else
|
|
{
|
|
m_flDeathCCWeight = 0.0f;
|
|
}
|
|
g_pColorCorrectionMgr->SetColorCorrectionWeight( m_CCDeathHandle, m_flDeathCCWeight );
|
|
}
|
|
|
|
UpdateIDTarget();
|
|
}
|
|
|
|
void C_Portal_Player::FixTeleportationRoll( void )
|
|
{
|
|
if( IsInAVehicle() ) //HL2 compatibility fix. do absolutely nothing to the view in vehicles
|
|
return;
|
|
|
|
if( !IsLocalPlayer() )
|
|
return;
|
|
|
|
// Normalize roll from odd portal transitions
|
|
QAngle vAbsAngles = EyeAngles();
|
|
|
|
|
|
Vector vCurrentForward, vCurrentRight, vCurrentUp;
|
|
AngleVectors( vAbsAngles, &vCurrentForward, &vCurrentRight, &vCurrentUp );
|
|
|
|
if ( vAbsAngles[ROLL] == 0.0f )
|
|
{
|
|
m_fReorientationRate = 0.0f;
|
|
g_bUpsideDown = ( vCurrentUp.z < 0.0f );
|
|
return;
|
|
}
|
|
|
|
bool bForcePitchReorient = ( vAbsAngles[ROLL] > 175.0f && vCurrentForward.z > 0.99f );
|
|
bool bOnGround = ( GetGroundEntity() != NULL );
|
|
|
|
if ( bForcePitchReorient )
|
|
{
|
|
m_fReorientationRate = REORIENTATION_RATE * ( ( bOnGround ) ? ( 2.0f ) : ( 1.0f ) );
|
|
}
|
|
else
|
|
{
|
|
// Don't reorient in air if they don't want to
|
|
if ( !cl_reorient_in_air.GetBool() && !bOnGround )
|
|
{
|
|
g_bUpsideDown = ( vCurrentUp.z < 0.0f );
|
|
return;
|
|
}
|
|
}
|
|
|
|
if ( vCurrentUp.z < 0.75f )
|
|
{
|
|
m_fReorientationRate += gpGlobals->frametime * REORIENTATION_ACCELERATION_RATE;
|
|
|
|
// Upright faster if on the ground
|
|
float fMaxReorientationRate = REORIENTATION_RATE * ( ( bOnGround ) ? ( 2.0f ) : ( 1.0f ) );
|
|
if ( m_fReorientationRate > fMaxReorientationRate )
|
|
m_fReorientationRate = fMaxReorientationRate;
|
|
}
|
|
else
|
|
{
|
|
if ( m_fReorientationRate > REORIENTATION_RATE * 0.5f )
|
|
{
|
|
m_fReorientationRate -= gpGlobals->frametime * REORIENTATION_ACCELERATION_RATE;
|
|
if ( m_fReorientationRate < REORIENTATION_RATE * 0.5f )
|
|
m_fReorientationRate = REORIENTATION_RATE * 0.5f;
|
|
}
|
|
else if ( m_fReorientationRate < REORIENTATION_RATE * 0.5f )
|
|
{
|
|
m_fReorientationRate += gpGlobals->frametime * REORIENTATION_ACCELERATION_RATE;
|
|
if ( m_fReorientationRate > REORIENTATION_RATE * 0.5f )
|
|
m_fReorientationRate = REORIENTATION_RATE * 0.5f;
|
|
}
|
|
}
|
|
|
|
if ( !m_bPitchReorientation && !bForcePitchReorient )
|
|
{
|
|
// Randomize which way we roll if we're completely upside down
|
|
if ( vAbsAngles[ROLL] == 180.0f && RandomInt( 0, 1 ) == 1 )
|
|
{
|
|
vAbsAngles[ROLL] = -180.0f;
|
|
}
|
|
|
|
if ( vAbsAngles[ROLL] < 0.0f )
|
|
{
|
|
vAbsAngles[ROLL] += gpGlobals->frametime * m_fReorientationRate;
|
|
if ( vAbsAngles[ROLL] > 0.0f )
|
|
vAbsAngles[ROLL] = 0.0f;
|
|
engine->SetViewAngles( vAbsAngles );
|
|
}
|
|
else if ( vAbsAngles[ROLL] > 0.0f )
|
|
{
|
|
vAbsAngles[ROLL] -= gpGlobals->frametime * m_fReorientationRate;
|
|
if ( vAbsAngles[ROLL] < 0.0f )
|
|
vAbsAngles[ROLL] = 0.0f;
|
|
engine->SetViewAngles( vAbsAngles );
|
|
m_angEyeAngles = vAbsAngles;
|
|
m_iv_angEyeAngles.Reset();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if ( vAbsAngles[ROLL] != 0.0f )
|
|
{
|
|
if ( vCurrentUp.z < 0.2f )
|
|
{
|
|
float fDegrees = gpGlobals->frametime * m_fReorientationRate;
|
|
if ( vCurrentForward.z > 0.0f )
|
|
{
|
|
fDegrees = -fDegrees;
|
|
}
|
|
|
|
// Rotate around the right axis
|
|
VMatrix mAxisAngleRot = SetupMatrixAxisRot( vCurrentRight, fDegrees );
|
|
|
|
vCurrentUp = mAxisAngleRot.VMul3x3( vCurrentUp );
|
|
vCurrentForward = mAxisAngleRot.VMul3x3( vCurrentForward );
|
|
|
|
VectorAngles( vCurrentForward, vCurrentUp, vAbsAngles );
|
|
|
|
engine->SetViewAngles( vAbsAngles );
|
|
m_angEyeAngles = vAbsAngles;
|
|
m_iv_angEyeAngles.Reset();
|
|
}
|
|
else
|
|
{
|
|
if ( vAbsAngles[ROLL] < 0.0f )
|
|
{
|
|
vAbsAngles[ROLL] += gpGlobals->frametime * m_fReorientationRate;
|
|
if ( vAbsAngles[ROLL] > 0.0f )
|
|
vAbsAngles[ROLL] = 0.0f;
|
|
engine->SetViewAngles( vAbsAngles );
|
|
m_angEyeAngles = vAbsAngles;
|
|
m_iv_angEyeAngles.Reset();
|
|
}
|
|
else if ( vAbsAngles[ROLL] > 0.0f )
|
|
{
|
|
vAbsAngles[ROLL] -= gpGlobals->frametime * m_fReorientationRate;
|
|
if ( vAbsAngles[ROLL] < 0.0f )
|
|
vAbsAngles[ROLL] = 0.0f;
|
|
engine->SetViewAngles( vAbsAngles );
|
|
m_angEyeAngles = vAbsAngles;
|
|
m_iv_angEyeAngles.Reset();
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// Keep track of if we're upside down for look control
|
|
vAbsAngles = EyeAngles();
|
|
AngleVectors( vAbsAngles, NULL, NULL, &vCurrentUp );
|
|
|
|
if ( bForcePitchReorient )
|
|
g_bUpsideDown = ( vCurrentUp.z < 0.0f );
|
|
else
|
|
g_bUpsideDown = false;
|
|
}
|
|
|
|
const QAngle& C_Portal_Player::GetRenderAngles()
|
|
{
|
|
if ( IsRagdoll() )
|
|
{
|
|
return vec3_angle;
|
|
}
|
|
else
|
|
{
|
|
return m_PlayerAnimState->GetRenderAngles();
|
|
}
|
|
}
|
|
|
|
void C_Portal_Player::UpdateClientSideAnimation( void )
|
|
{
|
|
UpdateLookAt();
|
|
|
|
// Update the animation data. It does the local check here so this works when using
|
|
// a third-person camera (and we don't have valid player angles).
|
|
if ( this == C_Portal_Player::GetLocalPortalPlayer() )
|
|
m_PlayerAnimState->Update( EyeAngles()[YAW], m_angEyeAngles[PITCH] );
|
|
else
|
|
m_PlayerAnimState->Update( m_angEyeAngles[YAW], m_angEyeAngles[PITCH] );
|
|
|
|
BaseClass::UpdateClientSideAnimation();
|
|
}
|
|
|
|
void C_Portal_Player::DoAnimationEvent( PlayerAnimEvent_t event, int nData )
|
|
{
|
|
m_PlayerAnimState->DoAnimationEvent( event, nData );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int C_Portal_Player::DrawModel( int flags )
|
|
{
|
|
if ( !m_bReadyToDraw )
|
|
return 0;
|
|
|
|
if( IsLocalPlayer() )
|
|
{
|
|
if ( !C_BasePlayer::ShouldDrawThisPlayer() )
|
|
{
|
|
if ( !g_pPortalRender->IsRenderingPortal() )
|
|
return 0;
|
|
|
|
if( (g_pPortalRender->GetViewRecursionLevel() == 1) && (m_iForceNoDrawInPortalSurface != -1) ) //CPortalRender::s_iRenderingPortalView )
|
|
return 0;
|
|
}
|
|
}
|
|
|
|
return BaseClass::DrawModel(flags);
|
|
}
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Should this object receive shadows?
|
|
//-----------------------------------------------------------------------------
|
|
bool C_Portal_Player::ShouldReceiveProjectedTextures( int flags )
|
|
{
|
|
Assert( flags & SHADOW_FLAGS_PROJECTED_TEXTURE_TYPE_MASK );
|
|
|
|
if ( IsEffectActive( EF_NODRAW ) )
|
|
return false;
|
|
|
|
if( flags & SHADOW_FLAGS_FLASHLIGHT )
|
|
{
|
|
return true;
|
|
}
|
|
|
|
return BaseClass::ShouldReceiveProjectedTextures( flags );
|
|
}
|
|
|
|
void C_Portal_Player::DoImpactEffect( trace_t &tr, int nDamageType )
|
|
{
|
|
if ( GetActiveWeapon() )
|
|
{
|
|
GetActiveWeapon()->DoImpactEffect( tr, nDamageType );
|
|
return;
|
|
}
|
|
|
|
BaseClass::DoImpactEffect( tr, nDamageType );
|
|
}
|
|
|
|
void C_Portal_Player::PreThink( void )
|
|
{
|
|
QAngle vTempAngles = GetLocalAngles();
|
|
|
|
if ( IsLocalPlayer() )
|
|
{
|
|
vTempAngles[PITCH] = EyeAngles()[PITCH];
|
|
}
|
|
else
|
|
{
|
|
vTempAngles[PITCH] = m_angEyeAngles[PITCH];
|
|
}
|
|
|
|
if ( vTempAngles[YAW] < 0.0f )
|
|
{
|
|
vTempAngles[YAW] += 360.0f;
|
|
}
|
|
|
|
SetLocalAngles( vTempAngles );
|
|
|
|
BaseClass::PreThink();
|
|
|
|
HandleSpeedChanges();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void C_Portal_Player::AddEntity( void )
|
|
{
|
|
BaseClass::AddEntity();
|
|
|
|
QAngle vTempAngles = GetLocalAngles();
|
|
vTempAngles[PITCH] = m_angEyeAngles[PITCH];
|
|
|
|
SetLocalAngles( vTempAngles );
|
|
|
|
// Zero out model pitch, blending takes care of all of it.
|
|
SetLocalAnglesDim( X_INDEX, 0 );
|
|
|
|
if( this != C_BasePlayer::GetLocalPlayer() )
|
|
{
|
|
if ( IsEffectActive( EF_DIMLIGHT ) )
|
|
{
|
|
int iAttachment = LookupAttachment( "anim_attachment_RH" );
|
|
|
|
if ( iAttachment < 0 )
|
|
return;
|
|
|
|
Vector vecOrigin;
|
|
QAngle eyeAngles = m_angEyeAngles;
|
|
|
|
GetAttachment( iAttachment, vecOrigin, eyeAngles );
|
|
|
|
Vector vForward;
|
|
AngleVectors( eyeAngles, &vForward );
|
|
|
|
trace_t tr;
|
|
UTIL_TraceLine( vecOrigin, vecOrigin + (vForward * 200), MASK_SHOT, this, COLLISION_GROUP_NONE, &tr );
|
|
}
|
|
}
|
|
}
|
|
|
|
ShadowType_t C_Portal_Player::ShadowCastType( void )
|
|
{
|
|
// Drawing player shadows looks bad in first person when they get close to walls
|
|
// It doesn't make sense to have shadows in the portal view, but not in the main view
|
|
// So no shadows for the player
|
|
return SHADOWS_NONE;
|
|
}
|
|
|
|
bool C_Portal_Player::ShouldDraw( void )
|
|
{
|
|
if ( !IsAlive() )
|
|
return false;
|
|
|
|
//return true;
|
|
|
|
// if( GetTeamNumber() == TEAM_SPECTATOR )
|
|
// return false;
|
|
|
|
if( IsLocalPlayer() && IsRagdoll() )
|
|
return true;
|
|
|
|
if ( IsRagdoll() )
|
|
return false;
|
|
|
|
return true;
|
|
|
|
return BaseClass::ShouldDraw();
|
|
}
|
|
|
|
const QAngle& C_Portal_Player::EyeAngles()
|
|
{
|
|
if ( IsLocalPlayer() && g_nKillCamMode == OBS_MODE_NONE )
|
|
{
|
|
return BaseClass::EyeAngles();
|
|
}
|
|
else
|
|
{
|
|
//C_BaseEntity *pEntity1 = g_eKillTarget1.Get();
|
|
//C_BaseEntity *pEntity2 = g_eKillTarget2.Get();
|
|
|
|
//Vector vLook = Vector( 0.0f, 0.0f, 0.0f );
|
|
|
|
//if ( pEntity2 )
|
|
//{
|
|
// vLook = pEntity1->GetAbsOrigin() - pEntity2->GetAbsOrigin();
|
|
// VectorNormalize( vLook );
|
|
//}
|
|
//else if ( pEntity1 )
|
|
//{
|
|
// return BaseClass::EyeAngles();
|
|
// //vLook = - pEntity1->GetAbsOrigin();
|
|
//}
|
|
|
|
//if ( vLook != Vector( 0.0f, 0.0f, 0.0f ) )
|
|
//{
|
|
// VectorAngles( vLook, m_angEyeAngles );
|
|
//}
|
|
|
|
return m_angEyeAngles;
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Input : -
|
|
// Output : IRagdoll*
|
|
//-----------------------------------------------------------------------------
|
|
IRagdoll* C_Portal_Player::GetRepresentativeRagdoll() const
|
|
{
|
|
if ( m_hRagdoll.Get() )
|
|
{
|
|
C_PortalRagdoll *pRagdoll = static_cast<C_PortalRagdoll*>( m_hRagdoll.Get() );
|
|
if ( !pRagdoll )
|
|
return NULL;
|
|
|
|
return pRagdoll->GetIRagdoll();
|
|
}
|
|
else
|
|
{
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
|
|
void C_Portal_Player::PlayerPortalled( C_Prop_Portal *pEnteredPortal )
|
|
{
|
|
if( pEnteredPortal )
|
|
{
|
|
m_bPortalledMessagePending = true;
|
|
m_PendingPortalMatrix = pEnteredPortal->MatrixThisToLinked();
|
|
|
|
if( IsLocalPlayer() )
|
|
g_pPortalRender->EnteredPortal( pEnteredPortal );
|
|
}
|
|
}
|
|
|
|
void C_Portal_Player::OnPreDataChanged( DataUpdateType_t type )
|
|
{
|
|
Assert( m_pPortalEnvironment_LastCalcView == m_hPortalEnvironment.Get() );
|
|
PreDataChanged_Backup.m_hPortalEnvironment = m_hPortalEnvironment;
|
|
PreDataChanged_Backup.m_hSurroundingLiquidPortal = m_hSurroundingLiquidPortal;
|
|
PreDataChanged_Backup.m_qEyeAngles = m_iv_angEyeAngles.GetCurrent();
|
|
|
|
BaseClass::OnPreDataChanged( type );
|
|
}
|
|
|
|
void C_Portal_Player::OnDataChanged( DataUpdateType_t type )
|
|
{
|
|
BaseClass::OnDataChanged( type );
|
|
|
|
if( m_hSurroundingLiquidPortal != PreDataChanged_Backup.m_hSurroundingLiquidPortal )
|
|
{
|
|
CLiquidPortal_InnerLiquidEffect *pLiquidEffect = (CLiquidPortal_InnerLiquidEffect *)g_pScreenSpaceEffects->GetScreenSpaceEffect( "LiquidPortal_InnerLiquid" );
|
|
if( pLiquidEffect )
|
|
{
|
|
C_Func_LiquidPortal *pSurroundingPortal = m_hSurroundingLiquidPortal.Get();
|
|
if( pSurroundingPortal != NULL )
|
|
{
|
|
C_Func_LiquidPortal *pOldSurroundingPortal = PreDataChanged_Backup.m_hSurroundingLiquidPortal.Get();
|
|
if( pOldSurroundingPortal != pSurroundingPortal->m_hLinkedPortal.Get() )
|
|
{
|
|
pLiquidEffect->m_pImmersionPortal = pSurroundingPortal;
|
|
pLiquidEffect->m_bFadeBackToReality = false;
|
|
}
|
|
else
|
|
{
|
|
pLiquidEffect->m_bFadeBackToReality = true;
|
|
pLiquidEffect->m_fFadeBackTimeLeft = pLiquidEffect->s_fFadeBackEffectTime;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
pLiquidEffect->m_pImmersionPortal = NULL;
|
|
pLiquidEffect->m_bFadeBackToReality = false;
|
|
}
|
|
}
|
|
}
|
|
|
|
DetectAndHandlePortalTeleportation();
|
|
|
|
if ( type == DATA_UPDATE_CREATED )
|
|
{
|
|
// Load color correction lookup for the death effect
|
|
m_CCDeathHandle = g_pColorCorrectionMgr->AddColorCorrection( DEATH_CC_LOOKUP_FILENAME );
|
|
if ( m_CCDeathHandle != INVALID_CLIENT_CCHANDLE )
|
|
{
|
|
g_pColorCorrectionMgr->SetColorCorrectionWeight( m_CCDeathHandle, 0.0f );
|
|
}
|
|
|
|
SetNextClientThink( CLIENT_THINK_ALWAYS );
|
|
}
|
|
|
|
UpdateVisibility();
|
|
}
|
|
|
|
//CalcView() gets called between OnPreDataChanged() and OnDataChanged(), and these changes need to be known about in both before CalcView() gets called, and if CalcView() doesn't get called
|
|
bool C_Portal_Player::DetectAndHandlePortalTeleportation( void )
|
|
{
|
|
if( m_bPortalledMessagePending )
|
|
{
|
|
m_bPortalledMessagePending = false;
|
|
|
|
//C_Prop_Portal *pOldPortal = PreDataChanged_Backup.m_hPortalEnvironment.Get();
|
|
//Assert( pOldPortal );
|
|
//if( pOldPortal )
|
|
{
|
|
Vector ptNewPosition = GetNetworkOrigin();
|
|
|
|
UTIL_Portal_PointTransform( m_PendingPortalMatrix, PortalEyeInterpolation.m_vEyePosition_Interpolated, PortalEyeInterpolation.m_vEyePosition_Interpolated );
|
|
UTIL_Portal_PointTransform( m_PendingPortalMatrix, PortalEyeInterpolation.m_vEyePosition_Uninterpolated, PortalEyeInterpolation.m_vEyePosition_Uninterpolated );
|
|
|
|
PortalEyeInterpolation.m_bEyePositionIsInterpolating = true;
|
|
|
|
UTIL_Portal_AngleTransform( m_PendingPortalMatrix, m_qEyeAngles_LastCalcView, m_angEyeAngles );
|
|
m_angEyeAngles.x = AngleNormalize( m_angEyeAngles.x );
|
|
m_angEyeAngles.y = AngleNormalize( m_angEyeAngles.y );
|
|
m_angEyeAngles.z = AngleNormalize( m_angEyeAngles.z );
|
|
m_iv_angEyeAngles.Reset(); //copies from m_angEyeAngles
|
|
|
|
if( engine->IsPlayingDemo() )
|
|
{
|
|
pl.v_angle = m_angEyeAngles;
|
|
engine->SetViewAngles( pl.v_angle );
|
|
}
|
|
|
|
engine->ResetDemoInterpolation();
|
|
if( IsLocalPlayer() )
|
|
{
|
|
//DevMsg( "FPT: %.2f %.2f %.2f\n", m_angEyeAngles.x, m_angEyeAngles.y, m_angEyeAngles.z );
|
|
SetLocalAngles( m_angEyeAngles );
|
|
}
|
|
|
|
m_PlayerAnimState->Teleport ( &ptNewPosition, &GetNetworkAngles(), this );
|
|
|
|
// Reorient last facing direction to fix pops in view model lag
|
|
for ( int i = 0; i < MAX_VIEWMODELS; i++ )
|
|
{
|
|
CBaseViewModel *vm = GetViewModel( i );
|
|
if ( !vm )
|
|
continue;
|
|
|
|
UTIL_Portal_VectorTransform( m_PendingPortalMatrix, vm->m_vecLastFacing, vm->m_vecLastFacing );
|
|
}
|
|
}
|
|
m_bPortalledMessagePending = false;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/*bool C_Portal_Player::ShouldInterpolate( void )
|
|
{
|
|
if( !IsInterpolationEnabled() )
|
|
return false;
|
|
|
|
return BaseClass::ShouldInterpolate();
|
|
}*/
|
|
|
|
|
|
void C_Portal_Player::PostDataUpdate( DataUpdateType_t updateType )
|
|
{
|
|
// C_BaseEntity assumes we're networking the entity's angles, so pretend that it
|
|
// networked the same value we already have.
|
|
SetNetworkAngles( GetLocalAngles() );
|
|
|
|
if ( m_iSpawnInterpCounter != m_iSpawnInterpCounterCache )
|
|
{
|
|
MoveToLastReceivedPosition( true );
|
|
ResetLatched();
|
|
m_iSpawnInterpCounterCache = m_iSpawnInterpCounter;
|
|
}
|
|
|
|
BaseClass::PostDataUpdate( updateType );
|
|
}
|
|
|
|
float C_Portal_Player::GetFOV( void )
|
|
{
|
|
//Find our FOV with offset zoom value
|
|
float flFOVOffset = C_BasePlayer::GetFOV() + GetZoom();
|
|
|
|
// Clamp FOV in MP
|
|
int min_fov = GetMinFOV();
|
|
|
|
// Don't let it go too low
|
|
flFOVOffset = MAX( min_fov, flFOVOffset );
|
|
|
|
return flFOVOffset;
|
|
}
|
|
|
|
//=========================================================
|
|
// Autoaim
|
|
// set crosshair position to point to enemey
|
|
//=========================================================
|
|
Vector C_Portal_Player::GetAutoaimVector( float flDelta )
|
|
{
|
|
// Never autoaim a predicted weapon (for now)
|
|
Vector forward;
|
|
AngleVectors( EyeAngles() + m_Local.m_vecPunchAngle, &forward );
|
|
return forward;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Returns whether or not we are allowed to sprint now.
|
|
//-----------------------------------------------------------------------------
|
|
bool C_Portal_Player::CanSprint( void )
|
|
{
|
|
return ( (!m_Local.m_bDucked && !m_Local.m_bDucking) && (GetWaterLevel() != 3) );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void C_Portal_Player::StartSprinting( void )
|
|
{
|
|
//if( m_HL2Local.m_flSuitPower < 10 )
|
|
//{
|
|
// // Don't sprint unless there's a reasonable
|
|
// // amount of suit power.
|
|
// CPASAttenuationFilter filter( this );
|
|
// filter.UsePredictionRules();
|
|
// EmitSound( filter, entindex(), "Player.SprintNoPower" );
|
|
// return;
|
|
//}
|
|
|
|
CPASAttenuationFilter filter( this );
|
|
filter.UsePredictionRules();
|
|
EmitSound( filter, entindex(), "Player.SprintStart" );
|
|
|
|
SetMaxSpeed( _SPRINT_SPEED );
|
|
m_fIsSprinting = true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void C_Portal_Player::StopSprinting( void )
|
|
{
|
|
SetMaxSpeed( _NORM_SPEED );
|
|
m_fIsSprinting = false;
|
|
}
|
|
|
|
void C_Portal_Player::HandleSpeedChanges( void )
|
|
{
|
|
int buttonsChanged = m_afButtonPressed | m_afButtonReleased;
|
|
|
|
if( buttonsChanged & IN_SPEED )
|
|
{
|
|
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;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void C_Portal_Player::ItemPreFrame( void )
|
|
{
|
|
if ( GetFlags() & FL_FROZEN )
|
|
return;
|
|
|
|
// Disallow shooting while zooming
|
|
if ( m_nButtons & IN_ZOOM )
|
|
{
|
|
//FIXME: Held weapons like the grenade get sad when this happens
|
|
m_nButtons &= ~(IN_ATTACK|IN_ATTACK2);
|
|
}
|
|
|
|
BaseClass::ItemPreFrame();
|
|
|
|
}
|
|
|
|
void C_Portal_Player::ItemPostFrame( void )
|
|
{
|
|
if ( GetFlags() & FL_FROZEN )
|
|
return;
|
|
|
|
BaseClass::ItemPostFrame();
|
|
}
|
|
|
|
C_BaseAnimating *C_Portal_Player::BecomeRagdollOnClient()
|
|
{
|
|
// Let the C_CSRagdoll entity do this.
|
|
// m_builtRagdoll = true;
|
|
return NULL;
|
|
}
|
|
|
|
void C_Portal_Player::UpdatePortalEyeInterpolation( void )
|
|
{
|
|
#ifdef ENABLE_PORTAL_EYE_INTERPOLATION_CODE
|
|
//PortalEyeInterpolation.m_bEyePositionIsInterpolating = false;
|
|
if( PortalEyeInterpolation.m_bUpdatePosition_FreeMove )
|
|
{
|
|
PortalEyeInterpolation.m_bUpdatePosition_FreeMove = false;
|
|
|
|
C_Prop_Portal *pOldPortal = PreDataChanged_Backup.m_hPortalEnvironment.Get();
|
|
if( pOldPortal )
|
|
{
|
|
UTIL_Portal_PointTransform( pOldPortal->MatrixThisToLinked(), PortalEyeInterpolation.m_vEyePosition_Interpolated, PortalEyeInterpolation.m_vEyePosition_Interpolated );
|
|
//PortalEyeInterpolation.m_vEyePosition_Interpolated = pOldPortal->m_matrixThisToLinked * PortalEyeInterpolation.m_vEyePosition_Interpolated;
|
|
|
|
//Vector vForward;
|
|
//m_hPortalEnvironment.Get()->GetVectors( &vForward, NULL, NULL );
|
|
|
|
PortalEyeInterpolation.m_vEyePosition_Interpolated = EyeFootPosition();
|
|
|
|
PortalEyeInterpolation.m_bEyePositionIsInterpolating = true;
|
|
}
|
|
}
|
|
|
|
if( IsInAVehicle() )
|
|
PortalEyeInterpolation.m_bEyePositionIsInterpolating = false;
|
|
|
|
if( !PortalEyeInterpolation.m_bEyePositionIsInterpolating )
|
|
{
|
|
PortalEyeInterpolation.m_vEyePosition_Uninterpolated = EyeFootPosition();
|
|
PortalEyeInterpolation.m_vEyePosition_Interpolated = PortalEyeInterpolation.m_vEyePosition_Uninterpolated;
|
|
return;
|
|
}
|
|
|
|
Vector vThisFrameUninterpolatedPosition = EyeFootPosition();
|
|
|
|
//find offset between this and last frame's uninterpolated movement, and apply this as freebie movement to the interpolated position
|
|
PortalEyeInterpolation.m_vEyePosition_Interpolated += (vThisFrameUninterpolatedPosition - PortalEyeInterpolation.m_vEyePosition_Uninterpolated);
|
|
PortalEyeInterpolation.m_vEyePosition_Uninterpolated = vThisFrameUninterpolatedPosition;
|
|
|
|
Vector vDiff = vThisFrameUninterpolatedPosition - PortalEyeInterpolation.m_vEyePosition_Interpolated;
|
|
float fLength = vDiff.Length();
|
|
float fFollowSpeed = gpGlobals->frametime * 100.0f;
|
|
const float fMaxDiff = 150.0f;
|
|
if( fLength > fMaxDiff )
|
|
{
|
|
//camera lagging too far behind, give it a speed boost to bring it within maximum range
|
|
fFollowSpeed = fLength - fMaxDiff;
|
|
}
|
|
else if( fLength < fFollowSpeed )
|
|
{
|
|
//final move
|
|
PortalEyeInterpolation.m_bEyePositionIsInterpolating = false;
|
|
PortalEyeInterpolation.m_vEyePosition_Interpolated = vThisFrameUninterpolatedPosition;
|
|
return;
|
|
}
|
|
|
|
if ( fLength > 0.001f )
|
|
{
|
|
vDiff *= (fFollowSpeed/fLength);
|
|
PortalEyeInterpolation.m_vEyePosition_Interpolated += vDiff;
|
|
}
|
|
else
|
|
{
|
|
PortalEyeInterpolation.m_vEyePosition_Interpolated = vThisFrameUninterpolatedPosition;
|
|
}
|
|
|
|
|
|
|
|
#else
|
|
PortalEyeInterpolation.m_vEyePosition_Interpolated = BaseClass::EyePosition();
|
|
#endif
|
|
}
|
|
|
|
Vector C_Portal_Player::EyePosition()
|
|
{
|
|
return PortalEyeInterpolation.m_vEyePosition_Interpolated;
|
|
}
|
|
|
|
Vector C_Portal_Player::EyeFootPosition( const QAngle &qEyeAngles )
|
|
{
|
|
#if 0
|
|
static int iPrintCounter = 0;
|
|
++iPrintCounter;
|
|
if( iPrintCounter == 50 )
|
|
{
|
|
QAngle vAbsAngles = qEyeAngles;
|
|
DevMsg( "Eye Angles: %f %f %f\n", vAbsAngles.x, vAbsAngles.y, vAbsAngles.z );
|
|
iPrintCounter = 0;
|
|
}
|
|
#endif
|
|
|
|
//interpolate between feet and normal eye position based on view roll (gets us wall/ceiling & ceiling/ceiling teleportations without an eye position pop)
|
|
float fFootInterp = fabs(qEyeAngles[ROLL]) * ((1.0f/180.0f) * 0.75f); //0 when facing straight up, 0.75 when facing straight down
|
|
return (BaseClass::EyePosition() - (fFootInterp * m_vecViewOffset)); //TODO: Find a good Up vector for this rolled player and interpolate along actual eye/foot axis
|
|
}
|
|
|
|
void C_Portal_Player::CalcView( Vector &eyeOrigin, QAngle &eyeAngles, float &zNear, float &zFar, float &fov )
|
|
{
|
|
DetectAndHandlePortalTeleportation();
|
|
//if( DetectAndHandlePortalTeleportation() )
|
|
// DevMsg( "Teleported within OnDataChanged\n" );
|
|
|
|
m_iForceNoDrawInPortalSurface = -1;
|
|
bool bEyeTransform_Backup = m_bEyePositionIsTransformedByPortal;
|
|
m_bEyePositionIsTransformedByPortal = false; //assume it's not transformed until it provably is
|
|
UpdatePortalEyeInterpolation();
|
|
|
|
QAngle qEyeAngleBackup = EyeAngles();
|
|
Vector ptEyePositionBackup = EyePosition();
|
|
C_Prop_Portal *pPortalBackup = m_hPortalEnvironment.Get();
|
|
|
|
if ( m_lifeState != LIFE_ALIVE )
|
|
{
|
|
if ( g_nKillCamMode != 0 )
|
|
{
|
|
return;
|
|
}
|
|
|
|
Vector origin = EyePosition();
|
|
|
|
C_BaseEntity* pRagdoll = m_hRagdoll.Get();
|
|
|
|
if ( pRagdoll )
|
|
{
|
|
origin = pRagdoll->GetAbsOrigin();
|
|
#if !PORTAL_HIDE_PLAYER_RAGDOLL
|
|
origin.z += VEC_DEAD_VIEWHEIGHT_SCALED( this ).z; // look over ragdoll, not through
|
|
#endif //PORTAL_HIDE_PLAYER_RAGDOLL
|
|
}
|
|
|
|
BaseClass::CalcView( eyeOrigin, eyeAngles, zNear, zFar, fov );
|
|
|
|
eyeOrigin = origin;
|
|
|
|
Vector vForward;
|
|
AngleVectors( eyeAngles, &vForward );
|
|
|
|
VectorNormalize( vForward );
|
|
#if !PORTAL_HIDE_PLAYER_RAGDOLL
|
|
VectorMA( origin, -CHASE_CAM_DISTANCE_MAX, vForward, eyeOrigin );
|
|
#endif //PORTAL_HIDE_PLAYER_RAGDOLL
|
|
|
|
Vector WALL_MIN( -WALL_OFFSET, -WALL_OFFSET, -WALL_OFFSET );
|
|
Vector WALL_MAX( WALL_OFFSET, WALL_OFFSET, WALL_OFFSET );
|
|
|
|
trace_t trace; // clip against world
|
|
C_BaseEntity::PushEnableAbsRecomputations( false ); // HACK don't recompute positions while doing RayTrace
|
|
UTIL_TraceHull( origin, eyeOrigin, WALL_MIN, WALL_MAX, MASK_SOLID_BRUSHONLY, this, COLLISION_GROUP_NONE, &trace );
|
|
C_BaseEntity::PopEnableAbsRecomputations();
|
|
|
|
if (trace.fraction < 1.0)
|
|
{
|
|
eyeOrigin = trace.endpos;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
IClientVehicle *pVehicle;
|
|
pVehicle = GetVehicle();
|
|
|
|
if ( !pVehicle )
|
|
{
|
|
if ( IsObserver() )
|
|
{
|
|
CalcObserverView( eyeOrigin, eyeAngles, fov );
|
|
}
|
|
else
|
|
{
|
|
CalcPlayerView( eyeOrigin, eyeAngles, fov );
|
|
if( m_hPortalEnvironment.Get() != NULL )
|
|
{
|
|
//time for hax
|
|
m_bEyePositionIsTransformedByPortal = bEyeTransform_Backup;
|
|
CalcPortalView( eyeOrigin, eyeAngles );
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
CalcVehicleView( pVehicle, eyeOrigin, eyeAngles, zNear, zFar, fov );
|
|
}
|
|
}
|
|
|
|
m_qEyeAngles_LastCalcView = qEyeAngleBackup;
|
|
m_ptEyePosition_LastCalcView = ptEyePositionBackup;
|
|
m_pPortalEnvironment_LastCalcView = pPortalBackup;
|
|
|
|
#ifdef WIN32
|
|
// NVNT Inform haptics module of fov
|
|
if(IsLocalPlayer())
|
|
haptics->UpdatePlayerFOV(fov);
|
|
#endif
|
|
}
|
|
|
|
void C_Portal_Player::SetLocalViewAngles( const QAngle &viewAngles )
|
|
{
|
|
// Nothing
|
|
if ( engine->IsPlayingDemo() )
|
|
return;
|
|
BaseClass::SetLocalViewAngles( viewAngles );
|
|
}
|
|
|
|
void C_Portal_Player::SetViewAngles( const QAngle& ang )
|
|
{
|
|
BaseClass::SetViewAngles( ang );
|
|
|
|
if ( engine->IsPlayingDemo() )
|
|
{
|
|
pl.v_angle = ang;
|
|
}
|
|
}
|
|
|
|
void C_Portal_Player::CalcPortalView( Vector &eyeOrigin, QAngle &eyeAngles )
|
|
{
|
|
//although we already ran CalcPlayerView which already did these copies, they also fudge these numbers in ways we don't like, so recopy
|
|
VectorCopy( EyePosition(), eyeOrigin );
|
|
VectorCopy( EyeAngles(), eyeAngles );
|
|
|
|
//Re-apply the screenshake (we just stomped it)
|
|
vieweffects->ApplyShake( eyeOrigin, eyeAngles, 1.0 );
|
|
|
|
C_Prop_Portal *pPortal = m_hPortalEnvironment.Get();
|
|
assert( pPortal );
|
|
|
|
C_Prop_Portal *pRemotePortal = pPortal->m_hLinkedPortal;
|
|
if( !pRemotePortal )
|
|
{
|
|
return; //no hacks possible/necessary
|
|
}
|
|
|
|
Vector ptPortalCenter;
|
|
Vector vPortalForward;
|
|
|
|
ptPortalCenter = pPortal->GetNetworkOrigin();
|
|
pPortal->GetVectors( &vPortalForward, NULL, NULL );
|
|
float fPortalPlaneDist = vPortalForward.Dot( ptPortalCenter );
|
|
|
|
bool bOverrideSpecialEffects = false; //sometimes to get the best effect we need to kill other effects that are simply for cleanliness
|
|
|
|
float fEyeDist = vPortalForward.Dot( eyeOrigin ) - fPortalPlaneDist;
|
|
bool bTransformEye = false;
|
|
if( fEyeDist < 0.0f ) //eye behind portal
|
|
{
|
|
if( pPortal->m_PortalSimulator.EntityIsInPortalHole( this ) ) //player standing in portal
|
|
{
|
|
bTransformEye = true;
|
|
}
|
|
else if( vPortalForward.z < -0.01f ) //there's a weird case where the player is ducking below a ceiling portal. As they unduck their eye moves beyond the portal before the code detects that they're in the portal hole.
|
|
{
|
|
Vector ptPlayerOrigin = GetAbsOrigin();
|
|
float fOriginDist = vPortalForward.Dot( ptPlayerOrigin ) - fPortalPlaneDist;
|
|
|
|
if( fOriginDist > 0.0f )
|
|
{
|
|
float fInvTotalDist = 1.0f / (fOriginDist - fEyeDist); //fEyeDist is negative
|
|
Vector ptPlaneIntersection = (eyeOrigin * fOriginDist * fInvTotalDist) - (ptPlayerOrigin * fEyeDist * fInvTotalDist);
|
|
Assert( fabs( vPortalForward.Dot( ptPlaneIntersection ) - fPortalPlaneDist ) < 0.01f );
|
|
|
|
Vector vIntersectionTest = ptPlaneIntersection - ptPortalCenter;
|
|
|
|
Vector vPortalRight, vPortalUp;
|
|
pPortal->GetVectors( NULL, &vPortalRight, &vPortalUp );
|
|
|
|
if( (vIntersectionTest.Dot( vPortalRight ) <= PORTAL_HALF_WIDTH) &&
|
|
(vIntersectionTest.Dot( vPortalUp ) <= PORTAL_HALF_HEIGHT) )
|
|
{
|
|
bTransformEye = true;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if( bTransformEye )
|
|
{
|
|
m_bEyePositionIsTransformedByPortal = true;
|
|
|
|
//DevMsg( 2, "transforming portal view from <%f %f %f> <%f %f %f>\n", eyeOrigin.x, eyeOrigin.y, eyeOrigin.z, eyeAngles.x, eyeAngles.y, eyeAngles.z );
|
|
|
|
VMatrix matThisToLinked = pPortal->MatrixThisToLinked();
|
|
UTIL_Portal_PointTransform( matThisToLinked, eyeOrigin, eyeOrigin );
|
|
UTIL_Portal_AngleTransform( matThisToLinked, eyeAngles, eyeAngles );
|
|
|
|
//DevMsg( 2, "transforming portal view to <%f %f %f> <%f %f %f>\n", eyeOrigin.x, eyeOrigin.y, eyeOrigin.z, eyeAngles.x, eyeAngles.y, eyeAngles.z );
|
|
|
|
if ( IsToolRecording() )
|
|
{
|
|
static EntityTeleportedRecordingState_t state;
|
|
|
|
KeyValues *msg = new KeyValues( "entity_teleported" );
|
|
msg->SetPtr( "state", &state );
|
|
state.m_bTeleported = false;
|
|
state.m_bViewOverride = true;
|
|
state.m_vecTo = eyeOrigin;
|
|
state.m_qaTo = eyeAngles;
|
|
MatrixInvert( matThisToLinked.As3x4(), state.m_teleportMatrix );
|
|
|
|
// Post a message back to all IToolSystems
|
|
Assert( (int)GetToolHandle() != 0 );
|
|
ToolFramework_PostToolMessage( GetToolHandle(), msg );
|
|
|
|
msg->deleteThis();
|
|
}
|
|
|
|
bOverrideSpecialEffects = true;
|
|
}
|
|
else
|
|
{
|
|
m_bEyePositionIsTransformedByPortal = false;
|
|
}
|
|
|
|
if( bOverrideSpecialEffects )
|
|
{
|
|
m_iForceNoDrawInPortalSurface = ((pRemotePortal->m_bIsPortal2)?(2):(1));
|
|
pRemotePortal->m_fStaticAmount = 0.0f;
|
|
}
|
|
}
|
|
|
|
extern float g_fMaxViewModelLag;
|
|
void C_Portal_Player::CalcViewModelView( const Vector& eyeOrigin, const QAngle& eyeAngles)
|
|
{
|
|
// HACK: Manually adjusting the eye position that view model looking up and down are similar
|
|
// (solves view model "pop" on floor to floor transitions)
|
|
Vector vInterpEyeOrigin = eyeOrigin;
|
|
|
|
Vector vForward;
|
|
Vector vRight;
|
|
Vector vUp;
|
|
AngleVectors( eyeAngles, &vForward, &vRight, &vUp );
|
|
|
|
if ( vForward.z < 0.0f )
|
|
{
|
|
float fT = vForward.z * vForward.z;
|
|
vInterpEyeOrigin += vRight * ( fT * 4.7f ) + vForward * ( fT * 5.0f ) + vUp * ( fT * 4.0f );
|
|
}
|
|
|
|
if ( UTIL_IntersectEntityExtentsWithPortal( this ) )
|
|
g_fMaxViewModelLag = 0.0f;
|
|
else
|
|
g_fMaxViewModelLag = 1.5f;
|
|
|
|
for ( int i = 0; i < MAX_VIEWMODELS; i++ )
|
|
{
|
|
CBaseViewModel *vm = GetViewModel( i );
|
|
if ( !vm )
|
|
continue;
|
|
|
|
vm->CalcViewModelView( this, vInterpEyeOrigin, eyeAngles );
|
|
}
|
|
}
|
|
|
|
bool LocalPlayerIsCloseToPortal( void )
|
|
{
|
|
return C_Portal_Player::GetLocalPlayer()->IsCloseToPortal();
|
|
}
|
|
|