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

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: EconItemSchema: Defines a schema for econ items
//
//=============================================================================

#include "cbase.h"
#include "econ_item_schema.h"
#include "tier1/fmtstr.h"
#include "tier1/UtlSortVector.h"
#include "tier2/tier2.h"
#include "filesystem.h"
#include "schemainitutils.h"
#include "gcsdk/gcsdk_auto.h"
#include "rtime.h"
#include "item_selection_criteria.h"
#include "crypto.h"
#include "checksum_sha1.h"

#include <google/protobuf/text_format.h>
#include <string.h>

#include "materialsystem/imaterialsystem.h"
#include "materialsystem/itexture.h"
#include "materialsystem/itexturecompositor.h"

#if ( defined( _MSC_VER ) && _MSC_VER >= 1900 )
#define timezone _timezone
#define daylight _daylight
#endif

// For holiday-limited loot lists.
#include "econ_holidays.h"

// Only used for startup testing.
#include "econ_item_tools.h"

#if defined(CLIENT_DLL) || defined(GAME_DLL)
	#include "econ_item_system.h"
	#include "econ_item.h"
	#include "activitylist.h"

	#if defined(TF_CLIENT_DLL) || defined(TF_DLL)
		#include "tf_gcmessages.h"
	#endif
#endif

#ifdef GC_DLL
#include "gcgamebase.h"
#include <memory>					// unique_ptr
#endif

// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"


using namespace GCSDK;


CEconItemSchema & GEconItemSchema()
{
#if defined( EXTERNALTESTS_DLL )
	static CEconItemSchema g_econItemSchema;
	return g_econItemSchema;
#elif defined( GC_DLL )
	return *GEconManager()->GetItemSchema();
#else
	return *ItemSystem()->GetItemSchema();
#endif
}

const char *g_szDropTypeStrings[] =
{
	"",		 // Blank and none mean the same thing: stay attached to the body.
	"none",
	"drop",	 // The item drops off the body.
	"break", // Not implemented, but an example of a type that could be added.
};

const char *g_TeamVisualSections[TEAM_VISUAL_SECTIONS] = 
{
	"visuals",		// TF_TEAM_UNASSIGNED. Visual changes applied to both teams.
	NULL,			// TF_TEAM_SPECTATOR. Unused.
	"visuals_red",	// TF_TEAM_RED
	"visuals_blu",	// TF_TEAM_BLUE
	"visuals_mvm_boss",	// Hack to override things in MvM at a general level
};

int GetTeamVisualsFromString( const char *pszString )
{
	for ( int i = 0; i < TEAM_VISUAL_SECTIONS; i++ )
	{
		// There's a NULL hidden in g_TeamVisualSections
		if ( g_TeamVisualSections[i] && !Q_stricmp( pszString, g_TeamVisualSections[i] ) )
			return i;
	}
	return -1;
}

#if defined(CLIENT_DLL) || defined(GAME_DLL)
// Used to convert strings to ints for wearable animation types
const char *g_WearableAnimTypeStrings[ NUM_WAP_TYPES ] =
{
	"on_spawn",			// WAP_ON_SPAWN,
	"start_building",	// WAP_START_BUILDING,
	"stop_building",	// WAP_STOP_BUILDING,
	"start_taunting",		// WAP_START_TAUNTING,
	"stop_taunting",	// WAP_STOP_TAUNTING,
};
#endif

const char *g_AttributeDescriptionFormats[] =
{
	"value_is_percentage",				// ATTDESCFORM_VALUE_IS_PERCENTAGE,
	"value_is_inverted_percentage",		// ATTDESCFORM_VALUE_IS_INVERTED_PERCENTAGE
	"value_is_additive",				// ATTDESCFORM_VALUE_IS_ADDITIVE
	"value_is_additive_percentage",		// ATTDESCFORM_VALUE_IS_ADDITIVE_PERCENTAGE
	"value_is_or",						// ATTDESCFORM_VALUE_IS_OR
	"value_is_date",					// ATTDESCFORM_VALUE_IS_DATE
	"value_is_account_id",				// ATTDESCFORM_VALUE_IS_ACCOUNT_ID
	"value_is_particle_index",			// ATTDESCFORM_VALUE_IS_PARTICLE_INDEX -> Could change to "string index"
	"value_is_killstreakeffect_index",	// ATTDESCFORM_VALUE_IS_KILLSTREAKEFFECT_INDEX -> Could change to "string index"
	"value_is_killstreak_idleeffect_index",  // ATTDESCFORM_VALUE_IS_KILLSTREAK_IDLEEFFECT_INDEX
	"value_is_item_def",				// ATTDESCFORM_VALUE_IS_ITEM_DEF
	"value_is_from_lookup_table",		// ATTDESCFORM_VALUE_IS_FROM_LOOKUP_TABLE
};

const char *g_EffectTypes[NUM_EFFECT_TYPES] =
{
	"unusual",		// ATTRIB_EFFECT_UNUSUAL,
	"strange",		// ATTRIB_EFFECT_STRANGE,
	"neutral",		// ATTRIB_EFFECT_NEUTRAL = 0,
	"positive",		// ATTRIB_EFFECT_POSITIVE,
	"negative",		// ATTRIB_EFFECT_NEGATIVE,
};

//-----------------------------------------------------------------------------
// Purpose: Set the capabilities bitfield based on whether the entry is true/false.
//-----------------------------------------------------------------------------
const char *g_Capabilities[] =
{
	"paintable",				// ITEM_CAP_PAINTABLE
	"nameable",					// ITEM_CAP_NAMEABLE
	"decodable",				// ITEM_CAP_DECODABLE
	"can_craft_if_purchased",	// ITEM_CAP_CAN_BE_CRAFTED_IF_PURCHASED
	"can_customize_texture",	// ITEM_CAP_CAN_CUSTOMIZE_TEXTURE
	"usable",					// ITEM_CAP_USABLE
	"usable_gc",				// ITEM_CAP_USABLE_GC
	"can_gift_wrap",			// ITEM_CAP_CAN_GIFT_WRAP
	"usable_out_of_game",		// ITEM_CAP_USABLE_OUT_OF_GAME
	"can_collect",				// ITEM_CAP_CAN_COLLECT
	"can_craft_count",			// ITEM_CAP_CAN_CRAFT_COUNT
	"can_craft_mark",			// ITEM_CAP_CAN_CRAFT_MARK
	"paintable_team_colors",	// ITEM_CAP_PAINTABLE_TEAM_COLORS
	"can_be_restored",			// ITEM_CAP_CAN_BE_RESTORED
	"strange_parts",			// ITEM_CAP_CAN_USE_STRANGE_PARTS
	"can_card_upgrade",			// ITEM_CAP_CAN_CARD_UPGRADE
	"can_strangify",			// ITEM_CAP_CAN_STRANGIFY
	"can_killstreakify",		// ITEM_CAP_CAN_KILLSTREAKIFY
	"can_consume",				// ITEM_CAP_CAN_CONSUME_ITEMS
	"can_spell_page",			// ITEM_CAP_CAN_SPELLBOOK_PAGE
	"has_slots",				// ITEM_CAP_HAS_SLOTS
	"duck_upgradable",			// ITEM_CAP_DUCK_UPGRADABLE
	"can_unusualify",			// ITEM_CAP_CAN_UNUSUALIFY
};
COMPILE_TIME_ASSERT( ARRAYSIZE(g_Capabilities) == NUM_ITEM_CAPS );

#define RETURN_ATTRIBUTE_STRING( attrib_name, default_string ) \
	static CSchemaAttributeDefHandle pAttribString( attrib_name ); \
	const char *pchResultAttribString = default_string; \
	FindAttribute_UnsafeBitwiseCast< CAttribute_String >( this, pAttribString, &pchResultAttribString ); \
	return pchResultAttribString;

#define RETURN_ATTRIBUTE_STRING_F( func_name, attrib_name, default_string ) \
	const char *func_name( void ) const { RETURN_ATTRIBUTE_STRING( attrib_name, default_string ) }

static void ParseCapability( item_capabilities_t &capsBitfield, KeyValues* pEntry )
{
	int idx = StringFieldToInt(  pEntry->GetName(), g_Capabilities, ARRAYSIZE(g_Capabilities) );
	if ( idx < 0 )
	{
		return;
	}
	int bit = 1 << idx;
	if ( pEntry->GetBool() )
	{
		(int&)capsBitfield |= bit;
	}
	else
	{
		(int&)capsBitfield &= ~bit;
	}
}

#ifdef GC_DLL
static bool BGetPaymentRule( KeyValues *pKVRule, EPaymentRuleType *out_pePaymentRuleType, double *out_pRevenueShare )
{
	Assert( out_pePaymentRuleType );
	Assert( out_pRevenueShare );

	struct payment_rule_lookup_t
	{
		const char *m_pszStr;
		EPaymentRuleType m_eRuleType;
	};

	static payment_rule_lookup_t s_Lookup[] =
	{
		{ "workshop_revenue_share",		kPaymentRule_SteamWorkshopFileID },
		{ "partner_revenue_share",		kPaymentRule_PartnerSteamID },
		{ "bundle_revenue_share",		kPaymentRule_Bundle },
	};

	for ( int i = 0; i < ARRAYSIZE( s_Lookup ); i++ )
	{
		KeyValues *pKVKey = pKVRule->FindKey( s_Lookup[i].m_pszStr );
		if ( !pKVKey )
			continue;

		*out_pePaymentRuleType = s_Lookup[i].m_eRuleType;
		*out_pRevenueShare = atof( pKVKey->GetString() ) * 100.0;				// KeyValues doesn't support parsing a string as a double-precision value, so we do it by hand
		return true;
	}

	return false;
}
#endif // GC_DLL

//-----------------------------------------------------------------------------
// Purpose: CEconItemSeriesDefinition
//-----------------------------------------------------------------------------
CEconItemSeriesDefinition::CEconItemSeriesDefinition( void )
	: m_nValue( INT_MAX )
{
}


//-----------------------------------------------------------------------------
// Purpose:	Copy constructor
//-----------------------------------------------------------------------------
CEconItemSeriesDefinition::CEconItemSeriesDefinition( const CEconItemSeriesDefinition &that )
{
	( *this ) = that;
}


//-----------------------------------------------------------------------------
// Purpose:	Operator=
//-----------------------------------------------------------------------------
CEconItemSeriesDefinition &CEconItemSeriesDefinition::operator=( const CEconItemSeriesDefinition &rhs )
{
	m_nValue = rhs.m_nValue;
	m_strName = rhs.m_strName;

	return *this;
}


//-----------------------------------------------------------------------------
// Purpose:	Initialize the quality definition
// Input:	pKVQuality - The KeyValues representation of the quality
//			schema - The overall item schema for this attribute
//			pVecErrors - An optional vector that will contain error messages if 
//				the init fails.
// Output:	True if initialization succeeded, false otherwise
//-----------------------------------------------------------------------------
bool CEconItemSeriesDefinition::BInitFromKV( KeyValues *pKVSeries, CUtlVector<CUtlString> *pVecErrors /* = NULL */ )
{

	m_nValue = pKVSeries->GetInt( "value", -1 );
	m_strName = pKVSeries->GetName();
	
	m_strLockKey = pKVSeries->GetString( "loc_key" );
	m_strUiFile = pKVSeries->GetString( "ui" );

	// Check for required fields
	SCHEMA_INIT_CHECK(
		NULL != pKVSeries->FindKey( "value" ),
		"Quality definition %s: Missing required field \"value\"", pKVSeries->GetName() );

	return SCHEMA_INIT_SUCCESS();
}


//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CEconItemQualityDefinition::CEconItemQualityDefinition( void )
:	m_nValue( INT_MAX )
,	m_bCanSupportSet( false )
{
}


//-----------------------------------------------------------------------------
// Purpose:	Copy constructor
//-----------------------------------------------------------------------------
CEconItemQualityDefinition::CEconItemQualityDefinition( const CEconItemQualityDefinition &that )
{
	(*this) = that;
}


//-----------------------------------------------------------------------------
// Purpose:	Operator=
//-----------------------------------------------------------------------------
CEconItemQualityDefinition &CEconItemQualityDefinition::operator=( const CEconItemQualityDefinition &rhs )
{
	m_nValue = rhs.m_nValue; 
	m_strName =	rhs.m_strName; 
	m_bCanSupportSet = rhs.m_bCanSupportSet;

	return *this;
}


//-----------------------------------------------------------------------------
// Purpose:	Initialize the quality definition
// Input:	pKVQuality - The KeyValues representation of the quality
//			schema - The overall item schema for this attribute
//			pVecErrors - An optional vector that will contain error messages if 
//				the init fails.
// Output:	True if initialization succeeded, false otherwise
//-----------------------------------------------------------------------------
bool CEconItemQualityDefinition::BInitFromKV( KeyValues *pKVQuality, CUtlVector<CUtlString> *pVecErrors /* = NULL */ )
{

	m_nValue = pKVQuality->GetInt( "value", -1 );
	m_strName = pKVQuality->GetName();	
	m_bCanSupportSet = pKVQuality->GetBool( "canSupportSet" );
#ifdef GC_DLL
	m_strHexColor = pKVQuality->GetString( "hexColor" );
#endif // GC_DLL

	// Check for required fields
	SCHEMA_INIT_CHECK( 
		NULL != pKVQuality->FindKey( "value" ), 
		"Quality definition %s: Missing required field \"value\"", pKVQuality->GetName() );

#if defined(CLIENT_DLL) || defined(GAME_DLL)
	return SCHEMA_INIT_SUCCESS();
#endif // GC_DLL

	// Check for data consistency
	SCHEMA_INIT_CHECK( 
		0 != Q_stricmp( GetName(), "any" ), 
		"Quality definition any: The quality name \"any\" is a reserved keyword and cannot be used." );

	SCHEMA_INIT_CHECK( 
		m_nValue != k_unItemQuality_Any, 
		"Quality definition %s: Invalid value (%d). It is reserved for Any", GetName(), k_unItemQuality_Any );

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// CEconItemRarityDefinition
//-----------------------------------------------------------------------------
CEconItemRarityDefinition::CEconItemRarityDefinition( void )
	: m_nValue( INT_MAX )
	, m_nLootlistWeight( 0 )
{
}

//-----------------------------------------------------------------------------
// Purpose:	Initialize the rarity definition
//-----------------------------------------------------------------------------
bool CEconItemRarityDefinition::BInitFromKV( KeyValues *pKVRarity, KeyValues *pKVRarityWeights, CEconItemSchema &pschema, CUtlVector<CUtlString> *pVecErrors /* = NULL */ )
{
	m_nValue = pKVRarity->GetInt( "value", -1 );
	m_strName = pKVRarity->GetName();
	m_strLocKey = pKVRarity->GetString( "loc_key" );
	m_strWepLocKey = pKVRarity->GetString( "loc_key_weapon" );

	m_iAttribColor = GetAttribColorIndexForName( pKVRarity->GetString( "color" ) );
	m_strDropSound = pKVRarity->GetString( "drop_sound" );
	m_strNextRarity = pKVRarity->GetString( "next_rarity" ); // Not required.

#ifdef GC_DLL
	if ( pKVRarityWeights )
	{
		m_nLootlistWeight = pKVRarityWeights->GetInt( m_strName, 0 );
	}
#endif
	//

	// Check for required fields
	SCHEMA_INIT_CHECK(
		NULL != pKVRarity->FindKey( "value" ),
		"Rarity definition %s: Missing required field \"value\"", pKVRarity->GetName() );

	SCHEMA_INIT_CHECK(
		NULL != pKVRarity->FindKey( "loc_key" ),
		"Rarity definition %s: Missing required field \"loc_key\"", pKVRarity->GetName() );

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconColorDefinition::BInitFromKV( KeyValues *pKVColor, CUtlVector<CUtlString> *pVecErrors /* = NULL */ )
{
	m_strName		= pKVColor->GetName();
	m_strColorName	= pKVColor->GetString( "color_name" );
#ifdef GC_DLL
	m_strHexColor	= pKVColor->GetString( "hex_color" );
#endif // GC_DLL

	SCHEMA_INIT_CHECK(
		!m_strColorName.IsEmpty(),
		"Quality definition %s: missing \"color_name\"", GetName() );

#ifdef GC_DLL
	SCHEMA_INIT_CHECK(
		!m_strHexColor.IsEmpty(),
		"Quality definition %s: missing \"hex_color\"", GetName() );
#endif // GC_DLL

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
CEconItemSetDefinition::CEconItemSetDefinition( void )
	: m_pszName( NULL )
	, m_pszLocalizedName( NULL )
	, m_iBundleItemDef( INVALID_ITEM_DEF_INDEX )
	, m_bIsHiddenSet( false )
{
}

//-----------------------------------------------------------------------------
// Purpose:	Copy constructor
//-----------------------------------------------------------------------------
CEconItemSetDefinition::CEconItemSetDefinition( const CEconItemSetDefinition &that )
{
	(*this) = that;
}

//-----------------------------------------------------------------------------
// Purpose:	Operator=
//-----------------------------------------------------------------------------
CEconItemSetDefinition &CEconItemSetDefinition::operator=( const CEconItemSetDefinition &other )
{
	m_pszName = other.m_pszName;
	m_pszLocalizedName = other.m_pszLocalizedName;
	m_iItemDefs = other.m_iItemDefs;
	m_iAttributes = other.m_iAttributes;
	m_iBundleItemDef = other.m_iBundleItemDef;
	m_bIsHiddenSet = other.m_bIsHiddenSet;

	return *this;
}

//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
bool CEconItemSetDefinition::BInitFromKV( KeyValues *pKVItemSet, CUtlVector<CUtlString> *pVecErrors )
{
	m_pszName = pKVItemSet->GetName();

	m_iBundleItemDef = INVALID_ITEM_DEF_INDEX;
	const char *pszBundleName = pKVItemSet->GetString( "store_bundle" );
	if ( pszBundleName && pszBundleName[0] )
	{
		CEconItemDefinition *pDef = GetItemSchema()->GetItemDefinitionByName( pszBundleName );
		if ( pDef )
		{
			m_iBundleItemDef = pDef->GetDefinitionIndex();
		}

		SCHEMA_INIT_CHECK( 
			pDef != NULL,
			"Item set %s: Bundle definition \"%s\" was not found", m_pszName, pszBundleName );
	}

	m_pszLocalizedName = pKVItemSet->GetString( "name", NULL );
	m_bIsHiddenSet = pKVItemSet->GetBool( "is_hidden_set", false );

	KeyValues *pKVItems = pKVItemSet->FindKey( "items" );
	if ( pKVItems )
	{
		FOR_EACH_SUBKEY( pKVItems, pKVItem )
		{
			const char *pszName = pKVItem->GetName();

			CEconItemDefinition *pDef = GetItemSchema()->GetItemDefinitionByName( pszName );

			SCHEMA_INIT_CHECK( 
				pDef != NULL,
				"Item set %s: Item definition \"%s\" was not found", m_pszName, pszName );

			const item_definition_index_t unDefIndex = pDef->GetDefinitionIndex();

			SCHEMA_INIT_CHECK(
				!m_iItemDefs.IsValidIndex( m_iItemDefs.Find( unDefIndex ) ),
				"Item set %s: item definition \"%s\" appears multiple times", m_pszName, pszName );
			SCHEMA_INIT_CHECK(
				!pDef->GetItemSetDefinition(),
				"Item set %s: item definition \"%s\" specified in multiple item sets", m_pszName, pszName );

			m_iItemDefs.AddToTail( unDefIndex );
			pDef->SetItemSetDefinition( this );

			// FIXME: hack to work around crafting item criteria
			pDef->GetRawDefinition()->SetString( "item_set", m_pszName );
		}
	}

	KeyValues *pKVAttributes = pKVItemSet->FindKey( "attributes" );
	if ( pKVAttributes )
	{
		FOR_EACH_SUBKEY( pKVAttributes, pKVAttribute )
		{
			const char *pszName = pKVAttribute->GetName();

			const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinitionByName( pszName );
			SCHEMA_INIT_CHECK( 
				pAttrDef != NULL,
				"Item set %s: Attribute definition \"%s\" was not found", m_pszName, pszName );
			SCHEMA_INIT_CHECK(
				pAttrDef->BIsSetBonusAttribute(),
				"Item set %s: Attribute definition \"%s\" is not a set bonus attribute", m_pszName, pszName );

			int iIndex = m_iAttributes.AddToTail();
			m_iAttributes[iIndex].m_iAttribDefIndex = pAttrDef->GetDefinitionIndex();
			m_iAttributes[iIndex].m_flValue = pKVAttribute->GetFloat( "value" );
		}
	}

	// Sanity check.
	SCHEMA_INIT_CHECK( m_pszLocalizedName != NULL,
		"Item set %s: Set contains no localized name", m_pszName );
	SCHEMA_INIT_CHECK( m_iItemDefs.Count() > 0,
		"Item set %s: Set contains no items", m_pszName );

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
void CEconItemSetDefinition::IterateAttributes( class IEconItemAttributeIterator *pIterator ) const
{
	FOR_EACH_VEC( m_iAttributes, i )
	{
		const itemset_attrib_t& itemsetAttrib = m_iAttributes[i];

		const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinition( itemsetAttrib.m_iAttribDefIndex );
		if ( !pAttrDef )
			continue;

		const ISchemaAttributeType *pAttrType = pAttrDef->GetAttributeType();
		Assert( pAttrType );

		// We know (and assert) that we only need 32 bits of data to store this attribute
		// data. We don't know anything about the type but we'll let the type handle it
		// below.
		attribute_data_union_t value;
		value.asFloat = itemsetAttrib.m_flValue;

		if ( !pAttrType->OnIterateAttributeValue( pIterator, pAttrDef, value ) )
			return;
	}
}

//-----------------------------------------------------------------------------
CEconItemCollectionDefinition::CEconItemCollectionDefinition( void )
	: m_pszName( NULL )
	, m_pszLocalizedName( NULL )
	, m_pszLocalizedDesc( NULL )
	, m_iRarityMin( k_unItemRarity_Any )
	, m_iRarityMax( k_unItemRarity_Any )
{
}

//-----------------------------------------------------------------------------
// 

//-----------------------------------------------------------------------------
static int SortCollectionByRarity( item_definition_index_t const *a, item_definition_index_t const *b )
{
	Assert( a );
	Assert( *a );
	Assert( b );
	Assert( *b );

	CEconItemDefinition *pItemA = GetItemSchema()->GetItemDefinition( *a );
	CEconItemDefinition *pItemB = GetItemSchema()->GetItemDefinition( *b );

	if ( !pItemA || !pItemB )
	{
		AssertMsg( 0, "ItemDef Doesn't exist for sorting" );
		return 1;
	}
	
	// If same Rarity, leave in current position?
	if ( pItemA->GetRarity() == pItemB->GetRarity() && pItemA->GetCustomPainkKitDefinition() && pItemB->GetCustomPainkKitDefinition() )
	{
#ifdef CLIENT_DLL
		// Sort by localized name
		// paintkits sort by paintkit name
		auto paintkitA = pItemA->GetCustomPainkKitDefinition();
		auto paintkitB = pItemB->GetCustomPainkKitDefinition();
		auto paintkitALocName = paintkitA->GetLocalizeName();
		auto paintkitBLocName = paintkitB->GetLocalizeName();
		auto pkALocalized = g_pVGuiLocalize->Find( paintkitALocName );
		auto pkBLocalized = g_pVGuiLocalize->Find( paintkitBLocName );
		if ( pkALocalized )
		{
			if ( pkBLocalized )
			{
				return V_wcscmp( pkALocalized, pkBLocalized );
			}
			else
			{
				return -1;
			}
		}
		else
		{
			return pkBLocalized ? 1 : -1;
		}
#else
		return 0;
#endif
	}

	return ( pItemA->GetRarity() > pItemB->GetRarity() ) ? -1 : 1;
}


//-----------------------------------------------------------------------------
bool CEconItemCollectionDefinition::BInitFromKV( KeyValues *pKVPItemCollection, CUtlVector<CUtlString> *pVecErrors )
{
	m_pszName = pKVPItemCollection->GetName();

	m_pszLocalizedName = pKVPItemCollection->GetString( "name", NULL );
	m_pszLocalizedDesc = pKVPItemCollection->GetString( "description", NULL );

	m_bIsReferenceCollection = pKVPItemCollection->GetBool( "is_reference_collection", false );

	KeyValues *pKVItems = pKVPItemCollection->FindKey( "items" );

	// Create a 'lootlist' from this collection
	KeyValues *pCollectionLootList = NULL;
	bool bIsLootList = false;
	if ( !m_bIsReferenceCollection )
	{
		pCollectionLootList = new KeyValues( m_pszName );
	}

	if ( pKVItems )
	{
		// Traverse rarity items and set rarity
		// Create a lootlist if applicable
		FOR_EACH_TRUE_SUBKEY( pKVItems, pKVRarity )
		{
			bIsLootList = true;
			// Get the Rarity Value
			const CEconItemRarityDefinition *pRarity = GetItemSchema()->GetRarityDefinitionByName( pKVRarity->GetName() );
			SCHEMA_INIT_CHECK( pRarity != NULL, "Item collection %s: Rarity type \"%s\" was not found", m_pszName, pKVRarity->GetName() );
			
			// Create a lootlist
			if ( !m_bIsReferenceCollection )
			{
				CFmtStr lootlistname( "%s_%s", m_pszName, pRarity->GetName() );
				const char *pszName = V_strdup( lootlistname.Get() );
				pKVRarity->SetInt( "rarity", pRarity->GetDBValue() );
				SCHEMA_INIT_CHECK( GetItemSchema()->BInsertLootlist( pszName, pKVRarity, pVecErrors ), "Invalid collection lootlist %s", pszName );
				KeyValues *pTempRarityKey = pKVRarity->FindKey( "rarity" );
				Assert( pTempRarityKey );
				pKVRarity->RemoveSubKey( pTempRarityKey );
				pTempRarityKey->deleteThis();
				pCollectionLootList->SetInt( pszName, pRarity->GetLootlistWeight() );
			}

			// Items in the Rarity
			FOR_EACH_VALUE( pKVRarity, pKVItem )
			{
				const char *pszName = pKVItem->GetName();

				CEconItemDefinition *pDef = GetItemSchema()->GetItemDefinitionByName( pszName );

				SCHEMA_INIT_CHECK(
					pDef != NULL,
					"Item set %s: Item definition \"%s\" was not found", m_pszName, pszName );

				const item_definition_index_t unDefIndex = pDef->GetDefinitionIndex();

				SCHEMA_INIT_CHECK(
					!m_iItemDefs.IsValidIndex( m_iItemDefs.Find( unDefIndex ) ),
					"Item Collection %s: item definition \"%s\" appears multiple times", m_pszName, pszName );

				m_iItemDefs.AddToTail( unDefIndex );

				// Collection Reference
				if ( !m_bIsReferenceCollection )
				{
					SCHEMA_INIT_CHECK(
						!pDef->GetItemCollectionDefinition(),
						"Item Collection %s: item definition \"%s\" specified in multiple item sets", m_pszName, pszName );
					pDef->SetItemCollectionDefinition( this );
				}

				// Item Rarity
				pDef->SetRarity( pRarity->GetDBValue() );
			}
		}

		// Loose Items
		FOR_EACH_VALUE( pKVItems, pKVItem )
		{
			const char *pszName = pKVItem->GetName();

			CEconItemDefinition *pDef = GetItemSchema()->GetItemDefinitionByName( pszName );

			SCHEMA_INIT_CHECK(
				pDef != NULL,
				"Item set %s: Item definition \"%s\" was not found", m_pszName, pszName );

			const item_definition_index_t unDefIndex = pDef->GetDefinitionIndex();

			SCHEMA_INIT_CHECK(
				!m_iItemDefs.IsValidIndex( m_iItemDefs.Find( unDefIndex ) ),
				"Item Collection %s: item definition \"%s\" appears multiple times", m_pszName, pszName );
			
			m_iItemDefs.AddToTail( unDefIndex );

			if ( !m_bIsReferenceCollection )
			{
				SCHEMA_INIT_CHECK(
					!pDef->GetItemCollectionDefinition(),
					"Item Collection %s: item definition \"%s\" specified in multiple item sets", m_pszName, pszName );
				pDef->SetItemCollectionDefinition( this );
			}
		}

		// Sort by Rarity
		m_iItemDefs.Sort( &SortCollectionByRarity );
	}

	if ( !m_bIsReferenceCollection && bIsLootList )
	{
		// Insert collection lootlist
		GetItemSchema()->BInsertLootlist( m_pszName, pCollectionLootList, pVecErrors );
	}

	if ( pCollectionLootList )
	{
		pCollectionLootList->deleteThis();
	}

	// Sorted high to low
	m_iRarityMax = GetItemSchema()->GetItemDefinition( m_iItemDefs[ 0 ] )->GetRarity();
	m_iRarityMin = GetItemSchema()->GetItemDefinition( m_iItemDefs[ m_iItemDefs.Count() - 1] )->GetRarity();
	// Verify that there is no gaps in the Rarity (would cause crafting problems and makes no sense)

	if ( !m_bIsReferenceCollection )
	{
		int iRarityVerify = m_iRarityMax;
		FOR_EACH_VEC( m_iItemDefs, i )
		{
			int iNextRarity = GetItemSchema()->GetItemDefinition( m_iItemDefs[i] )->GetRarity();
			SCHEMA_INIT_CHECK( iRarityVerify - iNextRarity <= 1, "Items in Collection %s: Have a gap in rarity tiers", m_pszName );
			iRarityVerify = iNextRarity;
		}
	}

	// Sanity check.
	SCHEMA_INIT_CHECK( m_pszLocalizedName != NULL,
		"Item Collection %s: Collection contains no localized name", m_pszName );
	SCHEMA_INIT_CHECK( m_pszLocalizedDesc != NULL,
		"Item Collection %s: Collection contains no localized description", m_pszName );
	SCHEMA_INIT_CHECK( m_iItemDefs.Count() > 0,
		"Item Collection %s: Collection contains no items", m_pszName );

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// CEconItemPaintKitDefinition
//-----------------------------------------------------------------------------
CEconItemPaintKitDefinition::CEconItemPaintKitDefinition( void )
	: m_pszName( NULL )
{
}

//-----------------------------------------------------------------------------
CEconItemPaintKitDefinition::~CEconItemPaintKitDefinition( void )
{
	FOR_EACH_VEC( m_vecPaintKitWearKVP, i )
	{
		if ( m_vecPaintKitWearKVP[i] )
		{
			m_vecPaintKitWearKVP[i]->deleteThis();
		}
	}

	m_vecPaintKitWearKVP.Purge();
}

bool VerifyPaintKitComposite( KeyValues *pKVWearInputItems, const char* pName, int iWearLevel, CUtlVector<CUtlString> *pVecErrors )
{
	SCHEMA_INIT_CHECK( pKVWearInputItems != NULL, "Paint Kit %s: Does not contain Wear Level %d", pName, iWearLevel );
#ifdef CLIENT_DLL
	int w = 1;
	int h = 1;
	int seed = 0;
	ITextureCompositor* pWeaponSkinBaseCompositor = NULL;

	SafeAssign( &pWeaponSkinBaseCompositor, materials->NewTextureCompositor( w, h, pName, TF_TEAM_RED, seed, pKVWearInputItems, TEX_COMPOSITE_CREATE_FLAGS_VERIFY_SCHEMA_ONLY ) );
	SCHEMA_INIT_CHECK( pWeaponSkinBaseCompositor != NULL, "Could Not Create Weapon Skin Compositor for [%s][Wear %d][Team Red]", pName, iWearLevel);
	SafeRelease( &pWeaponSkinBaseCompositor );

	SafeAssign( &pWeaponSkinBaseCompositor, materials->NewTextureCompositor( w, h, pName, TF_TEAM_BLUE, seed, pKVWearInputItems, TEX_COMPOSITE_CREATE_FLAGS_VERIFY_SCHEMA_ONLY ) );
	SCHEMA_INIT_CHECK( pWeaponSkinBaseCompositor != NULL, "Could Not Create Weapon Skin Compositor for [%s][Wear %d][Team BLUE]", pName, iWearLevel );
	SafeRelease( &pWeaponSkinBaseCompositor );
#endif // CLIENT_DLL
	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
bool CEconItemPaintKitDefinition::BInitFromKV( KeyValues *pKVPItemPaintKit, CUtlVector<CUtlString> *pVecErrors )
{
	m_pszName = pKVPItemPaintKit->GetName();
	m_pszLocalizedName = m_pszName;		// localization key is same as paintkit name for ease of generation

	SCHEMA_INIT_CHECK( m_pszLocalizedName != NULL, "Paint Kit %s: PaintKit contains no localized name", m_pszName );

	KeyValues *pKVWearInputItems = NULL;

	pKVWearInputItems = pKVPItemPaintKit->FindKey( "wear_level_1", false );
	SCHEMA_INIT_CHECK( VerifyPaintKitComposite( pKVWearInputItems, m_pszName, 1, pVecErrors ), "Could Not Create Weapon Skin Compositor for [%s][Wear %d]", m_pszName, 1 );
	m_vecPaintKitWearKVP.AddToTail( pKVWearInputItems->MakeCopy() );
	
	pKVWearInputItems = pKVPItemPaintKit->FindKey( "wear_level_2", false );
	SCHEMA_INIT_CHECK( VerifyPaintKitComposite( pKVWearInputItems, m_pszName, 2, pVecErrors ), "Could Not Create Weapon Skin Compositor for [%s][Wear %d]", m_pszName, 2 );
	m_vecPaintKitWearKVP.AddToTail( pKVWearInputItems->MakeCopy() );

	pKVWearInputItems = pKVPItemPaintKit->FindKey( "wear_level_3", false );
	SCHEMA_INIT_CHECK( VerifyPaintKitComposite( pKVWearInputItems, m_pszName, 3, pVecErrors ), "Could Not Create Weapon Skin Compositor for [%s][Wear %d]", m_pszName, 3 );
	m_vecPaintKitWearKVP.AddToTail( pKVWearInputItems->MakeCopy() );

	pKVWearInputItems = pKVPItemPaintKit->FindKey( "wear_level_4", false );
	SCHEMA_INIT_CHECK( VerifyPaintKitComposite( pKVWearInputItems, m_pszName, 4, pVecErrors ), "Could Not Create Weapon Skin Compositor for [%s][Wear %d]", m_pszName, 4 );
	m_vecPaintKitWearKVP.AddToTail( pKVWearInputItems->MakeCopy() );

	pKVWearInputItems = pKVPItemPaintKit->FindKey( "wear_level_5", false );
	SCHEMA_INIT_CHECK( VerifyPaintKitComposite( pKVWearInputItems, m_pszName, 5, pVecErrors ), "Could Not Create Weapon Skin Compositor for [%s][Wear %d]", m_pszName, 5 );
	m_vecPaintKitWearKVP.AddToTail( pKVWearInputItems->MakeCopy() );

	return SCHEMA_INIT_SUCCESS();
}

KeyValues *CEconItemPaintKitDefinition::GetPaintKitWearKV( int nWear )
{
	// Wear is 1-5 but this vec is 0-4
	int iIndex = nWear - 1;

	if ( !m_vecPaintKitWearKVP.IsValidIndex( iIndex ) )
	{
		iIndex = 0;
		Assert( m_vecPaintKitWearKVP.IsValidIndex( iIndex ) );
		DevMsg( "Invalid Paint Kit or Paint Kit Wear Entry (%s) Wear (%d).", m_pszName, nWear );
		return NULL;
	}

	return m_vecPaintKitWearKVP[iIndex];
}

//-----------------------------------------------------------------------------
// CEconOperationDefinition
//-----------------------------------------------------------------------------
CEconOperationDefinition::CEconOperationDefinition( void )
	: m_pszName( NULL )
	, m_unRequiredItemDefIndex( INVALID_ITEM_DEF_INDEX )
	, m_unGatewayItemDefIndex( INVALID_ITEM_DEF_INDEX )
{
}

//-----------------------------------------------------------------------------
CEconOperationDefinition::~CEconOperationDefinition( void )
{
	if ( m_pKVItem )
		m_pKVItem->deleteThis();
	m_pKVItem = NULL;
}

//-----------------------------------------------------------------------------
bool CEconOperationDefinition::BInitFromKV( KeyValues *pKVPOperation, CUtlVector<CUtlString> *pVecErrors )
{
	m_unOperationID = V_atoi( pKVPOperation->GetName() );

	m_pszName = pKVPOperation->GetString( "name", NULL );
	SCHEMA_INIT_CHECK( m_pszName != NULL, "OperationDefinition %s does not have 'name'", m_pszName );

	// initialize required item def index if we specified one
	const char *pszRequiredName = pKVPOperation->GetString( "required_item_name", NULL );
	if ( pszRequiredName )
	{
		CEconItemDefinition *pDef = GetItemSchema()->GetItemDefinitionByName( pszRequiredName );
		SCHEMA_INIT_CHECK( pDef != NULL, "OperationDefinition couldn't find item def from required name '%s'", pszRequiredName );

		m_unRequiredItemDefIndex = pDef->GetDefinitionIndex();
	}

	const char *pszGatewayItemName = pKVPOperation->GetString( "gateway_item_name", NULL );
	if ( pszGatewayItemName )
	{
		CEconItemDefinition *pDef = GetItemSchema()->GetItemDefinitionByName( pszGatewayItemName );
		SCHEMA_INIT_CHECK( pDef != NULL, "OperationDefinition couldn't find item def from gateway name '%s'", pszGatewayItemName );

		m_unGatewayItemDefIndex = pDef->GetDefinitionIndex();
	}

	if ( m_unGatewayItemDefIndex != INVALID_ITEM_DEF_INDEX )
	{
		SCHEMA_INIT_CHECK( m_unRequiredItemDefIndex != INVALID_ITEM_DEF_INDEX, "If a gateway item is set, a required item must be set!  Mismatch in %d", m_unOperationID );
	}

	const char *pszOperationStartDate = pKVPOperation->GetString( "operation_start_date", NULL );
	SCHEMA_INIT_CHECK( pszOperationStartDate != NULL, "OperationDefinition %s does not have 'operation_start_date'", m_pszName );
	m_OperationStartDate = ( pszOperationStartDate && pszOperationStartDate[0] )
							? CRTime::RTime32FromFmtString( "YYYY-MM-DD hh:mm:ss" , pszOperationStartDate )
							: RTime32(0);

	const char *pszDropEndDate = pKVPOperation->GetString( "stop_giving_to_player_date", NULL );
	SCHEMA_INIT_CHECK( pszDropEndDate != NULL, "OperationDefinition %s does not have 'stop_giving_to_player_date'", m_pszName );
	m_StopGivingToPlayerDate = ( pszDropEndDate && pszDropEndDate[0] )
							? CRTime::RTime32FromFmtString( "YYYY-MM-DD hh:mm:ss" , pszDropEndDate )
							: RTime32(0);

	const char *pszOperationEndDate = pKVPOperation->GetString( "stop_adding_to_queue_date", NULL );
	SCHEMA_INIT_CHECK( pszOperationEndDate != NULL, "OperationDefinition %s does not have 'stop_adding_to_queue_date'", m_pszName );
	m_StopAddingToQueueDate = ( pszOperationEndDate && pszOperationEndDate[0] )
							? CRTime::RTime32FromFmtString( "YYYY-MM-DD hh:mm:ss" , pszOperationEndDate )
							: RTime32(0);

	m_pszQuestLogResFile	= pKVPOperation->GetString( "quest_log_res_file", NULL );
	m_pszQuestListResFile	= pKVPOperation->GetString( "quest_list_res_file", NULL );

	m_pszOperationLootList	= pKVPOperation->GetString( "operation_lootlist" );
	SCHEMA_INIT_CHECK( m_pszOperationLootList != NULL, "OperationDefinition %s does not have 'operation_lootlist'", m_pszName );

	m_bIsCampaign			= pKVPOperation->GetBool( "is_campaign" );
	m_unMaxDropCount		= pKVPOperation->GetInt( "max_drop_count" );

#ifdef GC_DLL

	m_rtQueueFreqMin	= pKVPOperation->GetFloat( "queue_freq_min" ) * k_nSecondsPerHour; // converts specified hours to seconds
	SCHEMA_INIT_CHECK( m_rtQueueFreqMin != 0.f, "OperationDefinition %s does not have 'queue_freq_min'", m_pszName );

	m_rtQueueFreqMax	= pKVPOperation->GetFloat( "queue_freq_max" ) * k_nSecondsPerHour; // converts specified hours to seconds
	SCHEMA_INIT_CHECK( m_rtQueueFreqMax != 0.f, "OperationDefinition %s does not have 'queue_freq_max'", m_pszName );

	SCHEMA_INIT_CHECK( m_rtQueueFreqMin <= m_rtQueueFreqMax, "OperationDefinition %s 'queue_freq_min' must be less than 'queue_freq_max'", m_pszName );

	m_rtDropFreqMin		= pKVPOperation->GetFloat( "drop_freq_min" ) * k_nSecondsPerHour; // converts specified hours to seconds
	SCHEMA_INIT_CHECK( m_rtDropFreqMin != 0.f, "OperationDefinition %s does not have 'drop_freq_min'", m_pszName );

	m_rtDropFreqMax		= pKVPOperation->GetFloat( "drop_freq_max" ) * k_nSecondsPerHour; // converts specified hours to seconds
	SCHEMA_INIT_CHECK( m_rtDropFreqMax != 0.f, "OperationDefinition %s does not have 'drop_freq_max'", m_pszName );

	SCHEMA_INIT_CHECK( m_rtDropFreqMin <= m_rtDropFreqMax, "OperationDefinition %s 'drop_freq_min' must be less than 'drop_freq_max'", m_pszName );
	
	m_unSeed			= pKVPOperation->GetInt( "seed_drops" );
	m_unMaxHeldDrops	= pKVPOperation->GetInt( "max_held_drops" );
	m_nMaxQueueCount	= pKVPOperation->GetInt( "max_queue_count" );
	m_unMaxDropPerThink	= pKVPOperation->GetInt( "max_drop_per_think", 1 );

	m_pszContractRewardLootlist[ REWARD_CASE ]		= pKVPOperation->GetString( "contract_reward_case_lootlist" );
	m_pszContractRewardLootlist[ REWARD_WEAPON ]	= pKVPOperation->GetString( "contract_reward_weapon_lootlist" );

#endif // GC_DLL

	m_pKVItem = pKVPOperation->MakeCopy();

	return SCHEMA_INIT_SUCCESS();
}

#ifdef GC_DLL
#ifdef STAGING_ONLY
	GCConVar gc_quick_operation_drop_name( "gc_quick_operation_drop_name", "" );
	GCConVar gc_quick_operation_drop_rate( "gc_quick_operation_drop_rate", "10" );
#endif // STAGING_ONLY

RTime32	CEconOperationDefinition::GetMinQueueFreq() const
{ 
#ifdef STAGING_ONLY
	if ( Q_stricmp( gc_quick_operation_drop_name.GetString(), m_pszName ) == 0 )
	{
		return gc_quick_operation_drop_rate.GetInt();
	}
#endif

	return m_rtQueueFreqMin;
}

RTime32	CEconOperationDefinition::GetMaxQueueFreq() const
{ 
#ifdef STAGING_ONLY
	if ( Q_stricmp( gc_quick_operation_drop_name.GetString(), m_pszName ) == 0 )
	{
		return gc_quick_operation_drop_rate.GetInt() + 2;
	}
#endif

	return m_rtQueueFreqMax;
}

RTime32	CEconOperationDefinition::GetMinDropFreq() const 
{ 
#ifdef STAGING_ONLY
	if ( Q_stricmp( gc_quick_operation_drop_name.GetString(), m_pszName ) == 0 )
	{
		return gc_quick_operation_drop_rate.GetInt();
	}
#endif

	return m_rtDropFreqMin;
}

RTime32	CEconOperationDefinition::GetMaxDropFreq() const 
{ 
#ifdef STAGING_ONLY
	if ( Q_stricmp( gc_quick_operation_drop_name.GetString(), m_pszName ) == 0 )
	{
		return gc_quick_operation_drop_rate.GetInt() + 2;
	}
#endif

	return m_rtDropFreqMax;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool BCommonInitPropertyGeneratorsFromKV( const char *pszContext, CUtlVector<const IEconItemPropertyGenerator *> *out_pvecGenerators, KeyValues *pKV, CUtlVector<CUtlString> *pVecErrors )
{
	// Forward declaration so factory functions can be wherever.
	IEconItemPropertyGenerator *CreateChangeQualityGenerator( KeyValues *, CUtlVector<CUtlString> * );
	IEconItemPropertyGenerator *CreateRandomEvenChanceAttrGenerator( KeyValues *, CUtlVector<CUtlString> * );
	IEconItemPropertyGenerator *CreateUniformLineItemLootListGenerator( KeyValues *, CUtlVector<CUtlString> * );
	IEconItemPropertyGenerator *CreateDynamicAttrsGenerator( KeyValues *, CUtlVector<CUtlString> * );
	
	// "Factory".
	struct econ_item_property_generator_factory_entry_t
	{
		const char *m_pszGeneratorName;
		IEconItemPropertyGenerator * (* m_funcCreateGeneratorInstance)( KeyValues *, CUtlVector<CUtlString> * );
	};

	static econ_item_property_generator_factory_entry_t s_Generators[] =
	{
		{ "change_quality",					&CreateChangeQualityGenerator },
		{ "random_even_chance_attr",		&CreateRandomEvenChanceAttrGenerator },
		{ "uniform_line_item_loot_list",	&CreateUniformLineItemLootListGenerator },
		{ "dynamic_attrs",					&CreateDynamicAttrsGenerator },
	};

	Assert( out_pvecGenerators );
	Assert( pVecErrors );

	// No input data means "we succeeded here".
	if ( !pKV )
		return true;

	// Handle each generator one at a time. We'll try to initialize the whole set to get as many
	// errors as possible and then return accumulated errors.
	FOR_EACH_SUBKEY( pKV, pKVGenerator )
	{
		const char *pszGeneratorName = pKVGenerator->GetName();

		IEconItemPropertyGenerator *pGenerator = NULL;
		for ( const auto& gen : s_Generators )
		{
			if ( Q_stricmp( gen.m_pszGeneratorName, pszGeneratorName ) != 0 )
				continue;

			pGenerator = (*gen.m_funcCreateGeneratorInstance)( pKVGenerator, pVecErrors );
			SCHEMA_INIT_CHECK( pGenerator != nullptr, "%s: property generator \"%s\" failed to initialize.\n", pszContext, pszGeneratorName );
		
			out_pvecGenerators->AddToTail( pGenerator );
			break;
		}

		// Make sure we found a way to create this instance.
		SCHEMA_INIT_CHECK( pGenerator != nullptr, "%s: unknown type for property generator \"%s\".\n", pszContext, pszGeneratorName );
	}

	return SCHEMA_INIT_SUCCESS();
}
#endif // GC_DLL

//-----------------------------------------------------------------------------
// Dtor
//-----------------------------------------------------------------------------
CEconLootListDefinition::~CEconLootListDefinition( void )
{
#ifdef GC_DLL
	m_RandomAttribs.PurgeAndDeleteElements();
	m_PropertyGenerators.PurgeAndDeleteElements();
#endif
}

#ifdef GC_DLL
bool CEconLootListDefinition::AddRandomAtrributes( KeyValues *pRandomAttributesKV, CEconItemSchema &pschema, CUtlVector<CUtlString> *pVecErrors /*= NULL*/ )
{
	const char *pszAttrName = pRandomAttributesKV->GetName();

	// We've found the random attribute block. Parse it.
	random_attrib_t *pRandomAttr = pschema.CreateRandomAttribute( m_pszName, pRandomAttributesKV, pVecErrors );
	
	SCHEMA_INIT_CHECK(
		NULL != pRandomAttr,
		CFmtStr( "Loot List %s: Failed to create random_attrib_t '%s'", m_pszName, pszAttrName ) );

	m_RandomAttribs.AddToTail( pRandomAttr );

	return true;
}

bool CEconLootListDefinition::AddRandomAttributesFromTemplates( KeyValues *pRandomAttributesKV, CEconItemSchema &pschema, CUtlVector<CUtlString> *pVecErrors /*= NULL*/ )
{
	const char *pszAttrName = pRandomAttributesKV->GetName();

	// try to find attr by template name
	random_attrib_t *pRandomAttrTemplate = pschema.GetRandomAttributeTemplateByName( pszAttrName );
	
	SCHEMA_INIT_CHECK(
		NULL != pRandomAttrTemplate,
		CFmtStr( "Loot List %s: Couldn't find random_attrib_t '%s' from attribute_templates", m_pszName, pszAttrName ) );

	// craete a copy of the template and add to the list
	random_attrib_t *pRandomAttr = new random_attrib_t;
	*pRandomAttr = *pRandomAttrTemplate;
	m_RandomAttribs.AddToTail( pRandomAttr );

	return true;
}
#endif // GC_DLL
//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
static const char *g_pszDefaultRevolvingLootListHeader = "#Econ_Revolving_Loot_List";

bool CEconLootListDefinition::BInitFromKV( KeyValues *pKVLootList, CEconItemSchema &pschema, CUtlVector<CUtlString> *pVecErrors )
{
	m_pszName = pKVLootList->GetName();
	m_pszLootListHeader = g_pszDefaultRevolvingLootListHeader;
	m_pszLootListFooter = NULL;
	m_pszCollectionReference = NULL;
	m_bPublicListContents = true;
#ifdef GC_DLL
	m_iNoDupesIterations = -1;				// disable no-dupes functionality by default
	m_unRarity = pKVLootList->GetInt( "rarity", k_unItemRarity_Any );
#endif // GC_DLL
	bool bCollectionLootList = false;

	FOR_EACH_SUBKEY( pKVLootList, pKVListItem )
	{
		const char *pszName = pKVListItem->GetName();
		
		if ( !Q_strcmp( pszName, "loot_list_header_desc" ) )
		{
			// Make sure we didn't specify multiple entries.
			SCHEMA_INIT_CHECK(
				g_pszDefaultRevolvingLootListHeader == m_pszLootListHeader,
				"Loot list %s: Multiple header descriptions specified", m_pszName );

			m_pszLootListHeader = pKVListItem->GetString();

			SCHEMA_INIT_CHECK(
				NULL != m_pszLootListHeader,
				"Loot list %s: Invalid header description specified", m_pszName );

			continue;
		}
		else if ( !Q_strcmp( pszName, "loot_list_footer_desc" ) )
		{
			// Make sure we didn't specify multiple entries.
			SCHEMA_INIT_CHECK(
				NULL == m_pszLootListFooter,
				"Loot list %s: Multiple footer descriptions specified", m_pszName );

			m_pszLootListFooter = pKVListItem->GetString();

			SCHEMA_INIT_CHECK(
				NULL != m_pszLootListFooter,
				"Loot list %s: Invalid header description specified", m_pszName );

			continue;
		}
		else if ( !Q_strcmp( pszName, "loot_list_collection" ) )
		{
			// Set name as the collection lootlist name
			pszName = pKVListItem->GetString();
			m_pszCollectionReference = pszName;
			bCollectionLootList = true;
		}
		else if ( !Q_strcmp( pszName, "hide_lootlist" ) )
		{
			m_bPublicListContents = !pKVListItem->GetBool( nullptr, true );
			continue;
		}
		else if ( !Q_strcmp( pszName, "rarity" ) )
		{
			// already parsed up top
			continue;
		}
#ifdef GC_DLL
		else if ( !Q_strcmp( pszName, "random_attributes" ) )
		{
			AddRandomAtrributes( pKVListItem, pschema, pVecErrors );
			continue;
		}
		else if ( !Q_strcmp( pszName, "attribute_templates" ) )
		{
			FOR_EACH_SUBKEY( pKVListItem, pKVAttributeTemplate )
			{
				if ( pKVAttributeTemplate->GetInt() == 0 )
					continue;

				bool bAdded = AddRandomAttributesFromTemplates( pKVAttributeTemplate, pschema, pVecErrors );
				SCHEMA_INIT_CHECK( bAdded, "Loot list %s: Failed to attribute_templates '%s'", m_pszName, pKVAttributeTemplate->GetName() );
			}

			continue;
		}
		else if ( !Q_strcmp( pszName, "public_list_contents" ) )
		{
			m_bPublicListContents = pKVListItem->GetBool( nullptr, true );
			continue;
		}
		else if ( !Q_stricmp( pszName, "__no_dupes_iter_count" ) )
		{
			m_iNoDupesIterations = pKVListItem->GetInt( nullptr, -1 );
			continue;
		}
		else if ( !Q_strcmp( pszName, "additional_drop" ) )
		{
			float		fChance			   = pKVListItem->GetFloat( "chance", 0.0f );
			bool		bPremiumOnly	   = pKVListItem->GetBool( "premium_only", false );
			const char *pszLootList		   = pKVListItem->GetString( "loot_list", "" );
			const char *pszRequiredHoliday = pKVListItem->GetString( "required_holiday", NULL );
			const char *pszDropPerdiodStartDate = pKVListItem->GetString( "start_date", NULL );
			const char *pszDropPerdiodEndDate	= pKVListItem->GetString( "end_date", NULL );

			int iRequiredHolidayIndex = pszRequiredHoliday
									  ? EconHolidays_GetHolidayForString( pszRequiredHoliday )
									  : kHoliday_None;

			RTime32 dropStartDate = ( pszDropPerdiodStartDate && pszDropPerdiodStartDate[0] )
							? CRTime::RTime32FromFmtString( "YYYY-MM-DD hh:mm:ss" , pszDropPerdiodStartDate )
							: RTime32(0);	// Default to the start of time

			// Check that if we convert back to a string, we get the same value
			char rtimeBuf[k_RTimeRenderBufferSize];
			SCHEMA_INIT_CHECK(
				pszDropPerdiodStartDate == NULL || Q_strcmp( CRTime::RTime32ToString( dropStartDate, rtimeBuf ), pszDropPerdiodStartDate ) == 0,
				"Malformed start drop date \"%s\" for additional_drop in lootlist %s.  Must be of the form \"YYYY-MM-DD hh:mm:ss\"", pszDropPerdiodStartDate, m_pszName );


			RTime32 dropEndDate = ( pszDropPerdiodEndDate && pszDropPerdiodEndDate[0] )
						  ? CRTime::RTime32FromFmtString( "YYYY-MM-DD hh:mm:ss" , pszDropPerdiodEndDate )
						  : ~RTime32(0);	// Default to the end of time

			// Check that if we convert back to a string, we get the same value
			SCHEMA_INIT_CHECK(
				pszDropPerdiodEndDate == NULL || Q_strcmp( CRTime::RTime32ToString( dropEndDate, rtimeBuf ), pszDropPerdiodEndDate ) == 0,
				"Malformed end drop date \"%s\" for additional_drop in lootlist %s.  Must be of the form \"YYYY-MM-DD hh:mm:ss\"", pszDropPerdiodEndDate, m_pszName );

			SCHEMA_INIT_CHECK(
				fChance > 0.0f && fChance <= 1.0f,
				"Loot list %s: Invalid \"additional_drop\" chance %.2f", m_pszName, fChance );

			SCHEMA_INIT_CHECK(
				pszLootList && pszLootList[0],
				"Loot list %s: Missing \"additional_drop\" loot list name", m_pszName );

			SCHEMA_INIT_CHECK(
				(pszRequiredHoliday == NULL) == (iRequiredHolidayIndex == kHoliday_None),
				"Loot list %s: Unknown or missing holiday \"%s\"", m_pszName, pszRequiredHoliday ? pszRequiredHoliday : "(null)" );

			if ( pszLootList )
			{
				const CEconLootListDefinition *pLootListDef = GetItemSchema()->GetLootListByName( pszLootList );
				SCHEMA_INIT_CHECK(
					pLootListDef,
					"Loot list %s: Invalid \"additional_drop\" loot list \"%s\"", m_pszName, pszLootList );

				if ( pLootListDef )
				{
					drop_period_t dropPeriod = { dropStartDate, dropEndDate };
					loot_list_additional_drop_t additionalDrop = { fChance, bPremiumOnly, pszLootList, iRequiredHolidayIndex, dropPeriod };
					m_AdditionalDrops.AddToTail( additionalDrop );
				}
			}
			continue;
		}
		else if ( !Q_strcmp( pszName, "property_generators" ) )
		{
			SCHEMA_INIT_SUBSTEP( BCommonInitPropertyGeneratorsFromKV( m_pszName, &m_PropertyGenerators, pKVListItem, pVecErrors ) );
			continue;
		}
#endif // GC_DLL

		int iDef = 0;
		// First, see if we've got a loot list name, for embedded loot lists
		int iIdx = 0;
		if ( GetItemSchema()->GetLootListByName( pszName, &iIdx ) )
		{
			// HACKY: Store loot list indices as negatives, starting from -1, because 0 is a valid item index
			iDef = 0 - 1 - iIdx;
		}
		else
		{
			// Not a loot list. See if it's an item index. Check the first character.
			if ( pszName[0] >= '0' && pszName[0] <= '9' )
			{
				iDef = atoi( pszName );
			}
			else
			{
				// Not a number. See if we can find an item def with a matching name.
				const CEconItemDefinition *pDef = GetItemSchema()->GetItemDefinitionByName( pszName );
				if ( pDef )
				{
					iDef = pDef->GetDefinitionIndex();
				}

				SCHEMA_INIT_CHECK( 
					pDef != NULL,
					"Loot list %s: Item definition \"%s\" was not found", m_pszName, pszName );
			}
		}

		// Default to the start dropping at the start of time and end dropping at the end of time
		drop_period_t dropPeriod = { RTime32(0), ~RTime32(0) };

		// Make sure we never put non-enabled items into loot lists
		if ( iDef > 0 )
		{
			const CEconItemDefinition *pItemDef = GetItemSchema()->GetItemDefinition( iDef );
			SCHEMA_INIT_CHECK( 
				pItemDef != NULL,
				"Loot list %s: Item definition index \"%s\" (%d) was not found", m_pszName, pszName, iDef );

			static CSchemaAttributeDefHandle pAttribDef_StartDropDate( "start drop date" );
			static CSchemaAttributeDefHandle pAttribDef_EndDropDate( "end drop date" );

			CAttribute_String value;
			// Check for start drop date attribute on this item
			if ( FindAttribute( pItemDef, pAttribDef_StartDropDate, &value ) )
			{
				const char* pszStartDate = value.value().c_str();
				dropPeriod.m_DropStartDate = CRTime::RTime32FromFmtString( "YYYY-MM-DD hh:mm:ss" , pszStartDate );

				// Check that if we convert back to a string, we get the same value
				char rtimeBuf[k_RTimeRenderBufferSize];
				SCHEMA_INIT_CHECK(
					Q_strcmp( CRTime::RTime32ToString( dropPeriod.m_DropStartDate, rtimeBuf ), pszStartDate ) == 0,
					"Malformed start drop date \"%s\" for item %s.  Must be of the form \"YYYY-MM-DD hh:mm:ss\"",
					pszStartDate, pItemDef->GetDefinitionName() );
			}

			// Check for end drop date attribute on this item
			if ( FindAttribute( pItemDef, pAttribDef_EndDropDate, &value ) )
			{
				const char* pszEndDate = value.value().c_str();
				dropPeriod.m_DropEndDate = CRTime::RTime32FromFmtString( "YYYY-MM-DD hh:mm:ss" , pszEndDate );

				// Check that if we convert back to a string, we get the same value
				char rtimeBuf[k_RTimeRenderBufferSize];
				SCHEMA_INIT_CHECK(
					Q_strcmp( CRTime::RTime32ToString( dropPeriod.m_DropEndDate, rtimeBuf ), pszEndDate ) == 0,
					"Malformed end drop date \"%s\" for item %s.  Must be of the form \"YYYY-MM-DD hh:mm:ss\"", pszEndDate, pItemDef->GetDefinitionName() );
			}

#ifdef GC_DLL
			if ( pItemDef )
			{
				SCHEMA_INIT_CHECK( 
					true == pItemDef->BEnabled(), 
					"Loot list %s: Item definition \"%s\" (%d) isn't enabled, not allowed in loot lists", m_pszName, pItemDef->GetDefinitionName(), iDef );
			}
#endif // GC_DLL
		}

		float fItemWeight = 0.f;
#ifdef GC_DLL
		fItemWeight = bCollectionLootList ? 1.0f : pKVListItem->GetFloat();
		SCHEMA_INIT_CHECK( 
			fItemWeight > 0.0f,
			"Loot list %s: Item definition index \"%s\" (%d) has invalid weight %.2f", m_pszName, pszName, iDef, fItemWeight );
#endif // GC_DLL

		// Add this item
		drop_item_t dropItem = { iDef, fItemWeight, dropPeriod };
		m_DropList.AddToTail( dropItem );
	}

#ifdef GC_DLL

	int nNumTimeLimitedItems = 0;
	FOR_EACH_VEC( m_DropList, i )
	{
		// If either the start date or the end date is set, tally it up as a time limited item
		if( m_DropList[i].m_dropPeriod.m_DropStartDate != RTime32(0) || m_DropList[i].m_dropPeriod.m_DropEndDate != ~RTime32(0) )
		{
			++nNumTimeLimitedItems;
		}
	}

	// Verify that at least one item in a lootlist does not have a drop period that limits when it can drop.
	// This guarantees that we will always drop *something*
	SCHEMA_INIT_CHECK( m_DropList.Count() > nNumTimeLimitedItems, "Lootlist \"%s\" is made up entirely of limited-time items!  At least one must not be time-limited.", m_pszName );
#endif

	return SCHEMA_INIT_SUCCESS();
}

#ifdef GC_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static bool BContainsDuplicateItemDefs( const CUtlVector<CEconLootListDefinition::rolled_item_defs_t>& vecItemDefsA, const CUtlVector<CEconLootListDefinition::rolled_item_defs_t>& vecItemDefsB )
{
	CUtlHashtable<const CEconItemDefinition *> hashItemDefs;

	auto BPopulateAndLookForDupes = [&] ( const CUtlVector<CEconLootListDefinition::rolled_item_defs_t>& vecItemDefs )
	{
		for ( const auto& rolledItemDef : vecItemDefs )
		{
			if ( hashItemDefs.HasElement( rolledItemDef.m_pItemDef ) )
				return true;

			hashItemDefs.Insert( rolledItemDef.m_pItemDef );
		}

		return false;
	};

	return BPopulateAndLookForDupes( vecItemDefsA )
		|| BPopulateAndLookForDupes( vecItemDefsB );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconLootListDefinition::BGenerateSingleRollRandomItems( const CEconGameAccount *pGameAccount, bool bFreeAccount, CUtlVector<CEconItem *> *out_pvecItems, const CUtlVector< item_definition_index_t > *pVecAvoidItemDefs /*= NULL*/ ) const
{
	Assert( out_pvecItems );

	// Where is our source of random numbers coming from? If we're a no-dupe list,
	// we want to have reproducible state so we use our account ID as a unique-ish
	// seed.
	//
	// Wrap the whole thing in a smart pointer so we clean up whenever/however we
	// leave.
	std::unique_ptr<IUniformRandomStream> pRandomStream( [=]() -> IUniformRandomStream *
	{
		if ( !BIsInternalNoDupesLootList() || !pGameAccount )
			return new CDefaultUniformRandomStream;
	
	
		CUniformRandomStream *pAccountUniformRandomStream = new CUniformRandomStream;
		pAccountUniformRandomStream->SetSeed( pGameAccount->Obj().m_unAccountID );

		return pAccountUniformRandomStream;
	}() );

	// Make however many passes through our loot list code until we've generated the
	// right number of passing sets. (Most loot lists let anything pass. Some specify
	// no duplicate definitions allowed.)
	CUtlVector<rolled_item_defs_t> vecCumulativeItemDefs;			// total list of everything we've generated so far in any number of result sets
	CUtlVector<rolled_item_defs_t> vecItemDefs;						// current list under evaluation
	int iNoDupesIterations = 0;

	// This actually isn't guaranteed to converge, and is guaranteed not to converge if
	// we set up a broken lootlist. We set a really high bar here to catch broken/pathologically
	// bad cases here without grinding the whole GC to a halt.
	enum { kUpperBoundIterationSanityCheck = 2000 };
	int iTotalIterations = 0;
	
	while ( true )
	{
		// Don't runaway.
		iTotalIterations++;
		if ( iTotalIterations >= kUpperBoundIterationSanityCheck )
			return false;

		// Generate all of our item defs and their lootlists
		vecItemDefs.Purge();
		if ( !RollRandomItemsAndAdditionalItems( pRandomStream.get(), bFreeAccount, &vecItemDefs, pVecAvoidItemDefs ) )
			return false;

		// If we don't care about dupes and we got any results at all we're done.
		if ( !BIsInternalNoDupesLootList() )
			break;

		// If we do care about dupes and we have some, ignore this set of items.
		if ( BContainsDuplicateItemDefs( vecItemDefs, vecCumulativeItemDefs ) )
			continue;

		// Did we get to the right result set?
		iNoDupesIterations++;
		if ( iNoDupesIterations > m_iNoDupesIterations )
			break;
		
		// Store off the list of definition indices we've already used them so they don't get reused
		// in a later set.
		vecCumulativeItemDefs.AddVectorToTail( vecItemDefs );
	}
	
	// If we get down to here, we expect that we've rolled at least one item def
	Assert( vecItemDefs.Count() > 0 );
	FOR_EACH_VEC( vecItemDefs, i )
	{
		const rolled_item_defs_t& rolledDef = vecItemDefs[i];
		Assert( rolledDef.m_pItemDef );
		Assert( rolledDef.m_vecAffectingLootLists.Count() > 0 );

		// Create the items
		CEconItem *pItem = GEconManager()->GetItemFactory().CreateSpecificItem( pGameAccount, rolledDef.m_pItemDef->GetDefinitionIndex() );
		out_pvecItems->AddToTail( pItem );
		
		// Go through and let all the affecting lootlists attach their attributes to the item
		FOR_EACH_VEC( rolledDef.m_vecAffectingLootLists, j )
		{
			const CEconLootListDefinition *pLootList = rolledDef.m_vecAffectingLootLists[j];
			Assert( pLootList );
			if ( !pLootList->BAttachLootListAttributes( pGameAccount, pItem ) )
				return false;
		}
	}

	return ( out_pvecItems->Count() > 0 );
}

class CRollSimulator
{
public:

	CRollSimulator()
		: m_mapRarityCounts( StringLessThan )
		, m_mapCounts( DefLessFunc( item_definition_index_t ) )
		, m_mapUnusualHatEffectsCount( DefLessFunc( uint32 ) ) 
		, m_mapUnusualTauntEffectsCount( DefLessFunc( uint32 ) )
		, m_nNumIters( 0 )
	{}

	void RollLootlist( const char* pszLootListName, int nRolls, bool bWipePreviousResults = false )
	{
		const CEconLootListDefinition* pLootlist = GetItemSchema()->GetLootListByName( pszLootListName );

		if ( !pLootlist )
		{
			EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "Invalid lootlist \"%s\".\n", pszLootListName );
			return;
		}

		// Clear out results first?
		if ( bWipePreviousResults )
		{
			m_mapCounts.Purge();
			m_mapRarityCounts.Purge();
			m_DropsMaxes.Clear();
			m_DropsTotals.Clear();
		}

		while( nRolls-- )
		{
			AutoYield();
			CUtlVector<CEconItem *> vecItems;
			pLootlist->BGenerateSingleRollRandomItems( NULL, false, &vecItems );

			// Tally up what we got.
			for( auto pItem : vecItems )
			{
				AutoYield();
				// Insert item def if we need
				item_definition_index_t nDefIndex = pItem->GetDefinitionIndex();
				auto idx = m_mapCounts.Find( nDefIndex );
				if ( m_mapCounts.InvalidIndex() == idx )
				{
					idx = m_mapCounts.Insert( nDefIndex );
				}

				// Insert rarity if needed
				const CEconItemRarityDefinition* pItemRarity = GetItemSchema()->GetRarityDefinition( pItem->GetItemDefinition()->GetRarity() );
				if ( pItemRarity )
				{
					const char* pszRarity = GGCGameBase()->LocalizeToken( pItemRarity->GetLocKey() , k_Lang_English );
					auto rarityIdx = m_mapRarityCounts.Find( pszRarity );
					if ( m_mapRarityCounts.InvalidIndex() == rarityIdx )
					{
						rarityIdx = m_mapRarityCounts.Insert( pszRarity, 0 );
					}

					m_mapRarityCounts[ rarityIdx ] += 1;
				}

				// Count
				DropResult_t& result = m_mapCounts[ idx ];
				++result.m_nRollCount;
				++m_DropsTotals.m_nRollCount;
				m_DropsMaxes.m_nRollCount = Max( m_DropsMaxes.m_nRollCount, result.m_nRollCount );

				// Strange count
				if ( BIsItemStrange( pItem ) )
				{
					++result.m_nStrangeCount;
					++m_DropsTotals.m_nStrangeCount;
					m_DropsMaxes.m_nStrangeCount = Max( m_DropsMaxes.m_nStrangeCount, result.m_nStrangeCount );
				}

				// Unusual count
				static CSchemaAttributeDefHandle pAttrDef_ParticleEffect( "attach particle effect" );
				static CSchemaAttributeDefHandle pAttrDef_TauntUnusualAttr( "on taunt attach particle index" );
				if ( pAttrDef_ParticleEffect && pAttrDef_TauntUnusualAttr )
				{
					uint32 nUnusualHatValue = 0;
					uint32 nUnusualTauntValue = 0;
					pItem->FindAttribute( pAttrDef_ParticleEffect, &nUnusualHatValue );
					pItem->FindAttribute( pAttrDef_TauntUnusualAttr, &nUnusualTauntValue );
					// Cant use quality cause of old legacy items.  Quality is just a quick test
					if ( nUnusualHatValue != 0 || nUnusualTauntValue != 0 )
					{
						++result.m_nUnusualCount;
						++m_DropsTotals.m_nUnusualCount;
						m_DropsMaxes.m_nUnusualCount = Max( m_DropsMaxes.m_nUnusualCount, result.m_nUnusualCount );
					}

					if ( nUnusualHatValue )
					{
						nUnusualHatValue = (uint32)((float&)nUnusualHatValue);
						auto idx = m_mapUnusualHatEffectsCount.Find( nUnusualHatValue );
						if ( idx == m_mapUnusualHatEffectsCount.InvalidIndex() )
						{
							idx = m_mapUnusualHatEffectsCount.Insert( nUnusualHatValue, 0 );
						}

						++m_mapUnusualHatEffectsCount[ idx ];
					}

					if ( nUnusualTauntValue )
					{
						nUnusualTauntValue = (uint32)((float&)nUnusualTauntValue);
						auto idx = m_mapUnusualTauntEffectsCount.Find( nUnusualTauntValue );
						if ( idx == m_mapUnusualTauntEffectsCount.InvalidIndex() )
						{
							idx = m_mapUnusualTauntEffectsCount.Insert( nUnusualTauntValue, 0 );
						}

						++m_mapUnusualTauntEffectsCount[ idx ];
					}
				}
			}

			// Delete what we got
			vecItems.PurgeAndDeleteElements();
		}
	}

	void PrintRarityBreakdwn()
	{
		EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "-- Rarity breakdown:\n" );
		int nMaxDigits = 0;
		while( m_mapRarityCounts.Count() )
		{
			// Go through and print the most rolled to least rolled rarities
			auto maxIdx = m_mapRarityCounts.InvalidIndex();

			// Find the most hit
			FOR_EACH_MAP_FAST( m_mapRarityCounts, i )
			{
				AutoYield();
				if ( maxIdx == m_mapRarityCounts.InvalidIndex() ||  m_mapRarityCounts[ i ] > m_mapRarityCounts[ maxIdx ] )
				{
					maxIdx = i;
				}

				nMaxDigits = Max( nMaxDigits, NumDigits( m_mapRarityCounts[ maxIdx ] ) );
			}

			EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%9s %*d %.3f%%\n",
					  m_mapRarityCounts.Key( maxIdx ), nMaxDigits, m_mapRarityCounts[ maxIdx ],
					  100.f * (float)m_mapRarityCounts[ maxIdx ] / m_DropsTotals.m_nRollCount );
			m_mapRarityCounts.RemoveAt( maxIdx );
		}

		EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%-*s  %*s  %*s\n", 9 + 1 + NumDigits( m_DropsMaxes.m_nRollCount ) + 6,
				  "-- Item breakdown", NumDigits( m_DropsMaxes.m_nStrangeCount ) + 1, "S", NumDigits( m_DropsMaxes.m_nUnusualCount ), "U"  );
		
	}

	void PrintUnusualCounts()
	{
		EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "-- Unusual Hats breakdown:\n" );
		int nTotal = PrintUnusualsForType( m_mapUnusualHatEffectsCount );
		EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "-- %d total unusual hats\n", nTotal );
		
		EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "-- Unusual Taunts breakdown:\n" );
		nTotal = PrintUnusualsForType( m_mapUnusualTauntEffectsCount );
		EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "-- %d total unusual taunts\n", nTotal );
	}

	void PrintTotals()
	{
		while( m_mapCounts.Count() )
		{
			// Go through and print the most rolled to least rolled
			auto maxIdx = m_mapCounts.InvalidIndex();

			// Find the most hit
			FOR_EACH_MAP_FAST( m_mapCounts, i )
			{
				AutoYield();
				if ( maxIdx == m_mapCounts.InvalidIndex() ||  m_mapCounts[ i ].m_nRollCount > m_mapCounts[ maxIdx ].m_nRollCount )
				{
					maxIdx = i;
				}
			}

			DropResult_t& result = m_mapCounts[ maxIdx ];
			CEconItemDefinition *pItemDef = GetItemSchema()->GetItemDefinition( m_mapCounts.Key( maxIdx ) );

			const CEconItemRarityDefinition* pItemRarity = GetItemSchema()->GetRarityDefinition( pItemDef->GetRarity() );
			const char* pszRarity = pItemRarity ? GGCGameBase()->LocalizeToken( pItemRarity->GetLocKey() , k_Lang_English ) : "";
			CFmtStr rollString( "%*d %2.3f%%", NumDigits( m_DropsMaxes.m_nRollCount ), result.m_nRollCount,
								100.f * (float)result.m_nRollCount / m_DropsTotals.m_nRollCount );
			CFmtStr strangeString( "%*d", NumDigits( m_DropsMaxes.m_nStrangeCount ), result.m_nStrangeCount );
			CFmtStr unusualString( "%*d", NumDigits( m_DropsMaxes.m_nUnusualCount ), result.m_nUnusualCount );
			const char* pszItemname = GGCGameBase()->LocalizeToken( pItemDef->GetCustomPainkKitDefinition() ? pItemDef->GetCustomPainkKitDefinition()->GetName() : pItemDef->GetItemBaseName(), k_Lang_English );

			EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%9s %s  %s  %s  %s\n", pszRarity, rollString.Get(), strangeString.Get(), unusualString.Get(), pszItemname );

			m_mapCounts.RemoveAt( maxIdx );
		}

		EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "-- Total Items: %d Strange: %d (%.3f%%) Unusual: %d (%.3f%%)\n"
			, m_DropsTotals.m_nRollCount
			, m_DropsTotals.m_nStrangeCount
			, ( 100.f * (float)m_DropsTotals.m_nStrangeCount / m_DropsTotals.m_nRollCount )
			, m_DropsTotals.m_nUnusualCount
			, ( 100.f * (float)m_DropsTotals.m_nUnusualCount / m_DropsTotals.m_nRollCount ) );
	}

	struct DropResult_t
	{
		DropResult_t() { Clear(); }

		void Clear()
		{
			m_nStrangeCount = 0;
			m_nUnusualCount = 0;
			m_nRollCount = 0;
		}

		int m_nStrangeCount;
		int m_nUnusualCount;
		int m_nRollCount;
	};

	const DropResult_t& GetTotalDrops() const { return m_DropsTotals; }
	const DropResult_t& GetMaxesDrops() const { return m_DropsMaxes; }

private:

	int PrintUnusualsForType( CUtlMap< uint32, int >& mapUnusuals )
	{
		int nMaxDigits = 0;
		int nTotal = 0;
		FOR_EACH_MAP_FAST( mapUnusuals, i )
		{
			nTotal += mapUnusuals[ i ];
		}

		while( mapUnusuals.Count() )
		{
			// Go through and print the most rolled to least rolled unusual effects
			auto maxIdx = mapUnusuals.InvalidIndex();

			// Find the most hit
			FOR_EACH_MAP_FAST( mapUnusuals, i )
			{
				AutoYield();
				if ( maxIdx == mapUnusuals.InvalidIndex() ||  mapUnusuals[ i ] > mapUnusuals[ maxIdx ] )
				{
					maxIdx = i;
				}

				nMaxDigits = Max( nMaxDigits, NumDigits( mapUnusuals[ maxIdx ] ) );
			}

			char particleNameEntry[128];
			Q_snprintf( particleNameEntry, ARRAYSIZE( particleNameEntry ), "#Attrib_Particle%d", mapUnusuals.Key( maxIdx ) );
			const char* pszParticleName = GGCGameBase()->LocalizeToken( particleNameEntry, k_Lang_English );

			EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%*d %.3f%% %s (%d)\n",
				nMaxDigits,	  
				mapUnusuals[ maxIdx ],
				100.f * (float)mapUnusuals[ maxIdx ] / nTotal,
				pszParticleName,
				mapUnusuals.Key( maxIdx ) );

			mapUnusuals.RemoveAt( maxIdx );
		}

		return nTotal;
	}

	void AutoYield()
	{
		if ( ++m_nNumIters % 100 == 0 )
		{
			if ( GJobCur().BYieldIfNeeded() )
			{
				// If we re-entered logon surge we should go away for a while
				while ( GGCGameBase()->BIsInLogonSurge() )
				{
					GJobCur().BYieldingWaitOneFrame();
				}
			}
		}
	};

	int NumDigits( int nNumber )
	{
		int digits = 0;

		if ( nNumber <= 0) 
		{
			digits = 1; 
		}

		while ( nNumber ) 
		{
			nNumber /= 10;
			++digits;
		}

		return digits;
	}

	

	CUtlMap< item_definition_index_t, DropResult_t > m_mapCounts;
	CUtlMap< uint32, int > m_mapUnusualHatEffectsCount;
	CUtlMap< uint32, int > m_mapUnusualTauntEffectsCount;
	// Rarity name is the key
	CUtlMap< const char*, int > m_mapRarityCounts;
	DropResult_t m_DropsTotals;
	DropResult_t m_DropsMaxes;
	size_t m_nNumIters;
};

GC_CON_COMMAND( simulate_lootlist_contents, "<lootlist> <iterations> Check item distribution from a given lootlist n times" )
{
	if ( !BCheckArgs( 2, args, simulate_lootlist_contents_command ) )
		return;

	const char* pszLootListName = args[1];
	int nRolls = args.ArgC() == 3 ? atoi( args[2] ) : 1000;

	CRollSimulator simulator;
	simulator.RollLootlist( pszLootListName, nRolls );
	simulator.PrintRarityBreakdwn();
	simulator.PrintUnusualCounts();
	simulator.PrintTotals();
}


#ifdef GC_DLL
class CItemSourceFinder
{
public:
	CItemSourceFinder( const char* pszItemName )
		: m_pItemDef( GetItemSchema()->GetItemDefinitionByName( pszItemName ) )
	{
		Assert( m_pItemDef );
		if ( !m_pItemDef )
		{
			EG_ERROR( SPEW_CONSOLE, "%s is not a valid item", pszItemName );
			return;
		}

		// Find out what series this crate belongs to.
		static CSchemaAttributeDefHandle pAttr_CrateSeries( "set supply crate series" );
		if ( !pAttr_CrateSeries )
			return;

		auto& mapItemDefs = GetItemSchema()->GetItemDefinitionMap();
		auto& mapRevolvingLootlists = GetItemSchema()->GetRevolvingLootLists();

		CUtlDict< int > dictSeenLootlists;

		// Look through all the item defs and see if any of them statically specify a lootlist that they want to open
		FOR_EACH_MAP_FAST( mapItemDefs, i )
		{
			const CEconItemDefinition* pSourceItemDef = mapItemDefs[ i ];
			const CEconLootListDefinition* pLootlist = NULL;

			const CEconTool_Gift* pGift = pSourceItemDef->GetTypedEconTool< CEconTool_Gift >();
			// Self-opening crate?
			if ( pGift )
			{
				pLootlist = GetItemSchema()->GetLootListByName(	pGift->GetLootListName() );
			}
			else // Crate with an item series?
			{
				int iCrateSeries;
				{
					float fCrateSeries;		// crate series ID is stored as a float internally because we hate ourselves
					if ( !FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pSourceItemDef, pAttr_CrateSeries, &fCrateSeries ) || fCrateSeries == 0.0f )
						continue;

					iCrateSeries = fCrateSeries;
				}

				auto idx = mapRevolvingLootlists.Find( iCrateSeries );
				if ( idx == mapRevolvingLootlists.InvalidIndex() )
					continue;

				pLootlist = GetItemSchema()->GetLootListByName( mapRevolvingLootlists[ idx ] );
			}

			if ( !pLootlist )
				continue;

			// Mark that we've seen this lootlist already
			dictSeenLootlists.Insert( pLootlist->GetName() );

			DropSource_t& source = m_vecSources[ m_vecSources.AddToTail() ];
			source.m_pDroppingItem = pSourceItemDef;
			ChanceForItemFromLootlist( m_pItemDef, pLootlist, source.lootlistSource );
		}

		CEconItemDefinition* pCrateItemDef = GetItemSchema()->GetItemDefinitionByName( "Supply Crate" );
		Assert( pCrateItemDef );

		// Go through all the revolving lootlists and see if they have the item.  Assume that
		// they're from a "Supply Crate".
		FOR_EACH_MAP_FAST( mapRevolvingLootlists, i )
		{
			if ( !pCrateItemDef )
				continue;

			if ( mapRevolvingLootlists.Key( i ) <= 0 )
				continue;

			auto pLootlist = GetItemSchema()->GetLootListByName( mapRevolvingLootlists[ i ] );
			if ( !pLootlist )
				continue;

			// This lootlist was on a different crate already
			if ( dictSeenLootlists.Find( pLootlist->GetName() ) != dictSeenLootlists.InvalidIndex() )
				continue;

			DropSource_t& source = m_vecSources[ m_vecSources.AddToTail() ];
			source.m_pDroppingItem = pCrateItemDef;
			ChanceForItemFromLootlist( m_pItemDef, pLootlist, source.lootlistSource );
		}

		// Not available at all!
		if ( !m_vecSources.Count() )
		{
			EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "Not available from any sources!\n" );
			return;
		}

		// Sort greatest % chance
		auto lambdaSort = [] ( DropSource_t const *pLHS, DropSource_t const *pRHS ) -> int
		{
			return pLHS->lootlistSource.m_flChance < pRHS->lootlistSource.m_flChance;
		};
		m_vecSources.Sort( lambdaSort );
	}

	void PrintSources()
	{
		FOR_EACH_VEC( m_vecSources, i )
		{
			m_vecSources[ i ].PrintSources();
		}
	}

	bool BDropsFromLootlist( const CEconLootListDefinition* pLootlist )
	{
		FOR_EACH_VEC( m_vecSources, i )
		{
			if ( m_vecSources[ i ].lootlistSource.BDropsFromLootlist( pLootlist ) )
				return true;
		}

		return false;
	}

private:

	struct DropSource_t
	{
		void PrintSources()
		{
			if ( lootlistSource.m_flChance == 0.f )
				return;

			bool bSelfOpening = m_pDroppingItem->GetTypedEconTool< CEconTool_Gift >() != NULL;

			// Print the name of the item, and whether it's a self-opening item, or a crate
			EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%3.5f%% %s (%d - %s)\n", 
				lootlistSource.m_flChance * 100.f,
				m_pDroppingItem->GetDefinitionName(),
				m_pDroppingItem->GetDefinitionIndex(),
				bSelfOpening ? "Self-Opening" : "Crate/Case" );

			// Print all the sources
			lootlistSource.PrintSources( 1 );

			EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\n" );
		}

		struct LootListSource_t
		{
			LootListSource_t()
				: m_flChance( 0.f )
			{}

			bool BDropsFromLootlist( const CEconLootListDefinition* pLootlist )
			{
				// Skip no-chance entries
				if ( m_flChance == 0.f )
					return false;


				if ( m_pDroppingLootlist == pLootlist )
					return true;

				FOR_EACH_VEC( m_vecLootlistSources, i )
				{
					if ( m_vecLootlistSources[ i ].BDropsFromLootlist( pLootlist ) )
						return true;
				}

				return false;
			}

			void PrintSources( int nInset )
			{
				// Skip no-chance entries
				if ( m_flChance == 0.f )
					return;

				auto& mapRevolvingLootlists = GetItemSchema()->GetRevolvingLootLists();
				int nRevolvingIdx = mapRevolvingLootlists.InvalidIndex();

				// Check if our lootlist is one of the revolving lootlists.  If so, we want
				// to print out its index within revolving_lootlists, so we can map that to
				// the attribute value of supply_crate_series (187)
				FOR_EACH_MAP_FAST( mapRevolvingLootlists, i )
				{
					if ( V_stricmp( mapRevolvingLootlists[ i ], m_pDroppingLootlist->GetName() ) == 0 )
					{
						nRevolvingIdx = mapRevolvingLootlists.Key( i );
						break;
					}
				}
			
				if ( nRevolvingIdx != mapRevolvingLootlists.InvalidIndex() && nRevolvingIdx > 0 )
				{
					// It's in revolving_lootlists.  Print its index in there.
					EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%*.5f%% (%d) %s\n",
							4 * nInset + 5,
							m_flChance * 100.f,
							nRevolvingIdx,
							m_pDroppingLootlist->GetName() );
				}
				else 
				{
					// Not in the revolving lootlist
					EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%*.5f%% %s\n",
							4 * nInset + 5,
							m_flChance * 100.f,
							m_pDroppingLootlist->GetName() );
				}

				// Sort greatest % chance
				auto lambdaSort = [] ( LootListSource_t const *pLHS, LootListSource_t const *pRHS ) -> int
				{
					return pLHS->m_flChance < pRHS->m_flChance;
				};

				m_vecLootlistSources.Sort( lambdaSort );

				// Print out children indented a lil bit
				FOR_EACH_VEC( m_vecLootlistSources, i )
				{
					m_vecLootlistSources[i].PrintSources( nInset + 1 );
				}
			}

			float m_flChance;
			const CEconLootListDefinition* m_pDroppingLootlist;

			CCopyableUtlVector< LootListSource_t > m_vecLootlistSources;
		};

		const CEconItemDefinition* m_pDroppingItem;
		LootListSource_t lootlistSource;
	};

	float ChanceForItemFromLootlist( const CEconItemDefinition* pItemDef, const CEconLootListDefinition* pLootlist, DropSource_t::LootListSource_t& lootlistSource )
	{
		auto& vecContents = pLootlist->GetLootListContents();
		// Accumulate our chance of dropping the specified item
		lootlistSource.m_flChance = 0.f;
		lootlistSource.m_pDroppingLootlist = pLootlist;

		// Gather the items in this lootlist that we're able to roll for at this time
		float flTotalWeight = 0.f;
		CUtlVector<CEconLootListDefinition::drop_item_t> vecValidContents;
		FOR_EACH_VEC( vecContents, i )
		{
			if( !vecContents[ i ].m_dropPeriod.IsValidForTime( CRTime::RTime32TimeCur() ) )
				continue;

			flTotalWeight += vecContents[ i ].m_flWeight;
			vecValidContents.AddToTail( vecContents[ i ] );
		}

		// Go through valid contents, and see if the specified item is in there
		FOR_EACH_VEC( vecValidContents, i )
		{
			const int iItemDef = vecValidContents[ i ].m_iItemOrLootlistDef;
			const float flChance = vecValidContents[ i ].m_flWeight / flTotalWeight;

			if ( iItemDef < 0 ) // Lootlist
			{
				int iLLIndex = (iItemDef * -1) - 1;
				auto pSubLootlist = GetItemSchema()->GetLootListByIndex( iLLIndex );
				
				// One of our sub-lootlists might drop it.  Add in it's chance within
				// the sub-lootlist scaled by the chance to roll that sub-lootlist.
				auto& subSource = lootlistSource.m_vecLootlistSources[ lootlistSource.m_vecLootlistSources.AddToTail() ];
				lootlistSource.m_flChance += ChanceForItemFromLootlist( pItemDef, pSubLootlist, subSource ) * flChance;
			}
			else if ( pItemDef->GetDefinitionIndex() == iItemDef )
			{
				// We drop it!  Add the chance
				lootlistSource.m_flChance += flChance;
			}
		}

		// Treat additional drops just the same as nested lootlists.
		auto& vecAdditionalDrops = pLootlist->GetAdditionalDrops();
		FOR_EACH_VEC( vecAdditionalDrops, i )
		{
			auto& additionalDrop = vecAdditionalDrops[ i ];
			if ( !additionalDrop.m_dropPeriod.IsValidForTime( CRTime::RTime32TimeCur() ) )
				continue;
		
			auto pSubLootlist = GetItemSchema()->GetLootListByName( additionalDrop.m_pszLootListDefName );
			auto& subSource = lootlistSource.m_vecLootlistSources[ lootlistSource.m_vecLootlistSources.AddToTail() ];
			lootlistSource.m_flChance += ChanceForItemFromLootlist( pItemDef, pSubLootlist, subSource ) * additionalDrop.m_fChance;
		}

		// Return the total chance
		return lootlistSource.m_flChance;
	}

	CUtlVector< DropSource_t > m_vecSources;
	const CEconItemDefinition* m_pItemDef;
};

GC_CON_COMMAND( item_sources, "Lists the sources for obtaining a list of specific items" )
{
	if ( !BCheckArgs( 1, args, item_sources_command ) )
		return;

	for ( int i=1; i < args.ArgC(); ++i )
	{
		const char* pszItemName = args[i];
		const CEconItemDefinition* pItemDef = GetItemSchema()->GetItemDefinitionByName( pszItemName );
		if ( pItemDef )
		{
			EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\nChecking items for lootlists containing (%d) %s...\n", pItemDef->GetDefinitionIndex(), pItemDef->GetDefinitionName() );
			CItemSourceFinder source( pszItemName );
			source.PrintSources();
		}
		else
		{
			EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "\n\"%s\" is not a valid item name\n", pszItemName );
		}
	}
}

GC_CON_COMMAND( list_keys, "Lists all the keys in the schema" )
{
	EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "Spewing keys...\n" );

	auto& mapItemDefs = GetItemSchema()->GetItemDefinitionMap();
	FOR_EACH_MAP_FAST( mapItemDefs, i )
	{
		const CEconItemDefinition* pItemDef = mapItemDefs[ i ];
		if ( !pItemDef || !pItemDef->GetEconTool() || ( Q_strcmp( pItemDef->GetEconTool()->GetTypeName(), "decoder_ring" ) != 0 ) )
		{
			continue;
		}

		EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "%llu - %s\n", pItemDef->GetDefinitionIndex(), pItemDef->GetItemDefinitionName() );
	}
}

ConVar case_behavior_rolls_per_lootlist( "case_behavior_rolls_per_lootlist", "1000000", FCVAR_REPLICATED, "How many times to roll a lootlist" );
class CJobCaseBehaviorCheck : public CGCGameBaseJob
{
public:
	CJobCaseBehaviorCheck()
		: CGCGameBaseJob( GGCGameBase() )
	{}

	virtual bool BYieldingRunGCJob()
	{
		// Wait until logon surge ends to get going
		while ( GGCGameBase()->BIsInLogonSurge() )
		{
			GJobCur().BYieldingWaitOneFrame();
		}

		CRollSimulator simulator;

		// Convert the hash to something readable
		char pchSHAHex[41];
		memset( pchSHAHex, 0, sizeof( pchSHAHex ) );
		V_binarytohex( GetItemSchema()->GetSchemaSHA().m_shaDigest, 20, pchSHAHex, 41 );

		RTime32 now = CRTime::RTime32TimeCur();
		int nNewRecords = 0;

		EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "Beginning CJobCaseBehaviorCheck\n" );

		auto& lootlists = GetItemSchema()->GetRevolvingLootLists();

		// Go through all of the lootlists
		FOR_EACH_MAP( lootlists, i )
		{
			const CEconLootListDefinition* pEconLootlist = GetItemSchema()->GetLootListByName( lootlists[ i ] );
			if ( pEconLootlist )
			{
				// Check if we have data for this lootlist on this hash already
				{
					CSQLAccess sqlReadAccess;
					CUtlVector< CSchCaseBehavior > vecExistingResult;
					sqlReadAccess.AddBindParam( pchSHAHex );
					sqlReadAccess.AddBindParam( i );
					if ( sqlReadAccess.BYieldingReadRecordsWithWhereClause( &vecExistingResult, "SchemaSHA = ? and Series = ?", CSET_FULL( CSchCaseBehavior ) ) )
					{
						// Already got it?  Skip the work
						if ( vecExistingResult.Count() )
						{
							continue;
						}
					}
				}

				// Roll 'em up
				simulator.RollLootlist( pEconLootlist->GetName(), case_behavior_rolls_per_lootlist.GetInt(), true );

				// Insert record
				CSchCaseBehavior behavior;
				behavior.SetVarCharField( behavior.m_VarCharSchemaSHA, pchSHAHex, true, CSchCaseBehavior::k_iField_VarCharSchemaSHA );
				behavior.m_RTime32Date = now;
				behavior.m_unSeries = i;
				behavior.SetVarCharField( behavior.m_VarCharLootListName, pEconLootlist->GetName(), true, CSchCaseBehavior::k_iField_VarCharLootListName );
				behavior.m_fStrangeChance = 100.f * (float)simulator.GetTotalDrops().m_nStrangeCount / simulator.GetTotalDrops().m_nRollCount;
				behavior.m_fUnusualChance = 100.f * (float)simulator.GetTotalDrops().m_nUnusualCount / simulator.GetTotalDrops().m_nRollCount;

				CSQLAccess sqlAccess;
				sqlAccess.BBeginTransaction( "CJobCaseBehaviorCheck" );
				sqlAccess.BYieldingInsertOrUpdateOnPK( &behavior );
				sqlAccess.BCommitTransaction( true );
				++nNewRecords;
			}

			BYieldIfNeeded();
		}

		EmitInfo( SPEW_CONSOLE, SPEW_ALWAYS, LOG_ALWAYS, "Completed CJobUnusualChecker.  %d updated records.\n", nNewRecords );

		return true;
	}
};

void CEconItemSchema::PerformCaseBehaviorCheck()
{
	CJob* pJob = new CJobCaseBehaviorCheck();
	pJob->StartJobDelayed( NULL );
}
#endif

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconLootListDefinition::RollRandomItemsAndAdditionalItems( IUniformRandomStream *pRandomStream, bool bFreeAccount, CUtlVector<rolled_item_defs_t> *out_pVecRolledItems, const CUtlVector< item_definition_index_t > *pVecAvoidItemDefs ) const
{
	Assert( out_pVecRolledItems );

	// Roll to see what items we get from this loot list.
	bool bCreatedItems = RollRandomItemDef( pRandomStream, bFreeAccount, out_pVecRolledItems, pVecAvoidItemDefs );
	
	// Do we have additional drops?	
	FOR_EACH_VEC( m_AdditionalDrops, i )
	{
		if ( !bCreatedItems )
			break;

		// Is this within the period this is allowed to drop?
		if ( !m_AdditionalDrops[i].m_dropPeriod.IsValidForTime( CRTime::RTime32TimeCur() ) )
			continue;

		// Does this only apply to premium accounts?
		if ( m_AdditionalDrops[i].m_bPremiumOnly && bFreeAccount )
			continue;

		// Does this only apply on certain holidays?
		if ( m_AdditionalDrops[i].m_iRequiredHolidayIndex != kHoliday_None && !EconHolidays_IsHolidayActive( m_AdditionalDrops[i].m_iRequiredHolidayIndex, CRTime::RTime32TimeCur() ) )
			continue;

		// Random chance is in the range 0-1 so generate a value in that range to "roll".
		if ( pRandomStream->RandomFloat( 0.0f, 1.0f ) > m_AdditionalDrops[i].m_fChance )
			continue;

		// Roll!
		const char *pszAdditionalDropLootList = m_AdditionalDrops[i].m_pszLootListDefName;
		const CEconLootListDefinition *pLootListDef = GetItemSchema()->GetLootListByName( pszAdditionalDropLootList );
		if ( pLootListDef == NULL )
		{
			AssertMsg2( false, "Loot list '%s' specifies unknown additional drop '%s'", GetName(), pszAdditionalDropLootList );
			return false;
		}

		bCreatedItems &= pLootListDef->RollRandomItemsAndAdditionalItems( pRandomStream, bFreeAccount, out_pVecRolledItems );
	}

	// If we failed to create some items, we might still have chosen some item defs before those failures. In that case, clear
	// out any choices we've made so far
	if ( !bCreatedItems )
	{
		out_pVecRolledItems->Purge();
	}

	Assert( bCreatedItems == (out_pVecRolledItems->Count() > 0) );

	return bCreatedItems;
}


bool CEconLootListDefinition::RollRandomItemDef( IUniformRandomStream *pRandomStream, bool bFreeAccount, CUtlVector<rolled_item_defs_t> *out_pVecRolledItems, const CUtlVector< item_definition_index_t > *pVecAvoidItemDefs ) const
{
	Assert( out_pVecRolledItems );

	CUtlVector< rolled_item_defs_t > vecScratchDefs;
	CUtlVector<const drop_item_t*> vecValidDrops;

	// Gather the items in this lootlist that we're able to roll for at this time
	float flTotalWeight = 0.f;
	FOR_EACH_VEC( m_DropList, i )
	{
		if( !m_DropList[i].m_dropPeriod.IsValidForTime( CRTime::RTime32TimeCur() ) )
			continue;

		// Skip any item defs that are in our avoid list (if we have one)
		if ( pVecAvoidItemDefs )
		{
			item_definition_index_t defIndex = m_DropList[i].m_iItemOrLootlistDef;
			if ( pVecAvoidItemDefs->Find( defIndex ) != pVecAvoidItemDefs->InvalidIndex() )
				continue;
		}

		// If this is valid, add it to the list and add its weight to the total
		vecValidDrops.AddToTail( &m_DropList[i] );
		flTotalWeight += m_DropList[i].m_flWeight;
	}

	// Roll to see what item drops.
	float flRand = pRandomStream->RandomFloat(0.0f, 1.0f) * flTotalWeight;

	float flAccum = 0.0f;
	FOR_EACH_VEC( vecValidDrops, i )
	{
		flAccum += vecValidDrops[i]->m_flWeight;
		if ( flRand <= flAccum )
		{
			const int iItemDef = vecValidDrops[i]->m_iItemOrLootlistDef;	// not item_definition_index because it might also be a negative value to indicate a sub lootlist

			if ( iItemDef >= 0 )
			{
				const CEconItemDefinition* pItemDef = GetItemSchema()->GetItemDefinition( iItemDef );
				if( !pItemDef )
					return false;

				// Add the item def and the lootlist
				rolled_item_defs_t& rolledDef = vecScratchDefs[ vecScratchDefs.AddToTail() ];
				rolledDef.m_pItemDef = pItemDef;
			}
			else
			{
				// In the case where iItemDef is negative, it's a nested loot list. Ask that list to choose an item.
				// HACKY: Store loot list indices as negatives, starting from -1, because 0 is a valid item index
				int iLLIndex = (iItemDef * -1) - 1;
				const CEconLootListDefinition *pNestedLootList = GetItemSchema()->GetLootListByIndex( iLLIndex );
				if ( !pNestedLootList )
					return false;

				if( !pNestedLootList->RollRandomItemsAndAdditionalItems( pRandomStream, bFreeAccount, &vecScratchDefs, pVecAvoidItemDefs ) )
					return false;
			}

			// Add ourselves to the list of affecting lootlists, so that we and all nested loot lists will affect this item
			// We intentionally don't do this in our calling function because we don't want to include additional drops.
			FOR_EACH_VEC( vecScratchDefs, j )
			{
				vecScratchDefs[j].m_vecAffectingLootLists.AddToTail( this );
			}

			// We want to exit the loop here regardless of whether items were successfully so that we only perform a single
			// item-generating roll on this list.
			break;
		}
	}

	// Feed item defs, if they exist, back to our caller
	out_pVecRolledItems->AddVectorToTail( vecScratchDefs ); 
	
	// Did we successfully create any items?
	return ( vecScratchDefs.Count() > 0 );
}

//-----------------------------------------------------------------------------
// Purpose: find a list of lootlists with rarity from this lootlist
//-----------------------------------------------------------------------------
void CEconLootListDefinition::GetRarityLootLists( CUtlVector< const CEconLootListDefinition* > *out_pVecRarityLootList ) const
{
	Assert( out_pVecRarityLootList );
	if ( m_unRarity != k_unItemRarity_Any )
	{
		out_pVecRarityLootList->AddToTail( this );
	}

	FOR_EACH_VEC( m_DropList, i )
	{
		const int iItemDef = m_DropList[i].m_iItemOrLootlistDef;	// not item_definition_index because it might also be a negative value to indicate a sub lootlist
		if ( iItemDef < 0 )
		{
			// In the case where iItemDef is negative, it's a nested loot list. Ask that list to choose an item.
			// HACKY: Store loot list indices as negatives, starting from -1, because 0 is a valid item index
			int iLLIndex = (iItemDef * -1) - 1;
			const CEconLootListDefinition *pNestedLootList = GetItemSchema()->GetLootListByIndex( iLLIndex );
			if ( !pNestedLootList )
				return;

			pNestedLootList->GetRarityLootLists( out_pVecRarityLootList );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: get all item defs from this lootlist ( not lootlist item def )
//-----------------------------------------------------------------------------
void CEconLootListDefinition::GetItemDefs( CUtlVector< item_definition_index_t > *out_pVecItemDefs ) const
{
	Assert( out_pVecItemDefs );

	FOR_EACH_VEC( m_DropList, i )
	{
		const int iItemDef = m_DropList[i].m_iItemOrLootlistDef;	// not item_definition_index because it might also be a negative value to indicate a sub lootlist
		if ( iItemDef >= 0 )
		{
			out_pVecItemDefs->AddToTail( (item_definition_index_t)iItemDef );
		}
		else
		{
			// In the case where iItemDef is negative, it's a nested loot list. Ask that list to choose an item.
			// HACKY: Store loot list indices as negatives, starting from -1, because 0 is a valid item index
			int iLLIndex = (iItemDef * -1) - 1;
			const CEconLootListDefinition *pNestedLootList = GetItemSchema()->GetLootListByIndex( iLLIndex );
			if ( !pNestedLootList )
				return;

			pNestedLootList->GetItemDefs( out_pVecItemDefs );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose: Given a vector of possible attributes, roll to see which ones are
//			chosen.  We allocate memory for these new attributes, so it's the
//			responsibility of the caller to free these attributes when they're
//			done with them!
//-----------------------------------------------------------------------------
void CEconLootListDefinition::RollRandomAttributes( CUtlVector< static_attrib_t >& vecAttributes, const CEconGameAccount *pGameAccount ) const
{
	for ( int i=0; i<m_RandomAttribs.Count(); ++i )
	{
		const random_attrib_t* rattr = m_RandomAttribs[i];
		rattr->RollRandomAttributes( vecAttributes, pGameAccount );
	}
}


//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CEconLootListDefinition::drop_period_t::IsValidForTime( const RTime32& time ) const
{
	if( time >= m_DropStartDate && time < m_DropEndDate )
		return true;

	return false;
}

//-----------------------------------------------------------------------------
// Purpose: 
//-----------------------------------------------------------------------------
bool CEconLootListDefinition::BAttachLootListAttributes( const CEconGameAccount *pGameAccount, CEconItem *pItem ) const
{
	//static CSchemaAttributeDefHandle pAttr_ElevateQuality( "elevate quality" );

	// Gather and apply old-style random attributes.
	CUtlVector< static_attrib_t > vecAttributes;
	RollRandomAttributes( vecAttributes, pGameAccount );

	FOR_EACH_VEC( vecAttributes, i )
	{
		GEconManager()->GetItemFactory().ApplyStaticAttributeToItem( pItem, vecAttributes[i], pGameAccount );
		vecAttributes[i].GetAttributeDefinition()->GetAttributeType()->UnloadEconAttributeValue( &vecAttributes[i].m_value );
	}

	// Apply all relevant property generators.
	for ( auto pGenerator : m_PropertyGenerators )
	{
		if ( !pGenerator->BGenerateProperties( pItem ) )
			return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool lootlist_attrib_t::BInitFromKV( const char *pszContext, KeyValues *pKVKey, CEconItemSchema &pschema, CUtlVector<CUtlString> *pVecErrors )
{
	SCHEMA_INIT_SUBSTEP( m_staticAttrib.BInitFromKV_MultiLine( pszContext, pKVKey, pVecErrors ) );

	SCHEMA_INIT_CHECK(
		pKVKey->FindKey( "weight" ),
		"Context '%s': Attribute \"%s\" missing required 'weight' field", pszContext, pKVKey->GetName() );

	m_flWeight = pKVKey->GetFloat( "weight" );

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose: returns true if we should stop rolling from this random_attrib_t
//-----------------------------------------------------------------------------
bool random_attrib_t::RollRandomAttributes( CUtlVector< static_attrib_t >& vecAttributes, const CEconGameAccount *pGameAccount ) const
{
	if ( m_flChanceOfRandomAttribute && RandomFloat() <= m_flChanceOfRandomAttribute )
	{
		// We're attaching a random attribute. Determine which attribute.
		float flRand = 0.0f;
		if ( !m_bPickAllAttributes )
		{
			// Pick one attribute to add
			// Otherwise we'll pick them all
			flRand = RandomFloat( 0.f, 1.f ) * m_flTotalAttributeWeight;
		}
			
		float flAccum = 0.f;
		for ( int iAttrib = 0; iAttrib < m_RandomAttributes.Count(); ++iAttrib )
		{
			const lootlist_attrib_t& randomAttrib = m_RandomAttributes[iAttrib];

			flAccum += randomAttrib.m_flWeight;
			if ( flRand <= flAccum )
			{
				// Add the attribute
				static_attrib_t &staticAttrib = vecAttributes[ vecAttributes.AddToTail( randomAttrib.m_staticAttrib ) ];
				const CEconItemAttributeDefinition *pAttrDef = staticAttrib.GetAttributeDefinition();
				const ISchemaAttributeType *pAttrType = pAttrDef->GetAttributeType();
				// Generate a special value?
				pAttrType->InitializeNewEconAttributeValue( &staticAttrib.m_value );
				pAttrDef->GetAttributeType()->GenerateEconAttributeValue( pAttrDef, staticAttrib, pGameAccount, &staticAttrib.m_value );
					
				if ( !m_bPickAllAttributes )
				{
					// We're only picking one attribute from the list
					return true;
				}
			}
		}
	}

	return false;
}

#endif // GC_DLL

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEconLootListDefinition::EnumerateUserFacingPotentialDrops( IEconLootListIterator *pIt ) const
{
	Assert( pIt );

	// Loot lists have the option of specifying that their contents should not be publicly
	// listed. This is used on the GC for things like the "rare item drop list" to prevent
	// every single potentially-unusual hat from showing up.
	if ( !BPublicListContents() )
		return;

	FOR_EACH_VEC( GetLootListContents(), i )
	{
		const int iID = GetLootListContents()[i].m_iItemOrLootlistDef;

		// Nested loot lists are stored as negative indices.
		if ( iID < 0 )
		{
			const CEconLootListDefinition *pLootListDef = GetItemSchema()->GetLootListByIndex( (-iID) - 1 );
			if ( !pLootListDef )
				continue;

			pLootListDef->EnumerateUserFacingPotentialDrops( pIt );
		}
		else
		{
			pIt->OnIterate( iID );
		}
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
/*static*/ CSchemaAttributeDefHandle CAttributeLineItemLootList::s_pAttrDef_RandomDropLineItems[] =
{
	CSchemaAttributeDefHandle( "random drop line item 0" ),
	CSchemaAttributeDefHandle( "random drop line item 1" ),
	CSchemaAttributeDefHandle( "random drop line item 2" ),
	CSchemaAttributeDefHandle( "random drop line item 3" ),
};

#ifdef GC_DLL
/*static*/ CSchemaAttributeDefHandle CAttributeLineItemLootList::s_pAttrDef_RandomDropLineItemUnusualChance( "random drop line item unusual chance" );		// "one out of this many"
/*static*/ CSchemaAttributeDefHandle CAttributeLineItemLootList::s_pAttrDef_RandomDropLineItemUnusualList( "random drop line item unusual list" );	
#endif // GC_DLL
CSchemaAttributeDefHandle CAttributeLineItemLootList::s_pAttrDef_RandomDropLineItemFooterDesc( "random drop line item footer desc" );	

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CAttributeLineItemLootList::EnumerateUserFacingPotentialDrops( IEconLootListIterator *pIt ) const
{
	Assert( pIt );
	
	for ( int i = 0; i < ARRAYSIZE( s_pAttrDef_RandomDropLineItems ); i++ )
	{
		uint32 unItemDef;
		COMPILE_TIME_ASSERT( sizeof( unItemDef ) >= sizeof( item_definition_index_t ) );

		// If we run out of attributes we have set we're done.
		if ( !m_pEconItem->FindAttribute( s_pAttrDef_RandomDropLineItems[i], &unItemDef ) )
			break;

		pIt->OnIterate( unItemDef );
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CAttributeLineItemLootList::GetLootListHeaderLocalizationKey() const
{
	return g_pszDefaultRevolvingLootListHeader;
}

//-----------------------------------------------------------------------------
const char *CAttributeLineItemLootList::GetLootListFooterLocalizationKey() const
{
	CAttribute_String sFooter;
	const char* pszFooter = NULL;
	if ( FindAttribute_UnsafeBitwiseCast<CAttribute_String>( m_pEconItem, s_pAttrDef_RandomDropLineItemFooterDesc, &pszFooter ) )
	{
		return pszFooter;
	}
	return NULL;
}
//-----------------------------------------------------------------------------
const char *CAttributeLineItemLootList::GetLootListCollectionReference() const
{
	// TODO : Implement me!
	return NULL;
}
//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
const CEconLootListDefinition* CEconItemSchema::GetLootListByName( const char* pListName, int *out_piIndex ) const
{
	auto idx = m_mapLootLists.Find( pListName );
	if ( !m_mapLootLists.IsValidIndex( idx ) )
		return NULL;

	if ( out_piIndex )
	{
		*out_piIndex = idx;
	}

	return m_mapLootLists[idx];
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
const CQuestObjectiveDefinition* CEconItemSchema::GetQuestObjectiveByDefIndex( int iIdx ) const
{
	auto nMapIndex = m_mapQuestObjectives.Find( iIdx );
	if ( nMapIndex != m_mapQuestObjectives.InvalidIndex() )
	{
		return m_mapQuestObjectives[ nMapIndex ];
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CEconCraftingRecipeDefinition::CEconCraftingRecipeDefinition( void )
	: m_nDefIndex( 0 )
#ifdef GC_DLL
	, m_bIsCraftableByUnverifiedClient( false )
#endif // GC_DLL
{
}

//-----------------------------------------------------------------------------
// Purpose:	Initialize the attribute definition
// Input:	pKVAttribute - The KeyValues representation of the attribute
//			schema - The overall item schema for this attribute
//			pVecErrors - An optional vector that will contain error messages if 
//				the init fails.
// Output:	True if initialization succeeded, false otherwise
//-----------------------------------------------------------------------------
bool CEconCraftingRecipeDefinition::BInitFromKV( KeyValues *pKVRecipe, CUtlVector<CUtlString> *pVecErrors /* = NULL */ )
{
	m_nDefIndex = Q_atoi( pKVRecipe->GetName() );
	
	// Check for required fields
	SCHEMA_INIT_CHECK( 
		NULL != pKVRecipe->FindKey( "input_items" ), 
		"Recipe definition %d: Missing required field \"input_items\"", m_nDefIndex );

	SCHEMA_INIT_CHECK( 
		NULL != pKVRecipe->FindKey( "output_items" ), 
		"Recipe definition %d: Missing required field \"output_items\"", m_nDefIndex );

	m_bDisabled = pKVRecipe->GetBool( "disabled" );
	m_strName = pKVRecipe->GetString( "name" );	
	m_strN_A = pKVRecipe->GetString( "n_A" );	 
	m_strDescInputs = pKVRecipe->GetString( "desc_inputs" );	
	m_strDescOutputs = pKVRecipe->GetString( "desc_outputs" );	 
	m_strDI_A = pKVRecipe->GetString( "di_A" );	 
	m_strDI_B = pKVRecipe->GetString( "di_B" );	 
	m_strDI_C = pKVRecipe->GetString( "di_C" );	 
	m_strDO_A = pKVRecipe->GetString( "do_A" );	 
	m_strDO_B = pKVRecipe->GetString( "do_B" );	 
	m_strDO_C = pKVRecipe->GetString( "do_C" );	 

#ifdef GC_DLL
	m_bIsCraftableByUnverifiedClient = pKVRecipe->GetBool( "is_craftable_by_unverified_clients", false );
#endif // GC_DLL
	m_bRequiresAllSameClass = pKVRecipe->GetBool( "all_same_class" );
	m_bRequiresAllSameSlot = pKVRecipe->GetBool( "all_same_slot" );
	m_iCacheClassUsageForOutputFromItem = pKVRecipe->GetInt( "add_class_usage_to_output", -1 );
	m_iCacheSlotUsageForOutputFromItem = pKVRecipe->GetInt( "add_slot_usage_to_output", -1 );
	m_iCacheSetForOutputFromItem = pKVRecipe->GetInt( "add_set_to_output", -1 );
	m_bPremiumAccountOnly = pKVRecipe->GetBool( "premium_only", false );
	m_iCategory = (recipecategories_t)StringFieldToInt( pKVRecipe->GetString("category"), g_szRecipeCategoryStrings, ARRAYSIZE(g_szRecipeCategoryStrings) );

	// Read in all the input items
	KeyValues *pKVInputItems = pKVRecipe->FindKey( "input_items" );
	if ( NULL != pKVInputItems )
	{
		FOR_EACH_TRUE_SUBKEY( pKVInputItems, pKVInputItem )
		{
			int index = m_InputItemsCriteria.AddToTail();
			SCHEMA_INIT_SUBSTEP( m_InputItemsCriteria[index].BInitFromKV( pKVInputItem ) );

			// Recipes ignore the enabled flag when generating items
			m_InputItemsCriteria[index].SetIgnoreEnabledFlag( true );

			index = m_InputItemDupeCounts.AddToTail();
			m_InputItemDupeCounts[index] = atoi( pKVInputItem->GetName() );
		}
	}

	// Read in all the output items
	KeyValues *pKVOutputItems = pKVRecipe->FindKey( "output_items" );
	if ( NULL != pKVOutputItems )
	{
		FOR_EACH_TRUE_SUBKEY( pKVOutputItems, pKVOutputItem )
		{
			int index = m_OutputItemsCriteria.AddToTail();
			SCHEMA_INIT_SUBSTEP( m_OutputItemsCriteria[index].BInitFromKV( pKVOutputItem ) );

			// Recipes ignore the enabled flag when generating items
			m_OutputItemsCriteria[index].SetIgnoreEnabledFlag( true );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}


//-----------------------------------------------------------------------------
// Purpose: Serializes the criteria to and from messages
//-----------------------------------------------------------------------------
bool CEconCraftingRecipeDefinition::BSerializeToMsg( CSOItemRecipe & msg ) const
{
	msg.set_def_index( m_nDefIndex );
	msg.set_name( m_strName );
	msg.set_n_a( m_strN_A );
	msg.set_desc_inputs( m_strDescInputs );
	msg.set_desc_outputs( m_strDescOutputs );
	msg.set_di_a( m_strDI_A );
	msg.set_di_b( m_strDI_B );
	msg.set_di_c( m_strDI_C );
	msg.set_do_a( m_strDO_A );
	msg.set_do_b( m_strDO_B );
	msg.set_do_c( m_strDO_C );
	msg.set_requires_all_same_class( m_bRequiresAllSameClass );
	msg.set_requires_all_same_slot( m_bRequiresAllSameSlot );
	msg.set_class_usage_for_output( m_iCacheClassUsageForOutputFromItem );
	msg.set_slot_usage_for_output( m_iCacheSlotUsageForOutputFromItem );
	msg.set_set_for_output( m_iCacheSetForOutputFromItem );

	FOR_EACH_VEC( m_InputItemsCriteria, i )
	{
		CSOItemCriteria *pCrit = msg.add_input_items_criteria();
		if ( !m_InputItemsCriteria[i].BSerializeToMsg( *pCrit ) )
			return false;
	}

	FOR_EACH_VEC( m_InputItemDupeCounts, i )
	{
		msg.add_input_item_dupe_counts( m_InputItemDupeCounts[i] );
	}

	FOR_EACH_VEC( m_OutputItemsCriteria, i )
	{
		CSOItemCriteria *pCrit = msg.add_output_items_criteria();
		if ( !m_OutputItemsCriteria[i].BSerializeToMsg( *pCrit ) )
			return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Serializes the criteria to and from messages
//-----------------------------------------------------------------------------
bool CEconCraftingRecipeDefinition::BDeserializeFromMsg( const CSOItemRecipe & msg )
{
	m_nDefIndex = msg.def_index();
	m_strName = msg.name().c_str();
	m_strN_A = msg.n_a().c_str();
	m_strDescInputs = msg.desc_inputs().c_str();
	m_strDescOutputs = msg.desc_outputs().c_str();
	m_strDI_A = msg.di_a().c_str();
	m_strDI_B = msg.di_b().c_str();
	m_strDI_C = msg.di_c().c_str();
	m_strDO_A = msg.do_a().c_str();
	m_strDO_B = msg.do_b().c_str();
	m_strDO_C = msg.do_c().c_str();

	m_bRequiresAllSameClass = msg.requires_all_same_class();
	m_bRequiresAllSameSlot = msg.requires_all_same_slot();
	m_iCacheClassUsageForOutputFromItem = msg.class_usage_for_output();
	m_iCacheSlotUsageForOutputFromItem = msg.slot_usage_for_output();
	m_iCacheSetForOutputFromItem = msg.set_for_output();

	// Read how many input items there are
	uint32 unCount = msg.input_items_criteria_size();
	m_InputItemsCriteria.SetSize( unCount );
	for ( uint32 i = 0; i < unCount; i++ )
	{
		if ( !m_InputItemsCriteria[i].BDeserializeFromMsg( msg.input_items_criteria( i ) ) )
			return false;
	}

	// Read how many input item dupe counts there are
	unCount = msg.input_item_dupe_counts_size();
	m_InputItemDupeCounts.SetSize( unCount );
	for ( uint32 i = 0; i < unCount; i++ )
	{
		m_InputItemDupeCounts[i] = msg.input_item_dupe_counts( i );
	}

	// Read how many output items there are
	unCount = msg.output_items_criteria_size();
	m_OutputItemsCriteria.SetSize( unCount );
	for ( uint32 i = 0; i < unCount; i++ )
	{
		if ( !m_OutputItemsCriteria[i].BDeserializeFromMsg( msg.output_items_criteria( i ) ) )
			return false;
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Returns true if the vector contains a set of items that matches the inputs for this recipe
//			Note it will fail if the vector contains extra items that aren't needed.
//
//-----------------------------------------------------------------------------
bool CEconCraftingRecipeDefinition::ItemListMatchesInputs( CUtlVector<CEconItem*> *vecCraftingItems, KeyValues *out_pkvCraftParams, bool bIgnoreSlop, CUtlVector<uint64> *vecChosenItems ) const
{
	return false;
}

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
int CEconCraftingRecipeDefinition::GetTotalInputItemsRequired( void ) const
{
	int iCount = 0;
	FOR_EACH_VEC( m_InputItemsCriteria, i )
	{
		if ( m_InputItemDupeCounts[i] )
		{
			iCount += m_InputItemDupeCounts[i];
		}
		else
		{
			iCount++;
		}
	}
	return iCount;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
#ifdef GC_DLL
	#define GC_SCH_REFERENCE( TAttribSchType ) \
		TAttribSchType, 
#else
	#define GC_SCH_REFERENCE( TAttribSchType )
#endif

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
unsigned int Internal_GetAttributeTypeUniqueIdentifierNextValue()
{
	static unsigned int s_unUniqueCounter = 0;

	unsigned int unCounter = s_unUniqueCounter;
	s_unUniqueCounter++;
	return unCounter;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
#ifdef GC_DLL
template < typename TAttribSchType, typename TRecordBaseType >
static TAttribSchType *GetTypedSch( TRecordBaseType *pRecordBase )
{
	Assert( pRecordBase->GetITable() == TAttribSchType::k_iTable );

#if ENABLE_TYPED_ATTRIBUTE_PARANOIA
	TAttribSchType *pTypedSch = dynamic_cast<TAttribSchType *>( pRecordBase );
	Assert( pTypedSch );
	return pTypedSch;
#else
	return static_cast<TAttribSchType *>( pRecordBase );
#endif
}
#endif // GC_DLL

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
template < GC_SCH_REFERENCE( typename TAttribSchType ) typename TAttribInMemoryType >
class CSchemaAttributeTypeBase : public ISchemaAttributeTypeBase<TAttribInMemoryType>
{
public:
#ifdef GC_DLL
	virtual CColumnSet& GetFullColumnSet() const OVERRIDE
	{
		static CColumnSet sFullColumnSet( CColumnSet::Full<TAttribSchType>() );

		return sFullColumnSet;
	}

	virtual CRecordBase *CreateTypedSchRecord() const OVERRIDE
	{
		return new TAttribSchType;
	}
#endif // GC_DLL
};

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
template < GC_SCH_REFERENCE( typename TAttribSchType ) typename TProtobufValueType >
class CSchemaAttributeTypeProtobufBase : public CSchemaAttributeTypeBase< GC_SCH_REFERENCE( TAttribSchType ) TProtobufValueType >
{
public:
	virtual void ConvertTypedValueToByteStream( const TProtobufValueType& typedValue, ::std::string *out_psBytes ) const OVERRIDE
	{
		DbgVerify( typedValue.SerializeToString( out_psBytes ) );
	}

	virtual void ConvertByteStreamToTypedValue( const ::std::string& sBytes, TProtobufValueType *out_pTypedValue ) const OVERRIDE
	{
		DbgVerify( out_pTypedValue->ParseFromString( sBytes ) );
	}

	virtual bool BConvertStringToEconAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const char *pszValue, union attribute_data_union_t *out_pValue, bool bEnableTerribleBackwardsCompatibilitySchemaParsingCode ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_pValue );
		
		std::string sValue( pszValue );
		TProtobufValueType typedValue;
		if ( !google::protobuf::TextFormat::ParseFromString( sValue, &typedValue ) )
			return false;

		this->ConvertTypedValueToEconAttributeValue( typedValue, out_pValue );
		return true;
	}

	virtual void ConvertEconAttributeValueToString( const CEconItemAttributeDefinition *pAttrDef, const attribute_data_union_t& value, std::string *out_ps ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_ps );

		google::protobuf::TextFormat::PrintToString( this->GetTypedValueContentsFromEconAttributeValue( value ), out_ps );
	}
};

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CSchemaAttributeType_String : public CSchemaAttributeTypeProtobufBase< GC_SCH_REFERENCE( CSchItemAttributeString ) CAttribute_String >
{
public:
#ifdef GC_DLL
	virtual void ConvertEconAttributeValueToSch( itemid_t unItemId, const CEconItemAttributeDefinition *pAttrDef, const attribute_data_union_t& value, GCSDK::CRecordBase *out_pSchRecord ) const OVERRIDE
	{
		Assert( out_pSchRecord );
		Assert( pAttrDef );
		Assert( pAttrDef->GetAttributeType() == this );

		CSchItemAttributeString *out_psch = GetTypedSch<CSchItemAttributeString>( out_pSchRecord );

		CAttribute_String typedValue;
		this->ConvertEconAttributeValueToTypedValue( value, &typedValue );

		// const CAttribute_String& typedValue = GetTypedValueContentsFromEconAttributeValue( value );

		out_psch->m_ulItemID			= unItemId;
		out_psch->m_unAttrDefIndex		= pAttrDef->GetDefinitionIndex();
		WRITE_VAR_CHAR_FIELD( (*out_psch), VarCharAttrStrValue, typedValue.value().c_str() );
	}

	virtual void LoadSchToEconAttributeValue( CEconItem *pTargetItem, const CEconItemAttributeDefinition *pAttrDef, const GCSDK::CRecordBase *pSchRecord ) const OVERRIDE
	{
		Assert( pTargetItem );
		Assert( pAttrDef );
		Assert( pSchRecord );
		Assert( pAttrDef->GetAttributeType() == this );

		const CSchItemAttributeString *psch = GetTypedSch<const CSchItemAttributeString>( pSchRecord );

		CAttribute_String typedValue;
		typedValue.set_value( READ_VAR_CHAR_FIELD( (*psch), m_VarCharAttrStrValue ) );

		pTargetItem->SetDynamicAttributeValue( pAttrDef, typedValue );
	}
#endif // GC_DLL

	// We intentionally override the convert-to-/convert-from-string functions for strings so that string literals can be
	// specified in the schema, etc. without worrying about the protobuf text format.
	virtual bool BConvertStringToEconAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const char *pszValue, union attribute_data_union_t *out_pValue, bool bEnableTerribleBackwardsCompatibilitySchemaParsingCode ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_pValue );

		CAttribute_String typedValue;
		typedValue.set_value( pszValue );

		this->ConvertTypedValueToEconAttributeValue( typedValue, out_pValue );

		return true;
	}

	virtual void ConvertEconAttributeValueToString( const CEconItemAttributeDefinition *pAttrDef, const attribute_data_union_t& value, std::string *out_ps ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_ps );

		*out_ps = this->GetTypedValueContentsFromEconAttributeValue( value ).value().c_str();
	}
};

void CopyStringAttributeValueToCharPointerOutput( const CAttribute_String *pValue, const char **out_pValue )
{
	Assert( pValue );
	Assert( out_pValue );

	*out_pValue = pValue->value().c_str();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CSchemaAttributeType_DynamicRecipeComponentDefinedItem : public CSchemaAttributeTypeProtobufBase< GC_SCH_REFERENCE( CSchItemAttributeDynamicRecipeComponentDefinedItem ) CAttribute_DynamicRecipeComponent >
{
public:
#ifdef GC_DLL
	virtual void ConvertEconAttributeValueToSch( itemid_t unItemId, const CEconItemAttributeDefinition *pAttrDef, const union attribute_data_union_t& value, GCSDK::CRecordBase *out_pSchRecord ) const OVERRIDE
	{
		Assert( out_pSchRecord );
		Assert( pAttrDef );
		Assert( pAttrDef->GetAttributeType() == this );

		CSchItemAttributeDynamicRecipeComponentDefinedItem *out_psch = GetTypedSch<CSchItemAttributeDynamicRecipeComponentDefinedItem>( out_pSchRecord );

		CAttribute_DynamicRecipeComponent typedValue;
		ConvertEconAttributeValueToTypedValue( value, &typedValue );

		out_psch->m_ulItemID			= unItemId;
		out_psch->m_unAttrDefIndex		= pAttrDef->GetDefinitionIndex();
		out_psch->m_unItemDef			= typedValue.def_index();
		out_psch->m_unItemQuality		= typedValue.item_quality();
		out_psch->m_unFlags				= typedValue.component_flags();
		out_psch->m_unItemCount			= typedValue.num_required();
		out_psch->m_unItemsFulfilled	= typedValue.num_fulfilled();
		WRITE_VAR_CHAR_FIELD( (*out_psch), VarCharAttrStr, typedValue.attributes_string().c_str() );
	}

	virtual void LoadSchToEconAttributeValue( CEconItem *pTargetItem, const CEconItemAttributeDefinition *pAttrDef, const GCSDK::CRecordBase *pSchRecord ) const OVERRIDE
	{
		Assert( pTargetItem );
		Assert( pAttrDef );
		Assert( pSchRecord );
		Assert( pAttrDef->GetAttributeType() == this );

		const CSchItemAttributeDynamicRecipeComponentDefinedItem *psch = GetTypedSch<const CSchItemAttributeDynamicRecipeComponentDefinedItem>( pSchRecord );

		CAttribute_DynamicRecipeComponent typedValue;
		typedValue.set_def_index( psch->m_unItemDef );
		typedValue.set_item_quality( psch->m_unItemQuality );
		typedValue.set_component_flags( psch->m_unFlags );
		typedValue.set_attributes_string( READ_VAR_CHAR_FIELD( (*psch), m_VarCharAttrStr ) );
		typedValue.set_num_required( psch->m_unItemCount );
		typedValue.set_num_fulfilled( psch->m_unItemsFulfilled );

		pTargetItem->SetDynamicAttributeValue( pAttrDef, typedValue );
	}

	virtual bool BConvertStringToEconAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const char *pszValue, union attribute_data_union_t *out_pValue, bool bEnableTerribleBackwardsCompatibilitySchemaParsingCode ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_pValue );
		
		std::string sValue( pszValue );
		// What's happened here is we've renamed some fields within CAttribute_DynamicRecipeComponent,
		// but steam contains the strings of the old format serialized, and keeps sending them to us.
		// Rather than updating steam, we're going to made a protobuff class that can accept the new
		// and old formats, and put the corret values into the correct members of the new format.

		
		CAttribute_DynamicRecipeComponent_COMPAT_NEVER_SERIALIZE_THIS_OUT  typedCompatValue;
		CAttribute_DynamicRecipeComponent typedActualValue;

#ifdef STAGING_ONLY
		auto *pActualFields = typedActualValue.descriptor();
		auto *pCompatFields = typedCompatValue.descriptor();
		for ( int i=0; i < pActualFields->field_count(); ++i )
		{
			const bool bFoundField = pCompatFields->FindFieldByName( pActualFields->field( i )->name() ) != NULL;
			Assert( bFoundField );
			if ( !bFoundField )
			{
				EmitError( SPEW_GC, "Missing field '%s' in CAttribute_DynamicRecipeComponent_COMPAT_NEVER_SERIALIZE_THIS_OUT\n", pActualFields->field( i )->name() );
				return false;
			}
		}
#endif // STAGING_ONLY

		if ( !google::protobuf::TextFormat::ParseFromString( sValue, &typedCompatValue ) )
		{
			EmitError( SPEW_GC, "Failed to parse recipe component into compatible protobuf\n" );
			return false;
		}

		if ( typedCompatValue.has_component_flags() )
			typedActualValue.set_component_flags( typedCompatValue.component_flags() );
		else if ( typedCompatValue.has_item_flags() )
			typedActualValue.set_component_flags( typedCompatValue.item_flags() );
		else 
		{
			EmitError( SPEW_GC, "Failed to parse component_flags.  component_flags: %d, item_flags: %d\n", typedCompatValue.component_flags(), typedCompatValue.item_flags() );
			return false;
		}

		if ( typedCompatValue.has_def_index() )
			typedActualValue.set_def_index( typedCompatValue.def_index() );
		else if ( typedCompatValue.has_item_def() )
			typedActualValue.set_def_index( typedCompatValue.item_def() );
		else if ( typedActualValue.component_flags() & DYNAMIC_RECIPE_FLAG_PARAM_ITEM_DEF_SET )
		{
			EmitError( SPEW_GC, "Failed to parse item_def.  def_index: %d, item_def: %d\n", typedCompatValue.def_index(), typedCompatValue.item_def() );
			return false;
		}

		typedActualValue.set_item_quality( typedCompatValue.item_quality() );

		
		
		typedActualValue.set_attributes_string( typedCompatValue.attributes_string() );

		if( typedCompatValue.has_num_required() )
			typedActualValue.set_num_required( typedCompatValue.num_required() );
		else if ( typedCompatValue.has_item_count() )
			typedActualValue.set_num_required( typedCompatValue.item_count() );
		else
		{
			EmitError( SPEW_GC, "Failed to parse component_flags.  num_required: %d, item_count: %d\n", typedCompatValue.num_required(), typedCompatValue.item_count() );
			return false;
		}

		if ( typedCompatValue.has_items_fulfilled() )
			typedActualValue.set_num_fulfilled( typedCompatValue.items_fulfilled() );
		else if ( typedCompatValue.has_num_fulfilled() )
			typedActualValue.set_num_fulfilled( typedCompatValue.num_fulfilled() );
		else
		{
			EmitError( SPEW_GC, "Failed to parse num_fulfilled.  items_fulfilled: %d, num_fulfilled: %d\n", typedCompatValue.items_fulfilled(), typedCompatValue.num_fulfilled() );
			return false;
		}

		this->ConvertTypedValueToEconAttributeValue( typedActualValue, out_pValue );
		return true;
	}

#endif // GC_DLL
};


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CSchemaAttributeType_ItemSlotCriteria : public CSchemaAttributeTypeProtobufBase< GC_SCH_REFERENCE( CSchItemAttributeItemSlotCriteria ) CAttribute_ItemSlotCriteria >
{
public:
#ifdef GC_DLL
	virtual void ConvertEconAttributeValueToSch( itemid_t unItemId, const CEconItemAttributeDefinition *pAttrDef, const union attribute_data_union_t& value, GCSDK::CRecordBase *out_pSchRecord ) const OVERRIDE
	{
		Assert( out_pSchRecord );
		Assert( pAttrDef );
		Assert( pAttrDef->GetAttributeType() == this );

		AssertMsg( 0, "Implement this when we want this attribute to be dynamic" );
	}

	virtual void LoadSchToEconAttributeValue( CEconItem *pTargetItem, const CEconItemAttributeDefinition *pAttrDef, const GCSDK::CRecordBase *pSchRecord ) const OVERRIDE
	{
		Assert( pTargetItem );
		Assert( pAttrDef );
		Assert( pSchRecord );
		Assert( pAttrDef->GetAttributeType() == this );
		
		AssertMsg( 0, "Implement this when we want this attribute to be dynamic" );
	}
#endif // GC_DLL

	virtual bool BConvertStringToEconAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const char *pszValue, union attribute_data_union_t *out_pValue, bool bEnableTerribleBackwardsCompatibilitySchemaParsingCode ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_pValue );

		std::string sValue( pszValue );
		CAttribute_ItemSlotCriteria typedValue;
		if ( !google::protobuf::TextFormat::ParseFromString( sValue, &typedValue ) )
			return false;

		this->ConvertTypedValueToEconAttributeValue( typedValue, out_pValue );

		return true;
	}

	virtual void ConvertEconAttributeValueToString( const CEconItemAttributeDefinition *pAttrDef, const attribute_data_union_t& value, std::string *out_ps ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_ps );

		this->ConvertEconAttributeValueToString( pAttrDef, value, out_ps );
	}
};


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CSchemaAttributeType_WorldItemPlacement : public CSchemaAttributeTypeProtobufBase < GC_SCH_REFERENCE( CSchItemAttributeWorldItemPlacement ) CAttribute_WorldItemPlacement >
{
public:
#ifdef GC_DLL
	virtual void ConvertEconAttributeValueToSch( itemid_t unItemId, const CEconItemAttributeDefinition *pAttrDef, const union attribute_data_union_t& value, GCSDK::CRecordBase *out_pSchRecord ) const OVERRIDE
	{
		Assert( out_pSchRecord );
		Assert( pAttrDef );
		Assert( pAttrDef->GetAttributeType() == this );

		CSchItemAttributeWorldItemPlacement *out_psch = GetTypedSch< CSchItemAttributeWorldItemPlacement >( out_pSchRecord );

		CAttribute_WorldItemPlacement typedValue;
		ConvertEconAttributeValueToTypedValue( value, &typedValue );

		out_psch->m_ulItemID = unItemId;
		out_psch->m_unAttrDefIndex = pAttrDef->GetDefinitionIndex();
		out_psch->m_ulOriginalItemID = typedValue.original_item_id();
		out_psch->m_fPosX = typedValue.pos_x();
		out_psch->m_fPosY = typedValue.pos_y();
		out_psch->m_fPosZ = typedValue.pos_z();
		out_psch->m_fAngX = typedValue.ang_x();
		out_psch->m_fAngY = typedValue.ang_y();
		out_psch->m_fAngZ = typedValue.ang_z();
	}

	virtual void LoadSchToEconAttributeValue( CEconItem *pTargetItem, const CEconItemAttributeDefinition *pAttrDef, const GCSDK::CRecordBase *pSchRecord ) const OVERRIDE
	{
		Assert( pTargetItem );
		Assert( pAttrDef );
		Assert( pSchRecord );
		Assert( pAttrDef->GetAttributeType() == this );

		const CSchItemAttributeWorldItemPlacement *psch = GetTypedSch< const CSchItemAttributeWorldItemPlacement >( pSchRecord );

		CAttribute_WorldItemPlacement typedValue;
		typedValue.set_original_item_id( psch->m_ulOriginalItemID );
		typedValue.set_pos_x( psch->m_fPosX );
		typedValue.set_pos_y( psch->m_fPosY );
		typedValue.set_pos_x( psch->m_fPosZ );
		typedValue.set_ang_x( psch->m_fAngX );
		typedValue.set_ang_y( psch->m_fAngY );
		typedValue.set_ang_z( psch->m_fAngZ );

		pTargetItem->SetDynamicAttributeValue( pAttrDef, typedValue );
	}
#endif // GC_DLL

	virtual bool BConvertStringToEconAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const char *pszValue, union attribute_data_union_t *out_pValue, bool bEnableTerribleBackwardsCompatibilitySchemaParsingCode ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_pValue );

		CAttribute_WorldItemPlacement typedValue;

		uint32 unValue = ( pszValue ) ? atoi( pszValue ) : 0;
		
		// Item forcing us to create the attribute (via force_gc_to_generate)
		if ( unValue == 0 )
		{
			typedValue.set_original_item_id( INVALID_ITEM_ID );
			typedValue.set_pos_x( 0.f );
			typedValue.set_pos_y( 0.f );
			typedValue.set_pos_z( 0.f );
			typedValue.set_ang_x( 0.f );
			typedValue.set_ang_y( 0.f );
			typedValue.set_ang_z( 0.f );
		}
		else
		{
			std::string sValue( pszValue );
			if ( !google::protobuf::TextFormat::ParseFromString( sValue, &typedValue ) )
				return false;
		}
		
		this->ConvertTypedValueToEconAttributeValue( typedValue, out_pValue );
		return true;
	}

	virtual void ConvertEconAttributeValueToString( const CEconItemAttributeDefinition *pAttrDef, const attribute_data_union_t& value, std::string *out_ps ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_ps );

		this->ConvertEconAttributeValueToString( pAttrDef, value, out_ps );
	}
};

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CSchemaAttributeType_Float : public CSchemaAttributeTypeBase< GC_SCH_REFERENCE( CSchItemAttributeFloat ) float >
{
public:
#ifdef GC_DLL
	virtual void ConvertEconAttributeValueToSch( itemid_t unItemId, const CEconItemAttributeDefinition *pAttrDef, const union attribute_data_union_t& value, GCSDK::CRecordBase *out_pSchRecord ) const OVERRIDE
	{
		Assert( out_pSchRecord );
		Assert( pAttrDef );
		Assert( pAttrDef->GetAttributeType() == this );

		CSchItemAttributeFloat *out_pschItemAttribute = GetTypedSch<CSchItemAttributeFloat>( out_pSchRecord );

		// @note Tom Bui: we store the value as an unsigned integer in the DB, so just treat the field as a bunch of bits
		out_pschItemAttribute->m_ulItemID		= unItemId;
		out_pschItemAttribute->m_unAttrDefIndex = pAttrDef->GetDefinitionIndex();
		out_pschItemAttribute->m_fValue			= value.asFloat;
	}

	virtual void LoadSchToEconAttributeValue( CEconItem *pTargetItem, const CEconItemAttributeDefinition *pAttrDef, const GCSDK::CRecordBase *pSchRecord ) const OVERRIDE
	{
		Assert( pTargetItem );
		Assert( pAttrDef );
		Assert( pSchRecord );
		Assert( pAttrDef->GetAttributeType() == this );

		const CSchItemAttributeFloat *pschItemAttribute = GetTypedSch<const CSchItemAttributeFloat>( pSchRecord );

		pTargetItem->SetDynamicAttributeValue( pAttrDef, pschItemAttribute->m_fValue );
	}
#endif // GC_DLL

	virtual bool BConvertStringToEconAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const char *pszValue, union attribute_data_union_t *out_pValue, bool bEnableTerribleBackwardsCompatibilitySchemaParsingCode ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_pValue );

		out_pValue->asFloat = Q_atof( pszValue );
		return true;
	}

	virtual void ConvertEconAttributeValueToString( const CEconItemAttributeDefinition *pAttrDef, const attribute_data_union_t& value, std::string *out_ps ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_ps );

		*out_ps = CFmtStr( "%f", value.asFloat ).Get();
	}
	
	virtual void ConvertTypedValueToByteStream( const float& typedValue, ::std::string *out_psBytes ) const OVERRIDE
	{
		Assert( out_psBytes );
		Assert( out_psBytes->size() == 0 );

		out_psBytes->resize( sizeof( float ) );
		*reinterpret_cast<float *>( &((*out_psBytes)[0]) ) = typedValue;		// overwrite string contents (sizeof( float ) bytes)
	}

	virtual void ConvertByteStreamToTypedValue( const ::std::string& sBytes, float *out_pTypedValue ) const OVERRIDE
	{
		Assert( out_pTypedValue );
		Assert( sBytes.size() == sizeof( float ) );

		*out_pTypedValue = *reinterpret_cast<const float *>( &sBytes[0] );
	}

	virtual bool BSupportsGameplayModificationAndNetworking() const OVERRIDE
	{
		return true;
	}
};


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CSchemaAttributeType_UInt64 : public CSchemaAttributeTypeBase< GC_SCH_REFERENCE( CSchItemAttributeUInt64 ) uint64 >
{
public:
#ifdef GC_DLL
	virtual void ConvertEconAttributeValueToSch( itemid_t unItemId, const CEconItemAttributeDefinition *pAttrDef, const union attribute_data_union_t& value, GCSDK::CRecordBase *out_pSchRecord ) const OVERRIDE
	{
		Assert( out_pSchRecord );
		Assert( pAttrDef );
		Assert( pAttrDef->GetAttributeType() == this );

		uint64 ulValue;
		ConvertEconAttributeValueToTypedValue( value, &ulValue );

		CSchItemAttributeUInt64 *out_pschItemAttribute = GetTypedSch<CSchItemAttributeUInt64>( out_pSchRecord );

		// @note Tom Bui: we store the value as an unsigned integer in the DB, so just treat the field as a bunch of bits
		out_pschItemAttribute->m_ulItemID		= unItemId;
		out_pschItemAttribute->m_unAttrDefIndex = pAttrDef->GetDefinitionIndex();
		out_pschItemAttribute->m_ulValue		= ulValue;
	}

	virtual void LoadSchToEconAttributeValue( CEconItem *pTargetItem, const CEconItemAttributeDefinition *pAttrDef, const GCSDK::CRecordBase *pSchRecord ) const OVERRIDE
	{
		Assert( pTargetItem );
		Assert( pAttrDef );
		Assert( pSchRecord );
		Assert( pAttrDef->GetAttributeType() == this );

		const CSchItemAttributeUInt64 *pschItemAttribute = GetTypedSch<const CSchItemAttributeUInt64>( pSchRecord );

		pTargetItem->SetDynamicAttributeValue( pAttrDef, pschItemAttribute->m_ulValue );
	}
#endif // GC_DLL

	virtual bool BConvertStringToEconAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const char *pszValue, union attribute_data_union_t *out_pValue, bool bEnableTerribleBackwardsCompatibilitySchemaParsingCode ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_pValue );

		out_pValue->asUint32 = V_atoui64( pszValue );
		return true;
	}

	virtual void ConvertEconAttributeValueToString( const CEconItemAttributeDefinition *pAttrDef, const attribute_data_union_t& value, std::string *out_ps ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_ps );

		uint64 ulValue;
		ConvertEconAttributeValueToTypedValue( value, &ulValue );

		*out_ps = CFmtStr( "%llu", ulValue ).Get();
	}
	
	virtual void ConvertTypedValueToByteStream( const uint64& typedValue, ::std::string *out_psBytes ) const OVERRIDE
	{
		Assert( out_psBytes );
		Assert( out_psBytes->size() == 0 );

		out_psBytes->resize( sizeof( uint64 ) );
		*reinterpret_cast<uint64 *>( &((*out_psBytes)[0]) ) = typedValue;		// overwrite string contents (sizeof( uint64 ) bytes)
	}

	virtual void ConvertByteStreamToTypedValue( const ::std::string& sBytes, uint64 *out_pTypedValue ) const OVERRIDE
	{
		Assert( out_pTypedValue );
		Assert( sBytes.size() == sizeof( uint64 ) );

		*out_pTypedValue = *reinterpret_cast<const uint64 *>( &sBytes[0] );
	}
};


//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CSchemaAttributeType_Default : public CSchemaAttributeTypeBase< GC_SCH_REFERENCE( CSchItemAttribute ) attrib_value_t >
{
public:
#ifdef GC_DLL
	virtual bool BAssetClassExportedAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const attribute_data_union_t& value ) const OVERRIDE
	{
		Assert( pAttrDef );

		static CSchemaAttributeDefHandle pAttrib_TradableAfter( "tradable after date" );

		// Don't include "tradable after date" if it's in the past
		// See IEconItemInterface::IsTradable for the specific logic on how this affects tradability
		if ( pAttrDef == pAttrib_TradableAfter && CRTime::RTime32TimeCur() > value.asUint32 )
			return false;

		return CSchemaAttributeTypeBase< GC_SCH_REFERENCE( CSchItemAttribute ) attrib_value_t >::BAssetClassExportedAttributeValue( pAttrDef, value );
	}

	virtual void ConvertEconAttributeValueToSch( itemid_t unItemId, const CEconItemAttributeDefinition *pAttrDef, const union attribute_data_union_t& value, GCSDK::CRecordBase *out_pSchRecord ) const OVERRIDE
	{
		Assert( out_pSchRecord );
		Assert( pAttrDef );
		Assert( pAttrDef->GetAttributeType() == this );

		CSchItemAttribute *out_pschItemAttribute = GetTypedSch<CSchItemAttribute>( out_pSchRecord );

		// @note Tom Bui: we store the value as an unsigned integer in the DB, so just treat the field as a bunch of bits
		out_pschItemAttribute->m_ulItemID		= unItemId;
		out_pschItemAttribute->m_unAttrDefIndex = pAttrDef->GetDefinitionIndex();
		out_pschItemAttribute->m_unValue		= value.asUint32;
	}

	virtual void LoadSchToEconAttributeValue( CEconItem *pTargetItem, const CEconItemAttributeDefinition *pAttrDef, const GCSDK::CRecordBase *pSchRecord ) const OVERRIDE
	{
		Assert( pTargetItem );
		Assert( pAttrDef );
		Assert( pSchRecord );
		Assert( pAttrDef->GetAttributeType() == this );

		const CSchItemAttribute *pschItemAttribute = GetTypedSch<const CSchItemAttribute>( pSchRecord );

		pTargetItem->SetDynamicAttributeValue( pAttrDef, pschItemAttribute->m_unValue );
	}

	virtual void LoadOrGenerateEconAttributeValue( CEconItem *pTargetItem, const CEconItemAttributeDefinition *pAttrDef, const static_attrib_t& staticAttrib, const CEconGameAccount *pGameAccount ) const OVERRIDE
	{
		Assert( pTargetItem );
		Assert( pTargetItem->GetItemDefinition() );
		Assert( pAttrDef );

		// Wear is reassigned by attributes but has a default value from itemdef prefab
		static CSchemaAttributeDefHandle pAttrDef_PaintkitWear( "set_item_texture_wear" );

		// do not apply an attribute if it already exists.  If the new and the old attribute value is different then we assert (and use the latest value)
		attrib_value_t unValue = 0;
		if ( pTargetItem->FindAttribute( pAttrDef, &unValue ) && pAttrDef != pAttrDef_PaintkitWear )
		{
			AssertMsg4( unValue == staticAttrib.m_value.asUint32,
				"Item id %llu (%s) attempting to generate dynamic attribute value for '%s' (%d) when attribute already exists with a different Value! This probably indicates some sort of code flow error calling LoadOrGenerateEconAttributeValue() late.",
				pTargetItem->GetItemID(), pTargetItem->GetItemDefinition()->GetDefinitionName(), pAttrDef->GetDefinitionName(), pAttrDef->GetDefinitionIndex() );

			if ( unValue == staticAttrib.m_value.asUint32 )
				return;
		}
		
		// Could be raw integer bits or raw floating-point bits depending on where in the union we stored the value. We copy the
		// bit pattern indiscriminately.
		attribute_data_union_t ResultValue;
		ResultValue = staticAttrib.m_value;
		GenerateEconAttributeValue( pAttrDef, staticAttrib, pGameAccount, &ResultValue );
		LoadEconAttributeValue( pTargetItem, pAttrDef, ResultValue );
	}

	virtual void GenerateEconAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const static_attrib_t& staticAttrib, const CEconGameAccount *pGameAccount, attribute_data_union_t* out_pValue ) const
	{
		Assert( pAttrDef );
		AssertMsg( pGameAccount || !staticAttrib.m_pKVCustomData, "Cannot run custom logic with no game account object! Passing in NULL for pGameAccount is only supported when we know we won't be running custom value generation code!" );
		Assert( out_pValue );

		if( staticAttrib.m_pKVCustomData )
		{
			Internal_RunCustomAttributeValueLogic( staticAttrib, pGameAccount, out_pValue );
		}
	}
#endif // GC_DLL

	virtual bool BConvertStringToEconAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const char *pszValue, union attribute_data_union_t *out_pValue, bool bEnableTerribleBackwardsCompatibilitySchemaParsingCode ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_pValue );

		if ( bEnableTerribleBackwardsCompatibilitySchemaParsingCode )
		{
			// Not having any value specified is valid -- we interpret this as "default", or 0 as both an in int and a float.
			out_pValue->asFloat = pszValue
								? atof( pszValue )
								: 0.0f;
		}
		// This is terrible backwards-compatibility code to support the pulling of values from econ asset classes.
		else
		{
			if ( pAttrDef->IsStoredAsInteger() )
			{
				out_pValue->asUint32 = (uint32)Q_atoui64( pszValue );
			}
			else if ( pAttrDef->IsStoredAsFloat() )
			{
				out_pValue->asFloat = Q_atof( pszValue );
			}
			else
			{
				Assert( !"Unknown storage type for CSchemaAttributeType_Default::BConvertStringToEconAttributeValue()!" );
				return false;
			}
		}

		return true;
	}

	virtual void ConvertEconAttributeValueToString( const CEconItemAttributeDefinition *pAttrDef, const attribute_data_union_t& value, std::string *out_ps ) const OVERRIDE
	{
		Assert( pAttrDef );
		Assert( out_ps );

		if( pAttrDef->IsStoredAsFloat() )
		{
			*out_ps = CFmtStr( "%f", value.asFloat ).Get();
		}
		else if( pAttrDef->IsStoredAsInteger() )
		{
			*out_ps = CFmtStr( "%u", value.asUint32 ).Get();
		}
		else
		{
			Assert( !"Unknown storage type for CSchemaAttributeType_Default::ConvertEconAttributeValueToString()!" );
		}
	}
	
	virtual void ConvertTypedValueToByteStream( const attrib_value_t& typedValue, ::std::string *out_psBytes ) const OVERRIDE
	{
		Assert( out_psBytes );
		Assert( out_psBytes->size() == 0 );

		out_psBytes->resize( sizeof( attrib_value_t ) );
		*reinterpret_cast<attrib_value_t *>( &((*out_psBytes)[0]) ) = typedValue;		// overwrite string contents (sizeof( attrib_value_t ) bytes)
	}

	virtual void ConvertByteStreamToTypedValue( const ::std::string& sBytes, attrib_value_t *out_pTypedValue ) const OVERRIDE
	{
		Assert( out_pTypedValue );
#ifdef GC_DLL
		// The GC is expected to always have internally-consistent information.
		Assert( sBytes.size() == sizeof( attrib_value_t ) );
#else
		// Game clients and servers may have partially out-of-date information, or may have downloaded a new schema
		// but not know how to parse an attribute of a certain type, etc. In these cases, because we know we
		// aren't on the GC, temporarily failing to load these values until the client shuts down and updates
		// is about the best we can hope for.
		if ( sBytes.size() < sizeof( attrib_value_t ) )
		{
			*out_pTypedValue = attrib_value_t();
			return;
		}
#endif

		*out_pTypedValue = *reinterpret_cast<const attrib_value_t *>( &sBytes[0] );
	}

	virtual bool BSupportsGameplayModificationAndNetworking() const OVERRIDE
	{
		return true;
	}
	
private:
#ifdef GC_DLL
	void Internal_RunCustomAttributeValueLogic( const static_attrib_t& staticAttrib, const CEconGameAccount *pGameAccount, attribute_data_union_t* out_pValue ) const
	{
		AssertMsg( pGameAccount, "No game account when running custom attribute value logic!" );

		float flValue = 0;

		const char *pszMethod = staticAttrib.m_pKVCustomData->GetString( "method", NULL );

		if ( Q_stricmp( pszMethod, "employee_number" ) == 0 )
		{
			flValue = pGameAccount->Obj().m_rtime32FirstPlayed;
		}
		else if ( Q_stricmp( pszMethod, "date" ) == 0 ) // Not used?
		{
			flValue = CRTime::RTime32TimeCur();
		}
		else if ( Q_stricmp( pszMethod, "year" ) == 0 )
		{
			flValue = CRTime( CRTime::RTime32TimeCur() ).GetYear();
		}
		else if ( Q_stricmp( pszMethod, "gifts_given_out" ) == 0 )
		{
			flValue = pGameAccount->Obj().m_unNumGiftsGiven;
		}
		else if ( Q_stricmp( pszMethod, "expiration_period_hours_from_now" ) == 0 )
		{
			flValue = CRTime::RTime32DateAdd( CRTime::RTime32TimeCur(), staticAttrib.m_value.asFloat, k_ETimeUnitHour );
		}
		else if ( Q_stricmp( pszMethod, "def index from lootlist" ) == 0 )
		{
			const char* pszLootlistName = staticAttrib.m_pKVCustomData->GetString( "lootlist" );
			// Custom data stores the lootlist
			const CEconLootListDefinition* pLootList = GEconItemSchema().GetLootListByName( pszLootlistName );

			if( !pLootList )
			{
				AssertMsg1( 0, "Lootlist '%s' not found when performing custom attribute logic", pszLootlistName );
				return;
			}

			CUtlVector<CEconLootListDefinition::rolled_item_defs_t> vecRolledItems;
			// Roll our item def
			CDefaultUniformRandomStream RandomStream;
			if( !pLootList->RollRandomItemsAndAdditionalItems( &RandomStream, false, &vecRolledItems ) )
			{
				AssertMsg1( 0, "Error generating item defs from lootlist '%s'", pszLootlistName );
				return;
			}

			// Just take the first one's def index
			flValue = vecRolledItems.Head().m_pItemDef->GetDefinitionIndex();
		}
		else
		{
			AssertMsg1( false, "Unknown value for 'method': '%s'", pszMethod );
		}

		// Put the value into the right part of the union
		if ( staticAttrib.GetAttributeDefinition()->IsStoredAsFloat() )
		{
			(*out_pValue).asFloat = flValue;
		}
		else if ( staticAttrib.GetAttributeDefinition()->IsStoredAsInteger() )
		{
			(*out_pValue).asUint32 = (uint32)flValue;
		}
		else
		{
			AssertMsg1( 0, "Unknown storage type for CSchemaAttributeType_Default::Internal_RunCustomAttributeValueLogic() for attribute %s", staticAttrib.GetAttributeDefinition()->GetDefinitionName() );
		}
	}
#endif
};

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CEconItemAttributeDefinition::CEconItemAttributeDefinition( void )
:	m_pKVAttribute( NULL ),
	m_pAttrType( NULL ),
	m_bHidden( false ),
	m_bWebSchemaOutputForced( false ),
	m_bStoredAsInteger( false ),
	m_bInstanceData( false ),
	m_bIsSetBonus( false ),
	m_iUserGenerationType( 0 ),
	m_iEffectType( ATTRIB_EFFECT_NEUTRAL ),
	m_iDescriptionFormat( 0 ),
	m_pszDescriptionString( NULL ),
	m_pszArmoryDesc( NULL ),
	m_pszDefinitionName( NULL ),
	m_pszAttributeClass( NULL ),
	m_ItemDefinitionTag( INVALID_ECON_TAG_HANDLE ),
	m_bCanAffectMarketName( false ),
	m_bCanAffectRecipeComponentName( false )
#ifndef GC_DLL
  , m_iszAttributeClass( NULL_STRING )
#endif
{
}


//-----------------------------------------------------------------------------
// Purpose:	Copy constructor
//-----------------------------------------------------------------------------
CEconItemAttributeDefinition::CEconItemAttributeDefinition( const CEconItemAttributeDefinition &that )
{
	(*this) = that;
}


//-----------------------------------------------------------------------------
// Purpose:	Operator=
//-----------------------------------------------------------------------------
CEconItemAttributeDefinition &CEconItemAttributeDefinition::operator=( const CEconItemAttributeDefinition &rhs )
{
	m_nDefIndex = rhs.m_nDefIndex;
	m_pAttrType = rhs.m_pAttrType;
	m_bHidden = rhs.m_bHidden;
	m_bWebSchemaOutputForced = rhs.m_bWebSchemaOutputForced;
	m_bStoredAsInteger = rhs.m_bStoredAsInteger;
	m_iUserGenerationType = rhs.m_iUserGenerationType;
	m_bInstanceData = rhs.m_bInstanceData;
	m_bIsSetBonus = rhs.m_bIsSetBonus;
	m_iEffectType = rhs.m_iEffectType;
	m_iDescriptionFormat = rhs.m_iDescriptionFormat;
	m_pszDescriptionString = rhs.m_pszDescriptionString;
	m_pszArmoryDesc = rhs.m_pszArmoryDesc;
	m_pszDefinitionName = rhs.m_pszDefinitionName;
	m_pszAttributeClass = rhs.m_pszAttributeClass;
	m_ItemDefinitionTag = rhs.m_ItemDefinitionTag;
	m_bCanAffectMarketName = rhs.m_bCanAffectMarketName;
	m_bCanAffectRecipeComponentName = rhs.m_bCanAffectRecipeComponentName;
#ifndef GC_DLL
	m_iszAttributeClass = rhs.m_iszAttributeClass;
#endif

	m_pKVAttribute = NULL;
	if ( NULL != rhs.m_pKVAttribute )
	{
		m_pKVAttribute = rhs.m_pKVAttribute->MakeCopy();

		// Re-assign string pointers
		m_pszDefinitionName = m_pKVAttribute->GetString("name");
		m_pszDescriptionString = m_pKVAttribute->GetString( "description_string", NULL );
		m_pszArmoryDesc = m_pKVAttribute->GetString( "armory_desc", NULL );
		m_pszAttributeClass = m_pKVAttribute->GetString( "attribute_class", NULL );

		Assert( V_strcmp( m_pszDefinitionName, rhs.m_pszDefinitionName ) == 0 );
		Assert( V_strcmp( m_pszDescriptionString, rhs.m_pszDescriptionString ) == 0 );
		Assert( V_strcmp( m_pszArmoryDesc, rhs.m_pszArmoryDesc ) == 0 );
		Assert( V_strcmp( m_pszAttributeClass, rhs.m_pszAttributeClass ) == 0 );
	}
	else
	{
		Assert( m_pszDefinitionName == NULL );
		Assert( m_pszDescriptionString == NULL );
		Assert( m_pszArmoryDesc == NULL );
		Assert( m_pszAttributeClass == NULL );
	}
	return *this;
}


//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CEconItemAttributeDefinition::~CEconItemAttributeDefinition( void )
{
	if ( m_pKVAttribute )
		m_pKVAttribute->deleteThis();
	m_pKVAttribute = NULL;
}


//-----------------------------------------------------------------------------
// Purpose:	Initialize the attribute definition
// Input:	pKVAttribute - The KeyValues representation of the attribute
//			schema - The overall item schema for this attribute
//			pVecErrors - An optional vector that will contain error messages if 
//				the init fails.
// Output:	True if initialization succeeded, false otherwise
//-----------------------------------------------------------------------------
bool CEconItemAttributeDefinition::BInitFromKV( KeyValues *pKVAttribute, CUtlVector<CUtlString> *pVecErrors /* = NULL */ )
{
	m_pKVAttribute = pKVAttribute->MakeCopy();
	m_nDefIndex = Q_atoi( m_pKVAttribute->GetName() );
	
	m_pszDefinitionName = m_pKVAttribute->GetString("name", "(unnamed)");
	m_bHidden = m_pKVAttribute->GetInt( "hidden", 0 ) != 0;
	m_bWebSchemaOutputForced = m_pKVAttribute->GetInt( "force_output_description", 0 ) != 0;
	m_bStoredAsInteger = m_pKVAttribute->GetInt( "stored_as_integer", 0 ) != 0;
	m_bIsSetBonus = m_pKVAttribute->GetBool( "is_set_bonus", false );
	m_bCanAffectMarketName = m_pKVAttribute->GetBool( "can_affect_market_name", false );
	m_bCanAffectRecipeComponentName = m_pKVAttribute->GetBool( "can_affect_recipe_component_name", false );
	m_iUserGenerationType = m_pKVAttribute->GetInt( "is_user_generated", 0 );
	m_iEffectType = (attrib_effect_types_t)StringFieldToInt( m_pKVAttribute->GetString("effect_type"), g_EffectTypes, ARRAYSIZE(g_EffectTypes) );
	m_iDescriptionFormat = StringFieldToInt( m_pKVAttribute->GetString("description_format"), g_AttributeDescriptionFormats, ARRAYSIZE(g_AttributeDescriptionFormats) );
	m_pszDescriptionString = m_pKVAttribute->GetString( "description_string", NULL );
	m_pszArmoryDesc = m_pKVAttribute->GetString( "armory_desc", NULL );
	m_pszAttributeClass = m_pKVAttribute->GetString( "attribute_class", NULL );
	m_bInstanceData = pKVAttribute->GetBool( "instance_data", false );

	const char *pszTag = m_pKVAttribute->GetString( "apply_tag_to_item_definition", NULL );
	m_ItemDefinitionTag = pszTag ? GetItemSchema()->GetHandleForTag( pszTag ) : INVALID_ECON_TAG_HANDLE;

#if defined(CLIENT_DLL) || defined(GAME_DLL)
	m_iszAttributeClass = NULL_STRING;
#endif
	const char *pszAttrType = m_pKVAttribute->GetString( "attribute_type", NULL );		// NULL implies "default type" for backwards compatibility
	m_pAttrType = GetItemSchema()->GetAttributeType( pszAttrType );

	SCHEMA_INIT_CHECK( 
		NULL != m_pKVAttribute->FindKey( "name" ), 
		"Attribute definition %s: Missing required field \"name\"", m_pKVAttribute->GetName() );

	SCHEMA_INIT_CHECK(
		NULL != m_pAttrType,
		"Attribute definition %s: Unable to find attribute data type '%s'", m_pszDefinitionName, pszAttrType ? pszAttrType : "(default)" );

	if ( m_bIsSetBonus )
	{
		SCHEMA_INIT_CHECK(
			m_pAttrType->BSupportsGameplayModificationAndNetworking(),
			"Attribute definition %s: set as set bonus attribute but does not support gameplay modification/networking!", m_pszDefinitionName );
	}

	m_unAssetClassBucket = pKVAttribute->GetInt( "asset_class_bucket", 0 );
	m_eAssetClassAttrExportRule = k_EAssetClassAttrExportRule_Default;
	if ( char const *szRule = pKVAttribute->GetString( "asset_class_export", NULL ) )
	{
		if ( !V_stricmp( szRule, "skip" ) )
		{
			m_eAssetClassAttrExportRule = k_EAssetClassAttrExportRule_Skip;
		}
		else if ( !V_stricmp( szRule, "gconly" ) )
		{
			m_eAssetClassAttrExportRule = EAssetClassAttrExportRule_t( k_EAssetClassAttrExportRule_GCOnly | k_EAssetClassAttrExportRule_Skip );
		}
		else if ( !V_stricmp( szRule, "bucketed" ) )
		{
			SCHEMA_INIT_CHECK( m_unAssetClassBucket, "Attribute definition %s: Asset class export rule '%s' is incompatible", m_pszDefinitionName, szRule );
			m_eAssetClassAttrExportRule = k_EAssetClassAttrExportRule_Bucketed;
		}
		else if ( !V_stricmp( szRule, "default" ) )
		{
			m_eAssetClassAttrExportRule = k_EAssetClassAttrExportRule_Default;
		}
		else
		{
			SCHEMA_INIT_CHECK( false, "Attribute definition %s: Invalid asset class export rule '%s'", m_pszDefinitionName, szRule );
		}
	}

	// Check for misuse of asset class bucket
	SCHEMA_INIT_CHECK( ( !m_unAssetClassBucket || m_bInstanceData ), "Attribute definition %s: Cannot use \"asset_class_bucket\" on class-level attributes", m_pKVAttribute->GetName() );


	return SCHEMA_INIT_SUCCESS();
}

CQuestObjectiveDefinition::CQuestObjectiveDefinition( void )
	: m_pszDescriptionToken( NULL )
	, m_nDefIndex( 0 )
	, m_nPoints( 0 )
{}

CQuestObjectiveDefinition::~CQuestObjectiveDefinition()
{}

bool CQuestObjectiveDefinition::BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ )
{
	m_nDefIndex = pKVItem->GetInt( "defindex", -1 );
	m_pszDescriptionToken = pKVItem->GetString( "description_string" );
	m_bOptional = pKVItem->GetBool( "optional", false );
	m_bAdvanced = pKVItem->GetBool( "advanced", false );
	m_nPoints = pKVItem->GetInt( "points", 0 );

	SCHEMA_INIT_CHECK( m_nDefIndex != -1, "Quest objective missing def index" );
	SCHEMA_INIT_CHECK( m_pszDescriptionToken != NULL, "Quest objective is missing a description" );

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:	Constructor
//-----------------------------------------------------------------------------
CEconItemDefinition::CEconItemDefinition( void )
:	m_pKVItem( NULL ),
m_bEnabled( false ),
m_unMinItemLevel( 1 ),
m_unMaxItemLevel( 1 ),
m_iArmoryRemap( 0 ),
m_iStoreRemap( 0 ),
m_nItemQuality( k_unItemQuality_Any ),
m_nForcedItemQuality( k_unItemQuality_Any ),
m_nDefaultDropQuantity( 1 ),
m_bLoadOnDemand( false ),
m_pTool( NULL ),
m_rtExpiration( 0 ),
m_BundleInfo( NULL ),
#ifdef TF_CLIENT_DLL
m_unNumConcreteItems( 0 ),
#endif // TF_CLIENT_DLL
m_nPopularitySeed( 0 ),
m_pszDefinitionName( NULL ),
m_pszItemClassname( NULL ),
m_pszClassToken( NULL ),
m_pszSlotToken( NULL ),
m_pszItemBaseName( NULL ),
m_pszItemTypeName( NULL ),
m_pszItemDesc( NULL ),
m_pszArmoryDesc( NULL ),
m_pszInventoryModel( NULL ),
m_pszInventoryImage( NULL ),
m_pszHolidayRestriction( NULL ),
m_iSubType( 0 ),
m_pszBaseDisplayModel( NULL ),
m_iDefaultSkin( -1 ),
m_pszWorldDisplayModel( NULL ),
m_pszWorldExtraWearableModel( NULL ),
m_pszWorldExtraWearableViewModel( NULL ),
m_pszVisionFilteredDisplayModel( NULL ),
m_pszBrassModelOverride( NULL ),
m_bHideBodyGroupsDeployedOnly( false ),
m_bAttachToHands( false ),
m_bAttachToHandsVMOnly( false ),
m_bProperName( false ),
m_bFlipViewModel( false ),
m_bActAsWearable( false ),
m_bActAsWeapon( false ),
m_iDropType( 1 ),
m_bHidden( false ),
m_bShouldShowInArmory( false ),
m_bIsPackBundle( false ),
m_pOwningPackBundle( NULL ),
m_bIsPackItem( false ),
m_bBaseItem( false ),
m_pszItemLogClassname( NULL ),
m_pszItemIconClassname( NULL ),
m_pszDatabaseAuditTable( NULL ),
m_bImported( false ),
m_pItemSetDef( NULL ),
m_pItemCollectionDef( NULL ),
m_pItemPaintKitDef( NULL ),
m_pszArmoryRemap( NULL ),
m_pszStoreRemap( NULL ),
m_unSetItemRemapDefIndex( INVALID_ITEM_DEF_INDEX ),
m_pszXifierRemapClass( NULL ),
m_pszBaseFunctionalItemName( NULL ),
m_pszParticleSuffix( NULL ),
m_pszCollectionReference( NULL ),
m_nItemRarity( k_unItemRarity_Any ),
m_unItemSeries( 0 ),
m_bValidForShuffle( false ),
m_bValidForSelfMade( true )
{
	for ( int team = 0; team < TEAM_VISUAL_SECTIONS; team++ )
	{
		m_PerTeamVisuals[team] = NULL;
	}

	m_pDictIcons = new CUtlDict< CUtlString >;
}

//-----------------------------------------------------------------------------
// Purpose: Destructor
//-----------------------------------------------------------------------------
CEconItemDefinition::~CEconItemDefinition( void )
{
	for ( int i = 0; i < ARRAYSIZE( m_PerTeamVisuals ); i++ )
		delete m_PerTeamVisuals[i];

#ifdef GC_DLL
	m_vecPropertyGenerators.PurgeAndDeleteElements();
#endif // GC_DLL

	if ( m_pKVItem )
		m_pKVItem->deleteThis();
	m_pKVItem = NULL;
	delete m_pTool;
	delete m_BundleInfo;
	delete m_pDictIcons;
}

#if defined(CLIENT_DLL) || defined(GAME_DLL)
//-----------------------------------------------------------------------------
// Purpose: Stomp our base data with extra testing data specified by the player
//-----------------------------------------------------------------------------
bool CEconItemDefinition::BInitFromTestItemKVs( int iNewDefIndex, KeyValues *pKVItem, CUtlVector<CUtlString>* pVecErrors )
{
	// The KeyValues are stored in the player entity, so we can cache our name there

	m_nDefIndex = iNewDefIndex;
	m_unSetItemRemapDefIndex = m_nDefIndex;

	bool bTestingExistingItem = pKVItem->GetBool( "test_existing_item", false );
	if ( !bTestingExistingItem )
	{
		m_pszDefinitionName = pKVItem->GetString( "name", NULL );
		m_pszItemBaseName = pKVItem->GetString( "name", NULL );

#ifdef CLIENT_DLL
		pKVItem->SetString( "name", VarArgs("Test Item %d", iNewDefIndex) );
#else
		pKVItem->SetString( "name", UTIL_VarArgs("Test Item %d", iNewDefIndex) );
#endif

		m_pszBaseDisplayModel = pKVItem->GetString( "model_player", NULL );
		m_pszVisionFilteredDisplayModel = pKVItem->GetString( "model_vision_filtered", NULL );
		m_bAttachToHands = pKVItem->GetInt( "attach_to_hands", 0 ) != 0;

		BInitVisualBlockFromKV( pKVItem );
	}

	// Handle attributes
	m_vecStaticAttributes.Purge();
	int iPaintCanIndex = pKVItem->GetInt("paintcan_index", 0);
	if ( iPaintCanIndex )
	{
		static CSchemaAttributeDefHandle pAttrDef_PaintRGB( "set item tint RGB" );

		const CEconItemDefinition *pCanDef = GetItemSchema()->GetItemDefinition(iPaintCanIndex);
		
		float flRGBVal;
		if ( pCanDef && pAttrDef_PaintRGB && FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pCanDef, pAttrDef_PaintRGB, &flRGBVal ) )
		{
			static_attrib_t& StaticAttrib = m_vecStaticAttributes[ m_vecStaticAttributes.AddToTail() ];

			StaticAttrib.iDefIndex = pAttrDef_PaintRGB->GetDefinitionIndex();
			StaticAttrib.m_value.asFloat = flRGBVal;							// this is bad! but we're in crazy hack code for UI customization of item definitions that don't exist so
		}
	}

	int iUnusualEffectIndex = pKVItem->GetInt( "unusual_index", 0 );
	if ( iUnusualEffectIndex )
	{
		static CSchemaAttributeDefHandle pAttrDef_AttachParticleStatic( "attach particle effect static" );

		const attachedparticlesystem_t *pSystem = GetItemSchema()->GetAttributeControlledParticleSystem( iUnusualEffectIndex );

		if ( pAttrDef_AttachParticleStatic && pSystem )
		{
			static_attrib_t& StaticAttrib = m_vecStaticAttributes[ m_vecStaticAttributes.AddToTail() ];

			StaticAttrib.iDefIndex = pAttrDef_AttachParticleStatic->GetDefinitionIndex();
			StaticAttrib.m_value.asFloat = iUnusualEffectIndex;					// this is bad! but we're in crazy hack code for UI customization of item definitions that don't exist so
		}
	}

	return true;
}

animation_on_wearable_t *GetOrCreateAnimationActivity( perteamvisuals_t *pVisData, const char *pszActivityName )
{
	FOR_EACH_VEC( pVisData->m_Animations, i )
	{
		if ( Q_stricmp(pVisData->m_Animations[i].pszActivity, pszActivityName) == 0 )
			return &pVisData->m_Animations[i];
	}

	animation_on_wearable_t *pEntry = &pVisData->m_Animations[pVisData->m_Animations.AddToTail()];

	pEntry->iActivity = kActivityLookup_Unknown;	// We can't look it up yet, the activity list hasn't been populated.
	pEntry->pszActivity = pszActivityName;
	pEntry->iReplacement = kActivityLookup_Unknown;
	pEntry->pszReplacement = NULL;
	pEntry->pszSequence = NULL;
	pEntry->pszScene = NULL;
	pEntry->pszRequiredItem = NULL;

	return pEntry;
}

activity_on_wearable_t *GetOrCreatePlaybackActivity( perteamvisuals_t *pVisData, wearableanimplayback_t iPlayback )
{
	FOR_EACH_VEC( pVisData->m_Animations, i )
	{
		if ( pVisData->m_Activities[i].iPlayback == iPlayback )
			return &pVisData->m_Activities[i];
	}

	activity_on_wearable_t *pEntry = &pVisData->m_Activities[pVisData->m_Activities.AddToTail()];

	pEntry->iPlayback = iPlayback;
	pEntry->iActivity = kActivityLookup_Unknown;	// We can't look it up yet, the activity list hasn't been populated.
	pEntry->pszActivity = NULL;

	return pEntry;
}

#endif // defined(CLIENT_DLL) || defined(GAME_DLL)

//-----------------------------------------------------------------------------
// Purpose: Handle parsing the per-team visual block from the keyvalues
//-----------------------------------------------------------------------------
void CEconItemDefinition::BInitVisualBlockFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors )
{
	// Visuals
	for ( int team = 0; team < TEAM_VISUAL_SECTIONS; team++ )
	{
		m_PerTeamVisuals[team] = NULL;

		if ( !g_TeamVisualSections[team] )
			continue;

		KeyValues *pVisualsKV = pKVItem->FindKey( g_TeamVisualSections[team] );
		if ( pVisualsKV )
		{
			perteamvisuals_t *pVisData = new perteamvisuals_t();
#if defined(CLIENT_DLL) || defined(GAME_DLL)
			KeyValues *pKVEntry = pVisualsKV->GetFirstSubKey();
			while ( pKVEntry )
			{
				const char *pszEntry = pKVEntry->GetName();

				if ( !Q_stricmp( pszEntry, "use_visualsblock_as_base" ) )
				{
					// Start with a copy of an existing PerTeamVisuals
					const char *pszString = pKVEntry->GetString();
					int nOverrideTeam = GetTeamVisualsFromString( pszString );
					if ( nOverrideTeam != -1 )
					{
						*pVisData = *m_PerTeamVisuals[nOverrideTeam];
					}
					else
					{
						pVecErrors->AddToTail( CFmtStr( "Unknown visuals block: %s", pszString ).Access() );
					}
				}
				else if ( !Q_stricmp( pszEntry, "attached_models" ) )
				{
					FOR_EACH_SUBKEY( pKVEntry, pKVAttachedModelData )
					{
						int iAtt = pVisData->m_AttachedModels.AddToTail();
						pVisData->m_AttachedModels[iAtt].m_iModelDisplayFlags = pKVAttachedModelData->GetInt( "model_display_flags", kAttachedModelDisplayFlag_MaskAll );
						pVisData->m_AttachedModels[iAtt].m_pszModelName = pKVAttachedModelData->GetString( "model", NULL );
					}
				}
				else if ( !Q_stricmp( pszEntry, "attached_models_festive" ) )
				{
					FOR_EACH_SUBKEY( pKVEntry, pKVAttachedModelData )
					{
						int iAtt = pVisData->m_AttachedModelsFestive.AddToTail();
						pVisData->m_AttachedModelsFestive[iAtt].m_iModelDisplayFlags = pKVAttachedModelData->GetInt( "model_display_flags", kAttachedModelDisplayFlag_MaskAll );
						pVisData->m_AttachedModelsFestive[iAtt].m_pszModelName = pKVAttachedModelData->GetString( "model", NULL );
					}
				}
				else if ( !Q_stricmp( pszEntry, "attached_particlesystems" ) )
				{
					FOR_EACH_SUBKEY( pKVEntry, pKVAttachedParticleSystemData )
					{
						int iAtt = pVisData->m_AttachedParticles.AddToTail();
						pVisData->m_AttachedParticles[iAtt].pszSystemName = pKVAttachedParticleSystemData->GetString( "system", NULL );
						pVisData->m_AttachedParticles[iAtt].pszControlPoints[0] = pKVAttachedParticleSystemData->GetString( "attachment", NULL );
						pVisData->m_AttachedParticles[iAtt].bFollowRootBone = pKVAttachedParticleSystemData->GetBool( "attach_to_rootbone" );
						pVisData->m_AttachedParticles[iAtt].iCustomType = 0;
					}
				}
				else if ( !Q_stricmp( pszEntry, "custom_particlesystem2" ) )
				{
					int iAtt = pVisData->m_AttachedParticles.AddToTail();
					pVisData->m_AttachedParticles[iAtt].pszSystemName = pKVEntry->GetString( "system", NULL );
					pVisData->m_AttachedParticles[iAtt].iCustomType = 2;
				}
				else if ( !Q_stricmp( pszEntry, "custom_particlesystem" ) )
				{
					int iAtt = pVisData->m_AttachedParticles.AddToTail();
					pVisData->m_AttachedParticles[iAtt].pszSystemName = pKVEntry->GetString( "system", NULL );
					pVisData->m_AttachedParticles[iAtt].iCustomType = 1;
				}
				else if ( !Q_stricmp( pszEntry, "playback_activity" ) )
				{
					FOR_EACH_SUBKEY( pKVEntry, pKVSubKey )
					{
						int iPlaybackInt = StringFieldToInt( pKVSubKey->GetName(), g_WearableAnimTypeStrings, ARRAYSIZE(g_WearableAnimTypeStrings) );
						if ( iPlaybackInt >= 0 )
						{
							activity_on_wearable_t *pEntry = GetOrCreatePlaybackActivity( pVisData, (wearableanimplayback_t)iPlaybackInt );
							pEntry->pszActivity = pKVSubKey->GetString();
						}
					}
				}
				else if ( !Q_stricmp( pszEntry, "animation_replacement" ) )
				{
					FOR_EACH_SUBKEY( pKVEntry, pKVSubKey )
					{
						animation_on_wearable_t *pEntry = GetOrCreateAnimationActivity( pVisData, pKVSubKey->GetName() );
						pEntry->pszReplacement = pKVSubKey->GetString();
					}
				}
				else if ( !Q_stricmp( pszEntry, "animation_sequence" ) )
				{
					FOR_EACH_SUBKEY( pKVEntry, pKVSubKey )
					{
						animation_on_wearable_t *pEntry = GetOrCreateAnimationActivity( pVisData, pKVSubKey->GetName() );
						pEntry->pszSequence = pKVSubKey->GetString();
					}
				}
				else if ( !Q_stricmp( pszEntry, "animation_scene" ) )
				{
					FOR_EACH_SUBKEY( pKVEntry, pKVSubKey )
					{
						animation_on_wearable_t *pEntry = GetOrCreateAnimationActivity( pVisData, pKVSubKey->GetName() );
						pEntry->pszScene = pKVSubKey->GetString();
					}
				}
				else if ( !Q_stricmp( pszEntry, "animation_required_item" ) )
				{
					FOR_EACH_SUBKEY( pKVEntry, pKVSubKey )
					{
						animation_on_wearable_t *pEntry = GetOrCreateAnimationActivity( pVisData, pKVSubKey->GetName() );
						pEntry->pszRequiredItem = pKVSubKey->GetString();
					}
				}
				else if ( !Q_stricmp( pszEntry, "player_bodygroups" ) )
				{
					FOR_EACH_SUBKEY( pKVEntry, pKVBodygroupKey )
					{
						const char *pszBodygroupName = pKVBodygroupKey->GetName();
						int iValue = pKVBodygroupKey->GetInt();

						// Track bodygroup information for this item in particular.
						pVisData->m_Maps.m_ModifiedBodyGroupNames.Insert( pszBodygroupName, iValue );

						// Track global schema state.
						GetItemSchema()->AssignDefaultBodygroupState( pszBodygroupName, iValue );
					}
				}
				else if ( !Q_stricmp( pszEntry, "skin" ) )
				{
					pVisData->iSkin = pKVEntry->GetInt();
				}
				else if ( !Q_stricmp( pszEntry, "use_per_class_bodygroups" ) )
				{
					pVisData->bUsePerClassBodygroups = pKVEntry->GetBool();
				}
				else if ( !Q_stricmp( pszEntry, "muzzle_flash" ) )
				{
					pVisData->pszMuzzleFlash = pKVEntry->GetString();
				}
				else if ( !Q_stricmp( pszEntry, "tracer_effect" ) )
				{
					pVisData->pszTracerEffect = pKVEntry->GetString();
				}
				else if ( !Q_stricmp( pszEntry, "particle_effect" ) )
				{
					pVisData->pszParticleEffect = pKVEntry->GetString();
				}
				else if ( !Q_strnicmp( pszEntry, "custom_sound", 12 ) )			// intentionally comparing prefixes
				{
					int iIndex = 0;
					if ( pszEntry[12] )
					{
						iIndex = clamp( atoi( &pszEntry[12] ), 0, MAX_VISUALS_CUSTOM_SOUNDS-1 );
					}
					pVisData->pszCustomSounds[iIndex] = pKVEntry->GetString();
				}
				else if ( !Q_stricmp( pszEntry, "material_override" ) )
				{
					pVisData->pszMaterialOverride = pKVEntry->GetString();
				}
				else if ( !Q_strnicmp( pszEntry, "sound_", 6 ) )				// intentionally comparing prefixes
				{
					int iIndex = GetWeaponSoundFromString( &pszEntry[6] );
					if ( iIndex != -1 )
					{
						pVisData->pszWeaponSoundReplacements[iIndex] = pKVEntry->GetString();
					}
				}
				else if ( !Q_stricmp( pszEntry, "code_controlled_bodygroup" ) )
				{
					const char *pBodyGroupName = pKVEntry->GetString( "bodygroup", NULL );
					const char *pFuncName = pKVEntry->GetString( "function", NULL );
					if ( pBodyGroupName && pFuncName )
					{
						codecontrolledbodygroupdata_t ccbgd = { pFuncName, NULL };
						pVisData->m_Maps.m_CodeControlledBodyGroupNames.Insert( pBodyGroupName, ccbgd );
					}
				}
				else if ( !Q_stricmp( pszEntry, "vm_bodygroup_override" ) )
				{
					pVisData->m_iViewModelBodyGroupOverride = pKVEntry->GetInt();
				}
				else if ( !Q_stricmp( pszEntry, "vm_bodygroup_state_override" ) )
				{
					pVisData->m_iViewModelBodyGroupStateOverride = pKVEntry->GetInt();
				}
				else if ( !Q_stricmp( pszEntry, "wm_bodygroup_override" ) )
				{
					pVisData->m_iWorldModelBodyGroupOverride = pKVEntry->GetInt();
				}
				else if ( !Q_stricmp( pszEntry, "wm_bodygroup_state_override" ) )
				{
					pVisData->m_iWorldModelBodyGroupStateOverride = pKVEntry->GetInt();
				}

				pKVEntry = pKVEntry->GetNextKey();
			}
#endif // defined(CLIENT_DLL) || defined(GAME_DLL)
			KeyValues *pStylesDataKV = pVisualsKV->FindKey( "styles" );
			if ( pStylesDataKV )
			{
				// Styles are only valid in the base "visuals" section.
				if ( team == 0 )
				{
					BInitStylesBlockFromKV( pStylesDataKV, pVisData, pVecErrors );
				}
				// ...but they used to be valid everywhere, so spit out a warning if people are trying to use
				// the old style of per-team styles.
				else
				{
					pVecErrors->AddToTail( "Per-team styles blocks are no longer valid. Use \"skin_red\" and \"skin_blu\" in a style entry instead." );
				}
			}

			m_PerTeamVisuals[team] = pVisData;
		}
	}
}

#ifdef GC_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
template < typename T >
static void NthPermutation ( T *pData, unsigned int unDataCount, unsigned int unIdx )
{
	for ( unsigned int i = 1; i < unDataCount; i++ )
	{
		std::swap( pData[ unIdx % (i + 1) ], pData[ i ] );
		unIdx = unIdx / (i + 1);
	}
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconItemDefinition::BApplyPropertyGenerators( CEconItem *pItem ) const
{
	Assert( pItem );

	for ( const IEconItemPropertyGenerator *pPropertyGenerator : m_vecPropertyGenerators )
	{
		if ( !pPropertyGenerator->BGenerateProperties( pItem ) )
			return false;
	}

	return true;
}

#endif // GC_DLL

#if defined(CLIENT_DLL) || defined(GAME_DLL)
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEconItemDefinition::GeneratePrecacheModelStrings( bool bDynamicLoad, CUtlVector<const char *> *out_pVecModelStrings ) const
{
	Assert( out_pVecModelStrings );

	// Add base model.
	out_pVecModelStrings->AddToTail( GetBasePlayerDisplayModel() );

	// Add styles.
	if ( GetNumStyles() )
	{
		for ( style_index_t i=0; i<GetNumStyles(); ++i )
		{
			const CEconStyleInfo *pStyle = GetStyleInfo( i );
			Assert( pStyle );

			pStyle->GeneratePrecacheModelStringsForStyle( out_pVecModelStrings );
		}
	}

	// Precache all the attached models
	for ( int team = 0; team < TEAM_VISUAL_SECTIONS; team++ )
	{
		perteamvisuals_t *pPerTeamVisuals = GetPerTeamVisual( team );
		if ( !pPerTeamVisuals )
			continue;

		for ( int model = 0; model < pPerTeamVisuals->m_AttachedModels.Count(); model++ )
		{
			out_pVecModelStrings->AddToTail( pPerTeamVisuals->m_AttachedModels[model].m_pszModelName );
		}

		// Festive
		for ( int model = 0; model < pPerTeamVisuals->m_AttachedModelsFestive.Count(); model++ )
		{
			out_pVecModelStrings->AddToTail( pPerTeamVisuals->m_AttachedModelsFestive[model].m_pszModelName );
		}
	}

	if ( GetExtraWearableModel() )
	{
		out_pVecModelStrings->AddToTail( GetExtraWearableModel() );
	}

	if ( GetExtraWearableViewModel() )
	{
		out_pVecModelStrings->AddToTail( GetExtraWearableViewModel() );
	}

	if ( GetVisionFilteredDisplayModel() )
	{
		out_pVecModelStrings->AddToTail( GetVisionFilteredDisplayModel() );
	}

	// We don't need to cache the inventory model, because it's never loaded by the game
}

void CEconItemDefinition::GeneratePrecacheSoundStrings( bool bDynamicLoad, CUtlVector<const char *> *out_pVecSoundStrings ) const
{
	Assert( out_pVecSoundStrings );

	for ( int iTeam = 0; iTeam < TEAM_VISUAL_SECTIONS; ++iTeam )
	{
		for ( int iSound = 0; iSound < MAX_VISUALS_CUSTOM_SOUNDS; ++iSound )
		{
			const char *pSoundName = GetCustomSound( iTeam, iSound );
			if ( pSoundName && pSoundName[ 0 ] != '\0' )
			{
				out_pVecSoundStrings->AddToTail( pSoundName );
			}
		}
	}
}
#endif // #if defined(CLIENT_DLL) || defined(GAME_DLL)

//-----------------------------------------------------------------------------
const char	*CEconItemDefinition::GetDefinitionString( const char *pszKeyName, const char *pszDefaultValue ) const
{
	// !FIXME! Here we could do a dynamic lookup to apply the prefab overlay logic.
	// This could save a lot of duplicated data
	if ( m_pKVItem )
		return m_pKVItem->GetString( pszKeyName, pszDefaultValue );
	return pszDefaultValue;
}

//-----------------------------------------------------------------------------
KeyValues	*CEconItemDefinition::GetDefinitionKey( const char *pszKeyName ) const
{
	// !FIXME! Here we could do a dynamic lookup to apply the prefab overlay logic.
	// This could save a lot of duplicated data
	if ( m_pKVItem )
		return m_pKVItem->FindKey( pszKeyName );
	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: Parse the styles sub-section of the visuals block.
//-----------------------------------------------------------------------------
void CEconItemDefinition::BInitStylesBlockFromKV( KeyValues *pKVStyles, perteamvisuals_t *pVisData, CUtlVector<CUtlString> *pVecErrors )
{
	FOR_EACH_SUBKEY( pKVStyles, pKVStyle )
	{
		CEconStyleInfo *pStyleInfo = GetItemSchema()->CreateEconStyleInfo();
		Assert( pStyleInfo );

		pStyleInfo->BInitFromKV( pKVStyle, pVecErrors );

		pVisData->m_Styles.AddToTail( pStyleInfo );
	}
}

//-----------------------------------------------------------------------------
// Purpose: Parse one style from the styles block.
//-----------------------------------------------------------------------------
void CEconStyleInfo::BInitFromKV( KeyValues *pKVStyle, CUtlVector<CUtlString> *pVecErrors )
{
	enum { kInvalidSkinKey = -1, };

	Assert( pKVStyle );

	// A "skin" entry means "use this index for all of our teams, no matter how many we have".
	int iCommonSkin = pKVStyle->GetInt( "skin", kInvalidSkinKey );
	if ( iCommonSkin != kInvalidSkinKey )
	{
		for ( int i = 0; i < TEAM_VISUAL_SECTIONS; i++ )
		{
			m_iSkins[i] = iCommonSkin;
		}
	}

	int iCommonViewmodelSkin = pKVStyle->GetInt( "v_skin", kInvalidSkinKey );
	if ( iCommonViewmodelSkin != kInvalidSkinKey )
	{
		for ( int i=0; i<TEAM_VISUAL_SECTIONS; i++ )
		{
			m_iViewmodelSkins[i] = iCommonViewmodelSkin;
		}
	}

	// If we don't have a base entry, we look for a unique entry for each team. This will be
	// handled in a subclass if necessary.

	// Are we hiding additional bodygroups when this style is active?
	KeyValues *pKVHideBodygroups = pKVStyle->FindKey( "additional_hidden_bodygroups" );
	if ( pKVHideBodygroups )
	{
		FOR_EACH_SUBKEY( pKVHideBodygroups, pKVBodygroup )
		{
			m_vecAdditionalHideBodygroups.AddToTail( pKVBodygroup->GetName() );
		}
	}

	// Remaining common properties.
	m_pszName = pKVStyle->GetString( "name", "#TF_UnknownStyle" );
	m_pszBasePlayerModel = pKVStyle->GetString( "model_player", NULL );
	m_bIsSelectable = pKVStyle->GetBool( "selectable", true );
	m_pszInventoryImage = pKVStyle->GetString( "image_inventory", NULL );

	KeyValues *pKVBodygroup = pKVStyle->FindKey( "bodygroup" );
	if ( pKVBodygroup )
	{
		m_pszBodygroupName = pKVBodygroup->GetString( "name", NULL );
		Assert( m_pszBodygroupName );
		m_iBodygroupSubmodelIndex = pKVBodygroup->GetInt( "submodel_index", -1 );
		Assert( m_iBodygroupSubmodelIndex != -1 );
	}
}

#if defined(CLIENT_DLL) || defined(GAME_DLL)
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEconStyleInfo::GeneratePrecacheModelStringsForStyle( CUtlVector<const char *> *out_pVecModelStrings ) const
{
	Assert( out_pVecModelStrings );

	if ( GetBasePlayerDisplayModel() != NULL )
	{
		out_pVecModelStrings->AddToTail( GetBasePlayerDisplayModel() );
	}
}
#endif

//-----------------------------------------------------------------------------
// Purpose:	Item definition initialization helpers.
//-----------------------------------------------------------------------------
static void RecursiveInheritKeyValues( KeyValues *out_pValues, KeyValues *pInstance )
{
	KeyValues *pPrevSubKey = NULL;
	for ( KeyValues * pSubKey = pInstance->GetFirstSubKey(); pSubKey != NULL; pPrevSubKey = pSubKey, pSubKey = pSubKey->GetNextKey() )
	{
		// If this assert triggers, you have an item that uses a prefab but has multiple keys with the same name
		AssertMsg2 ( !pPrevSubKey || pPrevSubKey->GetNameSymbol() != pSubKey->GetNameSymbol(),
			"Item definition \"%s\" has multiple attributes of the same name (%s) can't use prefabs", pInstance->GetName(), pSubKey->GetName() );

		KeyValues::types_t eType = pSubKey->GetDataType();
		switch ( eType )
		{
		case KeyValues::TYPE_STRING:		out_pValues->SetString( pSubKey->GetName(), pSubKey->GetString() );			break;
		case KeyValues::TYPE_INT:			out_pValues->SetInt( pSubKey->GetName(), pSubKey->GetInt() );				break;
		case KeyValues::TYPE_FLOAT:			out_pValues->SetFloat( pSubKey->GetName(), pSubKey->GetFloat() );			break;
		case KeyValues::TYPE_WSTRING:		out_pValues->SetWString( pSubKey->GetName(), pSubKey->GetWString() );		break;
		case KeyValues::TYPE_COLOR:			out_pValues->SetColor( pSubKey->GetName(), pSubKey->GetColor() ) ;			break;
		case KeyValues::TYPE_UINT64:		out_pValues->SetUint64( pSubKey->GetName(), pSubKey->GetUint64() ) ;		break;

		// "NONE" means "KeyValues"
		case KeyValues::TYPE_NONE:
		{
			// We may already have this part of the tree to stuff data into/overwrite, or we
			// may have to make a new block.
			KeyValues *pNewChild = out_pValues->FindKey( pSubKey->GetName() );
			if ( !pNewChild )
			{
				pNewChild = out_pValues->CreateNewKey();
				pNewChild->SetName( pSubKey->GetName() );
			}

			RecursiveInheritKeyValues( pNewChild, pSubKey );
			break;
		}

		case KeyValues::TYPE_PTR:
		default:
			Assert( !"Unhandled data type for KeyValues inheritance!" );
			break;
		}
	}
}

void MergeDefinitionPrefab( KeyValues *pKVWriteItem, KeyValues *pKVSourceItem )
{
	Assert( pKVWriteItem );
	Assert( pKVSourceItem );

	const char *svPrefabName = pKVSourceItem->GetString( "prefab", NULL );
	
	if ( svPrefabName )
	{
		CUtlStringList vecPrefabs;

		Q_SplitString( svPrefabName, " ", vecPrefabs );

		// Iterate backwards so adjectives get applied over the noun prefab
		// e.g. wet scared cat would apply cat first, then scared and wet.
		FOR_EACH_VEC_BACK( vecPrefabs, i )
		{
			KeyValues *pKVPrefab = GetItemSchema()->FindDefinitionPrefabByName( vecPrefabs[i] );
			AssertMsg1( pKVPrefab, "Unable to find prefab \"%s\".", vecPrefabs[i] );

			if ( pKVPrefab )
			{
				MergeDefinitionPrefab( pKVWriteItem, pKVPrefab );
			}
		}
	}

	RecursiveInheritKeyValues( pKVWriteItem, pKVSourceItem );
}

KeyValues *CEconItemSchema::FindDefinitionPrefabByName( const char *pszPrefabName ) const
{
	int iIndex = m_mapDefinitionPrefabs.Find( pszPrefabName );
	if ( m_mapDefinitionPrefabs.IsValidIndex( iIndex ) )
		return m_mapDefinitionPrefabs[iIndex];

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CEconItemSchema::FindStringTableEntry( const char *pszTableName, int iIndex ) const
{
	SchemaStringTableDict_t::IndexType_t i = m_dictStringTable.Find( pszTableName );
	if ( !m_dictStringTable.IsValidIndex( i ) )
		return NULL;

	const CUtlVector< schema_string_table_entry_t >& vec = *m_dictStringTable[i];
	FOR_EACH_VEC( vec, j )
	{
		if ( vec[j].m_iIndex == iIndex )
			return vec[j].m_pszStr;
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose:	Initialize the item definition
// Input:	pKVItem - The KeyValues representation of the item
//			schema - The overall item schema for this item
//			pVecErrors - An optional vector that will contain error messages if 
//				the init fails.
// Output:	True if initialization succeeded, false otherwise
//-----------------------------------------------------------------------------
#ifdef GC_DLL
	GCConVar gc_steam_payment_rules_kv_key( "gc_steam_payment_rules_kv_key", "payment_rules" );
#endif // GC_DLL


#if defined( WITH_STREAMABLE_WEAPONS )
#if defined( CLIENT_DLL )
    ConVar tf_loadondemand_default("cl_loadondemand_default", "1", FCVAR_ARCHIVE | FCVAR_CLIENTDLL, "The default value for whether items should be delay loaded (1) or loaded now (0).");
#elif defined( GAME_DLL )
    // The server doesn't load on demand by default because it can crash sometimes when this is set. We need to run that down, but in the meantime 
    // we just have it load on demand.
    ConVar tf_loadondemand_default("sv_loadondemand_default", "0", FCVAR_ARCHIVE | FCVAR_GAMEDLL, "The default value for whether items should be delay loaded (1) or loaded now (0).");
#elif defined( GC_DLL )
    GCConVar tf_loadondemand_default("gc_loadondemand_default", "1", FCVAR_ARCHIVE, "The default value for whether items should be delay loaded (1) or loaded now (0).");
#else
#error "Need to add support for streamable weapons to this configuration, or disable streamable weapons here."
#endif
#endif // WITH_STREAMABLE_WEAPONS

bool CEconItemDefinition::BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors /* = NULL */ )
{
	// Set standard members
	m_pKVItem = new KeyValues( pKVItem->GetName() );
	MergeDefinitionPrefab( m_pKVItem, pKVItem );
	m_bEnabled = m_pKVItem->GetBool( "enabled" );

    // initializing this one first so that it will be available for all the errors below
    m_pszDefinitionName = m_pKVItem->GetString( "name", NULL );

#if defined( WITH_STREAMABLE_WEAPONS )
    bool bGotDefault = false;
    m_bLoadOnDemand = m_pKVItem->GetBool( "loadondemand", tf_loadondemand_default.GetBool(), &bGotDefault );

    // This logging is useful for tracking down bugs that crop up because we've (possibly) swapped the default value for loadondemand.
    // But it can be removed once we're satisfied there aren't any bugs as a result of the change (when we cleanup WITH_STREAMABLE_WEAPONS).
    if (bGotDefault)
    {
        DevMsg(10, "Item %s received default value for loadondemand\n", m_pszDefinitionName);
    }
#else
    // Keep the old behavior, which is that loadondemand is defaulted to false.
    m_bLoadOnDemand = m_pKVItem->GetBool("loadondemand");
#endif

	m_nDefIndex = Q_atoi( m_pKVItem->GetName() );
	m_unMinItemLevel = (uint32)m_pKVItem->GetInt( "min_ilevel", GetItemSchema()->GetMinLevel() );
	m_unMaxItemLevel = (uint32)m_pKVItem->GetInt( "max_ilevel", GetItemSchema()->GetMaxLevel() );
	m_nDefaultDropQuantity = m_pKVItem->GetInt( "default_drop_quantity", 1 );

	m_nPopularitySeed = m_pKVItem->GetInt( "popularity_seed", 0 );


#if defined(CLIENT_DLL) || defined(GAME_DLL)
	// We read this manually here in the game dlls. The GC reads it below while checking the global schema.
	GetItemSchema()->BGetItemQualityFromName( m_pKVItem->GetString( "item_quality" ), &m_nItemQuality );
	GetItemSchema()->BGetItemQualityFromName( m_pKVItem->GetString( "forced_item_quality" ), &m_nForcedItemQuality );
#endif

	// Check for required fields
	SCHEMA_INIT_CHECK( 
		NULL != m_pKVItem->FindKey( "name" ), 
		"Item definition %s: Missing required field \"name\"", m_pKVItem->GetName() );

	SCHEMA_INIT_CHECK( 
		NULL != m_pKVItem->FindKey( "item_class" ), 
		"Item definition %s: Missing required field \"item_class\"", m_pKVItem->GetName() );

	// Check value ranges
	SCHEMA_INIT_CHECK( 
		m_pKVItem->GetInt( "min_ilevel" ) >= 0, 
		"Item definition %s: \"min_ilevel\" must be greater than or equal to 0", GetDefinitionName() );

	SCHEMA_INIT_CHECK( 
		m_pKVItem->GetInt( "max_ilevel" ) >= 0, 
		"Item definition %s: \"max_ilevel\" must be greater than or equal to 0", GetDefinitionName() );

	// Check for consistency
#ifdef GC_DLL
	// We don't do these consistency checks in the game, because it doesn't have the data to do them
	SCHEMA_INIT_CHECK( 
		m_unMinItemLevel >= GetItemSchema()->GetMinLevel(), 
		"Item definition %s: min_ilevel (%d) must be greater or equal to Minimum Item Level (%d)", GetDefinitionName(), m_unMinItemLevel, GetItemSchema()->GetMinLevel() );

	SCHEMA_INIT_CHECK( 
		m_unMinItemLevel <= m_unMaxItemLevel,
		"Item definition %s: min_ilevel (%d) must be greater or equal to min_ilevel (%d)", GetDefinitionName(), m_unMaxItemLevel, m_unMinItemLevel );

	SCHEMA_INIT_CHECK( 
		m_unMaxItemLevel <= GetItemSchema()->GetMaxLevel(),
		"Item definition %s: max_ilevel (%d) must be less than or equal to Maximum Item Level (%d)", GetDefinitionName(), m_unMaxItemLevel, GetItemSchema()->GetMaxLevel() );

	// Read the item quality
	if ( m_pKVItem->FindKey( "item_quality" ) )
	{
		SCHEMA_INIT_CHECK( 
			GetItemSchema()->BGetItemQualityFromName( m_pKVItem->GetString( "item_quality" ), &m_nItemQuality ),
			"Item definition %s: Undefined item_quality \"%s\"", GetDefinitionName(), m_pKVItem->GetString( "item_quality" ) );
	}
	if ( m_pKVItem->FindKey( "forced_item_quality" ) )
	{
		SCHEMA_INIT_CHECK( 
			GetItemSchema()->BGetItemQualityFromName( m_pKVItem->GetString( "forced_item_quality" ), &m_nForcedItemQuality ),
			"Item definition %s: Undefined item_quality \"%s\"", GetDefinitionName(), m_pKVItem->GetString( "forced_item_quality" ) );
	}
#endif

	// Rarity
	// Get Index from this string and save the index
	if ( m_pKVItem->FindKey( "item_rarity" ) )
	{
		SCHEMA_INIT_CHECK(
			GetItemSchema()->BGetItemRarityFromName( m_pKVItem->GetString( "item_rarity" ), &m_nItemRarity ),
			"Item definition %s: Undefined item_rarity \"%s\"", GetDefinitionName(), m_pKVItem->GetString( "item_rarity" ) );
	}

	if ( m_pKVItem->FindKey( "item_series" ) )
	{
		// Make sure this is a valid series
		SCHEMA_INIT_CHECK(
			GetItemSchema()->BGetItemSeries( m_pKVItem->GetString( "item_series" ), &m_unItemSeries ),
			"Item definition %s: Undefined item_series \"%s\"", GetDefinitionName(), m_pKVItem->GetString( "item_series" ) );
	}

	// Get the item class
	m_pszItemClassname = m_pKVItem->GetString( "item_class", NULL );

	m_pszClassToken = m_pKVItem->GetString( "class_token_id", NULL );
	m_pszSlotToken = m_pKVItem->GetString( "slot_token_id", NULL );

	// expiration data
	const char *pchExpiration = m_pKVItem->GetString( "expiration_date", NULL );
	if( pchExpiration && pchExpiration[0] )
	{
		if ( pchExpiration[0] == '!' )
		{
			m_rtExpiration = GetItemSchema()->GetCustomExpirationDate( &pchExpiration[1] );
			SCHEMA_INIT_CHECK(
				m_rtExpiration != k_RTime32Nil,
				"Unknown/malformed expiration_date string \"%s\" in item %s.", pchExpiration, m_pszDefinitionName );
		}
		else
		{
			m_rtExpiration = CRTime::RTime32FromFmtString( "YYYY-MM-DD hh:mm:ss" , pchExpiration );

#ifdef GC_DLL
			// Check that if we convert back to a string, we get the same value
			char rtimeBuf[k_RTimeRenderBufferSize];
			SCHEMA_INIT_CHECK(
				Q_strcmp( CRTime::RTime32ToString( m_rtExpiration, rtimeBuf ), pchExpiration ) == 0,
				"Malformed expiration_date \"%s\" for expiration_date in item %s.  Must be of the form \"YYYY-MM-DD hh:mm:ss\".  Input: %s Output: %s InputTime: %u LocalTime: %u Timezone: %lu", pchExpiration, m_pszDefinitionName, pchExpiration,  rtimeBuf, m_rtExpiration, CRTime::RTime32TimeCur(), timezone );
#else
			// Check that if we convert back to a string, we get the same value.  Emit an error, but don't fail in the game code
			char rtimeBuf[k_RTimeRenderBufferSize];
			if ( Q_strcmp( CRTime::RTime32ToString( m_rtExpiration, rtimeBuf ), pchExpiration ) != 0 )
			{
#if ( defined( _MSC_VER ) && _MSC_VER >= 1900 )
#define timezone _timezone
#define daylight _daylight
#endif
				Assert( false );
				Warning( "Malformed expiration_date \"%s\" for expiration_date in item %s.  Must be of the form \"YYYY-MM-DD hh:mm:ss\".  Input: %s Output: %s InputTime: %u LocalTime: %u Timezone: %lu\n", pchExpiration, m_pszDefinitionName, pchExpiration, rtimeBuf, m_rtExpiration, CRTime::RTime32TimeCur(), timezone );
			}				
#endif
		}
	}

	// Display data
	m_pszItemBaseName = m_pKVItem->GetString( "item_name", "" ); // non-NULL to ensure we can sort
	m_pszItemTypeName = m_pKVItem->GetString( "item_type_name", "" ); // non-NULL to ensure we can sort
	m_pszItemDesc = m_pKVItem->GetString( "item_description", NULL );
	m_pszArmoryDesc = m_pKVItem->GetString( "armory_desc", NULL );
	m_pszInventoryModel = m_pKVItem->GetString( "model_inventory", NULL );
	m_pszInventoryImage = m_pKVItem->GetString( "image_inventory", NULL );

	const char* pOverlay = m_pKVItem->GetString( "image_inventory_overlay", NULL );
	if ( pOverlay )
	{
		m_pszInventoryOverlayImages.AddToTail( pOverlay );
	}
	pOverlay = m_pKVItem->GetString( "image_inventory_overlay2", NULL );
	if ( pOverlay )
	{
		m_pszInventoryOverlayImages.AddToTail( pOverlay );
	}

	m_iInventoryImagePosition[0] = atoi( m_pKVItem->GetString( "image_inventory_pos_x", "0" ) );
	m_iInventoryImagePosition[1] = atoi( m_pKVItem->GetString( "image_inventory_pos_y", "0" ) );
	m_iInventoryImageSize[0] = atoi( m_pKVItem->GetString( "image_inventory_size_w", "128" ) );
	m_iInventoryImageSize[1] = atoi( m_pKVItem->GetString( "image_inventory_size_h", "82" ) );
	m_iInspectPanelDistance = m_pKVItem->GetInt( "inspect_panel_dist", 70 );
	m_pszHolidayRestriction = m_pKVItem->GetString( "holiday_restriction", NULL );
	m_nVisionFilterFlags = m_pKVItem->GetInt( "vision_filter_flags", 0 );
	m_iSubType = atoi( m_pKVItem->GetString( "subtype", "0" ) );
	m_pszBaseDisplayModel = m_pKVItem->GetString( "model_player", NULL );
	m_iDefaultSkin = m_pKVItem->GetInt( "default_skin", -1 );
	m_pszWorldDisplayModel = m_pKVItem->GetString( "model_world", NULL ); // Not the ideal method. c_models are better, but this is to solve a retrofit problem with the sticky launcher.
	m_pszWorldExtraWearableModel = m_pKVItem->GetString( "extra_wearable", NULL ); 
	m_pszWorldExtraWearableViewModel = m_pKVItem->GetString( "extra_wearable_vm", NULL );
	m_pszVisionFilteredDisplayModel = pKVItem->GetString( "model_vision_filtered", NULL );
	m_pszBrassModelOverride = m_pKVItem->GetString( "brass_eject_model", NULL );
	m_bHideBodyGroupsDeployedOnly = m_pKVItem->GetBool( "hide_bodygroups_deployed_only" );
	m_bAttachToHands = m_pKVItem->GetInt( "attach_to_hands", 0 ) != 0;
	m_bAttachToHandsVMOnly = m_pKVItem->GetInt( "attach_to_hands_vm_only", 0 ) != 0;
	m_bProperName = m_pKVItem->GetInt( "propername", 0 ) != 0;
	m_bFlipViewModel = m_pKVItem->GetInt( "flip_viewmodel", 0 ) != 0;
	m_bActAsWearable = m_pKVItem->GetInt( "act_as_wearable", 0 ) != 0;
	m_bActAsWeapon = m_pKVItem->GetInt( "act_as_weapon", 0 ) != 0;
	m_bIsTool = m_pKVItem->GetBool( "is_tool", 0 ) || ( GetItemClass() && !V_stricmp( GetItemClass(), "tool" ) );
	m_iDropType = StringFieldToInt( m_pKVItem->GetString("drop_type"), g_szDropTypeStrings, ARRAYSIZE(g_szDropTypeStrings) );
	m_pszCollectionReference = m_pKVItem->GetString( "collection_reference", NULL );

	// Creation data
	m_bHidden = m_pKVItem->GetInt( "hidden", 0 ) != 0;
	m_bShouldShowInArmory = m_pKVItem->GetInt( "show_in_armory", 0 ) != 0;
	m_bBaseItem = m_pKVItem->GetInt( "baseitem", 0 ) != 0;
	m_pszItemLogClassname = m_pKVItem->GetString( "item_logname", NULL );
	m_pszItemIconClassname = m_pKVItem->GetString( "item_iconname", NULL );
	m_pszDatabaseAuditTable = m_pKVItem->GetString( "database_audit_table", NULL );
	m_bImported = m_pKVItem->FindKey( "import_from" ) != NULL;

	// Tool data
	m_pTool = NULL;
	KeyValues *pToolDataKV = m_pKVItem->FindKey( "tool" );
	if ( pToolDataKV )
	{
		const char *pszType = pToolDataKV->GetString( "type", NULL );
		SCHEMA_INIT_CHECK( pszType != NULL, "Tool '%s' missing required type.", m_pKVItem->GetName() );

		// Common-to-all-tools settings.
		const char *pszUseString = pToolDataKV->GetString( "use_string", NULL );
		const char *pszUsageRestriction = pToolDataKV->GetString( "restriction", NULL );
		KeyValues *pToolUsageKV = pToolDataKV->FindKey( "usage" );

		// Common-to-all-tools usage capability flags.
		item_capabilities_t usageCapabilities = (item_capabilities_t)ITEM_CAP_TOOL_DEFAULT;
		KeyValues *pToolUsageCapsKV = pToolDataKV->FindKey( "usage_capabilities" );
		if ( pToolUsageCapsKV )
		{
			KeyValues *pEntry = pToolUsageCapsKV->GetFirstSubKey();
			while ( pEntry )
			{
				ParseCapability( usageCapabilities, pEntry );
				pEntry = pEntry->GetNextKey();
			}
		}

		m_pTool = GetItemSchema()->CreateEconToolImpl( pszType, pszUseString, pszUsageRestriction, usageCapabilities, pToolUsageKV );
		SCHEMA_INIT_CHECK( m_pTool != NULL, "Unable to create tool implementation for '%s', of type '%s'.", m_pKVItem->GetName(), pszType );
	}

	// Bundle
	KeyValues *pBundleDataKV = m_pKVItem->FindKey( "bundle" );
	if ( pBundleDataKV )
	{
		m_BundleInfo = new bundleinfo_t();
		FOR_EACH_SUBKEY( pBundleDataKV, pKVCurItem )
		{
			CEconItemDefinition *pItemDef = GetItemSchema()->GetItemDefinitionByName( pKVCurItem->GetName() );
			SCHEMA_INIT_CHECK( pItemDef != NULL, "Unable to find item definition '%s' for bundle '%s'.", pKVCurItem->GetName(), m_pszDefinitionName );

			m_BundleInfo->vecItemDefs.AddToTail( pItemDef );
		}

		// Only check for pack bundle if the item is actually a bundle - note that we could do this programatically by checking that all items in the bundle are flagged as a "pack item" - but for now the bundle needs to be explicitly flagged as a pack bundle.
		m_bIsPackBundle = m_pKVItem->GetInt( "is_pack_bundle", 0 ) != 0;
	}

	// capabilities
	m_iCapabilities = (item_capabilities_t)ITEM_CAP_DEFAULT;
	KeyValues *pCapsKV = m_pKVItem->FindKey( "capabilities" );
	if ( pCapsKV )
	{
		KeyValues *pEntry = pCapsKV->GetFirstSubKey();
		while ( pEntry )
		{
			ParseCapability( m_iCapabilities, pEntry );
			pEntry = pEntry->GetNextKey();
		}
	}

	// item_set
	SCHEMA_INIT_CHECK( (!m_pKVItem->GetString( "item_set", NULL )), "Item definition '%s' specifies deprecated \"item_set\" field. Items sets are now specified only in the set itself, not on the definition.", GetDefinitionName() );

	const char *pszSetItemRemapDefIndexName = m_pKVItem->GetString( "set_item_remap", NULL );
	if ( pszSetItemRemapDefIndexName )
	{
		const CEconItemDefinition *pRemapItemDef = GetItemSchema()->GetItemDefinitionByName( pszSetItemRemapDefIndexName );
		m_unSetItemRemapDefIndex = pRemapItemDef ? pRemapItemDef->GetDefinitionIndex() : INVALID_ITEM_DEF_INDEX;

		SCHEMA_INIT_CHECK( m_unSetItemRemapDefIndex != INVALID_ITEM_DEF_INDEX, "Unable to find set item remap definition '%s' for '%s'.", pszSetItemRemapDefIndexName, GetDefinitionName() );
		SCHEMA_INIT_CHECK( m_unSetItemRemapDefIndex != GetDefinitionIndex(), "Unable to set set item remap for definition '%s' to itself.", GetDefinitionName() );
	}
	else
	{
		m_unSetItemRemapDefIndex = GetDefinitionIndex();
	}

	// cache item map names
	m_pszArmoryRemap = m_pKVItem->GetString( "armory_remap", NULL );
	m_pszStoreRemap = m_pKVItem->GetString( "store_remap", NULL );

	m_pszXifierRemapClass = m_pKVItem->GetString( "xifier_class_remap", NULL );
	m_pszBaseFunctionalItemName = m_pKVItem->GetString( "base_item_name", "" );
	m_pszParticleSuffix = m_pKVItem->GetString( "particle_suffix", NULL );

	m_bValidForShuffle = m_pKVItem->GetBool( "valid_for_shuffle", false );
	m_bValidForSelfMade = m_pKVItem->GetBool( "valid_for_self_made", true );

	// Init our visuals blocks.
	BInitVisualBlockFromKV( m_pKVItem, pVecErrors );

	// Calculate our equip region mask.
	{
		m_unEquipRegionMask = 0;
		m_unEquipRegionConflictMask = 0;

		// Our equip region will come from one of two places -- either we have an "equip_regions" (plural) section,
		// in which case we have any number of regions specified; or we have an "equip_region" (singular) section
		// which will have one and exactly one region. If we have "equip_regions" (plural), we ignore whatever is
		// in "equip_region" (singular).
		//
		// Yes, this is sort of dumb.
		CUtlVector<const char *> vecEquipRegionNames;

		KeyValues *pKVMultiEquipRegions = m_pKVItem->FindKey( "equip_regions" ),
				  *pKVSingleEquipRegion = m_pKVItem->FindKey( "equip_region" );

		// Maybe we have multiple entries?
		if ( pKVMultiEquipRegions )
		{
			for ( KeyValues *pKVRegion = pKVMultiEquipRegions->GetFirstSubKey(); pKVRegion; pKVRegion = pKVRegion->GetNextKey() )
			{
				vecEquipRegionNames.AddToTail( pKVRegion->GetName() );
			}
		}
		// This is our one-and-only-one equip region.
		else if ( pKVSingleEquipRegion )
		{
			const char *pEquipRegionName = pKVSingleEquipRegion->GetString( (const char *)NULL, NULL );
			if ( pEquipRegionName )
			{
				vecEquipRegionNames.AddToTail( pEquipRegionName );
			}
		}

		// For each of our regions, add to our conflict mask both ourself and all the regions
		// that we conflict with.
		FOR_EACH_VEC( vecEquipRegionNames, i )
		{
			const char *pszEquipRegionName = vecEquipRegionNames[i];
			equip_region_mask_t unThisRegionMask = GetItemSchema()->GetEquipRegionMaskByName( pszEquipRegionName );

			SCHEMA_INIT_CHECK(
				unThisRegionMask != 0,
				"Item definition %s: Unable to find equip region mask for region named \"%s\"", GetDefinitionName(), vecEquipRegionNames[i] );

			m_unEquipRegionMask |= GetItemSchema()->GetEquipRegionBitMaskByName( pszEquipRegionName );
			m_unEquipRegionConflictMask |= unThisRegionMask;
		}
	}

	// Single-line static attribute parsing.
	{
		KeyValues *pKVStaticAttrsKey = m_pKVItem->FindKey( "static_attrs" );
		if ( pKVStaticAttrsKey )
		{
			FOR_EACH_SUBKEY( pKVStaticAttrsKey, pKVKey )
			{
				static_attrib_t staticAttrib;

				SCHEMA_INIT_SUBSTEP( staticAttrib.BInitFromKV_SingleLine( GetDefinitionName(), pKVKey, pVecErrors, false ) );
				m_vecStaticAttributes.AddToTail( staticAttrib );

				// Does this attribute specify a tag to apply to this item definition?
				Assert( staticAttrib.GetAttributeDefinition() );
			}
		}
	}

	// Old style attribute parsing. Really only useful now for GC-generated attributes.
	KeyValues *pKVAttribKey = m_pKVItem->FindKey( "attributes" );
	if ( pKVAttribKey )
	{
		FOR_EACH_SUBKEY( pKVAttribKey, pKVKey )
		{
			static_attrib_t staticAttrib;

			SCHEMA_INIT_SUBSTEP( staticAttrib.BInitFromKV_MultiLine( GetDefinitionName(), pKVKey, pVecErrors ) );
			m_vecStaticAttributes.AddToTail( staticAttrib );

			// Does this attribute specify a tag to apply to this item definition?
			Assert( staticAttrib.GetAttributeDefinition() );
		}
	}

	// Initialize tags based on all static attributes for this item.
	for ( const static_attrib_t& attr : m_vecStaticAttributes )
	{
		const econ_tag_handle_t tag = attr.GetAttributeDefinition()->GetItemDefinitionTag();
		if ( tag != INVALID_ECON_TAG_HANDLE )
		{
			m_vecTags.AddToTail( tag );
		}
	}

	// Auto-generate tags based on capabilities.
	for ( int i = 0; i < NUM_ITEM_CAPS; i++ )
	{
		if ( m_iCapabilities & (1 << i) )
		{
			m_vecTags.AddToTail( GetItemSchema()->GetHandleForTag( CFmtStr( "auto__cap_%s", g_Capabilities[i] ).Get() ) );
		}
	}

	// Initialize used-specified tags for this item if present.
	KeyValues *pKVTags = m_pKVItem->FindKey( "tags" );
	if ( pKVTags )
	{
		FOR_EACH_SUBKEY( pKVTags, pKVTag )
		{
			m_vecTags.AddToTail( GetItemSchema()->GetHandleForTag( pKVTag->GetName() ) );
		}
	}

#ifdef GC_DLL
	SCHEMA_INIT_SUBSTEP( BCommonInitPropertyGeneratorsFromKV( GetDefinitionName(), &m_vecPropertyGenerators, m_pKVItem->FindKey( "property_generators" ), pVecErrors ) );

	// Parse payment rules on the GC if any exist.
	KeyValues *pKVPaymentRules = m_pKVItem->FindKey( gc_steam_payment_rules_kv_key.GetString() );
	if ( pKVPaymentRules )
	{
		FOR_EACH_TRUE_SUBKEY( pKVPaymentRules, pKVRule ) 
		{
			econ_item_payment_rule_t rule;

			const bool bFoundPaymentRule = BGetPaymentRule( pKVRule, &rule.m_eRuleType, &rule.m_RevenueShare );
			SCHEMA_INIT_CHECK( bFoundPaymentRule, "Item definition '%s': payment rule %s didn't specify a known payment rule type", GetDefinitionName(), pKVRule->GetName() );

			// Allow us to override some of our checks if we want to claim we really know what we're doing.
			if ( !pKVRule->FindKey( "sanity_check_override" ) )
			{
				SCHEMA_INIT_CHECK( rule.m_RevenueShare > 0.0, "Item definition '%s': payment rule %s has invalid revenue share %0.2f", GetDefinitionName(), pKVRule->GetName(), rule.m_RevenueShare );

				// Ordinarily, bundles can only specify the "bundle_revenue_share" payment rule type. However, for backwards compatability
				// with previous payment rules that pre-date the Workshop and had manual percentages set offline, we allow people who know
				// what they're doing to specify the "sanity_check_override" key and then use custom rules.
				SCHEMA_INIT_CHECK( (rule.m_eRuleType == kPaymentRule_Bundle) == IsBundle(), "Item definition '%s': payment rule %s has invalid bundle rules", GetDefinitionName(), pKVRule->GetName() );
			}

			KeyValues *pPaymentRuleForItemdef = pKVRule->FindKey( "payment_rule_for_itemdef" );
			SCHEMA_INIT_CHECK( pPaymentRuleForItemdef && ( pPaymentRuleForItemdef->GetInt() == m_nDefIndex ), "Item definition '%s': payment rule %s has invalid payment_rule_for_itemdef", GetDefinitionName(), pKVRule->GetName() );

			KeyValues *pKVMultiTargets = pKVRule->FindKey( "targets" );
			KeyValues *pKVSingleTarget = pKVRule->FindKey( "target" );
			SCHEMA_INIT_CHECK( pKVMultiTargets == NULL || pKVSingleTarget == NULL, "Item definition '%s': payment rule %s specifies both single- and multi-targets", GetDefinitionName(), pKVRule->GetName() );

			if ( pKVMultiTargets )
			{
				FOR_EACH_SUBKEY( pKVMultiTargets, pKVTarget )
				{
					rule.m_vecValues.AddToTail( (uint64)Q_atoi64( pKVTarget->GetName() ) );
				}
			}

			if ( pKVSingleTarget )
			{
				rule.m_vecValues.AddToTail( pKVSingleTarget->GetUint64() );
			}

			// We expect bundles to have no associated account data at all -- their payment processing
			// is done by splitting the total value of the bundle between each of the items in it. All
			// non-bundle payment rules require at least one data entry.
			SCHEMA_INIT_CHECK( (rule.m_eRuleType == kPaymentRule_Bundle) == (rule.m_vecValues.Count() == 0), "Item definition '%s': payment rule %s has invalid number of target entries %i", GetDefinitionName(), pKVRule->GetName(), rule.m_vecValues.Count() );

			// It doesn't make any sense to have multiple entries for a bundle. We expect their to be one
			// rule, and that's "process this like a bundle".
			if ( rule.m_eRuleType == kPaymentRule_Bundle )
			{
				SCHEMA_INIT_CHECK( m_vecPaymentRules.Count() == 0, "Item definition '%s': only the first payment rule can be specified as 'bundle'", GetDefinitionName() );

				// We only allow bundle payment rules to be applied to actual bundles with contents
				// specified. Without doing this, we would have nowhere to pull the metadata about
				// which items are contained.
				SCHEMA_INIT_CHECK( GetBundleInfo() && GetBundleInfo()->vecItemDefs.Count() > 0, "Item definition '%s': payment rule %s is specified as a bundle but outer item definition has no bundle contents.\n", GetDefinitionName(), pKVRule->GetName() );

				// Bundles rely on sub-items for figuring out payment so the revenue share for the
				// bundle itself is expected to be 100%.
				SCHEMA_INIT_CHECK( rule.m_RevenueShare == 100.0, "Item definition '%s': payment rule %s has invalid bundle revenue share %0.2f", GetDefinitionName(), pKVRule->GetName(), rule.m_RevenueShare );
			}

			const bool bWasNumberedCorrectly = (AddPaymentRule( rule ) == atoi( pKVRule->GetName() ));
			SCHEMA_INIT_CHECK( bWasNumberedCorrectly, "Item definition '%s': misnumbered payment rule %s", GetDefinitionName(), pKVRule->GetName() );
		}
	}
#endif // GC_DLL

	return SCHEMA_INIT_SUCCESS();
}

#ifdef GC_DLL
int CEconItemDefinition::AddPaymentRule( const econ_item_payment_rule_t& newRule )
{
	return m_vecPaymentRules.AddToTail( newRule );
}
#endif // GC_DLL

bool static_attrib_t::BInitFromKV_MultiLine( const char *pszContext, KeyValues *pKVAttribute, CUtlVector<CUtlString> *pVecErrors )
{
	const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinitionByName( pKVAttribute->GetName() );

	SCHEMA_INIT_CHECK( 
		NULL != pAttrDef,
		"Context '%s': Attribute \"%s\" in \"attributes\" did not match any attribute definitions", pszContext, pKVAttribute->GetName() );

	if ( pAttrDef )
	{
		iDefIndex = pAttrDef->GetDefinitionIndex();
			
		const ISchemaAttributeType *pAttrType = pAttrDef->GetAttributeType();
		Assert( pAttrType );

		pAttrType->InitializeNewEconAttributeValue( &m_value );

		const char *pszValue = pKVAttribute->GetString( "value", NULL );
		const bool bSuccessfullyLoadedValue = pAttrType->BConvertStringToEconAttributeValue( pAttrDef, pszValue, &m_value, true );

		SCHEMA_INIT_CHECK(
			bSuccessfullyLoadedValue,
			"Context '%s': Attribute \"%s\" could not parse value \"%s\"!", pszContext, pKVAttribute->GetName(), pszValue ? pszValue : "(null)" );

		SCHEMA_INIT_CHECK(
			!pAttrDef->BIsSetBonusAttribute(),
			"Context '%s': Attribute \"%s\" is a set bonus attribute and not supported here", pszContext, pKVAttribute->GetName() );
#ifdef GC_DLL
		bForceGCToGenerate	= pKVAttribute->GetBool( "force_gc_to_generate" );

		KeyValues *pKVLogicData = pKVAttribute->FindKey( "custom_value_logic" );
		if ( pKVLogicData )
		{
			m_pKVCustomData = pKVLogicData->MakeCopy();
		}

		SCHEMA_INIT_CHECK(
			m_pKVCustomData == NULL || bForceGCToGenerate,
			"Context '%s': Attribute \"%s\" is set to have custom logic but is not GC-generated so that logic will never get used!", pszContext, pKVAttribute->GetName() );

		SCHEMA_INIT_CHECK(
			m_pKVCustomData != NULL || pKVAttribute->FindKey( "value" ),
			"Context '%s': Attribute \"%s\" has no value set", pszContext, pKVAttribute->GetName() );

		SCHEMA_INIT_CHECK(
			m_pKVCustomData == NULL || m_pKVCustomData->FindKey( "method" ) != NULL,
			"Context '%s': Attribute \"%s\" custom logic data is set, but custom logic method is not set!", pszContext, pKVAttribute->GetName() );
#endif // GC_DLL
	}

	return SCHEMA_INIT_SUCCESS();
}

bool static_attrib_t::BInitFromKV_SingleLine( const char *pszContext, KeyValues *pKVAttribute, CUtlVector<CUtlString> *pVecErrors, bool bEnableTerribleBackwardsCompatibilitySchemaParsingCode /* = true */ )
{
	const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinitionByName( pKVAttribute->GetName() );

	SCHEMA_INIT_CHECK( 
		NULL != pAttrDef,
		"Context '%s': Attribute \"%s\" in \"attributes\" did not match any attribute definitions", pszContext, pKVAttribute->GetName() );

	if ( pAttrDef )
	{
		iDefIndex = pAttrDef->GetDefinitionIndex();
			
		const ISchemaAttributeType *pAttrType = pAttrDef->GetAttributeType();
		Assert( pAttrType );

		pAttrType->InitializeNewEconAttributeValue( &m_value );

		const char *pszValue = pKVAttribute->GetString();
		const bool bSuccessfullyLoadedValue = pAttrType->BConvertStringToEconAttributeValue( pAttrDef, pszValue, &m_value, bEnableTerribleBackwardsCompatibilitySchemaParsingCode );

		SCHEMA_INIT_CHECK(
			bSuccessfullyLoadedValue,
			"Context '%s': Attribute \"%s\" could not parse value \"%s\"!", pszContext, pKVAttribute->GetName(), pszValue ? pszValue : "(null)" );

		SCHEMA_INIT_CHECK(
			!pAttrDef->BIsSetBonusAttribute(),
			"Context '%s': Attribute \"%s\" is a set bonus attribute and not supported here", pszContext, pKVAttribute->GetName() );

#ifdef GC_DLL
		bForceGCToGenerate = false;
		m_pKVCustomData = NULL;
#endif // GC_DLL
	}

	return SCHEMA_INIT_SUCCESS();
}



bool CEconItemDefinition::BInitItemMappings( CUtlVector<CUtlString> *pVecErrors )
{
	// Armory remapping
	if ( m_pszArmoryRemap && m_pszArmoryRemap[0] )
	{
		CEconItemDefinition *pDef = GetItemSchema()->GetItemDefinitionByName( m_pszArmoryRemap );
		if ( pDef )
		{
			m_iArmoryRemap = pDef->GetDefinitionIndex();
		}

		SCHEMA_INIT_CHECK( 
			pDef != NULL,
			"Item %s: Armory remap definition \"%s\" was not found", m_pszItemBaseName, m_pszArmoryRemap );
	}

	// Store remapping
	if ( m_pszStoreRemap && m_pszStoreRemap[0] )
	{
		CEconItemDefinition *pDef = GetItemSchema()->GetItemDefinitionByName( m_pszStoreRemap );
		if ( pDef )
		{
			m_iStoreRemap = pDef->GetDefinitionIndex();
		}

		SCHEMA_INIT_CHECK(
			pDef != NULL,
			"Item %s: Store remap definition \"%s\" was not found", m_pszItemBaseName, m_pszStoreRemap );
	}

	return SCHEMA_INIT_SUCCESS();
}

const char* CEconItemDefinition::GetIconURL( const char* pszKey ) const
{
	auto idx = m_pDictIcons->Find( pszKey );
	if ( idx == m_pDictIcons->InvalidIndex() )
	{
		return NULL;
	}

	return (*m_pDictIcons)[ idx ];
}

//-----------------------------------------------------------------------------
// Purpose: Generate and return a random level according to whatever leveling
//			curve this definition uses.
//-----------------------------------------------------------------------------
uint32 CEconItemDefinition::RollItemLevel( void ) const
{
	return RandomInt( GetMinLevel(), GetMaxLevel() );
}

const char *CEconItemDefinition::GetFirstSaleDate() const
{
	return GetDefinitionString( "first_sale_date", "1960/00/00" );
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEconItemDefinition::IterateAttributes( IEconItemAttributeIterator *pIterator ) const
{
	FOR_EACH_VEC( GetStaticAttributes(), i )
	{
		const static_attrib_t& staticAttrib = GetStaticAttributes()[i];
		
#ifdef GC_DLL
		// we skip over static attributes that the GC will turn into dynamic attributes because otherwise we'll have
		// the appearance of iterating over them twice; for clients these attributes won't even make it into the
		// list
		if ( staticAttrib.bForceGCToGenerate )
			continue;
#endif // GC_DLL

		const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinition( staticAttrib.iDefIndex );
		if ( !pAttrDef )
			continue;

		const ISchemaAttributeType *pAttrType = pAttrDef->GetAttributeType();
		Assert( pAttrType );

		if ( !pAttrType->OnIterateAttributeValue( pIterator, pAttrDef, staticAttrib.m_value ) )
			return;
	}
}

#if defined(CLIENT_DLL) || defined(GAME_DLL)
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
Activity CEconItemDefinition::GetActivityOverride( int iTeam, Activity baseAct ) const
{
	int iAnims = GetNumAnimations( iTeam );
	for ( int i = 0; i < iAnims; i++ )
	{
		animation_on_wearable_t *pData = GetAnimationData( iTeam, i );
		if ( !pData )
			continue;
		if ( pData->iActivity == kActivityLookup_Unknown )
		{
			pData->iActivity = ActivityList_IndexForName( pData->pszActivity );
		}

		if ( pData->iActivity == baseAct )
		{
			if ( pData->iReplacement == kActivityLookup_Unknown )
			{
				pData->iReplacement = ActivityList_IndexForName( pData->pszReplacement );
			}

			if ( pData->iReplacement > 0 )
			{
				return (Activity) pData->iReplacement;
			}
		}
	}

	return baseAct;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CEconItemDefinition::GetActivityOverride( int iTeam, const char *pszActivity ) const
{
	int iAnims = GetNumAnimations( iTeam );
	for ( int i = 0; i < iAnims; i++ )
	{
		animation_on_wearable_t *pData = GetAnimationData( iTeam, i );
		if ( Q_stricmp( pszActivity, pData->pszActivity ) == 0 )
			return pData->pszReplacement;
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CEconItemDefinition::GetReplacementForActivityOverride( int iTeam, Activity baseAct ) const
{
	int iAnims = GetNumAnimations( iTeam );
	for ( int i = 0; i < iAnims; i++ )
	{
		animation_on_wearable_t *pData = GetAnimationData( iTeam, i );
		if ( pData->iActivity == kActivityLookup_Unknown )
		{
			pData->iActivity = ActivityList_IndexForName( pData->pszActivity );
		}
		if ( pData && pData->iActivity == baseAct )
			return pData->pszReplacement;
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose: Returns true if the content for this item view should be streamed. If false,
//			it should be preloaded.
//-----------------------------------------------------------------------------

// DO NOT MERGE THIS CONSOLE VARIABLE TO REL WE SHOULD NOT SHIP THIS OH GOD
#ifdef STAGING_ONLY
ConVar item_enable_dynamic_loading( "item_enable_dynamic_loading", "1", FCVAR_REPLICATED, "Enable/disable dynamic streaming of econ content." );
#endif // STAGING_ONLY

bool CEconItemDefinition::IsContentStreamable() const
{
	if ( !BLoadOnDemand() )
		return false;
		
#ifdef STAGING_ONLY
	return item_enable_dynamic_loading.GetBool();
#else
	return true;
#endif
}
#endif // defined(CLIENT_DLL) || defined(GAME_DLL)

RETURN_ATTRIBUTE_STRING_F( CEconItemDefinition::GetIconDisplayModel, "icon display model", m_pszWorldDisplayModel );

//-----------------------------------------------------------------------------
// Purpose: Constructor
//-----------------------------------------------------------------------------
CTimedItemRewardDefinition::CTimedItemRewardDefinition( void )
:	m_unMinFreq( 0 ),
	m_unMaxFreq( UINT_MAX ),
	m_flChance( 0.0f ),
	m_pLootList( NULL ),
	m_iRequiredItemDef(INVALID_ITEM_DEF_INDEX)
{
}


//-----------------------------------------------------------------------------
// Purpose:	Copy constructor
//-----------------------------------------------------------------------------
CTimedItemRewardDefinition::CTimedItemRewardDefinition( const CTimedItemRewardDefinition &that )
{
	(*this) = that;
}


//-----------------------------------------------------------------------------
// Purpose:	Operator=
//-----------------------------------------------------------------------------
CTimedItemRewardDefinition &CTimedItemRewardDefinition::operator=( const CTimedItemRewardDefinition &rhs )
{
	m_unMinFreq = rhs.m_unMinFreq;
	m_unMaxFreq = rhs.m_unMaxFreq;
	m_flChance = rhs.m_flChance;
	m_criteria = rhs.m_criteria;
	m_pLootList = rhs.m_pLootList;
	m_iRequiredItemDef = rhs.m_iRequiredItemDef;

	return *this;
}


//-----------------------------------------------------------------------------
// Purpose:	Initialize the attribute definition
// Input:	pKVTimedReward - The KeyValues representation of the timed reward
//			schema - The overall item schema
//			pVecErrors - An optional vector that will contain error messages if 
//				the init fails.
// Output:	True if initialization succeeded, false otherwise
//-----------------------------------------------------------------------------
bool CTimedItemRewardDefinition::BInitFromKV( KeyValues *pKVTimedReward, CUtlVector<CUtlString> *pVecErrors /* = NULL */ )
{
	// Parse the basic values
	m_flChance = pKVTimedReward->GetFloat( "pctChance" );
	m_unMinFreq = pKVTimedReward->GetInt( "value_min", 0 );
	m_unMaxFreq = pKVTimedReward->GetInt( "value_max", UINT_MAX );
	m_iRequiredItemDef = INVALID_ITEM_DEF_INDEX;

	const char *pszRequiredItem = pKVTimedReward->GetString( "required_item", NULL );
	if ( pszRequiredItem )
	{
		// Find the ItemDef
		CEconItemDefinition *pDef = GetItemSchema()->GetItemDefinitionByName( pszRequiredItem );
		SCHEMA_INIT_CHECK( pDef != NULL, "Invalid Item Def Required for a for TimedReward Definition");
		m_iRequiredItemDef = pDef->GetDefinitionIndex();
	}

	// Check required fields
	SCHEMA_INIT_CHECK( 
		NULL != pKVTimedReward->FindKey( "value_min" ), 
		"Time reward %s: Missing required field \"value_min\"", pKVTimedReward->GetName() );
	SCHEMA_INIT_CHECK( 
		NULL != pKVTimedReward->FindKey( "value_max" ), 
		"Time reward %s: Missing required field \"value_max\"", pKVTimedReward->GetName() );

	SCHEMA_INIT_CHECK( 
		NULL != pKVTimedReward->FindKey( "pctChance" ), 
		"Time reward %s: Missing required field \"pctChance\"", pKVTimedReward->GetName() );

	SCHEMA_INIT_CHECK(
		NULL == pKVTimedReward->FindKey( "criteria" ),
		"Time reward %s: \"criteria\" is no longer supported. Restructure as \"loot_list\"?", pKVTimedReward->GetName() );
		
	SCHEMA_INIT_CHECK( 
		NULL != pKVTimedReward->FindKey( "loot_list" ), 
		"Time reward %s: Missing required field \"loot_list\" ", pKVTimedReward->GetName() );

	// Parse the loot list
	const char *pszLootList = pKVTimedReward->GetString("loot_list", NULL);
	if ( pszLootList && pszLootList[0] )
	{
		m_pLootList = GetItemSchema()->GetLootListByName( pszLootList );

		// Make sure the item index is correct because we use this index as a reference
		SCHEMA_INIT_CHECK( 
			NULL != m_pLootList,
			"Time Reward %s: loot_list (%s) does not exist", pKVTimedReward->GetName(), pszLootList );
	}

	// Other integrity checks
	SCHEMA_INIT_CHECK(
		m_flChance >= 0.0f,
		"Time Reward %s: pctChance (%f) must be greater or equal to 0.0", pKVTimedReward->GetName(), m_flChance );

	SCHEMA_INIT_CHECK(
		m_flChance <= 1.0f,
		"Time Reward %s: pctChance (%f) must be less than or equal to 1.0", pKVTimedReward->GetName(), m_flChance );

	SCHEMA_INIT_CHECK(
		pKVTimedReward->GetInt( "value_min" ) > 0, 
		"Time Reward %s: value_min (%d) must be greater than 0", pKVTimedReward->GetName(), m_unMinFreq );
	SCHEMA_INIT_CHECK(
		pKVTimedReward->GetInt( "value_max" ) > 0, 
		"Time Reward %s: value_max (%d) must be greater than 0", pKVTimedReward->GetName(), m_unMaxFreq );
	SCHEMA_INIT_CHECK(
		(m_unMaxFreq >= m_unMinFreq), 
		"Time Reward %s: value_max (%d) must be greater than or equal to value_min (%d)", pKVTimedReward->GetName(), m_unMaxFreq, m_unMinFreq );

	return SCHEMA_INIT_SUCCESS();
}


//-----------------------------------------------------------------------------
// Purpose: Adds a foreign item definition to local definition mapping for a 
//			foreign app
//-----------------------------------------------------------------------------
void CForeignAppImports::AddMapping( uint16 unForeignDefIndex, const CEconItemDefinition *pDefn )
{
	m_mapDefinitions.InsertOrReplace( unForeignDefIndex, pDefn );
}


//-----------------------------------------------------------------------------
// Purpose: Adds a foreign item definition to local definition mapping for a 
//			foreign app
//-----------------------------------------------------------------------------
const CEconItemDefinition *CForeignAppImports::FindMapping( uint16 unForeignDefIndex ) const
{
	int i = m_mapDefinitions.Find( unForeignDefIndex );
	if( m_mapDefinitions.IsValidIndex( i ) )
		return m_mapDefinitions[i];
	else
		return NULL;
}

//-----------------------------------------------------------------------------
// Purpose:	Constructor
//-----------------------------------------------------------------------------
CEconItemSchema::CEconItemSchema( )
: 	m_unResetCount( 0 )
,	m_pKVRawDefinition( NULL )
,	m_mapItemSeries( DefLessFunc(int) )
,	m_mapRarities( DefLessFunc(int) )
,	m_mapQualities( DefLessFunc(int) )
,	m_mapAttributes( DefLessFunc(int) )
,	m_mapRecipes( DefLessFunc(int) )
,	m_mapQuestObjectives( DefLessFunc(int) )
,	m_mapItemsSorted( DefLessFunc(int) )
,	m_mapToolsItems( DefLessFunc(int) )
,	m_mapBaseItems( DefLessFunc(int) )
,	m_unVersion( 0 )
#if defined(CLIENT_DLL) || defined(GAME_DLL)
,	m_pDefaultItemDefinition( NULL )
#endif
,	m_mapItemSets( CaselessStringLessThan )
,	m_mapItemCollections( CaselessStringLessThan )
,	m_mapItemPaintKits( CaselessStringLessThan )
,	m_mapOperationDefinitions( CaselessStringLessThan )
,   m_mapLootLists( CaselessStringLessThan )
,	m_mapRevolvingLootLists( DefLessFunc(int) )
,	m_mapDefinitionPrefabs( CaselessStringLessThan )
,	m_mapAchievementRewardsByData( DefLessFunc( uint32 ) )
,	m_mapAttributeControlledParticleSystems( DefLessFunc(int) )
,	m_mapDefaultBodygroupState( CaselessStringLessThan )
#ifdef GC_DLL
,	m_mapForeignImports( DefLessFunc(AppId_t) )
#elif defined(CLIENT_DLL) || defined(GAME_DLL)
,	m_pDelayedSchemaData( NULL )
#endif
,	m_mapKillEaterScoreTypes( DefLessFunc( unsigned int ) )
,	m_mapCommunityMarketDefinitionIndexRemap( DefLessFunc( item_definition_index_t ) )
#ifdef CLIENT_DLL
,	m_mapSteamPackageLocalizationTokens( DefLessFunc( uint32 ) )
#endif
{
	Reset();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
IEconTool *CEconItemSchema::CreateEconToolImpl( const char *pszToolType, const char *pszUseString, const char *pszUsageRestriction, item_capabilities_t unCapabilities, KeyValues *pUsageKV )
{
	if ( pszToolType )
	{
		if ( !V_stricmp( pszToolType, "duel_minigame" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( unCapabilities != ITEM_CAP_NONE )		return NULL;
			if ( pUsageKV )								return NULL;
				
			return new CEconTool_DuelingMinigame( pszToolType, pszUseString );
		}

		if ( !V_stricmp( pszToolType, "noise_maker" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( unCapabilities != ITEM_CAP_NONE )		return NULL;
			if ( pUsageKV )								return NULL;

			return new CEconTool_Noisemaker( pszToolType, pszUseString );
		}

		if ( !V_stricmp( pszToolType, "wrapped_gift" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;

			return new CEconTool_WrappedGift( pszToolType, pszUseString, unCapabilities, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "backpack_expander" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( unCapabilities != ITEM_CAP_NONE )		return NULL;

			return new CEconTool_BackpackExpander( pszToolType, pszUseString, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "account_upgrade_to_premium" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( unCapabilities != ITEM_CAP_NONE )		return NULL;
			if ( pUsageKV )								return NULL;

			return new CEconTool_AccountUpgradeToPremium( pszToolType, pszUseString );
		}

		if ( !V_stricmp( pszToolType, "claimcode" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( unCapabilities != ITEM_CAP_NONE )		return NULL;

			return new CEconTool_ClaimCode( pszToolType, pszUseString, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "gift" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( unCapabilities != ITEM_CAP_NONE )		return NULL;

			return new CEconTool_Gift( pszToolType, pszUseString, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "paint_can" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( pUsageKV )								return NULL;

			return new CEconTool_PaintCan( pszToolType, unCapabilities );
		}

		if ( !V_stricmp( pszToolType, "name" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( pUsageKV )								return NULL;

			return new CEconTool_NameTag( pszToolType, unCapabilities );
		}

		if ( !V_stricmp( pszToolType, "desc" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( pUsageKV )								return NULL;

			return new CEconTool_DescTag( pszToolType, unCapabilities );
		}

		if ( !V_stricmp( pszToolType, "decoder_ring" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pUsageKV )								return NULL;

			return new CEconTool_CrateKey( pszToolType, pszUsageRestriction, unCapabilities );
		}

		if ( !V_stricmp( pszToolType, "customize_texture_item" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( pUsageKV )								return NULL;

			return new CEconTool_CustomizeTexture( pszToolType, unCapabilities );
		}

		if ( !V_stricmp( pszToolType, "gift_wrap" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;

			return new CEconTool_GiftWrap( pszToolType, pszUseString, unCapabilities, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "wedding_ring" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( pUsageKV )								return NULL;

			return new CEconTool_WeddingRing( pszToolType, pszUseString, unCapabilities );
		}

		if ( !V_stricmp( pszToolType, "strange_part" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			
			return new CEconTool_StrangePart( pszToolType, pszUseString, unCapabilities, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "strange_part_restriction" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( !pUsageKV )							return NULL;		// required
			
			return new CEconTool_StrangePartRestriction( pszToolType, pszUseString, unCapabilities, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "apply_custom_attrib" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			
			return new CEconTool_UpgradeCard( pszToolType, pszUseString, unCapabilities, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "strangifier" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;

			return new CEconTool_Strangifier( pszToolType, pszUseString, unCapabilities, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "killstreakifier" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;

			return new CEconTool_KillStreakifier( pszToolType, pszUseString, unCapabilities, pUsageKV );
		}

		if( !V_stricmp( pszToolType, "dynamic_recipe" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			
			return new CEconTool_ItemDynamicRecipe( pszToolType, pszUseString, unCapabilities, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "item_eater_recharger" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;

			return new CEconTool_ItemEaterRecharger( pszToolType, pszUseString, unCapabilities, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "class_transmogrifier" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;

			return new CEconTool_ClassTransmogrifier( pszToolType, pszUseString, unCapabilities, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "duck_token" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( pUsageKV )								return NULL;

			return new CEconTool_DuckToken( pszToolType, unCapabilities );
		}

		if ( !V_stricmp( pszToolType, "grant_operation_pass" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;

			return new CEconTool_GrantOperationPass( pszToolType, pszUseString, unCapabilities, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "strange_count_transfer" ) )
		{
			// Error checking -- make sure we aren't setting properties in the schema that we don't support.
			if ( pszUsageRestriction )					return NULL;
			if ( pUsageKV )								return NULL;

			return new CEconTool_StrangeCountTransfer( pszToolType, unCapabilities );
		}

		if ( !V_stricmp( pszToolType, "paintkit_weapon_festivizer" ) )
		{
			return new CEconTool_Festivizer( pszToolType, pszUseString, unCapabilities, pUsageKV );
		}

		if ( !V_stricmp( pszToolType, "unusualifier" ) )
		{
			return new CEconTool_Unusualifier( pszToolType, pszUseString, unCapabilities, pUsageKV );
		}
	}

	// Default behavior.
	return new CEconTool_Default( pszToolType, pszUseString, pszUsageRestriction, unCapabilities );
}

#ifdef GC_DLL
random_attrib_t	*CEconItemSchema::CreateRandomAttribute( const char *pszContext, KeyValues *pRandomAttributesKV, CUtlVector<CUtlString> *pVecErrors /*= NULL*/ )
{
	// We've found the random attribute block. Parse it.
	if ( pRandomAttributesKV->FindKey( "chance" ) == NULL )
	{
		CUtlString msg;													\
		msg.Format( CFmtStr( "Missing required field \"chance\" in the \"random_attributes\" block." ) );	
		if ( pVecErrors )
		{
			pVecErrors->AddToTail( msg );
		}
		else
		{
			AssertMsg( pRandomAttributesKV->FindKey( "chance" ) != NULL, msg.String() );
		}

		return NULL;
	}

	random_attrib_t randomAttrib;

	randomAttrib.m_flChanceOfRandomAttribute = pRandomAttributesKV->GetFloat( "chance" );
	randomAttrib.m_bPickAllAttributes = ( pRandomAttributesKV->GetFloat( "pick_all_attributes" ) != 0 );
	randomAttrib.m_flTotalAttributeWeight = 0;

	FOR_EACH_TRUE_SUBKEY( pRandomAttributesKV, pKVAttribute )
	{
		const char *pszName = pKVAttribute->GetName();

		if ( !Q_strcmp( pszName, "chance" ) )
			continue;

		// Quick block list of attrs that have equal weight
		if ( !Q_strcmp( pszName, "is_even_chance_attr" ) )
		{
			FOR_EACH_VALUE( pKVAttribute, pKVListItem )
			{
				const CEconItemAttributeDefinition *pDef = GetAttributeDefinitionByName( pKVListItem->GetName() );
				if ( pDef == NULL )
				{
					CUtlString msg;													\
					msg.Format( CFmtStr( "Attribute definition \"%s\" was not found", pszName ) );	
					if ( pVecErrors )
					{
						pVecErrors->AddToTail( msg );
					}
					else
					{
						AssertMsg( pDef != NULL, msg.String() );
					}

					return NULL;
				}

				lootlist_attrib_t lootListAttrib;
				if ( !lootListAttrib.m_staticAttrib.BInitFromKV_SingleLine( __FUNCTION__, pKVListItem, pVecErrors, false ) )
				{
					if ( pVecErrors )
					{
						pVecErrors->AddToTail( __FUNCTION__ ": error initializing line-item attribute from lootlist definition (possible attr template).\n" );
					}
					return NULL;
				}
				// Weight is set to 1 for even chance attr
				lootListAttrib.m_flWeight = 1.0f;
				randomAttrib.m_flTotalAttributeWeight += 1.0f;
				randomAttrib.m_RandomAttributes.AddToTail( lootListAttrib );
			}
		}
		else
		{
			const CEconItemAttributeDefinition *pDef = GetAttributeDefinitionByName( pszName );
			if ( pDef == NULL )
			{
				CUtlString msg;													\
				msg.Format( CFmtStr( "Attribute definition \"%s\" was not found", pszName ) );	
				if ( pVecErrors )
				{
					pVecErrors->AddToTail( msg );
				}
				else
				{
					AssertMsg( pDef != NULL, msg.String() );
				}

				return NULL;
			}

			lootlist_attrib_t lootListAttrib;
			if ( !lootListAttrib.BInitFromKV( pszContext, pKVAttribute, *this, pVecErrors ) )
			{
				return NULL;
			}

			randomAttrib.m_flTotalAttributeWeight += lootListAttrib.m_flWeight;
			randomAttrib.m_RandomAttributes.AddToTail( lootListAttrib );
		}
	}

	random_attrib_t *pRandomAttr = new random_attrib_t;
	*pRandomAttr = randomAttrib;
	return pRandomAttr;
}
#endif // GC_DLL


//-----------------------------------------------------------------------------
// Purpose:	Resets the schema to before BInit was called
//-----------------------------------------------------------------------------
void CEconItemSchema::Reset( void )
{
	++m_unResetCount;

	m_unFirstValidClass = 0;
	m_unLastValidClass = 0;
	m_unAccoutClassIndex = 0;
	m_unFirstValidClassItemSlot = 0;
	m_unLastValidClassItemSlot = 0;
	m_unFirstValidAccountItemSlot = 0;
	m_unLastValidAccountItemSlot = 0;
	m_unNumItemPresets = 0;
	m_unMinLevel = 0;
	m_unMaxLevel = 0;
	m_unVersion = 0;
	m_unSumQualityWeights = 0;
	FOR_EACH_VEC( m_vecAttributeTypes, i )
	{
		delete m_vecAttributeTypes[i].m_pAttrType;
	}
	m_vecAttributeTypes.Purge();
	m_mapItems.PurgeAndDeleteElements();
	m_mapItems.Purge();
	m_mapRarities.Purge();
	m_mapQualities.Purge();
	m_mapItemsSorted.Purge();
	m_mapToolsItems.Purge();
	m_mapBaseItems.Purge();
	m_mapRecipes.PurgeAndDeleteElements();
	m_vecTimedRewards.Purge();
	m_mapItemSets.PurgeAndDeleteElements();
	m_mapLootLists.PurgeAndDeleteElements();
#ifdef GC_DLL
	m_dictRandomAttributeTemplates.PurgeAndDeleteElements();
#endif // GC_DLL
	m_mapAttributeControlledParticleSystems.Purge();
	m_vecAttributeControlledParticleSystemsCosmetics.Purge();
	m_vecAttributeControlledParticleSystemsWeapons.Purge();
	m_vecAttributeControlledParticleSystemsTaunts.Purge();

	m_mapAttributes.Purge();
	if ( m_pKVRawDefinition )
	{
		m_pKVRawDefinition->deleteThis();
		m_pKVRawDefinition = NULL;
	}

#if defined(CLIENT_DLL) || defined(GAME_DLL)
	delete m_pDefaultItemDefinition;
	m_pDefaultItemDefinition = NULL;
#endif

	FOR_EACH_MAP_FAST( m_mapRecipes, i )
	{
		delete m_mapRecipes[i];
	}

	FOR_EACH_MAP_FAST( m_mapDefinitionPrefabs, i )
	{
		m_mapDefinitionPrefabs[i]->deleteThis();
	}
	m_mapDefinitionPrefabs.Purge();

	m_vecEquipRegionsList.Purge();
	m_vecItemLevelingData.PurgeAndDeleteElements();

	m_dictStringTable.PurgeAndDeleteElements();
	m_mapCommunityMarketDefinitionIndexRemap.Purge();
}


//-----------------------------------------------------------------------------
// Purpose:	Operator=
//-----------------------------------------------------------------------------
CEconItemSchema &CEconItemSchema::operator=( CEconItemSchema &rhs )
{
	Reset();
	BInitSchema( rhs.m_pKVRawDefinition );
	return *this;
}

bool g_bLastSignatureCheck;

bool CheckValveSignature( const void *data, uint32 nDataSize, const void *signature, uint32 nSignatureSize )
{
	// Must match the PUBLIC KEY in src\devtools\valve_source_officialcontent.privatekey.vdf
	static const unsigned char valvePublicKey[] =
		"\x30\x81\x9D\x30\x0D\x06\x09\x2A\x86\x48\x86\xF7\x0D\x01\x01\x01"
		"\x05\x00\x03\x81\x8B\x00\x30\x81\x87\x02\x81\x81\x00\xB1\xC0\xF1"
		"\x1C\xB2\x98\x2F\x29\x25\x95\x07\xA7\x74\xD4\x83\x43\x77\xC5\xB7"
		"\xA3\x8D\x9A\x4B\x38\x92\xB5\x98\x00\x9F\x16\xAA\x10\x95\x65\xCB"
		"\x09\xAD\x25\xDE\x0D\x3D\x1A\x08\x9C\x3C\xB6\x8E\x49\x19\x21\xCC"
		"\x14\x2F\x38\x33\x83\x20\x1D\xE9\x82\x62\xA7\x6E\xD8\xA6\xCC\x78"
		"\xBC\x51\x68\x5A\x0A\x64\xA6\x17\x2C\x67\x12\x7A\xF2\x3E\x78\x73"
		"\x1F\x4A\x82\xC2\x01\xD6\x4C\x9A\xB8\x09\x37\x32\x21\x84\xB6\x42"
		"\x72\x7F\xE1\x42\xD1\x5C\xC0\x45\xF3\x58\x3E\x19\xE3\xE3\xE1\xA9"
		"\xC5\x0C\x0F\xC8\x41\x13\x57\x3A\x52\x0A\x8F\x73\x23\x02\x01\x11";

	// Put into a global var.  Could help with VAC detection, if this
	// code gets detoured
	g_bLastSignatureCheck = CCrypto::RSAVerifySignatureSHA256(
		(const uint8 *)data, nDataSize, 
		(const uint8 *)signature, nSignatureSize,
		valvePublicKey, sizeof(valvePublicKey)
	);

	return g_bLastSignatureCheck;
}

//-----------------------------------------------------------------------------
// Initializes the schema, given KV filename
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInit( const char *fileName, const char *pathID, CUtlVector<CUtlString> *pVecErrors /* = NULL */)
{
	Reset();

	// Read the raw data
	CUtlBuffer bufRawData;
	bool bReadFileOK = g_pFullFileSystem->ReadFile( fileName, pathID, bufRawData );
	SCHEMA_INIT_CHECK( bReadFileOK, "Cannot load file '%s'", fileName );

	// Do we need to check the signature?
	#if defined(TF_DLL) || defined(TF_CLIENT_DLL)
	{

		// Load up the signature
		CUtlString sSignatureFilename( fileName ); sSignatureFilename.Append( ".sig" );
		CUtlBuffer bufSignatureBinary;
		bool bReadSignatureOK = g_pFullFileSystem->ReadFile( sSignatureFilename.String(), pathID, bufSignatureBinary );
		SCHEMA_INIT_CHECK( bReadSignatureOK, "Cannot load file '%s'", sSignatureFilename.String() );

		// Check it with the Valve public key
		bool bSignatureValid = CheckValveSignature(
			bufRawData.Base(), bufRawData.TellPut(), 
			bufSignatureBinary.Base(), bufSignatureBinary.TellPut()
		);

		// If they have a signature for a zero-byte file, that's OK, too.
		// That's the secret code that is checked into P4 internally that
		// let's us run with any items_game file
		if ( !bSignatureValid )
		{
			bSignatureValid = CheckValveSignature(
				"", 0, 
				bufSignatureBinary.Base(), bufSignatureBinary.TellPut()
			);
		}

		SCHEMA_INIT_CHECK( bSignatureValid, "'%s' is corrupt.  Please verify your local game files.  (https://support.steampowered.com/kb_article.php?ref=2037-QEUH-3335)", fileName );
	}
	#endif

	// Compute version hash
	CSHA1 sha1;
	sha1.Update( (unsigned char *)bufRawData.Base(), bufRawData.Size() );
	sha1.Final();
	sha1.GetHash( m_schemaSHA.m_shaDigest );

	// Wrap it with a text buffer reader
	CUtlBuffer bufText( bufRawData.Base(), bufRawData.TellPut(), CUtlBuffer::READ_ONLY | CUtlBuffer::TEXT_BUFFER );

	// Use the standard init path
	return BInitTextBuffer( bufText, pVecErrors );
}

//-----------------------------------------------------------------------------
// Initializes the schema, given KV in binary form
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitBinaryBuffer( CUtlBuffer &buffer, CUtlVector<CUtlString> *pVecErrors /* = NULL */ )
{
	Reset();
	m_pKVRawDefinition = new KeyValues( "CEconItemSchema" );
	if ( m_pKVRawDefinition->ReadAsBinary( buffer ) )
	{
		return BInitSchema( m_pKVRawDefinition, pVecErrors )
			&& BPostSchemaInit( pVecErrors );
	}
	if ( pVecErrors )
	{
		pVecErrors->AddToTail( "Error parsing keyvalues" );
	}
	return false;
}

unsigned char g_sha1ItemSchemaText[ k_cubHash ];

//-----------------------------------------------------------------------------
// Initializes the schema, given KV in text form
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitTextBuffer( CUtlBuffer &buffer, CUtlVector<CUtlString> *pVecErrors /* = NULL */ )
{
	// Save off the hash into a global variable, so VAC can check it
	// later
	GenerateHash( g_sha1ItemSchemaText, buffer.Base(), buffer.TellPut() );

	Reset();
	m_pKVRawDefinition = new KeyValues( "CEconItemSchema" );
	if ( m_pKVRawDefinition->LoadFromBuffer( NULL, buffer ) )
	{
		return BInitSchema( m_pKVRawDefinition, pVecErrors )
			&& BPostSchemaInit( pVecErrors );
	}
	if ( pVecErrors )
	{
		pVecErrors->AddToTail( "Error parsing keyvalues" );
	}
	return false;
}

bool CEconItemSchema::DumpItems ( const char *fileName, const char *pathID )
{
	// create a write file
	FileHandle_t f = g_pFullFileSystem->Open(fileName, "wb", pathID);

	if ( f == FILESYSTEM_INVALID_HANDLE )
	{
		DevMsg(1, "CEconItemSchema::DumpItems: couldn't open file \"%s\" in path \"%s\".\n", 
			fileName?fileName:"NULL", pathID?pathID:"NULL" );
		return false;
	}

	CUtlSortVector< KeyValues*, CUtlSortVectorKeyValuesByName > vecSortedItems;

	FOR_EACH_MAP_FAST( m_mapItems, i )
	{
		vecSortedItems.InsertNoSort( m_mapItems[ i ]->GetRawDefinition() );
	}
	vecSortedItems.RedoSort();

	CUtlBuffer buf;
	FOR_EACH_VEC( vecSortedItems, i )
	{
		vecSortedItems[i]->RecursiveSaveToFile( buf, 0, true );
	}

	int iBufSize = buf.GetBytesRemaining();
	bool bSuccess = false;
	if ( g_pFullFileSystem->Write(buf.PeekGet(), iBufSize, f) == iBufSize )
		bSuccess = true;

	g_pFullFileSystem->Close(f);

	return bSuccess;
}

//-----------------------------------------------------------------------------
// Called once the price sheet's been loaded
//-----------------------------------------------------------------------------
#ifdef GC_DLL
GCConVar econ_orphaned_sold_items_owned_by_account_id( "econ_orphaned_sold_items_owned_by_account_id", "121416792" );

bool CEconItemSchema::DoPostPriceSheetLoadInit( CEconStorePriceSheet *pPriceSheet )
{
	FOR_EACH_MAP_FAST( m_mapItems, iItem )
	{
		CEconItemDefinition *pItemDef = m_mapItems[ iItem ];

		// Is this item being sold?
		const econ_store_entry_t *pStoreEntry = pPriceSheet->GetEntry( pItemDef->GetDefinitionIndex() );
		if ( pStoreEntry )
		{
			// Cache off whether this item is a pack item
			pItemDef->SetIsPackItem( pStoreEntry->m_bIsPackItem );

			// If an item is being sold and it has no payment rules set up, we can optionally force-create
			// a dummy payment rule that will redirect that item revenue to a "hey, these are orphan items!"
			// account.
			if ( pItemDef->GetPaymentRules().Count() == 0 && econ_orphaned_sold_items_owned_by_account_id.GetInt() )
			{
				econ_item_payment_rule_t rule;
				rule.m_RevenueShare = 1.0;
				rule.m_eRuleType = kPaymentRule_PartnerSteamID;
				rule.m_vecValues.AddToTail( econ_orphaned_sold_items_owned_by_account_id.GetInt() );

				DbgVerify( pItemDef->AddPaymentRule( rule ) == 0 );
			}
		}

		// Go through the cache of all bundles...
		FOR_EACH_VEC( m_vecBundles, iBundle )
		{
			const CEconItemDefinition *pBundleItemDef = m_vecBundles[ iBundle ];
			const bundleinfo_t *pBundle = pBundleItemDef->GetBundleInfo();
			const bool bBundleItemIsForSale = pPriceSheet->BItemExistsInPriceSheet( pBundleItemDef->GetDefinitionIndex() ) != NULL;	// Only add bundles that are actually for sale

			bool bAddToContainingBundleItemDefs = false;
			if ( pItemDef->IsPackBundle() )
			{
				// If the current item is a pack bundle, look for the first pack item in the current bundle (pBundle). We can safely assume that all pack items will be
				// in pBundle if the first pack item is, since the GC won't startup otherwise. Don't add self as a containing bundle.
				bAddToContainingBundleItemDefs = pItemDef->GetDefinitionIndex() != pBundleItemDef->GetDefinitionIndex()
											  && pBundle->vecItemDefs.HasElement( pItemDef->GetBundleInfo()->vecItemDefs[0] );
			}
			else
			{
				bAddToContainingBundleItemDefs = pBundle->vecItemDefs.HasElement( pItemDef );
			}

			// Does the current bundle contain the given item?
			if ( bBundleItemIsForSale && bAddToContainingBundleItemDefs )
			{
				pItemDef->m_vecContainingBundleItemDefs.AddToTail( pBundleItemDef );
			}
		}
	}

	return true;
}
#endif


#if defined(CLIENT_DLL) || defined(GAME_DLL)
//-----------------------------------------------------------------------------
// Set up the buffer to use to reinitialize our schema next time we can do so safely.
//-----------------------------------------------------------------------------
bool CEconItemSchema::MaybeInitFromBuffer( IDelayedSchemaData *pDelayedSchemaData )
{
	bool bDidInit = false;

	// Use whatever our most current data block is.
	if ( m_pDelayedSchemaData )
	{
		delete m_pDelayedSchemaData;
	}

	m_pDelayedSchemaData = pDelayedSchemaData;

#ifdef CLIENT_DLL
	// If we aren't in a game we can parse immediately now.
	if ( !engine->IsInGame() )
	{
		BInitFromDelayedBuffer();
		bDidInit = true;
	}
#endif // CLIENT_DLL

	return bDidInit;
}

//-----------------------------------------------------------------------------
// We're in a safe place to change the contents of the schema, so do so and clean
// up whatever memory we were using.
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitFromDelayedBuffer()
{
	if ( !m_pDelayedSchemaData )
		return true;

	bool bSuccess = m_pDelayedSchemaData->InitializeSchema( this );
	delete m_pDelayedSchemaData;
	m_pDelayedSchemaData = NULL;

	return bSuccess;
}
#endif // !GC_DLL

static void CalculateKeyValuesCRCRecursive( KeyValues *pKV, CRC32_t *crc, bool bIgnoreName = false )
{
	// Hash in the key name in LOWERCASE.  Keyvalues files are not deterministic due
	// to the case insensitivity of the keys and the dependence on the existing
	// state of the name table upon entry.
	if ( !bIgnoreName )
	{
		const char *s = pKV->GetName();  
		for (;;)
		{
			unsigned char x = tolower(*s);
			CRC32_ProcessBuffer( crc, &x, 1 ); // !SPEED! This is slow, but it works.
			if (*s == '\0') break;
			++s;
		}
	}

	// Now hash in value, depending on type
	// !FIXME! This is not byte-order independent!
	switch ( pKV->GetDataType() )
	{
	case KeyValues::TYPE_NONE:
		{
			FOR_EACH_SUBKEY( pKV, pChild )
			{
				CalculateKeyValuesCRCRecursive( pChild, crc );
			}
			break;
		}
	case KeyValues::TYPE_STRING:
		{
			const char *val = pKV->GetString();
			CRC32_ProcessBuffer( crc, val, strlen(val)+1 );
			break;
		}

	case KeyValues::TYPE_INT:
		{
			int val = pKV->GetInt();
			CRC32_ProcessBuffer( crc, &val, sizeof(val) );
			break;
		}

	case KeyValues::TYPE_UINT64:
		{
			uint64 val = pKV->GetUint64();
			CRC32_ProcessBuffer( crc, &val, sizeof(val) );
			break;
		}

	case KeyValues::TYPE_FLOAT:
		{
			float val = pKV->GetFloat();
			CRC32_ProcessBuffer( crc, &val, sizeof(val) );
			break;
		}
	case KeyValues::TYPE_COLOR:
		{
			int val = pKV->GetColor().GetRawColor();
			CRC32_ProcessBuffer( crc, &val, sizeof(val) );
			break;
		}

	default:
	case KeyValues::TYPE_PTR:
	case KeyValues::TYPE_WSTRING:
		{
			Assert( !"Unsupport data type!" );
			break;
		}
	}
}

uint32 CEconItemSchema::CalculateKeyValuesVersion( KeyValues *pKV )
{
	CRC32_t crc;
	CRC32_Init( &crc );

	// Calc CRC recursively.  Ignore the very top-most
	// key name, which isn't set consistently
	CalculateKeyValuesCRCRecursive( pKV, &crc, true );
	CRC32_Final( &crc );
	return crc;
}

EEquipType_t CEconItemSchema::GetEquipTypeFromClassIndex( int iClass ) const
{
	if ( iClass == GetAccountIndex() )
		return EEquipType_t::EQUIP_TYPE_ACCOUNT;

	if ( iClass >= GetFirstValidClass() && iClass <= GetLastValidClass() )
		return EEquipType_t::EQUIP_TYPE_CLASS;

	return EEquipType_t::EQUIP_TYPE_INVALID;
}

//-----------------------------------------------------------------------------
// Purpose:	Initializes the schema
// Input:	pKVRawDefinition - The raw KeyValues representation of the schema
//			pVecErrors - An optional vector that will contain error messages if 
//				the init fails.
// Output:	True if initialization succeeded, false otherwise
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitSchema( KeyValues *pKVRawDefinition, CUtlVector<CUtlString> *pVecErrors /* = NULL */ )
{
	m_unMinLevel = pKVRawDefinition->GetInt( "item_level_min", 0 );
	m_unMaxLevel = pKVRawDefinition->GetInt( "item_level_max", 0 );

#if !defined( GC_DLL )
	m_unVersion = CalculateKeyValuesVersion( pKVRawDefinition );
#endif



#ifdef GC_DLL
	// Validate the integrity of the base data.
	SCHEMA_INIT_CHECK( 0 <= m_unMinLevel, "Minimum Item Level must be at least 0" );
	SCHEMA_INIT_CHECK( m_unMinLevel <= m_unMaxLevel, "Minimum Item Level must be less than or equal to Maximum Item Level" );
#endif // GC_DLL

	// Parse the prefabs block first so the prefabs will be populated in case anything else wants
	// to use them later.
	KeyValues *pKVPrefabs = pKVRawDefinition->FindKey( "prefabs" );
	if ( NULL != pKVPrefabs )
	{
		SCHEMA_INIT_SUBSTEP( BInitDefinitionPrefabs( pKVPrefabs, pVecErrors ) );
	}

	// Initialize the game info block
	KeyValues *pKVGameInfo = pKVRawDefinition->FindKey( "game_info" );
	SCHEMA_INIT_CHECK( NULL != pKVGameInfo, "Required key \"game_info\" missing.\n" );

	if ( NULL != pKVGameInfo )
	{
		SCHEMA_INIT_SUBSTEP( BInitGameInfo( pKVGameInfo, pVecErrors ) );
	}

	// Initialize our attribute types. We don't actually pull this data from the schema right now but it
	// still makes sense to initialize it at this point.
	SCHEMA_INIT_SUBSTEP( BInitAttributeTypes( pVecErrors ) );

	// Initialize the item series block
	KeyValues *pKVItemSeries = pKVRawDefinition->FindKey( "item_series_types" );
	SCHEMA_INIT_CHECK( NULL != pKVItemSeries, "Required key \"item_series_types\" missing.\n" );
	if ( NULL != pKVItemSeries )
	{
		SCHEMA_INIT_SUBSTEP( BInitItemSeries( pKVItemSeries, pVecErrors ) );
	}

	// Initialize the rarity block
	KeyValues *pKVRarities = pKVRawDefinition->FindKey( "rarities" );
	KeyValues *pKVRarityWeights = pKVRawDefinition->FindKey( "rarities_lootlist_weights" );
	SCHEMA_INIT_CHECK( NULL != pKVRarities, "Required key \"rarities\" missing.\n" );
	if ( NULL != pKVRarities )
	{
		SCHEMA_INIT_SUBSTEP( BInitRarities( pKVRarities, pKVRarityWeights, pVecErrors ) );
	}

	// Initialize the qualities block
	KeyValues *pKVQualities = pKVRawDefinition->FindKey( "qualities" );
	SCHEMA_INIT_CHECK( NULL != pKVQualities, "Required key \"qualities\" missing.\n" );

	if ( NULL != pKVQualities )
	{
		SCHEMA_INIT_SUBSTEP( BInitQualities( pKVQualities, pVecErrors ) );
	}

	// Initialize the colors block
	KeyValues *pKVColors = pKVRawDefinition->FindKey( "colors" );
	SCHEMA_INIT_CHECK( NULL != pKVColors, "Required key \"colors\" missing.\n" );

	if ( NULL != pKVColors )
	{
		SCHEMA_INIT_SUBSTEP( BInitColors( pKVColors, pVecErrors ) );
	}

	// Initialize the attributes block
	KeyValues *pKVAttributes = pKVRawDefinition->FindKey( "attributes" );
	SCHEMA_INIT_CHECK( NULL != pKVAttributes, "Required key \"attributes\" missing.\n" );

	if ( NULL != pKVAttributes )
	{
		SCHEMA_INIT_SUBSTEP( BInitAttributes( pKVAttributes, pVecErrors ) );
	}

#ifdef GC
	// Initialize the motd block
	KeyValues *pKVMOTD = pKVRawDefinition->FindKey( "motd_entries" );
	SCHEMA_INIT_CHECK( NULL != pKVMOTD, "Required key \"motd_entries\" missing.\n" );

	if ( NULL != pKVMOTD )
	{
		SCHEMA_INIT_SUBSTEP( GGCGameBase()->GetMOTDManager().BInitMOTDEntries( pKVMOTD, pVecErrors ) );
	}
#endif 

	// Initialize the "equip_regions_list" block -- this is an optional block
	KeyValues *pKVEquipRegions = pKVRawDefinition->FindKey( "equip_regions_list" );
	if ( NULL != pKVEquipRegions )
	{
		SCHEMA_INIT_SUBSTEP( BInitEquipRegions( pKVEquipRegions, pVecErrors ) );
	}

	// Initialize the "equip_conflicts" block -- this is an optional block, though it doesn't
	// make any sense and will probably fail internally if there is no corresponding "equip_regions"
	// block as well
	KeyValues *pKVEquipRegionConflicts = pKVRawDefinition->FindKey( "equip_conflicts" );
	if ( NULL != pKVEquipRegionConflicts )
	{
		SCHEMA_INIT_SUBSTEP( BInitEquipRegionConflicts( pKVEquipRegionConflicts, pVecErrors ) );
	}

	// TF2 Paint Kits
	// No included in schema file (Too Big).  Loaded Seperately
	// Load the KV and add it to the pKVRawDefinition
	KeyValues *pPaintkitKV = new KeyValues( "item_paintkit_definitions" );
	SCHEMA_INIT_CHECK( pPaintkitKV->LoadFromFile( g_pFullFileSystem, "scripts/items/paintkits_master.txt", "GAME" ), "Unable to Load paintkits_master.txt KV File!" );
	pKVRawDefinition->AddSubKey( pPaintkitKV );

	// Init Item Paint Kits
	// Must be BEFORE Item defs
	KeyValues *pKVItemPaintKits = pKVRawDefinition->FindKey( "item_paintkit_definitions" );
	if ( NULL != pKVItemPaintKits )
	{
		SCHEMA_INIT_SUBSTEP( BInitItemPaintKitDefinitions( pKVItemPaintKits, pVecErrors ) );
	}

#ifdef GC_DLL
	// Parse the loot lists block (on the GC)
	// Must be BEFORE Item defs
	KeyValues *pKVRandomAttributeTemplates = pKVRawDefinition->FindKey( "random_attribute_templates" );
	SCHEMA_INIT_SUBSTEP( BInitRandomAttributeTemplates( pKVRandomAttributeTemplates, pVecErrors ) );
#endif // GC_DLL

	// Initialize the items block
	KeyValues *pKVItems = pKVRawDefinition->FindKey( "items" );
	SCHEMA_INIT_CHECK( NULL != pKVItems, "Required key \"items\" missing.\n" );

	if ( NULL != pKVItems )
	{
		SCHEMA_INIT_SUBSTEP( BInitItems( pKVItems, pVecErrors ) );
	}


	// Verify base item names are proper in item schema
	SCHEMA_INIT_SUBSTEP( BVerifyBaseItemNames( pVecErrors ) );

	// Parse the item_sets block.
	KeyValues *pKVItemSets = pKVRawDefinition->FindKey( "item_sets" );
	SCHEMA_INIT_SUBSTEP( BInitItemSets( pKVItemSets, pVecErrors ) );
	
	// Particles
	KeyValues *pKVParticleSystems = pKVRawDefinition->FindKey( "attribute_controlled_attached_particles" );
	SCHEMA_INIT_SUBSTEP( BInitAttributeControlledParticleSystems( pKVParticleSystems, pVecErrors ) );

	// Parse any recipes block
	KeyValues *pKVRecipes = pKVRawDefinition->FindKey( "recipes" );
	SCHEMA_INIT_SUBSTEP( BInitRecipes( pKVRecipes, pVecErrors ) );

	// Reset our loot lists.
	m_mapLootLists.RemoveAll();

	// Init Item Collections - Must be before lootlists since collections are lootlists themselves and are referenced by lootlists
	KeyValues *pKVItemCollections = pKVRawDefinition->FindKey( "item_collections" );
	if ( NULL != pKVItemCollections )
	{
		SCHEMA_INIT_SUBSTEP( BInitItemCollections( pKVItemCollections, pVecErrors ) );
	}

#ifdef GC_DLL
	// Parse the loot lists block (on the GC)
	KeyValues *pKVLootLists = pKVRawDefinition->FindKey( "loot_lists" );
	SCHEMA_INIT_SUBSTEP( BInitLootLists( pKVLootLists, pVecErrors ) );

	// Initialize the periodic score accumulation block (this needs to take place after items)
	KeyValues *pKVPeriodicScoring = pKVRawDefinition->FindKey( "periodic_score_accumulation" );
	if ( NULL != pKVPeriodicScoring )
	{
		SCHEMA_INIT_SUBSTEP( BInitPeriodicScoring( pKVPeriodicScoring, pVecErrors ) );
	}
#endif // GC_DLL

	// Parse the client loot lists block (everywhere)
	KeyValues *pKVClientLootLists = pKVRawDefinition->FindKey( "client_loot_lists" );
	SCHEMA_INIT_SUBSTEP( BInitLootLists( pKVClientLootLists, pVecErrors ) );

	// Parse the revolving loot lists block
	KeyValues *pKVRevolvingLootLists = pKVRawDefinition->FindKey( "revolving_loot_lists" );
	SCHEMA_INIT_SUBSTEP( BInitRevolvingLootLists( pKVRevolvingLootLists, pVecErrors ) );

	// Init Items that may reference Collections
	SCHEMA_INIT_SUBSTEP( BInitCollectionReferences( pVecErrors ) );

	// Validate Operation Pass	
	KeyValues *pKVOperationDefinitions = pKVRawDefinition->FindKey( "operations" );
	if ( NULL != pKVOperationDefinitions )
	{
		SCHEMA_INIT_SUBSTEP( BInitOperationDefinitions( pKVGameInfo, pKVOperationDefinitions, pVecErrors ) );
	}

#if defined( GC_DLL )
	// Parse any time-based rewards
	KeyValues *pKVTimeRewards = pKVRawDefinition->FindKey( "time_rewards" );
	SCHEMA_INIT_SUBSTEP( BInitTimedRewards( pKVTimeRewards, pVecErrors ) );

	KeyValues *pKVExperiments = pKVRawDefinition->FindKey( "experiments" );
	SCHEMA_INIT_SUBSTEP( BInitExperiements( pKVExperiments, pVecErrors ) );

	SCHEMA_INIT_SUBSTEP( BInitForeignImports( pVecErrors ) );
#elif defined( CLIENT_DLL ) || defined( GAME_DLL )
	KeyValues *pKVArmoryData = pKVRawDefinition->FindKey( "armory_data" );
	SCHEMA_INIT_SUBSTEP( BInitArmoryData( pKVArmoryData, pVecErrors ) );
#endif // GC_DLL

	// Parse any achievement rewards
	KeyValues *pKVAchievementRewards = pKVRawDefinition->FindKey( "achievement_rewards" );
	SCHEMA_INIT_SUBSTEP( BInitAchievementRewards( pKVAchievementRewards, pVecErrors ) );

#ifdef TF_CLIENT_DLL
	// Compute the number of concrete items, for each item, and cache for quick access
	SCHEMA_INIT_SUBSTEP( BInitConcreteItemCounts( pVecErrors ) );

	// We don't have access to Steam's full library of app data on the client so initialize whichever packages
	// we want to reference.
	KeyValues *pKVSteamPackages = pKVRawDefinition->FindKey( "steam_packages" );
	SCHEMA_INIT_SUBSTEP( BInitSteamPackageLocalizationToken( pKVSteamPackages, pVecErrors ) );
#endif // TF_CLIENT_DLL

	// Parse the item levels block
	KeyValues *pKVItemLevels = pKVRawDefinition->FindKey( "item_levels" );
	SCHEMA_INIT_SUBSTEP( BInitItemLevels( pKVItemLevels, pVecErrors ) );

	// Parse the kill eater score types
	KeyValues *pKVKillEaterScoreTypes = pKVRawDefinition->FindKey( "kill_eater_score_types" );
	SCHEMA_INIT_SUBSTEP( BInitKillEaterScoreTypes( pKVKillEaterScoreTypes, pVecErrors ) );

	// Initialize the string tables, if present
	KeyValues *pKVStringTables = pKVRawDefinition->FindKey( "string_lookups" );
	SCHEMA_INIT_SUBSTEP( BInitStringTables( pKVStringTables, pVecErrors ) );

	// Initialize the community Market remaps, if present
	KeyValues *pKVCommunityMarketRemaps = pKVRawDefinition->FindKey( "community_market_item_remaps" );
	SCHEMA_INIT_SUBSTEP( BInitCommunityMarketRemaps( pKVCommunityMarketRemaps, pVecErrors ) );

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:	Initializes the "game_info" section of the schema
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitGameInfo( KeyValues *pKVGameInfo, CUtlVector<CUtlString> *pVecErrors )
{
	m_unFirstValidClass = pKVGameInfo->GetInt( "first_valid_class", 0 );
	m_unLastValidClass = pKVGameInfo->GetInt( "last_valid_class", 0 );
	SCHEMA_INIT_CHECK( 0 < m_unFirstValidClass, "First valid class must be greater than 0." );
	SCHEMA_INIT_CHECK( m_unFirstValidClass <= m_unLastValidClass, "First valid class must be less than or equal to last valid class." );
	m_unAccoutClassIndex = pKVGameInfo->GetInt( "account_class_index", 0 );
	SCHEMA_INIT_CHECK( m_unAccoutClassIndex > m_unLastValidClass, "Account class index must be greater than 'last_valid_class'" );

	m_unFirstValidClassItemSlot = pKVGameInfo->GetInt( "first_valid_item_slot", INVALID_EQUIPPED_SLOT );
	m_unLastValidClassItemSlot = pKVGameInfo->GetInt( "last_valid_item_slot", INVALID_EQUIPPED_SLOT );
	SCHEMA_INIT_CHECK( INVALID_EQUIPPED_SLOT != m_unFirstValidClassItemSlot, "first_valid_item_slot not set!" );
	SCHEMA_INIT_CHECK( INVALID_EQUIPPED_SLOT != m_unFirstValidClassItemSlot, "last_valid_item_slot not set!" );
	SCHEMA_INIT_CHECK( m_unFirstValidClassItemSlot <= m_unLastValidClassItemSlot, "First valid item slot must be less than or equal to last valid item slot." );

	m_unFirstValidAccountItemSlot = pKVGameInfo->GetInt( "account_first_valid_item_slot", INVALID_EQUIPPED_SLOT );
	m_unLastValidAccountItemSlot  = pKVGameInfo->GetInt( "account_last_valid_item_slot", INVALID_EQUIPPED_SLOT );
	SCHEMA_INIT_CHECK( INVALID_EQUIPPED_SLOT != m_unFirstValidAccountItemSlot, "account_first_valid_item_slot not set!" );
	SCHEMA_INIT_CHECK( INVALID_EQUIPPED_SLOT != m_unLastValidAccountItemSlot, "account_last_valid_item_slot not set!" );
	SCHEMA_INIT_CHECK( m_unFirstValidAccountItemSlot <= m_unLastValidAccountItemSlot, "First vlid account item slot must be less than or equal to the last valid account item slot." );

	m_unNumItemPresets = pKVGameInfo->GetInt( "num_item_presets", -1 );
	SCHEMA_INIT_CHECK( (uint32)-1 != m_unNumItemPresets, "num_item_presets not set!" );

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitAttributeTypes( CUtlVector<CUtlString> *pVecErrors )
{
	FOR_EACH_VEC( m_vecAttributeTypes, i )
	{
		delete m_vecAttributeTypes[i].m_pAttrType;
	}
	m_vecAttributeTypes.Purge();

	m_vecAttributeTypes.AddToTail( attr_type_t( NULL,										new CSchemaAttributeType_Default ) );
	m_vecAttributeTypes.AddToTail( attr_type_t( "float",									new CSchemaAttributeType_Float ) );
	m_vecAttributeTypes.AddToTail( attr_type_t( "uint64",									new CSchemaAttributeType_UInt64 ) );
	m_vecAttributeTypes.AddToTail( attr_type_t( "string",									new CSchemaAttributeType_String ) );
	m_vecAttributeTypes.AddToTail( attr_type_t( "dynamic_recipe_component_defined_item",	new CSchemaAttributeType_DynamicRecipeComponentDefinedItem ) );
	m_vecAttributeTypes.AddToTail( attr_type_t( "item_slot_criteria",						new CSchemaAttributeType_ItemSlotCriteria ) );
	m_vecAttributeTypes.AddToTail( attr_type_t( "item_placement",							new CSchemaAttributeType_WorldItemPlacement ) );

	// Make sure that all attribute types specified have the item ID in the 0th column. We use this
	// when loading items to map between item IDs and the attributes they own.
	FOR_EACH_VEC( m_vecAttributeTypes, i )
	{
#ifdef GC_DLL
		const CColumnSet& cs = m_vecAttributeTypes[i].m_pAttrType->GetFullColumnSet();

		SCHEMA_INIT_CHECK( cs.GetColumnCount() >= 2, "BInitAttributeTypes(): '%s' has invalid column count.\n", cs.GetRecordInfo()->GetName() );

		const CColumnInfo& Column0 = cs.GetColumnInfo( 0 );
		SCHEMA_INIT_CHECK( Column0.GetType() == k_EGCSQLType_int64, "BInitAttributeTypes(): '%s' column 0 has invalid data type %u.\n", cs.GetRecordInfo()->GetName(), Column0.GetType() );
		SCHEMA_INIT_CHECK( Column0.GetName() && !V_stricmp( Column0.GetName(), "ItemID" ), "BInitAttributeTypes(): '%s' has invalid name '%s'.\n", cs.GetRecordInfo()->GetName(), Column0.GetName() ? Column0.GetName() : "[null]" );
		SCHEMA_INIT_CHECK( Column0.BIsPrimaryKey(), "BInitAttributeTypes(): '%s' has an item ID column that isn't in the PK.\n", cs.GetRecordInfo()->GetName() );

		const CColumnInfo& Column1 = cs.GetColumnInfo( 1 );
		SCHEMA_INIT_CHECK( Column1.GetType() == k_EGCSQLType_int16, "BInitAttributeTypes(): '%s' column 1 has invalid data type %u.\n", cs.GetRecordInfo()->GetName(), Column0.GetType() );
		SCHEMA_INIT_CHECK( Column1.GetName() && !V_stricmp( Column1.GetName(), "AttrDefIndex" ), "BInitAttributeTypes(): '%s' has invalid name '%s'.\n", cs.GetRecordInfo()->GetName(), Column1.GetName() ? Column1.GetName() : "[null]" );

		// Make sure two different attribute types don't point to the same DB table. There's nothing
		// technically that would prevent this from working, but right now the way we load from the
		// DB would make this super-inefficient so we'd want to fix that code if we are rolling content
		// that would hit this error.
		for ( int j = i + 1; j < m_vecAttributeTypes.Count(); j++ )
		{
			SCHEMA_INIT_CHECK( cs.GetRecordInfo() != m_vecAttributeTypes[j].m_pAttrType->GetFullColumnSet().GetRecordInfo(),
				"BInitAttributeTypes(): multiple attribute types reference the same table '%s'.\n", cs.GetRecordInfo()->GetName() );
		}
#endif // GC_DLL
	}

	return SCHEMA_INIT_SUCCESS();
}

#ifdef GC_DLL
//-----------------------------------------------------------------------------
// Purpose:	Initializes the "periodic_score_accumulation" section of the schema
//-----------------------------------------------------------------------------
struct periodic_score_event_lookup_entry_t { const char *m_pszName; eEconPeriodicScoreEvents m_eValue; bool m_bGCUpdateOnly; };
static const periodic_score_event_lookup_entry_t sPeriodicScoreEvents[] =
{
	{ "gifts_distributed",				kPeriodicScoreEvent_GiftsDistributed,		true },
	{ "duels_won",						kPeriodicScoreEvent_DuelsWon,				true },
	{ "map_stamps_purchased",			kPeriodicScoreEvent_MapStampsPurchased,		true },
};

struct periodic_score_duration_lookup_entry_t { const char *m_pszName; uint32 m_unValue; };
static const periodic_score_duration_lookup_entry_t sPeriodicScoreDurations[] =
{
	{ "disabled",						0 },
	{ "hourly",							60 * 60 },
	{ "daily",							60 * 60 * 24 },
	{ "weekly",							60 * 60 * 24 * 7 },
	{ "monthly",						60 * 60 * 24 * 7 * 4 },			// four weeks, not necessarily a month boundary
};

template < typename search_entry_type, int search_entry_array_size >
static bool LookupValueFromString( const search_entry_type(&searchArray)[search_entry_array_size], const char *pszSearch, search_entry_type *out_pResult )
{
	Assert( out_pResult );

	for ( int i = 0; i < search_entry_array_size; i++ )
	{
		if ( !V_stricmp( pszSearch, searchArray[i].m_pszName ) )
		{
			*out_pResult = searchArray[i];
			return true;
		}
	}

	return false;
}	

bool CEconItemSchema::BInitPeriodicScoring( KeyValues *pKVPeriodicScoring, CUtlVector<CUtlString> *pVecErrors )
{
	FOR_EACH_TRUE_SUBKEY( pKVPeriodicScoring, pKVScoreType )
	{
		int index = Q_atoi( pKVScoreType->GetName() );
		SCHEMA_INIT_CHECK( index == m_vecPeriodicScoreTypes.Count(), "Invalid or out-of-order periodic score type '%s'", pKVScoreType->GetName() );

		periodic_score_t PeriodicScore;

		// Reward item definition.
		const char *pszRewardItemDefName = pKVScoreType->GetString( "reward_item_def_name", NULL );
		PeriodicScore.m_pRewardItemDefinition = pszRewardItemDefName ? GetItemDefinitionByName( pszRewardItemDefName ) : NULL;
		SCHEMA_INIT_CHECK( PeriodicScore.m_pRewardItemDefinition, "Periodic score type '%s' missing reward item definition name", pKVScoreType->GetName() );

		// Event type via string lookup.
		const char *pszEventName = pKVScoreType->GetString( "event", "" );
		{
			periodic_score_event_lookup_entry_t EventEntry;
			SCHEMA_INIT_CHECK( LookupValueFromString( sPeriodicScoreEvents, pszEventName, &EventEntry ),
							   "Periodic score type '%s' could not find event name '%s'", pKVScoreType->GetName(), pszEventName );
			PeriodicScore.m_eEventType = EventEntry.m_eValue;

			// Note: other parts of the code assume that the event type is associated with the GC-only updatability flag.)
			PeriodicScore.m_bGCUpdateOnly = EventEntry.m_bGCUpdateOnly;
		}

		// Time period via string lookup.
		{
			const char *pszTimePeriodName = pKVScoreType->GetString( "time_period", "" );
			periodic_score_duration_lookup_entry_t DurationEntry;
			SCHEMA_INIT_CHECK( LookupValueFromString( sPeriodicScoreDurations, pszTimePeriodName, &DurationEntry ),
							   "Periodic score type '%s' could not find time period name '%s'", pKVScoreType->GetName(), pszEventName );
			PeriodicScore.m_unTimePeriodLengthInSeconds = DurationEntry.m_unValue;
		}

		// Alternate time period specified for use in internal Steam?
		if ( GGCHost()->GetUniverse() != k_EUniversePublic )
		{
			const char *pszInternalTimePeriodName = pKVScoreType->GetString( "time_period_internal", NULL );
			if ( pszInternalTimePeriodName )
			{
				periodic_score_duration_lookup_entry_t InternalDurationEntry;
				SCHEMA_INIT_CHECK( LookupValueFromString( sPeriodicScoreDurations, pszInternalTimePeriodName, &InternalDurationEntry ),
								   "Periodic score type '%s' could not find internal time period name '%s'", pKVScoreType->GetName(), pszEventName );
				PeriodicScore.m_unTimePeriodLengthInSeconds = InternalDurationEntry.m_unValue;
			}
		}

		m_vecPeriodicScoreTypes.AddToTail( PeriodicScore );
	}

	return SCHEMA_INIT_SUCCESS();
}
#endif // GC_DLL

//-----------------------------------------------------------------------------
// Purpose:	Initializes the "prefabs" section of the schema
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitDefinitionPrefabs( KeyValues *pKVPrefabs, CUtlVector<CUtlString> *pVecErrors )
{
	FOR_EACH_TRUE_SUBKEY( pKVPrefabs, pKVPrefab )
	{
		const char *pszPrefabName = pKVPrefab->GetName();

		int nMapIndex = m_mapDefinitionPrefabs.Find( pszPrefabName );

		// Make sure the item index is correct because we use this index as a reference
		SCHEMA_INIT_CHECK( 
			!m_mapDefinitionPrefabs.IsValidIndex( nMapIndex ),
			"Duplicate prefab name (%s)", pszPrefabName );

		m_mapDefinitionPrefabs.Insert( pszPrefabName, pKVPrefab->MakeCopy() );
	}

	return SCHEMA_INIT_SUCCESS();
}


//-----------------------------------------------------------------------------
// Purpose:	Initializes the Item Series section of the schema
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitItemSeries( KeyValues *pKVSeries, CUtlVector<CUtlString> *pVecErrors )
{
	// initialize the item definitions
	if ( NULL != pKVSeries)
	{
		FOR_EACH_TRUE_SUBKEY( pKVSeries, pKVItem )
		{
			int nSeriesIndex = pKVItem->GetInt( "value" );
			int nMapIndex = m_mapItemSeries.Find( nSeriesIndex );

			// Make sure the item index is correct because we use this index as a reference
			SCHEMA_INIT_CHECK(
				!m_mapItemSeries.IsValidIndex( nMapIndex ),
				"Duplicate item series value (%d)", nSeriesIndex );

			nMapIndex = m_mapItemSeries.Insert( nMapIndex );
			SCHEMA_INIT_SUBSTEP( m_mapItemSeries[nMapIndex].BInitFromKV( pKVItem, pVecErrors ) );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:	Initializes the rarity section of the schema
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitRarities( KeyValues *pKVRarities, KeyValues *pKVRarityWeights, CUtlVector<CUtlString> *pVecErrors )
{
	// initialize the item definitions
	if ( NULL != pKVRarities )
	{
		FOR_EACH_TRUE_SUBKEY( pKVRarities, pKVRarity )
		{
			int nRarityIndex = pKVRarity->GetInt( "value" );
			int nMapIndex = m_mapRarities.Find( nRarityIndex );

			// Make sure the item index is correct because we use this index as a reference
			SCHEMA_INIT_CHECK(
				!m_mapRarities.IsValidIndex( nMapIndex ),
				"Duplicate rarity value (%d)", nRarityIndex );

			nMapIndex = m_mapRarities.Insert( nRarityIndex );
			SCHEMA_INIT_SUBSTEP( m_mapRarities[nMapIndex].BInitFromKV( pKVRarity, pKVRarityWeights, *this, pVecErrors ) );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:	Initializes the qualities section of the schema
// Input:	pKVQualities - The qualities section of the KeyValues 
//				representation of the schema
//			pVecErrors - An optional vector that will contain error messages if 
//				the init fails.
// Output:	True if initialization succeeded, false otherwise
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitQualities( KeyValues *pKVQualities, CUtlVector<CUtlString> *pVecErrors )
{
	// initialize the item definitions
	if ( NULL != pKVQualities )
	{
		FOR_EACH_TRUE_SUBKEY( pKVQualities, pKVQuality )
		{
			int nQualityIndex = pKVQuality->GetInt( "value" );
			int nMapIndex = m_mapQualities.Find( nQualityIndex );

			// Make sure the item index is correct because we use this index as a reference
			SCHEMA_INIT_CHECK( 
				!m_mapQualities.IsValidIndex( nMapIndex ),
				"Duplicate quality value (%d)", nQualityIndex );

			nMapIndex = m_mapQualities.Insert( nQualityIndex );
			SCHEMA_INIT_SUBSTEP( m_mapQualities[nMapIndex].BInitFromKV( pKVQuality, pVecErrors ) );
		}
	}

	// Check the integrity of the quality definitions

	// Check for duplicate quality names
	CUtlRBTree<const char *> rbQualityNames( CaselessStringLessThan );
	rbQualityNames.EnsureCapacity( m_mapQualities.Count() );
	FOR_EACH_MAP_FAST( m_mapQualities, i )
	{
		int iIndex = rbQualityNames.Find( m_mapQualities[i].GetName() );
		SCHEMA_INIT_CHECK( 
			!rbQualityNames.IsValidIndex( iIndex ),
			"Quality definition %d: Duplicate quality name %s", m_mapQualities[i].GetDBValue(), m_mapQualities[i].GetName() );

		if( !rbQualityNames.IsValidIndex( iIndex ) )
			rbQualityNames.Insert( m_mapQualities[i].GetName() );
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitColors( KeyValues *pKVColors, CUtlVector<CUtlString> *pVecErrors )
{
	// initialize the color definitions
	if ( NULL != pKVColors )
	{
		FOR_EACH_TRUE_SUBKEY( pKVColors, pKVColor )
		{
			CEconColorDefinition *pNewColorDef = new CEconColorDefinition;

			SCHEMA_INIT_SUBSTEP( pNewColorDef->BInitFromKV( pKVColor, pVecErrors ) );
			m_vecColorDefs.AddToTail( pNewColorDef );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CEconItemSchema::GetEquipRegionIndexByName( const char *pRegionName ) const
{
	FOR_EACH_VEC( m_vecEquipRegionsList, i )
	{
		const char *szEntryRegionName = m_vecEquipRegionsList[i].m_sName.Get();
		if ( !V_stricmp( szEntryRegionName, pRegionName ) )
			return i;
	}

	return -1;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
equip_region_mask_t CEconItemSchema::GetEquipRegionBitMaskByName( const char *pRegionName ) const
{
	int iRegionIndex = GetEquipRegionIndexByName( pRegionName );
	if ( !m_vecEquipRegionsList.IsValidIndex( iRegionIndex ) )
		return 0;

	equip_region_mask_t unRegionMask = 1 << m_vecEquipRegionsList[iRegionIndex].m_unBitIndex;
	Assert( unRegionMask > 0 );

	return unRegionMask;
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
void CEconItemSchema::SetEquipRegionConflict( int iRegion, unsigned int unBit )
{
	Assert( m_vecEquipRegionsList.IsValidIndex( iRegion ) );

	equip_region_mask_t unRegionMask = 1 << unBit;
	Assert( unRegionMask > 0 );

	m_vecEquipRegionsList[iRegion].m_unMask |= unRegionMask;
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
equip_region_mask_t CEconItemSchema::GetEquipRegionMaskByName( const char *pRegionName ) const
{
	int iRegionIdx = GetEquipRegionIndexByName( pRegionName );
	if ( iRegionIdx < 0 )
		return 0;

	return m_vecEquipRegionsList[iRegionIdx].m_unMask;
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
void CEconItemSchema::AssignDefaultBodygroupState( const char *pszBodygroupName, int iValue )
{
	// Flip the value passed in -- if we specify in the schema that a region should be off, we assume that it's
	// on by default.
	// actually the schemas are all authored assuming that the default is 0, so let's use that
	int iDefaultValue = 0; //iValue == 0 ? 1 : 0;

	// Make sure that we're constantly reinitializing our default value to the same default value. This is sort
	// of dumb but it works for everything we've got now. In the event that conflicts start cropping up it would
	// be easy enough to make a new schema section.
	int iIndex = m_mapDefaultBodygroupState.Find( pszBodygroupName );
	if ( (m_mapDefaultBodygroupState.IsValidIndex( iIndex ) && m_mapDefaultBodygroupState[iIndex] != iDefaultValue) ||
		 (iValue < 0 || iValue > 1) )
	{
		EmitWarning( SPEW_GC, 4, "Unable to get accurate read on whether bodygroup '%s' is enabled or disabled by default. (The schema is fine, but the code is confused and could stand to be made smarter.)\n", pszBodygroupName );
	}

	if ( !m_mapDefaultBodygroupState.IsValidIndex( iIndex ) )
	{
		m_mapDefaultBodygroupState.Insert( pszBodygroupName, iDefaultValue );
	}
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitEquipRegions( KeyValues *pKVEquipRegions, CUtlVector<CUtlString> *pVecErrors )
{
	CUtlVector<const char *> vecNames;

	FOR_EACH_SUBKEY( pKVEquipRegions, pKVRegion )
	{
		const char *pRegionKeyName = pKVRegion->GetName();

		vecNames.Purge();

		// The "shared" name is special for equip regions -- it means that all of the sub-regions specified
		// will use the same bit to store equipped-or-not data, but that one bit can be accessed by a whole
		// bunch of different names. This is useful in TF where different classes have different regions, but
		// those regions cannot possibly conflict with each other. For example, "scout_backpack" cannot possibly
		// overlap with "pyro_shoulder" because they can't even be equipped on the same character.
		if ( pRegionKeyName && !Q_stricmp( pRegionKeyName, "shared" ) )
		{
			FOR_EACH_SUBKEY( pKVRegion, pKVSharedRegionName )
			{
				vecNames.AddToTail( pKVSharedRegionName->GetName() );
			}
		}
		// We have a standard name -- this one entry is its own equip region.
		else
		{
			vecNames.AddToTail( pRegionKeyName );
		}

		// What bit will this equip region use to mask against conflicts? If we don't have any equip regions
		// at all, we'll use the base bit, otherwise we just grab one higher than whatever we used last.
		unsigned int unNewBitIndex = m_vecEquipRegionsList.Count() <= 0 ? 0 : m_vecEquipRegionsList.Tail().m_unBitIndex + 1;
		
		FOR_EACH_VEC( vecNames, i )
		{
			const char *pRegionName = vecNames[i];

			// Make sure this name is unique.
			if ( GetEquipRegionIndexByName( pRegionName ) >= 0 )
			{
				pVecErrors->AddToTail( CFmtStr( "Duplicate equip region named \"%s\".", pRegionName ).Access() );
				continue;
			}

			// Make a new region.
			EquipRegion newEquipRegion;
			newEquipRegion.m_sName		= pRegionName;
			newEquipRegion.m_unMask		= 0;				// we'll update this mask later
			newEquipRegion.m_unBitIndex	= unNewBitIndex;

			int iIdx = m_vecEquipRegionsList.AddToTail( newEquipRegion );

			// Tag this region to conflict with itself so that if nothing else two items in the same
			// region can't equip over each other.
			SetEquipRegionConflict( iIdx, unNewBitIndex );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitEquipRegionConflicts( KeyValues *pKVEquipRegionConflicts, CUtlVector<CUtlString> *pVecErrors )
{
	FOR_EACH_TRUE_SUBKEY( pKVEquipRegionConflicts, pKVConflict )
	{
		// What region is the base of this conflict?
		const char *pRegionName = pKVConflict->GetName();
		int iRegionIdx = GetEquipRegionIndexByName( pRegionName );
		if ( iRegionIdx < 0 )
		{
			pVecErrors->AddToTail( CFmtStr( "Unable to find base equip region named \"%s\" for conflicts.", pRegionName ).Access() );
			continue;
		}

		FOR_EACH_SUBKEY( pKVConflict, pKVConflictOther )
		{
			const char *pOtherRegionName = pKVConflictOther->GetName();
			int iOtherRegionIdx = GetEquipRegionIndexByName( pOtherRegionName );
			if ( iOtherRegionIdx < 0 )
			{
				pVecErrors->AddToTail( CFmtStr( "Unable to find other equip region named \"%s\" for conflicts.", pOtherRegionName ).Access() );
				continue;
			}

			SetEquipRegionConflict( iRegionIdx,		 m_vecEquipRegionsList[iOtherRegionIdx].m_unBitIndex );
			SetEquipRegionConflict( iOtherRegionIdx, m_vecEquipRegionsList[iRegionIdx].m_unBitIndex );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:	Initializes the attributes section of the schema
// Input:	pKVAttributes - The attributes section of the KeyValues 
//				representation of the schema
//			pVecErrors - An optional vector that will contain error messages if 
//				the init fails.
// Output:	True if initialization succeeded, false otherwise
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitAttributes( KeyValues *pKVAttributes, CUtlVector<CUtlString> *pVecErrors )
{
	// Initialize the attribute definitions
	FOR_EACH_TRUE_SUBKEY( pKVAttributes, pKVAttribute )
	{
		int nAttrIndex = Q_atoi( pKVAttribute->GetName() );
		int nMapIndex = m_mapAttributes.Find( nAttrIndex );

		// Make sure the index is positive
		SCHEMA_INIT_CHECK( 
			nAttrIndex >= 0,
			"Attribute definition index %d must be greater than or equal to zero", nAttrIndex );

		// Make sure the attribute index is not repeated
		SCHEMA_INIT_CHECK( 
			!m_mapAttributes.IsValidIndex( nMapIndex ),
			"Duplicate attribute definition index (%d)", nAttrIndex );

		nMapIndex = m_mapAttributes.Insert( nAttrIndex );

		SCHEMA_INIT_SUBSTEP( m_mapAttributes[nMapIndex].BInitFromKV( pKVAttribute, pVecErrors ) );
	}

	// Check the integrity of the attribute definitions

	// Check for duplicate attribute definition names
	CUtlRBTree<const char *> rbAttributeNames( CaselessStringLessThan );
	rbAttributeNames.EnsureCapacity( m_mapAttributes.Count() );
	FOR_EACH_MAP_FAST( m_mapAttributes, i )
	{
		int iIndex = rbAttributeNames.Find( m_mapAttributes[i].GetDefinitionName() );
		SCHEMA_INIT_CHECK( 
			!rbAttributeNames.IsValidIndex( iIndex ),
			"Attribute definition %d: Duplicate name \"%s\"", m_mapAttributes.Key( i ), m_mapAttributes[i].GetDefinitionName() );
		if( !rbAttributeNames.IsValidIndex( iIndex ) )
			rbAttributeNames.Insert( m_mapAttributes[i].GetDefinitionName() );
	}

	return SCHEMA_INIT_SUCCESS();
}


//-----------------------------------------------------------------------------
// Purpose:	Initializes the items section of the schema
// Input:	pKVItems - The items section of the KeyValues 
//				representation of the schema
//			pVecErrors - An optional vector that will contain error messages if 
//				the init fails.
// Output:	True if initialization succeeded, false otherwise
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitItems( KeyValues *pKVItems, CUtlVector<CUtlString> *pVecErrors )
{
	m_mapItems.PurgeAndDeleteElements();
	m_mapItemsSorted.Purge();
	m_mapToolsItems.Purge();
	m_mapBaseItems.Purge();
	m_vecBundles.Purge();
	m_mapQuestObjectives.PurgeAndDeleteElements();
	m_vecItemCollectionCrates.Purge();

#if defined(CLIENT_DLL) || defined(GAME_DLL)
	if ( m_pDefaultItemDefinition )
	{
		delete m_pDefaultItemDefinition;
		m_pDefaultItemDefinition = NULL;
	}
#endif

	// initialize the item definitions
	if ( NULL != pKVItems )
	{
		FOR_EACH_TRUE_SUBKEY( pKVItems, pKVItem )
		{
			if ( Q_stricmp( pKVItem->GetName(), "default" ) == 0 )
			{
#if defined(CLIENT_DLL) || defined(GAME_DLL)
				SCHEMA_INIT_CHECK(
					m_pDefaultItemDefinition == NULL,
					"Duplicate 'default' item definition." );

				m_pDefaultItemDefinition = CreateEconItemDefinition();
				SCHEMA_INIT_SUBSTEP( m_pDefaultItemDefinition->BInitFromKV( pKVItem, pVecErrors ) );
#endif
			}
			else
			{
				int nItemIndex = Q_atoi( pKVItem->GetName() );
				int nMapIndex = m_mapItems.Find( nItemIndex );

				// Make sure the item index is correct because we use this index as a reference
				SCHEMA_INIT_CHECK( 
					!m_mapItems.IsValidIndex( nMapIndex ),
					"Duplicate item definition (%d)", nItemIndex );

				// Check to make sure the index is positive
				SCHEMA_INIT_CHECK( 
					nItemIndex >= 0,
					"Item definition index %d must be greater than or equal to zero", nItemIndex );

				CEconItemDefinition *pItemDef = CreateEconItemDefinition();
				nMapIndex = m_mapItems.Insert( nItemIndex, pItemDef );
				m_mapItemsSorted.Insert( nItemIndex, pItemDef );
				SCHEMA_INIT_SUBSTEP( m_mapItems[nMapIndex]->BInitFromKV( pKVItem, pVecErrors ) );

				// Cache off Tools references
				if ( pItemDef->IsTool() )
				{
					m_mapToolsItems.Insert( nItemIndex, pItemDef );
				}

				if ( pItemDef->IsBaseItem() )
				{
					m_mapBaseItems.Insert( nItemIndex, pItemDef );
				}

				// Cache off bundles for the link phase below.
				if ( pItemDef->IsBundle() )
				{
					// Cache off the item def for the bundle, since we'll need both the bundle info and the item def index later.
					m_vecBundles.AddToTail( pItemDef );

					// If the bundle is a pack bundle, mark all the contained items as pack items / link to the owning pack bundle
					if ( pItemDef->IsPackBundle() )
					{
						const bundleinfo_t *pBundleInfo = pItemDef->GetBundleInfo();
						FOR_EACH_VEC( pBundleInfo->vecItemDefs, iCurItem )
						{
							CEconItemDefinition *pCurItemDef = pBundleInfo->vecItemDefs[ iCurItem ];
							SCHEMA_INIT_CHECK( NULL == pCurItemDef->m_pOwningPackBundle, "Pack item \"%s\" included in more than one pack bundle - not allowed!", pCurItemDef->GetDefinitionName() );
							pCurItemDef->m_pOwningPackBundle = pItemDef;
						}
					}
				}

				static CSchemaAttributeDefHandle pAttrDef_ContainsCollection( "contains collection" );
				if ( pAttrDef_ContainsCollection )
				{
					FOR_EACH_VEC( pItemDef->GetStaticAttributes(), i )
					{
						const static_attrib_t& staticAttrib = pItemDef->GetStaticAttributes()[i];
						if ( staticAttrib.iDefIndex == pAttrDef_ContainsCollection->GetDefinitionIndex() )
						{
							// Add to collection crate list
							m_vecItemCollectionCrates.AddToTail( pItemDef->GetDefinitionIndex() );
						}
					}
				}				
			}
		}
	}

	// Check the integrity of the item definitions
	CUtlRBTree<const char *> rbItemNames( CaselessStringLessThan );
	rbItemNames.EnsureCapacity( m_mapItems.Count() );
	FOR_EACH_MAP_FAST( m_mapItems, i )
	{
		CEconItemDefinition *pItemDef = m_mapItems[ i ];

		// Check for duplicate item definition names
		int iIndex = rbItemNames.Find( pItemDef->GetDefinitionName() );
		SCHEMA_INIT_CHECK( 
			!rbItemNames.IsValidIndex( iIndex ),
			"Item definition %s: Duplicate name on index %d", pItemDef->GetDefinitionName(), m_mapItems.Key( i ) );
		if( !rbItemNames.IsValidIndex( iIndex ) )
			rbItemNames.Insert( m_mapItems[i]->GetDefinitionName() );

		// Link up armory and store mappings for the item
		SCHEMA_INIT_SUBSTEP( pItemDef->BInitItemMappings( pVecErrors ) );
	}

#ifdef DOTA
	// Go through all regular (ie non-pack) bundles and ensure that if any pack items are included, *all* pack items in the owning pack bundle are included
	FOR_EACH_VEC( m_vecBundles, iBundle )
	{
		const CEconItemDefinition *pBundleItemDef = m_vecBundles[ iBundle ];
		if ( pBundleItemDef->IsPackBundle() )
			continue;

		// Go through all items in the bundle and look for pack items
		const bundleinfo_t *pBundle = pBundleItemDef->GetBundleInfo();
		if ( pBundle )
		{
			FOR_EACH_VEC( pBundle->vecItemDefs, iContainedBundleItem )
			{
				// Get the associated pack bundle
				const CEconItemDefinition *pContainedBundleItemDef = pBundle->vecItemDefs[ iContainedBundleItem ];

				// Ignore non-pack items
				if ( !pContainedBundleItemDef || !pContainedBundleItemDef->IsPackItem() )
					continue;

				// Get the pack bundle that contains this particular pack item
				const CEconItemDefinition *pOwningPackBundleItemDef = pContainedBundleItemDef->GetOwningPackBundle();

				// Make sure all items in the owning pack bundle are in pBundleItemDef's bundle info (pBundle)
				const bundleinfo_t *pOwningPackBundle = pOwningPackBundleItemDef->GetBundleInfo();
				FOR_EACH_VEC( pOwningPackBundle->vecItemDefs, iCurPackBundleItem )
				{
					CEconItemDefinition *pCurPackBundleItem = pOwningPackBundle->vecItemDefs[ iCurPackBundleItem ];
					if ( !pBundle->vecItemDefs.HasElement( pCurPackBundleItem ) )
					{
						SCHEMA_INIT_CHECK(
							false,
							"The bundle \"%s\" contains some, but not all pack items required specified by pack bundle \"%s.\"",
							pBundleItemDef->GetDefinitionName(),
							pOwningPackBundleItemDef->GetDefinitionName()
					   );
					}
				}
			}
		}
	}
#endif

	return SCHEMA_INIT_SUCCESS();
}

#if 0 // Compiled out until some DotA changes from the item editor are brought over
//-----------------------------------------------------------------------------
// Purpose:	Delete an item definition. Moderately dangerous as cached references will become bad.
// Intended for use by the item editor.
//-----------------------------------------------------------------------------
bool CEconItemSchema::DeleteItemDefinition( int iDefIndex )
{
	m_mapItemsSorted.Remove( iDefIndex );

	int nMapIndex = m_mapItems.Find( iDefIndex );
	if ( m_mapItems.IsValidIndex( nMapIndex ) )
	{
		CEconItemDefinition* pItemDef = m_mapItems[nMapIndex];
		if ( pItemDef )
		{
			m_mapItems.RemoveAt( nMapIndex );
			delete pItemDef;
			return true;
		}
	}
	return false;
}
#endif

//-----------------------------------------------------------------------------
// Purpose:	Parses the Item Sets section.
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitItemSets( KeyValues *pKVItemSets, CUtlVector<CUtlString> *pVecErrors )
{
	m_mapItemSets.RemoveAll();

	if ( NULL != pKVItemSets )
	{
		FOR_EACH_TRUE_SUBKEY( pKVItemSets, pKVItemSet )
		{
			const char* setName = pKVItemSet->GetName();

			SCHEMA_INIT_CHECK( setName != NULL, "All itemsets must have names." );
			SCHEMA_INIT_CHECK( m_mapItemSets.Find( setName ) == m_mapItemSets.InvalidIndex(), "Duplicate itemset name (%s) found!", setName );

			int idx = m_mapItemSets.Insert( setName, new CEconItemSetDefinition );
			SCHEMA_INIT_SUBSTEP( m_mapItemSets[idx]->BInitFromKV( pKVItemSet, pVecErrors ) );
		}

		// Once we've initialized all of our item sets, loop through all of our item definitions looking
		// for pseudo set items. For example, the Festive Holy Mackerel is a different item definition from
		// the regular Holy Mackerel, but for set completion and set listing purposes, we want it to show
		// as part of the base set.
		FOR_EACH_MAP_FAST( m_mapItems, i )
		{
			CEconItemDefinition *pItemDef = m_mapItems[i];
			Assert( pItemDef );

			// Items that point to themselves are the base set items and got initialized as part of the
			// set initialization above.
			if ( pItemDef->GetSetItemRemap() == pItemDef->GetDefinitionIndex() )
				continue;

			// Which item are we stealing set information from?
			const CEconItemDefinition *pRemappedSetItemDef = GetItemDefinition( pItemDef->GetSetItemRemap() );
			AssertMsg( pRemappedSetItemDef, "Somehow got through item and set initialization but have a broken set remap item!" );

			pItemDef->SetItemSetDefinition( pRemappedSetItemDef->GetItemSetDefinition() );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
bool CEconItemSchema::BVerifyBaseItemNames( CUtlVector<CUtlString> *pVecErrors )
{
	FOR_EACH_MAP_FAST( m_mapItems, i )
	{
		CEconItemDefinition *pItemDef = m_mapItems[i];

		// get base item name
		const char* pBaseName = pItemDef->GetBaseFunctionalItemName();

		if ( !pBaseName || pBaseName[0] == '\0' )
		{
			continue;
		}
		
		// look up base item name
		SCHEMA_INIT_CHECK( GetItemDefinitionByName( pBaseName ) != NULL, "Base item name not found %s.", pBaseName );
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitItemCollections( KeyValues *pKVItemCollections, CUtlVector<CUtlString> *pVecErrors )
{
	m_mapItemCollections.Purge();

	if ( NULL != pKVItemCollections )
	{
		FOR_EACH_TRUE_SUBKEY( pKVItemCollections, pKVItemCollection )
		{
			const char* setName = pKVItemCollection->GetName();

			SCHEMA_INIT_CHECK( setName != NULL, "All item collections must have names." );
			SCHEMA_INIT_CHECK( m_mapItemCollections.Find( setName ) == m_mapItemCollections.InvalidIndex(), "Duplicate item collection name (%s) found!", setName );

			int idx = m_mapItemCollections.Insert( setName, new CEconItemCollectionDefinition );
			SCHEMA_INIT_SUBSTEP( m_mapItemCollections[idx]->BInitFromKV( pKVItemCollection, pVecErrors ) );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitCollectionReferences( CUtlVector<CUtlString> *pVecErrors )
{
	FOR_EACH_MAP_FAST( m_mapItems, i )
	{
		CEconItemDefinition *pItemDef = m_mapItems[i];
		const char *pszCollectionName = pItemDef->GetCollectionReference();
		if ( pszCollectionName )
		{
			// Find the collection
			bool bFound = false;
			FOR_EACH_MAP_FAST( m_mapItemCollections, iCollectionIndex )
			{
				const char * pszTemp = m_mapItemCollections[iCollectionIndex]->m_pszName;

				if ( !V_strcmp( pszTemp, pszCollectionName) )
				{
					bFound = true;
					pItemDef->SetItemCollectionDefinition( m_mapItemCollections[iCollectionIndex] );
					break;
				}
			}
			SCHEMA_INIT_CHECK( bFound == true, "Collection %s referenced by item %s not found", pszCollectionName, pItemDef->GetDefinitionName() );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}
//-----------------------------------------------------------------------------
const CEconItemCollectionDefinition *CEconItemSchema::GetCollectionByName( const char* pCollectionName )
{
	if ( !pCollectionName )
		return NULL;

	FOR_EACH_MAP_FAST( m_mapItemCollections, iCollectionIndex )
	{
		const char * pszTemp = m_mapItemCollections[iCollectionIndex]->m_pszName;
		if ( !V_strcmp( pszTemp, pCollectionName ) )
		{
			return m_mapItemCollections[iCollectionIndex];
		}
	}
	return NULL;
}



//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitItemPaintKitDefinitions( KeyValues *pKVItemPaintKits, CUtlVector<CUtlString> *pVecErrors )
{
	m_mapItemPaintKits.Purge();

	const char* cWhitespace = " \r\n\t"; // space, end of line, tab.
	cWhitespace; // Compiler happiness for GC build

	if ( NULL != pKVItemPaintKits )
	{
#ifdef CLIENT_DLL
		FOR_EACH_TRUE_SUBKEY( pKVItemPaintKits, pKVPaintKit )
		{
			const char* keyField = pKVPaintKit->GetName();
			SCHEMA_INIT_CHECK( keyField != NULL, "All item collections must have names." );

			if ( V_stristr( keyField, "paintkit_template" ) != NULL )
			{
				static const int cSkipLen = strlen( "paintkit_template" );
				keyField += cSkipLen;
				keyField += strspn( keyField, cWhitespace );

				bool createTmplResult = materials->AddTextureCompositorTemplate( keyField, pKVPaintKit );
				SCHEMA_INIT_CHECK( createTmplResult, "Could Not Create paintkit_template '%s'", keyField );
			}
		}

		// Do post-load validation before moving on to paintkits.
		SCHEMA_INIT_CHECK( materials->VerifyTextureCompositorTemplates(), "Paintkit template post-init validation failed." );
#endif

		// Now do all the paintkits
		FOR_EACH_TRUE_SUBKEY( pKVItemPaintKits, pKVPaintKit )
		{
			// We know the keyField is valid, it was checked above.
			const char* keyField = pKVPaintKit->GetName();

			if ( V_stristr( keyField, "paintkit_template" ) == NULL )
			{
				SCHEMA_INIT_CHECK( m_mapItemPaintKits.Find( keyField ) == m_mapItemPaintKits.InvalidIndex(), "Duplicate paint kit definition name (%s) found!", keyField );

				int idx = m_mapItemPaintKits.Insert( keyField, new CEconItemPaintKitDefinition );
				SCHEMA_INIT_SUBSTEP( m_mapItemPaintKits[ idx ]->BInitFromKV( pKVPaintKit, pVecErrors ) );
			}
		}
	}


	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitOperationDefinitions( KeyValues *pKVGameInfo, KeyValues *pKVOperationDefinitions, CUtlVector<CUtlString> *pVecErrors )
{
	m_mapOperationDefinitions.Purge();

	if ( NULL != pKVOperationDefinitions )
	{
		FOR_EACH_TRUE_SUBKEY( pKVOperationDefinitions, pKVOperation )
		{
			const char* setName = pKVOperation->GetName();
			SCHEMA_INIT_CHECK( setName != NULL, "All operations must have names." );
			SCHEMA_INIT_CHECK( m_mapOperationDefinitions.Find( setName ) == m_mapOperationDefinitions.InvalidIndex(), "Duplicate operation definition name (%s) found!", setName );

			CEconOperationDefinition *pNewOperation = new CEconOperationDefinition();
			SCHEMA_INIT_SUBSTEP( pNewOperation->BInitFromKV( pKVOperation, pVecErrors ) );

			// don't add expired operation to list
			if ( pNewOperation->IsExpired() )
			{
				delete pNewOperation;
				continue;
			}
			
			m_mapOperationDefinitions.Insert( setName, pNewOperation );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}


//-----------------------------------------------------------------------------
// Purpose:	Initializes the timed rewards section of the schema
// Input:	pKVTimedRewards - The timed_rewards section of the KeyValues 
//				representation of the schema
//			pVecErrors - An optional vector that will contain error messages if 
//				the init fails.
// Output:	True if initialization succeeded, false otherwise
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitTimedRewards( KeyValues *pKVTimedRewards, CUtlVector<CUtlString> *pVecErrors )
{
	m_vecTimedRewards.RemoveAll();

	// initialize the rewards sections
	if ( NULL != pKVTimedRewards )
	{
		FOR_EACH_TRUE_SUBKEY( pKVTimedRewards, pKVTimedReward )
		{
			int index = m_vecTimedRewards.AddToTail();
			SCHEMA_INIT_SUBSTEP( m_vecTimedRewards[index].BInitFromKV( pKVTimedReward, pVecErrors ) );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:	
//-----------------------------------------------------------------------------
const CTimedItemRewardDefinition* CEconItemSchema::GetTimedReward( eTimedRewardType type ) const
{
	if ( (int)type < m_vecTimedRewards.Count() )
	{
		return &m_vecTimedRewards[type];
	}
	return NULL;
}



//-----------------------------------------------------------------------------
// Purpose:	Initializes the loot lists section of the schema
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitLootLists( KeyValues *pKVLootLists, CUtlVector<CUtlString> *pVecErrors )
{
	if ( NULL != pKVLootLists )
	{
 		FOR_EACH_TRUE_SUBKEY( pKVLootLists, pKVLootList )
		{
			const char* pListName = pKVLootList->GetName();
			SCHEMA_INIT_SUBSTEP( BInsertLootlist( pListName, pKVLootList, pVecErrors ) );
		}
	}

	FOR_EACH_MAP_FAST( m_mapLootLists, i )
	{
		const CEconLootListDefinition *pLootList = m_mapLootLists[i];
		BVerifyLootListItemDropDates( pLootList, pVecErrors );
	}

	return SCHEMA_INIT_SUCCESS();
}
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInsertLootlist( const char *pListName, KeyValues *pKVLootList, CUtlVector<CUtlString> *pVecErrors )
{
	SCHEMA_INIT_CHECK( pListName != NULL, "All lootlists must have names." );

	if ( m_mapLootLists.Count() > 0 )
	{
		SCHEMA_INIT_CHECK( GetLootListByName( pListName ) == NULL, "Duplicate lootlist name (%s) found!", pListName );
	}

	CEconLootListDefinition *pLootList = new CEconLootListDefinition;
	SCHEMA_INIT_SUBSTEP( pLootList->BInitFromKV( pKVLootList, *this, pVecErrors ) );
	m_mapLootLists.Insert( pListName, pLootList );

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:	Initializes the revolving loot lists section of the schema
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitRevolvingLootLists( KeyValues *pKVLootLists, CUtlVector<CUtlString> *pVecErrors )
{
	m_mapRevolvingLootLists.RemoveAll();

	if ( NULL != pKVLootLists )
	{
		FOR_EACH_SUBKEY( pKVLootLists, pKVList )
		{
			int iListIdx = pKVList->GetInt();
			const char* strListName = pKVList->GetName();
			m_mapRevolvingLootLists.Insert( iListIdx, strListName );
		}
	}

 	FOR_EACH_MAP_FAST( m_mapRevolvingLootLists, i )
	{
		const CEconLootListDefinition* pLootList = GetLootListByName(m_mapRevolvingLootLists[i]);
		BVerifyLootListItemDropDates( pLootList, pVecErrors );
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:	Create and return a new quest objective definition.  Verify that
//			a definition with the same name doesnt alreay exist.
//-----------------------------------------------------------------------------
bool CEconItemSchema::AddQuestObjective( const CQuestObjectiveDefinition **ppQuestObjective, KeyValues *pKVObjective, CUtlVector<CUtlString> *pVecErrors )
{
	// These need to be unique
	int nDefIndex = pKVObjective->GetInt( "defindex", -1 );
	SCHEMA_INIT_CHECK( nDefIndex != -1, "Missing defindex for quest objective" );
	// Verify defindex is unique
	auto nMapIndex = m_mapQuestObjectives.Find( nDefIndex );
	SCHEMA_INIT_CHECK( nMapIndex == m_mapQuestObjectives.InvalidIndex(), "Multiple quest objectives with defindex: %d", nDefIndex );
	// Create the quest def
	nMapIndex = m_mapQuestObjectives.Insert( nDefIndex );
	m_mapQuestObjectives[ nMapIndex ] = CreateQuestDefinition();
	// Init
	SCHEMA_INIT_SUBSTEP( m_mapQuestObjectives[nMapIndex]->BInitFromKV( pKVObjective, pVecErrors ) );

	if ( ppQuestObjective )
	{
		(*ppQuestObjective) = m_mapQuestObjectives[nMapIndex];
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:	Verify that the contents of visible lootlist do not have drop dates
//			associated with them.  The thinking being that we dont want to have
//			items listed that could potentially not drop, or items disappear/appear
//			in from a list.
//-----------------------------------------------------------------------------
bool CEconItemSchema::BVerifyLootListItemDropDates( const CEconLootListDefinition* pLootList, CUtlVector<CUtlString> *pVecErrors ) const
{
	if ( pLootList && pLootList->BPublicListContents() )
	{
		BRecurseiveVerifyLootListItemDropDates( pLootList, pLootList, pVecErrors );
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:	Recursively dig through all entries in the passed in lootlist to see
//			if any of the containted items have drop dates.
//-----------------------------------------------------------------------------
bool CEconItemSchema::BRecurseiveVerifyLootListItemDropDates( const CEconLootListDefinition* pLootList, const CEconLootListDefinition* pRootLootList, CUtlVector<CUtlString> *pVecErrors ) const
{
	FOR_EACH_VEC( pLootList->GetLootListContents(), j )
	{
		const CEconLootListDefinition::drop_item_t& item = pLootList->GetLootListContents()[j];
		// 0 and greater means item.  Less than 0 means nested lootlist
		if( item.m_iItemOrLootlistDef >= 0 )
		{
			const CEconItemDefinition* pItemDef = GetItemSchema()->GetItemDefinition( item.m_iItemOrLootlistDef );
			if( pItemDef )
			{
				static CSchemaAttributeDefHandle pAttribDef_StartDropDate( "start drop date" );
				static CSchemaAttributeDefHandle pAttribDef_EndDropDate( "end drop date" );

				CAttribute_String value;

				// Check for start drop date attribute on this item
				SCHEMA_INIT_CHECK( !FindAttribute( pItemDef, pAttribDef_StartDropDate, &value ),
					"Lootlist \"%s\" contains lootlist \"%s\", which contains item \"%s\", which has start drop date.", pRootLootList->GetName(), pLootList->GetName(), pItemDef->GetDefinitionName() );
				// Check for end drop date attribute on this item
				SCHEMA_INIT_CHECK( !FindAttribute( pItemDef, pAttribDef_EndDropDate, &value ),
					"Lootlist \"%s\" contains lootlist \"%s\", which contains item \"%s\", which has end drop date.", pRootLootList->GetName(), pLootList->GetName(), pItemDef->GetDefinitionName() );
			}
		}
		else
		{
			// Get the nested lootlist
			int iLLIndex = (item.m_iItemOrLootlistDef * -1) - 1;
			const CEconLootListDefinition *pNestedLootList = GetItemSchema()->GetLootListByIndex( iLLIndex );
			if ( !pNestedLootList )
				return SCHEMA_INIT_SUCCESS();

			// Dig through all of this lootlist's entries
			BRecurseiveVerifyLootListItemDropDates( pNestedLootList, pRootLootList, pVecErrors );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}


//-----------------------------------------------------------------------------
// Purpose:	Initializes the recipes section of the schema
// Input:	pKVRecipes - The recipes section of the KeyValues 
//				representation of the schema
//			pVecErrors - An optional vector that will contain error messages if 
//				the init fails.
// Output:	True if initialization succeeded, false otherwise
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitRecipes( KeyValues *pKVRecipes, CUtlVector<CUtlString> *pVecErrors )
{
	m_mapRecipes.RemoveAll();

	// initialize the rewards sections
	if ( NULL != pKVRecipes )
	{
		FOR_EACH_TRUE_SUBKEY( pKVRecipes, pKVRecipe )
		{
			int nRecipeIndex = Q_atoi( pKVRecipe->GetName() );
			int nMapIndex = m_mapRecipes.Find( nRecipeIndex );

			// Make sure the recipe index is correct because we use this index as a reference
			SCHEMA_INIT_CHECK( 
				!m_mapRecipes.IsValidIndex( nMapIndex ),
				"Duplicate recipe definition (%d)", nRecipeIndex );

			// Check to make sure the index is positive
			SCHEMA_INIT_CHECK( 
				nRecipeIndex >= 0,
				"Recipe definition index %d must be greater than or equal to zero", nRecipeIndex );

			CEconCraftingRecipeDefinition *recipeDef = CreateCraftingRecipeDefinition();
			SCHEMA_INIT_SUBSTEP( recipeDef->BInitFromKV( pKVRecipe, pVecErrors ) );

#ifdef _DEBUG
			// Sanity check in debug builds so that we know we aren't putting the same recipe in
			// multiple times.
			FOR_EACH_MAP_FAST( m_mapRecipes, i )
			{
				Assert( i != nRecipeIndex );
				Assert( m_mapRecipes[i] != recipeDef );
			}
#endif // _DEBUG

			// Store this recipe.
			m_mapRecipes.Insert( nRecipeIndex, recipeDef );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}


//-----------------------------------------------------------------------------
// Purpose:	Builds the name of a achievement in the form App<ID>.<AchName>
// Input:	unAppID - native app ID
//			pchNativeAchievementName - name of the achievement in its native app
// Returns: The combined achievement name
//-----------------------------------------------------------------------------
CUtlString CEconItemSchema::ComputeAchievementName( AppId_t unAppID, const char *pchNativeAchievementName ) 
{
	return CFmtStr1024( "App%u.%s", unAppID, pchNativeAchievementName ).Access();
}


//-----------------------------------------------------------------------------
// Purpose:	Initializes the achievement rewards section of the schema
// Input:	pKVAchievementRewards - The achievement_rewards section of the KeyValues 
//				representation of the schema
//			pVecErrors - An optional vector that will contain error messages if 
//				the init fails.
// Output:	True if initialization succeeded, false otherwise
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitAchievementRewards( KeyValues *pKVAchievementRewards, CUtlVector<CUtlString> *pVecErrors )
{
	m_dictAchievementRewards.RemoveAll();
	m_mapAchievementRewardsByData.PurgeAndDeleteElements();

	// initialize the rewards sections
	if ( NULL != pKVAchievementRewards )
	{
		FOR_EACH_SUBKEY( pKVAchievementRewards, pKVReward )
		{
			AchievementAward_t award;
			if( pKVReward->GetDataType() == KeyValues::TYPE_NONE )
			{
				int32 nItemIndex = pKVReward->GetInt( "DefIndex", -1 );
				if( nItemIndex != -1 )
				{
					award.m_vecDefIndex.AddToTail( (uint16)nItemIndex );			
				}
				else
				{
					KeyValues *pkvItems = pKVReward->FindKey( "Items" );
					SCHEMA_INIT_CHECK( 
						pkvItems != NULL,
						"Complex achievement %s must have an Items key or a DefIndex field", pKVReward->GetName() );
					if( !pkvItems )
					{
						continue;
					}

					FOR_EACH_VALUE( pkvItems, pkvItem )
					{
						award.m_vecDefIndex.AddToTail( (uint16)Q_atoi( pkvItem->GetName() ) );
					}
				}

			}
			else
			{
				award.m_vecDefIndex.AddToTail( (uint16)pKVReward->GetInt("", -1 ) );
			} 
		
			// make sure all the item types are valid
			bool bFoundAllItems = true;
			FOR_EACH_VEC( award.m_vecDefIndex, nItem )
			{
				const CEconItemDefinition *pDefn = GetItemDefinition( award.m_vecDefIndex[nItem] );
				SCHEMA_INIT_CHECK( 
					pDefn != NULL,
					"Item definition index %d in achievement reward %s was not found", award.m_vecDefIndex[nItem], pKVReward->GetName() );
				if( !pDefn )
				{
					bFoundAllItems = false;
				}
			}
			if( !bFoundAllItems )
				continue;

			SCHEMA_INIT_CHECK( 
				award.m_vecDefIndex.Count() > 0,
				"Achievement reward %s has no items!", pKVReward->GetName() );
			if( award.m_vecDefIndex.Count() == 0 )
				continue;

#ifdef GC_DLL
			award.m_unSourceAppId = GGCBase()->GetAppID();
#else		
			award.m_unSourceAppId = k_uAppIdInvalid;
#endif		
			if( pKVReward->GetDataType() == KeyValues::TYPE_NONE )
			{
				// cross game achievement
				award.m_sNativeName = pKVReward->GetName();
				award.m_unAuditData = pKVReward->GetInt( "AuditData", 0 );
				award.m_unSourceAppId = pKVReward->GetInt( "SourceAppID", award.m_unSourceAppId );
			}
			else
			{
				award.m_sNativeName = pKVReward->GetName();
				award.m_unAuditData = 0;
			}


#ifdef GC_DLL
			// Check to make sure the audit data is valid
			SCHEMA_INIT_CHECK( 
				award.m_unSourceAppId >= 0,
				"Source App ID %d in achievement reward %s must be valid", award.m_unSourceAppId, pKVReward->GetName() );
			if( award.m_unSourceAppId == k_uAppIdInvalid )
				continue;

			if( !GGCGameBase()->BYieldingLoadStats( award.m_unSourceAppId ) )
			{
				// this will often fail in a dev universe
				if( GGCHost()->GetUniverse() != k_EUniverseDev )
				{
					SCHEMA_INIT_CHECK( 
						false,
						"Unable to load stats schema for cross-game achievement %s for app %d", pKVReward->GetName(), award.m_unSourceAppId );
				}
				continue;
			}

			const CGCStatsSchema *pStatsSchema = GGCGameBase()->GetStatsSchema( award.m_unSourceAppId );
			if( !pStatsSchema )
			{
				SCHEMA_INIT_CHECK( 
					false,
					"Unable to retrieve stats schema for cross-game achievement %s for app %d", pKVReward->GetName(), award.m_unSourceAppId );
				continue;
			}

			if( award.m_unAuditData == 0 )
			{
				uint16 usStatID, usBitID;
				if( !pStatsSchema->BGetAchievementBit( award.m_sNativeName, &usStatID, &usBitID ) )
				{
					SCHEMA_INIT_CHECK( 
						false,
						"Unable to find achievement %s for app %d", award.m_sNativeName.Get(), award.m_unSourceAppId );
					continue;
				}

				award.m_unAuditData = ( usStatID <<16 ) | usBitID;
			}
#endif // GC_DLL


			AchievementAward_t *pAward = new AchievementAward_t;
			*pAward = award;

			m_dictAchievementRewards.Insert( ComputeAchievementName( pAward->m_unSourceAppId, pAward->m_sNativeName ), pAward );
			m_mapAchievementRewardsByData.Insert( pAward->m_unAuditData, pAward );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}


#ifdef GC_DLL
bool CEconItemSchema::BInitRandomAttributeTemplates( KeyValues *pKVRandomAttributeTemplates, CUtlVector<CUtlString> *pVecErrors )
{
	m_dictRandomAttributeTemplates.PurgeAndDeleteElements();

	FOR_EACH_TRUE_SUBKEY( pKVRandomAttributeTemplates, pKVAttributeTemplate )
	{
		const char *pszAttrName = pKVAttributeTemplate->GetName();

		// try to create random attrib from template
		random_attrib_t *pRandomAttr = CreateRandomAttribute( __FUNCTION__, pKVAttributeTemplate, pVecErrors );
		SCHEMA_INIT_CHECK(
			NULL != pRandomAttr,
			CFmtStr( "%s: Failed to create random_attrib_t '%s'", __FUNCTION__, pszAttrName ) );

		m_dictRandomAttributeTemplates.Insert( pszAttrName, pRandomAttr );
	}

	return true;
}
#endif // GC_DLL


#ifdef TF_CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose: Go through all items and cache the number of concrete items in each.
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitConcreteItemCounts( CUtlVector<CUtlString> *pVecErrors )
{
	FOR_EACH_MAP_FAST( m_mapItems, i )
	{
		CEconItemDefinition *pItemDef = m_mapItems[ i ];
		pItemDef->m_unNumConcreteItems = CalculateNumberOfConcreteItems( pItemDef );
	}

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Returns the number of actual "real" items referenced by the item definition
// (i.e. items that would take up space in the inventory)
//-----------------------------------------------------------------------------
int CEconItemSchema::CalculateNumberOfConcreteItems( const CEconItemDefinition *pItemDef )
{
	AssertMsg( pItemDef, "NULL item definition!  This should not happen!" );
	if ( !pItemDef )
		return 0;

	if ( pItemDef->IsBundle() )
	{
		uint32 unNumConcreteItems = 0;
		
		const bundleinfo_t *pBundle = pItemDef->GetBundleInfo();
		Assert( pBundle );

		FOR_EACH_VEC( pBundle->vecItemDefs, i )
		{
			unNumConcreteItems += CalculateNumberOfConcreteItems( pBundle->vecItemDefs[i] );
		}

		return unNumConcreteItems;
	}

	return 1;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitSteamPackageLocalizationToken( KeyValues *pKVSteamPackages, CUtlVector<CUtlString> *pVecErrors )
{
	if ( NULL != pKVSteamPackages )
	{
		FOR_EACH_TRUE_SUBKEY( pKVSteamPackages, pKVEntry )
		{
			// Check to make sure the index is positive
			int iRawPackageId = atoi( pKVEntry->GetName() );
			SCHEMA_INIT_CHECK( 
				iRawPackageId > 0,
				"Invalid package ID %i for localization", iRawPackageId );

			// Store off our data.
			uint32 unPackageId = (uint32)iRawPackageId;
			const char *pszLocalizationToken = pKVEntry->GetString( "localization_key" );

			m_mapSteamPackageLocalizationTokens.InsertOrReplace( unPackageId, pszLocalizationToken );

		}
	}
	return SCHEMA_INIT_SUCCESS();
}
#endif // TF_CLIENT_DLL

static const char *s_particle_controlpoint_names[] =
{
	"attachment",
	"control_point_1",
	"control_point_2",
	"control_point_3",
	"control_point_4",
	"control_point_5",
	"control_point_6",
};

//-----------------------------------------------------------------------------
// Purpose:	Initializes the attribute-controlled-particle-systems section of the schema
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitAttributeControlledParticleSystems( KeyValues *pKVParticleSystems, CUtlVector<CUtlString> *pVecErrors )
{
	m_mapAttributeControlledParticleSystems.RemoveAll();
	m_vecAttributeControlledParticleSystemsCosmetics.RemoveAll();
	m_vecAttributeControlledParticleSystemsWeapons.RemoveAll();
	m_vecAttributeControlledParticleSystemsTaunts.RemoveAll();
	
	CUtlVector< int > *pVec = NULL;

	// Addictional groups we are tracking for.
	// "cosmetic_unusual_effects"
	// "weapon_unusual_effects"
	// "taunt_unusual_effects"

	if ( NULL != pKVParticleSystems )
	{
		FOR_EACH_TRUE_SUBKEY( pKVParticleSystems, pKVCategory )
		{
			// There is 3 Categories we want to track with additional info
			if ( !V_strcmp( pKVCategory->GetName(), "cosmetic_unusual_effects" ) )
			{
				pVec = &m_vecAttributeControlledParticleSystemsCosmetics;
			} 
			else if ( !V_strcmp( pKVCategory->GetName(), "weapon_unusual_effects" ) )
			{
				pVec = &m_vecAttributeControlledParticleSystemsWeapons;
			}
			else if ( !V_strcmp( pKVCategory->GetName(), "taunt_unusual_effects" ) )
			{
				pVec = &m_vecAttributeControlledParticleSystemsTaunts;
			}
			else
			{
				pVec = NULL; // reset
			}
			
			FOR_EACH_TRUE_SUBKEY( pKVCategory, pKVEntry )
			{
				int32 nItemIndex = atoi( pKVEntry->GetName() );
				// Check to make sure the index is positive
				SCHEMA_INIT_CHECK( 
					nItemIndex > 0,
					"Particle system index %d greater than zero", nItemIndex );
				if ( nItemIndex <= 0 )
					continue;
				int iIndex = m_mapAttributeControlledParticleSystems.Insert( nItemIndex );
				attachedparticlesystem_t &system = m_mapAttributeControlledParticleSystems[iIndex];
				system.pszSystemName = pKVEntry->GetString( "system", NULL );
				system.bFollowRootBone = pKVEntry->GetInt( "attach_to_rootbone", 0 ) != 0;
				system.iCustomType = 0;
				system.nSystemID = nItemIndex;
				system.fRefireTime = pKVEntry->GetFloat( "refire_time", 0.0f );
				system.bDrawInViewModel = pKVEntry->GetBool( "draw_in_viewmodel", false );
				system.bUseSuffixName = pKVEntry->GetBool( "use_suffix_name", false );
				system.bHasViewModelSpecificEffect = pKVEntry->GetBool( "has_viewmodel_specific_effect", false );

				COMPILE_TIME_ASSERT( ARRAYSIZE( system.pszControlPoints ) == ARRAYSIZE( s_particle_controlpoint_names ) );
				for ( int i=0; i<ARRAYSIZE( system.pszControlPoints ); ++i )
				{
					system.pszControlPoints[i] = pKVEntry->GetString( s_particle_controlpoint_names[i], NULL );
				}

				if ( pVec )
				{
					pVec->AddToTail( nItemIndex );
				}
			}
		}
	}
	return SCHEMA_INIT_SUCCESS();
}

#ifdef CLIENT_DLL
locchar_t *CEconItemSchema::GetParticleSystemLocalizedName( int index ) const
{
	const attachedparticlesystem_t *pSystem = GetItemSchema()->GetAttributeControlledParticleSystem( index );
	if ( !pSystem )
		return NULL;

	char particleNameEntry[128];
	Q_snprintf( particleNameEntry, ARRAYSIZE( particleNameEntry ), "#Attrib_Particle%d", pSystem->nSystemID );

	return g_pVGuiLocalize->Find( particleNameEntry );
}

#endif
//-----------------------------------------------------------------------------
// Purpose: Inits data for items that can level up through kills, etc.
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitItemLevels( KeyValues *pKVItemLevels, CUtlVector<CUtlString> *pVecErrors )
{
	m_vecItemLevelingData.RemoveAll();

	// initialize the rewards sections
	if ( NULL != pKVItemLevels )
	{
		FOR_EACH_TRUE_SUBKEY( pKVItemLevels, pKVItemLevelBlock )
		{
			const char *pszLevelBlockName = pKVItemLevelBlock->GetName();
			SCHEMA_INIT_CHECK( GetItemLevelingData( pszLevelBlockName ) == NULL,
				"Duplicate leveling data block named \"%s\".", pszLevelBlockName );

			// Allocate a new structure for this block and assign it. We'll fill in the contents later.
			CUtlVector<CItemLevelingDefinition> *pLevelingData = new CUtlVector<CItemLevelingDefinition>;
			m_vecItemLevelingData.Insert( pszLevelBlockName, pLevelingData );

			FOR_EACH_TRUE_SUBKEY( pKVItemLevelBlock, pKVItemLevel )
			{
				int index = pLevelingData->AddToTail();
				SCHEMA_INIT_SUBSTEP( (*pLevelingData)[index].BInitFromKV( pKVItemLevel, pszLevelBlockName, pVecErrors ) );
			}
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose: Inits data for kill eater types.
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitKillEaterScoreTypes( KeyValues *pKVKillEaterScoreTypes, CUtlVector<CUtlString> *pVecErrors )
{
	m_mapKillEaterScoreTypes.RemoveAll();

	// initialize the rewards sections
	if ( NULL != pKVKillEaterScoreTypes )
	{
		FOR_EACH_TRUE_SUBKEY( pKVKillEaterScoreTypes, pKVScoreType )
		{
			unsigned int unIndex = (unsigned int)atoi( pKVScoreType->GetName() );
			SCHEMA_INIT_CHECK( m_mapKillEaterScoreTypes.Find( unIndex ) == KillEaterScoreMap_t::InvalidIndex(),
				"Duplicate kill eater score type index %u.", unIndex );
			
			kill_eater_score_type_t ScoreType;
			ScoreType.m_pszTypeString = pKVScoreType->GetString( "type_name" );
			ScoreType.m_bAllowBotVictims = pKVScoreType->GetBool( "allow_bot_victims", false );
#ifdef GC_DLL
			ScoreType.m_bGCUpdateOnly = pKVScoreType->GetBool( "gc_update_only", false );
			ScoreType.m_AllowIncrementValues = pKVScoreType->GetBool( "gc_allow_increment_values", false );
			ScoreType.m_bIsBaseKillType = pKVScoreType->GetBool( "gc_is_base_kill_type", false );
#endif

			const char *pszLevelBlockName = pKVScoreType->GetString( "level_data", "KillEaterRank" );
			SCHEMA_INIT_CHECK( GetItemLevelingData( pszLevelBlockName ) != NULL,
				"Unable to find leveling data block named \"%s\" for kill eater score type %u.", pszLevelBlockName, unIndex );

			ScoreType.m_pszLevelBlockName = pszLevelBlockName;

			m_mapKillEaterScoreTypes.Insert( unIndex, ScoreType );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitStringTables( KeyValues *pKVStringTables, CUtlVector<CUtlString> *pVecErrors )
{
	m_dictStringTable.PurgeAndDeleteElements();
	
	// initialize the rewards sections
	if ( NULL != pKVStringTables )
	{
		FOR_EACH_SUBKEY( pKVStringTables, pKVTable )
		{
			SCHEMA_INIT_CHECK( !m_dictStringTable.IsValidIndex( m_dictStringTable.Find( pKVTable->GetName() ) ),
				"Duplicate string table name '%s'.", pKVTable->GetName() );

			SchemaStringTableDict_t::IndexType_t i = m_dictStringTable.Insert( pKVTable->GetName(), new CUtlVector< schema_string_table_entry_t > );
			FOR_EACH_SUBKEY( pKVTable, pKVEntry )
			{
				schema_string_table_entry_t s = { atoi( pKVEntry->GetName() ), pKVEntry->GetString() };
				m_dictStringTable[i]->AddToTail( s );
			}
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitCommunityMarketRemaps( KeyValues *pKVCommunityMarketRemaps, CUtlVector<CUtlString> *pVecErrors )
{
	m_mapCommunityMarketDefinitionIndexRemap.Purge();

	if ( NULL != pKVCommunityMarketRemaps )
	{
		FOR_EACH_SUBKEY( pKVCommunityMarketRemaps, pKVRemapBase )
		{
			const char *pszBaseDefName = pKVRemapBase->GetName();
			const CEconItemDefinition *pBaseItemDef = GetItemSchema()->GetItemDefinitionByName( pszBaseDefName );
			SCHEMA_INIT_CHECK( pBaseItemDef != NULL, "Unknown Market remap base definition '%s'.", pszBaseDefName );

			FOR_EACH_SUBKEY( pKVRemapBase, pKVRemap )
			{
				const char *pszDefName = pKVRemap->GetName();
				const CEconItemDefinition *pItemDef = GetItemSchema()->GetItemDefinitionByName( pszDefName );
				SCHEMA_INIT_CHECK( pItemDef != NULL, "Unknown Market remap definition '%s' (under '%s').", pszDefName, pszBaseDefName );
				SCHEMA_INIT_CHECK( m_mapCommunityMarketDefinitionIndexRemap.Find( pItemDef->GetDefinitionIndex() ) == m_mapCommunityMarketDefinitionIndexRemap.InvalidIndex(), "Duplicate Market remap definition '%s'.\n", pszDefName );

				m_mapCommunityMarketDefinitionIndexRemap.Insert( pItemDef->GetDefinitionIndex(), pBaseItemDef->GetDefinitionIndex() );
			}
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
item_definition_index_t CEconItemSchema::GetCommunityMarketRemappedDefinitionIndex( item_definition_index_t unSearchItemDef ) const
{
	CommunityMarketDefinitionRemapMap_t::IndexType_t index = m_mapCommunityMarketDefinitionIndexRemap.Find( unSearchItemDef );
	if ( index == m_mapCommunityMarketDefinitionIndexRemap.InvalidIndex() )
		return unSearchItemDef;

	return m_mapCommunityMarketDefinitionIndexRemap[index];
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const ISchemaAttributeType *CEconItemSchema::GetAttributeType( const char *pszAttrTypeName ) const
{
	FOR_EACH_VEC( m_vecAttributeTypes, i )
	{
		if ( m_vecAttributeTypes[i].m_sName == pszAttrTypeName )
			return m_vecAttributeTypes[i].m_pAttrType;
	}

	return NULL;
}

//-----------------------------------------------------------------------------
// CItemLevelingDefinition Accessor
//-----------------------------------------------------------------------------
const CItemLevelingDefinition *CEconItemSchema::GetItemLevelForScore( const char *pszLevelBlockName, uint32 unScore ) const
{
	const CUtlVector<CItemLevelingDefinition> *pLevelingData = GetItemLevelingData( pszLevelBlockName );
	if ( !pLevelingData )
		return NULL;

	if ( pLevelingData->Count() == 0 )
		return NULL;

	FOR_EACH_VEC( (*pLevelingData), i )
	{
		if ( unScore < (*pLevelingData)[i].GetRequiredScore() )
			return &(*pLevelingData)[i];
	}

	return &(*pLevelingData).Tail();
}

//-----------------------------------------------------------------------------
// Kill eater score type accessor
//-----------------------------------------------------------------------------
const kill_eater_score_type_t *CEconItemSchema::FindKillEaterScoreType( uint32 unScoreType ) const
{
	KillEaterScoreMap_t::IndexType_t i = m_mapKillEaterScoreTypes.Find( unScoreType );
	if ( i == KillEaterScoreMap_t::InvalidIndex() )
		return NULL;

	return &m_mapKillEaterScoreTypes[i];
}

//-----------------------------------------------------------------------------
// Kill eater score type accessor
//-----------------------------------------------------------------------------
const char *CEconItemSchema::GetKillEaterScoreTypeLocString( uint32 unScoreType ) const
{
	const kill_eater_score_type_t *pScoreType = FindKillEaterScoreType( unScoreType );

	return pScoreType
		 ? pScoreType->m_pszTypeString
		 : NULL;
}

//-----------------------------------------------------------------------------
// Kill eater score type accessor
//-----------------------------------------------------------------------------
const char *CEconItemSchema::GetKillEaterScoreTypeLevelingDataName( uint32 unScoreType ) const
{
	const kill_eater_score_type_t *pScoreType = FindKillEaterScoreType( unScoreType );

	return pScoreType
		 ? pScoreType->m_pszLevelBlockName
		 : NULL;
}

#if defined(STAGING_ONLY) && ( defined(TF_CLIENT_DLL) || defined(TF_DLL) )
	ConVar tf_allow_strange_bot_kills( "tf_allow_strange_bot_kills", "0", FCVAR_REPLICATED );
#endif
//-----------------------------------------------------------------------------
// Kill eater score type accessor
//-----------------------------------------------------------------------------
bool CEconItemSchema::GetKillEaterScoreTypeAllowsBotVictims( uint32 unScoreType ) const
{
#if defined(STAGING_ONLY) && ( defined(TF_CLIENT_DLL) || defined(TF_DLL) )
	if ( tf_allow_strange_bot_kills.GetBool() )
	{
		return true;
	}
#endif

	const kill_eater_score_type_t *pScoreType = FindKillEaterScoreType( unScoreType );

	return pScoreType
		 ? pScoreType->m_bAllowBotVictims
		 : false;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
econ_tag_handle_t CEconItemSchema::GetHandleForTag( const char *pszTagName )
{
	EconTagDict_t::IndexType_t i = m_dictTags.Find( pszTagName );
	if ( m_dictTags.IsValidIndex( i ) )
		return i;

	return m_dictTags.Insert( pszTagName );
}

#ifdef GC_DLL
//-----------------------------------------------------------------------------
// Kill eater score type accessor
//-----------------------------------------------------------------------------
bool CEconItemSchema::GetKillEaterScoreTypeGCOnlyUpdate( uint32 unScoreType ) const
{
	const kill_eater_score_type_t *pScoreType = FindKillEaterScoreType( unScoreType );

	return pScoreType
		 ? pScoreType->m_bGCUpdateOnly
		 : true;								// default to being more restrictive
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconItemSchema::GetKillEaterScoreTypeAllowsIncrementValues( uint32 unScoreType ) const
{
	const kill_eater_score_type_t *pScoreType = FindKillEaterScoreType( unScoreType );

	return pScoreType
		 ? pScoreType->m_AllowIncrementValues
		 : true;								// default to being more restrictive
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const CEconItemSchema::periodic_score_t& CEconItemSchema::GetPeriodicScoreInfo( int iPeriodicScoreIndex ) const
{
	Assert( GetPeriodicScoreTypeList().IsValidIndex( iPeriodicScoreIndex ) );

	return GetPeriodicScoreTypeList()[ iPeriodicScoreIndex ];
}
#endif

#if defined(CLIENT_DLL) || defined(GAME_DLL)
//-----------------------------------------------------------------------------
// Purpose:	Clones the specified item definition, and returns the new item def.
//-----------------------------------------------------------------------------
void CEconItemSchema::ItemTesting_CreateTestDefinition( int iCloneFromItemDef, int iNewDef, KeyValues *pNewKV )
{
	int nMapIndex = m_mapItems.Find( iNewDef );
	if ( !m_mapItems.IsValidIndex( nMapIndex ) )
	{
		nMapIndex = m_mapItems.Insert( iNewDef, CreateEconItemDefinition() );
		m_mapItemsSorted.Insert( iNewDef, m_mapItems[nMapIndex] );
	}

	// Find & copy the clone item def's data in
	CEconItemDefinition *pCloneDef = GetItemDefinition( iCloneFromItemDef );
	if ( !pCloneDef )
		return;
	m_mapItems[nMapIndex]->CopyPolymorphic( pCloneDef );

	// Then stomp it with the KV test contents
	m_mapItems[nMapIndex]->BInitFromTestItemKVs( iNewDef, pNewKV );
}

//-----------------------------------------------------------------------------
// Purpose:	Discards the specified item definition
//-----------------------------------------------------------------------------
void CEconItemSchema::ItemTesting_DiscardTestDefinition( int iDef )
{
	m_mapItems.Remove( iDef );
	m_mapItemsSorted.Remove( iDef );
}

//-----------------------------------------------------------------------------
// Purpose:	Initializes the armory data section of the schema
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitArmoryData( KeyValues *pKVArmoryData, CUtlVector<CUtlString> *pVecErrors )
{
	m_dictArmoryItemDataStrings.RemoveAll();
	m_dictArmoryAttributeDataStrings.RemoveAll();
	if ( NULL != pKVArmoryData )
	{
		KeyValues *pKVItemTypes = pKVArmoryData->FindKey( "armory_item_types" );
		if ( pKVItemTypes )
		{
			FOR_EACH_SUBKEY( pKVItemTypes, pKVEntry )
			{
				const char *pszDataKey = pKVEntry->GetName();
				const CUtlConstString sLocString( pKVEntry->GetString() );
				m_dictArmoryItemTypesDataStrings.Insert( pszDataKey, sLocString );
			}
		}

		pKVItemTypes = pKVArmoryData->FindKey( "armory_item_classes" );
		if ( pKVItemTypes )
		{
			FOR_EACH_SUBKEY( pKVItemTypes, pKVEntry )
			{
				const char *pszDataKey = pKVEntry->GetName();
				const CUtlConstString sLocString( pKVEntry->GetString() );
				m_dictArmoryItemClassesDataStrings.Insert( pszDataKey, sLocString );
			}
		}

		KeyValues *pKVAttribs = pKVArmoryData->FindKey( "armory_attributes" );
		if ( pKVAttribs )
		{
			FOR_EACH_SUBKEY( pKVAttribs, pKVEntry )
			{
				const char *pszDataKey = pKVEntry->GetName();
				const CUtlConstString sLocString( pKVEntry->GetString() );
				m_dictArmoryAttributeDataStrings.Insert( pszDataKey, sLocString );
			}
		}

		KeyValues *pKVItems = pKVArmoryData->FindKey( "armory_items" );
		if ( pKVItems )
		{
			FOR_EACH_SUBKEY( pKVItems, pKVEntry )
			{
				const char *pszDataKey = pKVEntry->GetName();
				const CUtlConstString sLocString( pKVEntry->GetString() );
				m_dictArmoryItemDataStrings.Insert( pszDataKey, sLocString );
			}
		}
	}
	return SCHEMA_INIT_SUCCESS();
}
#endif


#ifdef GC_DLL
//-----------------------------------------------------------------------------
// Purpose:	Returns the item awarded for an achievement.
// Input:	pchAchievementName - The achievement that was awarded.
// Output:	The achievement struct for this reward.
//-----------------------------------------------------------------------------
const AchievementAward_t * CEconItemSchema::GetAchievementReward( const char *pchAchievementName, AppId_t unAppID ) const
{
	int nRewardIndex = m_dictAchievementRewards.Find( ComputeAchievementName( unAppID, pchAchievementName ) );

	if( m_dictAchievementRewards.IsValidIndex( nRewardIndex ) )
		return m_dictAchievementRewards[ nRewardIndex ];
	else
		return NULL;
}


//-----------------------------------------------------------------------------
// Purpose:	Returns the achievement award that matches the provided data or NULL
//			if there is no such award.
// Input:	unData - The data field that would be stored in ItemAudit
//-----------------------------------------------------------------------------
const AchievementAward_t *CEconItemSchema::GetAchievementRewardByData( uint32 unData ) const
{
	uint nIndex = m_mapAchievementRewardsByData.Find( unData );
	if( m_mapAchievementRewardsByData.IsValidIndex( nIndex ) )
	{
		return m_mapAchievementRewardsByData[nIndex];
	}
	else
	{
		return NULL;
	}
}


#endif // GC_DLL


//-----------------------------------------------------------------------------
// Purpose:	Returns the achievement award that matches the provided defindex or NULL
//			if there is no such award.
// Input:	unData - The data field that would be stored in ItemAudit
//-----------------------------------------------------------------------------
const AchievementAward_t *CEconItemSchema::GetAchievementRewardByDefIndex( uint16 usDefIndex ) const
{
	FOR_EACH_MAP_FAST( m_mapAchievementRewardsByData, nIndex )
	{
		if( m_mapAchievementRewardsByData[nIndex]->m_vecDefIndex.HasElement( usDefIndex ) )
			return m_mapAchievementRewardsByData[nIndex];
	}
	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose:	Gets a rarity value for a name.
//-----------------------------------------------------------------------------
bool CEconItemSchema::BGetItemRarityFromName( const char *pchName, uint8 *nRarity ) const
{
	if ( 0 == Q_stricmp( "any", pchName ) )
	{
		*nRarity = k_unItemRarity_Any;
		return true;
	}

	FOR_EACH_MAP_FAST( m_mapRarities, i )
	{
		if ( 0 == Q_stricmp( m_mapRarities[i].GetName(), pchName ) )
		{
			*nRarity = m_mapRarities[i].GetDBValue();
			return true;
		}
	}

	return false;
}


//-----------------------------------------------------------------------------
// Purpose:	Gets a quality value for a name.
// Input:	pchName - The name to translate.
//			nQuality - (out)The quality number for this name, if found.
// Output:	True if the string matched a quality for this schema, false otherwise.
//-----------------------------------------------------------------------------
bool CEconItemSchema::BGetItemQualityFromName( const char *pchName, uint8 *nQuality ) const
{
	if ( 0 == Q_stricmp( "any", pchName ) )
	{
		*nQuality = k_unItemQuality_Any;
		return true;
	}

	FOR_EACH_MAP_FAST( m_mapQualities, i )
	{
		if ( 0 == Q_stricmp( m_mapQualities[i].GetName(), pchName ) )
		{
			*nQuality = m_mapQualities[i].GetDBValue();
			return true;
		}
	}

	return false;
}


//-----------------------------------------------------------------------------
// Purpose:	Gets a quality definition for an index
// Input:	nQuality - The quality to get.
// Output:	A pointer to the desired definition, or NULL if it is not found.
//-----------------------------------------------------------------------------
const CEconItemQualityDefinition *CEconItemSchema::GetQualityDefinition( int nQuality ) const
{ 
	int iIndex = m_mapQualities.Find( nQuality );
	if ( m_mapQualities.IsValidIndex( iIndex ) )
		return &m_mapQualities[iIndex]; 
	return NULL;
}

const CEconItemQualityDefinition *CEconItemSchema::GetQualityDefinitionByName( const char *pszDefName ) const
{
	FOR_EACH_MAP_FAST( m_mapQualities, i )
	{
		if ( V_stricmp( pszDefName, m_mapQualities[i].GetName()) == 0 )
			return &m_mapQualities[i]; 
	}
	return NULL;
}

//-----------------------------------------------------------------------------
// ItemRarity
//-----------------------------------------------------------------------------
const CEconItemRarityDefinition *CEconItemSchema::GetRarityDefinitionByMapIndex( int nRarityIndex ) const
{
	if ( m_mapRarities.IsValidIndex( nRarityIndex ) )
		return &m_mapRarities[nRarityIndex];

	return NULL;
}
//-----------------------------------------------------------------------------
const CEconItemRarityDefinition *CEconItemSchema::GetRarityDefinition( int nRarity ) const
{
	int iIndex = m_mapRarities.Find( nRarity );
	if ( m_mapRarities.IsValidIndex( iIndex ) )
		return &m_mapRarities[iIndex];
	return NULL;
}
//-----------------------------------------------------------------------------
const CEconItemRarityDefinition *CEconItemSchema::GetRarityDefinitionByName( const char *pszDefName ) const
{
	FOR_EACH_MAP_FAST( m_mapRarities, i )
	{
		if ( !strcmp( pszDefName, m_mapRarities[i].GetName() ) )
			return &m_mapRarities[i];
	}
	return NULL;
}
//-----------------------------------------------------------------------------
const char* CEconItemSchema::GetRarityName( uint8 iRarity )
{
	const CEconItemRarityDefinition* pItemRarity = GetRarityDefinition( iRarity );
	if ( !pItemRarity )
		return NULL;
	else
		return pItemRarity->GetName();
}
//-----------------------------------------------------------------------------
const char* CEconItemSchema::GetRarityLocKey( uint8 iRarity )
{
	const CEconItemRarityDefinition* pItemRarity = GetRarityDefinition( iRarity );
	if ( !pItemRarity )
		return NULL;
	else
		return pItemRarity->GetLocKey();
}
//-----------------------------------------------------------------------------
const char* CEconItemSchema::GetRarityColor( uint8 iRarity )
{
	const CEconItemRarityDefinition* pItemRarity = GetRarityDefinition( iRarity );
	if ( !pItemRarity )
		return NULL;
	else
		return GetColorNameForAttribColor( pItemRarity->GetAttribColor() );
}
//-----------------------------------------------------------------------------
int CEconItemSchema::GetRarityIndex( const char* pszRarity )
{
	const CEconItemRarityDefinition* pRarity = GetRarityDefinitionByName( pszRarity );
	if ( pRarity )
		return pRarity->GetDBValue();
	else
		return 0;
}

//-----------------------------------------------------------------------------
bool CEconItemSchema::BGetItemSeries( const char* pchName, uint8 *nItemSeries ) const
{
	FOR_EACH_MAP_FAST( m_mapItemSeries, i )
	{
		if ( 0 == Q_stricmp( m_mapItemSeries[i].GetName(), pchName ) )
		{
			*nItemSeries = m_mapItemSeries[i].GetDBValue();
			return true;
		}
	}

	return false;
}

//-----------------------------------------------------------------------------
const CEconItemSeriesDefinition *CEconItemSchema::GetItemSeriesDefinition( int iSeries ) const
{
	int iIndex = m_mapItemSeries.Find( iSeries );
	if ( m_mapItemSeries.IsValidIndex( iIndex ) )
		return &m_mapItemSeries[iIndex];
	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose:	Gets an item definition for the specified definition index
// Input:	iItemIndex - The index of the desired definition.
// Output:	A pointer to the desired definition, or NULL if it is not found.
//-----------------------------------------------------------------------------
CEconItemDefinition *CEconItemSchema::GetItemDefinition( int iItemIndex )
{
#if defined(CLIENT_DLL) || defined(GAME_DLL)
#if !defined(CSTRIKE_DLL)
	AssertMsg( GetDefaultItemDefinition(), "No default item definition set up for item schema." );
#endif // CSTRIKE_DLL
#endif // defined(CLIENT_DLL) || defined(GAME_DLL)

	int iIndex = m_mapItems.Find( iItemIndex );
	if ( m_mapItems.IsValidIndex( iIndex ) )
		return m_mapItems[iIndex]; 

#if defined( GC_DLL ) || defined( EXTERNALTESTS_DLL )
	return NULL;
#else // !GC_DLL
	if ( GetDefaultItemDefinition() )
		return GetDefaultItemDefinition();

#if !defined(CSTRIKE_DLL)
	// We shouldn't ever get down here, but all the same returning a valid pointer is very slightly
	// a better plan than returning an invalid pointer to code that won't check to see if it's valid.
	static CEconItemDefinition *s_pEmptyDefinition = CreateEconItemDefinition();
	return s_pEmptyDefinition;
#else
	return NULL;
#endif // CSTRIKE_DLL

#endif // GC_DLL
}
const CEconItemDefinition *CEconItemSchema::GetItemDefinition( int iItemIndex ) const
{
	return const_cast<CEconItemSchema *>(this)->GetItemDefinition( iItemIndex );
}

//-----------------------------------------------------------------------------
// Purpose:	Gets an item definition that has a name matching the specified name.
// Input:	pszDefName - The name of the desired definition.
// Output:	A pointer to the desired definition, or NULL if it is not found.
//-----------------------------------------------------------------------------
CEconItemDefinition *CEconItemSchema::GetItemDefinitionByName( const char *pszDefName )
{
	// This shouldn't happen, but let's not crash if it ever does.
	Assert( pszDefName != NULL );
	if ( pszDefName == NULL )
		return NULL;

	FOR_EACH_MAP_FAST( m_mapItems, i )
	{
		if ( V_stricmp( pszDefName, m_mapItems[i]->GetDefinitionName()) == 0 )
			return m_mapItems[i]; 
	}
	return NULL;
}

const CEconItemDefinition *CEconItemSchema::GetItemDefinitionByName( const char *pszDefName ) const
{
	return const_cast<CEconItemSchema *>(this)->GetItemDefinitionByName( pszDefName );
}


#ifdef GC_DLL
random_attrib_t *CEconItemSchema::GetRandomAttributeTemplateByName( const char *pszAttrTemplateName ) const
{
	int index = m_dictRandomAttributeTemplates.Find( pszAttrTemplateName );
	if ( index != m_dictRandomAttributeTemplates.InvalidIndex() )
	{
		return m_dictRandomAttributeTemplates[index];
	}

	return NULL;
}
#endif // GC_DLL


//-----------------------------------------------------------------------------
// Purpose:	Gets an attribute definition for an index
// Input:	iAttribIndex - The index of the desired definition.
// Output:	A pointer to the desired definition, or NULL if it is not found.
//-----------------------------------------------------------------------------
CEconItemAttributeDefinition *CEconItemSchema::GetAttributeDefinition( int iAttribIndex )
{ 
	int iIndex = m_mapAttributes.Find( iAttribIndex );
	if ( m_mapAttributes.IsValidIndex( iIndex ) )
		return &m_mapAttributes[iIndex]; 
	return NULL;
}
const CEconItemAttributeDefinition *CEconItemSchema::GetAttributeDefinition( int iAttribIndex ) const
{
	return const_cast<CEconItemSchema *>(this)->GetAttributeDefinition( iAttribIndex );
}

CEconItemAttributeDefinition *CEconItemSchema::GetAttributeDefinitionByName( const char *pszDefName )
{
	Assert( pszDefName );
	if ( !pszDefName )
		return NULL;

	VPROF_BUDGET( "CEconItemSchema::GetAttributeDefinitionByName", VPROF_BUDGETGROUP_STEAM );
	FOR_EACH_MAP_FAST( m_mapAttributes, i )
	{
		Assert( m_mapAttributes[i].GetDefinitionName() );
		if ( !m_mapAttributes[i].GetDefinitionName() )
			continue;

		if ( V_stricmp( pszDefName, m_mapAttributes[i].GetDefinitionName() ) == 0 )
			return &m_mapAttributes[i]; 
	}
	return NULL;
}
const CEconItemAttributeDefinition *CEconItemSchema::GetAttributeDefinitionByName( const char *pszDefName ) const
{
	return const_cast<CEconItemSchema *>(this)->GetAttributeDefinitionByName( pszDefName );
}

//-----------------------------------------------------------------------------
// Purpose:	Gets a recipe definition for an index
// Input:	iRecipeIndex - The index of the desired definition.
// Output:	A pointer to the desired definition, or NULL if it is not found.
//-----------------------------------------------------------------------------
CEconCraftingRecipeDefinition *CEconItemSchema::GetRecipeDefinition( int iRecipeIndex )
{ 
	int iIndex = m_mapRecipes.Find( iRecipeIndex );
	if ( m_mapRecipes.IsValidIndex( iIndex ) )
		return m_mapRecipes[iIndex]; 
	return NULL;
}

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEconColorDefinition *CEconItemSchema::GetColorDefinitionByName( const char *pszDefName )
{
	FOR_EACH_VEC( m_vecColorDefs, i )
	{
		if ( !Q_stricmp( m_vecColorDefs[i]->GetName(), pszDefName ) )
			return m_vecColorDefs[i];
	}
	return NULL;
}
const CEconColorDefinition *CEconItemSchema::GetColorDefinitionByName( const char *pszDefName ) const
{
	return const_cast<CEconItemSchema *>(this)->GetColorDefinitionByName( pszDefName );
}


#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
const char *CEconItemSchema::GetSteamPackageLocalizationToken( uint32 unPackageId ) const
{
	SteamPackageLocalizationTokenMap_t::IndexType_t i = m_mapSteamPackageLocalizationTokens.Find( unPackageId );
	if ( m_mapSteamPackageLocalizationTokens.IsValidIndex( i ) )
		return m_mapSteamPackageLocalizationTokens[i]; 
	return NULL;
}
#endif // CLIENT_DLL

//-----------------------------------------------------------------------------
// Purpose:	Return the attribute specified attachedparticlesystem_t* associated with the given id.
//-----------------------------------------------------------------------------
attachedparticlesystem_t* CEconItemSchema::GetAttributeControlledParticleSystem( int id )
{
	int iIndex = m_mapAttributeControlledParticleSystems.Find( id );
	if ( m_mapAttributeControlledParticleSystems.IsValidIndex( iIndex ) )
		return &m_mapAttributeControlledParticleSystems[iIndex];
	return NULL;
}

attachedparticlesystem_t* CEconItemSchema::FindAttributeControlledParticleSystem( const char *pchSystemName )
{
	FOR_EACH_MAP_FAST( m_mapAttributeControlledParticleSystems, nSystem )
	{
		if( !Q_stricmp( m_mapAttributeControlledParticleSystems[nSystem].pszSystemName, pchSystemName ) )
			return &m_mapAttributeControlledParticleSystems[nSystem];
	}
	return NULL;
}


#if defined(CLIENT_DLL) || defined(GAME_DLL)
bool CEconItemSchema::SetupPreviewItemDefinition( KeyValues *pKV )
{
	int nMapIndex = m_mapItems.Find( PREVIEW_ITEM_DEFINITION_INDEX );
	if ( !m_mapItems.IsValidIndex( nMapIndex ) )
	{
		nMapIndex = m_mapItems.Insert( PREVIEW_ITEM_DEFINITION_INDEX, CreateEconItemDefinition() );
	}

	CEconItemDefinition *pItemDef = m_mapItems[ nMapIndex ];
	return pItemDef->BInitFromKV( pKV );
}
#endif // defined(CLIENT_DLL) || defined(GAME_DLL)

#ifdef GC_DLL
//-----------------------------------------------------------------------------
// Purpose: Returns all the foreign item imports for an app ID
//-----------------------------------------------------------------------------
const CEconItemDefinition *CEconItemSchema::GetAppItemImport( AppId_t unAppID, uint16 usDefIndex ) const
{
	int i = m_mapForeignImports.Find( unAppID );
	if( m_mapForeignImports.IsValidIndex( i ) )
		return m_mapForeignImports[i]->FindMapping( usDefIndex );
	else
		return NULL;
}


//-----------------------------------------------------------------------------
// Purpose: Returns all the foreign item imports for an app ID
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitForeignImports( CUtlVector<CUtlString> *pVecErrors )
{
	FOR_EACH_MAP_FAST( m_mapItems, nItem )
	{
		CEconItemDefinition *pDefn = m_mapItems[nItem];

		KeyValues *pkvImport = pDefn->GetDefinitionKey( "import_from" );
		if( !pkvImport )
			continue;

		FOR_EACH_VALUE( pkvImport, pkvApp )
		{
			CForeignAppImports *pAppImports = FindOrAddAppImports( Q_atoi( pkvApp->GetName() ) );
			pAppImports->AddMapping( pkvApp->GetInt(), pDefn );
		}
	}

	return true;
}


//-----------------------------------------------------------------------------
// Purpose: Returns all the foreign item imports for an app ID
//-----------------------------------------------------------------------------
CForeignAppImports *CEconItemSchema::FindOrAddAppImports( AppId_t unAppID )
{
	int i = m_mapForeignImports.Find( unAppID );
	if( m_mapForeignImports.IsValidIndex( i ) )
		return m_mapForeignImports[i];
	else
	{
		m_vecForeignApps.AddToTail( unAppID );
		CForeignAppImports *pApp = new CForeignAppImports();
		m_mapForeignImports.Insert( unAppID, pApp );
		return pApp;
	}
}
#endif // GC_DLL

bool CEconItemSchema::BCanStrangeFilterApplyToStrangeSlotInItem( uint32 /*strange_event_restriction_t*/ unRestrictionType, uint32 unRestrictionValue, const IEconItemInterface *pItem, int iStrangeSlot, uint32 *out_pOptionalScoreType ) const
{
	Assert( unRestrictionType != kStrangeEventRestriction_None );

	// Do we have a type for this slot? If not, move on, with the exception: all user-custom scores
	// we expect to have types, but certain weapons may not specify a base type and just use
	// kills implicitly.
	uint32 unStrangeScoreTypeBits = kKillEaterEvent_PlayerKill;
	if ( !pItem->FindAttribute( GetKillEaterAttr_Type( iStrangeSlot ), &unStrangeScoreTypeBits ) && iStrangeSlot != 0 )
		return false;

	// Do we have a restriction already in this slot? If so, move on.
	if ( pItem->FindAttribute( GetKillEaterAttr_Restriction( iStrangeSlot ) ) )
		return false;

	// We've found an open slot. Make sure that adding our restriction to this slot
	// won't result in a duplicate score-type/restriction-type entry.
	for ( int j = 0; j < GetKillEaterAttrCount(); j++ )
	{
		// Don't compare against ourself.
		if ( iStrangeSlot == j )
			continue;

		// Ignore this entry if we don't have a score type or if the score type differs from
		// our search criteria above.
		uint32 unAltStrangeScoreType;
		if ( !pItem->FindAttribute( GetKillEaterAttr_Type( j ), &unAltStrangeScoreType ) ||
			 unAltStrangeScoreType != unStrangeScoreTypeBits )
		{
			continue;
		}

		// This entry does have the same type, so tag us as a duplicate if we also have the same
		// restriction that we're trying to apply.
		uint32 unAltRestrictionType;
		uint32 unAltRestrictionValue;
		if ( pItem->FindAttribute( GetKillEaterAttr_Restriction( j ), &unAltRestrictionType ) &&
			 unAltRestrictionType == unRestrictionType &&
			 pItem->FindAttribute( GetKillEaterAttr_RestrictionValue( j ), &unAltRestrictionValue ) &&
			 unAltRestrictionValue == unRestrictionValue )
		{
			return false;
		}
	}	

	if ( out_pOptionalScoreType )
	{
		*out_pOptionalScoreType = *(float *)&unStrangeScoreTypeBits;
	}

	// Everything seems alright.
	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Ensure that all of our internal structures are consistent, and
//			account for all memory that we've allocated.
// Input:	validator -		Our global validator object
//			pchName -		Our name (typically a member var in our container)
//-----------------------------------------------------------------------------
#ifdef DBGFLAG_VALIDATE
void CEconItemSchema::Validate( CValidator &validator, const char *pchName )
{
	VALIDATE_SCOPE();
	ValidateObj( m_mapQualities );

	FOR_EACH_MAP_FAST( m_mapQualities, i )
	{
		ValidateObj( m_mapQualities[i] );
	}

	ValidateObj( m_mapItems );

	FOR_EACH_MAP_FAST( m_mapItems, i )
	{
		ValidateObj( m_mapItems[i] );
	}

	ValidateObj( m_mapUpgradeableBaseItems );

	FOR_EACH_MAP_FAST( m_mapUpgradeableBaseItems, i )
	{
		ValidateObj( m_mapUpgradeableBaseItems[i] );
	}

	ValidateObj( m_mapAttributes );

	FOR_EACH_MAP_FAST( m_mapAttributes, i )
	{
		ValidateObj( m_mapAttributes[i] );
	}

	ValidateObj( m_mapRecipes );

	FOR_EACH_MAP_FAST( m_mapRecipes, i )
	{
		ValidateObj( m_mapRecipes[i] );
	}

	FOR_EACH_VEC( m_vecTimedRewards, i )
	{
		ValidateObj( m_vecTimedRewards[i] );
	}
	ValidateObj( m_vecTimedRewards );

}
#endif // DBGFLAG_VALIDATE

#ifdef GC_DLL

//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CEconItemSchema::BInitExperiements( KeyValues *pKVExperiments, CUtlVector<CUtlString> *pVecErrors )
{
	m_vecExperiments.RemoveAll();

	if ( NULL != pKVExperiments )
	{
		FOR_EACH_TRUE_SUBKEY( pKVExperiments, pKVEntry )
		{
			const char *listName = pKVEntry->GetName();

			SCHEMA_INIT_CHECK( listName != NULL, "All experiments must have titles.");

			int idx = m_vecExperiments.AddToTail();
			SCHEMA_INIT_SUBSTEP( m_vecExperiments[idx].BInitFromKV( pKVEntry, pVecErrors ) );
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

//-----------------------------------------------------------------------------
// CExperimentDefinition
//-----------------------------------------------------------------------------
CExperimentDefinition::CExperimentDefinition( void )
	: m_bEnabled( false )
	, m_unExperimentID( 0 )
	, m_unNumParticipants( 0 )
	, m_unMaxParticipants( 0 )
	, m_pKeyValues( NULL )
{
}

CExperimentDefinition::~CExperimentDefinition( void )
{
	if ( m_pKeyValues )
	{
		m_pKeyValues->deleteThis();
	}
}

bool CExperimentDefinition::BInitFromKV( KeyValues *pKVExperiment, CUtlVector<CUtlString> *pVecErrors )
{
	m_pKeyValues = pKVExperiment->MakeCopy();

	m_unExperimentID = Q_atoi( m_pKeyValues->GetName() );
	m_bEnabled = m_pKeyValues->GetBool( "enabled" );
	m_unNumParticipants = 0;
	m_unMaxParticipants = 0;
	
	KeyValues *pKVGroups = m_pKeyValues->FindKey( "groups" );
	if ( pKVGroups )
	{
		FOR_EACH_TRUE_SUBKEY( pKVGroups, pKVEntry )
		{
			int idx = m_vecGroups.AddToTail();
			experiment_group_t &group = m_vecGroups[idx];
			group.m_pKeyValues = pKVEntry;
			group.m_pName = pKVEntry->GetName();
			group.m_unNumParticipants = 0;
			group.m_unMaxParticipants = pKVEntry->GetInt( "num_participants", 0 );
			m_unMaxParticipants += group.m_unMaxParticipants;
		}
	}

	return SCHEMA_INIT_SUCCESS();
}

bool CExperimentDefinition::ChooseGroup( uint32 &unGroup )
{
	CUtlVector< uint32 > vecGroupIndices;
	FOR_EACH_VEC( m_vecGroups, i )
	{
		experiment_group_t &group = m_vecGroups[i];
		if ( group.m_unNumParticipants < group.m_unMaxParticipants )
		{
			vecGroupIndices.AddToTail( i );
		}
	}
	if ( vecGroupIndices.Count() == 0 )
	{
		return false;
	}

	uint32 idx = vecGroupIndices[ RandomInt( 0, vecGroupIndices.Count() - 1 ) ];
	experiment_group_t &group = m_vecGroups[ idx ];
	++group.m_unNumParticipants;
	unGroup = idx;

	return true;
}

//-----------------------------------------------------------------------------
// Purpose: Give the chance after the schema has been initialized to sanity-check
//			individual parts or interactions before moving forward.
//-----------------------------------------------------------------------------
#ifdef TF_GC_DLL
static bool BTestToolApplicability( CUtlVector<CUtlString> *pVecErrors )
{
	static CSchemaItemDefHandle pItem_TeamPaint				( "Paint Can Team Color" ),			// tools
								pItem_Paint					( "Paint Can 14" ),
								pItem_DescriptionTag		( "Description Tag" ),
								pItem_NameTag				( "Name Tag" ),
								pItem_Key					( "Decoder Ring" ),
								pItem_SummerKey				( "Summer Key" ),
								pItem_GiftWrap				( "Gift Wrap" ),
								pItem_CustomTextureTool		( "Customize Texture Tool" ),
								pItem_SupplyCrateGeneric	( "Supply Crate 2" ),				// tool targets
								pItem_SummerCrate			( "Summer Crate" ),
								pItem_PaintableItem			( "Summer Hat" ),
								//pItem_TeamPaintableItem	( "" ),
								pItem_UnpaintableItem		( "Big Steel Jaw of Summer Fun" ),
								//pItem_UnnameableWeapon	( "" ),
								pItem_NameableWeapon		( "The Axtinguisher" ),
								pItem_GiftWrappableItem		( "Supply Crate 3" ),
								pItem_NonGiftWrappableItem	( "Wrapped Gift" ),
								pItem_StampableObject		( "The Conscientious Objector" ),
								pItem_NonstampableObject	( "Spiral Sallet" );

	struct ToolValidityTest_t
	{
		const CEconItemDefinition *m_pTool;
		const CEconItemDefinition *m_pTarget;
		bool m_bExpectedValidity;
	};

	ToolValidityTest_t definitionTests[] =
	{
		{ pItem_TeamPaint,					pItem_TeamPaint,				false },
		{ pItem_TeamPaint,					pItem_PaintableItem,			true },
		//{ pItem_TeamPaint,				pItem_TeamPaintableItem,		true },
		{ pItem_TeamPaint,					pItem_UnpaintableItem,			false },
		{ pItem_Paint,						pItem_PaintableItem,			true },
		//{ pItem_Paint,					pItem_TeamPaintableItem,		false },
		{ pItem_Paint,						pItem_UnpaintableItem,			false },
		{ pItem_Paint,						pItem_SupplyCrateGeneric,		false },
		{ pItem_Key,						pItem_SupplyCrateGeneric,		true },
		{ pItem_Key,						pItem_SummerCrate,				false },
		{ pItem_SummerKey,					pItem_SupplyCrateGeneric,		true },		// summer keys in staging are now regular keys and should...
		{ pItem_SummerKey,					pItem_SummerCrate,				false },	// ...be able to open regular crates
		{ pItem_NameTag,					pItem_NameableWeapon,			true },
		//{ pItem_NameTag,					pItem_UnnameableWeapon,			false },
		{ pItem_DescriptionTag,				pItem_NameableWeapon,			true },
		//{ pItem_DescriptionTag,			pItem_UnnameableWeapon,			false },
		{ pItem_CustomTextureTool,			pItem_StampableObject,			true },
		{ pItem_CustomTextureTool,			pItem_NonstampableObject,		false },
	};

	bool bAllSuccess = true;
	for ( int i = 0; i < ARRAYSIZE( definitionTests ); i++ )
	{
		const GameItemDefinition_t *pToolDef   = dynamic_cast<const GameItemDefinition_t *>( definitionTests[i].m_pTool ),
								   *pTargetDef = dynamic_cast<const GameItemDefinition_t *>( definitionTests[i].m_pTarget );

		if ( !pToolDef )
		{
			bAllSuccess = false;
			pVecErrors->AddToTail( CFmtStr( "Tool validity test %i failed: Tool is NULL.", i ).Access() );
			continue;
		}

		if ( !pTargetDef )
		{
			bAllSuccess = false;
			pVecErrors->AddToTail( CFmtStr( "Tool validity test %i failed: Target is NULL.", i ).Access() );
			continue;
		}

		if ( CEconSharedToolSupport::ToolCanApplyToDefinition( pToolDef, pTargetDef ) != definitionTests[i].m_bExpectedValidity )
		{
			bAllSuccess = false;
			pVecErrors->AddToTail( CFmtStr( "Tool validity test %i failed: %s %s have been able to apply to %s.",
											i,
											pToolDef->GetDefinitionName(),
											definitionTests[i].m_bExpectedValidity ? "should" : "shouldn't",
											pTargetDef->GetDefinitionName() ).Access() );
		}
	}

	// These tests require actual instances of the item--not just the definitions. 
	ToolValidityTest_t interfaceTests[] = 
	{
		{ pItem_GiftWrap,					pItem_GiftWrappableItem,		true },
		{ pItem_GiftWrap,					pItem_NonGiftWrappableItem,		false },
	};

	// Skip if we already have failures.
	if ( bAllSuccess )
	{
		for ( int i = 0; i < ARRAYSIZE( interfaceTests ); i++ )
		{
			const GameItemDefinition_t *pToolDef = dynamic_cast< const GameItemDefinition_t * >( interfaceTests[ i ].m_pTool ),
									   *pTargetDef = dynamic_cast< const GameItemDefinition_t * >( interfaceTests[ i ].m_pTarget );

			if ( !pToolDef )
			{
				bAllSuccess = false;
				pVecErrors->AddToTail( CFmtStr( "Tool validity test %i failed: Tool is NULL.", i ).Access() );
				continue;
			}

			if ( !pTargetDef )
			{
				bAllSuccess = false;
				pVecErrors->AddToTail( CFmtStr( "Tool validity test %i failed: Target is NULL.", i ).Access() );
				continue;
			}

			CEconItem *pTool = GEconManager()->GetItemFactory().CreateSpecificItem( ( const CEconGameAccount *) NULL, pToolDef->GetDefinitionIndex() );
			CEconItem *pTarget = GEconManager()->GetItemFactory().CreateSpecificItem( ( const CEconGameAccount *) NULL, pTargetDef->GetDefinitionIndex() );

			if ( CEconSharedToolSupport::ToolCanApplyTo( pTool, pTarget ) != interfaceTests[ i ].m_bExpectedValidity )
			{
				bAllSuccess = false;
				pVecErrors->AddToTail( CFmtStr( "Tool validity test %i failed: %s %s have been able to apply to %s.",
									   i,
									   pToolDef->GetDefinitionName(),
									   interfaceTests[ i ].m_bExpectedValidity ? "should" : "shouldn't",
									   pTargetDef->GetDefinitionName() ).Access() );
			}
			
			delete pTool;
			delete pTarget;
		}
	}




	return bAllSuccess;
}
#endif // TF_GC_DLL
#endif // defined(GC_DLL)

bool CEconItemSchema::BPostSchemaInit( CUtlVector<CUtlString> *pVecErrors ) const
{
	bool bAllSuccess = true;

	// Make sure all of our tools are valid. We have to do this after the whole schema is initialized so
	// that we don't run into circular reference problems with items referencing loot lists that reference
	// items, etc.
	FOR_EACH_MAP_FAST( m_mapItems, i )
	{
		const CEconItemDefinition *pItemDef = m_mapItems[i];
		const IEconTool *pTool = pItemDef->GetEconTool();
		
		if ( pTool && !const_cast<IEconTool *>( pTool )->BFinishInitialization() )
		{
#ifdef GC_DLL
			bAllSuccess = false;
			pVecErrors->AddToTail( CFmtStr( "BPostSchemaInit(): tool '%s' is invalid.", pItemDef->GetDefinitionName() ).Get() );
#endif // GC_DLL
		}
#if TF_GC_DLL
		else
		{
			// all cosmetic items should have these two attributes from the
			// cosmetic_killeater_attribs prefab in case we ever try to drop them as Strange
			static CSchemaAttributeDefHandle pAttribDef_KillEaterScoreType( "kill eater score type" );
			static CSchemaAttributeDefHandle pAttribDef_KillEaterKillType( "kill eater kill type" );

			const CTFItemDefinition *pTFItemDef = assert_cast< const CTFItemDefinition* >( pItemDef );
			if ( pTFItemDef )
			{
				int nSlot = pTFItemDef->GetLoadoutSlot( 0 ); // 0 gives use the default slot
				if ( ( nSlot == LOADOUT_POSITION_HEAD ) || ( nSlot == LOADOUT_POSITION_MISC ) || ( nSlot == LOADOUT_POSITION_MISC2 ) )
				{
					bool bFoundScore = false;
					bool bFoundKill = false;

					FOR_EACH_VEC( pTFItemDef->GetStaticAttributes(), iIndex )
					{
						const static_attrib_t& staticAttrib = pTFItemDef->GetStaticAttributes()[iIndex];
						const CEconItemAttributeDefinition *pAttrDef = GetItemSchema()->GetAttributeDefinition( staticAttrib.iDefIndex );
						if ( pAttrDef == pAttribDef_KillEaterScoreType )
						{
							bFoundScore = true;
						}
						else if ( pAttrDef == pAttribDef_KillEaterKillType )
						{
							bFoundKill = true;
						}
					}

					if ( !bFoundScore || !bFoundKill )
					{
						bAllSuccess = false;
						pVecErrors->AddToTail( CFmtStr( "BPostSchemaInit(): '%s' is missing the standard cosmetic killeater attributes.", pItemDef->GetDefinitionName() ).Get() );
					}
				}
			}
		}
#endif // TF_GC_DLL
	}

#if TF_GC_DLL
	// Make sure our tool application code validity works correctly.
	if ( !BTestToolApplicability( pVecErrors ) )
	{
		bAllSuccess = false;
		pVecErrors->AddToTail( "BPostSchemaInit(): error with tool application validity." );
	}

	const CEconLootListDefinition* pUnusualLootlist = GetItemSchema()->GetLootListByName( "all_particle_hats" );
	if ( !pUnusualLootlist )
	{
		bAllSuccess = false;
		pVecErrors->AddToTail( "No lootlist \"all_particle_hats\"" );
	}
	else
	{
		auto& contents = pUnusualLootlist->GetLootListContents();
		FOR_EACH_VEC( contents, i )
		{
			if ( contents[ i ].m_iItemOrLootlistDef > 0 )
			{
				const CEconItemDefinition* pItemDef = GetItemDefinition( contents[ i ].m_iItemOrLootlistDef );
				if ( !( pItemDef->GetEquipRegionMask() & GetItemSchema()->GetEquipRegionBitMaskByName( "hat" ) ) 
				  && !( pItemDef->GetEquipRegionMask() & GetItemSchema()->GetEquipRegionBitMaskByName( "whole_head" ) ) )
				{
					bAllSuccess = false;
					pVecErrors->AddToTail( CFmtStr( "Item \"%s\" is in all_particle_hats, but doesn't have equip region hat or whole_head, meaning it can't become unusual.  REMOVE IT!", pItemDef->GetDefinitionName() ).Get() );
				}
			}
		}
	}
#endif // TF_GC_DLL

	return bAllSuccess;
}

//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
CItemLevelingDefinition::CItemLevelingDefinition( void )
{
}

//-----------------------------------------------------------------------------
// Purpose:	Copy constructor
//-----------------------------------------------------------------------------
CItemLevelingDefinition::CItemLevelingDefinition( const CItemLevelingDefinition &that )
{
	(*this) = that;
}

//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
CItemLevelingDefinition::~CItemLevelingDefinition()
{
	// Free up strdup() memory.
	free( m_pszLocalizedName_LocalStorage );
}

//-----------------------------------------------------------------------------
// Purpose:	Operator=
//-----------------------------------------------------------------------------
CItemLevelingDefinition &CItemLevelingDefinition::operator=( const CItemLevelingDefinition &other )
{
	m_unLevel = other.m_unLevel;
	m_unRequiredScore = other.m_unRequiredScore;
	m_pszLocalizedName_LocalStorage = strdup( other.m_pszLocalizedName_LocalStorage );

	return *this;
}

//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
bool CItemLevelingDefinition::BInitFromKV( KeyValues *pKVItemLevel, const char *pszLevelBlockName, CUtlVector<CUtlString> *pVecErrors )
{
	m_unLevel = Q_atoi( pKVItemLevel->GetName() );
	m_unRequiredScore = pKVItemLevel->GetInt( "score" );
	m_pszLocalizedName_LocalStorage = strdup( pKVItemLevel->GetString( "rank_name", CFmtStr( "%s%i", pszLevelBlockName, m_unLevel ).Access() ) );

	return SCHEMA_INIT_SUCCESS();
}

#ifdef GC_DLL
EUniverse GetUniverse()
{
	return GGCHost()->GetUniverse();
}
#endif // GC_DLL