Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.

790 lines
23 KiB

5 years ago
//========= 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