tf2/tf2_src/game/shared/econ/econ_item_tools.cpp

//========= Copyright Valve Corporation, All rights reserved. ============//
#include "cbase.h"
#include "game_item_schema.h"
#include "econ_item_interface.h"
#include "econ_item_tools.h"
#include "econ_item_constants.h"
#include "econ_dynamic_recipe.h"
#include "schemainitutils.h"



bool BStringsEqual( const char *pszA, const char *pszB )
{
	if ( pszA == NULL )
		return pszB == NULL;

	if ( pszB == NULL )
		return false;

	return !V_strcmp( pszA, pszB );
}

const unsigned int g_CapabilityApplicationMap[] =
{
															// if we have a tool that has this capability...
	// ...then we check to see if the tool target has
	// this capability

	ITEM_CAP_PAINTABLE,										// ITEM_CAP_PAINTABLE
	ITEM_CAP_NAMEABLE,										// ITEM_CAP_NAMEABLE
	ITEM_CAP_DECODABLE,										// ITEM_CAP_DECODABLE
	0,														// ITEM_CAP_UNUSED; was ITEM_CAP_CAN_MOD_SOCKET
	ITEM_CAP_CAN_CUSTOMIZE_TEXTURE,							// ITEM_CAP_CAN_CUSTOMIZE_TEXTURE
	0,														// ITEM_CAP_USABLE
	0,														// ITEM_CAP_USABLE_GC
	ITEM_CAP_CAN_GIFT_WRAP,									// ITEM_CAP_CAN_GIFT_WRAP
	0,														// ITEM_CAP_USABLE_OUT_OF_GAME
	ITEM_CAP_CAN_COLLECT,									// ITEM_CAP_CAN_COLLECT
	0,														// ITEM_CAP_CAN_CRAFT_COUNT
	0,														// ITEM_CAP_CAN_CRAFT_MARK
	ITEM_CAP_PAINTABLE_TEAM_COLORS | ITEM_CAP_PAINTABLE,	// ITEM_CAP_PAINTABLE_TEAM_COLORS
	0,														// ITEM_CAP_CAN_BE_RESTORED
	ITEM_CAP_CAN_USE_STRANGE_PARTS,							// ITEM_CAP_CAN_USE_STRANGE_PARTS
	ITEM_CAP_CAN_CARD_UPGRADE,								// ITEM_CAP_CAN_CARD_UPGRADE
	ITEM_CAP_CAN_STRANGIFY,									// ITEM_CAP_CAN_STRANGIFY
	ITEM_CAP_CAN_KILLSTREAKIFY,								// ITEM_CAP_CAN_KILLSTREAKIFY
	ITEM_CAP_CAN_CONSUME,									// ITEM_CAP_CAN_CONSUME
	ITEM_CAP_CAN_SPELLBOOK_PAGE,							// ITEM_CAP_CAN_SPELLBOOK_PAGE
	ITEM_CAP_HAS_SLOTS,										// ITEM_CAP_HAS_SLOTS
	ITEM_CAP_DUCK_UPGRADABLE,								// ITEM_CAP_DUCK_UPGRADABLE
	ITEM_CAP_CAN_UNUSUALIFY,								// ITEM_CAP_CAN_UNUSUALIFY
};

COMPILE_TIME_ASSERT( ARRAYSIZE( g_CapabilityApplicationMap ) == NUM_ITEM_CAPS );

//---------------------------------------------------------------------------------------
// Purpose:
//---------------------------------------------------------------------------------------
bool IEconTool::ShouldDisplayQuantity( const IEconItemInterface *pTool ) const
{
	Assert( pTool );

	const GameItemDefinition_t *pItemDef = pTool->GetItemDefinition();
	if ( !pItemDef )
		return false;

	static CSchemaAttributeDefHandle pAttrDef_UnlimitedQuantity( "unlimited quantity" );
	if ( pTool->FindAttribute( pAttrDef_UnlimitedQuantity ) )
		return false;

	if ( pTool->GetQuantity() >= 0 )
	{
		if ( (pItemDef->GetCapabilities() & ITEM_CAP_USABLE_GC) != 0 )
			return true;

		if ( pItemDef->IsTool() )
			return true;
	}

	return false;
}

//---------------------------------------------------------------------------------------
// Purpose:
//---------------------------------------------------------------------------------------
CEconTool_WrappedGift::CEconTool_WrappedGift( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV )
	: IEconTool( pszTypeName, pszUseString, NULL, unCapabilities )
	, m_pszDeliveredGiftItemDefName( NULL )
	, m_pDeliveredGiftItemDef( NULL )
	, m_bIsGlobalGift( false )
	, m_bIsDirectGift( false )
{
	if ( pUsageKV )
	{
		m_bIsGlobalGift = pUsageKV->GetBool( "target_type_global", false );
		m_pszDeliveredGiftItemDefName = pUsageKV->GetString( "delivered_gift_item_def", NULL );
		m_bIsDirectGift = pUsageKV->GetBool( "is_direct_gift", false );
	}
}

//---------------------------------------------------------------------------------------
// Purpose:
//---------------------------------------------------------------------------------------
bool CEconTool_WrappedGift::BFinishInitialization()
{
	// Now that we've finished parsing our definitions, look for a match.
	if ( m_pszDeliveredGiftItemDefName )
	{
		m_pDeliveredGiftItemDef = GetItemSchema()->GetItemDefinitionByName( m_pszDeliveredGiftItemDefName );
	}

	// We're done with this value.
	m_pszDeliveredGiftItemDefName = NULL;

	return IEconTool::BFinishInitialization();
}

//---------------------------------------------------------------------------------------
// Purpose:
//---------------------------------------------------------------------------------------
CEconTool_GiftWrap::CEconTool_GiftWrap( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV )
	: IEconTool( pszTypeName, NULL, NULL, unCapabilities )
	, m_pszWrappedGiftItemDefName( NULL )
	, m_pWrappedGiftItemDef( NULL )
{
	if ( pUsageKV )
	{
		m_pszWrappedGiftItemDefName = pUsageKV->GetString( "wrapped_gift_item_def", NULL );
	}
}

//---------------------------------------------------------------------------------------
// Purpose:
//---------------------------------------------------------------------------------------
bool CEconTool_GiftWrap::BFinishInitialization()
{
	// Now that we've finished parsing our definitions, look for a match.
	if ( m_pszWrappedGiftItemDefName )
	{
		m_pWrappedGiftItemDef = GetItemSchema()->GetItemDefinitionByName( m_pszWrappedGiftItemDefName );
	}

	// We're done with this value.
	m_pszWrappedGiftItemDefName = NULL;

	return m_pWrappedGiftItemDef != NULL
		&& IEconTool::BFinishInitialization();
}

//---------------------------------------------------------------------------------------
// Purpose:
//---------------------------------------------------------------------------------------
bool CEconTool_GiftWrap::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
{
	Assert( pTool );
	Assert( pToolSubject );

	if ( pToolSubject->GetQuality() == AE_SELFMADE ||
		 pToolSubject->GetQuality() == AE_COMMUNITY ||
		 pToolSubject->GetQuality() == AE_CUSTOMIZED ||
		 pToolSubject->GetQuality() == AE_NORMAL )
	{
		return false;
	}

	// If an item is currently trade restricted, other flags don't matter (I think).
	if ( ( pToolSubject->GetUntradabilityFlags() & k_Untradability_Temporary ) != 0 )
		return false;

	// One item still has the gift wrap cap, which is the engagement ring ( Something Special For Someone Special (Tool) ).
	// However, the can_gift_wrap cap shouldn't overcome temporary trade restrictions.
	static CSchemaAttributeDefHandle pAttrDef_ToolNeedsGiftwrap( "tool needs giftwrap" );

	const bool cbSubjectNeedsGiftWrap = pToolSubject->FindAttribute( pAttrDef_ToolNeedsGiftwrap );
	const bool cbSubjectCanTrade = pToolSubject->IsTradable();
	const bool cbSubjectCanProceed = cbSubjectNeedsGiftWrap || cbSubjectCanTrade;
 
	if ( !cbSubjectCanProceed )
		return false;

	static CSchemaAttributeDefHandle pAttrDef_CannotGiftwrap( "cannot giftwrap" );
	if ( pToolSubject->FindAttribute( pAttrDef_CannotGiftwrap ) )
		return false;

	return IEconTool::CanApplyTo( pTool, pToolSubject );
}

CEconTool_StrangeCountTransfer::CEconTool_StrangeCountTransfer( const char *pszTypeName, item_capabilities_t unCapabilities ) 
	: IEconTool( pszTypeName, NULL, NULL, unCapabilities )
{
#ifdef CLIENT_DLL
	m_pItemSrc = NULL;
	m_pItemDest = NULL;
#endif // CLIENT_DLL
}

bool CEconTool_StrangeCountTransfer::AreItemsEligibleForStrangeCountTransfer( const IEconItemInterface *pItem1, const IEconItemInterface *pItem2 )
{
	if ( !pItem1 || !pItem2 )
		return false;

	const char *pItem1Xifier = pItem1->GetItemDefinition()->GetXifierRemapClass();
	const char *pItem2Xifier = pItem2->GetItemDefinition()->GetXifierRemapClass();

	// if no xifier class, check if the item defs are the same
	if ( !pItem1Xifier || !pItem2Xifier )
	{
		if ( pItem1->GetItemDefinition() != pItem2->GetItemDefinition() )
		{
			return false;
		}
	}
	else if ( V_stricmp( pItem1Xifier, pItem2Xifier ) != 0 )
	{
		return false;
	}
	
	// Item defs are compatabible, are there attributes? Check strange
	// Check if they are both strange (have kill eater). Quality is less important
	if ( !BIsItemStrange( pItem1) || !BIsItemStrange( pItem2 ) )
		return false;

	return true;
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconTool_StrangePart::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
{
	Assert( pTool );
	Assert( pToolSubject );

	// Abort if for some reason we don't know what type of attribute we're trying to track.
	static CSchemaAttributeDefHandle pAttrDef_StrangePartCounterID( "strange part new counter ID" );

	float flNewScoreType;
	if ( !FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pTool, pAttrDef_StrangePartCounterID, &flNewScoreType ) )
		return false;

	// Make sure we're "strange" in that we have at least one attribute tracking scores. We can't
	// explicitly test for quality here because now we can have strange vintages, etc.
	if ( GetKillEaterAttrCount() <= 0 )
		return false;

	if ( !pToolSubject->FindAttribute( GetKillEaterAttr_Score( 0 ) ) )
		return false;

	// Make sure the target item doesn't already have the property this tool is trying to
	// apply, unless that counter is restricted, in which case we allow a second stat to be
	// added with the same value.
	for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
	{
		float flScoreType;
		if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pToolSubject, GetKillEaterAttr_Type( i ), &flScoreType ) &&	// if we have a counter in this slot...
			 RoundFloatToInt( flScoreType ) == RoundFloatToInt( flNewScoreType ) &&		// ...and it's counting the same thing...
			 !pToolSubject->FindAttribute( GetKillEaterAttr_Restriction( i ) ) )		// ...and that counter isn't restricted
		{
			return false;
		}
	}

	// Make sure we have at least one empty customizable attribute slot.
	bool bFoundEmptyAttributeSlot = false;

	for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
	{
		// Ignore non-user-customizable attributes.
		if ( !GetKillEaterAttr_IsUserCustomizable( i ) )
			continue;

		// We expect to have both or neither of a user-customizable attribute. If this isn't the
		// case the later logic will be wrong.
		const bool bFoundTypeAttribute = pToolSubject->FindAttribute( GetKillEaterAttr_Type( i ) );
		Assert( bFoundTypeAttribute == pToolSubject->FindAttribute( GetKillEaterAttr_Score( i ) ) );

		if ( !bFoundTypeAttribute )
		{
			bFoundEmptyAttributeSlot = true;
			break;
		}
	}

	if ( !bFoundEmptyAttributeSlot )
		return false;

	// Check to make sure the definition of the item we're trying to apply to has the tags we need
	// to match and doesn't have any tags that we need to avoid. We use these to avoid tracking
	// damage done for a medigun, etc.
	const GameItemDefinition_t *pSubjectItemDef = pToolSubject->GetItemDefinition();
	if ( !pSubjectItemDef )
		return false;

#if defined( TF_DLL ) || defined( TF_GC_DLL ) || defined( TF_CLIENT_DLL )
	// Strange Cosmetics can take on any part
	if ( pSubjectItemDef->GetDefaultLoadoutSlot() == LOADOUT_POSITION_MISC )
	{
		return true;
	}
#endif

	FOR_EACH_VEC( m_RequiredTags.GetTagsList(), i )
	{
		if ( !pSubjectItemDef->HasEconTag( m_RequiredTags.GetTagsList()[i] ) )
			return false;
	}

	FOR_EACH_VEC( m_RequiredMissingTags.GetTagsList(), i )
	{
		if ( pSubjectItemDef->HasEconTag( m_RequiredMissingTags.GetTagsList()[i] ) )
			return false;
	}
	
	return IEconTool::CanApplyTo( pTool, pToolSubject );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static const char *s_pszStrangeRestrictionTypes[] =
{
	"",										// kStrangeEventRestriction_None
	"victim_account_id",					// kStrangeEventRestriction_VictimSteamAccount
#if defined( TF_DLL ) || defined( TF_GC_DLL ) || defined( TF_CLIENT_DLL )
	"map",									// kStrangeEventRestriction_Map
	"competitive",							// kStrangeEventRestriction_Competitive
#endif // defined( TF_DLL ) || defined( TF_GC_DLL ) || defined( TF_CLIENT_DLL )
};

COMPILE_TIME_ASSERT( ARRAYSIZE( s_pszStrangeRestrictionTypes ) == kStrangeEventRestrictionCount );

CEconTool_StrangePartRestriction::CEconTool_StrangePartRestriction( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV )
	: IEconTool( pszTypeName, pszUseString, NULL, unCapabilities )
	, m_eRestrictionType( kStrangeEventRestriction_None )				// default-initialize to failure
	, m_unRestrictionValue( (unsigned int)-1 )
{
	Assert( pUsageKV != NULL );

	// Parse our restriction type from a string. Anything invalid here will be handled below in the IsValid()
	// check.
	const int iRestrictionType = StringFieldToInt( pUsageKV->GetString( "restriction_type", "" ), &s_pszStrangeRestrictionTypes[0], ARRAYSIZE( s_pszStrangeRestrictionTypes ) );
	if ( iRestrictionType > 0 )
	{
		m_eRestrictionType = (strange_event_restriction_t)iRestrictionType;
	}

	// We'll use this value later from inside BFinishInitialization(). We may have to look at other
	// values from parts of the schema that haven't been parsed yet, like map or item names.
	m_pszRestrictionValue = pUsageKV->GetString( "restriction_value", NULL );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconTool_StrangePartRestriction::BFinishInitialization()
{
	// Run different parsers based on our restriction type.
	switch ( m_eRestrictionType )
	{
		// We don't expect anything for our sub-value when dealing with Steam accounts. Asserting based on
		// bad data is dumb but we don't really have any way of sending an error all the way up the tree.
		case kStrangeEventRestriction_None:
		case kStrangeEventRestriction_VictimSteamAccount:
			if ( m_pszRestrictionValue )
				return false;
			
			m_unRestrictionValue = 0;
			break;

#if defined( TF_DLL ) || defined( TF_GC_DLL ) || defined( TF_CLIENT_DLL )
		case kStrangeEventRestriction_Map:
		{
			if ( !m_pszRestrictionValue )
				return false;

			const MapDef_t *pSchemaMap = GetItemSchema()->GetMasterMapDefByName( m_pszRestrictionValue );
			if ( !pSchemaMap )
				return false;

			m_unRestrictionValue = pSchemaMap->m_nDefIndex;
		}
		break;
		case kStrangeEventRestriction_Competitive:
		{
			if (!m_pszRestrictionValue)
				return false;

			// Season string to int
			m_unRestrictionValue = V_atoi(m_pszRestrictionValue);
		}
		break;
#endif // defined( TF_DLL ) || defined( TF_GC_DLL ) || defined( TF_CLIENT_DLL )

		default:
			AssertMsg1( false, "CEconTool_StrangePartRestriction() doesn't understand how to parse restriction type %i.", m_eRestrictionType );
			return false;
	}

	// We're done with this value now.
	m_pszRestrictionValue = NULL;

	return m_eRestrictionType != kStrangeEventRestriction_None
		&& m_unRestrictionValue != (unsigned int)-1
		&& IEconTool::BFinishInitialization();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconTool_StrangePartRestriction::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
{
	Assert( pTool );
	Assert( pTool->GetItemDefinition() );
	Assert( pToolSubject );

	if ( !IEconTool::CanApplyTo( pTool, pToolSubject ) )
		return false;

	// Abort if for some reason we don't know what type of restriction we're trying to apply.
	if ( m_eRestrictionType == kStrangeEventRestriction_None )
		return false;

	// Abort if we don't have our tool information. We'll need this below to avoid duplicating
	// scores/restrictions.
	const CEconTool_StrangePartRestriction *pToolRestriction = pTool->GetItemDefinition()->GetTypedEconTool<CEconTool_StrangePartRestriction>();
	if ( !pToolRestriction )
		return false;

	// Make sure we're "strange" in that we have at least one attribute tracking scores. We can't
	// explicitly test for quality here because now we can have strange vintages, etc.
	if ( GetKillEaterAttrCount() <= 0 )
		return false;

	if ( !pToolSubject->FindAttribute( GetKillEaterAttr_Score( 0 ) ) )
		return false;
	
	// Look through all of the strange attributes on this item. We're looking for a slot that
	// has a score that we're tracking where that score doesn't already have a restriction.
	// If we find one, we can restrict that particular slot as long as doing so wouldn't generate
	// a duplicate score (ie., "soldier kills on Hightower"). We don't need to enumerate them
	// here, just find existence/nonexistence of at least one valid target.
	for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
	{
		if ( GetItemSchema()->BCanStrangeFilterApplyToStrangeSlotInItem( pToolRestriction->GetRestrictionType(), pToolRestriction->GetRestrictionValue(), pToolSubject, i, NULL ) )
			return true;
	}

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
CEconTool_ItemDynamicRecipe::CEconTool_ItemDynamicRecipe( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV )
	: IEconTool( pszTypeName, pszUseString, NULL, unCapabilities )
{
	COMPILE_TIME_ASSERT( sizeof( attrib_value_t ) == sizeof( uint32 ) );
	COMPILE_TIME_ASSERT( sizeof( attrib_value_t ) == sizeof( float ) );

	if ( pUsageKV )
	{
		BInitFromKV( pUsageKV, &m_vecErrors );
	}
}

const char* CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::m_pszUseParentNameIdentifier = "use_parents_item_def";

//-----------------------------------------------------------------------------
// Purpose: Make sure each of our components are fully formed.  Return false
//			if any components fail BFinishInitialization_Internal()
//-----------------------------------------------------------------------------
bool CEconTool_ItemDynamicRecipe::BFinishInitialization()
{
	CBaseRecipeComponent::ComponentAttribVector_t attribVec;

	FOR_EACH_VEC( m_vecComponents, i )
	{
		m_vecComponents[i]->BFinishInitialization_Internal( &m_vecErrors, &attribVec );	
	}

	// Emit any errors we've accumulated during initialization
	FOR_EACH_VEC( m_vecErrors, i )
	{
#ifdef GC_DLL
		EmitError( SPEW_GC, "%s\n", m_vecErrors[i].Get() );
#else
		AssertMsg1( 0, "%s\n", m_vecErrors[i].Get() );
#endif
	}

	if( m_vecErrors.Count() > 0 )
		return false;

	// Make sure we have at least one item required
	return IEconTool::BFinishInitialization();
}

//-----------------------------------------------------------------------------
// Purpose: Iterate through attributes on pTool to see if any can accept pToolSubject.
//			Return true if any attributes match.
//-----------------------------------------------------------------------------
bool CEconTool_ItemDynamicRecipe::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
{
	Assert( pTool );
	Assert( pToolSubject );

	// Iterate through all the attributes on the tool and see if the subject item matches
	// any of the recipe component attributes
	CRecipeComponentMatchingIterator matchingIterator( pTool, pToolSubject );
	pTool->IterateAttributes( &matchingIterator );

	const CUtlVector< const CEconItemAttributeDefinition* >& vecMatchingAttribs = matchingIterator.GetMatchingComponentInputs();
	// No matches, can't apply!
	if( vecMatchingAttribs.Count() == 0 )
	{
		return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::CBaseRecipeComponent( bool bIsOutput, const CBaseRecipeComponent* pParent ) 
	: m_bIsOutput( bIsOutput )
	, m_flChanceOfApplying( 1.f )
	, m_pParent( pParent )
	, m_flTotalWeights( 0.f )
	, m_eQuality( AE_UNDEFINED )
	, m_attributesMatchingType( ATTRIBUTES_MATCH_NONE )
{}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::~CBaseRecipeComponent()
{
	m_vecAdditionalComponents.PurgeAndDeleteElements();
}

//-----------------------------------------------------------------------------
// Purpose:	 Roll chance of component applying to the tool
//-----------------------------------------------------------------------------
#ifdef GC_DLL
int CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::RollCount() const
{
	if( m_vecCountChances.Count() == 0 )
		return 1;

	float flRand = RandomFloat( 0.f, 1.f ) * m_flTotalWeights;
	float flAccum = 0.f;

	// Go through and see which counts gets rolled
	FOR_EACH_VEC( m_vecCountChances, i )
	{
		const CountChance_t& countChance = m_vecCountChances[i];

		flAccum += countChance.m_flChance;
		if ( flRand <= flAccum )
		{
			// Winner!  Roll within its range
			return RandomInt( countChance.m_nMinCount, countChance.m_nMaxCount );
		}
	}

	AssertMsg( 0, "Failed to generate a count for recipe component.  Defaulting to 1" );
	return 1;
}

bool CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::RollChanceOfApplying() const
{
	// Guaranteed!
	if( m_flChanceOfApplying == 1.f )
		return true;

	return RandomFloat() < m_flChanceOfApplying;
}
#endif

//-----------------------------------------------------------------------------
// Purpose: Set chance for attributes to apply.
//-----------------------------------------------------------------------------
void CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::SetChanceOfApplying( float flChance )
{
	Assert( flChance >= 0.f && flChance <= 1.f );
	clamp( flChance, 0.f, 1.f );
	m_flChanceOfApplying = flChance;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::BFinishInitialization_Internal( CUtlVector<CUtlString>* pVecErrors, ComponentAttribVector_t* pAttribVec  )
{
	FOR_EACH_VEC( m_vecAdditionalComponents, i )
	{
		SCHEMA_INIT_SUBSTEP( m_vecAdditionalComponents[i]->BFinishInitialization_Internal( pVecErrors, pAttribVec ) );
	}

	return SCHEMA_INIT_SUCCESS();
}

void CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::GetIsGuaranteed( int &nFlags ) const
{
	// If we've got a 100% chance of applying, or we're the root (no parent) then we
	// can mark ourselves as guaranteed and continue to check our children to see if
	// any of them are guaranteed as well.
	if ( m_flChanceOfApplying == 1.f || !m_pParent )
	{
		nFlags |= GetIsOutput() ? GUARANTEED_OUTPUT : GUARANTEED_INPUT;

		FOR_EACH_VEC( m_vecAdditionalComponents, i )
		{
			m_vecAdditionalComponents[i]->GetIsGuaranteed( nFlags );
		}
	}
}


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentDefinedItem::CDynamicRecipeComponentDefinedItem( bool bIsOutput, const CBaseRecipeComponent* pParent )
	: CBaseRecipeComponent( bIsOutput, pParent )
{}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentDefinedItem::~CDynamicRecipeComponentDefinedItem()
{}

//-----------------------------------------------------------------------------
// Purpose: Make sure m_strName refers to an actual item def.  Return false
//			if it doesn not.  Child components are allowed to have "use_parents_item_def"
//			as their item name.
//-----------------------------------------------------------------------------
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentDefinedItem::BFinishInitialization_Internal( CUtlVector<CUtlString>* pVecErrors, ComponentAttribVector_t* pAttribVec )
{
	// Go through and make sure we have a bit of information that let's us describe an item
	bool bAnyDataSet = false;

	// Item def?
	if ( m_pParent == NULL && GetItemSchema()->GetItemDefinitionByName( m_strName ) )
	{
		bAnyDataSet = true;
	}
	else if ( BStringsEqual( m_strName, m_pszUseParentNameIdentifier ) || GetItemSchema()->GetItemDefinitionByName( m_strName ) )
	{
		bAnyDataSet = true;
	}

	// Quality?
	if ( m_eQuality != AE_UNDEFINED )
	{
		bAnyDataSet = true;
	}

	// Attributes?
	if ( m_vecDynamicAttributes.Count() )
	{
		bAnyDataSet = true;
	}

	// We better have one of the above
	SCHEMA_INIT_CHECK( bAnyDataSet, "Not enough data to describe component" );

#ifdef GC_DLL
	// Get next available attrib def for defining the item
	CEconItemAttributeDefinition* pAttribDef = GetNextAvailableAttributeWithBaseName( GetAttributeName(), pAttribVec );
	SCHEMA_INIT_CHECK( pAttribDef, "Too many potential components" );
	if( pAttribDef )
	{
		pAttribVec->AddToTail( pAttribDef );
	}
#endif

	SCHEMA_INIT_SUBSTEP( BaseClass::BFinishInitialization_Internal( pVecErrors, pAttribVec ) );

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose: Parse out our item definition name and quality.  Return false if 
//			either does not exist
//-----------------------------------------------------------------------------
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentDefinedItem::ParseKV( KeyValues *pKV, CUtlVector<CUtlString> *pVecErrors )
{
	bool bNoItemDef = !!pKV->FindKey( "no_item_def" );
	bool bItemName = !!pKV->FindKey( "item_name" );

	// Make sure only one of the above is set
	SCHEMA_INIT_CHECK( bNoItemDef != bItemName,
						"Both \"no_item_def\" and \"item_name\" specified in component." );

	// Make sure at least one of the above is set
	SCHEMA_INIT_CHECK( bNoItemDef || bItemName,
						"Neither \"no_item_def\" or \"item_name\" specified in component." );

	// If they specified an item name, then we need to grab it
	if ( bItemName )
	{
		m_strName = pKV->GetString( "item_name", NULL );
	}

	return BaseClass::ParseKV( pKV, pVecErrors );
}

//-----------------------------------------------------------------------------
// Purpose: Convert ourselves into an attribute.  Return false if our encoded
//			attributes exceed the allocated space for attributes
//-----------------------------------------------------------------------------
#ifdef GC_DLL
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentDefinedItem::AddRecipeComponentAsAttribute( CEconItem *pItem, const CEconGameAccount *pGameAccount ) const
{
	// Check if we should even apply
	if( !RollChanceOfApplying() )
		return true;

	// Gather up all the current attributes on the item
	ComponentAttribVector_t attribVec;
	CRecipeComponentMatchingIterator matchingIterator( pItem, NULL );
	pItem->IterateAttributes( &matchingIterator );
	attribVec.AddVectorToTail( matchingIterator.GetMatchingComponentInputs() );
	attribVec.AddVectorToTail( matchingIterator.GetMatchingComponentOutputs() );

	// Get next available attrib def for defining the item
	const CEconItemAttributeDefinition* pAttribDef = GetNextAvailableAttributeWithBaseName( GetAttributeName(), &attribVec );
	if( !pAttribDef )
		return false;

	uint32 nFlags = 0;
	CAttribute_DynamicRecipeComponent typedValue;

	// Check if our item name is specified to use our parent's
	const char* pszItemDefName = m_strName;
	if ( m_strName && m_strName[0] )
	{
		if( BStringsEqual( m_pszUseParentNameIdentifier, pszItemDefName ) && m_pParent )
		{
			// It's only possible to have another CDynamicRecipeComponentDefinedItem as a parent
			const CDynamicRecipeComponentDefinedItem* pParentDefinedItemComponent = dynamic_cast< const CDynamicRecipeComponentDefinedItem* >( m_pParent );
			AssertMsg( pParentDefinedItemComponent, "Parent attribute passed into defined item component is not a defined item component" );
			if( !pParentDefinedItemComponent )
			{
				return false;
			}
			// Adopt our parent's item name
			pszItemDefName = pParentDefinedItemComponent->m_strName;
		}
	
		// Make sure this item def exists
		CEconItemDefinition* pItemDef = GetItemSchema()->GetItemDefinitionByName( pszItemDefName );
		AssertMsg1( pItemDef, "No item def named %s found when applying defined item component", pszItemDefName );
		if( !pItemDef )
		{
			return false;
		}

		// Set the item def
		typedValue.set_def_index( (uint32)pItemDef->GetDefinitionIndex() );
		nFlags |= DYNAMIC_RECIPE_FLAG_PARAM_ITEM_DEF_SET;
	}

	// Set the quality, if we're supposed to
	if ( m_eQuality != AE_UNDEFINED )
	{
		typedValue.set_item_quality( (uint32)m_eQuality );
		nFlags |= DYNAMIC_RECIPE_FLAG_PARAM_QUALITY_SET;
	}

	nFlags |= m_bIsOutput ? DYNAMIC_RECIPE_FLAG_IS_OUTPUT : 0;

	if ( m_attributesMatchingType == ATTRIBUTES_MATCH_ALL )
	{
		nFlags |= DYNAMIC_RECIPE_FLAG_PARAM_ATTRIBUTE_SET_ALL;
	}
	else if ( m_attributesMatchingType == ATTRIBUTES_MATCH_ANY )
	{
		nFlags |= DYNAMIC_RECIPE_FLAG_PARAM_ATTRIBUTE_SET_ANY;
	}

	// Make sure any of the flags (besides the output flag) is set
	if ( ( nFlags & ~DYNAMIC_RECIPE_FLAG_IS_OUTPUT ) == 0 )
	{
		AssertMsg(0, "Created component without any data flags set!" );
		return false;
	}
	
	typedValue.set_component_flags( nFlags );
	typedValue.set_num_required( RollCount() );
	typedValue.set_num_fulfilled( 0 );

	// Write out attribute all attribute indexes and values, separated by what we expect to be an invalid character sequence
	CUtlString strAttribs;
	FOR_EACH_VEC( m_vecDynamicAttributes, i )
	{
		if( i != 0 ) 
		{
			strAttribs.Append( g_pszAttrEncodeSeparator );
		}
		// Convert all of our attributes into a string.
		strAttribs.Append( CFmtStr( "%d", m_vecDynamicAttributes[i].m_AttrIndex ) );
		strAttribs.Append( g_pszAttrEncodeSeparator );
		strAttribs.Append( m_vecDynamicAttributes[i].m_strAttrData.Get() );
	}

	// Make sure we're not too long
	if( strAttribs.Length() >= 1024 )
	{
		AssertMsg1( 0, "String-encoded attributes exceeds 1024 characters, when encoding component %s", m_strName.Get() );
		return false;
	}

	// Set it in there!
	typedValue.set_attributes_string( strAttribs.Get() );

	// Check to see if we're about to create a duplicate.  There's no need to spend another
	// attribute to describe the same item.  Let's instead just increase the count on the
	// already-existing attribute.
	FOR_EACH_VEC( attribVec, i )
	{
		CAttribute_DynamicRecipeComponent existingValue;
		if( pItem->FindAttribute( attribVec[i], &existingValue ) )
		{
			if( typedValue.def_index()			== existingValue.def_index() &&
				typedValue.item_quality()		== existingValue.item_quality() &&
				typedValue.component_flags()			== existingValue.component_flags() &&
				typedValue.attributes_string()	== existingValue.attributes_string() )
			{
				pAttribDef = attribVec[i];
				existingValue.set_num_required( existingValue.num_required() + typedValue.num_required() );
				typedValue = existingValue;
				break;
			}
		}
	}
	

	pItem->SetDynamicAttributeValue( pAttribDef, typedValue );

	// Go through and add any additional components that depend on this component
	FOR_EACH_VEC( m_vecAdditionalComponents, i )
	{
		CBaseRecipeComponent* pAdditionalComponent = m_vecAdditionalComponents[i];
		pAdditionalComponent->AddRecipeComponentAsAttribute( pItem, pGameAccount );
	}

	return true;
}

#endif

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::CDynamicRecipeComponentLootList( bool bIsOutput, const CBaseRecipeComponent* pParent )
	: CEconTool_ItemDynamicRecipe::CBaseRecipeComponent( bIsOutput, pParent )
#ifdef GC_DLL
	, m_eUniqueness( UNIQUE_AMONG_NOTHING )
#endif
{}



CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::~CDynamicRecipeComponentLootList()
{}

//-----------------------------------------------------------------------------
// Purpose: Make sure m_strName actually refers to a lootlist
//-----------------------------------------------------------------------------
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::BFinishInitialization_Internal( CUtlVector<CUtlString>* pVecErrors, ComponentAttribVector_t* pAttribVec )
{
	// The game doesn't have all of the lootlists
#ifdef GC_DLL
	SCHEMA_INIT_CHECK( GEconItemSchema().GetLootListByName( m_strName ),
					   "CDynamicRecipeComponentLootList has invalid loot list: %s", m_strName.Get() );

	// Get next available attrib def for defining the item
	CEconItemAttributeDefinition* pAttribDef = GetNextAvailableAttributeWithBaseName( GetAttributeName(), pAttribVec );
	SCHEMA_INIT_CHECK( pAttribDef, "Too many potential recipe components!" );
	if( pAttribDef )
	{
		pAttribVec->AddToTail( pAttribDef );
	}

	// Inputs are not allowed to be marked UNIQUE_AMONG_OUTPUTS.  Rather, mark the outputs UNIQUE_AMONG_INPUTS
	SCHEMA_INIT_CHECK( !(m_eUniqueness == UNIQUE_AMONG_OUTPUTS && !GetIsOutput() ), "Input component marked to be unique among inputs.  Not supported!" );
#endif

	// Skip defined item
	SCHEMA_INIT_SUBSTEP( BaseClass::BFinishInitialization_Internal( pVecErrors, pAttribVec ) );

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose: Parse in our lootlist name and quality.  Return false if either doesn't exist
//-----------------------------------------------------------------------------
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::ParseKV( KeyValues *pKV, CUtlVector<CUtlString> *pVecErrors )
{
	const char* pszLootListName = pKV->GetString( "lootlist_name" );
	SCHEMA_INIT_CHECK( pszLootListName != NULL,
					   "Missing lootlist name in lootlist recipe component" );

	m_strName = pszLootListName;

	bool bBaseResult = BaseClass::ParseKV( pKV, pVecErrors );

#ifdef GC_DLL
	// By default, outputs try to avoid rolling as input, and inputs dont try to avoid anything
	m_eUniqueness = GetIsOutput() ? UNIQUE_AMONG_INPUTS : UNIQUE_AMONG_NOTHING;
	const char* pszUniqueness = pKV->GetString( "uniqueness" );
	if ( !V_stricmp( "unique_among_inputs", pszUniqueness ) )
	{
		m_eUniqueness = UNIQUE_AMONG_INPUTS;
	}
	else if ( !V_stricmp( "unique_among_outputs", pszUniqueness ) )
	{
		m_eUniqueness = UNIQUE_AMONG_OUTPUTS;
	}
	else if ( !V_stricmp( "unique_among_everything", pszUniqueness ) )
	{
		m_eUniqueness = UNIQUE_AMONG_EVERYTHING;
	}
#endif

	return bBaseResult;
}


//-----------------------------------------------------------------------------
// Purpose:	Roll our item definition, then call our base to convert ourselves into an attribute
//-----------------------------------------------------------------------------
#ifdef GC_DLL
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::AddRecipeComponentAsAttribute( CEconItem *pItem, const CEconGameAccount *pGameAccount ) const
{
	// Check if we should even apply
	if( !RollChanceOfApplying() )
		return true;

	// See if there's any item defs we should try to avoid
	CRecipeComponentInputDefIndexIterator inputIterator( m_eUniqueness );
	pItem->IterateAttributes( &inputIterator );

	const char* pszItemDefName = NULL;
	// Roll the item and any additional attributes
	CUtlVector< StringEncodedAttribute_t > vecLootlistGeneratedAttributes;
	if (!RollLootlistItemAndAttributes( vecLootlistGeneratedAttributes, &pszItemDefName, &inputIterator.GetMatchingComponentInputs(), pGameAccount ) )
	{
		return false;
	}
	vecLootlistGeneratedAttributes.AddVectorToTail( m_vecDynamicAttributes );

	// Create a temporary defined item component based on the lootlist roll
	CDynamicRecipeComponentDefinedItem definedItem( m_bIsOutput, this );
	definedItem.m_eQuality = m_eQuality;
	definedItem.m_strName = pszItemDefName;
	definedItem.m_attributesMatchingType = m_attributesMatchingType;
	definedItem.m_vecDynamicAttributes = vecLootlistGeneratedAttributes;
	definedItem.m_vecCountChances = m_vecCountChances;
	definedItem.m_flTotalWeights = m_flTotalWeights;

	// Write out this defined item
	definedItem.AddRecipeComponentAsAttribute( pItem, pGameAccount );

	// Create any additional components that depend on this component existing
	FOR_EACH_VEC( m_vecAdditionalComponents, i )
	{
		CBaseRecipeComponent* pAdditionalComponent = m_vecAdditionalComponents[i];
		// Update the parent to be the item we generated
		pAdditionalComponent->SetParent( &definedItem );
		pAdditionalComponent->AddRecipeComponentAsAttribute( pItem, pGameAccount );
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose:	Roll our item definition, then call our base to convert ourselves into an attribute
//-----------------------------------------------------------------------------
class CAttributeToStringIterator : public IEconItemUntypedAttributeIterator
{
public:
	CAttributeToStringIterator( CUtlVector< CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::StringEncodedAttribute_t >& vecAdditionalAttribs, CEconItem* pItem )
		: m_vecAdditionalAttribs( vecAdditionalAttribs )
		, m_pItem( pItem )
	{}

	virtual bool OnIterateAttributeValueUntyped( const CEconItemAttributeDefinition *pAttrDef )
	{
		const CEconItem::attribute_t *pAttrInternalData = m_pItem->FindDynamicAttributeInternal( pAttrDef );

		// Only export attributes that we have dynamic data for.
		if ( pAttrInternalData )
		{
			const ISchemaAttributeType *pAttrType = pAttrDef->GetAttributeType();
			Assert( pAttrType );

			// Set the definition index
			auto& attrib = m_vecAdditionalAttribs[ m_vecAdditionalAttribs.AddToTail() ];
			attrib.m_AttrIndex = pAttrDef->GetDefinitionIndex();

			// Convert the value to a string
			std::string sAttrValue;
			pAttrType->ConvertEconAttributeValueToString( pAttrDef, pAttrInternalData->m_value, &sAttrValue );

			Assert( sAttrValue.length() > 0 );
			attrib.m_strAttrData.Set( sAttrValue.c_str() );
		}

		return true;
	}
	
private:

	CUtlVector< CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::StringEncodedAttribute_t >& m_vecAdditionalAttribs;
	CEconItem* m_pItem;
};

//-----------------------------------------------------------------------------
// Purpose: Roll our item definition.  This will give us a list of item definition.  From this list
//			we take the first one and set our item def name and quality to be its.  We then take any
//			attributes that it may have rolled and add them to our attributes as well.  Return false
//			if any of these steps fail.
//-----------------------------------------------------------------------------
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::RollLootlistItemAndAttributes( CUtlVector< StringEncodedAttribute_t >& vecAdditionalAttribs
																								, const char** pszDefName
																								, const CUtlVector< item_definition_index_t > *pVecAvoidItemDefs
																								, const CEconGameAccount *pGameAccount ) const
{
	const CEconLootListDefinition* pLootList = GEconItemSchema().GetLootListByName( m_strName );

	if( !pLootList )
	{
		AssertMsg1( 0, "Lootlist %s not found when adding dynamic attribute", m_strName.Get() );
		return false;
	}

	CUtlVector<CEconItem *> vecRolledItems;
	// Roll our items
	CDefaultUniformRandomStream RandomStream;
	if ( !pLootList->BGenerateSingleRollRandomItems( pGameAccount, false, &vecRolledItems ) )
	{
		AssertMsg1( 0, "Error generating item defs from lootlist \"%s\"", m_strName.Get() );
		return false;
	}

	// We're just going to use the first one
	CEconItem* pGeneratedItem = vecRolledItems.Head();

	// Set our name and quality
	(*pszDefName) = pGeneratedItem->GetItemDefinition()->GetDefinitionName();
	const_cast<CDynamicRecipeComponentLootList*>(this)->m_eQuality = (EEconItemQuality)pGeneratedItem->GetQuality();

	// Sniff and encode the attributes
	CAttributeToStringIterator attrToString( vecAdditionalAttribs, pGeneratedItem );
	pGeneratedItem->IterateAttributes( &attrToString );

	// Cleanup
	for( auto pItem : vecRolledItems )
	{
		delete pItem;
	}

	return true;
}

#endif


//-----------------------------------------------------------------------------
// Purpose: Delete all the things
//-----------------------------------------------------------------------------
CEconTool_ItemDynamicRecipe::~CEconTool_ItemDynamicRecipe()
{
	m_vecComponents.PurgeAndDeleteElements();
}

CEconTool_ItemDynamicRecipe::CRecipeComponentInputDefIndexIterator::CRecipeComponentInputDefIndexIterator( EItemDefUniqueness_t eUniqueness )
	: m_eUniqueness( eUniqueness )
{}

bool CEconTool_ItemDynamicRecipe::CRecipeComponentInputDefIndexIterator::OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_DynamicRecipeComponent& value )
{
	// We dont care
	if ( m_eUniqueness == CEconTool_ItemDynamicRecipe::UNIQUE_AMONG_NOTHING )
		return true;

	// Only check against outputs
	if ( m_eUniqueness == CEconTool_ItemDynamicRecipe::UNIQUE_AMONG_OUTPUTS && !( value.component_flags() & DYNAMIC_RECIPE_FLAG_IS_OUTPUT ) )
		return true;

	// Only check against inputs
	if ( m_eUniqueness == CEconTool_ItemDynamicRecipe::UNIQUE_AMONG_INPUTS && value.component_flags() & DYNAMIC_RECIPE_FLAG_IS_OUTPUT )
		return true;

	// Add this item def if we haven't seen it
	if ( m_vecInputItemDefs.Find( value.def_index() ) == m_vecInputItemDefs.InvalidIndex() )
	{
		m_vecInputItemDefs.AddToTail( value.def_index() );
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Parse all of our inputs then outputs
//-----------------------------------------------------------------------------
bool CEconTool_ItemDynamicRecipe::BInitFromKV( KeyValues *pKVDef, CUtlVector<CUtlString> *pVecErrors )
{
	// Parse the components blocks
	SCHEMA_INIT_SUBSTEP( CBaseRecipeComponent::ParseComponentsBlock( pKVDef, m_vecComponents, pVecErrors, NULL ) );

	// Sort the component vector such that inputs go first
	struct RecipeComponentSorter
	{
		static int SortRecipeComponentVector( CEconTool_ItemDynamicRecipe::CBaseRecipeComponent* const *pComponent1, CEconTool_ItemDynamicRecipe::CBaseRecipeComponent* const *pComponent2 )
		{
			return (*pComponent1)->GetIsOutput() && !(*pComponent2)->GetIsOutput();
		}
	};

	m_vecComponents.Sort( &RecipeComponentSorter::SortRecipeComponentVector );
	
#ifdef GC_DLL
	int nFlags = 0;
	FOR_EACH_VEC( m_vecComponents, i )
	{
		m_vecComponents[i]->GetIsGuaranteed( nFlags );
	}

	SCHEMA_INIT_CHECK( nFlags & GUARANTEED_OUTPUT, "No guaranteed outputs for dynamic recipe" );
	SCHEMA_INIT_CHECK( nFlags & GUARANTEED_INPUT, "No guaranteed inputs for dynamic recipe" );
#endif

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose: Parse the component blocks, determining if this component is an input or output
//-----------------------------------------------------------------------------
bool CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::ParseComponentsBlock( KeyValues *pKV, CUtlVector<CBaseRecipeComponent*>& vecComponents, CUtlVector<CUtlString> *pVecErrors, const CBaseRecipeComponent* pParent )
{
	// The components block doesn't exist on the client

	KeyValues *pKVComponents = pKV->FindKey( "components" );
#ifdef GC_DLL
	SCHEMA_INIT_CHECK( pKVComponents || pParent, "Failed to parse components block in dynamic recipe" );
#endif
	if ( pKVComponents )
	{
		// There's duplicate code when we read in like this, but it makes the
		// item defs much easier to read

		// Parse all the inputs
		KeyValues *pKVParameters = pKVComponents->FindKey( "input" );
		if( pKVParameters )
		{
			ParseComponents( pKVParameters, vecComponents, false, pVecErrors, pParent );
		}

#ifdef GC_DLL
		// Parse all the outputs
		pKVParameters = pKVComponents->FindKey( "output" );
		if( pKVParameters )
		{
			ParseComponents( pKVParameters, vecComponents, true, pVecErrors, pParent );
		}
#endif
	}



	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose: Create the appropriate component types and have them parse themselves.
//			Returns true if at least one of the components parsed has a 100% chance
//			of applying, and we don't have a parent
//-----------------------------------------------------------------------------
bool CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::ParseComponents( KeyValues *pKV, CUtlVector<CBaseRecipeComponent*>& vecComponents, bool bIsOutput, CUtlVector<CUtlString> *pVecErrors, const CBaseRecipeComponent* pParent )
{
	// Go through each entry in the tool
	KeyValues *pEntry = pKV->GetFirstSubKey();
	while( pEntry )
	{
		// Find which type is being specified.
		CBaseRecipeComponent *pComponent = NULL;
		if( pEntry->FindKey( "lootlist_name" ) )
		{
			pComponent = vecComponents[vecComponents.AddToTail( new CDynamicRecipeComponentLootList( bIsOutput, pParent ) )];
		}
		else if ( pEntry->FindKey( "item_name" ) || pEntry->FindKey( "no_item_def" ) )
		{
			pComponent = vecComponents[vecComponents.AddToTail( new CDynamicRecipeComponentDefinedItem( bIsOutput, pParent ) )];
		}
		else
		{
			SCHEMA_INIT_CHECK( false, "Unrecognized recipe component type!" );
		}

		// Now that we've got the right type, parse!
		if( pComponent )
		{
			pComponent->ParseKV( pEntry, pVecErrors );
		}

		pEntry = pEntry->GetNextKey();
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose: Parse in all of the attributes for this component.  Attributes have
//			already been parsed in, so we can immediately check if the attribute exists.
//-----------------------------------------------------------------------------
bool CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::ParseKV( KeyValues *pKV, CUtlVector<CUtlString> *pVecErrors )
{
	// Get the quality string
	const char* pszQuality = pKV->GetString( "quality", NULL );
	if ( pszQuality )
	{
		// Convert the quality string to a item quality
		m_eQuality = EconQuality_GetQualityFromString( pszQuality );
		SCHEMA_INIT_CHECK( m_eQuality != AE_UNDEFINED, "Invalid item quality \"%s\" specified for component \"%s\"", pszQuality, m_strName.Get() );
	}

	const char* pszAttributesMatchingType = pKV->GetString( "attributes_matching_type", NULL );
	if ( pszAttributesMatchingType )
	{
		if ( !V_stricmp( pszAttributesMatchingType, "all" ) )
		{
			m_attributesMatchingType = ATTRIBUTES_MATCH_ALL;
		}
		else if ( !V_stricmp( pszAttributesMatchingType, "any" ) )
		{
			m_attributesMatchingType = ATTRIBUTES_MATCH_ANY;
		}
		else
		{
			SCHEMA_INIT_CHECK( 0, "Invalid attributes_matching_type \"%s\"", pszAttributesMatchingType );
		}
	}

	// Parse all of our attributes
	KeyValues* pKVAttribs = pKV->FindKey( "attributes" );
	if( pKVAttribs )
	{
		FOR_EACH_SUBKEY( pKVAttribs, pKVAttribute )
		{
			static_attrib_t staticAttrib;
			
			SCHEMA_INIT_SUBSTEP( staticAttrib.BInitFromKV_SingleLine( "attributes", pKVAttribute, pVecErrors ) );

			const CEconItemAttributeDefinition * pAttrDef = staticAttrib.GetAttributeDefinition();
			SCHEMA_INIT_CHECK( pAttrDef != NULL, "Attribute index %i not found when specifying dynamic recipe", staticAttrib.iDefIndex );

			StringEncodedAttribute_t& attrib = m_vecDynamicAttributes[ m_vecDynamicAttributes.AddToTail() ];
			attrib.m_AttrIndex = pAttrDef->GetDefinitionIndex();
			attrib.m_strAttrData = pKVAttribs->GetString( pKVAttribute->GetName(), "" );

			Assert( !attrib.m_strAttrData.IsEmpty() );
		}
	}

	// Get our chance of applying.  Default to 100%
	float flChance = pKV->GetFloat( "chance", 1.f );
	// Make sure it's in the range (0,1]
	SCHEMA_INIT_CHECK( flChance > 0.f && flChance <= 1.f, "Recipe component chance to apply out of bounds: %f", flChance );
	SetChanceOfApplying( flChance );

	// Read in the "counts" block if it exists
	KeyValues *pKVCounts = pKV->FindKey( "counts" );
	if( pKVCounts )
	{
		// Read check count entry
		FOR_EACH_SUBKEY( pKVCounts, pKVEntry )
		{
			// Split out count range of the format "#-#", or just "#"
			CUtlStringList vecCount;
			const char* pszCount = pKVEntry->GetName();
			V_SplitString( pszCount, "-", vecCount );
			SCHEMA_INIT_CHECK( vecCount.Count() == 1 || vecCount.Count() == 2, "Malformed count value: %s", pszCount );
		
			CountChance_t& countChance = m_vecCountChances[ m_vecCountChances.AddToTail() ];

			// Add up the chances
			countChance.m_flChance = (float)pKVEntry->GetInt();
			m_flTotalWeights += countChance.m_flChance;
			// Set the min and the max.  If no max is specifid, then max is the min
			countChance.m_nMinCount = V_atoi( vecCount[0] );
			countChance.m_nMaxCount = vecCount.Count() > 1 ? V_atoi( vecCount[1] ) : countChance.m_nMinCount;
			// Make sure max >= min and min > 0
			SCHEMA_INIT_CHECK( countChance.m_nMaxCount >= countChance.m_nMinCount, "Recipe component count max is less than the min: %s", pszCount );
			SCHEMA_INIT_CHECK( countChance.m_nMinCount > 0, "Recipe component count min less than 0: %s", pszCount );
		}
	}

	// Init any components we may have in us
	SCHEMA_INIT_CHECK( ParseComponentsBlock( pKV, m_vecAdditionalComponents, pVecErrors, this ), "Failed to parse nested components block in dynamic recipe" );

	return SCHEMA_INIT_SUCCESS();
}


#ifdef GC_DLL
//-----------------------------------------------------------------------------
// Purpose:	This tool will apply recipe components as attributes.  Go through each
//			of our attributes, roll to see if it applies, and convert it to an attribute
//			and add it to the item if we do.  Return false if we ever fail.
//-----------------------------------------------------------------------------
bool CEconTool_ItemDynamicRecipe::BGenerateDynamicAttributes( CEconItem* pItem, const CEconGameAccount *pGameAccount ) const
{
	// Go through our inputs and write them out into attributes
	FOR_EACH_VEC( m_vecComponents, i )
	{
		if( !m_vecComponents[i]->AddRecipeComponentAsAttribute( pItem, pGameAccount ) )
				return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Scan the item for numbered attributes with the passed in base name.
//			Return the attribute of the next available index or NULL if there are
//			none available
//-----------------------------------------------------------------------------
CEconItemAttributeDefinition* CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::GetNextAvailableAttributeWithBaseName( const char* pszBaseAttribName, ComponentAttribVector_t* pAttribVec )
{
	Assert( pAttribVec );
	if( !pAttribVec )
		return NULL;

	CEconItemAttributeDefinition *pAttribDef = NULL;
	int i=1;
	while( pAttribDef == NULL )
	{
		const char* pszAttribName = CFmtStr( "%s %d", pszBaseAttribName, i++ );

		CEconItemAttributeDefinition *pTempAttribDef = GEconItemSchema().GetAttributeDefinitionByName( pszAttribName );

		// Check to see if this attribute we're talking about even exists
		if( !pTempAttribDef )
		{
			return NULL;
		}

		// Check if the vector doesn't have this attribute.  If not, it's available
		if( pAttribVec->Find( pTempAttribDef ) == pAttribVec->InvalidIndex() )
		{
			pAttribDef = pTempAttribDef;
		}
	}

	return pAttribDef;
}
#endif

//-----------------------------------------------------------------------------
bool CEconTool_Xifier::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
{
	Assert( pTool );
	Assert( pToolSubject );

	const CEconItemDefinition *pSubjectItemDef = pToolSubject->GetItemDefinition();
	if ( !pSubjectItemDef )
		return false;

	// Check to make sure the definition of the item we're trying to apply to has the tags we need to match.
	FOR_EACH_VEC( m_RequiredTags.GetTagsList(), i )
	{
		if ( !pSubjectItemDef->HasEconTag( m_RequiredTags.GetTagsList()[i] ) )
			return false;
	}

	// If this xifier has target restrictions, ensure our subject is one of them
	if ( m_ItemDefTargetRestrictions.Count() > 0 )
	{
		bool bPassed = false;
		FOR_EACH_VEC( m_ItemDefTargetRestrictions, i )
		{
			const CEconItemDefinition *pTargetItemDef = GetItemSchema()->GetItemDefinition( m_ItemDefTargetRestrictions[i] );
			if ( ItemDefMatch( pSubjectItemDef, pTargetItemDef ) )
			{
				bPassed = true;
				break;
			}
		}
		
		if ( bPassed == false )
			return false;
	}

	// if rarity restriction, target needs rarity of this or lower
	if ( m_ItemRarityRestriction != k_unItemRarity_Any )
	{
		uint8 unSubjectRarity = pToolSubject->GetItemDefinition()->GetRarity();
		if ( unSubjectRarity == k_unItemRarity_Any || unSubjectRarity == 0 || unSubjectRarity > m_ItemRarityRestriction )
			return false;

		// needs to be equippable
		static CSchemaAttributeDefHandle pAttribDef_StatModule( "weapon_uses_stattrak_module" );
		if ( !pToolSubject->FindAttribute( pAttribDef_StatModule ) )
			return false;
	}

	// Check if we have a restriction as an attribute
	static CSchemaAttributeDefHandle pAttribDef_ToolTargetItem( "tool target item" );
	float value;
	if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pTool, pAttribDef_ToolTargetItem, &value ) )
	{
		const CEconItemDefinition *pTargetDef =  GetItemSchema()->GetItemDefinition( value );

		// Check for a match (might have NULL here for target definition but that's safe to pass in)
		if ( !ItemDefMatch( pSubjectItemDef, pTargetDef ) )
		{
			return false;
		}
	}

	return IEconTool::CanApplyTo( pTool, pToolSubject );
}

//-----------------------------------------------------------------------------
bool CEconTool_Xifier::ItemDefMatch( const CEconItemDefinition* pTargetItemDef, const CEconItemDefinition* pSubjectItemDef ) const
{
	if ( pTargetItemDef && pSubjectItemDef )
	{
		// Item def match counts
		if ( pTargetItemDef == pSubjectItemDef )
			return true;

		// If these item defs have the same XifierRemapClass then they are allowed to match as well
		if ( pTargetItemDef->GetXifierRemapClass() && *pTargetItemDef->GetXifierRemapClass() 
			&& pSubjectItemDef->GetXifierRemapClass() && *pSubjectItemDef->GetXifierRemapClass() )
		{
			if (BStringsEqual(pSubjectItemDef->GetXifierRemapClass(), pTargetItemDef->GetXifierRemapClass()))
				return true;
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
bool CEconTool_Strangifier::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
{
	Assert( pTool );
	Assert( pToolSubject );

	// Do not allow for already strange items
	if ( pToolSubject->GetQuality() == AE_STRANGE )
		return false;

	// Go over the attributes of the item, if it has any strange attributes the item is strange and don't apply
	for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
	{
		if ( pToolSubject->FindAttribute( GetKillEaterAttr_Score( i ) ) )
		{
			return false;
		}
	}

	// Default rules
	return CEconTool_Xifier::CanApplyTo( pTool, pToolSubject );
}

//-----------------------------------------------------------------------------
bool CEconTool_KillStreakifier::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
{
	Assert( pTool );
	Assert( pToolSubject );

	// Make sure the item doesn't already have an effect
	static CSchemaAttributeDefHandle pAttribDef_KillStreakEffect( "killstreak tier" );
	float flEffectIndex = 0.0;
	if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pToolSubject, pAttribDef_KillStreakEffect, &flEffectIndex ) )
		return false;

	// Default rules
	return CEconTool_Xifier::CanApplyTo( pTool, pToolSubject );
}

//-----------------------------------------------------------------------------
bool CEconTool_Festivizer::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
{
	Assert( pTool );
	Assert( pToolSubject );

	const CEconItemDefinition *pSubjectItemDef = pToolSubject->GetItemDefinition();
	if ( !pSubjectItemDef )
		return false;

	// Make sure the item doesn't already have an effect
	static CSchemaAttributeDefHandle pAttribDef_Festivizer( "is_festivized" );
	if ( FindAttribute( pToolSubject, pAttribDef_Festivizer ) )
		return false;

	// Default rules
	return CEconTool_Xifier::CanApplyTo( pTool, pToolSubject );
}

bool CEconTool_Unusualifier::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
{
	Assert( pTool );
	Assert( pToolSubject );

	// don't stomp item that's already unusual
	if ( pToolSubject->GetQuality() == AE_UNUSUAL )
		return false;

	// Default rules
	return CEconTool_Xifier::CanApplyTo( pTool, pToolSubject );
}

//-----------------------------------------------------------------------------
bool CEconTool_ItemEaterRecharger::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
{
	Assert( pTool );
	Assert( pToolSubject );

	const CEconItemDefinition *pSubjectItemDef = pToolSubject->GetItemDefinition();
	if ( !pSubjectItemDef )
		return false;

	// Check to make sure the definition of the item we're trying to apply to has the tags we need to match.
	FOR_EACH_VEC( m_RequiredTags.GetTagsList(), i )
	{
		if ( !pSubjectItemDef->HasEconTag( m_RequiredTags.GetTagsList()[i] ) )
			return false;
	}

	// If this eater has target restrictions, ensure our subject is one of them
	if ( m_ItemDefTargetRestrictions.Count() > 0 )
	{
		bool bPassed = false;
		item_definition_index_t iSubject = pSubjectItemDef->GetDefinitionIndex();
		FOR_EACH_VEC( m_ItemDefTargetRestrictions, i )
		{
			if ( m_ItemDefTargetRestrictions[i] == iSubject )
			{
				bPassed = true;
				break;
			}
		}

		if ( bPassed == false )
			return false;
	}

	return IEconTool::CanApplyTo( pTool, pToolSubject );
}

//-----------------------------------------------------------------------------
int CEconTool_ItemEaterRecharger::GetChargesForItemDefId( item_definition_index_t defIndex ) const
{
	FOR_EACH_VEC( m_ItemDefTargetRestrictions, i )
	{
		if ( m_ItemDefTargetRestrictions[i] == defIndex )
		{
			return m_ItemDefTargetChargeValues[i];
		}
	}
	return 0;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconTool_UpgradeCard::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
{
	Assert( pTool );
	Assert( pToolSubject );

	const CEconItemDefinition *pSubjectItemDef = pToolSubject->GetItemDefinition();
	if ( !pSubjectItemDef )
		return false;

	// Abort if we're trying to apply to a base item.
	if ( pSubjectItemDef->IsBaseItem() )
		return false;

	// Abort if for some reason we don't know what type of attribute we would attach.
	if ( m_vecAttributes.Count() <= 0 )
		return false;

	// Make sure that none of the attributes we're going to try to apply already exist on the item. We don't
	// allow double-stacking the same attribute partially for balance purposes, but also because the database
	// back-end doesn't support two attributes of the same type on the same item.
	FOR_EACH_VEC( m_vecAttributes, i )
	{
		if ( pToolSubject->FindAttribute( m_vecAttributes[i].m_pAttrDef ) )
			return false;
	}

	// Make sure the item that we're thinking of applying to has enough room to have another card's
	// worth of items attached. We do this in sort of a roundabout way, by having the attributes themselves
	// know whether they came from a card or not.
	CCountUserGeneratedAttributeIterator countIterator;
	pToolSubject->IterateAttributes( &countIterator );

	if ( countIterator.GetCount() >= GetMaxCardUpgradesPerItem() )
		return false;

	// Check to make sure the definition of the item we're trying to apply to has the tags we need
	// to match.
	FOR_EACH_VEC( m_RequiredTags.GetTagsList(), i )
	{
		if ( !pSubjectItemDef->HasEconTag( m_RequiredTags.GetTagsList()[i] ) )
			return false;
	}

	return IEconTool::CanApplyTo( pTool, pToolSubject );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconTool_ClassTransmogrifier::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
{
	Assert( pTool );
	Assert( pToolSubject );

	const GameItemDefinition_t *pSubjectItemDef = pToolSubject->GetItemDefinition();
	if ( !pSubjectItemDef )
		return false;

	// Abort if we're trying to apply to a base item.
	if ( pSubjectItemDef->IsBaseItem() )
		return false;

	// Abort if we're trying to apply to a Self-Made or Community item
	if ( pToolSubject->GetQuality() == AE_SELFMADE ||
		 pToolSubject->GetQuality() == AE_COMMUNITY )
	{
		return false;
	}

	// Abort if we somehow got here before we know what class we were trying to produce items for.
	if ( m_iClass <= 0 || m_iClass >= LOADOUT_COUNT )
		return false;

	// Check to make sure the definition of the item we're trying to apply to has the tags we need
	// to match.
	FOR_EACH_VEC( m_RequiredTags.GetTagsList(), i )
	{
		if ( !pSubjectItemDef->HasEconTag( m_RequiredTags.GetTagsList()[i] ) )
			return false;
	}

	return IEconTool::CanApplyTo( pTool, pToolSubject );
}

//-----------------------------------------------------------------------------
bool CEconTool_DuckToken::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
{
	Assert( pTool );
	Assert( pToolSubject );

	static CSchemaAttributeDefHandle pAttrDef_DuckBadgeLevel( "duck badge level" );
	uint32 unOldBadgeLevel = 0;
	if ( !FindAttribute( pToolSubject, pAttrDef_DuckBadgeLevel, &unOldBadgeLevel ) )
		return false;

	if ( unOldBadgeLevel >= 5 )
		return false;

	// Default rules
	return IEconTool::CanApplyTo( pTool, pToolSubject );
}

//---------------------------------------------------------------------------------------
// Purpose: given a tool and an item to apply the tool's effects upon, return true if the
//			tool is allowed to affect the subject. This is used on the client for UI and
//			on the GC for actual application validity testing.
//---------------------------------------------------------------------------------------
/* static */ bool CEconSharedToolSupport::ToolCanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject )
{
	if ( pTool == NULL || pToolSubject == NULL )
		return false;

	const GameItemDefinition_t *pToolDef = pTool->GetItemDefinition();
	if ( pToolDef == NULL )
		return false;

	// If we have a tool that's in escrow it can't be used on anything.
	static CSchemaAttributeDefHandle pAttrib_ToolEscrowUntil( "tool escrow until date" );
	if ( pTool->FindAttribute( pAttrib_ToolEscrowUntil ) )
		return false;

	if ( pToolSubject->IsTemporaryItem() )
		return false;

	// Cannot modify preview items. Should be caught by temporary-item check above.
	Assert( pToolSubject->GetOrigin() != kEconItemOrigin_PreviewItem );

	const GameItemDefinition_t *pToolSubjectDef = pToolSubject->GetItemDefinition();
	if ( pToolSubjectDef == NULL )
		return false;

	if ( !ToolCanApplyToDefinition( pToolDef, pToolSubjectDef ) )
		return false;

	// If we can apply to the definition then we should be known to have valid tool data.
	// If our tool has no tool metadata then we don't allow it to be applied to anything.
	const IEconTool *pEconTool = pToolDef->GetEconTool();
	Assert( pEconTool );

	return pEconTool->CanApplyTo( pTool, pToolSubject );
}

/* static */ bool CEconSharedToolSupport::ToolCanApplyToDefinition( const GameItemDefinition_t *pToolDef, const GameItemDefinition_t *pToolSubjectDef )
{
	if ( !pToolDef || !pToolSubjectDef || !pToolDef->IsTool() )
	{
		// not a tool
		return false;
	}

	// If our tool has no tool metadata then we don't allow it to be applied to anything.
	const IEconTool *pEconTool = pToolDef->GetEconTool();
	if ( !pEconTool )
		return false;

	unsigned int unToolUsageCaps = 0;
	if ( pEconTool->GetCapabilities() )
	{
		for ( unsigned int i = 0; i < NUM_ITEM_CAPS; i++ )
		{
			if ( pEconTool->GetCapabilities() & (1 << i) )
			{
				unToolUsageCaps |= g_CapabilityApplicationMap[i];
			}
		}
	}
	
	// Check for base applicability of this tool to this object.
	if ( (unToolUsageCaps & pToolSubjectDef->GetCapabilities()) == 0 )
		return false;

	// check to see if either the tool or the tool target have usage restriction
	const IEconTool *pSubjectEconTool = pToolSubjectDef->GetEconTool();

	if ( pSubjectEconTool )
	{
		// If this tool can apply to anything then we don't care about the checks below
		// making sure restrictions match.
		const char *pszToolRestriction = BStringsEqual( pEconTool->GetUsageRestriction(), "any" )
									   ? pSubjectEconTool->GetUsageRestriction()
									   : pEconTool->GetUsageRestriction();

		if ( !BStringsEqual( pszToolRestriction, pSubjectEconTool->GetUsageRestriction() ) )
			return false;
	}

	return true;
}

// WARNING
// DO NOT USE THIS CODE IF YOUR TOOL HAS Attribute restrictions like "tool_target_item" or similar restriction attributes
/* static */ bool CEconSharedToolSupport::ToolCanApplyToBaseItem( const GameItemDefinition_t *pToolDef, const GameItemDefinition_t *pToolSubjectDef )
{
	if ( !pToolSubjectDef )
		return false;

	// We are targetting the "Upgradeable" version of a base item and not a base item itself
	if ( pToolSubjectDef->IsBaseItem() || pToolSubjectDef->IsHidden() || pToolSubjectDef->GetQuality() == AE_NORMAL || Q_strnicmp( pToolSubjectDef->GetDefinitionName(), "Upgradeable ", 12 ) )
		return false;

	return ToolCanApplyToDefinition( pToolDef, pToolSubjectDef );
}