d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
82 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 81b976c384
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '81b976c384'
${ noResults }
source-engine/game/shared/econ/econ_item_view.cpp

1971 lines
73 KiB
Raw Blame History

//========= 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