3375 lines
134 KiB
C++
3375 lines
134 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: EconItemSchema: Defines a schema for econ items
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef ECONITEMSCHEMA_H
|
|
#define ECONITEMSCHEMA_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
// Valve code doesn't play nicely with standard headers on some platforms sometimes.
|
|
#ifdef min
|
|
#undef min
|
|
#endif
|
|
|
|
#ifdef max
|
|
#undef max
|
|
#endif
|
|
|
|
#include <string>
|
|
|
|
#include "KeyValues.h"
|
|
#include "tier1/utldict.h"
|
|
#include "tier1/utlhashmaplarge.h"
|
|
#include "econ_item_constants.h"
|
|
|
|
#include "item_selection_criteria.h"
|
|
#include "bitvec.h"
|
|
#include "language.h"
|
|
#include "smartptr.h"
|
|
#include "rtime.h"
|
|
#include "checksum_sha1.h"
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
#include "engine/ivmodelinfo.h"
|
|
#include "engine/ivmodelrender.h"
|
|
#include "ilocalize.h"
|
|
#endif
|
|
#include "gamestringpool.h"
|
|
|
|
class CEconItemSchema;
|
|
class CEconItem;
|
|
class CEconSharedObjectCache;
|
|
class CSOItemRecipe;
|
|
|
|
union attribute_data_union_t
|
|
{
|
|
float asFloat;
|
|
uint32 asUint32;
|
|
byte *asBlobPointer;
|
|
};
|
|
|
|
struct static_attrib_t
|
|
{
|
|
static_attrib_t()
|
|
{
|
|
iDefIndex = 0;
|
|
m_value.asBlobPointer = NULL;
|
|
#ifdef GC_DLL
|
|
bForceGCToGenerate = false;
|
|
m_pKVCustomData = NULL;
|
|
#endif // GC_DLL
|
|
}
|
|
|
|
~static_attrib_t()
|
|
{
|
|
#ifdef GC_DLL
|
|
if ( m_pKVCustomData )
|
|
m_pKVCustomData->deleteThis();
|
|
m_pKVCustomData = NULL;
|
|
#endif
|
|
}
|
|
|
|
static_attrib_t( const static_attrib_t& rhs )
|
|
{
|
|
iDefIndex = rhs.iDefIndex;
|
|
m_value = rhs.m_value;
|
|
#ifdef GC_DLL
|
|
m_pKVCustomData = rhs.m_pKVCustomData ? rhs.m_pKVCustomData->MakeCopy() : NULL;
|
|
bForceGCToGenerate = rhs.bForceGCToGenerate;
|
|
#endif
|
|
}
|
|
|
|
attrib_definition_index_t iDefIndex;
|
|
attribute_data_union_t m_value;
|
|
#ifdef GC_DLL
|
|
bool bForceGCToGenerate;
|
|
KeyValues *m_pKVCustomData;
|
|
#endif // GC_DLL
|
|
|
|
// Parses a single subsection from a multi-line attribute block that looks like:
|
|
//
|
|
// "attributes"
|
|
// {
|
|
// "cannot trade"
|
|
// {
|
|
// "attribute_class" "cannot_trade"
|
|
// "value" "1"
|
|
// }
|
|
// "kill eater"
|
|
// {
|
|
// "attribute_class" "kill_eater"
|
|
// "force_gc_to_generate" "1"
|
|
// "use_custom_logic" "gifts_given_out"
|
|
// }
|
|
// }
|
|
//
|
|
// The "force_gc_to_generate" and "use_custom_logic" fields will only be parsed on the GC. Will return
|
|
// true/false based on whether the whole attribute and value parsed successfully.
|
|
bool BInitFromKV_MultiLine( const char *pszContext, KeyValues *pKVAttribute, CUtlVector<CUtlString> *pVecErrors );
|
|
|
|
// Parses a single subsection from a single-line attribute block that looks like:
|
|
//
|
|
// CharacterAttributes
|
|
// {
|
|
// "increase buff duration" 9.0
|
|
// "damage bonus" 2.0
|
|
// }
|
|
//
|
|
// It's impossible to specify GC-generated attributes in this format. Will return true/false based on
|
|
// whether the whole attribute and value parsed successfully.
|
|
bool BInitFromKV_SingleLine( const char *pszContext, KeyValues *pKVAttribute, CUtlVector<CUtlString> *pVecErrors, bool bEnableTerribleBackwardsCompatibilitySchemaParsingCode = true );
|
|
|
|
// Data access helpers.
|
|
const class CEconItemAttributeDefinition *GetAttributeDefinition() const;
|
|
const class ISchemaAttributeType *GetAttributeType() const;
|
|
};
|
|
|
|
typedef uint16 equipped_class_t;
|
|
typedef uint16 equipped_slot_t;
|
|
typedef uint8 equipped_preset_t;
|
|
|
|
#define INVALID_EQUIPPED_SLOT ((equipped_slot_t)-1)
|
|
#define INVALID_STYLE_INDEX ((style_index_t)-1)
|
|
#define INVALID_PRESET_INDEX ((equipped_preset_t)-1)
|
|
|
|
enum EEquipType_t
|
|
{
|
|
EQUIP_TYPE_CLASS = 0,
|
|
EQUIP_TYPE_ACCOUNT,
|
|
|
|
EQUIP_TYPE_INVALID,
|
|
};
|
|
|
|
// Streamable weapons cause stutters when people enter PVS. Turn it off for now.
|
|
// #define WITH_STREAMABLE_WEAPONS
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// IEconItemPropertyGenerator
|
|
//-----------------------------------------------------------------------------
|
|
class IEconItemPropertyGenerator
|
|
{
|
|
public:
|
|
virtual ~IEconItemPropertyGenerator() { }
|
|
|
|
MUST_CHECK_RETURN virtual bool BGenerateProperties( CEconItem *pItem ) const = 0;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Item Series
|
|
//-----------------------------------------------------------------------------
|
|
class CEconItemSeriesDefinition
|
|
{
|
|
public:
|
|
CEconItemSeriesDefinition( void );
|
|
CEconItemSeriesDefinition( const CEconItemSeriesDefinition &that );
|
|
CEconItemSeriesDefinition &operator=( const CEconItemSeriesDefinition& rhs );
|
|
|
|
~CEconItemSeriesDefinition( void ) { }
|
|
|
|
bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
int32 GetDBValue( void ) const { return m_nValue; }
|
|
const char *GetName( void ) const { return !m_strName.IsEmpty() ? m_strName.String() : "unknown"; }
|
|
const char *GetLocKey( void ) const { return !m_strLockKey.IsEmpty() ? m_strLockKey.String() : "unknown"; }
|
|
const char *GetUiFile( void ) const { return !m_strUiFile.IsEmpty() ? m_strUiFile.String() : "unknown"; }
|
|
|
|
private:
|
|
|
|
// The value that the game/DB will know this series by
|
|
int32 m_nValue;
|
|
|
|
CUtlString m_strName; // Key Name
|
|
CUtlString m_strLockKey; // Localization key
|
|
CUtlString m_strUiFile; // Ui File (.res file)
|
|
};
|
|
//-----------------------------------------------------------------------------
|
|
// CEconItemRarityDefinition
|
|
//-----------------------------------------------------------------------------
|
|
class CEconItemRarityDefinition
|
|
{
|
|
public:
|
|
CEconItemRarityDefinition( void );
|
|
|
|
~CEconItemRarityDefinition( void ) { }
|
|
|
|
bool BInitFromKV( KeyValues *pKVItem, KeyValues *pKVRarityWeights, CEconItemSchema &pschema, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
int32 GetDBValue( void ) const { return m_nValue; }
|
|
const char *GetName( void ) const { return !m_strName.IsEmpty() ? m_strName.String() : "unknown"; }
|
|
const char *GetLocKey( void ) const { return m_strLocKey.String(); }
|
|
const char *GetWepLocKey( void ) const { return m_strWepLocKey.String(); }
|
|
const char *GetDropSound( void ) const { return m_strDropSound.String(); }
|
|
attrib_colors_t GetAttribColor( void ) const { return m_iAttribColor; }
|
|
const char *GetNextRarity( void ) const { return m_strNextRarity.String(); }
|
|
int32 GetLootlistWeight( void ) const { return m_nLootlistWeight; }
|
|
|
|
private:
|
|
|
|
// The value that the game/DB will know this rarity by
|
|
int32 m_nValue;
|
|
|
|
attrib_colors_t m_iAttribColor;
|
|
|
|
// The English name of the rarity
|
|
CUtlString m_strName;
|
|
|
|
// The localization key for this rarity.
|
|
CUtlString m_strLocKey;
|
|
// The localization key for this rarity, for weapons.
|
|
CUtlString m_strWepLocKey;
|
|
|
|
// The loot list name associated with this rarity.
|
|
CUtlString m_strDropSound;
|
|
|
|
CUtlString m_strNextRarity;
|
|
|
|
int32 m_nLootlistWeight;
|
|
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CEconItemQualityDefinition
|
|
// Template Definition of a randomly created item
|
|
//-----------------------------------------------------------------------------
|
|
class CEconItemQualityDefinition
|
|
{
|
|
public:
|
|
CEconItemQualityDefinition( void );
|
|
CEconItemQualityDefinition( const CEconItemQualityDefinition &that );
|
|
CEconItemQualityDefinition &operator=( const CEconItemQualityDefinition& rhs );
|
|
|
|
~CEconItemQualityDefinition( void ) { }
|
|
|
|
bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
|
|
int32 GetDBValue( void ) const { return m_nValue; }
|
|
const char *GetName( void ) const { return !m_strName.IsEmpty() ? m_strName.Get() : "unknown"; }
|
|
bool CanSupportSet( void ) const { return m_bCanSupportSet; }
|
|
const char *GetHexColor( void ) const { return !m_strHexColor.IsEmpty() ? m_strHexColor.Get() : "B2B2B2"; }
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
void Validate( CValidator &validator, const char *pchName )
|
|
{
|
|
VALIDATE_SCOPE();
|
|
ValidateObj( m_strName );
|
|
}
|
|
#endif // DBGFLAG_VALIDATE
|
|
|
|
private:
|
|
|
|
// The value that the game/DB will know this quality by
|
|
int32 m_nValue;
|
|
|
|
// The English name of the quality
|
|
CUtlConstString m_strName;
|
|
|
|
// if this is true the support tool is allowed to set this quality level on any item
|
|
bool m_bCanSupportSet;
|
|
|
|
// A hex string representing the color this quality should display as. Used primarily for display on the Web.
|
|
CUtlConstString m_strHexColor;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CEconColorDefinition
|
|
//-----------------------------------------------------------------------------
|
|
class CEconColorDefinition
|
|
{
|
|
public:
|
|
bool BInitFromKV( KeyValues *pKVColor, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
const char *GetName( void ) const { return m_strName.Get(); }
|
|
const char *GetColorName( void ) const { return m_strColorName.Get(); } // meant for passing into VGUI styles, etc.
|
|
const char *GetHexColor( void ) const { return m_strHexColor.Get(); }
|
|
|
|
private:
|
|
// The English name of this color. Only used for lookup.
|
|
CUtlConstString m_strName;
|
|
|
|
// The VGUI name of the color in our schema. This will be used to set values
|
|
// for VGUI controls.
|
|
CUtlConstString m_strColorName;
|
|
|
|
// The hex string value of this color. This will be used for Web display.
|
|
CUtlConstString m_strHexColor;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CEconItemSetDefinition
|
|
// Definition of an item set
|
|
//-----------------------------------------------------------------------------
|
|
class CEconItemSetDefinition
|
|
{
|
|
public:
|
|
CEconItemSetDefinition( void );
|
|
CEconItemSetDefinition( const CEconItemSetDefinition &that );
|
|
CEconItemSetDefinition &operator=( const CEconItemSetDefinition& rhs );
|
|
|
|
~CEconItemSetDefinition( void ) {}
|
|
|
|
bool BInitFromKV( KeyValues *pKVItemSet, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
void IterateAttributes( class IEconItemAttributeIterator *pIterator ) const;
|
|
|
|
public:
|
|
|
|
const char *m_pszName;
|
|
const char *m_pszLocalizedName;
|
|
CUtlVector<item_definition_index_t> m_iItemDefs;
|
|
int m_iBundleItemDef; // Item def of the store bundle for this set, if any
|
|
bool m_bIsHiddenSet; // If true, this set and any bonuses will only be visible if the whole set is equipped.
|
|
|
|
struct itemset_attrib_t
|
|
{
|
|
attrib_definition_index_t m_iAttribDefIndex;
|
|
float m_flValue;
|
|
};
|
|
CUtlVector<itemset_attrib_t> m_iAttributes;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
class CEconItemCollectionDefinition
|
|
{
|
|
public:
|
|
CEconItemCollectionDefinition( void );
|
|
~CEconItemCollectionDefinition( void ) {}
|
|
|
|
bool BInitFromKV( KeyValues *pKVItemCollection, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
uint8 GetMinRarity() const { return m_iRarityMin; }
|
|
uint8 GetMaxRarity() const { return m_iRarityMax; }
|
|
|
|
public:
|
|
|
|
const char *m_pszName;
|
|
const char *m_pszLocalizedName;
|
|
const char *m_pszLocalizedDesc;
|
|
CUtlVector<item_definition_index_t> m_iItemDefs;
|
|
|
|
private:
|
|
bool m_bIsReferenceCollection;
|
|
|
|
uint8 m_iRarityMin;
|
|
uint8 m_iRarityMax;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
class CEconItemPaintKitDefinition
|
|
{
|
|
public:
|
|
CEconItemPaintKitDefinition( void );
|
|
~CEconItemPaintKitDefinition( void );
|
|
|
|
bool BInitFromKV( KeyValues *pKVItemPaintKit, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
//KeyValues *GetKVP() { return m_pKVItem; }
|
|
|
|
const char *GetName() const { return m_pszName; }
|
|
const char *GetLocalizeName() const { return m_pszLocalizedName; }
|
|
|
|
KeyValues *GetPaintKitWearKV( int nWear );
|
|
|
|
private:
|
|
const char *m_pszName;
|
|
const char *m_pszLocalizedName;
|
|
|
|
CUtlVector< KeyValues * > m_vecPaintKitWearKVP;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
class CEconOperationDefinition
|
|
{
|
|
public:
|
|
CEconOperationDefinition( void );
|
|
~CEconOperationDefinition( void );
|
|
|
|
bool BInitFromKV( KeyValues *pKVOperation, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
const char *GetName() const { return m_pszName; }
|
|
operation_definition_index_t GetOperationID() const { return m_unOperationID; }
|
|
item_definition_index_t GetRequiredItemDefIndex() const { return m_unRequiredItemDefIndex; }
|
|
item_definition_index_t GetGatewayItemDefIndex() const { return m_unGatewayItemDefIndex; }
|
|
|
|
KeyValues *GetKVP() { return m_pKVItem; }
|
|
|
|
// use the date that we stop giving things to players as expiry date
|
|
bool IsExpired() const { return CRTime::RTime32TimeCur() > GetStopGivingToPlayerDate(); }
|
|
bool IsActive() const { return CRTime::RTime32TimeCur() >= GetStartDate() && !IsExpired(); }
|
|
|
|
const char *GetQuestLogOverrideResFile() const { return m_pszQuestLogResFile; }
|
|
const char *GetQuestListOverrideResFile() const { return m_pszQuestListResFile; }
|
|
|
|
RTime32 GetStartDate() const { return m_OperationStartDate; }
|
|
RTime32 GetStopGivingToPlayerDate() const { return m_StopGivingToPlayerDate; }
|
|
RTime32 GetStopAddingToQueueDate() const { return m_StopAddingToQueueDate; }
|
|
|
|
const char *GetOperationLootlist() const { return m_pszOperationLootList; }
|
|
bool IsCampaign() const { return m_bIsCampaign; }
|
|
uint32 GetMaxDropCount() const { return m_unMaxDropCount; }
|
|
|
|
#ifdef GC_DLL
|
|
enum EContractRewardLootlist_t
|
|
{
|
|
REWARD_CASE,
|
|
REWARD_WEAPON,
|
|
|
|
NUM_REWARDS
|
|
};
|
|
const char *GetContractRewardLootlist( EContractRewardLootlist_t eType ) const { return m_pszContractRewardLootlist[ eType ]; }
|
|
|
|
RTime32 GetMinQueueFreq() const;
|
|
RTime32 GetMaxQueueFreq() const;
|
|
RTime32 GetMinDropFreq() const;
|
|
RTime32 GetMaxDropFreq() const;
|
|
|
|
uint8 GetNumSeededContracts() const { return m_unSeed; }
|
|
uint16 GetNumMaxHeldDrops() const { return m_unMaxHeldDrops; }
|
|
|
|
int GetNumMaxQueueCount() const { return m_nMaxQueueCount; }
|
|
|
|
uint8 GetMaxDropPerThink() const { return m_unMaxDropPerThink; }
|
|
|
|
#endif // GC_DLL
|
|
|
|
private:
|
|
const char *m_pszName;
|
|
operation_definition_index_t m_unOperationID;
|
|
|
|
// things operation periodically drops
|
|
const char *m_pszOperationLootList;
|
|
bool m_bIsCampaign;
|
|
uint32 m_unMaxDropCount;
|
|
|
|
const char *m_pszQuestLogResFile;
|
|
const char *m_pszQuestListResFile;
|
|
|
|
item_definition_index_t m_unRequiredItemDefIndex;
|
|
item_definition_index_t m_unGatewayItemDefIndex; // Defindex of the item users need to acquire in order to get the required item. Could be the required item itself.
|
|
|
|
RTime32 m_OperationStartDate; // when the operation starts and gives out rewards
|
|
RTime32 m_StopGivingToPlayerDate; // when the operation stops giving quests to player
|
|
RTime32 m_StopAddingToQueueDate; // when the operation stops adding more quests to the bucket
|
|
|
|
#ifdef GC_DLL
|
|
const char *m_pszContractRewardLootlist[ NUM_REWARDS ];
|
|
|
|
// in seconds
|
|
RTime32 m_rtQueueFreqMin;
|
|
RTime32 m_rtQueueFreqMax;
|
|
RTime32 m_rtDropFreqMin;
|
|
RTime32 m_rtDropFreqMax;
|
|
|
|
uint8 m_unSeed;
|
|
uint16 m_unMaxHeldDrops;
|
|
int m_nMaxQueueCount;
|
|
|
|
uint8 m_unMaxDropPerThink;
|
|
|
|
#endif // GC_DLL
|
|
|
|
KeyValues *m_pKVItem;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CEconLootListDefinition
|
|
// Definition of a loot list
|
|
//-----------------------------------------------------------------------------
|
|
class IEconLootList
|
|
{
|
|
public:
|
|
virtual ~IEconLootList() { }
|
|
|
|
MUST_CHECK_RETURN virtual bool BPublicListContents() const = 0;
|
|
MUST_CHECK_RETURN virtual const char *GetLootListHeaderLocalizationKey() const = 0;
|
|
MUST_CHECK_RETURN virtual const char *GetLootListFooterLocalizationKey() const = 0;
|
|
MUST_CHECK_RETURN virtual const char *GetLootListCollectionReference() const = 0;
|
|
|
|
class IEconLootListIterator
|
|
{
|
|
public:
|
|
virtual ~IEconLootListIterator() { }
|
|
virtual void OnIterate( item_definition_index_t unItemDefIndex ) = 0;
|
|
};
|
|
|
|
virtual void EnumerateUserFacingPotentialDrops( IEconLootListIterator *pIt ) const = 0;
|
|
|
|
#ifdef GC_DLL
|
|
MUST_CHECK_RETURN virtual bool BGenerateSingleRollRandomItems( const CEconGameAccount *pGameAccount, bool bFreeAccount, CUtlVector<CEconItem *> *out_pvecItems, const CUtlVector< item_definition_index_t > *pVecAvoidItemDefs = NULL ) const = 0;
|
|
#endif // GC_DLL
|
|
};
|
|
|
|
#ifdef GC_DLL
|
|
struct lootlist_attrib_t
|
|
{
|
|
static_attrib_t m_staticAttrib;
|
|
float m_flWeight;
|
|
|
|
bool BInitFromKV( const char *pszContext, KeyValues *pKVKey, CEconItemSchema &pschema, CUtlVector<CUtlString> *pVecErrors );
|
|
};
|
|
|
|
struct random_attrib_t
|
|
{
|
|
float m_flChanceOfRandomAttribute;
|
|
float m_flTotalAttributeWeight;
|
|
bool m_bPickAllAttributes;
|
|
CUtlVector<lootlist_attrib_t> m_RandomAttributes;
|
|
|
|
bool RollRandomAttributes( CUtlVector< static_attrib_t >& vecAttributes, const CEconGameAccount *pGameAccount ) const;
|
|
};
|
|
#endif // GC_DLL
|
|
|
|
class CEconLootListDefinition : public IEconLootList
|
|
{
|
|
public:
|
|
struct drop_period_t
|
|
{
|
|
bool IsValidForTime( const RTime32& time ) const;
|
|
|
|
RTime32 m_DropStartDate;
|
|
RTime32 m_DropEndDate;
|
|
};
|
|
|
|
struct drop_item_t
|
|
{
|
|
int m_iItemOrLootlistDef; // negative values indicate nested loot lists
|
|
float m_flWeight;
|
|
drop_period_t m_dropPeriod;
|
|
};
|
|
|
|
struct loot_list_additional_drop_t
|
|
{
|
|
float m_fChance;
|
|
bool m_bPremiumOnly;
|
|
const char *m_pszLootListDefName;
|
|
int m_iRequiredHolidayIndex;
|
|
drop_period_t m_dropPeriod;
|
|
};
|
|
|
|
virtual ~CEconLootListDefinition();
|
|
|
|
bool BInitFromKV( KeyValues *pKVLootList, CEconItemSchema &pschema, CUtlVector<CUtlString> *pVecErrors );
|
|
|
|
const char *GetName() const { return m_pszName; }
|
|
virtual const char *GetLootListHeaderLocalizationKey() const OVERRIDE { return m_pszLootListHeader; }
|
|
virtual const char *GetLootListFooterLocalizationKey() const OVERRIDE { return m_pszLootListFooter; }
|
|
virtual const char *GetLootListCollectionReference() const OVERRIDE { return m_pszCollectionReference; }
|
|
|
|
const CUtlVector<drop_item_t>& GetLootListContents() const { return m_DropList; }
|
|
#ifdef GC_DLL
|
|
const CUtlVector<loot_list_additional_drop_t>& GetAdditionalDrops() const { return m_AdditionalDrops; }
|
|
#endif
|
|
virtual void EnumerateUserFacingPotentialDrops( IEconLootListIterator *pIt ) const OVERRIDE;
|
|
|
|
virtual bool BPublicListContents() const OVERRIDE
|
|
{
|
|
return m_bPublicListContents;
|
|
}
|
|
|
|
#ifdef GC_DLL
|
|
|
|
public:
|
|
struct rolled_item_defs_t
|
|
{
|
|
const CEconItemDefinition *m_pItemDef;
|
|
CCopyableUtlVector< const CEconLootListDefinition * > m_vecAffectingLootLists;
|
|
};
|
|
|
|
bool AddRandomAtrributes( KeyValues *pRandomAttributesKV, CEconItemSchema &pschema, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
bool AddRandomAttributesFromTemplates( KeyValues *pRandomAttributesKV, CEconItemSchema &pschema, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
|
|
// Generates a single roll for this loot list as well as each "additional drop" loot list specified. This will return
|
|
// true if all items were created successfully or false if anything went wrong in any of the relevant lootlists. All
|
|
// items created will be returned via out_pvecItems.
|
|
MUST_CHECK_RETURN virtual bool BGenerateSingleRollRandomItems( const CEconGameAccount *pGameAccount, bool bFreeAccount, CUtlVector<CEconItem *> *out_pvecItems, const CUtlVector< item_definition_index_t > *pVecAvoidItemDefs = NULL ) const OVERRIDE;
|
|
|
|
void RollRandomAttributes( CUtlVector< static_attrib_t >& vecAttributes, const CEconGameAccount *pGameAccount ) const;
|
|
bool RollRandomItemsAndAdditionalItems( IUniformRandomStream *pRandomStream, bool bFreeAccount, CUtlVector<rolled_item_defs_t> *out_pVecRolledItems, const CUtlVector< item_definition_index_t > *pVecAvoidItemDefs = NULL ) const;
|
|
|
|
uint8 GetRarity() const { return m_unRarity; }
|
|
void GetRarityLootLists( CUtlVector< const CEconLootListDefinition* > *out_pVecRarityLootList ) const;
|
|
void GetItemDefs( CUtlVector< item_definition_index_t > *out_pVecItemDefs ) const;
|
|
|
|
private:
|
|
bool RollRandomItemDef( IUniformRandomStream *pRandomStream, bool bFreeAccount, CUtlVector<rolled_item_defs_t> *out_pVecRolledItems, const CUtlVector< item_definition_index_t > *pVecAvoidItemDefs = NULL ) const;
|
|
bool BIsInternalNoDupesLootList() const { return m_iNoDupesIterations >= 0; }
|
|
|
|
MUST_CHECK_RETURN bool BInitPropertyGeneratorsFromKV( KeyValues *pKV, CUtlVector<CUtlString> *pVecErrors );
|
|
#endif
|
|
|
|
private:
|
|
const char *m_pszName;
|
|
const char *m_pszLootListHeader;
|
|
const char *m_pszLootListFooter;
|
|
const char *m_pszCollectionReference;
|
|
CUtlVector<drop_item_t> m_DropList;
|
|
|
|
bool m_bPublicListContents; // do not show loot list contents to users (ie., when listing crate contents on Steam)
|
|
|
|
#ifdef GC_DLL
|
|
|
|
MUST_CHECK_RETURN bool BAttachLootListAttributes( const CEconGameAccount *pGameAccount, CEconItem *pItem ) const;
|
|
|
|
int m_iNoDupesIterations; // if less than zero, "no dupes" functionality disabled; if greater than or equal to zero, the number of iterations we want to run through passing no-dupe sets
|
|
|
|
CUtlVector<random_attrib_t*> m_RandomAttribs;
|
|
CUtlVector<loot_list_additional_drop_t> m_AdditionalDrops;
|
|
CUtlVector<const IEconItemPropertyGenerator *> m_PropertyGenerators;
|
|
|
|
uint8 m_unRarity;
|
|
#endif // GC_DLL
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CEconCraftingRecipeDefinition
|
|
// Template Definition of an item recipe
|
|
//-----------------------------------------------------------------------------
|
|
class CEconCraftingRecipeDefinition
|
|
{
|
|
public:
|
|
CEconCraftingRecipeDefinition( void );
|
|
virtual ~CEconCraftingRecipeDefinition( void ) { }
|
|
|
|
bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
#ifdef GC_DLL
|
|
bool BIsCraftableByUnverifiedClients() const { return m_bIsCraftableByUnverifiedClient; }
|
|
#endif // GC_DLL
|
|
|
|
virtual void CopyPolymorphic( const CEconCraftingRecipeDefinition *pSourceDef ) { *this = *pSourceDef; }
|
|
|
|
void SetDefinitionIndex( uint32 iIndex ) { m_nDefIndex = iIndex; }
|
|
int32 GetDefinitionIndex( void ) const { return m_nDefIndex; }
|
|
const char *GetName( void ) const { return !m_strName.IsEmpty() ? m_strName.String() : "unknown"; }
|
|
const char *GetName_A( void ) const { return !m_strN_A.IsEmpty() ? m_strN_A.String() : "unknown"; }
|
|
const char *GetDescInputs( void ) const { return !m_strDescInputs.IsEmpty() ? m_strDescInputs.String() : "unknown"; }
|
|
const char *GetDescOutputs( void ) const { return !m_strDescOutputs.IsEmpty() ? m_strDescOutputs.String() : "unknown"; }
|
|
|
|
const char *GetDescI_A( void ) const { return !m_strDI_A.IsEmpty() ? m_strDI_A.String() : "unknown"; }
|
|
const char *GetDescI_B( void ) const { return !m_strDI_B.IsEmpty() ? m_strDI_B.String() : "unknown"; }
|
|
const char *GetDescI_C( void ) const { return !m_strDI_C.IsEmpty() ? m_strDI_C.String() : "unknown"; }
|
|
const char *GetDescO_A( void ) const { return !m_strDO_A.IsEmpty() ? m_strDO_A.String() : "unknown"; }
|
|
const char *GetDescO_B( void ) const { return !m_strDO_B.IsEmpty() ? m_strDO_B.String() : "unknown"; }
|
|
const char *GetDescO_C( void ) const { return !m_strDO_C.IsEmpty() ? m_strDO_C.String() : "unknown"; }
|
|
|
|
bool IsDisabled( void ) const { return m_bDisabled; }
|
|
bool RequiresAllSameClass( void ) { return m_bRequiresAllSameClass; }
|
|
bool RequiresAllSameSlot( void ) { return m_bRequiresAllSameSlot; }
|
|
bool IsPremiumAccountOnly( void ) const { return m_bPremiumAccountOnly; }
|
|
recipecategories_t GetCategory( void ) const { return m_iCategory; }
|
|
int GetTotalInputItemsRequired( void ) const;
|
|
int GetTotalOutputItems( void ) const { return m_OutputItemsCriteria.Count(); }
|
|
|
|
// Returns true if the vector contains a set of items that matches the inputs for this recipe
|
|
virtual bool ItemListMatchesInputs( CUtlVector<CEconItem*> *vecCraftingItems, KeyValues *out_pCraftParams = NULL, bool bIgnoreSlop = false, CUtlVector<uint64> *vecChosenItems = NULL ) const;
|
|
|
|
const CUtlVector<CItemSelectionCriteria> *GetInputItems( void ) const { return &m_InputItemsCriteria; }
|
|
const CUtlVector<uint32> &GetInputItemDupeCounts( void ) const { return m_InputItemDupeCounts; }
|
|
const CUtlVector<CItemSelectionCriteria> &GetOutputItems( void ) const { return m_OutputItemsCriteria; }
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
void Validate( CValidator &validator, const char *pchName )
|
|
{
|
|
VALIDATE_SCOPE();
|
|
ValidateObj( m_InputItemsCriteria );
|
|
ValidateObj( m_InputItemDupeCounts );
|
|
ValidateObj( m_OutputItemsCriteria );
|
|
}
|
|
#endif // DBGFLAG_VALIDATE
|
|
|
|
// Serializes the criteria to and from messages
|
|
bool BSerializeToMsg( CSOItemRecipe & msg ) const;
|
|
bool BDeserializeFromMsg( const CSOItemRecipe & msg );
|
|
|
|
protected:
|
|
// The number used to refer to this definition in the DB
|
|
int32 m_nDefIndex;
|
|
|
|
// Localization key strings
|
|
CUtlString m_strName;
|
|
CUtlString m_strN_A;
|
|
CUtlString m_strDescInputs;
|
|
CUtlString m_strDescOutputs;
|
|
CUtlString m_strDI_A;
|
|
CUtlString m_strDI_B;
|
|
CUtlString m_strDI_C;
|
|
CUtlString m_strDO_A;
|
|
CUtlString m_strDO_B;
|
|
CUtlString m_strDO_C;
|
|
|
|
bool m_bDisabled;
|
|
#ifdef GC_DLL
|
|
bool m_bIsCraftableByUnverifiedClient;
|
|
#endif // GC_DLL
|
|
bool m_bRequiresAllSameClass;
|
|
bool m_bRequiresAllSameSlot;
|
|
int m_iCacheClassUsageForOutputFromItem;
|
|
int m_iCacheSlotUsageForOutputFromItem;
|
|
int m_iCacheSetForOutputFromItem;
|
|
bool m_bPremiumAccountOnly;
|
|
recipecategories_t m_iCategory;
|
|
|
|
// The list of items that a required to make this recipe
|
|
CUtlVector<CItemSelectionCriteria> m_InputItemsCriteria;
|
|
CUtlVector<uint32> m_InputItemDupeCounts;
|
|
|
|
// The list of items that are generated by this recipe
|
|
CUtlVector<CItemSelectionCriteria> m_OutputItemsCriteria;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Attribute definition details
|
|
//-----------------------------------------------------------------------------
|
|
enum
|
|
{
|
|
ATTDESCFORM_VALUE_IS_PERCENTAGE, // Printed as: ((m_flValue*100)-100.0)
|
|
ATTDESCFORM_VALUE_IS_INVERTED_PERCENTAGE, // Printed as: ((m_flValue*100)-100.0) if it's > 1.0, or ((1.0-m_flModifier)*100) if it's < 1.0
|
|
ATTDESCFORM_VALUE_IS_ADDITIVE, // Printed as: m_flValue
|
|
ATTDESCFORM_VALUE_IS_ADDITIVE_PERCENTAGE, // Printed as: (m_flValue*100)
|
|
ATTDESCFORM_VALUE_IS_OR, // Printed as: m_flValue, but results are ORd together instead of added
|
|
ATTDESCFORM_VALUE_IS_DATE, // Printed as a date
|
|
ATTDESCFORM_VALUE_IS_ACCOUNT_ID, // Printed as steam user name
|
|
ATTDESCFORM_VALUE_IS_PARTICLE_INDEX, // Printed as a particle description
|
|
ATTDESCFORM_VALUE_IS_KILLSTREAKEFFECT_INDEX,// Printed as killstreak effect description
|
|
ATTDESCFORM_VALUE_IS_KILLSTREAK_IDLEEFFECT_INDEX, // Printed as idle effect description
|
|
ATTDESCFORM_VALUE_IS_ITEM_DEF, // Printed as item name
|
|
ATTDESCFORM_VALUE_IS_FROM_LOOKUP_TABLE, // Printed as a string from a lookup table, specified by the attribute definition name
|
|
};
|
|
|
|
// Coloring for attribute lines
|
|
enum attrib_effect_types_t
|
|
{
|
|
ATTRIB_EFFECT_UNUSUAL = 0,
|
|
ATTRIB_EFFECT_STRANGE,
|
|
ATTRIB_EFFECT_NEUTRAL,
|
|
ATTRIB_EFFECT_POSITIVE,
|
|
ATTRIB_EFFECT_NEGATIVE,
|
|
|
|
NUM_EFFECT_TYPES,
|
|
};
|
|
|
|
enum EAssetClassAttrExportRule_t
|
|
{
|
|
k_EAssetClassAttrExportRule_Default = 0,
|
|
k_EAssetClassAttrExportRule_Bucketed = ( 1 << 0 ), // attribute exports bucketed value to Steam Community
|
|
k_EAssetClassAttrExportRule_Skip = ( 1 << 1 ), // attribute value is not exported to Steam Community
|
|
k_EAssetClassAttrExportRule_GCOnly = ( 1 << 2 ), // attribute only lives on GC and not exported to any external request
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CEconItemAttributeDefinition
|
|
// Template definition of a randomly created attribute
|
|
//-----------------------------------------------------------------------------
|
|
class CEconItemAttributeDefinition
|
|
{
|
|
public:
|
|
CEconItemAttributeDefinition( void );
|
|
CEconItemAttributeDefinition( const CEconItemAttributeDefinition &that );
|
|
CEconItemAttributeDefinition &operator=( const CEconItemAttributeDefinition& rhs );
|
|
|
|
~CEconItemAttributeDefinition( void );
|
|
|
|
bool BInitFromKV( KeyValues *pKVAttribute, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
attrib_definition_index_t GetDefinitionIndex( void ) const { return m_nDefIndex; }
|
|
// Attribute name referenced in the db.
|
|
const char *GetDefinitionName( void ) const { return m_pszDefinitionName; }
|
|
|
|
KeyValues *GetRawDefinition( void ) const { return m_pKVAttribute; }
|
|
|
|
// Data accessing
|
|
bool IsHidden( void ) const { return m_bHidden; }
|
|
bool BForceWebSchemaOutput( void ) const { return m_bWebSchemaOutputForced; }
|
|
bool BIsSetBonusAttribute( void ) const { return m_bIsSetBonus; }
|
|
bool CanAffectMarketName( void ) const { return m_bCanAffectMarketName; }
|
|
bool CanAffectRecipeComponentName( void ) const { return m_bCanAffectRecipeComponentName; }
|
|
bool IsStoredAsInteger( void ) const { return m_bStoredAsInteger; }
|
|
bool IsStoredAsFloat( void ) const { return !m_bStoredAsInteger; }
|
|
int GetUserGenerationType( void ) const { return m_iUserGenerationType; }
|
|
bool IsInstanceData() const { return m_bInstanceData; }
|
|
EAssetClassAttrExportRule_t GetAssetClassAttrExportRule() const { return m_eAssetClassAttrExportRule; }
|
|
uint32 GetAssetClassBucket() const { return m_unAssetClassBucket; }
|
|
int GetDescriptionFormat( void ) const { return m_iDescriptionFormat; }
|
|
const char *GetDescriptionString( void ) const { return m_pszDescriptionString; }
|
|
const char *GetArmoryDescString( void ) const { return m_pszArmoryDesc; }
|
|
const char *GetAttributeClass( void ) const { return m_pszAttributeClass; }
|
|
econ_tag_handle_t GetItemDefinitionTag( void ) const { return m_ItemDefinitionTag; }
|
|
attrib_effect_types_t GetEffectType( void ) const { return m_iEffectType; }
|
|
|
|
const class ISchemaAttributeType *GetAttributeType( void ) const { return m_pAttrType; }
|
|
|
|
#ifndef GC_DLL
|
|
void ClearStringCache( void ) const { m_iszAttributeClass = NULL_STRING; }
|
|
string_t GetCachedClass( void ) const
|
|
{
|
|
if ( m_iszAttributeClass == NULL_STRING && m_pszAttributeClass )
|
|
{
|
|
m_iszAttributeClass = AllocPooledString( m_pszAttributeClass );
|
|
}
|
|
return m_iszAttributeClass;
|
|
}
|
|
#endif
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
void Validate( CValidator &validator, const char *pchName )
|
|
{
|
|
VALIDATE_SCOPE();
|
|
ValidatePtr( m_pKVAttribute );
|
|
}
|
|
#endif // DBGFLAG_VALIDATE
|
|
|
|
private:
|
|
// The raw keyvalues for this attribute definition.
|
|
KeyValues *m_pKVAttribute;
|
|
|
|
// Required valued from m_pKVAttribute:
|
|
|
|
// The number used to refer to this definition in the DB
|
|
attrib_definition_index_t m_nDefIndex;
|
|
|
|
// A pointer to the schema-global type data for this attribute. This maps attribute types to functionality
|
|
// for loading/storing, both to memory and the DB.
|
|
const class ISchemaAttributeType *m_pAttrType;
|
|
|
|
// ---------------------------------------------
|
|
// Display related data
|
|
// ---------------------------------------------
|
|
// If true, this attribute isn't shown in the item description
|
|
bool m_bHidden;
|
|
|
|
// If true, this attribute's description is always output in web api calls regardless of the hidden flag.
|
|
bool m_bWebSchemaOutputForced;
|
|
|
|
// Whether or not the value is stored as an integer in the DB.
|
|
bool m_bStoredAsInteger;
|
|
|
|
// If this is true the attribute is counted as "instance" data for purposes of asset class in the Steam Economy. Non-instance
|
|
// properties are considered things that can differentiate items at a fundamental level (ie., definition index, quality); instance
|
|
// properties are more things like additional customizations -- score for strange items, paint color, etc.
|
|
bool m_bInstanceData;
|
|
EAssetClassAttrExportRule_t m_eAssetClassAttrExportRule; // if this is true the attribute will not be exported for asset class
|
|
uint32 m_unAssetClassBucket; // if this is set then attribute value is bucketed when exported for asset class
|
|
|
|
// Set item bonus attributes use a different attribute parser and make assumptions about memory layout. We
|
|
// don't really use these for any new content currently and it isn't worth touching all the old code.
|
|
//
|
|
// At runtime, this flag is used to determine whether or not to rebuild dynamic attributes attached to
|
|
// players on respawn.
|
|
bool m_bIsSetBonus;
|
|
|
|
// Whether or not this attribute is supposed to only come from user actions. These attributes are used for
|
|
// player item upgrades, etc. and cannot be set on items directly in the schema.
|
|
int m_iUserGenerationType;
|
|
|
|
// Overall positive/negative effect. Used to color the attribute.
|
|
attrib_effect_types_t m_iEffectType;
|
|
|
|
// Contains the description format & string for this attribute
|
|
int m_iDescriptionFormat;
|
|
const char *m_pszDescriptionString;
|
|
|
|
// Contains information on how to describe items with this attribute in the Armory
|
|
const char *m_pszArmoryDesc;
|
|
|
|
// Used to allow unique items to specify attributes by name.
|
|
const char *m_pszDefinitionName;
|
|
|
|
// The class name of this attribute. Used in creation, and to hook the attribute into the actual code that uses it.
|
|
const char *m_pszAttributeClass;
|
|
|
|
// Allowed to affect the market bucketization name. We dont want things like the strange level to affect the name,
|
|
// but we do want things like crate series number and strangifier targets to get their own buckets.
|
|
bool m_bCanAffectMarketName;
|
|
|
|
// Allowed to list itself in the name of an item in the recipe component description.
|
|
bool m_bCanAffectRecipeComponentName;
|
|
|
|
// Do item definitions with this attribute specified automatically get an additional tag applied?
|
|
econ_tag_handle_t m_ItemDefinitionTag;
|
|
|
|
#ifndef GC_DLL
|
|
mutable string_t m_iszAttributeClass; // Same as the above, but used for fast lookup when applying attributes.
|
|
#endif
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Visual data storage in item definitions
|
|
//-----------------------------------------------------------------------------
|
|
#define TEAM_VISUAL_SECTIONS 5
|
|
#define MAX_VISUALS_CUSTOM_SOUNDS 10
|
|
|
|
struct attachedparticlesystem_t
|
|
{
|
|
attachedparticlesystem_t() :
|
|
pszSystemName( NULL )
|
|
, bFollowRootBone( NULL )
|
|
, iCustomType( 0 )
|
|
, nSystemID( 0 )
|
|
, fRefireTime( 0 ) // only works for taunt effects, currently
|
|
, bDrawInViewModel( false )
|
|
, bUseSuffixName( false )
|
|
, bHasViewModelSpecificEffect ( false )
|
|
{
|
|
V_memset( pszControlPoints, 0, sizeof( pszControlPoints ) );
|
|
}
|
|
|
|
const char *pszSystemName;
|
|
bool bFollowRootBone;
|
|
int iCustomType;
|
|
int nSystemID;
|
|
float fRefireTime; // only works for taunt effects, currently
|
|
bool bDrawInViewModel;
|
|
bool bUseSuffixName;
|
|
bool bHasViewModelSpecificEffect;
|
|
|
|
const char *pszControlPoints[7];
|
|
};
|
|
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
enum
|
|
{
|
|
kAttachedModelDisplayFlag_WorldModel = 0x01,
|
|
kAttachedModelDisplayFlag_ViewModel = 0x02,
|
|
|
|
kAttachedModelDisplayFlag_MaskAll = kAttachedModelDisplayFlag_WorldModel | kAttachedModelDisplayFlag_ViewModel,
|
|
};
|
|
|
|
struct attachedmodel_t
|
|
{
|
|
const char *m_pszModelName;
|
|
int m_iModelDisplayFlags;
|
|
};
|
|
|
|
enum wearableanimplayback_t
|
|
{
|
|
WAP_ON_SPAWN, // Play this animation immediately on spawning the wearable
|
|
WAP_START_BUILDING, // Game code will start this anim whenever a player wearing this item deploys their builder weapon.
|
|
WAP_STOP_BUILDING, // Game code will start this anim whenever a player wearing this item holsters their builder weapon.
|
|
WAP_START_TAUNTING, // Game code will start this anim whenever a player wearing this item taunts
|
|
WAP_STOP_TAUNTING, // Game code will start this anim whenever a player wearing this item stops taunting
|
|
|
|
NUM_WAP_TYPES,
|
|
};
|
|
|
|
struct animation_on_wearable_t
|
|
{
|
|
int iActivity;
|
|
const char *pszActivity;
|
|
const char *pszReplacement;
|
|
int iReplacement; // Replacement activity to play. Might be set to one of kActivityLookup_Unknown/kActivityLookup_Missing.
|
|
const char *pszSequence;
|
|
const char *pszRequiredItem;
|
|
const char *pszScene;
|
|
};
|
|
|
|
struct activity_on_wearable_t
|
|
{
|
|
wearableanimplayback_t iPlayback;
|
|
int iActivity;
|
|
const char *pszActivity;
|
|
};
|
|
|
|
struct codecontrolledbodygroupdata_t
|
|
{
|
|
const char *pFuncName;
|
|
void *pFunc;
|
|
};
|
|
|
|
// This is a workaround because Source practice is to disable operator=() for CUtlMap.
|
|
struct perteamvisuals_maps_t
|
|
{
|
|
perteamvisuals_maps_t()
|
|
{
|
|
m_ModifiedBodyGroupNames.SetLessFunc( StringLessThan );
|
|
m_CodeControlledBodyGroupNames.SetLessFunc( StringLessThan );
|
|
}
|
|
|
|
void operator=( const perteamvisuals_maps_t& other )
|
|
{
|
|
DeepCopyMap( other.m_ModifiedBodyGroupNames, &m_ModifiedBodyGroupNames );
|
|
DeepCopyMap( other.m_CodeControlledBodyGroupNames, &m_CodeControlledBodyGroupNames );
|
|
}
|
|
|
|
CUtlMap<const char*, int> m_ModifiedBodyGroupNames; // Better method: hide multiple body groups by name.
|
|
CUtlMap<const char*, codecontrolledbodygroupdata_t> m_CodeControlledBodyGroupNames;
|
|
};
|
|
|
|
#endif // defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
|
|
class CEconStyleInfo
|
|
{
|
|
public:
|
|
CEconStyleInfo()
|
|
{
|
|
for ( int i = 0; i < TEAM_VISUAL_SECTIONS; i++ )
|
|
{
|
|
m_iSkins[i] = 0;
|
|
m_iViewmodelSkins[i] = -1;
|
|
}
|
|
|
|
m_pszName = NULL;
|
|
m_pszBasePlayerModel = NULL;
|
|
m_bIsSelectable = true;
|
|
m_pszInventoryImage = NULL;
|
|
|
|
m_pszBodygroupName = NULL;
|
|
m_iBodygroupSubmodelIndex = -1;
|
|
|
|
m_sIconURLSmall = "";
|
|
m_sIconURLLarge = "";
|
|
}
|
|
|
|
virtual ~CEconStyleInfo()
|
|
{
|
|
//
|
|
}
|
|
|
|
virtual void BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors );
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
virtual void GeneratePrecacheModelStringsForStyle( CUtlVector<const char *> *out_pVecModelStrings ) const;
|
|
#endif
|
|
|
|
int GetSkin( int iTeam, bool bViewmodel ) const
|
|
{
|
|
Assert( iTeam >= 0 );
|
|
Assert( iTeam < TEAM_VISUAL_SECTIONS );
|
|
|
|
if ( bViewmodel && m_iViewmodelSkins[ iTeam ] != -1 )
|
|
{
|
|
return m_iViewmodelSkins[ iTeam ];
|
|
}
|
|
|
|
return m_iSkins[iTeam];
|
|
}
|
|
|
|
const char *GetName() const { return m_pszName; }
|
|
const char *GetBasePlayerDisplayModel() const { return m_pszBasePlayerModel; }
|
|
const CUtlVector<const char *>& GetAdditionalHideBodygroups() const { return m_vecAdditionalHideBodygroups; }
|
|
bool IsSelectable() const { return m_bIsSelectable; }
|
|
const char *GetInventoryImage() const { return m_pszInventoryImage; }
|
|
|
|
const char *GetBodygroupName() const { return m_pszBodygroupName; }
|
|
int GetBodygroupSubmodelIndex() const { return m_iBodygroupSubmodelIndex; }
|
|
|
|
const char *GetIconURLSmall() const { return m_sIconURLSmall; }
|
|
const char *GetIconURLLarge() const { return m_sIconURLLarge; }
|
|
void SetIconURLSmall( const char *szURL ) { m_sIconURLSmall = szURL; }
|
|
void SetIconURLLarge( const char *szURL ) { m_sIconURLLarge = szURL; }
|
|
|
|
protected:
|
|
int m_iSkins[TEAM_VISUAL_SECTIONS];
|
|
int m_iViewmodelSkins[TEAM_VISUAL_SECTIONS];
|
|
const char *m_pszName;
|
|
const char *m_pszBasePlayerModel;
|
|
bool m_bIsSelectable;
|
|
const char *m_pszInventoryImage;
|
|
|
|
const char *m_pszBodygroupName;
|
|
int m_iBodygroupSubmodelIndex;
|
|
|
|
CUtlVector<const char *> m_vecAdditionalHideBodygroups;
|
|
|
|
private:
|
|
|
|
CUtlString m_sIconURLSmall;
|
|
CUtlString m_sIconURLLarge;
|
|
};
|
|
|
|
struct perteamvisuals_t
|
|
{
|
|
perteamvisuals_t()
|
|
{
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
iHideParentBodyGroup = -1;
|
|
|
|
iSkin = -1;
|
|
bUsePerClassBodygroups = false;
|
|
pszMaterialOverride = NULL;
|
|
pszMuzzleFlash = NULL;
|
|
pszTracerEffect = NULL;
|
|
pszParticleEffect = NULL;
|
|
for ( int i = 0; i < MAX_VISUALS_CUSTOM_SOUNDS; i++ )
|
|
{
|
|
pszCustomSounds[i] = NULL;
|
|
}
|
|
|
|
for ( int i = 0; i < NUM_SHOOT_SOUND_TYPES; i++ )
|
|
{
|
|
pszWeaponSoundReplacements[i] = NULL;
|
|
}
|
|
|
|
m_iViewModelBodyGroupOverride = -1;
|
|
m_iViewModelBodyGroupStateOverride = -1;
|
|
m_iWorldModelBodyGroupOverride = -1;
|
|
m_iWorldModelBodyGroupStateOverride = -1;
|
|
|
|
#endif // defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
}
|
|
|
|
~perteamvisuals_t()
|
|
{
|
|
m_Styles.PurgeAndDeleteElements();
|
|
}
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
int iHideParentBodyGroup;
|
|
|
|
// Properties necessary for the game client/server but not for the GC.
|
|
perteamvisuals_maps_t m_Maps;
|
|
int iSkin;
|
|
bool bUsePerClassBodygroups;
|
|
CUtlVector<attachedmodel_t> m_AttachedModels;
|
|
CUtlVector<attachedmodel_t> m_AttachedModelsFestive; // Attr controlled Festive Attachments
|
|
CUtlVector<attachedparticlesystem_t> m_AttachedParticles;
|
|
CUtlVector<animation_on_wearable_t> m_Animations;
|
|
CUtlVector<activity_on_wearable_t> m_Activities;
|
|
const char *pszCustomSounds[MAX_VISUALS_CUSTOM_SOUNDS];
|
|
const char *pszMaterialOverride;
|
|
const char *pszMuzzleFlash;
|
|
const char *pszTracerEffect;
|
|
const char *pszParticleEffect;
|
|
const char *pszWeaponSoundReplacements[NUM_SHOOT_SOUND_TYPES];
|
|
int m_iViewModelBodyGroupOverride;
|
|
int m_iViewModelBodyGroupStateOverride;
|
|
int m_iWorldModelBodyGroupOverride;
|
|
int m_iWorldModelBodyGroupStateOverride;
|
|
#endif // defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
|
|
// The GC does care about styles.
|
|
CUtlVector<CEconStyleInfo *> m_Styles;
|
|
};
|
|
|
|
enum item_capabilities_t
|
|
{
|
|
ITEM_CAP_NONE = 0,
|
|
ITEM_CAP_PAINTABLE = 1 << 0,
|
|
ITEM_CAP_NAMEABLE = 1 << 1,
|
|
ITEM_CAP_DECODABLE = 1 << 2,
|
|
ITEM_CAP_CAN_BE_CRAFTED_IF_PURCHASED = 1 << 3, // was ITEM_CAP_CAN_MOD_SOCKET
|
|
ITEM_CAP_CAN_CUSTOMIZE_TEXTURE = 1 << 4,
|
|
ITEM_CAP_USABLE = 1 << 5,
|
|
ITEM_CAP_USABLE_GC = 1 << 6,
|
|
ITEM_CAP_CAN_GIFT_WRAP = 1 << 7,
|
|
ITEM_CAP_USABLE_OUT_OF_GAME = 1 << 8,
|
|
ITEM_CAP_CAN_COLLECT = 1 << 9,
|
|
ITEM_CAP_CAN_CRAFT_COUNT = 1 << 10,
|
|
ITEM_CAP_CAN_CRAFT_MARK = 1 << 11,
|
|
ITEM_CAP_PAINTABLE_TEAM_COLORS = 1 << 12,
|
|
ITEM_CAP_CAN_BE_RESTORED = 1 << 13, // can users remove properties (paint, nametag, etc.) from this item via the in-game UI?
|
|
ITEM_CAP_CAN_USE_STRANGE_PARTS = 1 << 14,
|
|
ITEM_CAP_CAN_CARD_UPGRADE = 1 << 15,
|
|
ITEM_CAP_CAN_STRANGIFY = 1 << 16,
|
|
ITEM_CAP_CAN_KILLSTREAKIFY = 1 << 17,
|
|
ITEM_CAP_CAN_CONSUME = 1 << 18,
|
|
ITEM_CAP_CAN_SPELLBOOK_PAGE = 1 << 19, // IT'S A VERB OKAY
|
|
ITEM_CAP_HAS_SLOTS = 1 << 20,
|
|
ITEM_CAP_DUCK_UPGRADABLE = 1 << 21,
|
|
ITEM_CAP_CAN_UNUSUALIFY = 1 << 22,
|
|
NUM_ITEM_CAPS = 23,
|
|
};
|
|
|
|
enum { ITEM_CAP_DEFAULT = ITEM_CAP_CAN_CRAFT_MARK | ITEM_CAP_CAN_BE_RESTORED | ITEM_CAP_CAN_USE_STRANGE_PARTS | ITEM_CAP_CAN_CARD_UPGRADE | ITEM_CAP_CAN_STRANGIFY | ITEM_CAP_CAN_KILLSTREAKIFY | ITEM_CAP_CAN_CONSUME | ITEM_CAP_CAN_GIFT_WRAP }; // what are the default capabilities on an item?
|
|
enum { ITEM_CAP_TOOL_DEFAULT = ITEM_CAP_NONE }; // what are the default capabilities of a tool?
|
|
|
|
struct bundleinfo_t
|
|
{
|
|
CUtlVector<CEconItemDefinition *> vecItemDefs;
|
|
};
|
|
|
|
#ifdef GC_DLL
|
|
enum EPaymentRuleType
|
|
{
|
|
kPaymentRule_SteamWorkshopFileID = 0x01,
|
|
kPaymentRule_PartnerSteamID = 0x02,
|
|
kPaymentRule_Bundle = 0x04,
|
|
};
|
|
|
|
struct econ_item_payment_rule_t
|
|
{
|
|
double m_RevenueShare;
|
|
EPaymentRuleType m_eRuleType;
|
|
CCopyableUtlVector<uint64> m_vecValues;
|
|
};
|
|
#endif // GC_DLL
|
|
|
|
#ifdef CLIENT_DLL
|
|
namespace vgui
|
|
{
|
|
class Panel;
|
|
}
|
|
#endif // CLIENT_DLL
|
|
|
|
class IEconTool
|
|
{
|
|
friend class CEconSharedToolSupport;
|
|
|
|
public:
|
|
IEconTool( const char *pszTypeName, const char *pszUseString, const char *pszUsageRestriction, item_capabilities_t unCapabilities )
|
|
: m_pszTypeName( pszTypeName )
|
|
, m_pszUseString( pszUseString )
|
|
, m_pszUsageRestriction( pszUsageRestriction )
|
|
, m_unCapabilities( unCapabilities )
|
|
{
|
|
//
|
|
}
|
|
|
|
virtual ~IEconTool() { }
|
|
|
|
// Shared code.
|
|
const char *GetUsageRestriction() const { return m_pszUsageRestriction; }
|
|
item_capabilities_t GetCapabilities() const { return m_unCapabilities; }
|
|
|
|
virtual bool CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const { Assert( pTool ); Assert( pToolSubject ); return true; }
|
|
virtual bool ShouldDisplayQuantity( const IEconItemInterface *pTool ) const;
|
|
virtual bool RequiresToolEscrowPeriod() const { return false; }
|
|
|
|
// We don't support throwing exceptions from tool construction so this is intended to be checked afterwards
|
|
// whenever a new tool is created. (See CreateEconToolImpl().)
|
|
virtual bool BFinishInitialization() { return true; }
|
|
|
|
// Used by the GC only for WebAPI responses and for some weird internal code.
|
|
const char *GetTypeName() const { return m_pszTypeName; } // would like to disable on the client so we aren't tempted to check against it, but used for building a unique tool list
|
|
const char *GetUseString() const { return m_pszUseString; }
|
|
|
|
#ifdef CLIENT_DLL
|
|
virtual bool CanBeUsedNow( const IEconItemInterface *pItem ) const { return true; }
|
|
virtual bool ShouldShowContainedItemPanel( const IEconItemInterface *pItem ) const { Assert( !"IEconTool::ShouldShowContainedItemPanel(): we don't expect this to be called on anything besides gifts!" ); return false; }
|
|
virtual bool ShouldDisplayAsUseableOnItemsInArmory() const { return true; }
|
|
virtual const char *GetUseCommandLocalizationToken( const IEconItemInterface *pItem, int i = 0 ) const;
|
|
virtual int GetUseCommandCount( const IEconItemInterface *pItem ) const { return 1; }
|
|
virtual const char* GetUseCommand( const IEconItemInterface *pItem, int i = 0 ) const;
|
|
|
|
|
|
// Client "do something" interface. At least one of these functions must be implemented or your tool
|
|
// won't do anything on the client. Some tools (ie., collections) will implement both because they
|
|
// have one application behavior and one client-UI behavior.
|
|
|
|
// When the client attempts to use a consumable item of any kind, this function will be called. This
|
|
// is called from the UI in response to things like using dueling pistols, using a noisemaker, etc.
|
|
// Usually this opens up some UI, sends off a GC message, etc.
|
|
//
|
|
// There is a "default" implementation of this function in ClientConsumableTool_Generic() that can
|
|
// be called if specific behavior isn't needed.
|
|
virtual void OnClientUseConsumable( class C_EconItemView *pItem, vgui::Panel *pParent ) const
|
|
{
|
|
Assert( !"IEconTool::OnClientUseConsumable(): unimplemented call!" );
|
|
}
|
|
|
|
// When the client attempts to apply a tool to a specific other item in their inventory, this function
|
|
// will be called. This is called from the UI is response to things like putting paint on an item,
|
|
// using a key to unlock a crate, etc.
|
|
virtual void OnClientApplyTool( class C_EconItemView *pTool, class C_EconItemView *pSubject, vgui::Panel *pParent ) const
|
|
{
|
|
Assert( !"IEconTool::OnClientApplyTool(): unimplemented call!" );
|
|
}
|
|
#endif // CLIENT_DLL
|
|
|
|
#ifdef GC_DLL
|
|
virtual class CGCEconConsumableBehavior *CreateGCConsumableBehavior() const;
|
|
virtual bool BGenerateDynamicAttributes( CEconItem* pItem, const CEconGameAccount *pGameAccount ) const { return true; }
|
|
#endif // GC_DLL
|
|
|
|
private:
|
|
const char *m_pszTypeName;
|
|
const char *m_pszUseString;
|
|
const char *m_pszUsageRestriction;
|
|
item_capabilities_t m_unCapabilities;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CQuestObjectiveDefinition
|
|
//-----------------------------------------------------------------------------
|
|
class CQuestObjectiveDefinition
|
|
{
|
|
public:
|
|
|
|
CQuestObjectiveDefinition( void );
|
|
virtual ~CQuestObjectiveDefinition( void );
|
|
|
|
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
uint32 GetDefinitionIndex( void ) const { return m_nDefIndex; }
|
|
const char *GetDescriptionToken( void ) const { return m_pszDescriptionToken; }
|
|
bool IsOptional() const { return m_bOptional; }
|
|
bool IsAdvanced() const { return m_bAdvanced; }
|
|
uint32 GetPoints() const { return m_nPoints; } // TODO: change to a float
|
|
|
|
private:
|
|
const char *m_pszDescriptionToken;
|
|
uint32 m_nDefIndex;
|
|
uint32 m_nPoints;
|
|
bool m_bOptional;
|
|
bool m_bAdvanced;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CEconItemDefinition
|
|
// Template Definition of a randomly created item
|
|
//-----------------------------------------------------------------------------
|
|
class CEconItemDefinition
|
|
{
|
|
public:
|
|
CEconItemDefinition( void );
|
|
virtual ~CEconItemDefinition( void );
|
|
|
|
// BInitFromKV can be implemented on subclasses to parse additional values.
|
|
virtual bool BInitFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
virtual bool BInitFromTestItemKVs( int iNewDefIndex, KeyValues *pKVItem, CUtlVector<CUtlString>* pVecErrors = NULL );
|
|
virtual void GeneratePrecacheModelStrings( bool bDynamicLoad, CUtlVector<const char *> *out_pVecModelStrings ) const;
|
|
virtual void GeneratePrecacheSoundStrings( bool bDynamicLoad, CUtlVector<const char *> *out_pVecSoundStrings ) const;
|
|
virtual void CopyPolymorphic( const CEconItemDefinition *pSourceDef ) { *this = *pSourceDef; }
|
|
#endif
|
|
|
|
bool BInitItemMappings( CUtlVector<CUtlString> *pVecErrors );
|
|
|
|
void BInitVisualBlockFromKV( KeyValues *pKVItem, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
void BInitStylesBlockFromKV( KeyValues *pKVStyles, perteamvisuals_t *pVisData, CUtlVector<CUtlString> *pVecErrors );
|
|
|
|
item_definition_index_t GetDefinitionIndex( void ) const { return m_nDefIndex; }
|
|
bool BEnabled( void ) const { return m_bEnabled; }
|
|
bool BLoadOnDemand( void ) const { return m_bLoadOnDemand; }
|
|
bool BHasBeenLoaded( void ) const { return m_bHasBeenLoaded; }
|
|
const char *GetDefinitionName( void ) const { return m_pszDefinitionName; }
|
|
const char *GetItemDefinitionName( void ) const { return m_pszDefinitionName; }
|
|
const char *GetItemClass( void ) const { return m_pszItemClassname; }
|
|
const char *GetItemBaseName( void ) const { return m_pszItemBaseName; }
|
|
const char *GetBrassModelOverride( void ) const{ return m_pszBrassModelOverride; }
|
|
const char *GetItemTypeName( void ) const { return m_pszItemTypeName; }
|
|
uint8 GetMinLevel( void ) const { return m_unMinItemLevel; }
|
|
uint8 GetMaxLevel( void ) const { return m_unMaxItemLevel; }
|
|
uint8 GetItemSeries( void ) const { return m_unItemSeries; }
|
|
uint8 GetQuality( void ) const { return m_nItemQuality; }
|
|
void SetRarity( uint8 nRarity ) { Assert( m_nItemRarity == k_unItemRarity_Any ); m_nItemRarity = nRarity; }
|
|
uint8 GetRarity( void ) const { return m_nItemRarity; }
|
|
uint8 GetForcedQuality( void ) const { return m_nForcedItemQuality; }
|
|
uint16 GetDefaultDropQuantity( void ) const { return m_nDefaultDropQuantity; }
|
|
KeyValues *GetRawDefinition( void ) const { return m_pKVItem; }
|
|
const char *GetDefinitionString( const char *pszKeyName, const char *pszDefaultValue = "" ) const;
|
|
KeyValues *GetDefinitionKey( const char *pszKeyName ) const;
|
|
const CUtlVector<static_attrib_t> &GetStaticAttributes( void ) const { return m_vecStaticAttributes; }
|
|
#ifdef TF_CLIENT_DLL
|
|
uint32 GetNumConcreteItems() const { return m_unNumConcreteItems; }
|
|
#endif // TF_CLIENT_DLL
|
|
|
|
// Data accessing
|
|
bool IsHidden( void ) const { return m_bHidden; }
|
|
bool IsImported( void ) const { return m_bImported; }
|
|
bool IsAllowedInMatch( void ) const { return m_bAllowedInThisMatch; }
|
|
bool IsBaseItem( void ) const { return m_bBaseItem; }
|
|
bool IsBundle( void ) const { return m_BundleInfo != NULL; }
|
|
bool HasProperName( void ) const { return m_bProperName; }
|
|
const char *GetClassToken( void ) const { return m_pszClassToken; }
|
|
const char *GetSlotToken( void ) const { return m_pszSlotToken; }
|
|
bool ShouldAttachToHands( void ) const { return m_bAttachToHands; }
|
|
bool ShouldAttachToHandsVMOnly( void ) const { return m_bAttachToHandsVMOnly; }
|
|
bool ShouldFlipViewmodels( void ) const { return m_bFlipViewModel; }
|
|
int GetInventoryImagePosition( int iIndex ) const { Assert( iIndex >= 0 && iIndex < 2); return m_iInventoryImagePosition[iIndex]; }
|
|
int GetInventoryImageSize( int iIndex ) const { Assert( iIndex >= 0 && iIndex < 2); return m_iInventoryImageSize[iIndex]; }
|
|
int GetDropType( void ) const { return m_iDropType; }
|
|
const char *GetHolidayRestriction( void ) const { return m_pszHolidayRestriction; }
|
|
int GetVisionFilterFlags( void ) const { return m_nVisionFilterFlags; }
|
|
int GetSubType( void ) const { return m_iSubType; }
|
|
item_capabilities_t GetCapabilities( void ) const { return m_iCapabilities; }
|
|
int GetArmoryRemap( void ) const { return m_iArmoryRemap; }
|
|
int GetStoreRemap( void ) const { return m_iStoreRemap; }
|
|
item_definition_index_t GetSetItemRemap() const { return m_unSetItemRemapDefIndex; } // what def index do we consider ourself for purposes of determining "is an item equipped that satisfies this set slot?" (ie., Festive Huntsman -> Huntsman); default is to point to itself
|
|
const char *GetXifierRemapClass() const { return m_pszXifierRemapClass; }
|
|
const char *GetBaseFunctionalItemName() const { return m_pszBaseFunctionalItemName; }
|
|
const char *GetParticleSuffix() const { return m_pszParticleSuffix; }
|
|
|
|
const CEconItemSetDefinition *GetItemSetDefinition( void ) const { return m_pItemSetDef; }
|
|
void SetItemSetDefinition( const CEconItemSetDefinition *pItemSetDef ) { Assert( !m_pItemSetDef ); m_pItemSetDef = pItemSetDef; }
|
|
|
|
const CEconItemCollectionDefinition *GetItemCollectionDefinition( void ) const { return m_pItemCollectionDef; }
|
|
void SetItemCollectionDefinition( const CEconItemCollectionDefinition *pItemCollectionDef ) { Assert( !m_pItemCollectionDef ); m_pItemCollectionDef = pItemCollectionDef; }
|
|
|
|
CEconItemPaintKitDefinition *GetCustomPainkKitDefinition( void ) const { return m_pItemPaintKitDef; }
|
|
void SetItemPaintKitDefinition( CEconItemPaintKitDefinition *pItemPaintKitDef ) { Assert( !m_pItemPaintKitDef ); m_pItemPaintKitDef = pItemPaintKitDef; }
|
|
|
|
perteamvisuals_t *GetPerTeamVisual( int iTeam ) const { return m_PerTeamVisuals[iTeam]; }
|
|
|
|
bool IsTool() const { return m_bIsTool; }
|
|
const IEconTool *GetEconTool() const { return m_pTool; }
|
|
template < class T >
|
|
const T *GetTypedEconTool() const { return dynamic_cast<const T *>( GetEconTool() ); }
|
|
|
|
const bundleinfo_t *GetBundleInfo( void ) const { return m_BundleInfo; }
|
|
virtual int GetBundleItemCount( void ) const { return m_BundleInfo ? m_BundleInfo->vecItemDefs.Count() : 0; }
|
|
virtual int GetBundleItem( int iIndex ) const { return m_BundleInfo ? m_BundleInfo->vecItemDefs[iIndex]->GetDefinitionIndex() : -1; }
|
|
|
|
// Is this item contained in any bundles? GetContainingBundles() gets the CEconItemDefinitions for those bundles.
|
|
const CUtlVector< const CEconItemDefinition * > &GetContainingBundles() const { return m_vecContainingBundleItemDefs; }
|
|
uint32 GetContainingBundleCount() const { return m_vecContainingBundleItemDefs.Count(); }
|
|
|
|
void AddSteamWorkshopContributor( uint32 unAccountID ) { if ( m_vecSteamWorkshopContributors.InvalidIndex() == m_vecSteamWorkshopContributors.Find( unAccountID ) ) { m_vecSteamWorkshopContributors.AddToTail( unAccountID ); } }
|
|
const CUtlVector< uint32 > &GetSteamWorkshopContributors() const { return m_vecSteamWorkshopContributors; }
|
|
bool BIsSteamWorkshopItem() const { return m_vecSteamWorkshopContributors.Count() > 0; }
|
|
|
|
const char *GetIconClassname( void ) const { return m_pszItemIconClassname; }
|
|
const char *GetLogClassname( void ) const { return m_pszItemLogClassname; }
|
|
const char *GetInventoryModel( void ) const { return m_pszInventoryModel; }
|
|
const char *GetInventoryImage( void ) const { return m_pszInventoryImage; }
|
|
const char *GetInventoryOverlayImage( int idx ) const { if ( m_pszInventoryOverlayImages.IsValidIndex( idx ) ) return m_pszInventoryOverlayImages[idx]; else return NULL; }
|
|
int GetInventoryOverlayImageCount( void ) const { return m_pszInventoryOverlayImages.Count(); }
|
|
int GetInspectPanelDistance( void ) const { return m_iInspectPanelDistance; }
|
|
const char *GetIconURLSmall() const { return GetIconURL( "s" ); } // Plain small
|
|
const char *GetIconURLLarge() const { return GetIconURL( "l" ); } // Plain large
|
|
void SetIconURL( const char* pszKey, const char *szURL ) { m_pDictIcons->Insert( pszKey, CUtlString( szURL ) ); }
|
|
const char *GetIconURL( const char* pszKey ) const;
|
|
const char *GetBasePlayerDisplayModel() const { return m_pszBaseDisplayModel; }
|
|
int GetDefaultSkin() const { return m_iDefaultSkin; }
|
|
const char *GetWorldDisplayModel() const { return m_pszWorldDisplayModel; }
|
|
const char *GetCollectionReference() const { return m_pszCollectionReference; }
|
|
|
|
// Some weapons need a custom model for icon generation. If this value is not present, the world model is used.
|
|
virtual const char *GetIconDisplayModel() const;
|
|
|
|
const char *GetExtraWearableModel( void ) const { return m_pszWorldExtraWearableModel; }
|
|
const char *GetExtraWearableViewModel( void ) const { return m_pszWorldExtraWearableViewModel; }
|
|
const char *GetVisionFilteredDisplayModel() const { return m_pszVisionFilteredDisplayModel; }
|
|
const char *GetItemDesc( void ) const { return m_pszItemDesc; }
|
|
const char *GetArmoryDescString( void ) const { return m_pszArmoryDesc; }
|
|
RTime32 GetExpirationDate( void ) const { return m_rtExpiration; }
|
|
bool ShouldShowInArmory( void ) const { return m_bShouldShowInArmory; }
|
|
bool IsActingAsAWearable( void ) const { return m_bActAsWearable; }
|
|
bool IsActingAsAWeapon( void ) const { return m_bActAsWeapon; }
|
|
bool GetHideBodyGroupsDeployedOnly( void ) const { return m_bHideBodyGroupsDeployedOnly; }
|
|
bool IsPackBundle( void ) const { return m_bIsPackBundle; }
|
|
bool IsPackItem( void ) const { return m_bIsPackItem; }
|
|
CEconItemDefinition *GetOwningPackBundle() { return m_pOwningPackBundle; }
|
|
const CEconItemDefinition *GetOwningPackBundle() const { return m_pOwningPackBundle; }
|
|
const char *GetDatabaseAuditTableName( void ) const { return m_pszDatabaseAuditTable; }
|
|
|
|
void SetIsPackItem( bool bIsPackItem ) { m_bIsPackItem = bIsPackItem; }
|
|
|
|
equip_region_mask_t GetEquipRegionMask( void ) const { return m_unEquipRegionMask; }
|
|
equip_region_mask_t GetEquipRegionConflictMask( void ) const { return m_unEquipRegionConflictMask; }
|
|
|
|
// Dynamic modification during gameplay
|
|
void SetAllowedInMatch( bool bAllowed ) { m_bAllowedInThisMatch = bAllowed; }
|
|
void SetHasBeenLoaded( bool bLoaded ) { m_bHasBeenLoaded = bLoaded; }
|
|
|
|
// Generate and return a random level according to whatever leveling curve this definition uses.
|
|
uint32 RollItemLevel( void ) const;
|
|
|
|
const char *GetFirstSaleDate( void ) const;
|
|
|
|
void IterateAttributes( class IEconItemAttributeIterator *pIterator ) const;
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
// Visuals
|
|
// Attached models
|
|
int GetNumAttachedModels( int iTeam ) const;
|
|
attachedmodel_t *GetAttachedModelData( int iTeam, int iIdx ) const;
|
|
|
|
int GetNumAttachedModelsFestivized( int iTeam ) const;
|
|
attachedmodel_t *GetAttachedModelDataFestivized( int iTeam, int iIdx ) const;
|
|
|
|
// Attached particle systems
|
|
int GetNumAttachedParticles( int iTeam ) const;
|
|
attachedparticlesystem_t *GetAttachedParticleData( int iTeam, int iIdx ) const;
|
|
// Activities
|
|
int GetNumPlaybackActivities( int iTeam ) const;
|
|
activity_on_wearable_t *GetPlaybackActivityData( int iTeam, int iIdx ) const;
|
|
// Animations
|
|
int GetNumAnimations( int iTeam ) const;
|
|
animation_on_wearable_t *GetAnimationData( int iTeam, int iIdx ) const;
|
|
// Animation Overrides
|
|
Activity GetActivityOverride( int iTeam, Activity baseAct ) const;
|
|
const char *GetActivityOverride( int iTeam, const char *pszActivity ) const;
|
|
const char *GetReplacementForActivityOverride( int iTeam, Activity baseAct ) const;
|
|
// Should the content (meshes, etc.) for this be streamed or preloaded?
|
|
virtual bool IsContentStreamable() const;
|
|
#endif // defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
|
|
// FX Overrides
|
|
const char *GetMuzzleFlash( int iTeam ) const;
|
|
const char *GetTracerEffect( int iTeam ) const;
|
|
const char *GetParticleEffect( int iTeam ) const;
|
|
// Materials
|
|
const char *GetMaterialOverride( int iTeam ) const;
|
|
// Sounds
|
|
const char *GetCustomSound( int iTeam, int iSound ) const;
|
|
const char *GetWeaponReplacementSound( int iTeam, /*WeaponSound_t*/ int iSound ) const;
|
|
// Bodygroups
|
|
int GetHiddenParentBodygroup( int iTeam ) const;
|
|
int GetNumModifiedBodyGroups( int iTeam ) const;
|
|
const char* GetModifiedBodyGroup( int iTeam, int i, int& body ) const;
|
|
bool UsesPerClassBodygroups( int iTeam ) const;
|
|
int GetNumCodeControlledBodyGroups( int iTeam ) const;
|
|
const char* GetCodeControlledBodyGroup( int iIteam, int i, struct codecontrolledbodygroupdata_t &ccbgd ) const;
|
|
|
|
style_index_t GetNumStyles() const;
|
|
style_index_t GetNumSelectableStyles() const;
|
|
const CEconStyleInfo *GetStyleInfo( style_index_t unStyle ) const;
|
|
|
|
int GetViewmodelBodygroupOverride( int iTeam ) const;
|
|
int GetViewmodelBodygroupStateOverride( int iTeam ) const;
|
|
int GetWorldmodelBodygroupOverride( int iTeam ) const;
|
|
int GetWorldmodelBodygroupStateOverride( int iTeam ) const;
|
|
|
|
int GetPopularitySeed() const { return m_nPopularitySeed; }
|
|
|
|
bool HasEconTag( econ_tag_handle_t tag ) const { return m_vecTags.IsValidIndex( m_vecTags.Find( tag ) ); }
|
|
|
|
bool BValidForShuffle( void ) const { return m_bValidForShuffle; }
|
|
bool BValidForSelfMade( void ) const { return m_bValidForSelfMade; }
|
|
|
|
#ifdef GC_DLL
|
|
private:
|
|
MUST_CHECK_RETURN bool BInitializeEconItemGenerators( KeyValues *pKV, CUtlVector<CUtlString> *pVecErrors );
|
|
|
|
public:
|
|
// If this returns true, all relevant property generators were applied to the item instance
|
|
// passed in. If this returns false, some or none of the generators may have been applied,
|
|
// but there are no guarantees about the item state.
|
|
MUST_CHECK_RETURN bool BApplyPropertyGenerators( CEconItem *pItem ) const;
|
|
|
|
const CUtlVector<econ_tag_handle_t>& GetEconTags() const { return m_vecTags; } // meant for internal/debug use only, not for runtime iteration
|
|
const CUtlVector<econ_item_payment_rule_t>& GetPaymentRules() const { return m_vecPaymentRules; }
|
|
|
|
private:
|
|
int AddPaymentRule( const econ_item_payment_rule_t& newRule ); // returns which payment rule number was just created
|
|
public:
|
|
#endif // GC_DLL
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
int GetStyleSkin( style_index_t unStyle, int iTeam, bool bViewmodel ) const;
|
|
const char* GetStyleInventoryImage( style_index_t unStyle ) const;
|
|
int GetBestVisualTeamData( int iTeam ) const;
|
|
#endif // defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
void Validate( CValidator &validator, const char *pchName )
|
|
{
|
|
VALIDATE_SCOPE();
|
|
ValidateObj( m_vecStaticAttributes );
|
|
ValidatePtr( m_pKVItem );
|
|
ValidatePtr( m_pProxyCriteria );
|
|
}
|
|
#endif // DBGFLAG_VALIDATE
|
|
|
|
|
|
private:
|
|
// Pointer to the raw KeyValue definition of the item
|
|
KeyValues * m_pKVItem;
|
|
|
|
// Required values from m_pKVItem:
|
|
|
|
// The number used to refer to this definition in the DB
|
|
item_definition_index_t m_nDefIndex;
|
|
|
|
// False if this definition has been turned off and we're not using it to generate items
|
|
bool m_bEnabled;
|
|
|
|
// These values specify the range of item levels that an item based off this definition can be generated within.
|
|
uint8 m_unMinItemLevel;
|
|
uint8 m_unMaxItemLevel;
|
|
|
|
// This specifies an item quality that items from this definition must be set to. Used mostly to specify unique item definitions.
|
|
uint8 m_nItemQuality;
|
|
uint8 m_nForcedItemQuality;
|
|
uint8 m_nItemRarity;
|
|
|
|
// Default drop quantity
|
|
uint16 m_nDefaultDropQuantity;
|
|
|
|
// Item Series
|
|
uint8 m_unItemSeries;
|
|
|
|
// Static attributes (ones that are always on these items)
|
|
CUtlVector<static_attrib_t> m_vecStaticAttributes;
|
|
|
|
// Seeds the popular item list with this number of the item when the list is reset.
|
|
uint8 m_nPopularitySeed;
|
|
|
|
// ---------------------------------------------
|
|
// Display related data
|
|
// ---------------------------------------------
|
|
// The base name of this item. i.e. "The Kritz-Krieg".
|
|
const char *m_pszItemBaseName;
|
|
bool m_bProperName; // If set, the name will have "The" prepended to it, unless it's got a non-unique quality
|
|
// in which case it'll have "A" prepended to the quality. i.e. A Community Kritzkrieg
|
|
|
|
// The base type of this item. i.e. "Rocket Launcher" or "Shotgun".
|
|
// This is often the same as the base name, but not always.
|
|
const char *m_pszItemTypeName;
|
|
|
|
// The item's non-attribute description.
|
|
const char *m_pszItemDesc;
|
|
|
|
// expiration time
|
|
RTime32 m_rtExpiration;
|
|
|
|
// The .mdl file used for this item when it's displayed in inventory-style boxes.
|
|
const char *m_pszInventoryModel;
|
|
// Alternatively, the image used for this item when it's displayed in inventory-style boxes. If specified, it's used over the model.
|
|
const char *m_pszInventoryImage;
|
|
// An optional image that's overlayed over the top of the base inventory image. It'll be RGB colored by the tint color of the item.
|
|
CUtlVector<const char*> m_pszInventoryOverlayImages;
|
|
int m_iInventoryImagePosition[2];
|
|
int m_iInventoryImageSize[2];
|
|
int m_iInspectPanelDistance;
|
|
|
|
const char *m_pszBaseDisplayModel;
|
|
int m_iDefaultSkin;
|
|
bool m_bLoadOnDemand;
|
|
bool m_bHasBeenLoaded;
|
|
|
|
bool m_bHideBodyGroupsDeployedOnly;
|
|
|
|
// The .mdl file used for the world view.
|
|
// This is inferior to using a c_model, but because the geometry of the sticky bomb launcher's
|
|
// world model is significantly different from the view model the demoman pack requires
|
|
// using two separate models for now.
|
|
const char *m_pszWorldDisplayModel;
|
|
const char *m_pszWorldExtraWearableModel; // Some weapons attach an extra wearable item to the player
|
|
const char *m_pszWorldExtraWearableViewModel; // Some weapons attach an extra wearable view model item to the player
|
|
const char *m_pszVisionFilteredDisplayModel; // Some weapons display differently depending on the viewer's filters
|
|
|
|
const char *m_pszCollectionReference; // Reference a colletion
|
|
|
|
// If set, we use the base hands model for a viewmodel, and bonemerge the above player model
|
|
bool m_bAttachToHands;
|
|
bool m_bAttachToHandsVMOnly;
|
|
|
|
// If set, we will force the view model to render flipped. Good for models built left handed.
|
|
bool m_bFlipViewModel;
|
|
|
|
// This is a wearable that sits in a non-wearable loadout slot
|
|
bool m_bActAsWearable;
|
|
|
|
// This is a weapon that sits in a wearable slot (Action)
|
|
bool m_bActAsWeapon;
|
|
|
|
// Is this Item a tool
|
|
bool m_bIsTool;
|
|
|
|
// The set this item is a member of
|
|
const CEconItemSetDefinition *m_pItemSetDef;
|
|
const CEconItemCollectionDefinition *m_pItemCollectionDef;
|
|
|
|
CEconItemPaintKitDefinition *m_pItemPaintKitDef;
|
|
|
|
// A list of per-team visual data used to modify base model for visual recognition
|
|
perteamvisuals_t *m_PerTeamVisuals[TEAM_VISUAL_SECTIONS];
|
|
|
|
// Optional override for specifying a custom shell ejection model
|
|
const char *m_pszBrassModelOverride;
|
|
|
|
IEconTool *m_pTool;
|
|
bundleinfo_t *m_BundleInfo;
|
|
item_capabilities_t m_iCapabilities;
|
|
|
|
#ifdef TF_CLIENT_DLL
|
|
uint32 m_unNumConcreteItems; // This is the number of items that will actually end up in a user's inventory - this can be 0 for some items (e.g. map stamps in TF), 1 for a "regular" item, or many for bundles, etc.
|
|
#endif // TF_CLIENT_DLL
|
|
|
|
CUtlDict< CUtlString >* m_pDictIcons;
|
|
|
|
// ---------------------------------------------
|
|
// Creation related data
|
|
// ---------------------------------------------
|
|
// The entity classname for this item.
|
|
const char *m_pszItemClassname;
|
|
|
|
// The entity name that will be displayed in log files.
|
|
const char *m_pszItemLogClassname;
|
|
|
|
// The name of the icon used in the death notices.
|
|
const char *m_pszItemIconClassname;
|
|
|
|
// This is the script file name of this definition. Used to generate items by script name.
|
|
const char *m_pszDefinitionName;
|
|
|
|
// This is used for auditing purposes
|
|
const char *m_pszDatabaseAuditTable;
|
|
|
|
bool m_bHidden;
|
|
bool m_bShouldShowInArmory;
|
|
bool m_bBaseItem;
|
|
bool m_bImported;
|
|
|
|
// A pack bundle is a bundle that contains items that are not for sale individually
|
|
bool m_bIsPackBundle;
|
|
|
|
// A pack item is an item which is not for sale individually and is only for sale as part of a pack bundle. A 'regular' bundle can only include a pack bundle by explicitly including all of the pack bundle's items individually.
|
|
// If this pointer is non-NULL, this item is considered to be a pack item (see CEconItemDefinition::IsPackItem()).
|
|
CEconItemDefinition *m_pOwningPackBundle;
|
|
bool m_bIsPackItem;
|
|
|
|
// Contains information on how to describe items with this attribute in the Armory
|
|
const char *m_pszArmoryDesc;
|
|
|
|
// Temporary(?) solution to allow xifiers to work on botkiller and festive variants of weapons
|
|
const char *m_pszXifierRemapClass;
|
|
|
|
// Base item name -- used for grouping weapon functionality
|
|
const char *m_pszBaseFunctionalItemName;
|
|
|
|
// For particle effects that have derivatives, what is the suffix for this item
|
|
const char *m_pszParticleSuffix;
|
|
|
|
// ---------------------------------------------
|
|
// Remapping data for armory/store
|
|
// ---------------------------------------------
|
|
int m_iArmoryRemap;
|
|
int m_iStoreRemap;
|
|
const char *m_pszArmoryRemap;
|
|
const char *m_pszStoreRemap;
|
|
|
|
// ---------------------------------------------
|
|
// Crafting related data
|
|
// ---------------------------------------------
|
|
const char *m_pszClassToken;
|
|
const char *m_pszSlotToken;
|
|
|
|
// ---------------------------------------------
|
|
// Gameplay related data
|
|
// ---------------------------------------------
|
|
// How to behave when the player wearing the item dies.
|
|
int m_iDropType;
|
|
|
|
// Holiday restriction. Item only has an appearance when the holiday is in effect.
|
|
const char *m_pszHolidayRestriction;
|
|
|
|
// Meet the pyro makes some items invisible unless you're wearing Pyro Goggles
|
|
int m_nVisionFilterFlags;
|
|
|
|
// Temporary. Revisit this in the engineer update. Enables an additional buildable.
|
|
int m_iSubType;
|
|
|
|
// Whitelist support for tournament mode
|
|
bool m_bAllowedInThisMatch;
|
|
|
|
equip_region_mask_t m_unEquipRegionMask; // which equip regions does this item cover directly
|
|
equip_region_mask_t m_unEquipRegionConflictMask; // which equip regions does equipping this item prevent from having something in them
|
|
|
|
item_definition_index_t m_unSetItemRemapDefIndex; // reference to the definition index we want to consider this item for set matching purposes; see GetSetItemRemap()
|
|
|
|
#ifdef GC_DLL
|
|
CUtlVector<const IEconItemPropertyGenerator *> m_vecPropertyGenerators;
|
|
CUtlVector<econ_item_payment_rule_t> m_vecPaymentRules;
|
|
#endif // GC_DLL
|
|
|
|
// False if this definition is not allowed to be part of a shuffled crate's contents
|
|
bool m_bValidForShuffle;
|
|
|
|
// False if this definition should not grant self-made items
|
|
bool m_bValidForSelfMade;
|
|
|
|
protected:
|
|
// Protected to allow subclasses to add/remove game-specific tags.
|
|
CUtlVector<econ_tag_handle_t> m_vecTags;
|
|
CUtlVector<const CEconItemDefinition *> m_vecContainingBundleItemDefs; // Item definition indices for any bundles which contain this item
|
|
CUtlVector<uint32> m_vecSteamWorkshopContributors;
|
|
|
|
friend class CEconItemSchema;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline style_index_t CEconItemDefinition::GetNumStyles() const
|
|
{
|
|
const perteamvisuals_t *pVisData = GetPerTeamVisual( 0 );
|
|
|
|
if ( !pVisData )
|
|
return 0;
|
|
|
|
// Bad things will happen if we ever get more styles than will fit in our
|
|
// style index type. Not Very Bad things, but bad things. Mostly we'll fail
|
|
// to iterate over all our styles.
|
|
return pVisData->m_Styles.Count();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Similar to GetNumStyles, but only the selectable styles
|
|
//-----------------------------------------------------------------------------
|
|
inline style_index_t CEconItemDefinition::GetNumSelectableStyles() const
|
|
{
|
|
const perteamvisuals_t *pVisData = GetPerTeamVisual(0);
|
|
|
|
if (!pVisData)
|
|
return 0;
|
|
|
|
style_index_t nCount = 0;
|
|
FOR_EACH_VEC( pVisData->m_Styles, i )
|
|
{
|
|
if( pVisData->m_Styles[i]->IsSelectable() )
|
|
{
|
|
++nCount;
|
|
}
|
|
}
|
|
|
|
return nCount;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline const CEconStyleInfo *CEconItemDefinition::GetStyleInfo( style_index_t unStyle ) const
|
|
{
|
|
const perteamvisuals_t *pBaseVisuals = GetPerTeamVisual( 0 );
|
|
if ( !pBaseVisuals || !pBaseVisuals->m_Styles.IsValidIndex( unStyle ) )
|
|
return NULL;
|
|
|
|
return pBaseVisuals->m_Styles[unStyle];
|
|
}
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetNumAttachedModels( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return 0;
|
|
return GetPerTeamVisual(iTeam)->m_AttachedModels.Count();
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
inline attachedmodel_t *CEconItemDefinition::GetAttachedModelData( int iTeam, int iIdx ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
perteamvisuals_t *pVisuals = GetPerTeamVisual(iTeam);
|
|
Assert( pVisuals );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !pVisuals )
|
|
return NULL;
|
|
|
|
Assert( iIdx < pVisuals->m_AttachedModels.Count() );
|
|
if ( iIdx >= pVisuals->m_AttachedModels.Count() )
|
|
return NULL;
|
|
|
|
return &pVisuals->m_AttachedModels[iIdx];
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetNumAttachedModelsFestivized( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
perteamvisuals_t *pVisuals = GetPerTeamVisual(iTeam);
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !pVisuals )
|
|
return 0;
|
|
return pVisuals->m_AttachedModelsFestive.Count();
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
inline attachedmodel_t *CEconItemDefinition::GetAttachedModelDataFestivized( int iTeam, int iIdx ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
perteamvisuals_t *pVisuals = GetPerTeamVisual(iTeam);
|
|
Assert( pVisuals );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !pVisuals )
|
|
return NULL;
|
|
|
|
Assert( iIdx < pVisuals->m_AttachedModelsFestive.Count() );
|
|
if ( iIdx >= pVisuals->m_AttachedModelsFestive.Count() )
|
|
return NULL;
|
|
|
|
return &pVisuals->m_AttachedModelsFestive[iIdx];
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetNumPlaybackActivities( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return 0;
|
|
return GetPerTeamVisual(iTeam)->m_Activities.Count();
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
inline activity_on_wearable_t *CEconItemDefinition::GetPlaybackActivityData( int iTeam, int iIdx ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
Assert( GetPerTeamVisual(iTeam) );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return NULL;
|
|
|
|
Assert( iIdx < GetPerTeamVisual(iTeam)->m_Activities.Count() );
|
|
if ( iIdx >= GetPerTeamVisual(iTeam)->m_Activities.Count() )
|
|
return NULL;
|
|
|
|
return &GetPerTeamVisual(iTeam)->m_Activities[iIdx];
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetNumAnimations( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return 0;
|
|
return GetPerTeamVisual(iTeam)->m_Animations.Count();
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
inline animation_on_wearable_t *CEconItemDefinition::GetAnimationData( int iTeam, int iIdx ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
Assert( GetPerTeamVisual(iTeam) );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return NULL;
|
|
|
|
Assert( iIdx < GetPerTeamVisual(iTeam)->m_Animations.Count() );
|
|
if ( iIdx >= GetPerTeamVisual(iTeam)->m_Animations.Count() )
|
|
return NULL;
|
|
|
|
return &GetPerTeamVisual(iTeam)->m_Animations[iIdx];
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetNumAttachedParticles( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return 0;
|
|
return GetPerTeamVisual(iTeam)->m_AttachedParticles.Count();
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline attachedparticlesystem_t *CEconItemDefinition::GetAttachedParticleData( int iTeam, int iIdx ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
Assert( GetPerTeamVisual(iTeam) );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return NULL;
|
|
|
|
Assert( iIdx < GetPerTeamVisual(iTeam)->m_AttachedParticles.Count() );
|
|
if ( iIdx >= GetPerTeamVisual(iTeam)->m_AttachedParticles.Count() )
|
|
return NULL;
|
|
|
|
return &GetPerTeamVisual(iTeam)->m_AttachedParticles[iIdx];
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline const char *CEconItemDefinition::GetMaterialOverride( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return NULL;
|
|
return GetPerTeamVisual(iTeam)->pszMaterialOverride;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline const char *CEconItemDefinition::GetMuzzleFlash( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return NULL;
|
|
return GetPerTeamVisual(iTeam)->pszMuzzleFlash;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline const char *CEconItemDefinition::GetTracerEffect( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return NULL;
|
|
return GetPerTeamVisual(iTeam)->pszTracerEffect;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline const char *CEconItemDefinition::GetParticleEffect( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return NULL;
|
|
return GetPerTeamVisual(iTeam)->pszParticleEffect;
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetHiddenParentBodygroup( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return -1;
|
|
return GetPerTeamVisual(iTeam)->iHideParentBodyGroup;
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetNumModifiedBodyGroups( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return -1;
|
|
return GetPerTeamVisual(iTeam)->m_Maps.m_ModifiedBodyGroupNames.Count();
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline const char* CEconItemDefinition::GetModifiedBodyGroup( int iTeam, int i, int& body ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return NULL;
|
|
body = GetPerTeamVisual(iTeam)->m_Maps.m_ModifiedBodyGroupNames[i];
|
|
return GetPerTeamVisual(iTeam)->m_Maps.m_ModifiedBodyGroupNames.Key(i);
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetNumCodeControlledBodyGroups( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return -1;
|
|
return GetPerTeamVisual(iTeam)->m_Maps.m_CodeControlledBodyGroupNames.Count();
|
|
#else
|
|
return -1;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline const char* CEconItemDefinition::GetCodeControlledBodyGroup( int iTeam, int i, codecontrolledbodygroupdata_t &ccbgd ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return NULL;
|
|
ccbgd = GetPerTeamVisual(iTeam)->m_Maps.m_CodeControlledBodyGroupNames[i];
|
|
return GetPerTeamVisual(iTeam)->m_Maps.m_CodeControlledBodyGroupNames.Key(i);
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetStyleSkin( style_index_t unStyle, int iTeam, bool bViewmodel ) const
|
|
{
|
|
const CEconStyleInfo *pStyle = GetStyleInfo( unStyle );
|
|
|
|
// Return our skin if we have a style or our default skin of -1 otherwise.
|
|
return pStyle
|
|
? pStyle->GetSkin( iTeam, bViewmodel )
|
|
: GetDefaultSkin();
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline const char* CEconItemDefinition::GetStyleInventoryImage( style_index_t unStyle ) const
|
|
{
|
|
const CEconStyleInfo *pStyle = GetStyleInfo( unStyle );
|
|
|
|
return pStyle ? pStyle->GetInventoryImage() : NULL;
|
|
}
|
|
|
|
#endif // defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetViewmodelBodygroupOverride( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return 0;
|
|
return GetPerTeamVisual(iTeam)->m_iViewModelBodyGroupOverride;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetViewmodelBodygroupStateOverride( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return 0;
|
|
return GetPerTeamVisual(iTeam)->m_iViewModelBodyGroupStateOverride;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetWorldmodelBodygroupOverride( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return 0;
|
|
return GetPerTeamVisual(iTeam)->m_iWorldModelBodyGroupOverride;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetWorldmodelBodygroupStateOverride( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return 0;
|
|
return GetPerTeamVisual(iTeam)->m_iWorldModelBodyGroupStateOverride;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline bool CEconItemDefinition::UsesPerClassBodygroups( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return false;
|
|
return GetPerTeamVisual(iTeam)->bUsePerClassBodygroups;
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline const char *CEconItemDefinition::GetCustomSound( int iTeam, int iSound ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return NULL;
|
|
if ( iSound < 0 || iSound >= MAX_VISUALS_CUSTOM_SOUNDS )
|
|
return NULL;
|
|
return GetPerTeamVisual(iTeam)->pszCustomSounds[iSound];
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline const char *CEconItemDefinition::GetWeaponReplacementSound( int iTeam, /* WeaponSound_t */ int iSound ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
iTeam = GetBestVisualTeamData( iTeam );
|
|
if ( iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS || !GetPerTeamVisual(iTeam) )
|
|
return NULL;
|
|
if ( iSound < 0 || iSound >= NUM_SHOOT_SOUND_TYPES )
|
|
return NULL;
|
|
return GetPerTeamVisual(iTeam)->pszWeaponSoundReplacements[iSound];
|
|
#else
|
|
return NULL;
|
|
#endif
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
inline int CEconItemDefinition::GetBestVisualTeamData( int iTeam ) const
|
|
{
|
|
#ifndef CSTRIKE_DLL
|
|
Assert( iTeam >= 0 && iTeam < TEAM_VISUAL_SECTIONS );
|
|
// If we don't have data for the specified team, try to fall back to the base
|
|
// if ( !GetStaticData() )
|
|
// return 0;
|
|
if ( (iTeam < 0 || iTeam >= TEAM_VISUAL_SECTIONS) || (iTeam > 0 && !GetPerTeamVisual(iTeam)) )
|
|
return 0;
|
|
return iTeam;
|
|
#else
|
|
return 0;
|
|
#endif
|
|
}
|
|
#endif // defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CTimedItemRewardDefinition
|
|
// Describes a periodic item reward
|
|
//-----------------------------------------------------------------------------
|
|
class CTimedItemRewardDefinition
|
|
{
|
|
public:
|
|
CTimedItemRewardDefinition( void );
|
|
CTimedItemRewardDefinition( const CTimedItemRewardDefinition &that );
|
|
CTimedItemRewardDefinition &operator=( const CTimedItemRewardDefinition& rhs );
|
|
|
|
~CTimedItemRewardDefinition( void ) { }
|
|
|
|
bool BInitFromKV( KeyValues *pKVTimedReward, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
uint32 GetRandomFrequency( void ) const { return RandomFloat( m_unMinFreq, m_unMaxFreq ); }
|
|
uint32 GetMinFrequency( void ) const { return m_unMinFreq; }
|
|
uint32 GetMaxFrequency( void ) const { return m_unMaxFreq; }
|
|
float GetChance( void ) const { return m_flChance; }
|
|
const CItemSelectionCriteria &GetCriteria( void ) const { return m_criteria; }
|
|
const CEconLootListDefinition *GetLootList( void ) const { return m_pLootList; }
|
|
|
|
bool BHasRequiredItem() const { return m_iRequiredItemDef != INVALID_ITEM_DEF_INDEX; }
|
|
item_definition_index_t GetRequiredItem() const { return m_iRequiredItemDef; }
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
void Validate( CValidator &validator, const char *pchName )
|
|
{
|
|
VALIDATE_SCOPE();
|
|
ValidateObj( m_criteria );
|
|
}
|
|
#endif // DBGFLAG_VALIDATE
|
|
|
|
private:
|
|
// Frequency of how often the item is awarded
|
|
uint32 m_unMinFreq;
|
|
uint32 m_unMaxFreq;
|
|
|
|
// The chance, between 0 and 1, that the item is rewarded
|
|
float m_flChance;
|
|
|
|
// The criteria to use to select the item to reward
|
|
CItemSelectionCriteria m_criteria;
|
|
// Alternatively, the loot_list to use instead
|
|
const CEconLootListDefinition *m_pLootList;
|
|
|
|
item_definition_index_t m_iRequiredItemDef;
|
|
};
|
|
|
|
#ifdef GC_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// CExperimentDefinition
|
|
//-----------------------------------------------------------------------------
|
|
struct experiment_group_t
|
|
{
|
|
const char* m_pName;
|
|
uint32 m_unNumParticipants;
|
|
uint32 m_unMaxParticipants;
|
|
KeyValues *m_pKeyValues;
|
|
};
|
|
|
|
class CExperimentDefinition
|
|
{
|
|
public:
|
|
CExperimentDefinition( void );
|
|
~CExperimentDefinition( void );
|
|
|
|
bool BInitFromKV( KeyValues *pKVExperiment, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
CUtlVector< experiment_group_t > &GetGroups() { return m_vecGroups; }
|
|
|
|
uint32 GetID() const { return m_unExperimentID; }
|
|
const char *GetName( void ) const { return m_pKeyValues->GetString( "name", "unknown" ); }
|
|
const char *GetDescription( void ) const { return m_pKeyValues->GetString( "description", "unknown" ); }
|
|
|
|
bool IsEnabled() const { return m_bEnabled; }
|
|
bool IsFull() const { return m_unNumParticipants >= m_unMaxParticipants; }
|
|
|
|
uint32 GetNumParticipants() const { return m_unNumParticipants; }
|
|
void SetNumParticipants( uint32 unNumParticipants ) { m_unNumParticipants = unNumParticipants; }
|
|
uint32 GetMaxParticipants() const { return m_unMaxParticipants; }
|
|
|
|
bool ChooseGroup( uint32 &unGroup );
|
|
|
|
private:
|
|
bool m_bEnabled;
|
|
uint32 m_unExperimentID;
|
|
uint32 m_unNumParticipants;
|
|
uint32 m_unMaxParticipants;
|
|
KeyValues *m_pKeyValues;
|
|
CUtlVector< experiment_group_t > m_vecGroups;
|
|
};
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CItemLevelingDefinition
|
|
//-----------------------------------------------------------------------------
|
|
class CItemLevelingDefinition
|
|
{
|
|
public:
|
|
CItemLevelingDefinition( void );
|
|
CItemLevelingDefinition( const CItemLevelingDefinition &that );
|
|
CItemLevelingDefinition &operator=( const CItemLevelingDefinition& rhs );
|
|
|
|
~CItemLevelingDefinition( void );
|
|
|
|
bool BInitFromKV( KeyValues *pKVItemLevel, const char *pszLevelBlockName, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
|
|
uint32 GetLevel( void ) const { return m_unLevel; }
|
|
uint32 GetRequiredScore( void ) const { return m_unRequiredScore; }
|
|
const char *GetNameLocalizationKey( void ) const { return m_pszLocalizedName_LocalStorage; }
|
|
|
|
private:
|
|
uint32 m_unLevel;
|
|
uint32 m_unRequiredScore;
|
|
char *m_pszLocalizedName_LocalStorage;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// AchievementAward_t
|
|
// Holds the item to give away and the Data value to audit it with ( for cross
|
|
// game achievements)
|
|
//-----------------------------------------------------------------------------
|
|
struct AchievementAward_t
|
|
{
|
|
AchievementAward_t( const AchievementAward_t & rhs )
|
|
: m_sNativeName( rhs.m_sNativeName ),
|
|
m_unSourceAppId( rhs.m_unSourceAppId ),
|
|
m_unAuditData( rhs.m_unAuditData )
|
|
{
|
|
m_vecDefIndex.CopyArray( rhs.m_vecDefIndex.Base(), rhs.m_vecDefIndex.Count() );
|
|
}
|
|
AchievementAward_t( ) {}
|
|
|
|
CUtlString m_sNativeName;
|
|
AppId_t m_unSourceAppId;
|
|
uint32 m_unAuditData;
|
|
CUtlVector<uint16> m_vecDefIndex;
|
|
};
|
|
|
|
enum eTimedRewardType
|
|
{
|
|
kTimedRewards_RegularDrop,
|
|
kTimedRewards_SupplyCrate,
|
|
kTimedRewards_FreeTrialDrop,
|
|
kTimedRewards_RecipeDrop,
|
|
kTimedRewards_EventDrop02,
|
|
kNumTimedRewards
|
|
};
|
|
|
|
struct kill_eater_score_type_t
|
|
{
|
|
const char *m_pszTypeString;
|
|
const char *m_pszLevelBlockName;
|
|
bool m_bAllowBotVictims; // if true, we don't check for a valid Steam ID on the client before sending or a valid session on the GC before incrementing
|
|
#ifdef GC_DLL
|
|
bool m_bGCUpdateOnly;
|
|
bool m_AllowIncrementValues; // if true, clients are allowed to send up the amount to increment by (ie., "did 100 damage") rather than implicitly assuming a value of 1
|
|
bool m_bIsBaseKillType; // if true, when clients send up a notification of this type we'll also look for other relevant things on the GC, like whether the victim was a friend, etc.
|
|
#endif
|
|
};
|
|
|
|
// Index-to-string table, currently used for attribute value string lookups.
|
|
struct schema_string_table_entry_t
|
|
{
|
|
int m_iIndex;
|
|
const char *m_pszStr;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CForeignAppImports
|
|
// Defines the way a single foreign app's items are mapped into this app
|
|
//-----------------------------------------------------------------------------
|
|
|
|
class CForeignAppImports
|
|
{
|
|
public:
|
|
CForeignAppImports() : m_mapDefinitions( DefLessFunc( uint16 ) ) {}
|
|
|
|
void AddMapping( uint16 unForeignDefIndex, const CEconItemDefinition *pDefn );
|
|
const CEconItemDefinition *FindMapping( uint16 unForeignDefIndex ) const;
|
|
|
|
private:
|
|
CUtlMap< uint16, const CEconItemDefinition *> m_mapDefinitions;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// ISchemaAttributeType
|
|
//-----------------------------------------------------------------------------
|
|
#ifdef GC_DLL
|
|
namespace GCSDK
|
|
{
|
|
class CColumnSet;
|
|
class CRecordBase;
|
|
class CWebAPIValues;
|
|
};
|
|
#endif // GC_DLL
|
|
|
|
// ISchemaAttributeType is the base interface for a "type" of attribute, where "type" is defined as
|
|
// "something that describes the memory layout, the DB layout, how to convert between them, etc.".
|
|
// Most of the low-level work done with attributes, including DB reading/writing, packing/unpacking
|
|
// for wire traffic, and other leaf code works exclusively through this interface.
|
|
//
|
|
// The class hierarchy looks like:
|
|
//
|
|
// ISchemaAttributeTypeBase< TAttribInMemoryType >:
|
|
//
|
|
// This describes a specific in-memory format for an attribute, without any association to
|
|
// a particular DB, wire format, etc. We can't template the base class because it's an
|
|
// interface. This implements about half of ISchemaAttributeType and has its own mini
|
|
// interface consisting of ConvertTypedValueToByteStream() and ConvertByteStreamToTypedValue(),
|
|
// both of which do work on statically-typed values that don't exist at higher levels.
|
|
//
|
|
// CSchemaAttributeTypeBase< TAttribSchType, TAttribInMemoryType >:
|
|
//
|
|
// This handles the schema-related functions on ISchemaAttributeType. These exist at a lower
|
|
// inheritance level than ISchemaAttributeTypeBase to allow code that needs to work type-safely
|
|
// on attributes in memory, but that doesn't know or need to know anything about databases,
|
|
// to exist. Examples of this include code that calls CEconItem::SetDynamicAttributeValue<T>().
|
|
//
|
|
// Individual implementations of custom attribute type start making sense immediately as
|
|
// subclasses of CSchemaAttributeTypeBase, for example CSchemaAttributeType_Default, which
|
|
// implements all of the old, untyped attribute system logic.
|
|
//
|
|
// CSchemaAttributeTypeProtobufBase< TAttribSchType, TProtobufValueType >
|
|
//
|
|
// An easy way of automating most of the work for making a new attribute type is to have
|
|
// the in-memory format be a protobuf object, allowing reflection, automatic network support,
|
|
// etc.
|
|
//
|
|
// Creating a new custom protobuf attribute consists of three steps:
|
|
//
|
|
// - create a new DB table that will hold your attribute data. This needs an itemid_t-sized item ID
|
|
// column named "ItemID", an attrib_definition_index_t-sized definition index column named "AttrDefIndex",
|
|
// and then whatever data you want to store.
|
|
//
|
|
// - create a new protobuf message type that will hold your custom attribute contents. This exists
|
|
// on the client and the GC in the same format.
|
|
//
|
|
// - implement a subclass of CSchemaAttributeTypeProtobufBase<>, for example:
|
|
//
|
|
// class CSchemaAttributeType_StrangeScore : public CSchemaAttributeTypeProtobufBase< GC_SCH_REFERENCE( CSchItemAttributeStrangeScore ) CAttribute_StrangeScore >
|
|
// {
|
|
// virtual void ConvertEconAttributeValueToSch( itemid_t unItemId, const CEconItemAttributeDefinition *pAttrDef, const union attribute_data_union_t& value, GCSDK::CRecordBase *out_pSchRecord ) const OVERRIDE;
|
|
// virtual void LoadSchToEconAttributeValue( CEconItem *pTargetItem, const CEconItemAttributeDefinition *pAttrDef, const GCSDK::CRecordBase *pSchRecord ) const OVERRIDE;
|
|
// };
|
|
//
|
|
// Implement these two GC-only functions to convert from the in-memory format to the DB format and
|
|
// vice versa and you're good to go.
|
|
//
|
|
// - register the new type in CEconItemSchema::BInitAttributeTypes().
|
|
//
|
|
// If the attribute type can't be silently converted to an already-existing attribute value type, a few other
|
|
// places will also fail to compile -- things like typed iteration, or compile-time type checking.
|
|
//
|
|
// Functions that start with "Convert" change the format of an attribute value (in a type-safe way wherever
|
|
// possible), copying the value from one of the passed-in parameters to the other. Functions that start with
|
|
// "Load" do a format conversion, but also add the post-conversion value to the passed-in CEconItem. This
|
|
// comes up most often when generating new items, either from the DB (LoadSch), the network (LoadByteSteam),
|
|
// or creation of a new item on the GC (LoadOrGenerate).
|
|
class ISchemaAttributeType
|
|
{
|
|
public:
|
|
virtual ~ISchemaAttributeType() { }
|
|
|
|
// Returns a unique integer describing the C++-in-memory-layout type used by this attribute type.
|
|
// For example, something that stores "int" might return 0 and "CSomeFancyWideAttributeType" might
|
|
// return 1. The actual values don't matter and can even differ between different runs of the game/GC.
|
|
// The only important thing is that during a single run the value for a single type is consistent.
|
|
virtual unsigned int GetTypeUniqueIdentifier() const = 0;
|
|
|
|
#ifdef GC_DLL
|
|
// What's the whole column set (and associated DB table) that this attribute uses? Meant to be
|
|
// implemented by subclasses that have DB type information.
|
|
virtual const GCSDK::CColumnSet& GetFullColumnSet() const = 0;
|
|
|
|
// Create an instance of a schema row. Mananging the memory is the responsibility of the caller.
|
|
// Meant to be implemented by subclasses that have DB type information.
|
|
virtual GCSDK::CRecordBase *CreateTypedSchRecord() const = 0;
|
|
|
|
// ...
|
|
virtual bool BAssetClassExportedAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const attribute_data_union_t& value ) const { return true; }
|
|
|
|
// Prepare a DB row describing an instance of this attribute for writing.
|
|
virtual void ConvertEconAttributeValueToSch( itemid_t unItemId, const CEconItemAttributeDefinition *pAttrDef, const union attribute_data_union_t& value, GCSDK::CRecordBase *out_pSchRecord ) const = 0;
|
|
|
|
// We have a row read from the database and an item to add it as an attribute for. This
|
|
// does the opposite work of ConvertEconAttributeValueToSch() and also adds it to the CEconItem.
|
|
virtual void LoadSchToEconAttributeValue( CEconItem *pTargetItem, const CEconItemAttributeDefinition *pAttrDef, const GCSDK::CRecordBase *pSchRecord ) const = 0;
|
|
|
|
// Have this attribute type either copy the data straight out of the value union, or run the logic
|
|
// described by pszCustomLogicDesc to generate a new value. Either way, some correctly-typed data
|
|
// will wind up in an attribute on the target item. This is intended to call through to LoadEconAttributeValue()
|
|
// to do the actual assignment. This is only accessible on the GC.
|
|
virtual void LoadOrGenerateEconAttributeValue( CEconItem *pTargetItem, const CEconItemAttributeDefinition *pAttrDef, const static_attrib_t& staticAttrib, const CEconGameAccount *pGameAccount ) const = 0;
|
|
|
|
virtual void GenerateEconAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const static_attrib_t& staticAttrib, const CEconGameAccount *pGameAccount, attribute_data_union_t* out_pValue ) const = 0;
|
|
#endif // GC_DLL
|
|
|
|
// Have this attribute type copy the data out of the value union and type-copy it onto the item. This
|
|
// is accessible on clients as well as the GC.
|
|
virtual void LoadEconAttributeValue( CEconItem *pTargetItem, const CEconItemAttributeDefinition *pAttrDef, const union attribute_data_union_t& value ) const = 0;
|
|
|
|
// ...
|
|
virtual void ConvertEconAttributeValueToByteStream( const union attribute_data_union_t& value, std::string *out_psBytes ) const = 0;
|
|
|
|
// ...
|
|
virtual bool BConvertStringToEconAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const char *pszValue, union attribute_data_union_t *out_pValue, bool bEnableTerribleBackwardsCompatibilitySchemaParsingCode = false ) const = 0;
|
|
|
|
// ...
|
|
virtual void ConvertEconAttributeValueToString( const CEconItemAttributeDefinition *pAttrDef, const attribute_data_union_t& value, std::string *out_ps ) const = 0;
|
|
|
|
// Used to deserialize a byte stream, probably from an on-wire protobuf message, instead an instance
|
|
// of the attribute in memory. See ConvertByteStreamToTypedValue() for example implementation, or
|
|
// ConvertTypedValueToByteStream() for an example of the byte-stream generator code.
|
|
virtual void LoadByteStreamToEconAttributeValue( CEconItem *pTargetItem, const CEconItemAttributeDefinition *pAttrDef, const std::string& sBytes ) const = 0;
|
|
|
|
// Give the subclass a chance to default-initialize a new value. For larger types, this may hit the
|
|
// heap. This must be called before otherwise manipulating [out_pValue] through Convert*() functions.
|
|
virtual void InitializeNewEconAttributeValue( attribute_data_union_t *out_pValue ) const = 0;
|
|
|
|
// Free any heap-allocated memory from this attribute value. Is not responsible for zeroing out
|
|
// pointers, etc.
|
|
virtual void UnloadEconAttributeValue( union attribute_data_union_t *out_pValue ) const = 0;
|
|
|
|
// ...
|
|
virtual bool OnIterateAttributeValue( class IEconItemAttributeIterator *pIterator, const CEconItemAttributeDefinition *pAttrDef, const attribute_data_union_t& value ) const = 0;
|
|
|
|
// This could also be called "BIsHackyMessyOldAttributeType()". This determines whether the attribute
|
|
// can be set at runtime on a CEconItemView instance, whether the gameserver can replicate the value to
|
|
// game clients, etc. It really only makes sense for value types 32 bits or smaller.
|
|
virtual bool BSupportsGameplayModificationAndNetworking() const { return false; }
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CEconItemSchema
|
|
// Defines the way econ items can be used in a game
|
|
//-----------------------------------------------------------------------------
|
|
typedef CUtlDict<CUtlConstString, int> ArmoryStringDict_t;
|
|
typedef CUtlDict< CUtlVector<CItemLevelingDefinition> * > LevelBlockDict_t;
|
|
typedef CUtlMap<unsigned int, kill_eater_score_type_t> KillEaterScoreMap_t;
|
|
typedef CUtlDict< CUtlVector< schema_string_table_entry_t > * > SchemaStringTableDict_t;
|
|
|
|
struct attr_type_t
|
|
{
|
|
CUtlConstString m_sName;
|
|
const ISchemaAttributeType *m_pAttrType;
|
|
|
|
attr_type_t( const char *pszName, const ISchemaAttributeType *pAttrType )
|
|
: m_sName( pszName )
|
|
, m_pAttrType( pAttrType )
|
|
{
|
|
}
|
|
};
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
class IDelayedSchemaData
|
|
{
|
|
public:
|
|
virtual ~IDelayedSchemaData() {}
|
|
virtual bool InitializeSchema( CEconItemSchema *pItemSchema ) = 0;
|
|
|
|
protected:
|
|
// Passing '0' as the expected version means "we weren't expecting any version in particular" and will
|
|
// skip the sanity checking.
|
|
bool InitializeSchemaInternal( CEconItemSchema *pItemSchema, CUtlBuffer& bufRawData, bool bInitAsBinary, uint32 nExpectedVersion );
|
|
};
|
|
#endif // defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
|
|
class CEconStorePriceSheet;
|
|
|
|
class CEconItemSchema
|
|
{
|
|
public:
|
|
CEconItemSchema( );
|
|
|
|
private:
|
|
CEconItemSchema( const CEconItemSchema & rhs );
|
|
CEconItemSchema &operator=( CEconItemSchema & rhs );
|
|
|
|
public:
|
|
virtual ~CEconItemSchema( void ) { Reset(); };
|
|
|
|
// Setup & parse in the item data files.
|
|
virtual bool BInit( const char *fileName, const char *pathID, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
bool BInitBinaryBuffer( CUtlBuffer &buffer, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
bool BInitTextBuffer( CUtlBuffer &buffer, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
#ifdef GC_DLL
|
|
virtual bool DoPostPriceSheetLoadInit( CEconStorePriceSheet *pPriceSheet ); // Called once the price sheet's been loaded
|
|
#endif
|
|
|
|
uint32 GetVersion() const { return m_unVersion; }
|
|
CSHA GetSchemaSHA() const { return m_schemaSHA; }
|
|
uint32 GetResetCount() const { return m_unResetCount; }
|
|
|
|
// Dump the schema for debug purposes
|
|
bool DumpItems ( const char *fileName, const char *pathID = NULL );
|
|
|
|
// Perform the computation used to calculate the schema version
|
|
static uint32 CalculateKeyValuesVersion( KeyValues *pKV );
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
// This function will immediately reinitialize the schema if it's safe to do so, or store off the data
|
|
// if it isn't safe to update at the moment.
|
|
bool MaybeInitFromBuffer( IDelayedSchemaData *pDelayedSchemaData );
|
|
|
|
// If there is saved schema initialization data, initialize it now. If there is no saved data, this
|
|
// will return success.
|
|
bool BInitFromDelayedBuffer();
|
|
#endif // defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
|
|
// Accessors to the base properties
|
|
EEquipType_t GetEquipTypeFromClassIndex( int iClass ) const;
|
|
equipped_class_t GetAccountIndex() const { return m_unAccoutClassIndex; }
|
|
equipped_class_t GetFirstValidClass() const { return m_unFirstValidClass; }
|
|
equipped_class_t GetLastValidClass() const { return m_unLastValidClass; }
|
|
bool IsValidClass( equipped_class_t unClass ) { return ( unClass >= m_unFirstValidClass && unClass <= m_unLastValidClass ) || unClass == GetAccountIndex(); }
|
|
bool IsValidItemSlot( equipped_slot_t unSlot, equipped_class_t unClass ) const { return IsValidItemSlot( unSlot, unClass == m_unAccoutClassIndex ? EQUIP_TYPE_ACCOUNT : EQUIP_TYPE_CLASS ); }
|
|
bool IsValidItemSlot( equipped_slot_t unSlot, EEquipType_t eType ) const
|
|
{
|
|
return eType == EQUIP_TYPE_ACCOUNT ? unSlot >= m_unFirstValidAccountItemSlot && unSlot <= m_unLastValidAccountItemSlot
|
|
: unSlot >= m_unFirstValidClassItemSlot && unSlot <= m_unLastValidClassItemSlot;
|
|
}
|
|
|
|
enum { kMaxItemPresetCount = 4 };
|
|
uint32 GetNumAllowedItemPresets() const { return kMaxItemPresetCount; }
|
|
bool IsValidPreset( equipped_preset_t unPreset ) const { return unPreset <= GetNumAllowedItemPresets(); }
|
|
|
|
uint32 GetMinLevel() const { return m_unMinLevel; }
|
|
uint32 GetMaxLevel() const { return m_unMaxLevel; }
|
|
|
|
// Accessors to the underlying sections
|
|
typedef CUtlHashMapLarge<int, CEconItemDefinition*> ItemDefinitionMap_t;
|
|
const ItemDefinitionMap_t &GetItemDefinitionMap() const { return m_mapItems; }
|
|
|
|
typedef CUtlMap<int, CEconItemDefinition*, int> SortedItemDefinitionMap_t;
|
|
const SortedItemDefinitionMap_t &GetSortedItemDefinitionMap() const { return m_mapItemsSorted; }
|
|
|
|
typedef CUtlMap<int, CEconItemDefinition*, int> ToolsItemDefinitionMap_t;
|
|
const ToolsItemDefinitionMap_t &GetToolsItemDefinitionMap() const { return m_mapToolsItems; }
|
|
|
|
typedef CUtlMap<int, CEconItemDefinition*, int> BaseItemDefinitionMap_t;
|
|
const BaseItemDefinitionMap_t &GetBaseItemDefinitionMap() const { return m_mapBaseItems; }
|
|
|
|
typedef CUtlMap<const char*, CEconLootListDefinition *, int> LootListDefinitionMap_t;
|
|
const LootListDefinitionMap_t &GetLootLists() const { return m_mapLootLists; }
|
|
|
|
typedef CUtlMap<int, const char*> RevolvingLootListDefinitionMap_t;
|
|
const RevolvingLootListDefinitionMap_t &GetRevolvingLootLists() const { return m_mapRevolvingLootLists; }
|
|
|
|
typedef CUtlMap<const char*, int> BodygroupStateMap_t;
|
|
const BodygroupStateMap_t &GetDefaultBodygroupStateMap() const { return m_mapDefaultBodygroupState; }
|
|
|
|
typedef CUtlVector<CEconColorDefinition *> ColorDefinitionsList_t;
|
|
|
|
typedef CUtlMap<const char *, KeyValues *, int> PrefabMap_t;
|
|
|
|
#ifdef GC_DLL
|
|
struct periodic_score_t
|
|
{
|
|
eEconPeriodicScoreEvents m_eEventType;
|
|
bool m_bGCUpdateOnly; // if set, only code that runs on the GC can initiate a change of this stat (ie., counting gifts -> true; bots killed -> false)
|
|
uint32 m_unTimePeriodLengthInSeconds;
|
|
CEconItemDefinition *m_pRewardItemDefinition;
|
|
};
|
|
|
|
typedef CUtlVector<periodic_score_t> PeriodicScoreTypeList_t;
|
|
#endif // GC_DLL
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
CEconItemDefinition *GetDefaultItemDefinition() { return m_pDefaultItemDefinition; }
|
|
|
|
bool SetupPreviewItemDefinition( KeyValues *pKV );
|
|
#endif
|
|
|
|
const CUtlMap<int, CEconItemQualityDefinition, int > &GetQualityDefinitionMap() const { return m_mapQualities; }
|
|
const CUtlMap<int, CEconItemAttributeDefinition, int > &GetAttributeDefinitionMap() const { return m_mapAttributes; }
|
|
|
|
typedef CUtlMap<int, CEconCraftingRecipeDefinition*, int > RecipeDefinitionMap_t;
|
|
const RecipeDefinitionMap_t &GetRecipeDefinitionMap() const { return m_mapRecipes; }
|
|
|
|
typedef CUtlMap<const char*, CEconItemSetDefinition*, int > ItemSetMap_t;
|
|
const ItemSetMap_t &GetItemSets() const { return m_mapItemSets; }
|
|
|
|
typedef CUtlMap<const char*, CEconItemCollectionDefinition*, int > ItemCollectionMap_t;
|
|
const ItemCollectionMap_t &GetItemCollections() const { return m_mapItemCollections; }
|
|
|
|
typedef CUtlVector< int > ItemCollectionCrateMap_t;
|
|
const ItemCollectionCrateMap_t &GetItemCollectionCrates() const { return m_vecItemCollectionCrates; }
|
|
|
|
typedef CUtlMap<const char*, CEconItemPaintKitDefinition*, int > ItemPaintKitMap_t;
|
|
const ItemPaintKitMap_t &GetItemPaintKits() const { return m_mapItemPaintKits; }
|
|
|
|
typedef CUtlMap<const char*, CEconOperationDefinition*, int > OperationDefinitionMap_t;
|
|
const OperationDefinitionMap_t &GetOperationDefinitions() const { return m_mapOperationDefinitions; }
|
|
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
const ArmoryStringDict_t &GetArmoryDataItemClasses() const { return m_dictArmoryItemClassesDataStrings; }
|
|
const ArmoryStringDict_t &GetArmoryDataItemTypes() const { return m_dictArmoryItemTypesDataStrings; }
|
|
const ArmoryStringDict_t &GetArmoryDataItems() const { return m_dictArmoryItemDataStrings; }
|
|
const ArmoryStringDict_t &GetArmoryDataAttributes() const { return m_dictArmoryAttributeDataStrings; }
|
|
#elif defined(GC_DLL)
|
|
CUtlVector< CExperimentDefinition > &GetExperiments() { return m_vecExperiments; }
|
|
|
|
const CUtlVector< AppId_t > & GetForeignApps() const { return m_vecForeignApps; }
|
|
const CEconItemDefinition *GetAppItemImport( AppId_t unAppID, uint16 usDefIndex ) const;
|
|
#endif
|
|
|
|
const CTimedItemRewardDefinition* GetTimedReward( eTimedRewardType type ) const;
|
|
|
|
const CEconLootListDefinition* GetLootListByName( const char* pListName, int *out_piIndex = NULL ) const;
|
|
const CEconLootListDefinition* GetLootListByIndex( int iIdx ) const { return m_mapLootLists.IsValidIndex(iIdx) ? m_mapLootLists[iIdx] : NULL; }
|
|
|
|
const CQuestObjectiveDefinition* GetQuestObjectiveByDefIndex( int iIdx ) const;
|
|
const CUtlMap<int, CQuestObjectiveDefinition*, int >& GetQuestObjectives() const { return m_mapQuestObjectives; }
|
|
|
|
uint8 GetDefaultQuality() const { return AE_UNIQUE; }
|
|
|
|
void AssignDefaultBodygroupState( const char *pszBodygroupName, int iValue );
|
|
|
|
equip_region_mask_t GetEquipRegionMaskByName( const char *pRegionName ) const;
|
|
|
|
struct EquipRegion
|
|
{
|
|
CUtlConstString m_sName;
|
|
unsigned int m_unBitIndex; // which bit are we claiming ownership over? there might be multiple equip regions with the same bit if we're in a "shared" block
|
|
equip_region_mask_t m_unMask; // full region conflict mask
|
|
};
|
|
|
|
typedef CUtlVector<EquipRegion> EquipRegionsList_t;
|
|
const EquipRegionsList_t& GetEquipRegionsList() const { return m_vecEquipRegionsList; }
|
|
|
|
equip_region_mask_t GetEquipRegionBitMaskByName( const char *pRegionName ) const;
|
|
|
|
KeyValues *FindDefinitionPrefabByName( const char *pszPrefabName ) const;
|
|
const PrefabMap_t& GetPrefabMap() const { return m_mapDefinitionPrefabs; }
|
|
|
|
CUtlVector< CEconItemDefinition * > &GetBundles() { return m_vecBundles; } // Retrieve a cached list of all bundles
|
|
|
|
const char *FindStringTableEntry( const char *pszTableName, int iIndex ) const;
|
|
|
|
private:
|
|
void SetEquipRegionConflict( int iRegion, unsigned int unBit );
|
|
int GetEquipRegionIndexByName( const char *pRegionName ) const;
|
|
|
|
public:
|
|
// Common lookup methods
|
|
bool BGetItemQualityFromName( const char *pchName, uint8 *nQuality ) const;
|
|
const CEconItemQualityDefinition *GetQualityDefinition( int nQuality ) const;
|
|
const CEconItemQualityDefinition *GetQualityDefinitionByName( const char *pszDefName ) const;
|
|
|
|
bool BGetItemRarityFromName( const char* pchName, uint8 *nRarity ) const;
|
|
const CEconItemRarityDefinition *GetRarityDefinitionByMapIndex( int nRarityIndex ) const;
|
|
const CEconItemRarityDefinition *GetRarityDefinition( int nRarity ) const;
|
|
const CEconItemRarityDefinition *GetRarityDefinitionByName( const char *pszDefName ) const;
|
|
virtual int GetRarityDefinitionCount( void ) const { return m_mapRarities.Count(); }
|
|
virtual const char* GetRarityName( uint8 iRarity );
|
|
virtual const char* GetRarityLocKey( uint8 iRarity );
|
|
virtual const char* GetRarityColor( uint8 iRarity );
|
|
virtual int GetRarityIndex( const char* pszRarity );
|
|
|
|
const CEconItemCollectionDefinition *GetCollectionByName( const char* pCollectionName );
|
|
|
|
virtual int GetItemSeriesDefinitionCount( void ) const { return m_mapItemSeries.Count(); }
|
|
bool BGetItemSeries( const char* pchName, uint8 *nItemSeries ) const;
|
|
const CEconItemSeriesDefinition *GetItemSeriesDefinition( int nRarity ) const;
|
|
|
|
CEconItemDefinition *GetItemDefinition( int iItemIndex );
|
|
const CEconItemDefinition *GetItemDefinition( int iItemIndex ) const;
|
|
CEconItemAttributeDefinition *GetAttributeDefinition( int iAttribIndex );
|
|
const CEconItemAttributeDefinition *GetAttributeDefinition( int iAttribIndex ) const;
|
|
CEconItemAttributeDefinition *GetAttributeDefinitionByName( const char *pszDefName );
|
|
const CEconItemAttributeDefinition *GetAttributeDefinitionByName( const char *pszDefName ) const;
|
|
CEconCraftingRecipeDefinition *GetRecipeDefinition( int iRecipeIndex );
|
|
CEconColorDefinition *GetColorDefinitionByName( const char *pszDefName );
|
|
const CEconColorDefinition *GetColorDefinitionByName( const char *pszDefName ) const;
|
|
#ifdef CLIENT_DLL
|
|
const char *GetSteamPackageLocalizationToken( uint32 unPackageId ) const;
|
|
#endif // CLIENT_DLL
|
|
|
|
bool BCanGSCreateItems( uint32 unIP ) const;
|
|
#ifdef GC_DLL
|
|
const AchievementAward_t *GetAchievementReward( const char *pchAchievementName, AppId_t unAppID ) const;
|
|
const AchievementAward_t *GetAchievementRewardByData( uint32 unData ) const;
|
|
#endif
|
|
const AchievementAward_t *GetAchievementRewardByDefIndex( uint16 usDefIndex ) const;
|
|
bool BHasAchievementRewards( void ) const { return (m_dictAchievementRewards.Count() > 0); }
|
|
|
|
static CUtlString ComputeAchievementName( AppId_t unAppID, const char *pchNativeAchievementName );
|
|
|
|
// Iterating over the item definitions. Game needs this to precache data.
|
|
CEconItemDefinition *GetItemDefinitionByName( const char *pszDefName );
|
|
const CEconItemDefinition *GetItemDefinitionByName( const char *pszDefName ) const;
|
|
|
|
#ifdef GC_DLL
|
|
random_attrib_t *GetRandomAttributeTemplateByName( const char *pszAttrTemplateName ) const;
|
|
#endif // GC_DLL
|
|
|
|
attachedparticlesystem_t* GetAttributeControlledParticleSystem( int id );
|
|
attachedparticlesystem_t* FindAttributeControlledParticleSystem( const char *pchSystemName );
|
|
typedef CUtlMap<int, attachedparticlesystem_t > ParticleDefinitionMap_t;
|
|
const ParticleDefinitionMap_t& GetAttributeControlledParticleSystems() const { return m_mapAttributeControlledParticleSystems; }
|
|
|
|
const CUtlVector< int > *GetWeaponUnusualParticleIndexes() const { return &m_vecAttributeControlledParticleSystemsWeapons; }
|
|
const CUtlVector< int > *GetCosmeticUnusualParticleIndexes() const { return &m_vecAttributeControlledParticleSystemsCosmetics; }
|
|
const CUtlVector< int > *GetTauntUnusualParticleIndexes() const { return &m_vecAttributeControlledParticleSystemsTaunts; }
|
|
|
|
#ifdef CLIENT_DLL
|
|
locchar_t *GetParticleSystemLocalizedName( int index ) const;
|
|
#endif // CLIENT_DLL
|
|
|
|
#ifdef GC_DLL
|
|
const PeriodicScoreTypeList_t& GetPeriodicScoreTypeList() const { return m_vecPeriodicScoreTypes; }
|
|
|
|
int GetPeriodicScoreTypeCount() const { return GetPeriodicScoreTypeList().Count(); } // how many types of events are we tracking? the range goes from 0 through this return value
|
|
const periodic_score_t& GetPeriodicScoreInfo( int iPeriodicScoreIndex ) const; // get the full info block for this periodic score -- event type, time period, etc.
|
|
|
|
// Only intended to be used for generating data for the WebAPI.
|
|
const KillEaterScoreMap_t& GetKillEaterScoreTypes() const { return m_mapKillEaterScoreTypes; }
|
|
const SchemaStringTableDict_t& GetStringTables() const { return m_dictStringTable; }
|
|
#endif // GC_DLL
|
|
|
|
item_definition_index_t GetCommunityMarketRemappedDefinitionIndex( item_definition_index_t unSearchItemDef ) const;
|
|
|
|
const CUtlVector<attr_type_t>& GetAttributeTypes() const { return m_vecAttributeTypes; }
|
|
const ISchemaAttributeType *GetAttributeType( const char *pszAttrTypeName ) const;
|
|
|
|
const LevelBlockDict_t& GetItemLevelingDataDict() const { return m_vecItemLevelingData; }
|
|
|
|
const CUtlVector<CItemLevelingDefinition> *GetItemLevelingData( const char *pszLevelBlockName ) const
|
|
{
|
|
LevelBlockDict_t::IndexType_t i = m_vecItemLevelingData.Find( pszLevelBlockName );
|
|
if ( i == LevelBlockDict_t::InvalidIndex() )
|
|
return NULL;
|
|
|
|
return m_vecItemLevelingData[i];
|
|
}
|
|
|
|
const CItemLevelingDefinition *GetItemLevelForScore( const char *pszLevelBlockName, uint32 unScore ) const;
|
|
const char *GetKillEaterScoreTypeLocString( uint32 unScoreType ) const;
|
|
const char *GetKillEaterScoreTypeLevelingDataName( uint32 unScoreType ) const;
|
|
bool GetKillEaterScoreTypeAllowsBotVictims( uint32 unScoreType ) const;
|
|
#ifdef GC_DLL
|
|
bool GetKillEaterScoreTypeGCOnlyUpdate( uint32 unScoreType ) const;
|
|
bool GetKillEaterScoreTypeAllowsIncrementValues( uint32 unScoreType ) const;
|
|
#endif
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
void ItemTesting_CreateTestDefinition( int iCloneFromItemDef, int iNewDef, KeyValues *pNewKV );
|
|
void ItemTesting_DiscardTestDefinition( int iDef );
|
|
#endif
|
|
|
|
#ifdef DBGFLAG_VALIDATE
|
|
void Validate( CValidator &validator, const char *pchName );
|
|
#endif // DBGFLAG_VALIDATE
|
|
|
|
econ_tag_handle_t GetHandleForTag( const char *pszTagName ); // non-const because it may create a new tag handle
|
|
|
|
typedef CUtlDict<econ_tag_handle_t> EconTagDict_t;
|
|
#ifdef GC_DLL
|
|
const EconTagDict_t& GetEconTagDict() const { return m_dictTags; } // meant for internal/debug use only, not for runtime iteration
|
|
#endif // GC_DLL
|
|
|
|
virtual RTime32 GetCustomExpirationDate( const char *pszExpirationDate ) const { return k_RTime32Nil; }
|
|
|
|
public:
|
|
// Subclass interface.
|
|
virtual CEconItemDefinition *CreateEconItemDefinition() { return new CEconItemDefinition; }
|
|
virtual CEconCraftingRecipeDefinition *CreateCraftingRecipeDefinition() { return new CEconCraftingRecipeDefinition; }
|
|
virtual CEconStyleInfo *CreateEconStyleInfo() { return new CEconStyleInfo; }
|
|
virtual CQuestObjectiveDefinition *CreateQuestDefinition() { return new CQuestObjectiveDefinition; }
|
|
|
|
virtual IEconTool *CreateEconToolImpl( const char *pszToolType, const char *pszUseString, const char *pszUsageRestriction, item_capabilities_t unCapabilities, KeyValues *pUsageKV );
|
|
|
|
#ifdef GC_DLL
|
|
virtual random_attrib_t *CreateRandomAttribute( const char *pszContext, KeyValues *pRandomAttributesKV, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
#endif // GC_DLL
|
|
|
|
virtual bool BCanStrangeFilterApplyToStrangeSlotInItem( uint32 /*strange_event_restriction_t*/ unRestrictionType, uint32 unRestrictionValue, const IEconItemInterface *pItem, int iStrangeSlot, uint32 *out_pOptionalScoreType ) const;
|
|
bool AddQuestObjective( const CQuestObjectiveDefinition **ppQuestObjective, KeyValues *pKVObjective, CUtlVector<CUtlString> *pVecErrors );
|
|
|
|
bool BInsertLootlist( const char *pListName, KeyValues *pKVLootList, CUtlVector<CUtlString> *pVecErrors );
|
|
|
|
#ifdef GC_DLL
|
|
void PerformCaseBehaviorCheck();
|
|
#endif
|
|
protected:
|
|
virtual void Reset( void );
|
|
|
|
virtual bool BInitSchema( KeyValues *pKVRawDefinition, CUtlVector<CUtlString> *pVecErrors = NULL );
|
|
#ifdef TF_CLIENT_DLL
|
|
virtual int CalculateNumberOfConcreteItems( const CEconItemDefinition *pItemDef ); // Let derived classes handle custom item types
|
|
#endif // TF_CLIENT_DLL
|
|
|
|
private:
|
|
bool BInitGameInfo( KeyValues *pKVGameInfo, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitAttributeTypes( CUtlVector<CUtlString> *pVecErrors );
|
|
#ifdef GC_DLL
|
|
bool BInitPeriodicScoring( KeyValues *pKVGameInfo, CUtlVector<CUtlString> *pVecErrors );
|
|
#endif // GC_DLL
|
|
bool BInitDefinitionPrefabs( KeyValues *pKVPrefabs, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitItemSeries( KeyValues *pKVSeries, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BVerifyBaseItemNames( CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitRarities( KeyValues *pKVRarities, KeyValues *pKVRarityWeights, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitQualities( KeyValues *pKVAttributes, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitColors( KeyValues *pKVColors, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitAttributes( KeyValues *pKVAttributes, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitEquipRegions( KeyValues *pKVEquipRegions, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitEquipRegionConflicts( KeyValues *pKVEquipRegions, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitItems( KeyValues *pKVAttributes, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitItemSets( KeyValues *pKVItemSets, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitTimedRewards( KeyValues *pKVTimeRewards, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitAchievementRewards( KeyValues *pKVTimeRewards, CUtlVector<CUtlString> *pVecErrors );
|
|
#ifdef GC_DLL
|
|
bool BInitRandomAttributeTemplates( KeyValues *pKVRandomAttributeTemplates, CUtlVector<CUtlString> *pVecErrors );
|
|
#endif // GC_DLL
|
|
bool BInitRecipes( KeyValues *pKVRecipes, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitLootLists( KeyValues *pKVLootLists, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitRevolvingLootLists( KeyValues *pKVRevolvingLootLists, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitItemCollections( KeyValues *pKVItemSets, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitCollectionReferences( CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitItemPaintKitDefinitions( KeyValues *pKVPaintKits, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitOperationDefinitions( KeyValues *pKVGameInfo, KeyValues *pOperations, CUtlVector<CUtlString> *pVecErrors );
|
|
|
|
#ifdef TF_CLIENT_DLL
|
|
bool BInitConcreteItemCounts( CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitSteamPackageLocalizationToken( KeyValues *pKVSteamPackages, CUtlVector<CUtlString> *pVecErrors );
|
|
#endif // TF_CLIENT_DLL
|
|
bool BInitItemLevels( KeyValues *pKVItemLevels, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitKillEaterScoreTypes( KeyValues *pKVItemLevels, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitStringTables( KeyValues *pKVStringTables, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitCommunityMarketRemaps( KeyValues *pKVCommunityMarketRemaps, CUtlVector<CUtlString> *pVecErrors );
|
|
|
|
bool BPostSchemaInit( CUtlVector<CUtlString> *pVecErrors ) const;
|
|
bool BInitAttributeControlledParticleSystems( KeyValues *pKVParticleSystems, CUtlVector<CUtlString> *pVecErrors );
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
bool BInitArmoryData( KeyValues *pKVArmoryData, CUtlVector<CUtlString> *pVecErrors );
|
|
#else
|
|
bool BInitExperiements( KeyValues *pKVExperiments, CUtlVector<CUtlString> *pVecErrors );
|
|
bool BInitForeignImports( CUtlVector<CUtlString> *pVecErrors );
|
|
|
|
CForeignAppImports *FindOrAddAppImports( AppId_t unAppID );
|
|
#endif
|
|
|
|
bool BVerifyLootListItemDropDates( const CEconLootListDefinition* pLootList, CUtlVector<CUtlString> *pVecErrors ) const;
|
|
bool BRecurseiveVerifyLootListItemDropDates( const CEconLootListDefinition* pLootList, const CEconLootListDefinition* pRootLootList, CUtlVector<CUtlString> *pVecErrors ) const;
|
|
|
|
// Note: this returns pointers to the inside of a vector and/or NULL. Pointers are not intended to be
|
|
// saved off and used later.
|
|
const kill_eater_score_type_t *FindKillEaterScoreType( uint32 unScoreType ) const;
|
|
|
|
uint32 m_unResetCount;
|
|
|
|
KeyValues *m_pKVRawDefinition;
|
|
uint32 m_unVersion;
|
|
CSHA m_schemaSHA;
|
|
|
|
// Class range
|
|
equipped_class_t m_unFirstValidClass;
|
|
equipped_class_t m_unLastValidClass;
|
|
equipped_class_t m_unAccoutClassIndex;
|
|
|
|
// Item slot range
|
|
equipped_slot_t m_unFirstValidClassItemSlot;
|
|
equipped_slot_t m_unLastValidClassItemSlot;
|
|
equipped_slot_t m_unFirstValidAccountItemSlot;
|
|
equipped_slot_t m_unLastValidAccountItemSlot;
|
|
|
|
// Number of allowed presets
|
|
uint32 m_unNumItemPresets;
|
|
|
|
// Allowable range of item levels for this app
|
|
uint32 m_unMinLevel;
|
|
uint32 m_unMaxLevel;
|
|
|
|
// Total value of all the weights of the qualities
|
|
uint32 m_unSumQualityWeights;
|
|
|
|
// Name-to-implementation list of all unique attribute types (ie., "wide strange score").
|
|
CUtlVector<attr_type_t> m_vecAttributeTypes;
|
|
|
|
// Contains the list of rarity definitions
|
|
CUtlMap<int, CEconItemSeriesDefinition, int > m_mapItemSeries;
|
|
|
|
// Contains the list of rarity definitions
|
|
CUtlMap<int, CEconItemRarityDefinition, int > m_mapRarities;
|
|
|
|
// Contains the list of item definitions read in from all data files.
|
|
CUtlMap<int, CEconItemQualityDefinition, int > m_mapQualities;
|
|
|
|
// Contains the list of item definitions read in from all data files.
|
|
ItemDefinitionMap_t m_mapItems;
|
|
|
|
CUtlMap<int, CQuestObjectiveDefinition*, int > m_mapQuestObjectives;
|
|
|
|
// A sorted version of the same map, for instances where we really want sorted data
|
|
SortedItemDefinitionMap_t m_mapItemsSorted;
|
|
|
|
// List of all the tool items, is a sublist of mapItems
|
|
ToolsItemDefinitionMap_t m_mapToolsItems;
|
|
|
|
// List of all base items, is a sublist of mapItems
|
|
BaseItemDefinitionMap_t m_mapBaseItems;
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
// What is the default item definition we'll return in the client code if we can't find the correct one?
|
|
CEconItemDefinition *m_pDefaultItemDefinition;
|
|
#endif
|
|
|
|
// Contains the list of attribute definitions read in from all data files.
|
|
CUtlMap<int, CEconItemAttributeDefinition, int > m_mapAttributes;
|
|
|
|
// Contains the list of item recipes read in from all data files.
|
|
RecipeDefinitionMap_t m_mapRecipes;
|
|
|
|
// Contains the list of item sets.
|
|
ItemSetMap_t m_mapItemSets;
|
|
ItemCollectionMap_t m_mapItemCollections;
|
|
ItemCollectionCrateMap_t m_vecItemCollectionCrates;
|
|
|
|
OperationDefinitionMap_t m_mapOperationDefinitions;
|
|
|
|
// Paint Kit defintions
|
|
ItemPaintKitMap_t m_mapItemPaintKits;
|
|
|
|
// Revolving loot lists.
|
|
CUtlMap<int, const char*> m_mapRevolvingLootLists;
|
|
|
|
// Contains the list of loot lists.
|
|
LootListDefinitionMap_t m_mapLootLists;
|
|
|
|
// List of events that award items based on time played
|
|
CUtlVector<CTimedItemRewardDefinition> m_vecTimedRewards;
|
|
|
|
// list of items that will be awarded from achievements
|
|
CUtlDict< AchievementAward_t *, int > m_dictAchievementRewards;
|
|
CUtlMap< uint32, AchievementAward_t * > m_mapAchievementRewardsByData;
|
|
|
|
#ifdef GC_DLL
|
|
// list of random attribute templates
|
|
CUtlDict< random_attrib_t * > m_dictRandomAttributeTemplates;
|
|
#endif // GC_DLL
|
|
|
|
// Contains information for attribute attached particle systems
|
|
CUtlMap<int, attachedparticlesystem_t > m_mapAttributeControlledParticleSystems;
|
|
CUtlVector< int > m_vecAttributeControlledParticleSystemsCosmetics;
|
|
CUtlVector< int > m_vecAttributeControlledParticleSystemsWeapons;
|
|
CUtlVector< int > m_vecAttributeControlledParticleSystemsTaunts;
|
|
|
|
|
|
// Contains information on which equip regions conflict with each other regions and how to
|
|
// test for overlap.
|
|
EquipRegionsList_t m_vecEquipRegionsList;
|
|
|
|
// Contains information about prefab KeyValues blocks that be can referenced elsewhere
|
|
// in the schema.
|
|
PrefabMap_t m_mapDefinitionPrefabs;
|
|
|
|
// Contains runtime color information, looked-up by name.
|
|
ColorDefinitionsList_t m_vecColorDefs;
|
|
|
|
// Contains information about: a) every bodygroup that appears anywhere in the schema, and
|
|
// b) whether they default to on or off.
|
|
BodygroupStateMap_t m_mapDefaultBodygroupState;
|
|
|
|
// Various definitions can have any number of unique tags associated with them.
|
|
EconTagDict_t m_dictTags;
|
|
|
|
#ifdef GC_DLL
|
|
// Information about our periodic score accumulators.
|
|
PeriodicScoreTypeList_t m_vecPeriodicScoreTypes;
|
|
#endif // GC_DLL
|
|
|
|
// List of item leveling data.
|
|
KillEaterScoreMap_t m_mapKillEaterScoreTypes;
|
|
|
|
SchemaStringTableDict_t m_dictStringTable;
|
|
|
|
typedef CUtlMap< item_definition_index_t, item_definition_index_t, item_definition_index_t > CommunityMarketDefinitionRemapMap_t;
|
|
CommunityMarketDefinitionRemapMap_t m_mapCommunityMarketDefinitionIndexRemap;
|
|
|
|
#ifdef CLIENT_DLL
|
|
// Steam-package-ID-to-localization-token map, used for modifying tooltips in the store.
|
|
typedef CUtlMap< uint32, const char * > SteamPackageLocalizationTokenMap_t;
|
|
SteamPackageLocalizationTokenMap_t m_mapSteamPackageLocalizationTokens;
|
|
#endif // CLIENT_DLL
|
|
|
|
LevelBlockDict_t m_vecItemLevelingData;
|
|
|
|
#if defined(CLIENT_DLL) || defined(GAME_DLL)
|
|
// Contains Armory data key->localization string mappings
|
|
ArmoryStringDict_t m_dictArmoryItemTypesDataStrings;
|
|
ArmoryStringDict_t m_dictArmoryItemClassesDataStrings;
|
|
ArmoryStringDict_t m_dictArmoryAttributeDataStrings;
|
|
ArmoryStringDict_t m_dictArmoryItemDataStrings;
|
|
|
|
// Used for delaying the parsing of the item schema until its safe to swap out the back end data.
|
|
IDelayedSchemaData *m_pDelayedSchemaData;
|
|
#elif defined(GC_DLL)
|
|
// GC only
|
|
CUtlVector< CExperimentDefinition > m_vecExperiments;
|
|
CUtlMap< AppId_t, CForeignAppImports *> m_mapForeignImports;
|
|
CUtlVector< AppId_t > m_vecForeignApps;
|
|
#endif
|
|
|
|
CUtlVector< CEconItemDefinition * > m_vecBundles; // A cached list of all bundles
|
|
};
|
|
|
|
#ifdef GC_DLL
|
|
void PerformIncrementKillEaterAttributeScore( CEconUserSession *pLockedOwnerSession, CEconItem *pItem, uint32 unEventType, uint32 unIncrementCount, bool bGCOrigination, GCSDK::CSharedObjectTransactionEx *pTransaction );
|
|
#endif // GC_DLL
|
|
|
|
extern CEconItemSchema & GEconItemSchema();
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// CSchemaFieldHandle
|
|
//-----------------------------------------------------------------------------
|
|
template < class T >
|
|
class CSchemaFieldHandle
|
|
{
|
|
public:
|
|
explicit CSchemaFieldHandle( const char *szName )
|
|
: m_szName( szName )
|
|
{
|
|
m_pRef = GetTypedRef();
|
|
m_unSchemaGeneration = GEconItemSchema().GetResetCount();
|
|
#if _DEBUG
|
|
m_unVersion_Debug = GEconItemSchema().GetVersion();
|
|
#endif
|
|
}
|
|
|
|
operator const T *( void ) const
|
|
{
|
|
uint32 unSchemaGeneration = GEconItemSchema().GetResetCount();
|
|
if ( m_unSchemaGeneration != unSchemaGeneration )
|
|
{
|
|
m_pRef = GetTypedRef();
|
|
m_unSchemaGeneration = unSchemaGeneration;
|
|
#if _DEBUG
|
|
m_unVersion_Debug = GEconItemSchema().GetVersion();
|
|
#endif
|
|
}
|
|
|
|
#if _DEBUG
|
|
Assert( m_unVersion_Debug == GEconItemSchema().GetVersion() );
|
|
#endif
|
|
return m_pRef;
|
|
}
|
|
|
|
const T *operator->( void ) const
|
|
{
|
|
return static_cast<const T *>( *this );
|
|
}
|
|
|
|
const char *GetName( void ) const
|
|
{
|
|
return m_szName;
|
|
}
|
|
|
|
private:
|
|
const T *GetTypedRef() const;
|
|
|
|
private:
|
|
const char *m_szName;
|
|
|
|
mutable const T *m_pRef;
|
|
mutable uint32 m_unSchemaGeneration;
|
|
#if _DEBUG
|
|
mutable uint32 m_unVersion_Debug;
|
|
#endif
|
|
};
|
|
|
|
template < >
|
|
inline const CEconColorDefinition *CSchemaFieldHandle<CEconColorDefinition>::GetTypedRef( void ) const
|
|
{
|
|
return GEconItemSchema().GetColorDefinitionByName( m_szName );
|
|
}
|
|
|
|
template < >
|
|
inline const CEconItemAttributeDefinition *CSchemaFieldHandle<CEconItemAttributeDefinition>::GetTypedRef( void ) const
|
|
{
|
|
return GEconItemSchema().GetAttributeDefinitionByName( m_szName );
|
|
}
|
|
|
|
template < >
|
|
inline const CEconItemDefinition *CSchemaFieldHandle<CEconItemDefinition>::GetTypedRef( void ) const
|
|
{
|
|
return GEconItemSchema().GetItemDefinitionByName( m_szName );
|
|
}
|
|
|
|
template < >
|
|
inline const CEconLootListDefinition *CSchemaFieldHandle<CEconLootListDefinition>::GetTypedRef( void ) const
|
|
{
|
|
return GEconItemSchema().GetLootListByName( m_szName );
|
|
}
|
|
|
|
template < >
|
|
inline const attachedparticlesystem_t *CSchemaFieldHandle<attachedparticlesystem_t>::GetTypedRef( void ) const
|
|
{
|
|
return GEconItemSchema().FindAttributeControlledParticleSystem( m_szName );
|
|
}
|
|
|
|
typedef CSchemaFieldHandle<CEconColorDefinition> CSchemaColorDefHandle;
|
|
typedef CSchemaFieldHandle<CEconItemAttributeDefinition> CSchemaAttributeDefHandle;
|
|
typedef CSchemaFieldHandle<CEconItemDefinition> CSchemaItemDefHandle;
|
|
typedef CSchemaFieldHandle<CEconLootListDefinition> CSchemaLootListDefHandle;
|
|
typedef CSchemaFieldHandle<attachedparticlesystem_t> CSchemaParticleHandle;
|
|
|
|
|
|
struct steam_market_gc_identifier_t
|
|
{
|
|
item_definition_index_t m_unDefIndex;
|
|
uint8 m_unQuality;
|
|
|
|
bool operator<( const struct steam_market_gc_identifier_t& b ) const
|
|
{
|
|
return (m_unDefIndex < b.m_unDefIndex)
|
|
|| ((m_unDefIndex == b.m_unDefIndex) && (m_unQuality < b.m_unQuality));
|
|
}
|
|
};
|
|
|
|
// Implementation reliant on earlier class content.
|
|
inline const CEconItemAttributeDefinition *static_attrib_t::GetAttributeDefinition() const
|
|
{
|
|
return GEconItemSchema().GetAttributeDefinition( iDefIndex );
|
|
}
|
|
|
|
inline const ISchemaAttributeType *static_attrib_t::GetAttributeType() const
|
|
{
|
|
const CEconItemAttributeDefinition *pAttrDef = GetAttributeDefinition();
|
|
if ( !pAttrDef )
|
|
return NULL;
|
|
|
|
return pAttrDef->GetAttributeType();
|
|
}
|
|
|
|
// Utility function to convert datafile strings to ints.
|
|
int StringFieldToInt( const char *szValue, const char **pValueStrings, int iNumStrings, bool bDontAssert = false );
|
|
int StringFieldToInt( const char *szValue, const CUtlVector<const char *>& vecValueStrings, bool bDontAssert = false );
|
|
|
|
#ifdef GC_DLL
|
|
// Global econ-level helper functionality.
|
|
EUniverse GetUniverse();
|
|
|
|
bool BYieldingGetChangedItemDefinitions( int iComparisonColumn, CUtlVector<item_definition_index_t>& out_vecChangedDefIndices );
|
|
bool BYieldingUpdateItemDefinitionStateHashValue( GCSDK::CSQLAccess& sqlAccess, item_definition_index_t unItemDef, int iUpdatedColumn );
|
|
#endif // GC_DLL
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
class CAttributeLineItemLootList : public IEconLootList
|
|
{
|
|
public:
|
|
static CSchemaAttributeDefHandle s_pAttrDef_RandomDropLineItems[4];
|
|
#ifdef GC_DLL
|
|
static CSchemaAttributeDefHandle s_pAttrDef_RandomDropLineItemUnusualChance;
|
|
static CSchemaAttributeDefHandle s_pAttrDef_RandomDropLineItemUnusualList;
|
|
#endif // GC_DLL
|
|
static CSchemaAttributeDefHandle s_pAttrDef_RandomDropLineItemFooterDesc;
|
|
|
|
public:
|
|
CAttributeLineItemLootList( const IEconItemInterface *pEconItem )
|
|
: m_pEconItem( pEconItem )
|
|
{
|
|
//
|
|
}
|
|
|
|
virtual void EnumerateUserFacingPotentialDrops( IEconLootListIterator *pIt ) const OVERRIDE;
|
|
virtual bool BPublicListContents() const OVERRIDE { return true; } // any attribute data that clients have is public to them
|
|
virtual const char *GetLootListHeaderLocalizationKey() const OVERRIDE;
|
|
virtual const char *GetLootListFooterLocalizationKey() const OVERRIDE;
|
|
virtual const char *GetLootListCollectionReference() const OVERRIDE;
|
|
|
|
#ifdef GC_DLL
|
|
MUST_CHECK_RETURN virtual bool BGenerateSingleRollRandomItems( const CEconGameAccount *pGameAccount, bool bFreeAccount, CUtlVector<CEconItem *> *out_pvecItems, const CUtlVector< item_definition_index_t > *pVecAvoidItemDefs = NULL ) const OVERRIDE;
|
|
#endif // GC_DLL
|
|
|
|
private:
|
|
const IEconItemInterface *m_pEconItem;
|
|
};
|
|
|
|
void MergeDefinitionPrefab( KeyValues *pKVWriteItem, KeyValues *pKVSourceItem );
|
|
|
|
#endif //ECONITEMSCHEMA_H
|