BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/game/shared/econ/econ_item_schema.cpp

9706 lines
350 KiB
C++
Raw Blame History

//========= 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
Reference in New Issue View Git Blame Copy Permalink