519 lines
14 KiB
C++
519 lines
14 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Client side C_CHostage class
|
|
//
|
|
// $NoKeywords: $
|
|
//=============================================================================//
|
|
#include "cbase.h"
|
|
#include "c_cs_hostage.h"
|
|
#include <bitbuf.h>
|
|
#include "ragdoll_shared.h"
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
#undef CHostage
|
|
|
|
//-----------------------------------------------------------------------------
|
|
|
|
static float HOSTAGE_HEAD_TURN_RATE = 130;
|
|
|
|
|
|
CUtlVector< C_CHostage* > g_Hostages;
|
|
CUtlVector< EHANDLE > g_HostageRagdolls;
|
|
|
|
extern ConVar g_ragdoll_fadespeed;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
const int NumInterestingPoseParameters = 6;
|
|
static const char* InterestingPoseParameters[NumInterestingPoseParameters] =
|
|
{
|
|
"body_yaw",
|
|
"spine_yaw",
|
|
"neck_trans",
|
|
"head_pitch",
|
|
"head_yaw",
|
|
"head_roll"
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
class C_LowViolenceHostageDeathModel : public C_BaseAnimating
|
|
{
|
|
public:
|
|
DECLARE_CLASS( C_LowViolenceHostageDeathModel, C_BaseAnimating );
|
|
|
|
C_LowViolenceHostageDeathModel();
|
|
~C_LowViolenceHostageDeathModel();
|
|
|
|
bool SetupLowViolenceModel( C_CHostage *pHostage );
|
|
|
|
// fading out
|
|
void ClientThink( void );
|
|
|
|
private:
|
|
|
|
void Interp_Copy( VarMapping_t *pDest, CBaseEntity *pSourceEntity, VarMapping_t *pSrc );
|
|
|
|
float m_flFadeOutStart;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
C_LowViolenceHostageDeathModel::C_LowViolenceHostageDeathModel()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
C_LowViolenceHostageDeathModel::~C_LowViolenceHostageDeathModel()
|
|
{
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_LowViolenceHostageDeathModel::Interp_Copy( VarMapping_t *pDest, CBaseEntity *pSourceEntity, VarMapping_t *pSrc )
|
|
{
|
|
if ( !pDest || !pSrc )
|
|
return;
|
|
|
|
if ( pDest->m_Entries.Count() != pSrc->m_Entries.Count() )
|
|
{
|
|
Assert( false );
|
|
return;
|
|
}
|
|
|
|
int c = pDest->m_Entries.Count();
|
|
for ( int i = 0; i < c; i++ )
|
|
{
|
|
pDest->m_Entries[ i ].watcher->Copy( pSrc->m_Entries[i].watcher );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool C_LowViolenceHostageDeathModel::SetupLowViolenceModel( C_CHostage *pHostage )
|
|
{
|
|
const model_t *model = pHostage->GetModel();
|
|
const char *pModelName = modelinfo->GetModelName( model );
|
|
if ( InitializeAsClientEntity( pModelName, RENDER_GROUP_OPAQUE_ENTITY ) == false )
|
|
{
|
|
Release();
|
|
return false;
|
|
}
|
|
|
|
// Play the low-violence death anim
|
|
if ( LookupSequence( "death1" ) == -1 )
|
|
{
|
|
Release();
|
|
return false;
|
|
}
|
|
|
|
m_flFadeOutStart = gpGlobals->curtime + 5.0f;
|
|
SetNextClientThink( CLIENT_THINK_ALWAYS );
|
|
|
|
SetSequence( LookupSequence( "death1" ) );
|
|
ForceClientSideAnimationOn();
|
|
|
|
if ( pHostage && !pHostage->IsDormant() )
|
|
{
|
|
SetNetworkOrigin( pHostage->GetAbsOrigin() );
|
|
SetAbsOrigin( pHostage->GetAbsOrigin() );
|
|
SetAbsVelocity( pHostage->GetAbsVelocity() );
|
|
|
|
// move my current model instance to the ragdoll's so decals are preserved.
|
|
pHostage->SnatchModelInstance( this );
|
|
|
|
SetAbsAngles( pHostage->GetRenderAngles() );
|
|
SetNetworkAngles( pHostage->GetRenderAngles() );
|
|
|
|
CStudioHdr *pStudioHdr = GetModelPtr();
|
|
|
|
// update pose parameters
|
|
float poseParameter[MAXSTUDIOPOSEPARAM];
|
|
GetPoseParameters( pStudioHdr, poseParameter );
|
|
for ( int i=0; i<NumInterestingPoseParameters; ++i )
|
|
{
|
|
int poseParameterIndex = LookupPoseParameter( pStudioHdr, InterestingPoseParameters[i] );
|
|
SetPoseParameter( pStudioHdr, poseParameterIndex, poseParameter[poseParameterIndex] );
|
|
}
|
|
}
|
|
|
|
Interp_Reset( GetVarMapping() );
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_LowViolenceHostageDeathModel::ClientThink( void )
|
|
{
|
|
if ( m_flFadeOutStart > gpGlobals->curtime )
|
|
{
|
|
return;
|
|
}
|
|
|
|
int iAlpha = GetRenderColor().a;
|
|
|
|
iAlpha = MAX( iAlpha - ( g_ragdoll_fadespeed.GetInt() * gpGlobals->frametime ), 0 );
|
|
|
|
SetRenderMode( kRenderTransAlpha );
|
|
SetRenderColorA( iAlpha );
|
|
|
|
if ( iAlpha == 0 )
|
|
{
|
|
Release();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
//-----------------------------------------------------------------------------
|
|
void C_CHostage::RecvProxy_Rescued( const CRecvProxyData *pData, void *pStruct, void *pOut )
|
|
{
|
|
C_CHostage *pHostage= (C_CHostage *) pStruct;
|
|
|
|
bool isRescued = pData->m_Value.m_Int != 0;
|
|
|
|
if ( isRescued && !pHostage->m_isRescued )
|
|
{
|
|
// hostage was rescued
|
|
pHostage->m_flDeadOrRescuedTime = gpGlobals->curtime + 2;
|
|
pHostage->SetRenderMode( kRenderGlow );
|
|
pHostage->SetNextClientThink( gpGlobals->curtime );
|
|
}
|
|
|
|
pHostage->m_isRescued = isRescued;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
IMPLEMENT_CLIENTCLASS_DT(C_CHostage, DT_CHostage, CHostage)
|
|
|
|
RecvPropInt( RECVINFO( m_isRescued ), 0, C_CHostage::RecvProxy_Rescued ),
|
|
RecvPropInt( RECVINFO( m_iHealth ) ),
|
|
RecvPropInt( RECVINFO( m_iMaxHealth ) ),
|
|
RecvPropInt( RECVINFO( m_lifeState ) ),
|
|
|
|
RecvPropEHandle( RECVINFO( m_leader ) ),
|
|
|
|
END_RECV_TABLE()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
C_CHostage::C_CHostage()
|
|
{
|
|
g_Hostages.AddToTail( this );
|
|
|
|
m_flDeadOrRescuedTime = 0.0;
|
|
m_flLastBodyYaw = 0;
|
|
m_createdLowViolenceRagdoll = false;
|
|
|
|
// TODO: Get IK working on the steep slopes CS has, then enable it on characters.
|
|
m_EntClientFlags |= ENTCLIENTFLAG_DONTUSEIK;
|
|
|
|
// set the model so the PlayerAnimState uses the Hostage activities/sequences
|
|
SetModelName( "models/Characters/Hostage_01.mdl" );
|
|
|
|
m_PlayerAnimState = CreateHostageAnimState( this, this, LEGANIM_8WAY, false );
|
|
|
|
m_leader = NULL;
|
|
m_blinkTimer.Invalidate();
|
|
m_seq = -1;
|
|
|
|
m_flCurrentHeadPitch = 0;
|
|
m_flCurrentHeadYaw = 0;
|
|
|
|
m_eyeAttachment = -1;
|
|
m_chestAttachment = -1;
|
|
m_headYawPoseParam = -1;
|
|
m_headPitchPoseParam = -1;
|
|
m_lookAt = Vector( 0, 0, 0 );
|
|
m_isInit = false;
|
|
m_lookAroundTimer.Invalidate();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
C_CHostage::~C_CHostage()
|
|
{
|
|
g_Hostages.FindAndRemove( this );
|
|
m_PlayerAnimState->Release();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_CHostage::Spawn( void )
|
|
{
|
|
m_leader = NULL;
|
|
m_blinkTimer.Invalidate();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool C_CHostage::ShouldDraw( void )
|
|
{
|
|
if ( m_createdLowViolenceRagdoll )
|
|
return false;
|
|
|
|
return BaseClass::ShouldDraw();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
C_BaseAnimating * C_CHostage::BecomeRagdollOnClient()
|
|
{
|
|
if ( g_RagdollLVManager.IsLowViolence() )
|
|
{
|
|
// We can't just play the low-violence anim ourselves, since we're about to be deleted by the server.
|
|
// So, let's create another entity that can play the anim and stick around.
|
|
C_LowViolenceHostageDeathModel *pLowViolenceModel = new C_LowViolenceHostageDeathModel();
|
|
m_createdLowViolenceRagdoll = pLowViolenceModel->SetupLowViolenceModel( this );
|
|
if ( m_createdLowViolenceRagdoll )
|
|
{
|
|
UpdateVisibility();
|
|
g_HostageRagdolls.AddToTail( pLowViolenceModel );
|
|
return pLowViolenceModel;
|
|
}
|
|
else
|
|
{
|
|
// if we don't have a low-violence death anim, don't create a ragdoll.
|
|
return NULL;
|
|
}
|
|
}
|
|
|
|
C_BaseAnimating *pRagdoll = BaseClass::BecomeRagdollOnClient();
|
|
if ( pRagdoll && pRagdoll != this )
|
|
{
|
|
g_HostageRagdolls.AddToTail( pRagdoll );
|
|
}
|
|
return pRagdoll;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
* Set up attachment and pose param indices.
|
|
* We can't do this in the constructor or Spawn() because the data isn't
|
|
* there yet.
|
|
*/
|
|
void C_CHostage::Initialize( )
|
|
{
|
|
m_eyeAttachment = LookupAttachment( "eyes" );
|
|
m_chestAttachment = LookupAttachment( "chest" );
|
|
|
|
m_headYawPoseParam = LookupPoseParameter( "head_yaw" );
|
|
GetPoseParameterRange( m_headYawPoseParam, m_headYawMin, m_headYawMax );
|
|
|
|
m_headPitchPoseParam = LookupPoseParameter( "head_pitch" );
|
|
GetPoseParameterRange( m_headPitchPoseParam, m_headPitchMin, m_headPitchMax );
|
|
|
|
m_bodyYawPoseParam = LookupPoseParameter( "body_yaw" );
|
|
GetPoseParameterRange( m_bodyYawPoseParam, m_bodyYawMin, m_bodyYawMax );
|
|
|
|
Vector pos;
|
|
QAngle angles;
|
|
|
|
if (!GetAttachment( m_eyeAttachment, pos, angles ))
|
|
{
|
|
m_vecViewOffset = Vector( 0, 0, 50.0f );
|
|
}
|
|
else
|
|
{
|
|
m_vecViewOffset = pos - GetAbsOrigin();
|
|
}
|
|
|
|
|
|
if (!GetAttachment( m_chestAttachment, pos, angles ))
|
|
{
|
|
m_lookAt = Vector( 0, 0, 0 );
|
|
}
|
|
else
|
|
{
|
|
Vector forward;
|
|
AngleVectors( angles, &forward );
|
|
m_lookAt = EyePosition() + 100.0f * forward;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
CWeaponCSBase* C_CHostage::CSAnim_GetActiveWeapon()
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool C_CHostage::CSAnim_CanMove()
|
|
{
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
* Orient head and eyes towards m_lookAt.
|
|
*/
|
|
void C_CHostage::UpdateLookAt( CStudioHdr *pStudioHdr )
|
|
{
|
|
if (!m_isInit)
|
|
{
|
|
m_isInit = true;
|
|
Initialize( );
|
|
}
|
|
|
|
// head yaw
|
|
if (m_headYawPoseParam < 0 || m_bodyYawPoseParam < 0 || m_headPitchPoseParam < 0)
|
|
return;
|
|
|
|
if (GetLeader())
|
|
{
|
|
m_lookAt = GetLeader()->EyePosition();
|
|
}
|
|
|
|
// orient eyes
|
|
m_viewtarget = m_lookAt;
|
|
|
|
// blinking
|
|
if (m_blinkTimer.IsElapsed())
|
|
{
|
|
m_blinktoggle = !m_blinktoggle;
|
|
m_blinkTimer.Start( RandomFloat( 1.5f, 4.0f ) );
|
|
}
|
|
|
|
// Figure out where we want to look in world space.
|
|
QAngle desiredAngles;
|
|
Vector to = m_lookAt - EyePosition();
|
|
VectorAngles( to, desiredAngles );
|
|
|
|
// Figure out where our body is facing in world space.
|
|
float poseParams[MAXSTUDIOPOSEPARAM];
|
|
GetPoseParameters( pStudioHdr, poseParams );
|
|
QAngle bodyAngles( 0, 0, 0 );
|
|
bodyAngles[YAW] = GetRenderAngles()[YAW] + RemapVal( poseParams[m_bodyYawPoseParam], 0, 1, m_bodyYawMin, m_bodyYawMax );
|
|
|
|
|
|
float flBodyYawDiff = bodyAngles[YAW] - m_flLastBodyYaw;
|
|
m_flLastBodyYaw = bodyAngles[YAW];
|
|
|
|
|
|
// Set the head's yaw.
|
|
float desired = AngleNormalize( desiredAngles[YAW] - bodyAngles[YAW] );
|
|
desired = clamp( desired, m_headYawMin, m_headYawMax );
|
|
m_flCurrentHeadYaw = ApproachAngle( desired, m_flCurrentHeadYaw, HOSTAGE_HEAD_TURN_RATE * gpGlobals->frametime );
|
|
|
|
// Counterrotate the head from the body rotation so it doesn't rotate past its target.
|
|
m_flCurrentHeadYaw = AngleNormalize( m_flCurrentHeadYaw - flBodyYawDiff );
|
|
desired = clamp( desired, m_headYawMin, m_headYawMax );
|
|
|
|
SetPoseParameter( pStudioHdr, m_headYawPoseParam, m_flCurrentHeadYaw );
|
|
|
|
|
|
// Set the head's yaw.
|
|
desired = AngleNormalize( desiredAngles[PITCH] );
|
|
desired = clamp( desired, m_headPitchMin, m_headPitchMax );
|
|
|
|
m_flCurrentHeadPitch = ApproachAngle( desired, m_flCurrentHeadPitch, HOSTAGE_HEAD_TURN_RATE * gpGlobals->frametime );
|
|
m_flCurrentHeadPitch = AngleNormalize( m_flCurrentHeadPitch );
|
|
SetPoseParameter( pStudioHdr, m_headPitchPoseParam, m_flCurrentHeadPitch );
|
|
|
|
SetPoseParameter( pStudioHdr, "head_roll", 0.0f );
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
/**
|
|
* Look around at various interesting things
|
|
*/
|
|
void C_CHostage::LookAround( void )
|
|
{
|
|
if (GetLeader() == NULL && m_lookAroundTimer.IsElapsed())
|
|
{
|
|
m_lookAroundTimer.Start( RandomFloat( 3.0f, 15.0f ) );
|
|
|
|
Vector forward;
|
|
QAngle angles = GetAbsAngles();
|
|
angles[ YAW ] += RandomFloat( m_headYawMin, m_headYawMax );
|
|
angles[ PITCH ] += RandomFloat( m_headPitchMin, m_headPitchMax );
|
|
AngleVectors( angles, &forward );
|
|
m_lookAt = EyePosition() + 100.0f * forward;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_CHostage::UpdateClientSideAnimation()
|
|
{
|
|
if (IsDormant())
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_PlayerAnimState->Update( GetAbsAngles()[YAW], GetAbsAngles()[PITCH] );
|
|
|
|
// initialize pose parameters
|
|
char *setToZero[] =
|
|
{
|
|
"spine_yaw",
|
|
"head_roll"
|
|
};
|
|
CStudioHdr *pStudioHdr = GetModelPtr();
|
|
for ( int i=0; i < ARRAYSIZE( setToZero ); i++ )
|
|
{
|
|
int index = LookupPoseParameter( pStudioHdr, setToZero[i] );
|
|
if ( index >= 0 )
|
|
SetPoseParameter( pStudioHdr, index, 0 );
|
|
}
|
|
|
|
// orient head and eyes
|
|
LookAround();
|
|
UpdateLookAt( pStudioHdr );
|
|
|
|
|
|
BaseClass::UpdateClientSideAnimation();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_CHostage::ClientThink()
|
|
{
|
|
C_BaseCombatCharacter::ClientThink();
|
|
|
|
int speed = 2;
|
|
int a = m_clrRender->a;
|
|
|
|
a = MAX( 0, a - speed );
|
|
|
|
SetRenderColorA( a );
|
|
|
|
if ( m_clrRender->a > 0 )
|
|
{
|
|
SetNextClientThink( gpGlobals->curtime + 0.001 );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool C_CHostage::WasRecentlyKilledOrRescued( void )
|
|
{
|
|
return ( gpGlobals->curtime < m_flDeadOrRescuedTime );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_CHostage::OnPreDataChanged( DataUpdateType_t updateType )
|
|
{
|
|
BaseClass::OnPreDataChanged( updateType );
|
|
|
|
m_OldLifestate = m_lifeState;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_CHostage::OnDataChanged( DataUpdateType_t updateType )
|
|
{
|
|
BaseClass::OnDataChanged( updateType );
|
|
|
|
if ( m_OldLifestate != m_lifeState )
|
|
{
|
|
if( m_lifeState == LIFE_DEAD || m_lifeState == LIFE_DYING )
|
|
m_flDeadOrRescuedTime = gpGlobals->curtime + 2;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void C_CHostage::ImpactTrace( trace_t *pTrace, int iDamageType, const char *pCustomImpactName )
|
|
{
|
|
static ConVar *violence_hblood = cvar->FindVar( "violence_hblood" );
|
|
if ( violence_hblood && !violence_hblood->GetBool() )
|
|
return;
|
|
|
|
BaseClass::ImpactTrace( pTrace, iDamageType, pCustomImpactName );
|
|
}
|
|
|