You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
310 lines
8.7 KiB
310 lines
8.7 KiB
|
|
#include "cbase.h"
|
|
#include "econ_item_interface.h"
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Purpose:
|
|
// --------------------------------------------------------------------------
|
|
RTime32 IEconItemInterface::GetExpirationDate() const
|
|
{
|
|
COMPILE_TIME_ASSERT( sizeof( float ) == sizeof( RTime32 ) );
|
|
|
|
// dynamic attributes, if present, will override any static expiration timer
|
|
static CSchemaAttributeDefHandle pAttrib_ExpirationDate( "expiration date" );
|
|
|
|
attrib_value_t unAttribExpirationTimeBits;
|
|
COMPILE_TIME_ASSERT( sizeof( unAttribExpirationTimeBits ) == sizeof( RTime32 ) );
|
|
|
|
if ( pAttrib_ExpirationDate && FindAttribute( pAttrib_ExpirationDate, &unAttribExpirationTimeBits ) )
|
|
return *(RTime32 *)&unAttribExpirationTimeBits;
|
|
|
|
// do we have a static timer set in the schema for all instances to expire?
|
|
return GetItemDefinition()
|
|
? GetItemDefinition()->GetExpirationDate()
|
|
: RTime32( 0 );
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Purpose:
|
|
// --------------------------------------------------------------------------
|
|
RTime32 IEconItemInterface::GetTradableAfterDateTime() const
|
|
{
|
|
static CSchemaAttributeDefHandle pAttrib( "tradable after date" );
|
|
Assert( pAttrib );
|
|
|
|
if ( !pAttrib )
|
|
return 0;
|
|
|
|
RTime32 rtTimestamp;
|
|
if ( !FindAttribute( pAttrib, &rtTimestamp ) )
|
|
return 0;
|
|
|
|
return rtTimestamp;
|
|
}
|
|
|
|
RTime32 IEconItemInterface::GetUseAfterDateTime() const
|
|
{
|
|
static CSchemaAttributeDefHandle pAttrib( "use after date" );
|
|
Assert( pAttrib );
|
|
|
|
if ( !pAttrib )
|
|
return 0;
|
|
|
|
RTime32 rtTimestamp;
|
|
if ( !FindAttribute( pAttrib, &rtTimestamp ) )
|
|
return 0;
|
|
|
|
return rtTimestamp;
|
|
}
|
|
|
|
RTime32 IEconItemInterface::GetCacheRefreshDateTime() const
|
|
{
|
|
RTime32 rtExpiration = 0;
|
|
/** Removed for partner depot **/
|
|
return rtExpiration;
|
|
}
|
|
|
|
int IEconItemInterface::GetCustomPaintKitIndex( void ) const
|
|
{
|
|
static CSchemaAttributeDefHandle pAttrDef_PaintKit( "set item texture prefab" );
|
|
float flPaintKit = 0;
|
|
FindAttribute_UnsafeBitwiseCast<attrib_value_t>( this, pAttrDef_PaintKit, &flPaintKit );
|
|
|
|
return flPaintKit;
|
|
}
|
|
|
|
int IEconItemInterface::GetCustomPaintKitSeed( void ) const
|
|
{
|
|
static CSchemaAttributeDefHandle pAttrDef_PaintKitSeed( "set item texture seed" );
|
|
float flPaintSeed = 0;
|
|
FindAttribute_UnsafeBitwiseCast<attrib_value_t>( this, pAttrDef_PaintKitSeed, &flPaintSeed );
|
|
|
|
return flPaintSeed;
|
|
}
|
|
|
|
float IEconItemInterface::GetCustomPaintKitWear( float flWearDefault /*= 0.0f*/ ) const
|
|
{
|
|
static CSchemaAttributeDefHandle pAttrDef_PaintKitWear( "set item texture wear" );
|
|
float flPaintKitWear = flWearDefault;
|
|
FindAttribute_UnsafeBitwiseCast<attrib_value_t>( this, pAttrDef_PaintKitWear, &flPaintKitWear );
|
|
|
|
return flPaintKitWear;
|
|
}
|
|
|
|
float IEconItemInterface::GetStickerAttributeBySlotIndexFloat( int nSlotIndex, EStickerAttributeType type, float flDefault ) const
|
|
{
|
|
const CSchemaAttributeDefHandle &attrDef = GetStickerAttributeDefHandle( nSlotIndex, type );
|
|
if ( attrDef )
|
|
{
|
|
if ( attrDef->IsStoredAsFloat() )
|
|
{
|
|
float flOutput = 0.0f;
|
|
if ( FindAttribute_UnsafeBitwiseCast< attrib_value_t >( this, attrDef, &flOutput ) )
|
|
{
|
|
return flOutput;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
Assert( false );
|
|
}
|
|
}
|
|
|
|
return flDefault;
|
|
}
|
|
|
|
uint32 IEconItemInterface::GetStickerAttributeBySlotIndexInt( int nSlotIndex, EStickerAttributeType type, uint32 uiDefault ) const
|
|
{
|
|
const CSchemaAttributeDefHandle &attrDef = GetStickerAttributeDefHandle( nSlotIndex, type );
|
|
if ( attrDef )
|
|
{
|
|
if ( attrDef->IsStoredAsFloat() )
|
|
{
|
|
Assert( false );
|
|
}
|
|
else
|
|
{
|
|
uint32 unOutput;
|
|
if ( FindAttribute( attrDef, &unOutput ) )
|
|
{
|
|
return unOutput;
|
|
}
|
|
}
|
|
}
|
|
|
|
return uiDefault;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Purpose:
|
|
// --------------------------------------------------------------------------
|
|
bool IEconItemInterface::IsTradable() const
|
|
{
|
|
/** Removed for partner depot **/
|
|
return false;
|
|
}
|
|
|
|
bool IEconItemInterface::IsPotentiallyTradable() const
|
|
{
|
|
if ( GetItemDefinition() == NULL )
|
|
return false;
|
|
|
|
// check attributes
|
|
|
|
static CSchemaAttributeDefHandle pAttrDef_AlwaysTradableAndUsableInCrafting( "always tradable" );
|
|
static CSchemaAttributeDefHandle pAttrib_CannotTrade( "cannot trade" );
|
|
|
|
|
|
Assert( pAttrDef_AlwaysTradableAndUsableInCrafting != NULL );
|
|
Assert( pAttrib_CannotTrade != NULL );
|
|
|
|
if ( pAttrDef_AlwaysTradableAndUsableInCrafting == NULL || pAttrib_CannotTrade == NULL )
|
|
return false;
|
|
|
|
// NOTE: we are not checking the time delay on trade restriction here - the item is considered potentially tradable in future = true
|
|
// if ( GetTradableAfterDateTime() > CRTime::RTime32TimeCur() )
|
|
// return false;
|
|
|
|
// Explicit rules by item quality to validate trading eligibility
|
|
switch ( GetQuality() )
|
|
{
|
|
case AE_UNIQUE:
|
|
break;
|
|
case AE_STRANGE:
|
|
return ( GetOrigin() == kEconItemOrigin_FoundInCrate || GetOrigin() == kEconItemOrigin_Crafted || GetOrigin() == kEconItemOrigin_Purchased );
|
|
case AE_UNUSUAL:
|
|
case AE_TOURNAMENT:
|
|
return ( GetOrigin() == kEconItemOrigin_FoundInCrate );
|
|
default:
|
|
// all other qualities are untradable
|
|
return false;
|
|
}
|
|
|
|
if ( FindAttribute( pAttrDef_AlwaysTradableAndUsableInCrafting ) )
|
|
return true;
|
|
|
|
if ( FindAttribute( pAttrib_CannotTrade ) )
|
|
return false;
|
|
|
|
// items gained in this way are not tradable
|
|
switch ( GetOrigin() )
|
|
{
|
|
case kEconItemOrigin_Invalid:
|
|
case kEconItemOrigin_Achievement:
|
|
case kEconItemOrigin_Foreign:
|
|
case kEconItemOrigin_PreviewItem:
|
|
case kEconItemOrigin_SteamWorkshopContribution:
|
|
case kEconItemOrigin_StockItem:
|
|
return false;
|
|
}
|
|
|
|
// certain quality levels are not tradable
|
|
if ( GetQuality() >= AE_COMMUNITY && GetQuality() <= AE_SELFMADE )
|
|
return false;
|
|
|
|
// explicitly marked cannot trade?
|
|
if ( ( kEconItemFlags_CheckFlags_CannotTrade & GetFlags() ) != 0 )
|
|
return false;
|
|
|
|
// tagged to not be a part of the economy?
|
|
if ( ( kEconItemFlag_NonEconomy & GetFlags() ) != 0 )
|
|
return false;
|
|
|
|
// This code catches stock items with name tags (rarity is stock) and prevents them from trading/marketing
|
|
// until we have a better solution for extracting value out of reselling these items and avoiding scams
|
|
if ( GetRarity() <= 0 )
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Purpose:
|
|
// --------------------------------------------------------------------------
|
|
bool IEconItemInterface::IsMarketable() const
|
|
{
|
|
/** Removed for partner depot **/
|
|
return false;
|
|
}
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Purpose:
|
|
// --------------------------------------------------------------------------
|
|
bool IEconItemInterface::IsCommodity() const
|
|
{
|
|
const CEconItemDefinition *pItemDef = GetItemDefinition();
|
|
if ( pItemDef == NULL )
|
|
return false;
|
|
|
|
static CSchemaAttributeDefHandle pAttrib_IsCommodity( "is commodity" );
|
|
Assert( pAttrib_IsCommodity != NULL );
|
|
if ( pAttrib_IsCommodity == NULL )
|
|
return false;
|
|
|
|
attrib_value_t unAttribValue;
|
|
if ( FindAttribute( pAttrib_IsCommodity, &unAttribValue ) && unAttribValue )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
bool IEconItemInterface::IsHiddenFromDropList() const
|
|
{
|
|
const CEconItemDefinition *pItemDef = GetItemDefinition();
|
|
if ( pItemDef == NULL )
|
|
return false;
|
|
|
|
static CSchemaAttributeDefHandle pAttrib_HideFromDropList( "hide from drop list" );
|
|
Assert( pAttrib_HideFromDropList != NULL );
|
|
if ( pAttrib_HideFromDropList == NULL )
|
|
return false;
|
|
|
|
attrib_value_t unAttribValue;
|
|
if ( FindAttribute( pAttrib_HideFromDropList, &unAttribValue ) && unAttribValue )
|
|
return true;
|
|
|
|
return false;
|
|
}
|
|
|
|
|
|
// --------------------------------------------------------------------------
|
|
// Purpose:
|
|
// --------------------------------------------------------------------------
|
|
bool IEconItemInterface::IsUsableInCrafting() const
|
|
{
|
|
if ( GetItemDefinition() == NULL )
|
|
return false;
|
|
|
|
// check attribute
|
|
static CSchemaAttributeDefHandle pAttrDef_AlwaysTradableAndUsableInCrafting( "always tradable" );
|
|
Assert( pAttrDef_AlwaysTradableAndUsableInCrafting );
|
|
|
|
if ( FindAttribute( pAttrDef_AlwaysTradableAndUsableInCrafting ) )
|
|
return true;
|
|
|
|
// explicitly marked not usable in crafting?
|
|
if ( ( kEconItemFlags_CheckFlags_NotUsableInCrafting & GetFlags() ) != 0 )
|
|
return false;
|
|
|
|
// items gained in this way are not craftable
|
|
switch ( GetOrigin() )
|
|
{
|
|
case kEconItemOrigin_Invalid:
|
|
case kEconItemOrigin_Foreign:
|
|
case kEconItemOrigin_PreviewItem:
|
|
case kEconItemOrigin_Purchased:
|
|
case kEconItemOrigin_StorePromotion:
|
|
case kEconItemOrigin_SteamWorkshopContribution:
|
|
return false;
|
|
}
|
|
|
|
// certain quality levels are not craftable
|
|
if ( GetQuality() >= AE_COMMUNITY && GetQuality() <= AE_SELFMADE )
|
|
return false;
|
|
|
|
// tagged to not be a part of the economy?
|
|
if ( ( kEconItemFlag_NonEconomy & GetFlags() ) != 0 )
|
|
return false;
|
|
|
|
return true;
|
|
}
|