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