1778 lines
64 KiB
C++
1778 lines
64 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
#include "cbase.h"
|
|
#include "game_item_schema.h"
|
|
#include "econ_item_interface.h"
|
|
#include "econ_item_tools.h"
|
|
#include "econ_item_constants.h"
|
|
#include "econ_dynamic_recipe.h"
|
|
#include "schemainitutils.h"
|
|
|
|
|
|
|
|
bool BStringsEqual( const char *pszA, const char *pszB )
|
|
{
|
|
if ( pszA == NULL )
|
|
return pszB == NULL;
|
|
|
|
if ( pszB == NULL )
|
|
return false;
|
|
|
|
return !V_strcmp( pszA, pszB );
|
|
}
|
|
|
|
const unsigned int g_CapabilityApplicationMap[] =
|
|
{
|
|
// if we have a tool that has this capability...
|
|
// ...then we check to see if the tool target has
|
|
// this capability
|
|
|
|
ITEM_CAP_PAINTABLE, // ITEM_CAP_PAINTABLE
|
|
ITEM_CAP_NAMEABLE, // ITEM_CAP_NAMEABLE
|
|
ITEM_CAP_DECODABLE, // ITEM_CAP_DECODABLE
|
|
0, // ITEM_CAP_UNUSED; was ITEM_CAP_CAN_MOD_SOCKET
|
|
ITEM_CAP_CAN_CUSTOMIZE_TEXTURE, // ITEM_CAP_CAN_CUSTOMIZE_TEXTURE
|
|
0, // ITEM_CAP_USABLE
|
|
0, // ITEM_CAP_USABLE_GC
|
|
ITEM_CAP_CAN_GIFT_WRAP, // ITEM_CAP_CAN_GIFT_WRAP
|
|
0, // ITEM_CAP_USABLE_OUT_OF_GAME
|
|
ITEM_CAP_CAN_COLLECT, // ITEM_CAP_CAN_COLLECT
|
|
0, // ITEM_CAP_CAN_CRAFT_COUNT
|
|
0, // ITEM_CAP_CAN_CRAFT_MARK
|
|
ITEM_CAP_PAINTABLE_TEAM_COLORS | ITEM_CAP_PAINTABLE, // ITEM_CAP_PAINTABLE_TEAM_COLORS
|
|
0, // ITEM_CAP_CAN_BE_RESTORED
|
|
ITEM_CAP_CAN_USE_STRANGE_PARTS, // ITEM_CAP_CAN_USE_STRANGE_PARTS
|
|
ITEM_CAP_CAN_CARD_UPGRADE, // ITEM_CAP_CAN_CARD_UPGRADE
|
|
ITEM_CAP_CAN_STRANGIFY, // ITEM_CAP_CAN_STRANGIFY
|
|
ITEM_CAP_CAN_KILLSTREAKIFY, // ITEM_CAP_CAN_KILLSTREAKIFY
|
|
ITEM_CAP_CAN_CONSUME, // ITEM_CAP_CAN_CONSUME
|
|
ITEM_CAP_CAN_SPELLBOOK_PAGE, // ITEM_CAP_CAN_SPELLBOOK_PAGE
|
|
ITEM_CAP_HAS_SLOTS, // ITEM_CAP_HAS_SLOTS
|
|
ITEM_CAP_DUCK_UPGRADABLE, // ITEM_CAP_DUCK_UPGRADABLE
|
|
ITEM_CAP_CAN_UNUSUALIFY, // ITEM_CAP_CAN_UNUSUALIFY
|
|
};
|
|
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( g_CapabilityApplicationMap ) == NUM_ITEM_CAPS );
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// Purpose:
|
|
//---------------------------------------------------------------------------------------
|
|
bool IEconTool::ShouldDisplayQuantity( const IEconItemInterface *pTool ) const
|
|
{
|
|
Assert( pTool );
|
|
|
|
const GameItemDefinition_t *pItemDef = pTool->GetItemDefinition();
|
|
if ( !pItemDef )
|
|
return false;
|
|
|
|
static CSchemaAttributeDefHandle pAttrDef_UnlimitedQuantity( "unlimited quantity" );
|
|
if ( pTool->FindAttribute( pAttrDef_UnlimitedQuantity ) )
|
|
return false;
|
|
|
|
if ( pTool->GetQuantity() >= 0 )
|
|
{
|
|
if ( (pItemDef->GetCapabilities() & ITEM_CAP_USABLE_GC) != 0 )
|
|
return true;
|
|
|
|
if ( pItemDef->IsTool() )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// Purpose:
|
|
//---------------------------------------------------------------------------------------
|
|
CEconTool_WrappedGift::CEconTool_WrappedGift( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV )
|
|
: IEconTool( pszTypeName, pszUseString, NULL, unCapabilities )
|
|
, m_pszDeliveredGiftItemDefName( NULL )
|
|
, m_pDeliveredGiftItemDef( NULL )
|
|
, m_bIsGlobalGift( false )
|
|
, m_bIsDirectGift( false )
|
|
{
|
|
if ( pUsageKV )
|
|
{
|
|
m_bIsGlobalGift = pUsageKV->GetBool( "target_type_global", false );
|
|
m_pszDeliveredGiftItemDefName = pUsageKV->GetString( "delivered_gift_item_def", NULL );
|
|
m_bIsDirectGift = pUsageKV->GetBool( "is_direct_gift", false );
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// Purpose:
|
|
//---------------------------------------------------------------------------------------
|
|
bool CEconTool_WrappedGift::BFinishInitialization()
|
|
{
|
|
// Now that we've finished parsing our definitions, look for a match.
|
|
if ( m_pszDeliveredGiftItemDefName )
|
|
{
|
|
m_pDeliveredGiftItemDef = GetItemSchema()->GetItemDefinitionByName( m_pszDeliveredGiftItemDefName );
|
|
}
|
|
|
|
// We're done with this value.
|
|
m_pszDeliveredGiftItemDefName = NULL;
|
|
|
|
return IEconTool::BFinishInitialization();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// Purpose:
|
|
//---------------------------------------------------------------------------------------
|
|
CEconTool_GiftWrap::CEconTool_GiftWrap( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV )
|
|
: IEconTool( pszTypeName, NULL, NULL, unCapabilities )
|
|
, m_pszWrappedGiftItemDefName( NULL )
|
|
, m_pWrappedGiftItemDef( NULL )
|
|
{
|
|
if ( pUsageKV )
|
|
{
|
|
m_pszWrappedGiftItemDefName = pUsageKV->GetString( "wrapped_gift_item_def", NULL );
|
|
}
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// Purpose:
|
|
//---------------------------------------------------------------------------------------
|
|
bool CEconTool_GiftWrap::BFinishInitialization()
|
|
{
|
|
// Now that we've finished parsing our definitions, look for a match.
|
|
if ( m_pszWrappedGiftItemDefName )
|
|
{
|
|
m_pWrappedGiftItemDef = GetItemSchema()->GetItemDefinitionByName( m_pszWrappedGiftItemDefName );
|
|
}
|
|
|
|
// We're done with this value.
|
|
m_pszWrappedGiftItemDefName = NULL;
|
|
|
|
return m_pWrappedGiftItemDef != NULL
|
|
&& IEconTool::BFinishInitialization();
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// Purpose:
|
|
//---------------------------------------------------------------------------------------
|
|
bool CEconTool_GiftWrap::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
|
|
{
|
|
Assert( pTool );
|
|
Assert( pToolSubject );
|
|
|
|
if ( pToolSubject->GetQuality() == AE_SELFMADE ||
|
|
pToolSubject->GetQuality() == AE_COMMUNITY ||
|
|
pToolSubject->GetQuality() == AE_CUSTOMIZED ||
|
|
pToolSubject->GetQuality() == AE_NORMAL )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// If an item is currently trade restricted, other flags don't matter (I think).
|
|
if ( ( pToolSubject->GetUntradabilityFlags() & k_Untradability_Temporary ) != 0 )
|
|
return false;
|
|
|
|
// One item still has the gift wrap cap, which is the engagement ring ( Something Special For Someone Special (Tool) ).
|
|
// However, the can_gift_wrap cap shouldn't overcome temporary trade restrictions.
|
|
static CSchemaAttributeDefHandle pAttrDef_ToolNeedsGiftwrap( "tool needs giftwrap" );
|
|
|
|
const bool cbSubjectNeedsGiftWrap = pToolSubject->FindAttribute( pAttrDef_ToolNeedsGiftwrap );
|
|
const bool cbSubjectCanTrade = pToolSubject->IsTradable();
|
|
const bool cbSubjectCanProceed = cbSubjectNeedsGiftWrap || cbSubjectCanTrade;
|
|
|
|
if ( !cbSubjectCanProceed )
|
|
return false;
|
|
|
|
static CSchemaAttributeDefHandle pAttrDef_CannotGiftwrap( "cannot giftwrap" );
|
|
if ( pToolSubject->FindAttribute( pAttrDef_CannotGiftwrap ) )
|
|
return false;
|
|
|
|
return IEconTool::CanApplyTo( pTool, pToolSubject );
|
|
}
|
|
|
|
CEconTool_StrangeCountTransfer::CEconTool_StrangeCountTransfer( const char *pszTypeName, item_capabilities_t unCapabilities )
|
|
: IEconTool( pszTypeName, NULL, NULL, unCapabilities )
|
|
{
|
|
#ifdef CLIENT_DLL
|
|
m_pItemSrc = NULL;
|
|
m_pItemDest = NULL;
|
|
#endif // CLIENT_DLL
|
|
}
|
|
|
|
bool CEconTool_StrangeCountTransfer::AreItemsEligibleForStrangeCountTransfer( const IEconItemInterface *pItem1, const IEconItemInterface *pItem2 )
|
|
{
|
|
if ( !pItem1 || !pItem2 )
|
|
return false;
|
|
|
|
const char *pItem1Xifier = pItem1->GetItemDefinition()->GetXifierRemapClass();
|
|
const char *pItem2Xifier = pItem2->GetItemDefinition()->GetXifierRemapClass();
|
|
|
|
// if no xifier class, check if the item defs are the same
|
|
if ( !pItem1Xifier || !pItem2Xifier )
|
|
{
|
|
if ( pItem1->GetItemDefinition() != pItem2->GetItemDefinition() )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
else if ( V_stricmp( pItem1Xifier, pItem2Xifier ) != 0 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Item defs are compatabible, are there attributes? Check strange
|
|
// Check if they are both strange (have kill eater). Quality is less important
|
|
if ( !BIsItemStrange( pItem1) || !BIsItemStrange( pItem2 ) )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_StrangePart::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
|
|
{
|
|
Assert( pTool );
|
|
Assert( pToolSubject );
|
|
|
|
// Abort if for some reason we don't know what type of attribute we're trying to track.
|
|
static CSchemaAttributeDefHandle pAttrDef_StrangePartCounterID( "strange part new counter ID" );
|
|
|
|
float flNewScoreType;
|
|
if ( !FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pTool, pAttrDef_StrangePartCounterID, &flNewScoreType ) )
|
|
return false;
|
|
|
|
// Make sure we're "strange" in that we have at least one attribute tracking scores. We can't
|
|
// explicitly test for quality here because now we can have strange vintages, etc.
|
|
if ( GetKillEaterAttrCount() <= 0 )
|
|
return false;
|
|
|
|
if ( !pToolSubject->FindAttribute( GetKillEaterAttr_Score( 0 ) ) )
|
|
return false;
|
|
|
|
// Make sure the target item doesn't already have the property this tool is trying to
|
|
// apply, unless that counter is restricted, in which case we allow a second stat to be
|
|
// added with the same value.
|
|
for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
|
|
{
|
|
float flScoreType;
|
|
if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pToolSubject, GetKillEaterAttr_Type( i ), &flScoreType ) && // if we have a counter in this slot...
|
|
RoundFloatToInt( flScoreType ) == RoundFloatToInt( flNewScoreType ) && // ...and it's counting the same thing...
|
|
!pToolSubject->FindAttribute( GetKillEaterAttr_Restriction( i ) ) ) // ...and that counter isn't restricted
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Make sure we have at least one empty customizable attribute slot.
|
|
bool bFoundEmptyAttributeSlot = false;
|
|
|
|
for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
|
|
{
|
|
// Ignore non-user-customizable attributes.
|
|
if ( !GetKillEaterAttr_IsUserCustomizable( i ) )
|
|
continue;
|
|
|
|
// We expect to have both or neither of a user-customizable attribute. If this isn't the
|
|
// case the later logic will be wrong.
|
|
const bool bFoundTypeAttribute = pToolSubject->FindAttribute( GetKillEaterAttr_Type( i ) );
|
|
Assert( bFoundTypeAttribute == pToolSubject->FindAttribute( GetKillEaterAttr_Score( i ) ) );
|
|
|
|
if ( !bFoundTypeAttribute )
|
|
{
|
|
bFoundEmptyAttributeSlot = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( !bFoundEmptyAttributeSlot )
|
|
return false;
|
|
|
|
// Check to make sure the definition of the item we're trying to apply to has the tags we need
|
|
// to match and doesn't have any tags that we need to avoid. We use these to avoid tracking
|
|
// damage done for a medigun, etc.
|
|
const GameItemDefinition_t *pSubjectItemDef = pToolSubject->GetItemDefinition();
|
|
if ( !pSubjectItemDef )
|
|
return false;
|
|
|
|
#if defined( TF_DLL ) || defined( TF_GC_DLL ) || defined( TF_CLIENT_DLL )
|
|
// Strange Cosmetics can take on any part
|
|
if ( pSubjectItemDef->GetDefaultLoadoutSlot() == LOADOUT_POSITION_MISC )
|
|
{
|
|
return true;
|
|
}
|
|
#endif
|
|
|
|
FOR_EACH_VEC( m_RequiredTags.GetTagsList(), i )
|
|
{
|
|
if ( !pSubjectItemDef->HasEconTag( m_RequiredTags.GetTagsList()[i] ) )
|
|
return false;
|
|
}
|
|
|
|
FOR_EACH_VEC( m_RequiredMissingTags.GetTagsList(), i )
|
|
{
|
|
if ( pSubjectItemDef->HasEconTag( m_RequiredMissingTags.GetTagsList()[i] ) )
|
|
return false;
|
|
}
|
|
|
|
return IEconTool::CanApplyTo( pTool, pToolSubject );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
static const char *s_pszStrangeRestrictionTypes[] =
|
|
{
|
|
"", // kStrangeEventRestriction_None
|
|
"victim_account_id", // kStrangeEventRestriction_VictimSteamAccount
|
|
#if defined( TF_DLL ) || defined( TF_GC_DLL ) || defined( TF_CLIENT_DLL )
|
|
"map", // kStrangeEventRestriction_Map
|
|
"competitive", // kStrangeEventRestriction_Competitive
|
|
#endif // defined( TF_DLL ) || defined( TF_GC_DLL ) || defined( TF_CLIENT_DLL )
|
|
};
|
|
|
|
COMPILE_TIME_ASSERT( ARRAYSIZE( s_pszStrangeRestrictionTypes ) == kStrangeEventRestrictionCount );
|
|
|
|
CEconTool_StrangePartRestriction::CEconTool_StrangePartRestriction( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV )
|
|
: IEconTool( pszTypeName, pszUseString, NULL, unCapabilities )
|
|
, m_eRestrictionType( kStrangeEventRestriction_None ) // default-initialize to failure
|
|
, m_unRestrictionValue( (unsigned int)-1 )
|
|
{
|
|
Assert( pUsageKV != NULL );
|
|
|
|
// Parse our restriction type from a string. Anything invalid here will be handled below in the IsValid()
|
|
// check.
|
|
const int iRestrictionType = StringFieldToInt( pUsageKV->GetString( "restriction_type", "" ), &s_pszStrangeRestrictionTypes[0], ARRAYSIZE( s_pszStrangeRestrictionTypes ) );
|
|
if ( iRestrictionType > 0 )
|
|
{
|
|
m_eRestrictionType = (strange_event_restriction_t)iRestrictionType;
|
|
}
|
|
|
|
// We'll use this value later from inside BFinishInitialization(). We may have to look at other
|
|
// values from parts of the schema that haven't been parsed yet, like map or item names.
|
|
m_pszRestrictionValue = pUsageKV->GetString( "restriction_value", NULL );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_StrangePartRestriction::BFinishInitialization()
|
|
{
|
|
// Run different parsers based on our restriction type.
|
|
switch ( m_eRestrictionType )
|
|
{
|
|
// We don't expect anything for our sub-value when dealing with Steam accounts. Asserting based on
|
|
// bad data is dumb but we don't really have any way of sending an error all the way up the tree.
|
|
case kStrangeEventRestriction_None:
|
|
case kStrangeEventRestriction_VictimSteamAccount:
|
|
if ( m_pszRestrictionValue )
|
|
return false;
|
|
|
|
m_unRestrictionValue = 0;
|
|
break;
|
|
|
|
#if defined( TF_DLL ) || defined( TF_GC_DLL ) || defined( TF_CLIENT_DLL )
|
|
case kStrangeEventRestriction_Map:
|
|
{
|
|
if ( !m_pszRestrictionValue )
|
|
return false;
|
|
|
|
const MapDef_t *pSchemaMap = GetItemSchema()->GetMasterMapDefByName( m_pszRestrictionValue );
|
|
if ( !pSchemaMap )
|
|
return false;
|
|
|
|
m_unRestrictionValue = pSchemaMap->m_nDefIndex;
|
|
}
|
|
break;
|
|
case kStrangeEventRestriction_Competitive:
|
|
{
|
|
if (!m_pszRestrictionValue)
|
|
return false;
|
|
|
|
// Season string to int
|
|
m_unRestrictionValue = V_atoi(m_pszRestrictionValue);
|
|
}
|
|
break;
|
|
#endif // defined( TF_DLL ) || defined( TF_GC_DLL ) || defined( TF_CLIENT_DLL )
|
|
|
|
default:
|
|
AssertMsg1( false, "CEconTool_StrangePartRestriction() doesn't understand how to parse restriction type %i.", m_eRestrictionType );
|
|
return false;
|
|
}
|
|
|
|
// We're done with this value now.
|
|
m_pszRestrictionValue = NULL;
|
|
|
|
return m_eRestrictionType != kStrangeEventRestriction_None
|
|
&& m_unRestrictionValue != (unsigned int)-1
|
|
&& IEconTool::BFinishInitialization();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_StrangePartRestriction::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
|
|
{
|
|
Assert( pTool );
|
|
Assert( pTool->GetItemDefinition() );
|
|
Assert( pToolSubject );
|
|
|
|
if ( !IEconTool::CanApplyTo( pTool, pToolSubject ) )
|
|
return false;
|
|
|
|
// Abort if for some reason we don't know what type of restriction we're trying to apply.
|
|
if ( m_eRestrictionType == kStrangeEventRestriction_None )
|
|
return false;
|
|
|
|
// Abort if we don't have our tool information. We'll need this below to avoid duplicating
|
|
// scores/restrictions.
|
|
const CEconTool_StrangePartRestriction *pToolRestriction = pTool->GetItemDefinition()->GetTypedEconTool<CEconTool_StrangePartRestriction>();
|
|
if ( !pToolRestriction )
|
|
return false;
|
|
|
|
// Make sure we're "strange" in that we have at least one attribute tracking scores. We can't
|
|
// explicitly test for quality here because now we can have strange vintages, etc.
|
|
if ( GetKillEaterAttrCount() <= 0 )
|
|
return false;
|
|
|
|
if ( !pToolSubject->FindAttribute( GetKillEaterAttr_Score( 0 ) ) )
|
|
return false;
|
|
|
|
// Look through all of the strange attributes on this item. We're looking for a slot that
|
|
// has a score that we're tracking where that score doesn't already have a restriction.
|
|
// If we find one, we can restrict that particular slot as long as doing so wouldn't generate
|
|
// a duplicate score (ie., "soldier kills on Hightower"). We don't need to enumerate them
|
|
// here, just find existence/nonexistence of at least one valid target.
|
|
for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
|
|
{
|
|
if ( GetItemSchema()->BCanStrangeFilterApplyToStrangeSlotInItem( pToolRestriction->GetRestrictionType(), pToolRestriction->GetRestrictionValue(), pToolSubject, i, NULL ) )
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconTool_ItemDynamicRecipe::CEconTool_ItemDynamicRecipe( const char *pszTypeName, const char *pszUseString, item_capabilities_t unCapabilities, KeyValues *pUsageKV )
|
|
: IEconTool( pszTypeName, pszUseString, NULL, unCapabilities )
|
|
{
|
|
COMPILE_TIME_ASSERT( sizeof( attrib_value_t ) == sizeof( uint32 ) );
|
|
COMPILE_TIME_ASSERT( sizeof( attrib_value_t ) == sizeof( float ) );
|
|
|
|
if ( pUsageKV )
|
|
{
|
|
BInitFromKV( pUsageKV, &m_vecErrors );
|
|
}
|
|
}
|
|
|
|
const char* CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::m_pszUseParentNameIdentifier = "use_parents_item_def";
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Make sure each of our components are fully formed. Return false
|
|
// if any components fail BFinishInitialization_Internal()
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemDynamicRecipe::BFinishInitialization()
|
|
{
|
|
CBaseRecipeComponent::ComponentAttribVector_t attribVec;
|
|
|
|
FOR_EACH_VEC( m_vecComponents, i )
|
|
{
|
|
m_vecComponents[i]->BFinishInitialization_Internal( &m_vecErrors, &attribVec );
|
|
}
|
|
|
|
// Emit any errors we've accumulated during initialization
|
|
FOR_EACH_VEC( m_vecErrors, i )
|
|
{
|
|
#ifdef GC_DLL
|
|
EmitError( SPEW_GC, "%s\n", m_vecErrors[i].Get() );
|
|
#else
|
|
AssertMsg1( 0, "%s\n", m_vecErrors[i].Get() );
|
|
#endif
|
|
}
|
|
|
|
if( m_vecErrors.Count() > 0 )
|
|
return false;
|
|
|
|
// Make sure we have at least one item required
|
|
return IEconTool::BFinishInitialization();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Iterate through attributes on pTool to see if any can accept pToolSubject.
|
|
// Return true if any attributes match.
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemDynamicRecipe::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
|
|
{
|
|
Assert( pTool );
|
|
Assert( pToolSubject );
|
|
|
|
// Iterate through all the attributes on the tool and see if the subject item matches
|
|
// any of the recipe component attributes
|
|
CRecipeComponentMatchingIterator matchingIterator( pTool, pToolSubject );
|
|
pTool->IterateAttributes( &matchingIterator );
|
|
|
|
const CUtlVector< const CEconItemAttributeDefinition* >& vecMatchingAttribs = matchingIterator.GetMatchingComponentInputs();
|
|
// No matches, can't apply!
|
|
if( vecMatchingAttribs.Count() == 0 )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::CBaseRecipeComponent( bool bIsOutput, const CBaseRecipeComponent* pParent )
|
|
: m_bIsOutput( bIsOutput )
|
|
, m_flChanceOfApplying( 1.f )
|
|
, m_pParent( pParent )
|
|
, m_flTotalWeights( 0.f )
|
|
, m_eQuality( AE_UNDEFINED )
|
|
, m_attributesMatchingType( ATTRIBUTES_MATCH_NONE )
|
|
{}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::~CBaseRecipeComponent()
|
|
{
|
|
m_vecAdditionalComponents.PurgeAndDeleteElements();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Roll chance of component applying to the tool
|
|
//-----------------------------------------------------------------------------
|
|
#ifdef GC_DLL
|
|
int CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::RollCount() const
|
|
{
|
|
if( m_vecCountChances.Count() == 0 )
|
|
return 1;
|
|
|
|
float flRand = RandomFloat( 0.f, 1.f ) * m_flTotalWeights;
|
|
float flAccum = 0.f;
|
|
|
|
// Go through and see which counts gets rolled
|
|
FOR_EACH_VEC( m_vecCountChances, i )
|
|
{
|
|
const CountChance_t& countChance = m_vecCountChances[i];
|
|
|
|
flAccum += countChance.m_flChance;
|
|
if ( flRand <= flAccum )
|
|
{
|
|
// Winner! Roll within its range
|
|
return RandomInt( countChance.m_nMinCount, countChance.m_nMaxCount );
|
|
}
|
|
}
|
|
|
|
AssertMsg( 0, "Failed to generate a count for recipe component. Defaulting to 1" );
|
|
return 1;
|
|
}
|
|
|
|
bool CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::RollChanceOfApplying() const
|
|
{
|
|
// Guaranteed!
|
|
if( m_flChanceOfApplying == 1.f )
|
|
return true;
|
|
|
|
return RandomFloat() < m_flChanceOfApplying;
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Set chance for attributes to apply.
|
|
//-----------------------------------------------------------------------------
|
|
void CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::SetChanceOfApplying( float flChance )
|
|
{
|
|
Assert( flChance >= 0.f && flChance <= 1.f );
|
|
clamp( flChance, 0.f, 1.f );
|
|
m_flChanceOfApplying = flChance;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::BFinishInitialization_Internal( CUtlVector<CUtlString>* pVecErrors, ComponentAttribVector_t* pAttribVec )
|
|
{
|
|
FOR_EACH_VEC( m_vecAdditionalComponents, i )
|
|
{
|
|
SCHEMA_INIT_SUBSTEP( m_vecAdditionalComponents[i]->BFinishInitialization_Internal( pVecErrors, pAttribVec ) );
|
|
}
|
|
|
|
return SCHEMA_INIT_SUCCESS();
|
|
}
|
|
|
|
void CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::GetIsGuaranteed( int &nFlags ) const
|
|
{
|
|
// If we've got a 100% chance of applying, or we're the root (no parent) then we
|
|
// can mark ourselves as guaranteed and continue to check our children to see if
|
|
// any of them are guaranteed as well.
|
|
if ( m_flChanceOfApplying == 1.f || !m_pParent )
|
|
{
|
|
nFlags |= GetIsOutput() ? GUARANTEED_OUTPUT : GUARANTEED_INPUT;
|
|
|
|
FOR_EACH_VEC( m_vecAdditionalComponents, i )
|
|
{
|
|
m_vecAdditionalComponents[i]->GetIsGuaranteed( nFlags );
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentDefinedItem::CDynamicRecipeComponentDefinedItem( bool bIsOutput, const CBaseRecipeComponent* pParent )
|
|
: CBaseRecipeComponent( bIsOutput, pParent )
|
|
{}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentDefinedItem::~CDynamicRecipeComponentDefinedItem()
|
|
{}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Make sure m_strName refers to an actual item def. Return false
|
|
// if it doesn not. Child components are allowed to have "use_parents_item_def"
|
|
// as their item name.
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentDefinedItem::BFinishInitialization_Internal( CUtlVector<CUtlString>* pVecErrors, ComponentAttribVector_t* pAttribVec )
|
|
{
|
|
// Go through and make sure we have a bit of information that let's us describe an item
|
|
bool bAnyDataSet = false;
|
|
|
|
// Item def?
|
|
if ( m_pParent == NULL && GetItemSchema()->GetItemDefinitionByName( m_strName ) )
|
|
{
|
|
bAnyDataSet = true;
|
|
}
|
|
else if ( BStringsEqual( m_strName, m_pszUseParentNameIdentifier ) || GetItemSchema()->GetItemDefinitionByName( m_strName ) )
|
|
{
|
|
bAnyDataSet = true;
|
|
}
|
|
|
|
// Quality?
|
|
if ( m_eQuality != AE_UNDEFINED )
|
|
{
|
|
bAnyDataSet = true;
|
|
}
|
|
|
|
// Attributes?
|
|
if ( m_vecDynamicAttributes.Count() )
|
|
{
|
|
bAnyDataSet = true;
|
|
}
|
|
|
|
// We better have one of the above
|
|
SCHEMA_INIT_CHECK( bAnyDataSet, "Not enough data to describe component" );
|
|
|
|
#ifdef GC_DLL
|
|
// Get next available attrib def for defining the item
|
|
CEconItemAttributeDefinition* pAttribDef = GetNextAvailableAttributeWithBaseName( GetAttributeName(), pAttribVec );
|
|
SCHEMA_INIT_CHECK( pAttribDef, "Too many potential components" );
|
|
if( pAttribDef )
|
|
{
|
|
pAttribVec->AddToTail( pAttribDef );
|
|
}
|
|
#endif
|
|
|
|
SCHEMA_INIT_SUBSTEP( BaseClass::BFinishInitialization_Internal( pVecErrors, pAttribVec ) );
|
|
|
|
return SCHEMA_INIT_SUCCESS();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Parse out our item definition name and quality. Return false if
|
|
// either does not exist
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentDefinedItem::ParseKV( KeyValues *pKV, CUtlVector<CUtlString> *pVecErrors )
|
|
{
|
|
bool bNoItemDef = !!pKV->FindKey( "no_item_def" );
|
|
bool bItemName = !!pKV->FindKey( "item_name" );
|
|
|
|
// Make sure only one of the above is set
|
|
SCHEMA_INIT_CHECK( bNoItemDef != bItemName,
|
|
"Both \"no_item_def\" and \"item_name\" specified in component." );
|
|
|
|
// Make sure at least one of the above is set
|
|
SCHEMA_INIT_CHECK( bNoItemDef || bItemName,
|
|
"Neither \"no_item_def\" or \"item_name\" specified in component." );
|
|
|
|
// If they specified an item name, then we need to grab it
|
|
if ( bItemName )
|
|
{
|
|
m_strName = pKV->GetString( "item_name", NULL );
|
|
}
|
|
|
|
return BaseClass::ParseKV( pKV, pVecErrors );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Convert ourselves into an attribute. Return false if our encoded
|
|
// attributes exceed the allocated space for attributes
|
|
//-----------------------------------------------------------------------------
|
|
#ifdef GC_DLL
|
|
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentDefinedItem::AddRecipeComponentAsAttribute( CEconItem *pItem, const CEconGameAccount *pGameAccount ) const
|
|
{
|
|
// Check if we should even apply
|
|
if( !RollChanceOfApplying() )
|
|
return true;
|
|
|
|
// Gather up all the current attributes on the item
|
|
ComponentAttribVector_t attribVec;
|
|
CRecipeComponentMatchingIterator matchingIterator( pItem, NULL );
|
|
pItem->IterateAttributes( &matchingIterator );
|
|
attribVec.AddVectorToTail( matchingIterator.GetMatchingComponentInputs() );
|
|
attribVec.AddVectorToTail( matchingIterator.GetMatchingComponentOutputs() );
|
|
|
|
// Get next available attrib def for defining the item
|
|
const CEconItemAttributeDefinition* pAttribDef = GetNextAvailableAttributeWithBaseName( GetAttributeName(), &attribVec );
|
|
if( !pAttribDef )
|
|
return false;
|
|
|
|
uint32 nFlags = 0;
|
|
CAttribute_DynamicRecipeComponent typedValue;
|
|
|
|
// Check if our item name is specified to use our parent's
|
|
const char* pszItemDefName = m_strName;
|
|
if ( m_strName && m_strName[0] )
|
|
{
|
|
if( BStringsEqual( m_pszUseParentNameIdentifier, pszItemDefName ) && m_pParent )
|
|
{
|
|
// It's only possible to have another CDynamicRecipeComponentDefinedItem as a parent
|
|
const CDynamicRecipeComponentDefinedItem* pParentDefinedItemComponent = dynamic_cast< const CDynamicRecipeComponentDefinedItem* >( m_pParent );
|
|
AssertMsg( pParentDefinedItemComponent, "Parent attribute passed into defined item component is not a defined item component" );
|
|
if( !pParentDefinedItemComponent )
|
|
{
|
|
return false;
|
|
}
|
|
// Adopt our parent's item name
|
|
pszItemDefName = pParentDefinedItemComponent->m_strName;
|
|
}
|
|
|
|
// Make sure this item def exists
|
|
CEconItemDefinition* pItemDef = GetItemSchema()->GetItemDefinitionByName( pszItemDefName );
|
|
AssertMsg1( pItemDef, "No item def named %s found when applying defined item component", pszItemDefName );
|
|
if( !pItemDef )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Set the item def
|
|
typedValue.set_def_index( (uint32)pItemDef->GetDefinitionIndex() );
|
|
nFlags |= DYNAMIC_RECIPE_FLAG_PARAM_ITEM_DEF_SET;
|
|
}
|
|
|
|
// Set the quality, if we're supposed to
|
|
if ( m_eQuality != AE_UNDEFINED )
|
|
{
|
|
typedValue.set_item_quality( (uint32)m_eQuality );
|
|
nFlags |= DYNAMIC_RECIPE_FLAG_PARAM_QUALITY_SET;
|
|
}
|
|
|
|
nFlags |= m_bIsOutput ? DYNAMIC_RECIPE_FLAG_IS_OUTPUT : 0;
|
|
|
|
if ( m_attributesMatchingType == ATTRIBUTES_MATCH_ALL )
|
|
{
|
|
nFlags |= DYNAMIC_RECIPE_FLAG_PARAM_ATTRIBUTE_SET_ALL;
|
|
}
|
|
else if ( m_attributesMatchingType == ATTRIBUTES_MATCH_ANY )
|
|
{
|
|
nFlags |= DYNAMIC_RECIPE_FLAG_PARAM_ATTRIBUTE_SET_ANY;
|
|
}
|
|
|
|
// Make sure any of the flags (besides the output flag) is set
|
|
if ( ( nFlags & ~DYNAMIC_RECIPE_FLAG_IS_OUTPUT ) == 0 )
|
|
{
|
|
AssertMsg(0, "Created component without any data flags set!" );
|
|
return false;
|
|
}
|
|
|
|
typedValue.set_component_flags( nFlags );
|
|
typedValue.set_num_required( RollCount() );
|
|
typedValue.set_num_fulfilled( 0 );
|
|
|
|
// Write out attribute all attribute indexes and values, separated by what we expect to be an invalid character sequence
|
|
CUtlString strAttribs;
|
|
FOR_EACH_VEC( m_vecDynamicAttributes, i )
|
|
{
|
|
if( i != 0 )
|
|
{
|
|
strAttribs.Append( g_pszAttrEncodeSeparator );
|
|
}
|
|
// Convert all of our attributes into a string.
|
|
strAttribs.Append( CFmtStr( "%d", m_vecDynamicAttributes[i].m_AttrIndex ) );
|
|
strAttribs.Append( g_pszAttrEncodeSeparator );
|
|
strAttribs.Append( m_vecDynamicAttributes[i].m_strAttrData.Get() );
|
|
}
|
|
|
|
// Make sure we're not too long
|
|
if( strAttribs.Length() >= 1024 )
|
|
{
|
|
AssertMsg1( 0, "String-encoded attributes exceeds 1024 characters, when encoding component %s", m_strName.Get() );
|
|
return false;
|
|
}
|
|
|
|
// Set it in there!
|
|
typedValue.set_attributes_string( strAttribs.Get() );
|
|
|
|
// Check to see if we're about to create a duplicate. There's no need to spend another
|
|
// attribute to describe the same item. Let's instead just increase the count on the
|
|
// already-existing attribute.
|
|
FOR_EACH_VEC( attribVec, i )
|
|
{
|
|
CAttribute_DynamicRecipeComponent existingValue;
|
|
if( pItem->FindAttribute( attribVec[i], &existingValue ) )
|
|
{
|
|
if( typedValue.def_index() == existingValue.def_index() &&
|
|
typedValue.item_quality() == existingValue.item_quality() &&
|
|
typedValue.component_flags() == existingValue.component_flags() &&
|
|
typedValue.attributes_string() == existingValue.attributes_string() )
|
|
{
|
|
pAttribDef = attribVec[i];
|
|
existingValue.set_num_required( existingValue.num_required() + typedValue.num_required() );
|
|
typedValue = existingValue;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
|
|
pItem->SetDynamicAttributeValue( pAttribDef, typedValue );
|
|
|
|
// Go through and add any additional components that depend on this component
|
|
FOR_EACH_VEC( m_vecAdditionalComponents, i )
|
|
{
|
|
CBaseRecipeComponent* pAdditionalComponent = m_vecAdditionalComponents[i];
|
|
pAdditionalComponent->AddRecipeComponentAsAttribute( pItem, pGameAccount );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::CDynamicRecipeComponentLootList( bool bIsOutput, const CBaseRecipeComponent* pParent )
|
|
: CEconTool_ItemDynamicRecipe::CBaseRecipeComponent( bIsOutput, pParent )
|
|
#ifdef GC_DLL
|
|
, m_eUniqueness( UNIQUE_AMONG_NOTHING )
|
|
#endif
|
|
{}
|
|
|
|
|
|
|
|
CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::~CDynamicRecipeComponentLootList()
|
|
{}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Make sure m_strName actually refers to a lootlist
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::BFinishInitialization_Internal( CUtlVector<CUtlString>* pVecErrors, ComponentAttribVector_t* pAttribVec )
|
|
{
|
|
// The game doesn't have all of the lootlists
|
|
#ifdef GC_DLL
|
|
SCHEMA_INIT_CHECK( GEconItemSchema().GetLootListByName( m_strName ),
|
|
"CDynamicRecipeComponentLootList has invalid loot list: %s", m_strName.Get() );
|
|
|
|
// Get next available attrib def for defining the item
|
|
CEconItemAttributeDefinition* pAttribDef = GetNextAvailableAttributeWithBaseName( GetAttributeName(), pAttribVec );
|
|
SCHEMA_INIT_CHECK( pAttribDef, "Too many potential recipe components!" );
|
|
if( pAttribDef )
|
|
{
|
|
pAttribVec->AddToTail( pAttribDef );
|
|
}
|
|
|
|
// Inputs are not allowed to be marked UNIQUE_AMONG_OUTPUTS. Rather, mark the outputs UNIQUE_AMONG_INPUTS
|
|
SCHEMA_INIT_CHECK( !(m_eUniqueness == UNIQUE_AMONG_OUTPUTS && !GetIsOutput() ), "Input component marked to be unique among inputs. Not supported!" );
|
|
#endif
|
|
|
|
// Skip defined item
|
|
SCHEMA_INIT_SUBSTEP( BaseClass::BFinishInitialization_Internal( pVecErrors, pAttribVec ) );
|
|
|
|
return SCHEMA_INIT_SUCCESS();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Parse in our lootlist name and quality. Return false if either doesn't exist
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::ParseKV( KeyValues *pKV, CUtlVector<CUtlString> *pVecErrors )
|
|
{
|
|
const char* pszLootListName = pKV->GetString( "lootlist_name" );
|
|
SCHEMA_INIT_CHECK( pszLootListName != NULL,
|
|
"Missing lootlist name in lootlist recipe component" );
|
|
|
|
m_strName = pszLootListName;
|
|
|
|
bool bBaseResult = BaseClass::ParseKV( pKV, pVecErrors );
|
|
|
|
#ifdef GC_DLL
|
|
// By default, outputs try to avoid rolling as input, and inputs dont try to avoid anything
|
|
m_eUniqueness = GetIsOutput() ? UNIQUE_AMONG_INPUTS : UNIQUE_AMONG_NOTHING;
|
|
const char* pszUniqueness = pKV->GetString( "uniqueness" );
|
|
if ( !V_stricmp( "unique_among_inputs", pszUniqueness ) )
|
|
{
|
|
m_eUniqueness = UNIQUE_AMONG_INPUTS;
|
|
}
|
|
else if ( !V_stricmp( "unique_among_outputs", pszUniqueness ) )
|
|
{
|
|
m_eUniqueness = UNIQUE_AMONG_OUTPUTS;
|
|
}
|
|
else if ( !V_stricmp( "unique_among_everything", pszUniqueness ) )
|
|
{
|
|
m_eUniqueness = UNIQUE_AMONG_EVERYTHING;
|
|
}
|
|
#endif
|
|
|
|
return bBaseResult;
|
|
}
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Roll our item definition, then call our base to convert ourselves into an attribute
|
|
//-----------------------------------------------------------------------------
|
|
#ifdef GC_DLL
|
|
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::AddRecipeComponentAsAttribute( CEconItem *pItem, const CEconGameAccount *pGameAccount ) const
|
|
{
|
|
// Check if we should even apply
|
|
if( !RollChanceOfApplying() )
|
|
return true;
|
|
|
|
// See if there's any item defs we should try to avoid
|
|
CRecipeComponentInputDefIndexIterator inputIterator( m_eUniqueness );
|
|
pItem->IterateAttributes( &inputIterator );
|
|
|
|
const char* pszItemDefName = NULL;
|
|
// Roll the item and any additional attributes
|
|
CUtlVector< StringEncodedAttribute_t > vecLootlistGeneratedAttributes;
|
|
if (!RollLootlistItemAndAttributes( vecLootlistGeneratedAttributes, &pszItemDefName, &inputIterator.GetMatchingComponentInputs(), pGameAccount ) )
|
|
{
|
|
return false;
|
|
}
|
|
vecLootlistGeneratedAttributes.AddVectorToTail( m_vecDynamicAttributes );
|
|
|
|
// Create a temporary defined item component based on the lootlist roll
|
|
CDynamicRecipeComponentDefinedItem definedItem( m_bIsOutput, this );
|
|
definedItem.m_eQuality = m_eQuality;
|
|
definedItem.m_strName = pszItemDefName;
|
|
definedItem.m_attributesMatchingType = m_attributesMatchingType;
|
|
definedItem.m_vecDynamicAttributes = vecLootlistGeneratedAttributes;
|
|
definedItem.m_vecCountChances = m_vecCountChances;
|
|
definedItem.m_flTotalWeights = m_flTotalWeights;
|
|
|
|
// Write out this defined item
|
|
definedItem.AddRecipeComponentAsAttribute( pItem, pGameAccount );
|
|
|
|
// Create any additional components that depend on this component existing
|
|
FOR_EACH_VEC( m_vecAdditionalComponents, i )
|
|
{
|
|
CBaseRecipeComponent* pAdditionalComponent = m_vecAdditionalComponents[i];
|
|
// Update the parent to be the item we generated
|
|
pAdditionalComponent->SetParent( &definedItem );
|
|
pAdditionalComponent->AddRecipeComponentAsAttribute( pItem, pGameAccount );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Roll our item definition, then call our base to convert ourselves into an attribute
|
|
//-----------------------------------------------------------------------------
|
|
class CAttributeToStringIterator : public IEconItemUntypedAttributeIterator
|
|
{
|
|
public:
|
|
CAttributeToStringIterator( CUtlVector< CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::StringEncodedAttribute_t >& vecAdditionalAttribs, CEconItem* pItem )
|
|
: m_vecAdditionalAttribs( vecAdditionalAttribs )
|
|
, m_pItem( pItem )
|
|
{}
|
|
|
|
virtual bool OnIterateAttributeValueUntyped( const CEconItemAttributeDefinition *pAttrDef )
|
|
{
|
|
const CEconItem::attribute_t *pAttrInternalData = m_pItem->FindDynamicAttributeInternal( pAttrDef );
|
|
|
|
// Only export attributes that we have dynamic data for.
|
|
if ( pAttrInternalData )
|
|
{
|
|
const ISchemaAttributeType *pAttrType = pAttrDef->GetAttributeType();
|
|
Assert( pAttrType );
|
|
|
|
// Set the definition index
|
|
auto& attrib = m_vecAdditionalAttribs[ m_vecAdditionalAttribs.AddToTail() ];
|
|
attrib.m_AttrIndex = pAttrDef->GetDefinitionIndex();
|
|
|
|
// Convert the value to a string
|
|
std::string sAttrValue;
|
|
pAttrType->ConvertEconAttributeValueToString( pAttrDef, pAttrInternalData->m_value, &sAttrValue );
|
|
|
|
Assert( sAttrValue.length() > 0 );
|
|
attrib.m_strAttrData.Set( sAttrValue.c_str() );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
private:
|
|
|
|
CUtlVector< CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::StringEncodedAttribute_t >& m_vecAdditionalAttribs;
|
|
CEconItem* m_pItem;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Roll our item definition. This will give us a list of item definition. From this list
|
|
// we take the first one and set our item def name and quality to be its. We then take any
|
|
// attributes that it may have rolled and add them to our attributes as well. Return false
|
|
// if any of these steps fail.
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemDynamicRecipe::CDynamicRecipeComponentLootList::RollLootlistItemAndAttributes( CUtlVector< StringEncodedAttribute_t >& vecAdditionalAttribs
|
|
, const char** pszDefName
|
|
, const CUtlVector< item_definition_index_t > *pVecAvoidItemDefs
|
|
, const CEconGameAccount *pGameAccount ) const
|
|
{
|
|
const CEconLootListDefinition* pLootList = GEconItemSchema().GetLootListByName( m_strName );
|
|
|
|
if( !pLootList )
|
|
{
|
|
AssertMsg1( 0, "Lootlist %s not found when adding dynamic attribute", m_strName.Get() );
|
|
return false;
|
|
}
|
|
|
|
CUtlVector<CEconItem *> vecRolledItems;
|
|
// Roll our items
|
|
CDefaultUniformRandomStream RandomStream;
|
|
if ( !pLootList->BGenerateSingleRollRandomItems( pGameAccount, false, &vecRolledItems ) )
|
|
{
|
|
AssertMsg1( 0, "Error generating item defs from lootlist \"%s\"", m_strName.Get() );
|
|
return false;
|
|
}
|
|
|
|
// We're just going to use the first one
|
|
CEconItem* pGeneratedItem = vecRolledItems.Head();
|
|
|
|
// Set our name and quality
|
|
(*pszDefName) = pGeneratedItem->GetItemDefinition()->GetDefinitionName();
|
|
const_cast<CDynamicRecipeComponentLootList*>(this)->m_eQuality = (EEconItemQuality)pGeneratedItem->GetQuality();
|
|
|
|
// Sniff and encode the attributes
|
|
CAttributeToStringIterator attrToString( vecAdditionalAttribs, pGeneratedItem );
|
|
pGeneratedItem->IterateAttributes( &attrToString );
|
|
|
|
// Cleanup
|
|
for( auto pItem : vecRolledItems )
|
|
{
|
|
delete pItem;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
#endif
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Delete all the things
|
|
//-----------------------------------------------------------------------------
|
|
CEconTool_ItemDynamicRecipe::~CEconTool_ItemDynamicRecipe()
|
|
{
|
|
m_vecComponents.PurgeAndDeleteElements();
|
|
}
|
|
|
|
CEconTool_ItemDynamicRecipe::CRecipeComponentInputDefIndexIterator::CRecipeComponentInputDefIndexIterator( EItemDefUniqueness_t eUniqueness )
|
|
: m_eUniqueness( eUniqueness )
|
|
{}
|
|
|
|
bool CEconTool_ItemDynamicRecipe::CRecipeComponentInputDefIndexIterator::OnIterateAttributeValue( const CEconItemAttributeDefinition *pAttrDef, const CAttribute_DynamicRecipeComponent& value )
|
|
{
|
|
// We dont care
|
|
if ( m_eUniqueness == CEconTool_ItemDynamicRecipe::UNIQUE_AMONG_NOTHING )
|
|
return true;
|
|
|
|
// Only check against outputs
|
|
if ( m_eUniqueness == CEconTool_ItemDynamicRecipe::UNIQUE_AMONG_OUTPUTS && !( value.component_flags() & DYNAMIC_RECIPE_FLAG_IS_OUTPUT ) )
|
|
return true;
|
|
|
|
// Only check against inputs
|
|
if ( m_eUniqueness == CEconTool_ItemDynamicRecipe::UNIQUE_AMONG_INPUTS && value.component_flags() & DYNAMIC_RECIPE_FLAG_IS_OUTPUT )
|
|
return true;
|
|
|
|
// Add this item def if we haven't seen it
|
|
if ( m_vecInputItemDefs.Find( value.def_index() ) == m_vecInputItemDefs.InvalidIndex() )
|
|
{
|
|
m_vecInputItemDefs.AddToTail( value.def_index() );
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Parse all of our inputs then outputs
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemDynamicRecipe::BInitFromKV( KeyValues *pKVDef, CUtlVector<CUtlString> *pVecErrors )
|
|
{
|
|
// Parse the components blocks
|
|
SCHEMA_INIT_SUBSTEP( CBaseRecipeComponent::ParseComponentsBlock( pKVDef, m_vecComponents, pVecErrors, NULL ) );
|
|
|
|
// Sort the component vector such that inputs go first
|
|
struct RecipeComponentSorter
|
|
{
|
|
static int SortRecipeComponentVector( CEconTool_ItemDynamicRecipe::CBaseRecipeComponent* const *pComponent1, CEconTool_ItemDynamicRecipe::CBaseRecipeComponent* const *pComponent2 )
|
|
{
|
|
return (*pComponent1)->GetIsOutput() && !(*pComponent2)->GetIsOutput();
|
|
}
|
|
};
|
|
|
|
m_vecComponents.Sort( &RecipeComponentSorter::SortRecipeComponentVector );
|
|
|
|
#ifdef GC_DLL
|
|
int nFlags = 0;
|
|
FOR_EACH_VEC( m_vecComponents, i )
|
|
{
|
|
m_vecComponents[i]->GetIsGuaranteed( nFlags );
|
|
}
|
|
|
|
SCHEMA_INIT_CHECK( nFlags & GUARANTEED_OUTPUT, "No guaranteed outputs for dynamic recipe" );
|
|
SCHEMA_INIT_CHECK( nFlags & GUARANTEED_INPUT, "No guaranteed inputs for dynamic recipe" );
|
|
#endif
|
|
|
|
return SCHEMA_INIT_SUCCESS();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Parse the component blocks, determining if this component is an input or output
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::ParseComponentsBlock( KeyValues *pKV, CUtlVector<CBaseRecipeComponent*>& vecComponents, CUtlVector<CUtlString> *pVecErrors, const CBaseRecipeComponent* pParent )
|
|
{
|
|
// The components block doesn't exist on the client
|
|
|
|
KeyValues *pKVComponents = pKV->FindKey( "components" );
|
|
#ifdef GC_DLL
|
|
SCHEMA_INIT_CHECK( pKVComponents || pParent, "Failed to parse components block in dynamic recipe" );
|
|
#endif
|
|
if ( pKVComponents )
|
|
{
|
|
// There's duplicate code when we read in like this, but it makes the
|
|
// item defs much easier to read
|
|
|
|
// Parse all the inputs
|
|
KeyValues *pKVParameters = pKVComponents->FindKey( "input" );
|
|
if( pKVParameters )
|
|
{
|
|
ParseComponents( pKVParameters, vecComponents, false, pVecErrors, pParent );
|
|
}
|
|
|
|
#ifdef GC_DLL
|
|
// Parse all the outputs
|
|
pKVParameters = pKVComponents->FindKey( "output" );
|
|
if( pKVParameters )
|
|
{
|
|
ParseComponents( pKVParameters, vecComponents, true, pVecErrors, pParent );
|
|
}
|
|
#endif
|
|
}
|
|
|
|
|
|
|
|
return SCHEMA_INIT_SUCCESS();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Create the appropriate component types and have them parse themselves.
|
|
// Returns true if at least one of the components parsed has a 100% chance
|
|
// of applying, and we don't have a parent
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::ParseComponents( KeyValues *pKV, CUtlVector<CBaseRecipeComponent*>& vecComponents, bool bIsOutput, CUtlVector<CUtlString> *pVecErrors, const CBaseRecipeComponent* pParent )
|
|
{
|
|
// Go through each entry in the tool
|
|
KeyValues *pEntry = pKV->GetFirstSubKey();
|
|
while( pEntry )
|
|
{
|
|
// Find which type is being specified.
|
|
CBaseRecipeComponent *pComponent = NULL;
|
|
if( pEntry->FindKey( "lootlist_name" ) )
|
|
{
|
|
pComponent = vecComponents[vecComponents.AddToTail( new CDynamicRecipeComponentLootList( bIsOutput, pParent ) )];
|
|
}
|
|
else if ( pEntry->FindKey( "item_name" ) || pEntry->FindKey( "no_item_def" ) )
|
|
{
|
|
pComponent = vecComponents[vecComponents.AddToTail( new CDynamicRecipeComponentDefinedItem( bIsOutput, pParent ) )];
|
|
}
|
|
else
|
|
{
|
|
SCHEMA_INIT_CHECK( false, "Unrecognized recipe component type!" );
|
|
}
|
|
|
|
// Now that we've got the right type, parse!
|
|
if( pComponent )
|
|
{
|
|
pComponent->ParseKV( pEntry, pVecErrors );
|
|
}
|
|
|
|
pEntry = pEntry->GetNextKey();
|
|
}
|
|
|
|
return SCHEMA_INIT_SUCCESS();
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Parse in all of the attributes for this component. Attributes have
|
|
// already been parsed in, so we can immediately check if the attribute exists.
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::ParseKV( KeyValues *pKV, CUtlVector<CUtlString> *pVecErrors )
|
|
{
|
|
// Get the quality string
|
|
const char* pszQuality = pKV->GetString( "quality", NULL );
|
|
if ( pszQuality )
|
|
{
|
|
// Convert the quality string to a item quality
|
|
m_eQuality = EconQuality_GetQualityFromString( pszQuality );
|
|
SCHEMA_INIT_CHECK( m_eQuality != AE_UNDEFINED, "Invalid item quality \"%s\" specified for component \"%s\"", pszQuality, m_strName.Get() );
|
|
}
|
|
|
|
const char* pszAttributesMatchingType = pKV->GetString( "attributes_matching_type", NULL );
|
|
if ( pszAttributesMatchingType )
|
|
{
|
|
if ( !V_stricmp( pszAttributesMatchingType, "all" ) )
|
|
{
|
|
m_attributesMatchingType = ATTRIBUTES_MATCH_ALL;
|
|
}
|
|
else if ( !V_stricmp( pszAttributesMatchingType, "any" ) )
|
|
{
|
|
m_attributesMatchingType = ATTRIBUTES_MATCH_ANY;
|
|
}
|
|
else
|
|
{
|
|
SCHEMA_INIT_CHECK( 0, "Invalid attributes_matching_type \"%s\"", pszAttributesMatchingType );
|
|
}
|
|
}
|
|
|
|
// Parse all of our attributes
|
|
KeyValues* pKVAttribs = pKV->FindKey( "attributes" );
|
|
if( pKVAttribs )
|
|
{
|
|
FOR_EACH_SUBKEY( pKVAttribs, pKVAttribute )
|
|
{
|
|
static_attrib_t staticAttrib;
|
|
|
|
SCHEMA_INIT_SUBSTEP( staticAttrib.BInitFromKV_SingleLine( "attributes", pKVAttribute, pVecErrors ) );
|
|
|
|
const CEconItemAttributeDefinition * pAttrDef = staticAttrib.GetAttributeDefinition();
|
|
SCHEMA_INIT_CHECK( pAttrDef != NULL, "Attribute index %i not found when specifying dynamic recipe", staticAttrib.iDefIndex );
|
|
|
|
StringEncodedAttribute_t& attrib = m_vecDynamicAttributes[ m_vecDynamicAttributes.AddToTail() ];
|
|
attrib.m_AttrIndex = pAttrDef->GetDefinitionIndex();
|
|
attrib.m_strAttrData = pKVAttribs->GetString( pKVAttribute->GetName(), "" );
|
|
|
|
Assert( !attrib.m_strAttrData.IsEmpty() );
|
|
}
|
|
}
|
|
|
|
// Get our chance of applying. Default to 100%
|
|
float flChance = pKV->GetFloat( "chance", 1.f );
|
|
// Make sure it's in the range (0,1]
|
|
SCHEMA_INIT_CHECK( flChance > 0.f && flChance <= 1.f, "Recipe component chance to apply out of bounds: %f", flChance );
|
|
SetChanceOfApplying( flChance );
|
|
|
|
// Read in the "counts" block if it exists
|
|
KeyValues *pKVCounts = pKV->FindKey( "counts" );
|
|
if( pKVCounts )
|
|
{
|
|
// Read check count entry
|
|
FOR_EACH_SUBKEY( pKVCounts, pKVEntry )
|
|
{
|
|
// Split out count range of the format "#-#", or just "#"
|
|
CUtlStringList vecCount;
|
|
const char* pszCount = pKVEntry->GetName();
|
|
V_SplitString( pszCount, "-", vecCount );
|
|
SCHEMA_INIT_CHECK( vecCount.Count() == 1 || vecCount.Count() == 2, "Malformed count value: %s", pszCount );
|
|
|
|
CountChance_t& countChance = m_vecCountChances[ m_vecCountChances.AddToTail() ];
|
|
|
|
// Add up the chances
|
|
countChance.m_flChance = (float)pKVEntry->GetInt();
|
|
m_flTotalWeights += countChance.m_flChance;
|
|
// Set the min and the max. If no max is specifid, then max is the min
|
|
countChance.m_nMinCount = V_atoi( vecCount[0] );
|
|
countChance.m_nMaxCount = vecCount.Count() > 1 ? V_atoi( vecCount[1] ) : countChance.m_nMinCount;
|
|
// Make sure max >= min and min > 0
|
|
SCHEMA_INIT_CHECK( countChance.m_nMaxCount >= countChance.m_nMinCount, "Recipe component count max is less than the min: %s", pszCount );
|
|
SCHEMA_INIT_CHECK( countChance.m_nMinCount > 0, "Recipe component count min less than 0: %s", pszCount );
|
|
}
|
|
}
|
|
|
|
// Init any components we may have in us
|
|
SCHEMA_INIT_CHECK( ParseComponentsBlock( pKV, m_vecAdditionalComponents, pVecErrors, this ), "Failed to parse nested components block in dynamic recipe" );
|
|
|
|
return SCHEMA_INIT_SUCCESS();
|
|
}
|
|
|
|
|
|
#ifdef GC_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: This tool will apply recipe components as attributes. Go through each
|
|
// of our attributes, roll to see if it applies, and convert it to an attribute
|
|
// and add it to the item if we do. Return false if we ever fail.
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemDynamicRecipe::BGenerateDynamicAttributes( CEconItem* pItem, const CEconGameAccount *pGameAccount ) const
|
|
{
|
|
// Go through our inputs and write them out into attributes
|
|
FOR_EACH_VEC( m_vecComponents, i )
|
|
{
|
|
if( !m_vecComponents[i]->AddRecipeComponentAsAttribute( pItem, pGameAccount ) )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Scan the item for numbered attributes with the passed in base name.
|
|
// Return the attribute of the next available index or NULL if there are
|
|
// none available
|
|
//-----------------------------------------------------------------------------
|
|
CEconItemAttributeDefinition* CEconTool_ItemDynamicRecipe::CBaseRecipeComponent::GetNextAvailableAttributeWithBaseName( const char* pszBaseAttribName, ComponentAttribVector_t* pAttribVec )
|
|
{
|
|
Assert( pAttribVec );
|
|
if( !pAttribVec )
|
|
return NULL;
|
|
|
|
CEconItemAttributeDefinition *pAttribDef = NULL;
|
|
int i=1;
|
|
while( pAttribDef == NULL )
|
|
{
|
|
const char* pszAttribName = CFmtStr( "%s %d", pszBaseAttribName, i++ );
|
|
|
|
CEconItemAttributeDefinition *pTempAttribDef = GEconItemSchema().GetAttributeDefinitionByName( pszAttribName );
|
|
|
|
// Check to see if this attribute we're talking about even exists
|
|
if( !pTempAttribDef )
|
|
{
|
|
return NULL;
|
|
}
|
|
|
|
// Check if the vector doesn't have this attribute. If not, it's available
|
|
if( pAttribVec->Find( pTempAttribDef ) == pAttribVec->InvalidIndex() )
|
|
{
|
|
pAttribDef = pTempAttribDef;
|
|
}
|
|
}
|
|
|
|
return pAttribDef;
|
|
}
|
|
#endif
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_Xifier::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
|
|
{
|
|
Assert( pTool );
|
|
Assert( pToolSubject );
|
|
|
|
const CEconItemDefinition *pSubjectItemDef = pToolSubject->GetItemDefinition();
|
|
if ( !pSubjectItemDef )
|
|
return false;
|
|
|
|
// Check to make sure the definition of the item we're trying to apply to has the tags we need to match.
|
|
FOR_EACH_VEC( m_RequiredTags.GetTagsList(), i )
|
|
{
|
|
if ( !pSubjectItemDef->HasEconTag( m_RequiredTags.GetTagsList()[i] ) )
|
|
return false;
|
|
}
|
|
|
|
// If this xifier has target restrictions, ensure our subject is one of them
|
|
if ( m_ItemDefTargetRestrictions.Count() > 0 )
|
|
{
|
|
bool bPassed = false;
|
|
FOR_EACH_VEC( m_ItemDefTargetRestrictions, i )
|
|
{
|
|
const CEconItemDefinition *pTargetItemDef = GetItemSchema()->GetItemDefinition( m_ItemDefTargetRestrictions[i] );
|
|
if ( ItemDefMatch( pSubjectItemDef, pTargetItemDef ) )
|
|
{
|
|
bPassed = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( bPassed == false )
|
|
return false;
|
|
}
|
|
|
|
// if rarity restriction, target needs rarity of this or lower
|
|
if ( m_ItemRarityRestriction != k_unItemRarity_Any )
|
|
{
|
|
uint8 unSubjectRarity = pToolSubject->GetItemDefinition()->GetRarity();
|
|
if ( unSubjectRarity == k_unItemRarity_Any || unSubjectRarity == 0 || unSubjectRarity > m_ItemRarityRestriction )
|
|
return false;
|
|
|
|
// needs to be equippable
|
|
static CSchemaAttributeDefHandle pAttribDef_StatModule( "weapon_uses_stattrak_module" );
|
|
if ( !pToolSubject->FindAttribute( pAttribDef_StatModule ) )
|
|
return false;
|
|
}
|
|
|
|
// Check if we have a restriction as an attribute
|
|
static CSchemaAttributeDefHandle pAttribDef_ToolTargetItem( "tool target item" );
|
|
float value;
|
|
if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pTool, pAttribDef_ToolTargetItem, &value ) )
|
|
{
|
|
const CEconItemDefinition *pTargetDef = GetItemSchema()->GetItemDefinition( value );
|
|
|
|
// Check for a match (might have NULL here for target definition but that's safe to pass in)
|
|
if ( !ItemDefMatch( pSubjectItemDef, pTargetDef ) )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
return IEconTool::CanApplyTo( pTool, pToolSubject );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_Xifier::ItemDefMatch( const CEconItemDefinition* pTargetItemDef, const CEconItemDefinition* pSubjectItemDef ) const
|
|
{
|
|
if ( pTargetItemDef && pSubjectItemDef )
|
|
{
|
|
// Item def match counts
|
|
if ( pTargetItemDef == pSubjectItemDef )
|
|
return true;
|
|
|
|
// If these item defs have the same XifierRemapClass then they are allowed to match as well
|
|
if ( pTargetItemDef->GetXifierRemapClass() && *pTargetItemDef->GetXifierRemapClass()
|
|
&& pSubjectItemDef->GetXifierRemapClass() && *pSubjectItemDef->GetXifierRemapClass() )
|
|
{
|
|
if (BStringsEqual(pSubjectItemDef->GetXifierRemapClass(), pTargetItemDef->GetXifierRemapClass()))
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_Strangifier::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
|
|
{
|
|
Assert( pTool );
|
|
Assert( pToolSubject );
|
|
|
|
// Do not allow for already strange items
|
|
if ( pToolSubject->GetQuality() == AE_STRANGE )
|
|
return false;
|
|
|
|
// Go over the attributes of the item, if it has any strange attributes the item is strange and don't apply
|
|
for ( int i = 0; i < GetKillEaterAttrCount(); i++ )
|
|
{
|
|
if ( pToolSubject->FindAttribute( GetKillEaterAttr_Score( i ) ) )
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
// Default rules
|
|
return CEconTool_Xifier::CanApplyTo( pTool, pToolSubject );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_KillStreakifier::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
|
|
{
|
|
Assert( pTool );
|
|
Assert( pToolSubject );
|
|
|
|
// Make sure the item doesn't already have an effect
|
|
static CSchemaAttributeDefHandle pAttribDef_KillStreakEffect( "killstreak tier" );
|
|
float flEffectIndex = 0.0;
|
|
if ( FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pToolSubject, pAttribDef_KillStreakEffect, &flEffectIndex ) )
|
|
return false;
|
|
|
|
// Default rules
|
|
return CEconTool_Xifier::CanApplyTo( pTool, pToolSubject );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_Festivizer::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
|
|
{
|
|
Assert( pTool );
|
|
Assert( pToolSubject );
|
|
|
|
const CEconItemDefinition *pSubjectItemDef = pToolSubject->GetItemDefinition();
|
|
if ( !pSubjectItemDef )
|
|
return false;
|
|
|
|
// Make sure the item doesn't already have an effect
|
|
static CSchemaAttributeDefHandle pAttribDef_Festivizer( "is_festivized" );
|
|
if ( FindAttribute( pToolSubject, pAttribDef_Festivizer ) )
|
|
return false;
|
|
|
|
// Default rules
|
|
return CEconTool_Xifier::CanApplyTo( pTool, pToolSubject );
|
|
}
|
|
|
|
bool CEconTool_Unusualifier::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
|
|
{
|
|
Assert( pTool );
|
|
Assert( pToolSubject );
|
|
|
|
// don't stomp item that's already unusual
|
|
if ( pToolSubject->GetQuality() == AE_UNUSUAL )
|
|
return false;
|
|
|
|
// Default rules
|
|
return CEconTool_Xifier::CanApplyTo( pTool, pToolSubject );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ItemEaterRecharger::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
|
|
{
|
|
Assert( pTool );
|
|
Assert( pToolSubject );
|
|
|
|
const CEconItemDefinition *pSubjectItemDef = pToolSubject->GetItemDefinition();
|
|
if ( !pSubjectItemDef )
|
|
return false;
|
|
|
|
// Check to make sure the definition of the item we're trying to apply to has the tags we need to match.
|
|
FOR_EACH_VEC( m_RequiredTags.GetTagsList(), i )
|
|
{
|
|
if ( !pSubjectItemDef->HasEconTag( m_RequiredTags.GetTagsList()[i] ) )
|
|
return false;
|
|
}
|
|
|
|
// If this eater has target restrictions, ensure our subject is one of them
|
|
if ( m_ItemDefTargetRestrictions.Count() > 0 )
|
|
{
|
|
bool bPassed = false;
|
|
item_definition_index_t iSubject = pSubjectItemDef->GetDefinitionIndex();
|
|
FOR_EACH_VEC( m_ItemDefTargetRestrictions, i )
|
|
{
|
|
if ( m_ItemDefTargetRestrictions[i] == iSubject )
|
|
{
|
|
bPassed = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if ( bPassed == false )
|
|
return false;
|
|
}
|
|
|
|
return IEconTool::CanApplyTo( pTool, pToolSubject );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
int CEconTool_ItemEaterRecharger::GetChargesForItemDefId( item_definition_index_t defIndex ) const
|
|
{
|
|
FOR_EACH_VEC( m_ItemDefTargetRestrictions, i )
|
|
{
|
|
if ( m_ItemDefTargetRestrictions[i] == defIndex )
|
|
{
|
|
return m_ItemDefTargetChargeValues[i];
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_UpgradeCard::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
|
|
{
|
|
Assert( pTool );
|
|
Assert( pToolSubject );
|
|
|
|
const CEconItemDefinition *pSubjectItemDef = pToolSubject->GetItemDefinition();
|
|
if ( !pSubjectItemDef )
|
|
return false;
|
|
|
|
// Abort if we're trying to apply to a base item.
|
|
if ( pSubjectItemDef->IsBaseItem() )
|
|
return false;
|
|
|
|
// Abort if for some reason we don't know what type of attribute we would attach.
|
|
if ( m_vecAttributes.Count() <= 0 )
|
|
return false;
|
|
|
|
// Make sure that none of the attributes we're going to try to apply already exist on the item. We don't
|
|
// allow double-stacking the same attribute partially for balance purposes, but also because the database
|
|
// back-end doesn't support two attributes of the same type on the same item.
|
|
FOR_EACH_VEC( m_vecAttributes, i )
|
|
{
|
|
if ( pToolSubject->FindAttribute( m_vecAttributes[i].m_pAttrDef ) )
|
|
return false;
|
|
}
|
|
|
|
// Make sure the item that we're thinking of applying to has enough room to have another card's
|
|
// worth of items attached. We do this in sort of a roundabout way, by having the attributes themselves
|
|
// know whether they came from a card or not.
|
|
CCountUserGeneratedAttributeIterator countIterator;
|
|
pToolSubject->IterateAttributes( &countIterator );
|
|
|
|
if ( countIterator.GetCount() >= GetMaxCardUpgradesPerItem() )
|
|
return false;
|
|
|
|
// Check to make sure the definition of the item we're trying to apply to has the tags we need
|
|
// to match.
|
|
FOR_EACH_VEC( m_RequiredTags.GetTagsList(), i )
|
|
{
|
|
if ( !pSubjectItemDef->HasEconTag( m_RequiredTags.GetTagsList()[i] ) )
|
|
return false;
|
|
}
|
|
|
|
return IEconTool::CanApplyTo( pTool, pToolSubject );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_ClassTransmogrifier::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
|
|
{
|
|
Assert( pTool );
|
|
Assert( pToolSubject );
|
|
|
|
const GameItemDefinition_t *pSubjectItemDef = pToolSubject->GetItemDefinition();
|
|
if ( !pSubjectItemDef )
|
|
return false;
|
|
|
|
// Abort if we're trying to apply to a base item.
|
|
if ( pSubjectItemDef->IsBaseItem() )
|
|
return false;
|
|
|
|
// Abort if we're trying to apply to a Self-Made or Community item
|
|
if ( pToolSubject->GetQuality() == AE_SELFMADE ||
|
|
pToolSubject->GetQuality() == AE_COMMUNITY )
|
|
{
|
|
return false;
|
|
}
|
|
|
|
// Abort if we somehow got here before we know what class we were trying to produce items for.
|
|
if ( m_iClass <= 0 || m_iClass >= LOADOUT_COUNT )
|
|
return false;
|
|
|
|
// Check to make sure the definition of the item we're trying to apply to has the tags we need
|
|
// to match.
|
|
FOR_EACH_VEC( m_RequiredTags.GetTagsList(), i )
|
|
{
|
|
if ( !pSubjectItemDef->HasEconTag( m_RequiredTags.GetTagsList()[i] ) )
|
|
return false;
|
|
}
|
|
|
|
return IEconTool::CanApplyTo( pTool, pToolSubject );
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
bool CEconTool_DuckToken::CanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject ) const
|
|
{
|
|
Assert( pTool );
|
|
Assert( pToolSubject );
|
|
|
|
static CSchemaAttributeDefHandle pAttrDef_DuckBadgeLevel( "duck badge level" );
|
|
uint32 unOldBadgeLevel = 0;
|
|
if ( !FindAttribute( pToolSubject, pAttrDef_DuckBadgeLevel, &unOldBadgeLevel ) )
|
|
return false;
|
|
|
|
if ( unOldBadgeLevel >= 5 )
|
|
return false;
|
|
|
|
// Default rules
|
|
return IEconTool::CanApplyTo( pTool, pToolSubject );
|
|
}
|
|
|
|
//---------------------------------------------------------------------------------------
|
|
// Purpose: given a tool and an item to apply the tool's effects upon, return true if the
|
|
// tool is allowed to affect the subject. This is used on the client for UI and
|
|
// on the GC for actual application validity testing.
|
|
//---------------------------------------------------------------------------------------
|
|
/* static */ bool CEconSharedToolSupport::ToolCanApplyTo( const IEconItemInterface *pTool, const IEconItemInterface *pToolSubject )
|
|
{
|
|
if ( pTool == NULL || pToolSubject == NULL )
|
|
return false;
|
|
|
|
const GameItemDefinition_t *pToolDef = pTool->GetItemDefinition();
|
|
if ( pToolDef == NULL )
|
|
return false;
|
|
|
|
// If we have a tool that's in escrow it can't be used on anything.
|
|
static CSchemaAttributeDefHandle pAttrib_ToolEscrowUntil( "tool escrow until date" );
|
|
if ( pTool->FindAttribute( pAttrib_ToolEscrowUntil ) )
|
|
return false;
|
|
|
|
if ( pToolSubject->IsTemporaryItem() )
|
|
return false;
|
|
|
|
// Cannot modify preview items. Should be caught by temporary-item check above.
|
|
Assert( pToolSubject->GetOrigin() != kEconItemOrigin_PreviewItem );
|
|
|
|
const GameItemDefinition_t *pToolSubjectDef = pToolSubject->GetItemDefinition();
|
|
if ( pToolSubjectDef == NULL )
|
|
return false;
|
|
|
|
if ( !ToolCanApplyToDefinition( pToolDef, pToolSubjectDef ) )
|
|
return false;
|
|
|
|
// If we can apply to the definition then we should be known to have valid tool data.
|
|
// If our tool has no tool metadata then we don't allow it to be applied to anything.
|
|
const IEconTool *pEconTool = pToolDef->GetEconTool();
|
|
Assert( pEconTool );
|
|
|
|
return pEconTool->CanApplyTo( pTool, pToolSubject );
|
|
}
|
|
|
|
/* static */ bool CEconSharedToolSupport::ToolCanApplyToDefinition( const GameItemDefinition_t *pToolDef, const GameItemDefinition_t *pToolSubjectDef )
|
|
{
|
|
if ( !pToolDef || !pToolSubjectDef || !pToolDef->IsTool() )
|
|
{
|
|
// not a tool
|
|
return false;
|
|
}
|
|
|
|
// If our tool has no tool metadata then we don't allow it to be applied to anything.
|
|
const IEconTool *pEconTool = pToolDef->GetEconTool();
|
|
if ( !pEconTool )
|
|
return false;
|
|
|
|
unsigned int unToolUsageCaps = 0;
|
|
if ( pEconTool->GetCapabilities() )
|
|
{
|
|
for ( unsigned int i = 0; i < NUM_ITEM_CAPS; i++ )
|
|
{
|
|
if ( pEconTool->GetCapabilities() & (1 << i) )
|
|
{
|
|
unToolUsageCaps |= g_CapabilityApplicationMap[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
// Check for base applicability of this tool to this object.
|
|
if ( (unToolUsageCaps & pToolSubjectDef->GetCapabilities()) == 0 )
|
|
return false;
|
|
|
|
// check to see if either the tool or the tool target have usage restriction
|
|
const IEconTool *pSubjectEconTool = pToolSubjectDef->GetEconTool();
|
|
|
|
if ( pSubjectEconTool )
|
|
{
|
|
// If this tool can apply to anything then we don't care about the checks below
|
|
// making sure restrictions match.
|
|
const char *pszToolRestriction = BStringsEqual( pEconTool->GetUsageRestriction(), "any" )
|
|
? pSubjectEconTool->GetUsageRestriction()
|
|
: pEconTool->GetUsageRestriction();
|
|
|
|
if ( !BStringsEqual( pszToolRestriction, pSubjectEconTool->GetUsageRestriction() ) )
|
|
return false;
|
|
}
|
|
|
|
return true;
|
|
}
|
|
|
|
// WARNING
|
|
// DO NOT USE THIS CODE IF YOUR TOOL HAS Attribute restrictions like "tool_target_item" or similar restriction attributes
|
|
/* static */ bool CEconSharedToolSupport::ToolCanApplyToBaseItem( const GameItemDefinition_t *pToolDef, const GameItemDefinition_t *pToolSubjectDef )
|
|
{
|
|
if ( !pToolSubjectDef )
|
|
return false;
|
|
|
|
// We are targetting the "Upgradeable" version of a base item and not a base item itself
|
|
if ( pToolSubjectDef->IsBaseItem() || pToolSubjectDef->IsHidden() || pToolSubjectDef->GetQuality() == AE_NORMAL || Q_strnicmp( pToolSubjectDef->GetDefinitionName(), "Upgradeable ", 12 ) )
|
|
return false;
|
|
|
|
return ToolCanApplyToDefinition( pToolDef, pToolSubjectDef );
|
|
}
|