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.
1043 lines
39 KiB
1043 lines
39 KiB
//========= Copyright Valve Corporation, All rights reserved. ============// |
|
|
|
#ifndef ECONITEMTOOLS_H |
|
#define ECONITEMTOOLS_H |
|
#ifdef _WIN32 |
|
#pragma once |
|
#endif |
|
|
|
enum EConsumptionAttemptResult |
|
{ |
|
kConsumptionResult_CannotConsume, // could be bum definitions or doesnt meet criteria or anything -- this is failure |
|
kConsumptionResult_CanConsume, // able to consume |
|
kConsumptionResult_WillCompleteCollection, // able to consume and is the final item to be consumed |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconSharedToolSupport |
|
{ |
|
public: |
|
// Can the given tool instance apply to a specific instance of an item. This should be used in the general |
|
// case whenever a CEconItem or a CEconItemView is available. |
|
static bool ToolCanApplyTo( const IEconItemInterface *pToolDef, const IEconItemInterface *pToolSubject ); |
|
|
|
// Can the given tool definition apply to an item definition? This will check things like restrictions, |
|
// matching tool capabilities, etc. but will ignore instance-specific properties. This should only be used |
|
// by code that doesn't have any access to an instance of the definition. |
|
static bool ToolCanApplyToDefinition( const GameItemDefinition_t *pToolDef, const GameItemDefinition_t *pToolSubjectDef ); |
|
|
|
// Can the given tool definition apply to a base item definition? |
|
static bool ToolCanApplyToBaseItem( const GameItemDefinition_t *pToolDef, const GameItemDefinition_t *pToolSubjectDef ); |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_DuelingMinigame : public IEconTool |
|
{ |
|
public: |
|
CEconTool_DuelingMinigame( const char *pszTypeName, const char *pszUseString ) : IEconTool( pszTypeName, pszUseString, NULL, ITEM_CAP_NONE ) { } |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
#ifdef GC_DLL |
|
virtual class CGCEconConsumableBehavior *CreateGCConsumableBehavior() const; |
|
#endif // GC_DLL |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_Noisemaker : public IEconTool |
|
{ |
|
public: |
|
CEconTool_Noisemaker( const char *pszTypeName, const char *pszUseString ) : IEconTool( pszTypeName, pszUseString, NULL, ITEM_CAP_NONE ) { } |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_WrappedGift : public IEconTool |
|
{ |
|
public: |
|
CEconTool_WrappedGift( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ); |
|
|
|
virtual bool BFinishInitialization() OVERRIDE; |
|
|
|
bool BIsGlobalGift() const { return m_bIsGlobalGift; } |
|
// Allows the item to be directly used rather than via the trading system |
|
bool BIsDirectGift() const { return m_bIsDirectGift; } |
|
const CEconItemDefinition *GetDeliveredItemDefinition() const { return m_pDeliveredGiftItemDef; } // can return NULL! (means "don't change definitions on delivery") |
|
|
|
#ifdef CLIENT_DLL |
|
virtual bool CanBeUsedNow( const IEconItemInterface *pItem ) const; |
|
virtual bool ShouldShowContainedItemPanel( const IEconItemInterface *pItem ) const; |
|
virtual const char *GetUseCommandLocalizationToken( const IEconItemInterface *pItem, int i = 0 ) const; |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
virtual int GetUseCommandCount( const IEconItemInterface *pItem ) const; |
|
virtual const char* GetUseCommand( const IEconItemInterface *pItem, int i = 0 ) const; |
|
#endif // CLIENT_DLL |
|
|
|
#ifdef GC_DLL |
|
virtual class CGCEconConsumableBehavior *CreateGCConsumableBehavior() const; |
|
#endif // GC_DLL |
|
|
|
private: |
|
const char *m_pszDeliveredGiftItemDefName; // points to memory inside our init KV -- only valid between the constructor call and the BFinishInitialization() call (this is messy but Fletcher and I agree it makes more sense than switching to a full two-pass schema parse just for this) |
|
|
|
const CEconItemDefinition *m_pDeliveredGiftItemDef; |
|
bool m_bIsGlobalGift; |
|
bool m_bIsDirectGift; |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_WeddingRing : public IEconTool |
|
{ |
|
public: |
|
CEconTool_WeddingRing( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities ) : IEconTool( pszTypeName, pszUseString, NULL, unCapabilities ) { } |
|
|
|
virtual bool RequiresToolEscrowPeriod() const { return false; } |
|
|
|
#ifdef CLIENT_DLL |
|
virtual const char *GetUseCommandLocalizationToken( const IEconItemInterface *pItem, int i = 0 ) const; |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
#ifdef GC_DLL |
|
virtual class CGCEconConsumableBehavior *CreateGCConsumableBehavior() const; |
|
#endif // GC_DLL |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_TagsList |
|
{ |
|
public: |
|
CEconTool_TagsList( KeyValues *pKVTags ) |
|
{ |
|
if ( pKVTags ) |
|
{ |
|
FOR_EACH_SUBKEY( pKVTags, pKVTag ) |
|
{ |
|
m_vecTags.AddToTail( GetItemSchema()->GetHandleForTag( pKVTag->GetName() ) ); |
|
} |
|
} |
|
} |
|
|
|
const CUtlVector<econ_tag_handle_t>& GetTagsList() const { return m_vecTags; } |
|
|
|
private: |
|
CUtlVector<econ_tag_handle_t> m_vecTags; |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_StrangeCountTransfer : public IEconTool |
|
{ |
|
public: |
|
CEconTool_StrangeCountTransfer( const char *pszTypeName, item_capabilities_t unCapabilities ); |
|
|
|
static bool AreItemsEligibleForStrangeCountTransfer( const IEconItemInterface *pItem1, const IEconItemInterface *pItem2 ); |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
//virtual void OnClientApplyCommit( CEconItemView *pTool, CEconItemView *pSubject ) const; |
|
|
|
bool SetItems( CEconItemView *pItem1, CEconItemView *pItem2 ); |
|
|
|
CEconItemView *m_pItemSrc; |
|
CEconItemView *m_pItemDest; |
|
#endif |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_StrangePart : public IEconTool |
|
{ |
|
public: |
|
CEconTool_StrangePart( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ) |
|
: IEconTool( pszTypeName, pszUseString, NULL, unCapabilities ) |
|
, m_RequiredTags( pUsageKV ? pUsageKV->FindKey( "required_tags" ) : NULL ) |
|
, m_RequiredMissingTags( pUsageKV ? pUsageKV->FindKey( "required_missing_tags" ) : NULL ) |
|
{ |
|
// |
|
} |
|
|
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const; |
|
|
|
#ifdef CLIENT_DLL |
|
virtual bool ShouldDisplayAsUseableOnItemsInArmory() const { return false; } |
|
|
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
private: |
|
CEconTool_TagsList m_RequiredTags; |
|
CEconTool_TagsList m_RequiredMissingTags; |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_StrangePartRestriction : public IEconTool |
|
{ |
|
public: |
|
CEconTool_StrangePartRestriction( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ); |
|
|
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const; |
|
virtual bool BFinishInitialization() OVERRIDE; |
|
#ifdef CLIENT_DLL |
|
virtual bool ShouldDisplayAsUseableOnItemsInArmory() const { return false; } |
|
|
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
unsigned int GetRestrictionType() const { return m_eRestrictionType; } |
|
unsigned int GetRestrictionValue() const { return m_unRestrictionValue; } |
|
|
|
private: |
|
unsigned int /*strange_event_restriction_t*/ m_eRestrictionType; |
|
|
|
const char *m_pszRestrictionValue; // points to memory inside our init KV -- only valid between the constructor call and the BFinishInitialization() call (this is messy but Fletcher and I agree it makes more sense than switching to a full two-pass schema parse just for this) |
|
unsigned int m_unRestrictionValue; |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: New crafting! This new systems allows for dynamic crafting recipes to be |
|
// generated in the form of an item itself. Players can "feed" in items on the |
|
// recipe's input list, either all at once or once at a time, until the inputs |
|
// are all fulfilled. Once that happens at which the outputs of the recipe are given to the player. |
|
// |
|
// This is done using new attribute types that encode the recipe's inputs and outputs. |
|
// Inputs and outputs can either be specific items of specific qualities, or lootlist |
|
// with a specific quality -- for now. Lootlist will roll the specific item to be the input/output |
|
// when the recipe item is created. Any gc generated attributes that would come |
|
// from the lootlists will also get encoded as a string in the recipe's attribute, so things like |
|
// unusual particle effects will get applied to outputs. These string-encoded attributes |
|
// are ignored during input criteria matching for now. |
|
// |
|
// Components are allowed to have nested components defined within them. These child |
|
// components only roll their chance to apply if their parent successfully rolls their |
|
// chance to apply. |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_ItemDynamicRecipe : public IEconTool |
|
{ |
|
public: |
|
|
|
// This enum lets the CDynamicRecipeComponentLootList class specify |
|
// "uniqueness" of the item def that it will roll. This allows us to |
|
// do things like ensure that the output item will never be one of the |
|
// input items, or there's never duplicate inputs. |
|
enum EItemDefUniqueness_t |
|
{ |
|
UNIQUE_AMONG_INPUTS = 0, |
|
UNIQUE_AMONG_OUTPUTS, |
|
UNIQUE_AMONG_EVERYTHING, |
|
UNIQUE_AMONG_NOTHING, |
|
}; |
|
|
|
CEconTool_ItemDynamicRecipe( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ); |
|
~CEconTool_ItemDynamicRecipe(); |
|
|
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const; |
|
virtual bool BFinishInitialization() OVERRIDE; |
|
|
|
#ifdef CLIENT_DLL |
|
virtual bool ShouldDisplayAsUseableOnItemsInArmory() const { return false; } |
|
#endif // CLIENT_DLL |
|
|
|
|
|
virtual bool BInitFromKV( KeyValues *pKVDefinition, CUtlVector<CUtlString> *pVecErrors ); |
|
#ifdef GC_DLL |
|
virtual bool BGenerateDynamicAttributes( CEconItem* pItem, const CEconGameAccount *pGameAccount ) const OVERRIDE; |
|
#endif |
|
|
|
class CBaseRecipeComponent |
|
{ |
|
public: |
|
|
|
struct StringEncodedAttribute_t |
|
{ |
|
attrib_definition_index_t m_AttrIndex; |
|
CUtlConstString m_strAttrData; |
|
}; |
|
|
|
struct CountChance_t |
|
{ |
|
int m_nMinCount; |
|
int m_nMaxCount; |
|
float m_flChance; |
|
}; |
|
|
|
typedef CUtlVector<const CEconItemAttributeDefinition *> ComponentAttribVector_t; |
|
|
|
CBaseRecipeComponent( bool bIsOutput, const CBaseRecipeComponent* pParent ); |
|
virtual ~CBaseRecipeComponent(); |
|
|
|
static bool ParseComponentsBlock( KeyValues *pKV, CUtlVector<CBaseRecipeComponent*>& vecComponents, CUtlVector<CUtlString> *pVecErrors, const CBaseRecipeComponent* pParent ); |
|
static bool ParseComponents( KeyValues *pKV, CUtlVector<CBaseRecipeComponent*>& vecComponents, bool bIsOutput, CUtlVector<CUtlString> *pVecErrors, const CBaseRecipeComponent* pParent ); |
|
virtual bool ParseKV( KeyValues *pKV, CUtlVector<CUtlString> *pVecErrors ); |
|
void SetIsOutput( bool bIsOutput ) { m_bIsOutput = bIsOutput; } |
|
void SetParent( CBaseRecipeComponent* pParent ) { m_pParent = pParent; } |
|
void SetChanceOfApplying( float flChance ); |
|
virtual bool BFinishInitialization_Internal( CUtlVector<CUtlString>* pVecErrors, ComponentAttribVector_t* attribVec ); |
|
|
|
bool GetIsOutput() const { return m_bIsOutput; } |
|
void GetIsGuaranteed( int &nFlags ) const; |
|
const CUtlVector< CountChance_t >& GetRollChances() const { return m_vecCountChances; } |
|
#ifdef GC_DLL |
|
bool RollChanceOfApplying() const; |
|
float GetRollChance() const { return m_flChanceOfApplying; } |
|
int RollCount() const; |
|
virtual bool AddRecipeComponentAsAttribute( CEconItem *pItem, const CEconGameAccount *pGameAccount ) const = 0; |
|
#endif |
|
protected: |
|
#ifdef GC_DLL |
|
virtual const char* GetAttributeName() const { return "recipe component defined item"; } |
|
static CEconItemAttributeDefinition* GetNextAvailableAttributeWithBaseName( const char* pszBaseAttribName, ComponentAttribVector_t *pAttribVec ); |
|
#endif |
|
const CBaseRecipeComponent* m_pParent; |
|
CUtlVector< CBaseRecipeComponent* > m_vecAdditionalComponents; |
|
float m_flChanceOfApplying; |
|
bool m_bIsOutput; |
|
CUtlVector< CountChance_t > m_vecCountChances; |
|
float m_flTotalWeights; |
|
|
|
EEconItemQuality m_eQuality; |
|
|
|
enum EAttributesMatchingType_t |
|
{ |
|
ATTRIBUTES_MATCH_NONE = 0, |
|
ATTRIBUTES_MATCH_ALL, |
|
ATTRIBUTES_MATCH_ANY, |
|
}; |
|
|
|
EAttributesMatchingType_t m_attributesMatchingType; |
|
CUtlVector< StringEncodedAttribute_t > m_vecDynamicAttributes; |
|
|
|
CUtlString m_strName; |
|
|
|
static const char* m_pszUseParentNameIdentifier; |
|
}; |
|
|
|
public: |
|
|
|
class CDynamicRecipeComponentLootList; |
|
// Defined item type: Use this when you want to quickly define a specific item as |
|
// a component for a recipe. A "defined item" is considered an |
|
// itemdef, a quality, and any additional attributes. |
|
class CDynamicRecipeComponentDefinedItem : public CBaseRecipeComponent |
|
{ |
|
typedef CBaseRecipeComponent BaseClass; |
|
public: |
|
CDynamicRecipeComponentDefinedItem( bool bIsOutput, const CBaseRecipeComponent* pParent ); |
|
virtual ~CDynamicRecipeComponentDefinedItem(); |
|
virtual bool BFinishInitialization_Internal( CUtlVector<CUtlString>* pVecErrors, ComponentAttribVector_t* attribVec ) OVERRIDE; |
|
#ifdef GC_DLL |
|
virtual bool AddRecipeComponentAsAttribute( CEconItem *pItem, const CEconGameAccount *pGameAccount ) const OVERRIDE; |
|
#endif |
|
protected: |
|
|
|
virtual bool ParseKV( KeyValues *pKV, CUtlVector<CUtlString> *pVecErrors ) OVERRIDE; |
|
|
|
friend class CDynamicRecipeComponentLootList; |
|
}; |
|
|
|
// Lootlist type: Use this when you want a random item from a lootlist to be a |
|
// component in a recipe. You must specify a quality in the definition |
|
// but it can get stomped if the lootlist-generated item gets an "elevate quality" |
|
// attribute rolled onto it. |
|
class CDynamicRecipeComponentLootList : public CBaseRecipeComponent |
|
{ |
|
typedef CBaseRecipeComponent BaseClass; |
|
public: |
|
CDynamicRecipeComponentLootList( bool bIsOutput, const CBaseRecipeComponent* pParent ); |
|
virtual ~CDynamicRecipeComponentLootList(); |
|
virtual bool BFinishInitialization_Internal( CUtlVector<CUtlString>* pVecErrors, ComponentAttribVector_t* attribVec ) OVERRIDE; |
|
protected: |
|
virtual bool ParseKV( KeyValues *pKV, CUtlVector<CUtlString> *pVecErrors ) OVERRIDE; |
|
|
|
private: |
|
#ifdef GC_DLL |
|
virtual bool AddRecipeComponentAsAttribute( CEconItem *pItem, const CEconGameAccount *pGameAccount ) const OVERRIDE; |
|
bool RollLootlistItemAndAttributes( CUtlVector< StringEncodedAttribute_t >& vecAdditionalAttributes |
|
, const char** pszDefName |
|
, const CUtlVector< item_definition_index_t > *pVecAvoidItemDefs |
|
, const CEconGameAccount *pGameAccount ) const; |
|
|
|
EItemDefUniqueness_t m_eUniqueness; |
|
#endif |
|
}; |
|
|
|
class CRecipeComponentInputDefIndexIterator : public CEconItemSpecificAttributeIterator |
|
{ |
|
public: |
|
CRecipeComponentInputDefIndexIterator( EItemDefUniqueness_t eUniqueness ); |
|
virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, |
|
const CAttribute_DynamicRecipeComponent& value ) OVERRIDE; |
|
|
|
const CUtlVector< item_definition_index_t >& GetMatchingComponentInputs() const { return m_vecInputItemDefs; } |
|
|
|
private: |
|
|
|
CUtlVector< item_definition_index_t > m_vecInputItemDefs; |
|
EItemDefUniqueness_t m_eUniqueness; |
|
}; |
|
|
|
const CUtlVector<CBaseRecipeComponent*>& GetComponents() const { return m_vecComponents; } |
|
|
|
private: |
|
|
|
// All the different components for this recipe |
|
CUtlVector<CBaseRecipeComponent*> m_vecComponents; |
|
// Errors we ecounter during initialization |
|
CUtlVector<CUtlString> m_vecErrors; |
|
}; |
|
|
|
class CWorldItemPlacementAttributeIterator : public CEconItemSpecificAttributeIterator |
|
{ |
|
public: |
|
CWorldItemPlacementAttributeIterator() {} |
|
|
|
virtual bool OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_WorldItemPlacement &value ) OVERRIDE |
|
{ |
|
Assert( pAttrDef ); |
|
if ( pAttrDef ) |
|
{ |
|
m_vecPlacementAttributes.AddToTail( pAttrDef ); |
|
} |
|
|
|
return true; |
|
} |
|
|
|
const CUtlVector< const CEconItemAttributeDefinition* > &GetPlacementAttributes( void ) const { return m_vecPlacementAttributes; } |
|
private: |
|
|
|
CUtlVector< const CEconItemAttributeDefinition* > m_vecPlacementAttributes; |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: Turns valid target items in to strange |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_Xifier : public IEconTool |
|
{ |
|
public: |
|
CEconTool_Xifier( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ) |
|
: IEconTool( pszTypeName, pszUseString, NULL, unCapabilities ) |
|
, m_RequiredTags( pUsageKV ? pUsageKV->FindKey( "required_tags" ) : NULL ) |
|
{ |
|
if ( pUsageKV ) |
|
{ |
|
KeyValues *pKVItemDefRestrictions = pUsageKV->FindKey( "itemdef_restrictions" ); |
|
if ( pKVItemDefRestrictions ) |
|
{ |
|
FOR_EACH_SUBKEY( pKVItemDefRestrictions, pKVTag ) |
|
{ |
|
m_ItemDefTargetRestrictions.AddToTail( atoi(pKVTag->GetName()) ); |
|
} |
|
} |
|
|
|
m_ItemRarityRestriction = pUsageKV->GetInt( "itemrarity_restrictions", k_unItemRarity_Any ); |
|
} |
|
|
|
m_sItemDescLocToken = pUsageKV ? pUsageKV->GetString( "item_desc_tool_target", "" ) : ""; |
|
} |
|
|
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const; |
|
|
|
const char *GetItemDescToolTargetLocToken() const { return m_sItemDescLocToken.String(); } |
|
|
|
#ifdef GC |
|
virtual CEconItem *GenerateNewItem( const IEconItemInterface *pTool, const CEconItem *pTarget ) const = 0; |
|
#endif |
|
|
|
#ifdef CLIENT_DLL |
|
virtual bool ShouldDisplayAsUseableOnItemsInArmory() const { return false; } |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
private: |
|
bool ItemDefMatch( const CEconItemDefinition* pTargetItemDef, const CEconItemDefinition* pSubjectItemDef ) const; |
|
|
|
CUtlString m_sItemDescLocToken; |
|
CEconTool_TagsList m_RequiredTags; |
|
CUtlVector<item_definition_index_t> m_ItemDefTargetRestrictions; |
|
|
|
uint8 m_ItemRarityRestriction; |
|
}; |
|
|
|
class CEconTool_Strangifier : public CEconTool_Xifier |
|
{ |
|
public: |
|
CEconTool_Strangifier( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ) |
|
: CEconTool_Xifier( pszTypeName, pszUseString, unCapabilities, pUsageKV ) {} |
|
|
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const; |
|
|
|
#ifdef GC |
|
virtual CEconItem *GenerateNewItem( const IEconItemInterface *pTool, const CEconItem *pTarget ) const; |
|
#endif |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
}; |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_KillStreakifier : public CEconTool_Xifier |
|
{ |
|
public: |
|
CEconTool_KillStreakifier( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ) |
|
: CEconTool_Xifier( pszTypeName, pszUseString, unCapabilities, pUsageKV ) {} |
|
|
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const; |
|
|
|
#ifdef GC |
|
virtual CEconItem *GenerateNewItem( const IEconItemInterface *pTool, const CEconItem *pTarget ) const; |
|
#endif |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
}; |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_Festivizer : public CEconTool_Xifier |
|
{ |
|
public: |
|
CEconTool_Festivizer( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ) |
|
: CEconTool_Xifier( pszTypeName, pszUseString, unCapabilities, pUsageKV ) |
|
{ |
|
} |
|
|
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const; |
|
|
|
#ifdef GC |
|
virtual CEconItem *GenerateNewItem( const IEconItemInterface *pTool, const CEconItem *pTarget ) const; |
|
#endif |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_Unusualifier : public CEconTool_Xifier |
|
{ |
|
public: |
|
CEconTool_Unusualifier( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ) |
|
: CEconTool_Xifier( pszTypeName, pszUseString, unCapabilities, pUsageKV ) {} |
|
|
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const; |
|
|
|
#ifdef GC |
|
virtual CEconItem *GenerateNewItem( const IEconItemInterface *pTool, const CEconItem *pTarget ) const; |
|
#endif |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Eats an item to give it charges |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_ItemEaterRecharger: public IEconTool |
|
{ |
|
public: |
|
CEconTool_ItemEaterRecharger( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ) |
|
: IEconTool( pszTypeName, pszUseString, NULL, unCapabilities ) |
|
, m_RequiredTags( pUsageKV ? pUsageKV->FindKey( "required_tags" ) : NULL ) |
|
{ |
|
if ( pUsageKV ) |
|
{ |
|
KeyValues *pKVItemDefRestrictions = pUsageKV->FindKey( "itemdef_restrictions" ); |
|
|
|
if ( pKVItemDefRestrictions ) |
|
{ |
|
FOR_EACH_SUBKEY( pKVItemDefRestrictions, pKVTag ) |
|
{ |
|
m_ItemDefTargetRestrictions.AddToTail( atoi(pKVTag->GetName()) ); |
|
m_ItemDefTargetChargeValues.AddToTail( pKVItemDefRestrictions->GetInt( pKVTag->GetName(), 0 ) ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
int GetChargesForItemDefId ( item_definition_index_t defIndex ) const; |
|
|
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const; |
|
|
|
#ifdef CLIENT_DLL |
|
virtual bool ShouldDisplayAsUseableOnItemsInArmory() const { return false; } |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
#ifdef GC_DLL |
|
virtual class CGCEconConsumableBehavior *CreateGCConsumableBehavior() const; |
|
#endif // GC_DLL |
|
|
|
private: |
|
CEconTool_TagsList m_RequiredTags; |
|
CUtlVector<item_definition_index_t> m_ItemDefTargetRestrictions; |
|
CUtlVector<int> m_ItemDefTargetChargeValues; |
|
}; |
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_UpgradeCard : public IEconTool |
|
{ |
|
public: |
|
struct upgrade_card_attr_value_t |
|
{ |
|
const CEconItemAttributeDefinition *m_pAttrDef; |
|
attrib_value_t m_value; |
|
}; |
|
|
|
typedef CUtlVectorFixedGrowable<upgrade_card_attr_value_t, 1> UpgradeCardAttributeVec_t; |
|
|
|
CEconTool_UpgradeCard( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ) |
|
: IEconTool( pszTypeName, pszUseString, NULL, unCapabilities ) |
|
, m_RequiredTags( pUsageKV ? pUsageKV->FindKey( "required_tags" ) : NULL ) |
|
{ |
|
COMPILE_TIME_ASSERT( sizeof( attrib_value_t ) == sizeof( uint32 ) ); |
|
COMPILE_TIME_ASSERT( sizeof( attrib_value_t ) == sizeof( float ) ); |
|
|
|
if ( pUsageKV ) |
|
{ |
|
KeyValues *pAttributesKV = pUsageKV->FindKey( "attributes" ); |
|
if ( pAttributesKV ) |
|
{ |
|
FOR_EACH_SUBKEY( pAttributesKV, pAttrKV ) |
|
{ |
|
const char *pszAttributeName = pAttrKV->GetName(); |
|
const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinitionByName( pszAttributeName ); |
|
|
|
// Kyle says: this is bad, dumb code, and more importantly it's bad dumb code that doesn't |
|
// make any sense here, way down inside the "parse a tool" function. |
|
attrib_value_t value; |
|
|
|
const bool bParseAsFloat = pAttrDef && pAttrDef->IsStoredAsFloat(); |
|
if ( bParseAsFloat ) |
|
{ |
|
*(float *)&value = pAttrKV->GetFloat(); |
|
} |
|
else |
|
{ |
|
*(uint32 *)&value = pAttrKV->GetInt(); |
|
} |
|
|
|
// Add this attribute to our list. Adding a NULL pointer is safe here. We'll use that to check |
|
// later in BFinishInitialization() whether we had a successful init or not. |
|
upgrade_card_attr_value_t attrValue = { pAttrDef, value }; |
|
m_vecAttributes.AddToTail( attrValue ); |
|
} |
|
} |
|
} |
|
} |
|
|
|
virtual bool BFinishInitialization() OVERRIDE |
|
{ |
|
// Make sure we didn't fail to find any attributes. |
|
FOR_EACH_VEC( m_vecAttributes, i ) |
|
{ |
|
if ( m_vecAttributes[i].m_pAttrDef == NULL ) |
|
return false; |
|
} |
|
|
|
// Make sure we have a non-zero number of attributes. If we don't have at least one, applicable would be |
|
// a nonsensical action. |
|
return m_vecAttributes.Count() > 0 |
|
&& IEconTool::BFinishInitialization(); |
|
} |
|
|
|
const UpgradeCardAttributeVec_t& GetAttributes() const { return m_vecAttributes; } |
|
|
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const; |
|
|
|
#ifdef CLIENT_DLL |
|
virtual bool ShouldDisplayAsUseableOnItemsInArmory() const { return false; } |
|
|
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
private: |
|
CEconTool_TagsList m_RequiredTags; |
|
UpgradeCardAttributeVec_t m_vecAttributes; |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_ClassTransmogrifier : public IEconTool |
|
{ |
|
public: |
|
CEconTool_ClassTransmogrifier( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ) |
|
: IEconTool( pszTypeName, pszUseString, NULL, unCapabilities ) |
|
, m_RequiredTags( pUsageKV ? pUsageKV->FindKey( "required_tags" ) : NULL ) |
|
, m_iClass( -1 ) |
|
{ |
|
KeyValues *pKVOutputClass = pUsageKV->FindKey( "output_class" ); |
|
if ( pKVOutputClass ) |
|
{ |
|
m_iClass = StringFieldToInt( pKVOutputClass->GetString( "" ), GetItemSchema()->GetClassUsabilityStrings() ); |
|
} |
|
} |
|
|
|
virtual bool BFinishInitialization() OVERRIDE |
|
{ |
|
return m_iClass > 0 |
|
&& m_iClass < LOADOUT_COUNT |
|
&& IEconTool::BFinishInitialization(); |
|
} |
|
|
|
int GetOutputClass() const { return m_iClass; } |
|
const CEconTool_TagsList& GetRequiredTags() const { return m_RequiredTags; } |
|
|
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const; |
|
|
|
#ifdef CLIENT_DLL |
|
virtual bool ShouldDisplayAsUseableOnItemsInArmory() const { return false; } |
|
|
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
private: |
|
CEconTool_TagsList m_RequiredTags; // required for both the input item and the output item |
|
int m_iClass; |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_BackpackExpander : public IEconTool |
|
{ |
|
public: |
|
CEconTool_BackpackExpander ( const char *pszTypeName, const char *pszUseString, KeyValues *pUsageKV ) |
|
: IEconTool( pszTypeName, pszUseString, NULL, ITEM_CAP_NONE ) |
|
, m_iBackpackSlots( 0 ) |
|
{ |
|
if ( pUsageKV ) |
|
{ |
|
m_iBackpackSlots = pUsageKV->GetInt( "backpack_slots", 0 ); |
|
} |
|
} |
|
|
|
virtual bool BFinishInitialization() OVERRIDE |
|
{ |
|
return m_iBackpackSlots > 0 |
|
&& IEconTool::BFinishInitialization(); |
|
} |
|
|
|
int GetBackpackSlots() const { return m_iBackpackSlots; } |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
#ifdef GC_DLL |
|
virtual class CGCEconConsumableBehavior *CreateGCConsumableBehavior() const; |
|
#endif // GC_DLL |
|
|
|
private: |
|
int m_iBackpackSlots; |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_AccountUpgradeToPremium : public IEconTool |
|
{ |
|
public: |
|
CEconTool_AccountUpgradeToPremium( const char *pszTypeName, const char *pszUseString ) : IEconTool( pszTypeName, pszUseString, NULL, ITEM_CAP_NONE ) { } |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
#ifdef GC_DLL |
|
virtual class CGCEconConsumableBehavior *CreateGCConsumableBehavior() const; |
|
#endif // GC_DLL |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_DuckToken: public IEconTool |
|
{ |
|
public: |
|
CEconTool_DuckToken( const char *pszTypeName, item_capabilities_t unCapabilities ) : IEconTool( pszTypeName, NULL, NULL, unCapabilities ) { } |
|
|
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const; |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
#ifdef GC_DLL |
|
//virtual class CGCEconConsumableBehavior *CreateGCConsumableBehavior() const; |
|
#endif // GC_DLL |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_GrantOperationPass : public IEconTool |
|
{ |
|
public: |
|
CEconTool_GrantOperationPass( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ) : IEconTool( pszTypeName, pszUseString, NULL, ITEM_CAP_NONE ) |
|
{ |
|
m_pOperationPassName = NULL; |
|
m_pOptionalBonusLootList = NULL; |
|
if ( pUsageKV ) |
|
{ |
|
// Find the Item |
|
m_pOperationPassName = pUsageKV->GetString( "operation_pass", NULL ); |
|
m_pOptionalBonusLootList = pUsageKV->GetString( "bonus_lootlist", NULL ); |
|
} |
|
} |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
#ifdef GC_DLL |
|
virtual class CGCEconConsumableBehavior *CreateGCConsumableBehavior() const; |
|
#endif // GC_DLL |
|
|
|
const char *m_pOperationPassName; |
|
const char *m_pOptionalBonusLootList; |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_ClaimCode : public IEconTool |
|
{ |
|
public: |
|
CEconTool_ClaimCode ( const char *pszTypeName, const char *pszUseString, KeyValues *pUsageKV ) |
|
: IEconTool( pszTypeName, pszUseString, NULL, ITEM_CAP_NONE ) |
|
, m_pszClaimType( NULL ) |
|
{ |
|
if ( pUsageKV ) |
|
{ |
|
m_pszClaimType = pUsageKV->GetString( "claim_type", NULL ); |
|
} |
|
} |
|
|
|
virtual bool BFinishInitialization() OVERRIDE |
|
{ |
|
return m_pszClaimType |
|
&& IEconTool::BFinishInitialization(); |
|
} |
|
|
|
const char *GetClaimType() const { return m_pszClaimType; } |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
#ifdef GC_DLL |
|
virtual class CGCEconConsumableBehavior *CreateGCConsumableBehavior() const; |
|
#endif // GC_DLL |
|
|
|
private: |
|
const char *m_pszClaimType; |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
enum EGiftTargetRule |
|
{ |
|
kGiftTargetRule_OnlyOthers = 0, |
|
kGiftTargetRule_OnlySelf = 1, |
|
}; |
|
|
|
class CEconTool_Gift : public IEconTool |
|
{ |
|
public: |
|
CEconTool_Gift ( const char *pszTypeName, const char *pszUseString, KeyValues *pUsageKV ) |
|
: IEconTool( pszTypeName, pszUseString, NULL, ITEM_CAP_NONE ) |
|
, m_pszLootListName( NULL ) |
|
, m_iMaxRecipients( 0 ) |
|
, m_eTargetRule( kGiftTargetRule_OnlySelf ) |
|
{ |
|
if ( pUsageKV ) |
|
{ |
|
m_pszLootListName = pUsageKV->GetString( "loot_list", NULL ); |
|
m_iMaxRecipients = pUsageKV->GetInt( "max_recipients", 0 ); |
|
m_eTargetRule = !Q_stricmp( pUsageKV->GetString( "target_rule", "only_others" ), "only_self" ) |
|
? kGiftTargetRule_OnlySelf |
|
: kGiftTargetRule_OnlyOthers; |
|
} |
|
} |
|
|
|
virtual bool BFinishInitialization() OVERRIDE |
|
{ |
|
return m_pszLootListName |
|
&& GetItemSchema()->GetLootListByName( m_pszLootListName ) |
|
&& m_iMaxRecipients > 0 |
|
&& IEconTool::BFinishInitialization(); |
|
} |
|
|
|
const char *GetLootListName() const { return m_pszLootListName; } |
|
int GetMaxRecipients() const { return m_iMaxRecipients; } |
|
EGiftTargetRule GetTargetRule() const { return m_eTargetRule; } |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
#ifdef GC_DLL |
|
virtual class CGCEconConsumableBehavior *CreateGCConsumableBehavior() const; |
|
#endif // GC_DLL |
|
|
|
private: |
|
const char *m_pszLootListName; |
|
int m_iMaxRecipients; |
|
EGiftTargetRule m_eTargetRule; |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_PaintCan : public IEconTool |
|
{ |
|
public: |
|
CEconTool_PaintCan( const char *pszTypeName, item_capabilities_t unCapabilities ) : IEconTool( pszTypeName, NULL, NULL, unCapabilities ) { } |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_GiftWrap : public IEconTool |
|
{ |
|
public: |
|
CEconTool_GiftWrap( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV ); |
|
|
|
virtual bool BFinishInitialization() OVERRIDE; |
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const; |
|
virtual bool RequiresToolEscrowPeriod() const { return false; } |
|
|
|
const CEconItemDefinition *GetWrappedItemDefinition() const { Assert( m_pWrappedGiftItemDef ); return m_pWrappedGiftItemDef; } |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
|
|
private: |
|
const char *m_pszWrappedGiftItemDefName; // points to memory inside our init KV -- only valid between the constructor call and the BFinishInitialization() call (this is messy but Fletcher and I agree it makes more sense than switching to a full two-pass schema parse just for this) |
|
const CEconItemDefinition *m_pWrappedGiftItemDef; |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_NameTag : public IEconTool |
|
{ |
|
public: |
|
CEconTool_NameTag( const char *pszTypeName, item_capabilities_t unCapabilities ) : IEconTool( pszTypeName, NULL, NULL, unCapabilities ) { } |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_DescTag : public IEconTool |
|
{ |
|
public: |
|
CEconTool_DescTag( const char *pszTypeName, item_capabilities_t unCapabilities ) : IEconTool( pszTypeName, NULL, NULL, unCapabilities ) { } |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_CustomizeTexture : public IEconTool |
|
{ |
|
public: |
|
CEconTool_CustomizeTexture( const char *pszTypeName, item_capabilities_t unCapabilities ) : IEconTool( pszTypeName, NULL, NULL, unCapabilities ) { } |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_CrateKey : public IEconTool |
|
{ |
|
public: |
|
CEconTool_CrateKey( const char *pszTypeName, const char *pszUsageRestriction, item_capabilities_t unCapabilities ) : IEconTool( pszTypeName, NULL, pszUsageRestriction, unCapabilities ) { } |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientApplyTool( CEconItemView *pTool, CEconItemView *pSubject, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
}; |
|
|
|
//--------------------------------------------------------------------------------------- |
|
// Purpose: |
|
//--------------------------------------------------------------------------------------- |
|
class CEconTool_Default : public IEconTool |
|
{ |
|
public: |
|
CEconTool_Default( const char *pszTypeName, const char *pszUseString, const char *pszUsageRestriction, item_capabilities_t unCapabilities ) |
|
: IEconTool( pszTypeName, pszUseString, pszUsageRestriction, unCapabilities ) |
|
{ |
|
Assert( pszTypeName ); |
|
} |
|
|
|
#ifdef CLIENT_DLL |
|
virtual void OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const; |
|
#endif // CLIENT_DLL |
|
}; |
|
|
|
//----------------------------------------------------------------------------- |
|
// Purpose: |
|
//----------------------------------------------------------------------------- |
|
|
|
class CCountUserGeneratedAttributeIterator : public IEconItemUntypedAttributeIterator |
|
{ |
|
public: |
|
CCountUserGeneratedAttributeIterator() : m_iCount( 0 ) { } |
|
|
|
virtual bool OnIterateAttributeValueUntyped( const CEconItemAttributeDefinition *pAttrDef ) OVERRIDE |
|
{ |
|
if ( pAttrDef->GetUserGenerationType() != 0 ) |
|
{ |
|
m_iCount++; |
|
} |
|
|
|
return true; |
|
} |
|
|
|
int GetCount() const { return m_iCount; } |
|
|
|
private: |
|
int m_iCount; |
|
}; |
|
|
|
#endif // ECONITEMTOOLS_H
|
|
|