790 lines
23 KiB
C++
790 lines
23 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "cbase.h"
|
|
#include "tf_item_wearable.h"
|
|
#include "vcollide_parse.h"
|
|
#include "tf_gamerules.h"
|
|
#include "animation.h"
|
|
#include "basecombatweapon_shared.h"
|
|
#ifdef CLIENT_DLL
|
|
#include "c_tf_player.h"
|
|
#include "model_types.h"
|
|
#include "props_shared.h"
|
|
#include "tf_mapinfo.h"
|
|
#else
|
|
#include "tf_player.h"
|
|
#endif
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_wearable, CTFWearable );
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFWearable, DT_TFWearable )
|
|
|
|
// Network Table --
|
|
BEGIN_NETWORK_TABLE( CTFWearable, DT_TFWearable )
|
|
#if defined( GAME_DLL )
|
|
SendPropBool( SENDINFO( m_bDisguiseWearable ) ),
|
|
SendPropEHandle( SENDINFO( m_hWeaponAssociatedWith ) ),
|
|
#else
|
|
RecvPropBool( RECVINFO( m_bDisguiseWearable ) ),
|
|
RecvPropEHandle( RECVINFO( m_hWeaponAssociatedWith ) ),
|
|
#endif // GAME_DLL
|
|
END_NETWORK_TABLE()
|
|
// -- Network Table
|
|
|
|
// Data Desc --
|
|
BEGIN_DATADESC( CTFWearable )
|
|
END_DATADESC()
|
|
// -- Data Desc
|
|
|
|
PRECACHE_REGISTER( tf_wearable );
|
|
|
|
|
|
LINK_ENTITY_TO_CLASS( tf_wearable_vm, CTFWearableVM );
|
|
IMPLEMENT_NETWORKCLASS_ALIASED( TFWearableVM, DT_TFWearableVM )
|
|
|
|
BEGIN_NETWORK_TABLE( CTFWearableVM, DT_TFWearableVM )
|
|
END_NETWORK_TABLE()
|
|
|
|
PRECACHE_REGISTER( tf_wearable_vm );
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SHARED CODE
|
|
//-----------------------------------------------------------------------------
|
|
|
|
CTFWearable::CTFWearable() : CEconWearable()
|
|
{
|
|
m_bDisguiseWearable = false;
|
|
m_hWeaponAssociatedWith = NULL;
|
|
#if defined( CLIENT_DLL )
|
|
m_eParticleSystemVisibility = kParticleSystemVisibility_Undetermined;
|
|
m_nWorldModelIndex = 0;
|
|
#endif
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// SERVER ONLY CODE
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#if defined( GAME_DLL )
|
|
void CTFWearable::Break( void )
|
|
{
|
|
CPVSFilter filter( GetAbsOrigin() );
|
|
UserMessageBegin( filter, "BreakModel" );
|
|
WRITE_SHORT( GetModelIndex() );
|
|
WRITE_VEC3COORD( GetAbsOrigin() );
|
|
WRITE_ANGLES( GetAbsAngles() );
|
|
WRITE_SHORT( GetSkin() );
|
|
MessageEnd();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CTFWearable::CalculateVisibleClassFor( CBaseCombatCharacter *pPlayer )
|
|
{
|
|
if ( m_bDisguiseWearable )
|
|
{
|
|
CTFPlayer *pTFPlayer = ToTFPlayer( pPlayer );
|
|
if ( pTFPlayer )
|
|
return pTFPlayer->m_Shared.GetDisguiseClass();
|
|
}
|
|
return BaseClass::CalculateVisibleClassFor( pPlayer );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CTFWearable::UpdateTransmitState()
|
|
{
|
|
return SetTransmitState( FL_EDICT_FULLCHECK );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CTFWearable::ShouldTransmit( const CCheckTransmitInfo *pInfo )
|
|
{
|
|
if ( pInfo->m_pClientEnt && GetOwnerEntity() && CBaseEntity::Instance( pInfo->m_pClientEnt ) == GetOwnerEntity() )
|
|
{
|
|
return FL_EDICT_ALWAYS;
|
|
}
|
|
|
|
// We have some entities that have no model (ie., "hatless hats") but we still want
|
|
// to transmit them down to clients so that the clients can do things like update body
|
|
// groups, etc.
|
|
return FL_EDICT_PVSCHECK;
|
|
}
|
|
|
|
#endif
|
|
|
|
#ifdef CLIENT_DLL
|
|
ConVar tf_test_hat_bodygroup( "tf_test_hat_bodygroup", "0", 0, "For testing bodygroups on hats." );
|
|
#endif
|
|
|
|
static int CalcBodyGroup( CBaseCombatCharacter* pOwner, CEconItemView *pItem, const char *pBodyGroup, codecontrolledbodygroupdata_t &ccbgd )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
if ( !Q_strnicmp( ccbgd.pFuncName, "test", ARRAYSIZE( "test" ) ) )
|
|
{
|
|
return tf_test_hat_bodygroup.GetInt();
|
|
}
|
|
else if ( !Q_strnicmp( ccbgd.pFuncName, "map_contributor", ARRAYSIZE( "map_contributor" ) ) )
|
|
{
|
|
int iDonationAmount = MapInfo_GetDonationAmount( pItem->GetAccountID(), engine->GetLevelName() );
|
|
return MIN( iDonationAmount / 25, 4 );
|
|
}
|
|
#endif
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CLIENT ONLY CODE
|
|
//-----------------------------------------------------------------------------
|
|
|
|
#if defined( CLIENT_DLL )
|
|
extern ConVar tf_playergib_forceup;
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Receive the BreakModel user message
|
|
//-----------------------------------------------------------------------------
|
|
void HandleBreakModel( bf_read &msg, bool bCheap )
|
|
{
|
|
int nModelIndex = (int)msg.ReadShort();
|
|
CUtlVector<breakmodel_t> aGibs;
|
|
BuildGibList( aGibs, nModelIndex, 1.0f, COLLISION_GROUP_NONE );
|
|
if ( !aGibs.Count() )
|
|
return;
|
|
|
|
// Get the origin & angles
|
|
Vector vecOrigin;
|
|
QAngle vecAngles;
|
|
int nSkin = 0;
|
|
msg.ReadBitVec3Coord( vecOrigin );
|
|
if ( !bCheap )
|
|
{
|
|
msg.ReadBitAngles( vecAngles );
|
|
nSkin = (int)msg.ReadShort();
|
|
}
|
|
else
|
|
{
|
|
vecAngles = vec3_angle;
|
|
}
|
|
|
|
// Launch it straight up with some random spread
|
|
Vector vecBreakVelocity = Vector(0,0,200);
|
|
AngularImpulse angularImpulse( RandomFloat( 0.0f, 120.0f ), RandomFloat( 0.0f, 120.0f ), 0.0 );
|
|
breakablepropparams_t breakParams( vecOrigin, vecAngles, vecBreakVelocity, angularImpulse );
|
|
breakParams.impactEnergyScale = 1.0f;
|
|
breakParams.nDefaultSkin = nSkin;
|
|
|
|
CreateGibsFromList( aGibs, nModelIndex, NULL, breakParams, NULL, -1 , false, true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Receive the BreakModel user message
|
|
//-----------------------------------------------------------------------------
|
|
void __MsgFunc_BreakModel( bf_read &msg )
|
|
{
|
|
HandleBreakModel( msg, false );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Receive the CheapBreakModel user message
|
|
//-----------------------------------------------------------------------------
|
|
void __MsgFunc_CheapBreakModel( bf_read &msg )
|
|
{
|
|
HandleBreakModel( msg, true );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Receive the BreakModel_Pumpkin user message
|
|
//-----------------------------------------------------------------------------
|
|
void __MsgFunc_BreakModel_Pumpkin( bf_read &msg )
|
|
{
|
|
int nModelIndex = (int)msg.ReadShort();
|
|
CUtlVector<breakmodel_t> aGibs;
|
|
BuildGibList( aGibs, nModelIndex, 1.0f, COLLISION_GROUP_NONE );
|
|
if ( !aGibs.Count() )
|
|
return;
|
|
|
|
// Get the origin & angles
|
|
Vector vecOrigin;
|
|
QAngle vecAngles;
|
|
msg.ReadBitVec3Coord( vecOrigin );
|
|
msg.ReadBitAngles( vecAngles );
|
|
|
|
// Launch it straight up with some random spread
|
|
Vector vecBreakVelocity = Vector(0,0,0);
|
|
AngularImpulse angularImpulse( RandomFloat( 0.0f, 120.0f ), RandomFloat( 0.0f, 120.0f ), 0.0 );
|
|
breakablepropparams_t breakParams( vecOrigin /*+ Vector(0,0,20)*/, vecAngles, vecBreakVelocity, angularImpulse );
|
|
breakParams.impactEnergyScale = 1.0f;
|
|
|
|
for ( int i=0; i<aGibs.Count(); ++i )
|
|
{
|
|
aGibs[i].burstScale = 1000.f;
|
|
}
|
|
|
|
CUtlVector<EHANDLE> hSpawnedGibs;
|
|
CreateGibsFromList( aGibs, nModelIndex, NULL, breakParams, NULL, -1 , false, true, &hSpawnedGibs );
|
|
|
|
// Make the base stay low to the ground.
|
|
for ( int i=0; i<hSpawnedGibs.Count(); ++i )
|
|
{
|
|
CBaseEntity *pGib = hSpawnedGibs[i];
|
|
if ( pGib )
|
|
{
|
|
IPhysicsObject *pPhysObj = pGib->VPhysicsGetObject();
|
|
if ( pPhysObj )
|
|
{
|
|
Vector vecVel;
|
|
AngularImpulse angImp;
|
|
pPhysObj->GetVelocity( &vecVel, &angImp );
|
|
vecVel *= 3.0;
|
|
if ( i == 3 )
|
|
{
|
|
vecVel.z = 300;
|
|
}
|
|
else
|
|
{
|
|
vecVel.z = 400;
|
|
}
|
|
pPhysObj->SetVelocity( &vecVel, &angImp );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CTFWearable::InternalDrawModel( int flags )
|
|
{
|
|
C_TFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
|
|
|
if ( pOwner && pOwner->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
|
|
{
|
|
bool bShouldDraw = false;
|
|
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
|
|
if ( pItem )
|
|
{
|
|
econ_tag_handle_t tagHandle = GetItemSchema()->GetHandleForTag( "ghost_wearable" );
|
|
if ( pItem->GetItemDefinition()->HasEconTag( tagHandle ) )
|
|
bShouldDraw = true;
|
|
}
|
|
|
|
if ( !bShouldDraw )
|
|
return 0;
|
|
}
|
|
|
|
bool bUseInvulnMaterial = ( pOwner && pOwner->m_Shared.IsInvulnerable() &&
|
|
( !pOwner->m_Shared.InCond( TF_COND_INVULNERABLE_HIDE_UNLESS_DAMAGED ) || gpGlobals->curtime < pOwner->GetLastDamageTime() + 2.0f ) );
|
|
|
|
if ( bUseInvulnMaterial && (flags & STUDIO_RENDER) )
|
|
{
|
|
modelrender->ForcedMaterialOverride( *pOwner->GetInvulnMaterialRef() );
|
|
}
|
|
|
|
int ret = BaseClass::InternalDrawModel( flags );
|
|
|
|
if ( bUseInvulnMaterial && (flags & STUDIO_RENDER) )
|
|
{
|
|
modelrender->ForcedMaterialOverride( NULL );
|
|
}
|
|
|
|
return ret;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFWearable::ShouldDraw()
|
|
{
|
|
C_TFPlayer *pOwner = ToTFPlayer( GetOwnerEntity() );
|
|
|
|
if ( pOwner )
|
|
{
|
|
if ( pOwner->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
|
|
{
|
|
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
|
|
if ( pItem )
|
|
{
|
|
econ_tag_handle_t tagHandle = GetItemSchema()->GetHandleForTag( "ghost_wearable" );
|
|
if ( pItem->GetItemDefinition()->HasEconTag( tagHandle ) )
|
|
return BaseClass::ShouldDraw();
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
// don't draw cosmetic while sniper is zoom
|
|
if ( pOwner == C_TFPlayer::GetLocalTFPlayer() && pOwner->m_Shared.InCond( TF_COND_ZOOMED ) )
|
|
return false;
|
|
}
|
|
|
|
// Don't draw 3rd person wearables if our owner is disguised.
|
|
if ( pOwner && pOwner->m_Shared.InCond( TF_COND_DISGUISED ) && !IsViewModelWearable() )
|
|
{
|
|
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( m_bDisguiseWearable && pLocalPlayer )
|
|
{
|
|
int iLocalPlayerTeam = pLocalPlayer->GetTeamNumber();
|
|
if ( pLocalPlayer->m_bIsCoaching && pLocalPlayer->m_hStudent )
|
|
{
|
|
iLocalPlayerTeam = pLocalPlayer->m_hStudent->GetTeamNumber();
|
|
}
|
|
|
|
// This wearable is a part of our disguise -- we might want to draw it.
|
|
if ( GetEnemyTeam( pOwner->GetTeamNumber() ) != iLocalPlayerTeam )
|
|
{
|
|
// The local player is on this spy's team. We don't see the disguise.
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
if ( pOwner->m_Shared.GetDisguiseClass() == TF_CLASS_SPY &&
|
|
pOwner->m_Shared.GetDisguiseTeam() == iLocalPlayerTeam )
|
|
{
|
|
// This enemy spy is disguised as a spy on our team, don't draw wearables.
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// The local player is an enemy. Show the disguise wearable.
|
|
return BaseClass::ShouldDraw();
|
|
}
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
else
|
|
{
|
|
// See if the visibility is controlled by a weapon.
|
|
CTFWeaponBase *pWeapon = assert_cast< CTFWeaponBase* >( GetWeaponAssociatedWith() );
|
|
if ( pWeapon )
|
|
{
|
|
// If the weapon isn't active, don't draw
|
|
if ( pOwner && pOwner->GetActiveWeapon() != pWeapon )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( !IsViewModelWearable() )
|
|
{
|
|
// If it's the 3rd person wearable, don't draw it when the weapon is hidden
|
|
if ( !pWeapon->ShouldDraw() )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// If the weapon is being repurposed for a taunt dont draw.
|
|
// The Brutal Legend taunt changes your weapon's model to be the guitar,
|
|
// but we dont want things like bot-killer skulls or festive lights
|
|
// to continue to draw
|
|
if( pWeapon->IsBeingRepurposedForTaunt() )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return BaseClass::ShouldDraw();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFWearable::ShouldDrawParticleSystems( void )
|
|
{
|
|
if ( !BaseClass::ShouldDrawParticleSystems() )
|
|
return false;
|
|
|
|
C_TFPlayer *pPlayer = ToTFPlayer( GetOwnerEntity() );
|
|
bool bStealthed = pPlayer->m_Shared.IsStealthed();
|
|
|
|
// If we're disguised, this ought to only be getting called on disguise wearables,
|
|
// otherwise we could get two particles showing at once (disguise wearable + real wearable).
|
|
Assert( !pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) || IsDisguiseWearable() );
|
|
|
|
if ( bStealthed )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
if ( m_eParticleSystemVisibility == kParticleSystemVisibility_Undetermined )
|
|
{
|
|
static CSchemaItemDefHandle pItemDef_MapLoverHat( "World Traveler" );
|
|
|
|
m_eParticleSystemVisibility = kParticleSystemVisibility_Shown;
|
|
|
|
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
|
|
if ( pItem && pItem->GetStaticData() == pItemDef_MapLoverHat )
|
|
{
|
|
if ( MapInfo_DidPlayerDonate( pItem->GetAccountID(), engine->GetLevelName() ) == false )
|
|
{
|
|
m_eParticleSystemVisibility = kParticleSystemVisibility_Hidden;
|
|
}
|
|
}
|
|
}
|
|
|
|
return m_eParticleSystemVisibility == kParticleSystemVisibility_Shown;
|
|
}
|
|
|
|
int CTFWearable::GetWorldModelIndex( void )
|
|
{
|
|
if ( m_nWorldModelIndex == 0 )
|
|
return m_nModelIndex;
|
|
|
|
static CSchemaItemDefHandle pItemDef_OculusRiftHeadset( "The TF2VRH" );
|
|
const CEconItemView *pItem = GetAttributeContainer()->GetItem();
|
|
if ( pItem && pItem->GetStaticData() == pItemDef_OculusRiftHeadset )
|
|
{
|
|
CTFPlayer *pTFPlayer = ToTFPlayer( GetOwnerEntity() );
|
|
if ( pTFPlayer )
|
|
{
|
|
if ( pTFPlayer->IsUsingVRHeadset() && pTFPlayer->GetPlayerClass() )
|
|
{
|
|
const char *pszReplacementModel = pItem->GetStaticData()->GetPlayerDisplayModelAlt( pTFPlayer->GetPlayerClass()->GetClassIndex() );
|
|
if ( pszReplacementModel && pszReplacementModel[0] )
|
|
{
|
|
return modelinfo->GetModelIndex( pszReplacementModel );
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
//*********************************************************************************
|
|
// Parachute states
|
|
static CSchemaItemDefHandle pItemDef_BaseJumper( "The B.A.S.E. Jumper" );
|
|
const int iParachuteOpen = modelinfo->GetModelIndex( "models/workshop/weapons/c_models/c_paratooper_pack/c_paratrooper_pack_open.mdl" );
|
|
const int iParachuteClosed = modelinfo->GetModelIndex( "models/workshop/weapons/c_models/c_paratooper_pack/c_paratrooper_pack.mdl" );
|
|
if ( m_nModelIndex == iParachuteOpen || m_nModelIndex == iParachuteClosed )
|
|
{
|
|
CTFPlayer *pTFPlayer = ToTFPlayer( GetOwnerEntity() );
|
|
if ( pTFPlayer )
|
|
{
|
|
if ( pTFPlayer->m_Shared.InCond( TF_COND_PARACHUTE_DEPLOYED ) )
|
|
{
|
|
return iParachuteOpen;
|
|
}
|
|
else
|
|
{
|
|
return iParachuteClosed;
|
|
}
|
|
}
|
|
}
|
|
|
|
if ( GameRules() )
|
|
{
|
|
const char *pBaseName = modelinfo->GetModelName( modelinfo->GetModel( m_nWorldModelIndex ) );
|
|
const char *pTranslatedName = GameRules()->TranslateEffectForVisionFilter( "weapons", pBaseName );
|
|
|
|
if ( pTranslatedName != pBaseName )
|
|
{
|
|
return modelinfo->GetModelIndex( pTranslatedName );
|
|
}
|
|
}
|
|
|
|
return m_nWorldModelIndex;
|
|
}
|
|
|
|
void CTFWearable::ValidateModelIndex( void )
|
|
{
|
|
m_nModelIndex = GetWorldModelIndex();
|
|
|
|
BaseClass::ValidateModelIndex();
|
|
}
|
|
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Hides or shows masked bodygroups associated with this item.
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFWearable::UpdateBodygroups( CBaseCombatCharacter* pOwner, int iState )
|
|
{
|
|
CTFPlayer *pTFOwner = ToTFPlayer( pOwner );
|
|
if ( !pTFOwner )
|
|
return false;
|
|
|
|
bool bBaseUpdate = BaseClass::UpdateBodygroups( pOwner, iState );
|
|
if ( bBaseUpdate && m_bDisguiseWearable )
|
|
{
|
|
CEconItemView *pItem = GetAttributeContainer()->GetItem(); // Safe. Checked in base class call.
|
|
|
|
CTFPlayer *pDisguiseTarget = ToTFPlayer( pTFOwner->m_Shared.GetDisguiseTarget() );
|
|
if ( !pDisguiseTarget )
|
|
return false;
|
|
|
|
// Update our disguise bodygroup.
|
|
int iDisguiseBody = pTFOwner->m_Shared.GetDisguiseBody();
|
|
int iTeam = pTFOwner->m_Shared.GetDisguiseTeam();
|
|
int iNumBodyGroups = pItem->GetStaticData()->GetNumModifiedBodyGroups( iTeam );
|
|
for ( int i=0; i<iNumBodyGroups; ++i )
|
|
{
|
|
int iBody = 0;
|
|
const char *pszBodyGroup = pItem->GetStaticData()->GetModifiedBodyGroup( iTeam, i, iBody );
|
|
int iBodyGroup = pDisguiseTarget->FindBodygroupByName( pszBodyGroup );
|
|
|
|
if ( iBodyGroup == -1 )
|
|
continue;
|
|
|
|
::SetBodygroup( pDisguiseTarget->GetModelPtr(), iDisguiseBody, iBodyGroup, iState );
|
|
}
|
|
|
|
pTFOwner->m_Shared.SetDisguiseBody( iDisguiseBody );
|
|
}
|
|
|
|
CEconItemView *pItem = GetAttributeContainer() ? GetAttributeContainer()->GetItem() : NULL;
|
|
if ( pItem )
|
|
{
|
|
int iTeam = pTFOwner->GetTeamNumber();
|
|
int iNumBodyGroups = pItem->GetStaticData()->GetNumCodeControlledBodyGroups( iTeam );
|
|
for ( int i=0; i<iNumBodyGroups; ++i )
|
|
{
|
|
codecontrolledbodygroupdata_t ccbgd = { NULL, NULL };
|
|
const char *pszBodyGroup = pItem->GetStaticData()->GetCodeControlledBodyGroup( iTeam, i, ccbgd );
|
|
int iBodyGroup = FindBodygroupByName( pszBodyGroup );
|
|
if ( iBodyGroup != -1 )
|
|
{
|
|
SetBodygroup( iBodyGroup, CalcBodyGroup( pOwner, pItem, pszBodyGroup, ccbgd ) );
|
|
}
|
|
}
|
|
}
|
|
|
|
// Additional hidden bodygroups.
|
|
for ( int i=0; i<m_HiddenBodyGroups.Count(); ++i )
|
|
{
|
|
int iBodyGroup = pOwner->FindBodygroupByName( m_HiddenBodyGroups[i] );
|
|
if ( iBodyGroup == -1 )
|
|
continue;
|
|
pOwner->SetBodygroup( iBodyGroup, iState );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
int CTFWearable::GetSkin()
|
|
{
|
|
CTFPlayer *pPlayer = ToTFPlayer( GetOwnerEntity() );
|
|
if ( !pPlayer )
|
|
return 0;
|
|
|
|
int iTeamNumber = pPlayer->GetTeamNumber();
|
|
|
|
#if defined( CLIENT_DLL )
|
|
// Run client-only "is the viewer on the same team as the wielder" logic. Assumed to
|
|
// always be false on the server.
|
|
CTFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
|
|
if ( !pLocalPlayer )
|
|
return 0;
|
|
|
|
int iLocalTeam = pLocalPlayer->GetTeamNumber();
|
|
|
|
// We only show disguise weapon to the enemy team when owner is disguised
|
|
bool bUseDisguiseWeapon = ( iTeamNumber != iLocalTeam && iLocalTeam > LAST_SHARED_TEAM );
|
|
|
|
if ( bUseDisguiseWeapon && pPlayer->m_Shared.InCond( TF_COND_DISGUISED ) )
|
|
{
|
|
if ( pLocalPlayer != pPlayer )
|
|
{
|
|
iTeamNumber = pPlayer->m_Shared.GetDisguiseTeam();
|
|
}
|
|
}
|
|
#endif // defined( CLIENT_DLL )
|
|
|
|
// See if the item wants to override the skin
|
|
int nSkin = -1;
|
|
|
|
CBaseCombatWeapon *pWeapon = assert_cast< CBaseCombatWeapon* >( GetWeaponAssociatedWith() );
|
|
if ( pWeapon )
|
|
{
|
|
CEconItemView *pItem = pWeapon->GetAttributeContainer()->GetItem();
|
|
if ( pItem->IsValid() )
|
|
{
|
|
nSkin = pItem->GetSkin( iTeamNumber ); // if we didn't have custom code, fall back to the item definition
|
|
}
|
|
}
|
|
|
|
if ( nSkin != -1 )
|
|
{
|
|
return nSkin;
|
|
}
|
|
|
|
return BaseClass::GetSkin();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFWearable::InternalSetPlayerDisplayModel( void )
|
|
{
|
|
// Set our model to the player model
|
|
CEconItemView *pItem = GetAttributeContainer()->GetItem();
|
|
if ( pItem && pItem->IsValid() && pItem->GetStaticData() )
|
|
{
|
|
if ( pItem->GetStaticData()->IsContentStreamable() )
|
|
{
|
|
const char *pszPlayerDisplayModelAlt = pItem->GetStaticData()->GetPlayerDisplayModelAlt();
|
|
if ( pszPlayerDisplayModelAlt && pszPlayerDisplayModelAlt[0] )
|
|
{
|
|
modelinfo->RegisterDynamicModel( pszPlayerDisplayModelAlt, IsClient() );
|
|
}
|
|
}
|
|
}
|
|
|
|
BaseClass::InternalSetPlayerDisplayModel();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFWearable::AddHiddenBodyGroup( const char* bodygroup )
|
|
{
|
|
m_HiddenBodyGroups.AddToHead( bodygroup );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFWearable::ReapplyProvision( void )
|
|
{
|
|
// Disguise wearables never provide
|
|
if ( IsDisguiseWearable() )
|
|
{
|
|
#ifdef GAME_DLL
|
|
UpdateModelToClass();
|
|
#endif
|
|
return;
|
|
}
|
|
|
|
BaseClass::ReapplyProvision();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Attaches the item to the player.
|
|
//-----------------------------------------------------------------------------
|
|
void CTFWearable::Equip( CBasePlayer* pOwner )
|
|
{
|
|
BaseClass::Equip( pOwner );
|
|
|
|
CTFPlayer *pTFPlayer = ToTFPlayer( pOwner );
|
|
if ( !pTFPlayer )
|
|
return;
|
|
|
|
int iTeamNumber = pTFPlayer->GetTeamNumber();
|
|
if ( m_bDisguiseWearable )
|
|
{
|
|
iTeamNumber = pTFPlayer->m_Shared.GetDisguiseTeam();
|
|
}
|
|
ChangeTeam( iTeamNumber );
|
|
m_nSkin = ( iTeamNumber == (LAST_SHARED_TEAM+1) ) ? 0 : 1;
|
|
|
|
#ifdef CLIENT_DLL
|
|
pTFPlayer->SetBodygroupsDirty();
|
|
#endif
|
|
|
|
#ifdef GAME_DLL
|
|
// Reapply upgrades for wearables upon equip
|
|
CEconItemView *pItem = ( (CTFWearable *)this )->GetAttributeContainer()->GetItem();
|
|
if ( pTFPlayer && pItem->IsValid() )
|
|
{
|
|
pTFPlayer->ReapplyItemUpgrades( pItem );
|
|
}
|
|
#endif // GAME_DLL
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Attaches the item to the player.
|
|
//-----------------------------------------------------------------------------
|
|
void CTFWearable::UnEquip( CBasePlayer* pOwner )
|
|
{
|
|
BaseClass::UnEquip( pOwner );
|
|
|
|
#ifdef CLIENT_DLL
|
|
CTFPlayer *pTFPlayer = ToTFPlayer( pOwner );
|
|
if ( pTFPlayer )
|
|
{
|
|
pTFPlayer->SetBodygroupsDirty();
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Check for any TF specific restrictions on item use.
|
|
//-----------------------------------------------------------------------------
|
|
bool CTFWearable::CanEquip( CBaseEntity *pOther )
|
|
{
|
|
CEconItemView *pItem = GetAttributeContainer()->GetItem();
|
|
if ( pItem && TFGameRules() )
|
|
{
|
|
CEconItemDefinition* pData = pItem->GetStaticData();
|
|
if ( pData && pData->GetHolidayRestriction() )
|
|
{
|
|
int iHolidayRestriction = UTIL_GetHolidayForString( pData->GetHolidayRestriction() );
|
|
if ( iHolidayRestriction != kHoliday_None && !TFGameRules()->IsHolidayActive( iHolidayRestriction ) )
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFWearable::OnDataChanged( DataUpdateType_t updateType )
|
|
{
|
|
BaseClass::OnDataChanged( updateType );
|
|
|
|
if ( updateType == DATA_UPDATE_CREATED )
|
|
{
|
|
ListenForGameEvent( "localplayer_changeteam" );
|
|
|
|
m_nWorldModelIndex = m_nModelIndex;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CTFWearable::FireGameEvent( IGameEvent *event )
|
|
{
|
|
const char *pszEventName = event->GetName();
|
|
if ( Q_strcmp( pszEventName, "localplayer_changeteam" ) == 0 )
|
|
{
|
|
UpdateVisibility();
|
|
}
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
// Choose shadow type for VM-wearables.
|
|
//-----------------------------------------------------------------------------
|
|
#if defined( CLIENT_DLL )
|
|
ShadowType_t CTFWearableVM::ShadowCastType( void )
|
|
{
|
|
if ( ToTFPlayer(GetMoveParent())->ShouldDrawThisPlayer() )
|
|
{
|
|
// Using the viewmodel.
|
|
return SHADOWS_NONE;
|
|
}
|
|
|
|
return SHADOWS_RENDER_TO_TEXTURE;
|
|
}
|
|
#endif
|
|
|
|
|