1HEADmaster

1 files changed, 1043 insertions, 0 deletions

diff --git a/game/shared/econ/econ_item_tools.h b/game/shared/econ/econ_item_tools.h
new file mode 100644
index 0000000..b6adfe9
--- /dev/null
+++ b/game/shared/econ/econ_item_tools.h
@@ -0,0 +1,1043 @@
+//========= 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