1972 lines
73 KiB
C++
1972 lines
73 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose:
|
|
//
|
|
//=============================================================================
|
|
|
|
#include "cbase.h"
|
|
#include "econ_item_view.h"
|
|
#include "econ_item_system.h"
|
|
#include "econ_item_description.h"
|
|
#include "econ_item_inventory.h"
|
|
|
|
#include "rtime.h"
|
|
#include "econ_gcmessages.h"
|
|
#include "gamestringpool.h"
|
|
|
|
// For localization
|
|
#include "tier3/tier3.h"
|
|
#include "vgui/ILocalize.h"
|
|
|
|
#include "isaverestore.h"
|
|
#include "dt_utlvector_send.h"
|
|
#include "dt_utlvector_recv.h"
|
|
#include <vgui_controls/Panel.h>
|
|
|
|
#ifdef CLIENT_DLL
|
|
#ifndef DEDICATED
|
|
#include "vgui/IScheme.h"
|
|
#endif
|
|
#endif
|
|
|
|
#if defined(TF_CLIENT_DLL)
|
|
#include "tf_duel_summary.h"
|
|
#include "econ_contribution.h"
|
|
#include "tf_player_info.h"
|
|
#include "tf_gcmessages.h"
|
|
#include "c_tf_freeaccount.h"
|
|
#include "c_tf_player.h"
|
|
#endif
|
|
|
|
#include "materialsystem/itexture.h"
|
|
#include "materialsystem/itexturecompositor.h"
|
|
|
|
#include "activitylist.h"
|
|
|
|
#ifdef CLIENT_DLL
|
|
#include "gc_clientsystem.h"
|
|
#endif // CLIENT_DLL
|
|
|
|
#ifdef GC_DLL
|
|
#error "CEconItemView is not meant to be compiled on the GC! There are silent assumptions made about attributes, etc."
|
|
#endif // GC_DLL
|
|
|
|
// memdbgon must be the last include file in a .cpp file!!!
|
|
#include "tier0/memdbgon.h"
|
|
|
|
|
|
#ifdef STAGING_ONLY
|
|
ConVar econ_force_style_index( "econ_force_style_index", "-1", FCVAR_REPLICATED );
|
|
#endif // STAGING_ONLY
|
|
|
|
|
|
// Networking tables for attributes
|
|
BEGIN_NETWORK_TABLE_NOBASE( CEconItemAttribute, DT_ScriptCreatedAttribute )
|
|
|
|
// Note: we are networking the value as an int, even though it's a "float", because really it isn't
|
|
// a float. It's 32 raw bits.
|
|
|
|
#ifndef CLIENT_DLL
|
|
SendPropInt( SENDINFO(m_iAttributeDefinitionIndex), -1, SPROP_UNSIGNED ),
|
|
SendPropInt( SENDINFO_NAME(m_flValue, m_iRawValue32), 32, SPROP_UNSIGNED ),
|
|
#if ENABLE_ATTRIBUTE_CURRENCY_TRACKING
|
|
SendPropInt( SENDINFO(m_nRefundableCurrency), -1, SPROP_UNSIGNED ),
|
|
#endif // ENABLE_ATTRIBUTE_CURRENCY_TRACKING
|
|
#else
|
|
RecvPropInt( RECVINFO(m_iAttributeDefinitionIndex) ),
|
|
RecvPropInt( RECVINFO_NAME(m_flValue, m_iRawValue32) ),
|
|
RecvPropFloat( RECVINFO(m_flValue), SPROP_NOSCALE ), // for demo compatibility only
|
|
#if ENABLE_ATTRIBUTE_CURRENCY_TRACKING
|
|
RecvPropInt( RECVINFO(m_nRefundableCurrency) ),
|
|
#endif // ENABLE_ATTRIBUTE_CURRENCY_TRACKING
|
|
#endif
|
|
END_NETWORK_TABLE()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconItemAttribute::CEconItemAttribute( void )
|
|
{
|
|
Init();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconItemAttribute::CEconItemAttribute( const attrib_definition_index_t iAttributeIndex, float flValue )
|
|
{
|
|
Init();
|
|
|
|
m_iAttributeDefinitionIndex = iAttributeIndex;
|
|
SetValue( flValue );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconItemAttribute::CEconItemAttribute( const attrib_definition_index_t iAttributeIndex, uint32 unValue )
|
|
{
|
|
Init();
|
|
|
|
m_iAttributeDefinitionIndex = iAttributeIndex;
|
|
SetIntValue( unValue );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemAttribute::SetValue( float flValue )
|
|
{
|
|
// Assert( GetStaticData() && GetStaticData()->IsStoredAsFloat() );
|
|
m_flValue = flValue;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemAttribute::SetIntValue( uint32 unValue )
|
|
{
|
|
// @note we don't check the storage type here, because this is how it is set from the data file
|
|
// Note that numbers approaching two billion cannot be stored in a float
|
|
// representation because they will map to NaNs. Numbers below 16 million
|
|
// will fail if denormals are disabled.
|
|
m_flValue = *(float*)&unValue;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemAttribute::Init( void )
|
|
{
|
|
m_iAttributeDefinitionIndex = INVALID_ATTRIB_DEF_INDEX;
|
|
m_flValue = 0.0f;
|
|
|
|
#if ENABLE_ATTRIBUTE_CURRENCY_TRACKING
|
|
m_nRefundableCurrency = 0;
|
|
#endif // ENABLE_ATTRIBUTE_CURRENCY_TRACKING
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemAttribute::operator=( const CEconItemAttribute &val )
|
|
{
|
|
m_iAttributeDefinitionIndex = val.m_iAttributeDefinitionIndex;
|
|
m_flValue = val.m_flValue;
|
|
|
|
#if ENABLE_ATTRIBUTE_CURRENCY_TRACKING
|
|
m_nRefundableCurrency = val.m_nRefundableCurrency;
|
|
#endif // ENABLE_ATTRIBUTE_CURRENCY_TRACKING
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const CEconItemAttributeDefinition *CEconItemAttribute::GetStaticData( void ) const
|
|
{
|
|
return GetItemSchema()->GetAttributeDefinition( m_iAttributeDefinitionIndex );
|
|
}
|
|
|
|
BEGIN_NETWORK_TABLE_NOBASE( CAttributeList, DT_AttributeList )
|
|
#if !defined( CLIENT_DLL )
|
|
SendPropUtlVectorDataTable( m_Attributes, MAX_ATTRIBUTES_PER_ITEM, DT_ScriptCreatedAttribute ),
|
|
#else
|
|
RecvPropUtlVectorDataTable( m_Attributes, MAX_ATTRIBUTES_PER_ITEM, DT_ScriptCreatedAttribute ),
|
|
#endif // CLIENT_DLL
|
|
END_NETWORK_TABLE()
|
|
|
|
BEGIN_DATADESC_NO_BASE( CAttributeList )
|
|
END_DATADESC()
|
|
|
|
//===========================================================================================================================
|
|
// SCRIPT CREATED ITEMS
|
|
//===========================================================================================================================
|
|
BEGIN_NETWORK_TABLE_NOBASE( CEconItemView, DT_ScriptCreatedItem )
|
|
#if !defined( CLIENT_DLL )
|
|
SendPropInt( SENDINFO( m_iItemDefinitionIndex ), 20, SPROP_UNSIGNED ),
|
|
SendPropInt( SENDINFO( m_iEntityLevel ), 8 ),
|
|
//SendPropInt( SENDINFO( m_iItemID ), 64, SPROP_UNSIGNED ),
|
|
SendPropInt( SENDINFO( m_iItemIDHigh ), 32, SPROP_UNSIGNED ),
|
|
SendPropInt( SENDINFO( m_iItemIDLow ), 32, SPROP_UNSIGNED ),
|
|
SendPropInt( SENDINFO( m_iAccountID ), 32, SPROP_UNSIGNED ),
|
|
SendPropInt( SENDINFO( m_iEntityQuality ), 5 ),
|
|
SendPropBool( SENDINFO( m_bInitialized ) ),
|
|
SendPropBool( SENDINFO( m_bOnlyIterateItemViewAttributes) ),
|
|
SendPropDataTable(SENDINFO_DT(m_AttributeList), &REFERENCE_SEND_TABLE(DT_AttributeList)),
|
|
SendPropInt( SENDINFO( m_iTeamNumber ) ),
|
|
SendPropDataTable(SENDINFO_DT( m_NetworkedDynamicAttributesForDemos ), &REFERENCE_SEND_TABLE( DT_AttributeList ) ),
|
|
#else
|
|
RecvPropInt( RECVINFO( m_iItemDefinitionIndex ) ),
|
|
RecvPropInt( RECVINFO( m_iEntityLevel ) ),
|
|
//RecvPropInt( RECVINFO( m_iItemID ) ),
|
|
RecvPropInt( RECVINFO( m_iItemIDHigh ) ),
|
|
RecvPropInt( RECVINFO( m_iItemIDLow ) ),
|
|
RecvPropInt( RECVINFO( m_iAccountID ) ),
|
|
RecvPropInt( RECVINFO( m_iEntityQuality ) ),
|
|
RecvPropBool( RECVINFO( m_bInitialized ) ),
|
|
RecvPropBool( RECVINFO( m_bOnlyIterateItemViewAttributes ) ),
|
|
RecvPropDataTable(RECVINFO_DT(m_AttributeList), 0, &REFERENCE_RECV_TABLE(DT_AttributeList)),
|
|
RecvPropInt( RECVINFO( m_iTeamNumber ) ),
|
|
RecvPropDataTable( RECVINFO_DT( m_NetworkedDynamicAttributesForDemos ), 0, &REFERENCE_RECV_TABLE( DT_AttributeList ) ),
|
|
#endif // CLIENT_DLL
|
|
END_NETWORK_TABLE()
|
|
|
|
BEGIN_DATADESC_NO_BASE( CEconItemView )
|
|
DEFINE_FIELD( m_iItemDefinitionIndex, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_iEntityQuality, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_iEntityLevel, FIELD_INTEGER ),
|
|
DEFINE_FIELD( m_iItemID, FIELD_INTEGER ),
|
|
// DEFINE_FIELD( m_wszItemName, FIELD_STRING ), Regenerated post-save
|
|
// DEFINE_FIELD( m_szItemName, FIELD_STRING ), Regenerated post-save
|
|
// DEFINE_FIELD( m_szAttributeDescription, FIELD_STRING ), Regenerated post-save
|
|
// m_AttributeLineColors // Regenerated post-save
|
|
// m_Attributes // Custom handling in Save()/Restore()
|
|
DEFINE_FIELD( m_bInitialized, FIELD_BOOLEAN ),
|
|
DEFINE_FIELD( m_bOnlyIterateItemViewAttributes, FIELD_BOOLEAN ),
|
|
DEFINE_EMBEDDED( m_AttributeList ),
|
|
DEFINE_EMBEDDED( m_NetworkedDynamicAttributesForDemos ),
|
|
END_DATADESC()
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconItemView::CEconItemView( void )
|
|
{
|
|
m_iItemDefinitionIndex = INVALID_ITEM_DEF_INDEX;
|
|
m_iEntityQuality = (int)AE_UNDEFINED;
|
|
m_iEntityLevel = 0;
|
|
SetItemID( INVALID_ITEM_ID );
|
|
m_iInventoryPosition = 0;
|
|
m_bInitialized = false;
|
|
m_bOnlyIterateItemViewAttributes = false;
|
|
m_iAccountID = 0;
|
|
m_pNonSOEconItem = NULL;
|
|
m_bColorInit = false;
|
|
m_bPaintOverrideInit = false;
|
|
m_bHasPaintOverride = false;
|
|
m_flOverrideIndex = 0.f;
|
|
#if defined( CLIENT_DLL )
|
|
m_bIsTradeItem = false;
|
|
m_iEntityQuantity = 1;
|
|
m_unClientFlags = 0;
|
|
m_unOverrideStyle = INVALID_STYLE_INDEX;
|
|
m_unOverrideOrigin = kEconItemOrigin_Max;
|
|
#endif
|
|
#if BUILD_ITEM_NAME_AND_DESC
|
|
m_pDescription = NULL;
|
|
m_pszGrayedOutReason = NULL;
|
|
#endif
|
|
|
|
#ifdef CLIENT_DLL
|
|
m_pWeaponSkinBase = NULL;
|
|
m_pWeaponSkinBaseCompositor = NULL;
|
|
m_iLastGeneratedTeamSkin = TF_TEAM_RED;
|
|
m_bWeaponSkinUseHighRes = false;
|
|
m_bWeaponSkinUseLowRes = false;
|
|
#endif // CLIENT_DLL
|
|
|
|
m_iTeamNumber = TF_TEAM_RED;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconItemView::~CEconItemView( void )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
SafeRelease( &m_pWeaponSkinBase );
|
|
SafeRelease( &m_pWeaponSkinBaseCompositor );
|
|
#endif // CLIENT_DLL
|
|
|
|
DestroyAllAttributes();
|
|
|
|
#if BUILD_ITEM_NAME_AND_DESC
|
|
MarkDescriptionDirty();
|
|
free( m_pszGrayedOutReason );
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconItemView::CEconItemView( const CEconItemView &src )
|
|
{
|
|
#if BUILD_ITEM_NAME_AND_DESC
|
|
m_pDescription = NULL;
|
|
m_pszGrayedOutReason = NULL;
|
|
#endif
|
|
|
|
#ifdef CLIENT_DLL
|
|
// Need to null these out here for initial behavior.
|
|
m_pWeaponSkinBase = NULL;
|
|
m_pWeaponSkinBaseCompositor = NULL;
|
|
m_nWeaponSkinGeneration = 0;
|
|
m_iLastGeneratedTeamSkin = TF_TEAM_RED;
|
|
m_unWeaponSkinBaseCreateFlags = 0;
|
|
m_bWeaponSkinUseHighRes = src.m_bWeaponSkinUseHighRes;
|
|
m_bWeaponSkinUseLowRes = src.m_bWeaponSkinUseLowRes;
|
|
#endif //CLIENT_DLL
|
|
|
|
m_iTeamNumber = src.m_iTeamNumber; // keep the same team from the first creation
|
|
|
|
*this = src;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemView::Init( int iDefIndex, int iQuality, int iLevel, uint32 iAccountID )
|
|
{
|
|
m_AttributeList.Init();
|
|
m_NetworkedDynamicAttributesForDemos.Init();
|
|
|
|
m_iItemDefinitionIndex = iDefIndex;
|
|
CEconItemDefinition *pData = GetStaticData();
|
|
if ( !pData )
|
|
{
|
|
// We've got an item that we don't have static data for.
|
|
return;
|
|
}
|
|
|
|
SetItemID( INVALID_ITEM_ID );
|
|
m_bInitialized = true;
|
|
m_iAccountID = iAccountID;
|
|
|
|
if ( iQuality == AE_USE_SCRIPT_VALUE )
|
|
{
|
|
m_iEntityQuality = pData->GetQuality();
|
|
|
|
// Kyle says: this is a horrible hack because AE_UNDEFINED will get stuffed into a uint8 when
|
|
// loaded into the item definition, but then read back out into a regular int here.
|
|
if ( m_iEntityQuality == (uint8)AE_UNDEFINED )
|
|
{
|
|
m_iEntityQuality = (int)AE_NORMAL;
|
|
}
|
|
}
|
|
else if ( iQuality == k_unItemQuality_Any )
|
|
{
|
|
m_iEntityQuality = (int)AE_RARITY1;
|
|
}
|
|
else
|
|
{
|
|
m_iEntityQuality = iQuality;
|
|
}
|
|
|
|
if ( iLevel == AE_USE_SCRIPT_VALUE )
|
|
{
|
|
m_iEntityLevel = pData->RollItemLevel();
|
|
}
|
|
else
|
|
{
|
|
m_iEntityLevel = iLevel;
|
|
}
|
|
|
|
// We made changes to quality, level, etc. so mark the description as dirty.
|
|
MarkDescriptionDirty();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconItemView& CEconItemView::operator=( const CEconItemView& src )
|
|
{
|
|
m_iItemDefinitionIndex = src.m_iItemDefinitionIndex;
|
|
m_iEntityQuality = src.m_iEntityQuality;
|
|
m_iEntityLevel = src.m_iEntityLevel;
|
|
SetItemID( src.GetItemID() );
|
|
m_iInventoryPosition = src.m_iInventoryPosition;
|
|
m_bInitialized = src.m_bInitialized;
|
|
m_bOnlyIterateItemViewAttributes = src.m_bOnlyIterateItemViewAttributes;
|
|
m_iAccountID = src.m_iAccountID;
|
|
SetNonSOEconItem(src.m_pNonSOEconItem);
|
|
m_bColorInit = false; // reset Color init
|
|
m_bPaintOverrideInit = false;
|
|
m_bHasPaintOverride = false;
|
|
m_flOverrideIndex = 0.f;
|
|
#ifdef CLIENT_DLL
|
|
m_iLastGeneratedTeamSkin = src.m_iLastGeneratedTeamSkin;
|
|
m_bIsTradeItem = src.m_bIsTradeItem;
|
|
m_iEntityQuantity = src.m_iEntityQuantity;
|
|
m_unClientFlags = src.m_unClientFlags;
|
|
m_unOverrideStyle = src.m_unOverrideStyle;
|
|
m_unOverrideOrigin = src.m_unOverrideOrigin;
|
|
|
|
SafeAssign( &m_pWeaponSkinBase, src.m_pWeaponSkinBase );
|
|
SafeAssign( &m_pWeaponSkinBaseCompositor, src.m_pWeaponSkinBaseCompositor );
|
|
|
|
m_nWeaponSkinGeneration = src.m_nWeaponSkinGeneration;
|
|
m_unWeaponSkinBaseCreateFlags = src.m_unWeaponSkinBaseCreateFlags;
|
|
|
|
m_bWeaponSkinUseHighRes = src.m_bWeaponSkinUseHighRes;
|
|
m_bWeaponSkinUseLowRes = src.m_bWeaponSkinUseLowRes;
|
|
|
|
#endif // CLIENT_DLL
|
|
|
|
m_iTeamNumber = src.m_iTeamNumber; // keep the same team from the first creation
|
|
|
|
DestroyAllAttributes();
|
|
|
|
m_AttributeList = src.m_AttributeList;
|
|
m_NetworkedDynamicAttributesForDemos = src.m_NetworkedDynamicAttributesForDemos;
|
|
|
|
// TODO: Copying the description pointer and refcounting it would work also.
|
|
MarkDescriptionDirty();
|
|
|
|
// Clear out any overrides we currently have, they'll get reset up on demand.
|
|
ResetMaterialOverrides();
|
|
return *this;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconItemView::operator==( const CEconItemView &other ) const
|
|
{
|
|
if ( IsValid() != other.IsValid() )
|
|
return false;
|
|
if ( ( GetItemID() != INVALID_ITEM_ID || other.GetItemID() != INVALID_ITEM_ID ) && GetItemID() != other.GetItemID() )
|
|
return false;
|
|
if ( GetItemDefIndex() != other.GetItemDefIndex() )
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
GameItemDefinition_t *CEconItemView::GetStaticData( void ) const
|
|
{
|
|
CEconItemDefinition *pRet = GetItemSchema()->GetItemDefinition( m_iItemDefinitionIndex );
|
|
GameItemDefinition_t *pTypedRet = dynamic_cast<GameItemDefinition_t *>( pRet );
|
|
|
|
AssertMsg( pRet == pTypedRet, "Item definition of inappropriate type." );
|
|
|
|
return pTypedRet;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int32 CEconItemView::GetQuality() const
|
|
{
|
|
return GetSOCData()
|
|
? GetSOCData()->GetQuality()
|
|
#ifdef TF_CLIENT_DLL
|
|
: GetFlags() & kEconItemFlagClient_StoreItem
|
|
? AE_UNIQUE
|
|
#endif
|
|
: GetOrigin() != kEconItemOrigin_Invalid
|
|
? GetItemQuality()
|
|
: AE_NORMAL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
style_index_t CEconItemView::GetStyle() const
|
|
{
|
|
return GetItemStyle();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
uint8 CEconItemView::GetFlags() const
|
|
{
|
|
uint8 unSOCFlags = GetSOCData() ? GetSOCData()->GetFlags() : 0;
|
|
|
|
#if !defined( GAME_DLL )
|
|
return unSOCFlags | m_unClientFlags;
|
|
#else // defined( GAME_DLL )
|
|
return unSOCFlags;
|
|
#endif // !defined( GAME_DLL )
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
eEconItemOrigin CEconItemView::GetOrigin() const
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
if( m_unOverrideOrigin != kEconItemOrigin_Max )
|
|
{
|
|
return m_unOverrideOrigin;
|
|
}
|
|
#endif//CLIENT_DLL
|
|
|
|
return GetSOCData() ? GetSOCData()->GetOrigin() : kEconItemOrigin_Invalid;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CEconItemView::GetQuantity() const
|
|
{
|
|
return GetItemQuantity();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const char *CEconItemView::GetCustomName() const
|
|
{
|
|
return GetSOCData() ? GetSOCData()->GetCustomName() : NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const char *CEconItemView::GetCustomDesc() const
|
|
{
|
|
return GetSOCData() ? GetSOCData()->GetCustomDesc() : NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemView::IterateAttributes( class IEconItemAttributeIterator *pIterator ) const
|
|
{
|
|
Assert( pIterator );
|
|
|
|
// Note if we have network attribs, because m_NetworkedDynamicAttributesForDemos might be the iterator
|
|
// which we're about to fill up below.
|
|
const bool bHasNetworkedAttribsForDemos = m_NetworkedDynamicAttributesForDemos.GetNumAttributes() > 0;
|
|
|
|
// First, we iterate over the attributes we have local copies of. If we have any attribute
|
|
// values here they'll override whatever values we would otherwise have pulled from our
|
|
// definition/CEconItem.
|
|
const CAttributeList *pAttrList = GetAttributeList();
|
|
if ( pAttrList )
|
|
{
|
|
pAttrList->IterateAttributes( pIterator );
|
|
}
|
|
|
|
if ( m_bOnlyIterateItemViewAttributes )
|
|
return;
|
|
|
|
// This wraps any other iterator class and will prevent double iteration of any attributes
|
|
// that exist on us.
|
|
class CEconItemAttributeIterator_EconItemViewWrapper : public IEconItemAttributeIterator
|
|
{
|
|
public:
|
|
CEconItemAttributeIterator_EconItemViewWrapper( const CEconItemView *pEconItemView, IEconItemAttributeIterator *pIterator )
|
|
: m_pEconItemView( pEconItemView )
|
|
, m_pIterator( pIterator )
|
|
{
|
|
Assert( m_pEconItemView );
|
|
Assert( m_pIterator );
|
|
}
|
|
|
|
virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, attrib_value_t value )
|
|
{
|
|
Assert( pAttrDef );
|
|
|
|
return m_pEconItemView->GetAttributeList()->GetAttributeByID( pAttrDef->GetDefinitionIndex() )
|
|
? true
|
|
: m_pIterator->OnIterateAttributeValue( pAttrDef, value );
|
|
}
|
|
|
|
virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, float value )
|
|
{
|
|
Assert( pAttrDef );
|
|
|
|
return m_pEconItemView->GetAttributeList()->GetAttributeByID( pAttrDef->GetDefinitionIndex() )
|
|
? true
|
|
: m_pIterator->OnIterateAttributeValue( pAttrDef, value );
|
|
}
|
|
|
|
virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const uint64& value )
|
|
{
|
|
Assert( pAttrDef );
|
|
|
|
return m_pEconItemView->GetAttributeList()->GetAttributeByID( pAttrDef->GetDefinitionIndex() )
|
|
? true
|
|
: m_pIterator->OnIterateAttributeValue( pAttrDef, value );
|
|
}
|
|
|
|
virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_String& value )
|
|
{
|
|
Assert( pAttrDef );
|
|
|
|
return m_pEconItemView->GetAttributeList()->GetAttributeByID( pAttrDef->GetDefinitionIndex() )
|
|
? true
|
|
: m_pIterator->OnIterateAttributeValue( pAttrDef, value );
|
|
}
|
|
|
|
virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_DynamicRecipeComponent& value )
|
|
{
|
|
Assert( pAttrDef );
|
|
|
|
return m_pEconItemView->GetAttributeList()->GetAttributeByID( pAttrDef->GetDefinitionIndex() )
|
|
? true
|
|
: m_pIterator->OnIterateAttributeValue( pAttrDef, value );
|
|
}
|
|
|
|
virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_ItemSlotCriteria& value )
|
|
{
|
|
Assert( pAttrDef );
|
|
|
|
return m_pEconItemView->GetAttributeList()->GetAttributeByID( pAttrDef->GetDefinitionIndex() )
|
|
? true
|
|
: m_pIterator->OnIterateAttributeValue( pAttrDef, value );
|
|
}
|
|
|
|
virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_WorldItemPlacement& value )
|
|
{
|
|
Assert( pAttrDef );
|
|
|
|
return m_pEconItemView->GetAttributeList()->GetAttributeByID( pAttrDef->GetDefinitionIndex() )
|
|
? true
|
|
: m_pIterator->OnIterateAttributeValue( pAttrDef, value );
|
|
}
|
|
|
|
private:
|
|
const CEconItemView *m_pEconItemView;
|
|
IEconItemAttributeIterator *m_pIterator;
|
|
};
|
|
|
|
CEconItemAttributeIterator_EconItemViewWrapper iteratorWrapper( this, pIterator );
|
|
|
|
// Next, iterate over our database-backed item if we have one... if we do have a DB
|
|
// backing for our item here, that will also feed in the definition attributes.
|
|
CEconItem *pEconItem = GetSOCData();
|
|
if ( pEconItem )
|
|
{
|
|
pEconItem->IterateAttributes( &iteratorWrapper );
|
|
}
|
|
else if ( GetItemID() != INVALID_ITEM_ID && bHasNetworkedAttribsForDemos )
|
|
{
|
|
// Since there's no persistent data available, try the networked values!
|
|
// note: only copies the default type and floats
|
|
m_NetworkedDynamicAttributesForDemos.IterateAttributes( &iteratorWrapper );
|
|
}
|
|
// If we didn't have a DB backing, we can still iterate over our item definition
|
|
// attributes ourselves. This can happen if we're previewing an item in the store, etc.
|
|
else if ( GetStaticData() )
|
|
{
|
|
GetStaticData()->IterateAttributes( &iteratorWrapper );
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemView::EnsureDescriptionIsBuilt() const
|
|
{
|
|
#if BUILD_ITEM_NAME_AND_DESC
|
|
if ( m_pDescription )
|
|
{
|
|
return;
|
|
}
|
|
|
|
m_pDescription = new CEconItemDescription;
|
|
|
|
IEconItemDescription::YieldingFillOutEconItemDescription( m_pDescription, GLocalizationProvider(), this );
|
|
|
|
// We use the empty string to mean "grey out but don't specify a user-facing reason".
|
|
if ( m_pszGrayedOutReason && m_pszGrayedOutReason[0] )
|
|
{
|
|
m_pDescription->AddEmptyDescLine();
|
|
m_pDescription->LocalizedAddDescLine( GLocalizationProvider(), m_pszGrayedOutReason, ATTRIB_COL_NEGATIVE, kDescLineFlag_Misc );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemView::MarkDescriptionDirty()
|
|
{
|
|
#if BUILD_ITEM_NAME_AND_DESC
|
|
if ( m_pDescription )
|
|
{
|
|
delete m_pDescription;
|
|
m_pDescription = NULL;
|
|
}
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemView::SetGrayedOutReason( const char *pszGrayedOutReason )
|
|
{
|
|
#if BUILD_ITEM_NAME_AND_DESC
|
|
if ( m_pszGrayedOutReason )
|
|
{
|
|
free( m_pszGrayedOutReason );
|
|
m_pszGrayedOutReason = NULL;
|
|
}
|
|
|
|
if ( pszGrayedOutReason )
|
|
{
|
|
m_pszGrayedOutReason = strdup(pszGrayedOutReason);
|
|
}
|
|
|
|
MarkDescriptionDirty();
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CEconItemView::GetItemQuantity() const
|
|
{
|
|
CEconItem *pSOCData = GetSOCData();
|
|
if ( pSOCData )
|
|
{
|
|
return pSOCData->GetQuantity();
|
|
}
|
|
#ifdef CLIENT_DLL
|
|
return m_iEntityQuantity;
|
|
#else
|
|
return 1;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
style_index_t CEconItemView::GetItemStyle() const
|
|
{
|
|
#ifdef STAGING_ONLY
|
|
if ( econ_force_style_index.GetInt() != -1 )
|
|
return econ_force_style_index.GetInt();
|
|
#endif // STAGING_ONLY
|
|
|
|
#ifdef CLIENT_DLL
|
|
// Are we overriding the backing store style?
|
|
if ( m_unOverrideStyle != INVALID_STYLE_INDEX )
|
|
return m_unOverrideStyle;
|
|
#endif // CLIENT_DLL
|
|
|
|
static CSchemaAttributeDefHandle pAttrDef_ItemStyleOverride( "item style override" );
|
|
float fStyleOverride = 0.f;
|
|
if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( this, pAttrDef_ItemStyleOverride, &fStyleOverride ) )
|
|
{
|
|
return fStyleOverride;
|
|
}
|
|
|
|
static CSchemaAttributeDefHandle pAttrDef_ItemStyleStrange( "style changes on strange level" );
|
|
uint32 iMaxStyle = 0;
|
|
if ( pAttrDef_ItemStyleStrange && FindAttribute( pAttrDef_ItemStyleStrange, &iMaxStyle ) )
|
|
{
|
|
// Use the strange prefix if the weapon has one.
|
|
uint32 unScore = 0;
|
|
if ( !FindAttribute( GetKillEaterAttr_Score( 0 ), &unScore ) )
|
|
return 0;
|
|
|
|
// What type of event are we tracking and how does it describe itself?
|
|
uint32 unKillEaterEventType = 0;
|
|
// This will overwrite our default 0 value if we have a value set but leave it if not.
|
|
float fKillEaterEventType;
|
|
if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( this, GetKillEaterAttr_Type( 0 ), &fKillEaterEventType ) )
|
|
{
|
|
unKillEaterEventType = fKillEaterEventType;
|
|
}
|
|
|
|
const char *pszLevelingDataName = GetItemSchema()->GetKillEaterScoreTypeLevelingDataName( unKillEaterEventType );
|
|
if ( !pszLevelingDataName )
|
|
{
|
|
pszLevelingDataName = KILL_EATER_RANK_LEVEL_BLOCK_NAME;
|
|
}
|
|
|
|
const CItemLevelingDefinition *pLevelDef = GetItemSchema()->GetItemLevelForScore( pszLevelingDataName, unScore );
|
|
if ( !pLevelDef )
|
|
return 0;
|
|
|
|
return Min( pLevelDef->GetLevel(), iMaxStyle );
|
|
}
|
|
|
|
|
|
CEconItem *pSOCData = GetSOCData();
|
|
if ( pSOCData )
|
|
return pSOCData->GetStyle();
|
|
|
|
return INVALID_STYLE_INDEX;
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemView::SetClientItemFlags( uint8 unFlags )
|
|
{
|
|
// Generally speaking, we have two uses for client flags:
|
|
//
|
|
// - we don't have a backing store (a real CEconItem) but want to pretend we do
|
|
// for purposes of generating tooltips, graying out icons, etc.
|
|
//
|
|
// - we may or may not have a backing store but want to shove client-specific
|
|
// information into the structure -- things like "this is the item being
|
|
// actively previewed", etc.
|
|
//
|
|
// If neither of these two cases is true, then we're going to get unexpected
|
|
// behavior where the GC and the client disagree about the item flags and then
|
|
// Terrible Things happen. We assert to make sure we're in one of the above cases.
|
|
Assert( !GetSOCData() || (unFlags & kEconItemFlags_CheckFlags_AllGCFlags) == 0 );
|
|
|
|
m_unClientFlags = unFlags;
|
|
MarkDescriptionDirty();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemView::SetItemStyleOverride( style_index_t unNewStyleOverride )
|
|
{
|
|
// We should only ever override the style on items that don't have a real
|
|
// backing store or we'll start getting disagreements about what the client
|
|
// wants to happen and what's being stored on the GC. Unfortunately we can't
|
|
// assert on this because we do it sometimes when previewing items.
|
|
//Assert( !GetSOCData() );
|
|
|
|
m_unOverrideStyle = unNewStyleOverride;
|
|
MarkDescriptionDirty();
|
|
}
|
|
|
|
|
|
void CEconItemView::SetItemOriginOverride( eEconItemOrigin unNewOriginOverride )
|
|
{
|
|
Assert( !GetSOCData() || m_pNonSOEconItem );
|
|
Assert( unNewOriginOverride >= kEconItemOrigin_Invalid );
|
|
Assert( unNewOriginOverride <= kEconItemOrigin_Max ); // Allow max. We ignore this value if it's max
|
|
|
|
m_unOverrideOrigin = unNewOriginOverride;
|
|
}
|
|
#endif // CLIENT_DLL
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconItem *CEconItemView::GetSOCData( void ) const
|
|
{
|
|
if ( m_pNonSOEconItem )
|
|
return m_pNonSOEconItem;
|
|
|
|
#ifdef CLIENT_DLL
|
|
// We need to find the inventory that contains this item. If we're not connected
|
|
// to a server, and the owner is the same as the local player, use the local inventory.
|
|
// We need to do this for trading, since we are subscribed to the other person's cache.
|
|
if ( !engine->IsInGame() && InventoryManager()->GetLocalInventory()->GetOwner().GetAccountID() == m_iAccountID )
|
|
return InventoryManager()->GetLocalInventory()->GetSOCDataForItem( GetItemID() );
|
|
#endif // CLIENT_DLL
|
|
|
|
// We're in-game. Find the inventory with our account ID.
|
|
CPlayerInventory *pInventory = InventoryManager()->GetInventoryForAccount( m_iAccountID );
|
|
if ( pInventory )
|
|
return pInventory->GetSOCDataForItem( GetItemID() );
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the model to use for model panels containing this item
|
|
//-----------------------------------------------------------------------------
|
|
const char *CEconItemView::GetInventoryModel( void )
|
|
{
|
|
if ( !GetStaticData() )
|
|
return NULL;
|
|
return GetStaticData()->GetInventoryModel();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the image to use for model panels containing this item
|
|
//-----------------------------------------------------------------------------
|
|
const char *CEconItemView::GetInventoryImage( void )
|
|
{
|
|
if ( !GetStaticData() )
|
|
return NULL;
|
|
|
|
// Do we have a style set?
|
|
const char* pStyleImage = NULL;
|
|
if ( GetStaticData()->GetNumStyles() )
|
|
pStyleImage = GetStaticData()->GetStyleInventoryImage( GetItemStyle() );
|
|
|
|
if ( pStyleImage && *pStyleImage )
|
|
return pStyleImage;
|
|
|
|
return GetStaticData()->GetInventoryImage();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the drawing data for the image to use for model panels containing this item
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconItemView::GetInventoryImageData( int *iPosition, int *iSize )
|
|
{
|
|
if ( !GetStaticData() )
|
|
return false;
|
|
for ( int i = 0; i < 2; i++ )
|
|
{
|
|
iPosition[i] = GetStaticData()->GetInventoryImagePosition(i);
|
|
iSize[i] = GetStaticData()->GetInventoryImageSize(i);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the image to use for model panels containing this item
|
|
//-----------------------------------------------------------------------------
|
|
const char *CEconItemView::GetInventoryOverlayImage( int idx )
|
|
{
|
|
if ( !GetStaticData() )
|
|
return NULL;
|
|
return GetStaticData()->GetInventoryOverlayImage( idx );
|
|
}
|
|
|
|
int CEconItemView::GetInventoryOverlayImageCount( void )
|
|
{
|
|
if ( !GetStaticData() )
|
|
return 0;
|
|
return GetStaticData()->GetInventoryOverlayImageCount();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the model to use when displaying this model on the player character model, if any
|
|
//-----------------------------------------------------------------------------
|
|
const char *CEconItemView::GetPlayerDisplayModel( int iClass, int iTeam ) const
|
|
{
|
|
const CEconItemDefinition *pDef = GetStaticData();
|
|
if ( !pDef )
|
|
return NULL;
|
|
|
|
// If we have styles, give the style system a chance to change the mesh used for this
|
|
// player class.
|
|
if ( pDef->GetNumStyles() )
|
|
{
|
|
style_index_t unStyle = GetItemStyle();
|
|
|
|
const CEconStyleInfo *pStyle = pDef->GetStyleInfo( unStyle );
|
|
|
|
// It's possible to get back a NULL pStyle if GetItemStyle() returns INVALID_STYLE_INDEX.
|
|
if ( pStyle )
|
|
{
|
|
#if defined( TF_DLL ) || defined( TF_CLIENT_DLL )
|
|
// TF styles support per-class models.
|
|
const CTFStyleInfo *pTFStyle = assert_cast<const CTFStyleInfo *>( pStyle );
|
|
if ( pTFStyle->GetPlayerDisplayModel( iClass, iTeam ) )
|
|
return pTFStyle->GetPlayerDisplayModel( iClass, iTeam );
|
|
#endif // defined( TF_DLL ) || defined( TF_CLIENT_DLL )
|
|
|
|
if ( pStyle->GetBasePlayerDisplayModel() )
|
|
return pStyle->GetBasePlayerDisplayModel();
|
|
}
|
|
}
|
|
|
|
#if defined( TF_DLL ) || defined( TF_CLIENT_DLL )
|
|
// If we don't have a style, we still a couple potential overrides.
|
|
if ( iClass >= 0 && iClass < LOADOUT_COUNT )
|
|
{
|
|
// We don't support overriding meshes in the visuals section, but we might still be overriding
|
|
// the model for each class at the schema level.
|
|
const CTFItemDefinition *pTFDef = dynamic_cast<const CTFItemDefinition *>( pDef );
|
|
if ( pTFDef )
|
|
{
|
|
const char *pszModel = pTFDef->GetPlayerDisplayModel(iClass);
|
|
if ( pszModel && pszModel[0] )
|
|
return pszModel;
|
|
}
|
|
}
|
|
#endif // defined( TF_DLL ) || defined( TF_CLIENT_DLL )
|
|
|
|
return pDef->GetBasePlayerDisplayModel();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CEconItemView::GetSkin( int iTeam, bool bViewmodel /*= false*/ ) const
|
|
{
|
|
int iDefaultSkin = -1;
|
|
#ifndef CSTRIKE_DLL
|
|
// Immediately abort if we're out of range.
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS )
|
|
return 0;
|
|
|
|
// Do we have a style set?
|
|
if ( GetStaticData()->GetNumStyles() )
|
|
return GetStaticData()->GetStyleSkin( GetItemStyle(), iTeam, bViewmodel );
|
|
|
|
iTeam = GetStaticData()->GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS )
|
|
return -1;
|
|
|
|
// Do we have per-team skins set?
|
|
const perteamvisuals_t *pVisData = GetStaticData()->GetPerTeamVisual( iTeam );
|
|
if ( pVisData )
|
|
return pVisData->iSkin;
|
|
|
|
iDefaultSkin = GetItemDefinition()->GetDefaultSkin();
|
|
#endif
|
|
|
|
// Fallback case.
|
|
return iDefaultSkin;
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handle assignment for textures, which involves some reference counting shenanigans.
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemView::SetWeaponSkinBase( ITexture* pBaseTex )
|
|
{
|
|
SafeAssign( &m_pWeaponSkinBase, pBaseTex );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Handle assignment for compositors, which involves some reference counting shenanigans.
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemView::SetWeaponSkinBaseCompositor( ITextureCompositor * pTexCompositor )
|
|
{
|
|
SafeAssign( &m_pWeaponSkinBaseCompositor, pTexCompositor );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Cancels a pending composite, if one is currently in process.
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemView::CancelWeaponSkinComposite( )
|
|
{
|
|
SafeRelease( &m_pWeaponSkinBaseCompositor );
|
|
}
|
|
#endif // CLIENT_DLL
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const char *CEconItemView::GetWorldDisplayModel() const
|
|
{
|
|
CEconItemDefinition *pData = GetStaticData();
|
|
if ( !pData )
|
|
return NULL;
|
|
|
|
return pData->GetWorldDisplayModel();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const char *CEconItemView::GetExtraWearableModel() const
|
|
{
|
|
CEconItemDefinition *pData = GetStaticData();
|
|
if ( !pData )
|
|
return NULL;
|
|
|
|
return pData->GetExtraWearableModel();
|
|
}
|
|
|
|
const char *CEconItemView::GetExtraWearableViewModel() const
|
|
{
|
|
CEconItemDefinition *pData = GetStaticData();
|
|
if ( !pData )
|
|
return NULL;
|
|
|
|
return pData->GetExtraWearableViewModel();
|
|
}
|
|
|
|
const char *CEconItemView::GetVisionFilteredDisplayModel() const
|
|
{
|
|
CEconItemDefinition *pData = GetStaticData();
|
|
if ( !pData )
|
|
return NULL;
|
|
|
|
return pData->GetVisionFilteredDisplayModel();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CEconItemView::GetQualityParticleType() const
|
|
{
|
|
static CSchemaParticleHandle pSparkleSystem( "community_sparkle" );
|
|
|
|
CEconItem* pItem = GetSOCData();
|
|
if ( !pItem )
|
|
return 0;
|
|
|
|
if( GetSOCData()->GetQuality() == AE_SELFMADE || GetSOCData()->GetQuality() == AE_COMMUNITY )
|
|
return pSparkleSystem ? pSparkleSystem->nSystemID : 0;
|
|
else
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return the animation set that this item wants the player to use (ie., melee, item1, pda)
|
|
//-----------------------------------------------------------------------------
|
|
int CEconItemView::GetAnimationSlot( void ) const
|
|
{
|
|
if ( !GetStaticData() )
|
|
return -1;
|
|
|
|
#if defined( CSTRIKE_DLL ) || defined( DOTA_DLL )
|
|
return -1;
|
|
#else
|
|
return GetStaticData()->GetAnimSlot();
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Return an int that indicates whether the item should be dropped from a dead owner.
|
|
//-----------------------------------------------------------------------------
|
|
int CEconItemView::GetDropType( void )
|
|
{
|
|
if ( !GetStaticData() )
|
|
return 0;
|
|
return GetStaticData()->GetDropType();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemView::DestroyAllAttributes( void )
|
|
{
|
|
m_AttributeList.DestroyAllAttributes();
|
|
m_NetworkedDynamicAttributesForDemos.DestroyAllAttributes();
|
|
NetworkStateChanged();
|
|
MarkDescriptionDirty();
|
|
}
|
|
|
|
extern const char *g_EffectTypes[NUM_EFFECT_TYPES];
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
#ifdef CLIENT_DLL
|
|
const wchar_t *CEconItemView::GetItemName() const
|
|
{
|
|
static const wchar_t *pwzDefaultName = L"";
|
|
|
|
const CEconItemDescription *pDescription = GetDescription();
|
|
if ( !pDescription )
|
|
return pwzDefaultName;
|
|
|
|
const econ_item_description_line_t *pNameDescLine = pDescription->GetFirstLineWithMetaType( kDescLineFlag_Name );
|
|
if ( !pNameDescLine )
|
|
return pwzDefaultName;
|
|
|
|
return pNameDescLine->sText.Get();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemView::GetRenderBounds( Vector& mins, Vector& maxs )
|
|
{
|
|
const CEconItemDefinition *pDef = GetStaticData();
|
|
if ( !pDef )
|
|
return;
|
|
|
|
int iClass = 0;
|
|
int iTeam = 0;
|
|
|
|
#ifdef TF_CLIENT_DLL
|
|
C_TFPlayer *pTFPlayer = ToTFPlayer( GetPlayerByAccountID( GetAccountID() ) );
|
|
if ( pTFPlayer )
|
|
{
|
|
iClass = pTFPlayer->GetPlayerClass()->GetClassIndex();
|
|
iTeam = pTFPlayer->GetTeamNumber();
|
|
}
|
|
#endif // TF_CLIENT_DLL
|
|
|
|
const char * pszModel = GetPlayerDisplayModel( iClass, iTeam );
|
|
if ( !pszModel )
|
|
return;
|
|
|
|
int iIndex = modelinfo->GetModelIndex( pszModel );
|
|
|
|
if ( iIndex == -1 )
|
|
{
|
|
// hard load the model to get its bounds
|
|
MDLHandle_t hMDLFindResult = g_pMDLCache->FindMDL( pszModel );
|
|
MDLHandle_t hMDL = pszModel ? hMDLFindResult : MDLHANDLE_INVALID;
|
|
if ( g_pMDLCache->IsErrorModel( hMDL ) )
|
|
return;
|
|
|
|
const studiohdr_t * pStudioHdr = g_pMDLCache->GetStudioHdr( hMDL );
|
|
VectorCopy( pStudioHdr->hull_min, mins );
|
|
VectorCopy( pStudioHdr->hull_max, maxs );
|
|
|
|
g_pMDLCache->Release( hMDLFindResult );
|
|
}
|
|
else
|
|
{
|
|
const model_t *pModel = modelinfo->GetModel( iIndex );
|
|
modelinfo->GetModelRenderBounds( pModel, mins, maxs );
|
|
}
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CEconItemView::InitNetworkedDynamicAttributesForDemos( void )
|
|
{
|
|
if ( !GetSOCData() )
|
|
return;
|
|
|
|
class CEconDynamicAttributesForDemosIterator : public CEconItemSpecificAttributeIterator
|
|
{
|
|
public:
|
|
CEconDynamicAttributesForDemosIterator( CAttributeList* out_NetworkedDynamicAttributesForDemos )
|
|
: m_NetworkedDynamicAttributesForDemos( out_NetworkedDynamicAttributesForDemos )
|
|
{
|
|
m_bAdded = false;
|
|
}
|
|
|
|
virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, attrib_value_t value ) OVERRIDE
|
|
{
|
|
CEconItemAttribute attribute( pAttrDef->GetDefinitionIndex(), value );
|
|
m_NetworkedDynamicAttributesForDemos->AddAttribute( &attribute );
|
|
m_bAdded = true;
|
|
return true;
|
|
}
|
|
|
|
virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, float value ) OVERRIDE
|
|
{
|
|
CEconItemAttribute attribute( pAttrDef->GetDefinitionIndex(), value );
|
|
m_NetworkedDynamicAttributesForDemos->AddAttribute( &attribute );
|
|
m_bAdded = true;
|
|
return true;
|
|
}
|
|
|
|
bool BAdded( void ){ return m_bAdded; }
|
|
|
|
private:
|
|
bool m_bAdded;
|
|
CAttributeList *m_NetworkedDynamicAttributesForDemos;
|
|
};
|
|
|
|
m_NetworkedDynamicAttributesForDemos.DestroyAllAttributes();
|
|
|
|
CEconDynamicAttributesForDemosIterator it( &m_NetworkedDynamicAttributesForDemos );
|
|
IterateAttributes( &it );
|
|
|
|
if ( it.BAdded() )
|
|
{
|
|
NetworkStateChanged();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
static int RemapOverridePaintIndexToRGB( uint32 unIndex, uint32 unTeamIndex )
|
|
{
|
|
enum { kSamplePoints = 256, };
|
|
|
|
static uint32 k_unWitchYellow[] = {
|
|
5328971, 5328971, 5328971, 5328971, 5328971, 5328971, 5328971, 5328971,
|
|
5328971, 5328971, 5395018, 5591625, 5723465, 5855050, 5921095, 6052679,
|
|
6315591, 6447429, 6513222, 6710852, 7039299, 7170884, 7433793, 7631425,
|
|
7894336, 8222784, 8354622, 8618045, 8815420, 9078333, 9406779, 9604411,
|
|
9802040, 10064952, 10328376, 10459959, 10722870, 11051318, 11314483, 11511859,
|
|
11709490, 11841074, 12103729, 12301360, 12498479, 12630063, 12761901, 12959022,
|
|
13090604, 13156651, 13288236, 13485099, 13616683, 13682474, 13748010, 13813801,
|
|
13945386, 13945386, 14011433, 14011433, 14011433, 13945386, 13945386, 13879594,
|
|
13814314, 13813801, 13748010, 13682474, 13616681, 13616683, 13550890, 13550890,
|
|
13354027, 13288234, 13288236, 13222443, 13222443, 13156651, 13156651, 13025322,
|
|
13025324, 12959531, 12893740, 12893740, 12893740, 12762413, 12696621, 12696621,
|
|
12630828, 12630574, 12630574, 12499760, 12433713, 12433713, 12367922, 12302642,
|
|
12302387, 12236596, 12236598, 12171575, 12105528, 12039736, 11908409, 11974204,
|
|
11908413, 11842880, 11842880, 11842880, 11908421, 11776837, 11645765, 11579973,
|
|
11579975, 11514182, 11448137, 11382344, 11316298, 11184712, 11053387, 11053387,
|
|
10921802, 10855755, 10724941, 10659150, 10658896, 10527311, 10527057, 10395986,
|
|
10330195, 10264147, 10264147, 10264149, 10263895, 10198104, 10132313, 10198106,
|
|
10132058, 10263133, 10263133, 10328928, 10394721, 10394723, 10328675, 10394981,
|
|
10460263, 10526056, 10329190, 10394983, 10329188, 10394723, 10328928, 10328926,
|
|
10526042, 10526040, 10394452, 10459985, 10394446, 10460235, 10525511, 10525763,
|
|
10657089, 10657341, 10723131, 10854456, 10920502, 11183156, 11380273, 11512111,
|
|
11906350, 12038190, 12301100, 12629804, 12827436, 13221676, 13419306, 13616170,
|
|
13813803, 13945386, 14077226, 13879593, 13813801, 13616170, 13485099, 13221674,
|
|
12893227, 12630057, 12301098, 12103723, 11775018, 11511594, 11117353, 10853929,
|
|
10459431, 10130984, 9868327, 9670182, 9472807, 9275686, 9013027, 8815396,
|
|
8618019, 8420385, 8289569, 8223006, 8026399, 7894813, 7763484, 7829020,
|
|
7763738, 7894810, 7960857, 8158234, 8552475, 8684059, 8881690, 9079324,
|
|
9210908, 9407772, 9605405, 9671198, 9736989, 9736989, 9736991, 9605918,
|
|
9473565, 9341979, 9078809, 8684059, 8355096, 7763224, 7434010, 6973206,
|
|
6447895, 6118679, 5723416, 5394715, 5131549, 5000483, 5000234, 4999981,
|
|
5000242, 4999990, 4868407, 4671291, 4539707, 4539709, 4605502, 4671041,
|
|
4868420, 5000006, 5065799, 5131592, 5197385, 5263178, 5328971, 5263178,
|
|
};
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( k_unWitchYellow ) == kSamplePoints );
|
|
|
|
static uint32 k_unDistinctiveLackOfSanity[] =
|
|
{
|
|
5720667, 5720667, 5786460, 5720667, 5786460, 5786460, 5851996, 5851741,
|
|
6048606, 6048606, 6114145, 6114145, 6245474, 6311013, 6311013, 6441829,
|
|
6507624, 6573417, 6704491, 6704491, 6704493, 6901359, 6901359, 7097970,
|
|
7097970, 7163252, 7229045, 7294840, 7425656, 7491449, 7622523, 7688062,
|
|
7819137, 7950209, 8147077, 8277894, 8409226, 8540301, 8540303, 8671376,
|
|
8737171, 8737171, 8867985, 8671376, 8671374, 8540301, 8475019, 8475273,
|
|
8278408, 8147334, 8082309, 7885441, 7819902, 7754366, 7754621, 7558012,
|
|
7492217, 7426937, 7361142, 7164533, 7164531, 7164529, 7033456, 6967663,
|
|
6902382, 6836587, 6771564, 6771564, 6639978, 6574185, 6640232, 6508903,
|
|
6443110, 6574439, 6443110, 6442599, 6442599, 6573415, 6508392, 6573417,
|
|
6507624, 6572905, 6572905, 6572907, 6638187, 6703212, 6768494, 6834289,
|
|
6965105, 6964850, 7030132, 7029621, 7226486, 7160439, 7225720, 7356538,
|
|
7421820, 7421820, 7487102, 7617920, 7617921, 7748226, 7814021, 7879303,
|
|
7944328, 7944330, 8074635, 8271500, 8271246, 8336527, 8336529, 8598420,
|
|
8532629, 8597911, 8794521, 8859803, 8859803, 8990878, 9121440, 9120928,
|
|
9317793, 9317539, 9382823, 9448103, 9513898, 9644714, 9709995, 9840813,
|
|
9840815, 9906095, 9971890, 9971378, 10102194, 10167989, 10233269, 10364085,
|
|
10364087, 10363833, 10429369, 10429114, 10560186, 10625725, 10625468, 10691007,
|
|
10691007, 10756543, 10756289, 10756289, 10756289, 10756289, 10691007, 10625214,
|
|
10625468, 10559932, 10560186, 10429114, 10363576, 10298040, 10232501, 10101429,
|
|
10101683, 9970608, 9970608, 9773998, 9773998, 9642923, 9511848, 9511848,
|
|
9381030, 9381030, 9249956, 9053345, 8987806, 8922270, 8856731, 8725656,
|
|
8594839, 8463510, 8397971, 8201360, 8070287, 8070285, 7939211, 7807625,
|
|
7676805, 7545732, 7479937, 7283582, 7152508, 7086972, 6890361, 6759029,
|
|
6627700, 6496882, 6366064, 6300269, 6169194, 6103399, 5840997, 5775716,
|
|
5513312, 5448030, 5251162, 5054551, 5054806, 4857684, 4661073, 4595534,
|
|
4398666, 4267337, 4136776, 4070981, 4005186, 3874111, 3677502, 3480634,
|
|
3414840, 3283767, 3152951, 3152949, 3153203, 3153203, 3153460, 3153460,
|
|
3219253, 3285046, 3350839, 3416632, 3482425, 3614011, 3811133, 3942465,
|
|
4008260, 4336455, 4533321, 4664908, 4730701, 4993362, 5124948, 5256536,
|
|
5650013, 5781599, 6044003, 6175589, 6306920, 6504042, 6701167, 6898035,
|
|
7029621, 7292279, 7489404, 7686526, 7752064, 8014722, 8080261, 8277127,
|
|
};
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( k_unDistinctiveLackOfSanity ) == kSamplePoints );
|
|
|
|
static uint32 k_unOverabundanceOfRottingFlesh[] =
|
|
{
|
|
12703514, 12703514, 12703514, 12703516, 12703516, 12703514, 12572700, 12506907,
|
|
12506907, 12506652, 12506907, 12506907, 12506652, 12506652, 12506907, 12506652,
|
|
12506652, 12506652, 12506654, 12506654, 12440861, 12441374, 12441374, 12375581,
|
|
12375581, 12375583, 12375583, 12375583, 12375583, 12309536, 12309536, 12309536,
|
|
12309536, 12309537, 12112928, 12243744, 12243744, 12177697, 12046881, 12046881,
|
|
11981090, 11915299, 11915299, 11915044, 11915044, 11849253, 11783206, 11783206,
|
|
11717415, 11717417, 11651624, 11585576, 11519785, 11519787, 11453994, 11388460,
|
|
11387948, 11256621, 11190830, 11190832, 11124785, 11058993, 11058995, 10992948,
|
|
10992950, 10861364, 10795572, 10729527, 10729527, 10663736, 10597690, 10466106,
|
|
10466106, 10465852, 10400062, 10334015, 10202431, 10202433, 10136640, 10136385,
|
|
10004801, 10004803, 10004549, 9938243, 10004037, 9938244, 9938246, 9872199,
|
|
9937478, 9937224, 9871431, 9871433, 9871433, 9805640, 9870921, 9805128,
|
|
9805128, 9805128, 9805128, 9805128, 9739337, 9804360, 9804360, 9804360,
|
|
9804360, 9804360, 9869640, 9869640, 9803847, 9803847, 9803847, 9803847,
|
|
9738054, 9803334, 9737541, 9672261, 9672261, 9672261, 9606468, 9606470,
|
|
9606470, 9540677, 9475397, 9475397, 9409604, 9409604, 9212739, 9212741,
|
|
9212741, 9146948, 9081668, 9081668, 8950596, 8950596, 9015875, 9015875,
|
|
9081668, 9081668, 9081664, 8950850, 8950848, 8885568, 8819775, 8951359,
|
|
8950846, 9016894, 9016892, 9016892, 9016890, 9147962, 9016376, 9147958,
|
|
9082165, 9213494, 9081907, 9147698, 9147698, 9278768, 9212975, 9212973,
|
|
9212716, 9278508, 9212713, 9212456, 9343272, 9212454, 9343524, 9343011,
|
|
9277218, 9408034, 9342241, 9407523, 9341730, 9341730, 9341219, 9275426,
|
|
9406242, 9339938, 9339938, 9339171, 9273380, 9272613, 9272613, 9141030,
|
|
9206310, 9140519, 9140265, 9205290, 9138985, 9138985, 9138987, 9073453,
|
|
9007662, 9007150, 9007150, 9137968, 9072945, 8941618, 9138484, 9007413,
|
|
9138999, 9204788, 9270581, 9205556, 9271604, 9272115, 9469490, 9404210,
|
|
9536049, 9536817, 9603119, 9734960, 9866542, 9801772, 9999147, 9999913,
|
|
10197288, 10263848, 10264613, 10462244, 10462754, 10463776, 10661152, 10792988,
|
|
10859547, 10991642, 11057688, 11190040, 11256086, 11388435, 11520274, 11521042,
|
|
11652625, 11784463, 11784974, 11916813, 11916813, 11982604, 12048397, 12114188,
|
|
12179981, 12246028, 12246028, 12311308, 12311308, 12311308, 12311308, 12377101,
|
|
12377101, 12377101, 12377101, 12377101, 12377101, 12377101, 12377101, 12377101,
|
|
};
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( k_unOverabundanceOfRottingFlesh ) == kSamplePoints );
|
|
|
|
// orange_flash
|
|
static uint32 k_unTheFlamesBelow[] =
|
|
{
|
|
11548953, 11614745, 11746074, 11877659, 12008987, 12140572, 12337693, 12469278,
|
|
12666655, 12863776, 13060897, 13258274, 13455395, 13652772, 13849893, 14047014,
|
|
14244391, 14375976, 14573097, 14704681, 14836010, 14967595, 15033387, 15164716,
|
|
15164972, 15230508, 15230508, 15230508, 15164716, 15033387, 14967595, 14836010,
|
|
14638889, 14507304, 14310183, 14112806, 13915685, 13718308, 13455651, 13258274,
|
|
13060897, 12863776, 12666399, 12469278, 12272157, 12075036, 11943451, 11811866,
|
|
11680538, 11614745, 11548953, 11548953, 11548953, 11614745, 11680538, 11746330,
|
|
11877659, 12009244, 12206364, 12403485, 12600862, 12797983, 12995360, 13192482,
|
|
13389859, 13652772, 13849893, 14047270, 14244391, 14441512, 14638889, 14770474,
|
|
14901802, 15033387, 15099179, 15164972, 15230508, 15230508, 15098924, 14835755,
|
|
14572586, 14177832, 13783078, 13322789, 12862755, 12468001, 12139295, 11811101,
|
|
11614491, 11548954, 11549209, 11747351, 12011542, 12407317, 12869139, 13396754,
|
|
13924369, 14451983, 14979598, 15506957, 15902989, 16298508, 16562443, 16759819,
|
|
16760075, 16562188, 16166669, 15704590, 15110927, 14451217, 13791507, 13132053,
|
|
12538390, 12011032, 11681049, 11548953, 11614745, 11812888, 12142615, 12538646,
|
|
13066005, 13593875, 14187538, 14780944, 15308815, 15836430, 16232204, 16561932,
|
|
16694283, 16760075, 16561932, 16100621, 15506958, 14846992, 14121490, 13395732,
|
|
12670486, 12142359, 11746585, 11548953, 11614745, 11812632, 12076824, 12472343,
|
|
12934165, 13395988, 13923859, 14517265, 15044880, 15506702, 15968269, 16298508,
|
|
16562187, 16759819, 16760075, 16627979, 16298508, 15902733, 15375374, 14781967,
|
|
14188560, 13594897, 13066771, 12539156, 12077334, 11747351, 11549209, 11548954,
|
|
11680028, 11876637, 12139295, 12533793, 12928291, 13323045, 13783335, 14178088,
|
|
14572586, 14836011, 15098924, 15230508, 15230508, 15164972, 15099179, 15033387,
|
|
14901802, 14770474, 14638889, 14441768, 14244391, 14047270, 13849893, 13652772,
|
|
13455395, 13192482, 12995360, 12797983, 12600862, 12403485, 12206364, 12074780,
|
|
11877659, 11746330, 11680538, 11614745, 11548953, 11548953, 11548953, 11614745,
|
|
11680538, 11811866, 11943451, 12075036, 12272157, 12403742, 12600863, 12863776,
|
|
13060897, 13258274, 13455395, 13718308, 13915685, 14112806, 14310183, 14507304,
|
|
14638889, 14836010, 14967339, 15033387, 15164716, 15230508, 15230508, 15230508,
|
|
15164972, 15164716, 15033387, 14967595, 14836010, 14704681, 14573097, 14375976,
|
|
14244391, 14047014, 13849893, 13652772, 13455395, 13258274, 13060897, 12863776,
|
|
12666655, 12469278, 12337693, 12140572, 12008987, 11877659, 11746074, 11614745,
|
|
};
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( k_unTheFlamesBelow ) == kSamplePoints );
|
|
|
|
// green_pulse
|
|
static uint32 k_unThatQueesyFeeling[] =
|
|
{
|
|
7439904, 7571489, 7703329, 7900706, 8032547, 8295716, 8493349, 8756518,
|
|
9019943, 9283369, 9546794, 9810219, 10073644, 10402606, 10666031, 10929200,
|
|
11192625, 11390259, 11653428, 11851061, 12048437, 12180278, 12312119, 12443703,
|
|
12509496, 12575288, 12575288, 12509496, 12443703, 12312119, 12180278, 11982901,
|
|
11785268, 11522099, 11258674, 10995249, 10731823, 10468398, 10139181, 9810219,
|
|
9546794, 9217576, 8954151, 8690726, 8427557, 8229924, 7966755, 7834914,
|
|
7637537, 7571488, 7440160, 7439904, 7439904, 7505696, 7637281, 7769121,
|
|
7900962, 8098339, 8361508, 8624933, 8888359, 9151784, 9415209, 9744171,
|
|
10073388, 10336814, 10666031, 10929456, 11192882, 11456051, 11719476, 11982645,
|
|
12114486, 12311863, 12443447, 12509496, 12575288, 12575288, 12509496, 12443703,
|
|
12311863, 12180278, 11982645, 11785012, 11521843, 11258674, 10995249, 10731823,
|
|
10402862, 10139181, 9810219, 9546794, 9283368, 8954151, 8690982, 8427557,
|
|
8229924, 8032291, 7834914, 7703073, 7571489, 7505696, 7439904, 7439904,
|
|
7505696, 7571745, 7703329, 7900706, 8098083, 8295716, 8559141, 8822310,
|
|
9085736, 9349161, 9678378, 9941804, 10270765, 10534447, 10863408, 11126833,
|
|
11390258, 11653428, 11851061, 12048694, 12246070, 12377911, 12509240, 12575288,
|
|
12575288, 12575288, 12509240, 12377911, 12246070, 12048694, 11851061, 11653428,
|
|
11390258, 11126833, 10863408, 10534447, 10270765, 9941804, 9678378, 9349161,
|
|
9085736, 8822310, 8559141, 8295716, 8098083, 7900706, 7703329, 7571745,
|
|
7505696, 7439904, 7439904, 7505696, 7571489, 7703073, 7834914, 8032291,
|
|
8229924, 8427557, 8690982, 8954151, 9283368, 9546794, 9810219, 10139181,
|
|
10402862, 10731823, 10995249, 11258674, 11521843, 11785012, 11982645, 12180278,
|
|
12311863, 12443703, 12509496, 12575288, 12575288, 12509496, 12443447, 12311863,
|
|
12180022, 11982645, 11719476, 11521843, 11258418, 10929456, 10666031, 10336814,
|
|
10073388, 9744427, 9480745, 9151784, 8888359, 8624933, 8361508, 8163875,
|
|
7900962, 7769121, 7637281, 7505696, 7439904, 7439904, 7440160, 7571488,
|
|
7637537, 7834914, 7966755, 8164132, 8427557, 8690726, 8954151, 9217576,
|
|
9546538, 9810219, 10139181, 10402606, 10731823, 10995249, 11258674, 11521843,
|
|
11785268, 11982645, 12180278, 12312119, 12443703, 12509496, 12575288, 12575288,
|
|
12509496, 12443703, 12312119, 12180278, 12048437, 11851061, 11653428, 11390259,
|
|
11192625, 10929200, 10666031, 10402606, 10073644, 9810219, 9546794, 9283369,
|
|
9019943, 8756518, 8493349, 8295716, 8032547, 7900706, 7703329, 7571489,
|
|
};
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( k_unThatQueesyFeeling ) == kSamplePoints );
|
|
|
|
// blue_pulse
|
|
static uint32 k_unBubbleBubble[] =
|
|
{
|
|
9094364, 9160156, 9291485, 9357278, 9488607, 9685472, 9816801, 10013922,
|
|
10145251, 10342372, 10539237, 10736358, 10933479, 11130345, 11327466, 11458795,
|
|
11655916, 11852781, 11984366, 12115695, 12247024, 12378352, 12444145, 12509681,
|
|
12575474, 12641010, 12641010, 12575474, 12509681, 12444145, 12312816, 12181487,
|
|
12049902, 11853037, 11655916, 11458795, 11261930, 11064808, 10802151, 10605030,
|
|
10407908, 10211043, 10013922, 9816801, 9619936, 9488607, 9357022, 9225693,
|
|
9160156, 9094364, 9094364, 9094364, 9159900, 9225693, 9357022, 9553886,
|
|
9751008, 9948129, 10210786, 10473444, 10736102, 11064551, 11392745, 11655659,
|
|
11983853, 12312303, 12640496, 12903410, 13166068, 13494262, 13691383, 13954040,
|
|
14150905, 14282490, 14413819, 14545148, 14545148, 14545148, 14545148, 14413819,
|
|
14282490, 14151162, 13954040, 13756919, 13494262, 13231604, 12968947, 12706289,
|
|
12377839, 12115181, 11786732, 11458538, 11195880, 10867430, 10604773, 10342115,
|
|
10079458, 9816800, 9619679, 9422814, 9291485, 9160156, 9094364, 9094364,
|
|
9094364, 9094364, 9160157, 9291485, 9422814, 9554143, 9685472, 9882593,
|
|
10079458, 10276579, 10473701, 10736358, 10933479, 11130345, 11327466, 11590123,
|
|
11787245, 11918574, 12115695, 12247024, 12378352, 12509681, 12575218, 12641010,
|
|
12641010, 12641010, 12575218, 12509681, 12378352, 12247024, 12115695, 11918574,
|
|
11787245, 11590123, 11327466, 11130345, 10933479, 10736358, 10473701, 10276579,
|
|
10079458, 9882593, 9685472, 9554143, 9422814, 9291485, 9160157, 9094364,
|
|
9094364, 9094364, 9094364, 9160156, 9291485, 9422814, 9619679, 9816800,
|
|
10079458, 10342115, 10604773, 10867430, 11195880, 11458538, 11786732, 12115181,
|
|
12377839, 12706289, 12968947, 13231604, 13494262, 13756919, 13954040, 14151162,
|
|
14282490, 14413819, 14545148, 14545148, 14545148, 14545148, 14413819, 14282490,
|
|
14150905, 13954040, 13691383, 13494262, 13231604, 12903410, 12640497, 12312303,
|
|
11983853, 11721195, 11392745, 11064551, 10801638, 10473444, 10210786, 9948129,
|
|
9751008, 9553887, 9357022, 9225693, 9159900, 9094364, 9094364, 9094364,
|
|
9160156, 9225693, 9357022, 9488351, 9619935, 9816801, 10013922, 10210787,
|
|
10407908, 10605030, 10802151, 11064808, 11261674, 11458795, 11655916, 11853037,
|
|
12049902, 12181231, 12312560, 12443889, 12575217, 12641010, 12641010, 12641010,
|
|
12575474, 12575217, 12509681, 12378352, 12247024, 12115695, 11984366, 11852781,
|
|
11655916, 11524331, 11327466, 11130345, 10933479, 10736358, 10539237, 10342372,
|
|
10145251, 10013922, 9816801, 9685472, 9554143, 9422814, 9291485, 9160156,
|
|
};
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( k_unBubbleBubble ) == kSamplePoints );
|
|
|
|
// purple_orange_rand
|
|
static uint32 k_unAfraidOfShadowsDark[] =
|
|
{
|
|
4536928, 4536928, 4602721, 4602721, 4668515, 4668515, 4734308, 4734308,
|
|
4734308, 4734309, 4734309, 4734309, 4865896, 4865896, 4931689, 4931689,
|
|
4997226, 4997226, 5063019, 5063019, 5128813, 5194606, 5194607, 5260400,
|
|
5260400, 5391730, 5457523, 5457524, 5457524, 5523317, 5589111, 5654904,
|
|
5654905, 5654905, 5720698, 5852028, 5917821, 5917822, 5983615, 5983615,
|
|
6115202, 6115202, 6115203, 6180996, 6312326, 6378119, 6378120, 6443913,
|
|
6444683, 6576785, 6577556, 6709913, 6710941, 6843555, 6844583, 6845868,
|
|
6912945, 6914230, 6915515, 6982592, 6983877, 6985161, 6986446, 6987986,
|
|
6989014, 6924762, 6926046, 6926817, 6862308, 6863079, 6863593, 6798827,
|
|
6799597, 6799083, 6929385, 6863079, 6927845, 6992866, 7057632, 7187677,
|
|
7252442, 7382487, 7447251, 7577296, 7641805, 7772362, 7836871, 7967172,
|
|
8097473, 8227774, 8292283, 8422841, 8487607, 8749750, 8814516, 8879794,
|
|
8945072, 9075888, 8946614, 8752575, 8427464, 8102353, 7842008, 7647197,
|
|
7582176, 7842777, 8233938, 8559562, 8950979, 9277117, 9537977, 9733814,
|
|
9734070, 9734070, 9734070, 9734070, 9734071, 9799863, 9799863, 9799863,
|
|
9799863, 9799863, 9799863, 9799863, 9799863, 9799604, 9799863, 9799604,
|
|
9799344, 9733548, 9733032, 9732771, 9732509, 9731992, 9731473, 9731211,
|
|
9796485, 9861502, 9861239, 9926256, 10057321, 10122338, 10253403, 10450004,
|
|
10580557, 10777414, 10974016, 11235897, 11432754, 11629612, 11825958, 12088353,
|
|
12350747, 12547606, 12875538, 13072654, 13203723, 13531656, 13729032, 13729032,
|
|
13794568, 13991688, 14188808, 14254344, 14385672, 14451464, 14648328, 14845704,
|
|
14977032, 15108360, 15239689, 15436809, 15568393, 15831050, 15962892, 16160781,
|
|
16226832, 16293140, 16294170, 16294943, 16295713, 16296229, 16297257, 16363566,
|
|
16364595, 16365365, 16431930, 16432957, 16433729, 16500037, 16501065, 16501836,
|
|
16502864, 16503634, 16569685, 16570712, 16571482, 16637789, 16638303, 16639072,
|
|
16639586, 16640355, 16640869, 16707173, 16707430, 16707943, 16708456, 16708712,
|
|
16709224, 16775016, 16775272, 16775784, 16776040, 16776552, 16776295, 16776551,
|
|
16776551, 16776039, 16709991, 16709736, 16709224, 16511336, 16247913, 16116074,
|
|
15786858, 15457899, 15193963, 14865004, 14601837, 14206573, 13811822, 13351022,
|
|
12890479, 12429935, 11969392, 11508591, 11048049, 10587504, 10192752, 9732208,
|
|
9337455, 8877166, 8482670, 8153453, 7758957, 7430252, 7101291, 6772586,
|
|
6509418, 6246505, 5983337, 5786216, 5588840, 5391719, 5194599, 5063014,
|
|
};
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( k_unAfraidOfShadowsDark ) == kSamplePoints );
|
|
|
|
static uint32 *k_pPointSampleContent_Team0[] =
|
|
{
|
|
&k_unWitchYellow[0],
|
|
&k_unDistinctiveLackOfSanity[0],
|
|
&k_unOverabundanceOfRottingFlesh[0],
|
|
&k_unTheFlamesBelow[0],
|
|
&k_unThatQueesyFeeling[0],
|
|
&k_unAfraidOfShadowsDark[0],
|
|
};
|
|
|
|
static uint32 *k_pPointSampleContent_Team1[] =
|
|
{
|
|
&k_unWitchYellow[0],
|
|
&k_unDistinctiveLackOfSanity[0],
|
|
&k_unOverabundanceOfRottingFlesh[0],
|
|
&k_unBubbleBubble[0],
|
|
&k_unThatQueesyFeeling[0],
|
|
&k_unAfraidOfShadowsDark[0],
|
|
};
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( k_pPointSampleContent_Team0 ) == ARRAYSIZE( k_pPointSampleContent_Team1 ) );
|
|
|
|
if ( unIndex >= ARRAYSIZE( k_pPointSampleContent_Team0 ) )
|
|
return 0;
|
|
|
|
if ( unTeamIndex > 1 )
|
|
return 0;
|
|
|
|
const float fScaledTime = gpGlobals->curtime * 22.0f; // arbitrary time scalar people liked
|
|
const unsigned int unSamplePoint0 = (unsigned int)fScaledTime % kSamplePoints;
|
|
const unsigned int unSamplePoint1 = (unSamplePoint0 + 1) % kSamplePoints;
|
|
|
|
const float fDelta = fScaledTime - (unsigned int)fScaledTime; // offset between two sample points for blending
|
|
|
|
const uint32 *punData = (unTeamIndex == 0 ? k_pPointSampleContent_Team0 : k_pPointSampleContent_Team1)[unIndex];
|
|
|
|
Color c0;
|
|
c0.SetRawColor( punData[unSamplePoint0] );
|
|
|
|
Color c1;
|
|
c1.SetRawColor( punData[unSamplePoint1] );
|
|
|
|
const Color cBlend( Lerp( fDelta, c0.r(), c1.r() ),
|
|
Lerp( fDelta, c0.g(), c1.g() ),
|
|
Lerp( fDelta, c0.b(), c1.b() ) );
|
|
|
|
return cBlend.GetRawColor();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Get RGB modifying attribute value
|
|
//-----------------------------------------------------------------------------
|
|
int CEconItemView::GetModifiedRGBValue( bool bAltColor )
|
|
{
|
|
enum
|
|
{
|
|
kPaintConstant_Default = 0,
|
|
kPaintConstant_OldTeamColor = 1,
|
|
};
|
|
|
|
static CSchemaAttributeDefHandle pAttr_Paint( "set item tint rgb" );
|
|
static CSchemaAttributeDefHandle pAttr_Paint2( "set item tint rgb 2" );
|
|
|
|
static CSchemaAttributeDefHandle pAttr_PaintOverride( "SPELL: set item tint RGB" );
|
|
|
|
// Do we have an override paint color? This takes precedence over base paints and team
|
|
// paints.
|
|
#if defined( TF_DLL ) || defined( TF_CLIENT_DLL )
|
|
extern bool TF_IsHolidayActive( /*EHoliday*/ int eHoliday );
|
|
|
|
if ( TF_IsHolidayActive( kHoliday_HalloweenOrFullMoon ) )
|
|
#endif // defined( TF_DLL ) || defined( TF_CLIENT_DLL )
|
|
{
|
|
if ( !m_bPaintOverrideInit )
|
|
{
|
|
m_bHasPaintOverride = FindAttribute_UnsafeBitwiseCast<attrib_value_t>( this, pAttr_PaintOverride, &m_flOverrideIndex );
|
|
m_bPaintOverrideInit = true;
|
|
}
|
|
|
|
if ( m_bHasPaintOverride )
|
|
return RemapOverridePaintIndexToRGB( (uint32)m_flOverrideIndex, bAltColor ? 1 : 0 );
|
|
}
|
|
|
|
if ( !m_bColorInit )
|
|
{
|
|
// See if we also have a secondary paint color.
|
|
uint32 unRGB = kPaintConstant_Default;
|
|
uint32 unRGBAlt = kPaintConstant_Default;
|
|
float fRGB;
|
|
float fRGBAlt;
|
|
|
|
// If we have no base paint color we don't do anything special.
|
|
if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( this, pAttr_Paint, &fRGB ) )
|
|
{
|
|
unRGB = (uint32)fRGB;
|
|
unRGBAlt = unRGB;
|
|
}
|
|
|
|
// Backwards compatibility for old team colored items.
|
|
if ( unRGB == kPaintConstant_OldTeamColor )
|
|
{
|
|
unRGB = RGB_INT_RED;
|
|
unRGBAlt = RGB_INT_BLUE;
|
|
}
|
|
else if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( this, pAttr_Paint2, &fRGBAlt ) )
|
|
{
|
|
unRGBAlt = (uint32)fRGBAlt;
|
|
}
|
|
else
|
|
{
|
|
// By default our secondary color will match our primary if we can't find a replacement.
|
|
unRGBAlt = unRGB;
|
|
}
|
|
|
|
m_unRGB = unRGB;
|
|
m_unAltRGB = unRGBAlt;
|
|
|
|
m_bColorInit = true;
|
|
}
|
|
|
|
return bAltColor ? m_unAltRGB : m_unRGB;
|
|
}
|
|
|
|
uint64 CEconItemView::GetCustomUserTextureID()
|
|
{
|
|
static CSchemaAttributeDefHandle pAttr_CustomTextureLo( "custom texture lo" );
|
|
static CSchemaAttributeDefHandle pAttr_CustomTextureHi( "custom texture hi" );
|
|
|
|
uint32 unLowVal, unHighVal;
|
|
const bool bHasLowVal = FindAttribute( pAttr_CustomTextureLo, &unLowVal ),
|
|
bHasHighVal = FindAttribute( pAttr_CustomTextureHi, &unHighVal );
|
|
|
|
// We should have both, or neither. We should never have just one
|
|
Assert( bHasLowVal == bHasHighVal );
|
|
|
|
if ( bHasLowVal && bHasHighVal )
|
|
{
|
|
return ((uint64)unHighVal << 32) | (uint64)unLowVal;
|
|
}
|
|
|
|
// No attribute set
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CAttributeList::CAttributeList()
|
|
{
|
|
m_pManager = NULL;
|
|
m_Attributes.Purge();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CAttributeList::SetManager( CAttributeManager *pManager )
|
|
{
|
|
m_pManager = pManager;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CAttributeList::Init()
|
|
{
|
|
m_Attributes.Purge();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CAttributeList::IterateAttributes( class IEconItemAttributeIterator *pIterator ) const
|
|
{
|
|
Assert( pIterator );
|
|
|
|
FOR_EACH_VEC( m_Attributes, i )
|
|
{
|
|
const CEconItemAttribute *pAttrInst = &m_Attributes[i];
|
|
|
|
const CEconItemAttributeDefinition *pAttrDef = pAttrInst->GetStaticData();
|
|
if ( !pAttrDef )
|
|
continue;
|
|
|
|
const ISchemaAttributeType *pAttrType = pAttrDef->GetAttributeType();
|
|
Assert( pAttrType );
|
|
Assert( pAttrType->BSupportsGameplayModificationAndNetworking() );
|
|
|
|
// We know (and assert) that we only need 32 bits of data to store this attribute
|
|
// data. We don't know anything about the type but we'll let the type handle it
|
|
// below.
|
|
attribute_data_union_t value;
|
|
value.asFloat = pAttrInst->m_flValue;
|
|
|
|
if ( !pAttrType->OnIterateAttributeValue( pIterator, pAttrDef, value ) )
|
|
return;
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CAttributeList::DestroyAllAttributes( void )
|
|
{
|
|
if ( m_Attributes.Count() )
|
|
{
|
|
m_Attributes.Purge();
|
|
NotifyManagerOfAttributeValueChanges();
|
|
NetworkStateChanged();
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CAttributeList::AddAttribute( CEconItemAttribute *pAttribute )
|
|
{
|
|
Assert( pAttribute );
|
|
|
|
// Only add attributes to the attribute list if they have a definition we can
|
|
// pull data from.
|
|
if ( !pAttribute->GetStaticData() )
|
|
return;
|
|
|
|
m_Attributes.AddToTail( *pAttribute );
|
|
NetworkStateChanged();
|
|
NotifyManagerOfAttributeValueChanges();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CAttributeList::SetRuntimeAttributeValue( const CEconItemAttributeDefinition *pAttrDef, float flValue )
|
|
{
|
|
Assert( pAttrDef );
|
|
|
|
// Look for an existing attribute.
|
|
const int iAttributes = GetNumAttributes();
|
|
for ( int i = 0; i < iAttributes; i++ )
|
|
{
|
|
CEconItemAttribute *pAttribute = GetAttribute(i);
|
|
|
|
if ( pAttribute->GetAttribIndex() == pAttrDef->GetDefinitionIndex() )
|
|
{
|
|
// Found existing attribute -- change value.
|
|
pAttribute->m_flValue = flValue;
|
|
NotifyManagerOfAttributeValueChanges();
|
|
return;
|
|
}
|
|
}
|
|
|
|
// Couldn't find an existing attribute for this definition -- make a new one.
|
|
CEconItemAttribute attribute;
|
|
attribute.m_iAttributeDefinitionIndex = pAttrDef->GetDefinitionIndex();
|
|
attribute.m_flValue = flValue;
|
|
|
|
m_Attributes.AddToTail( attribute );
|
|
NotifyManagerOfAttributeValueChanges();
|
|
}
|
|
|
|
#if ENABLE_ATTRIBUTE_CURRENCY_TRACKING
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CAttributeList::SetRuntimeAttributeRefundableCurrency( const CEconItemAttributeDefinition *pAttrDef, int iRefundableCurrency )
|
|
{
|
|
Assert( pAttrDef );
|
|
|
|
// Look for an existing attribute.
|
|
const int iAttributes = GetNumAttributes();
|
|
for ( int i = 0; i < iAttributes; i++ )
|
|
{
|
|
CEconItemAttribute *pAttribute = GetAttribute(i);
|
|
|
|
if ( pAttribute->GetAttribIndex() == pAttrDef->GetDefinitionIndex() )
|
|
{
|
|
// Found existing attribute -- change value.
|
|
pAttribute->m_nRefundableCurrency = iRefundableCurrency;
|
|
return;
|
|
}
|
|
}
|
|
|
|
AssertMsg1( false, "Unable to find attribute '%s' for setting currency!", pAttrDef->GetDefinitionName() );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
int CAttributeList::GetRuntimeAttributeRefundableCurrency( const CEconItemAttributeDefinition *pAttrDef ) const
|
|
{
|
|
const int iAttributes = GetNumAttributes();
|
|
for ( int i = 0; i < iAttributes; i++ )
|
|
{
|
|
const CEconItemAttribute *pAttribute = GetAttribute(i);
|
|
|
|
if ( pAttribute->GetAttribIndex() == pAttrDef->GetDefinitionIndex() )
|
|
return pAttribute->m_nRefundableCurrency;
|
|
}
|
|
|
|
AssertMsg1( false, "Unable to find attribute '%s' for getting currency!", pAttrDef->GetDefinitionName() );
|
|
return 0;
|
|
}
|
|
#endif // ENABLE_ATTRIBUTE_CURRENCY_TRACKING
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Remove an attribute by name
|
|
//-----------------------------------------------------------------------------
|
|
void CAttributeList::RemoveAttribute( const CEconItemAttributeDefinition *pAttrDef )
|
|
{
|
|
const int iAttributes = m_Attributes.Count();
|
|
for ( int i = 0; i < iAttributes; i++ )
|
|
{
|
|
if ( m_Attributes[i].GetStaticData() == pAttrDef )
|
|
{
|
|
m_Attributes.Remove( i );
|
|
NotifyManagerOfAttributeValueChanges();
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Remove an attribute by index
|
|
//-----------------------------------------------------------------------------
|
|
void CAttributeList::RemoveAttributeByIndex( int iIndex )
|
|
{
|
|
if ( iIndex < 0 || iIndex >= GetNumAttributes() )
|
|
return;
|
|
|
|
m_Attributes.Remove( iIndex );
|
|
NotifyManagerOfAttributeValueChanges();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const CEconItemAttribute *CAttributeList::GetAttributeByID( int iAttributeID ) const
|
|
{
|
|
int iAttributes = m_Attributes.Count();
|
|
for ( int i = 0; i < iAttributes; i++ )
|
|
{
|
|
const CEconItemAttributeDefinition *pData = m_Attributes[i].GetStaticData();
|
|
|
|
if ( pData && ( pData->GetDefinitionIndex() == iAttributeID ) )
|
|
return &m_Attributes[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
const CEconItemAttribute *CAttributeList::GetAttributeByName( const char *pszAttribDefName ) const
|
|
{
|
|
CEconItemAttributeDefinition *pDef = GetItemSchema()->GetAttributeDefinitionByName( pszAttribDefName );
|
|
if ( !pDef )
|
|
return NULL;
|
|
|
|
int iAttributes = m_Attributes.Count();
|
|
for ( int i = 0; i < iAttributes; i++ )
|
|
{
|
|
if ( m_Attributes[i].GetStaticData()->GetDefinitionIndex() == pDef->GetDefinitionIndex() )
|
|
return &m_Attributes[i];
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CAttributeList::operator=( const CAttributeList& src )
|
|
{
|
|
m_Attributes = src.m_Attributes;
|
|
|
|
// HACK: We deliberately don't copy managers, because attributelists are contained inside
|
|
// CEconItemViews, which we duplicate inside CItemModelPanels all the time. If the manager
|
|
// is copied, copies will mess with the attribute caches of the copied item.
|
|
// Our manager will be setup properly by the CAttributeManager itself if we have an associated entity.
|
|
m_pManager = NULL;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
void CAttributeList::NotifyManagerOfAttributeValueChanges( void )
|
|
{
|
|
if ( m_pManager )
|
|
{
|
|
m_pManager->OnAttributeValuesChanged();
|
|
}
|
|
}
|
|
|
|
#ifdef CLIENT_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool DoesItemPassSearchFilter( const IEconItemDescription *pDescription, const wchar_t* wszFilter )
|
|
{
|
|
// check if item matches name filter
|
|
if ( wszFilter && *wszFilter )
|
|
{
|
|
if ( !pDescription )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
wchar_t wszBuffer[ 4096 ] = L"";
|
|
for ( unsigned int i = 0; i < pDescription->GetLineCount(); i++ )
|
|
{
|
|
const econ_item_description_line_t& line = pDescription->GetLine(i);
|
|
|
|
if ( !(line.unMetaType & ( kDescLineFlag_Collection | kDescLineFlag_CollectionCurrentItem ) ) )
|
|
{
|
|
V_wcscat_safe( wszBuffer, line.sText.Get() );
|
|
}
|
|
}
|
|
|
|
V_wcslower( wszBuffer );
|
|
if ( !wcsstr( wszBuffer, wszFilter ) )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CBasePlayer *GetPlayerByAccountID( uint32 unAccountID )
|
|
{
|
|
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
|
|
{
|
|
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
|
|
if ( pPlayer == NULL )
|
|
continue;
|
|
|
|
CSteamID steamIDPlayer;
|
|
if ( !pPlayer->GetSteamID( &steamIDPlayer ) )
|
|
continue;
|
|
|
|
// return the player with the matching ID
|
|
if ( steamIDPlayer.GetAccountID() == unAccountID )
|
|
{
|
|
return pPlayer;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
#endif // CLIENT_DLL
|