622 lines
23 KiB
C++
622 lines
23 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Common objects and utilities related to the in-game item store
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef ECON_STORE_H
|
|
#define ECON_STORE_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "UtlSortVector.h"
|
|
#include "vstdlib/IKeyValuesSystem.h"
|
|
#include "econ/econ_storecategory.h"
|
|
#ifdef CLIENT_DLL
|
|
#include "client_community_market.h"
|
|
#endif // CLIENT_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Error code enum for purchase messages
|
|
//-----------------------------------------------------------------------------
|
|
enum EPurchaseResult
|
|
{
|
|
k_EPurchaseResultOK = 1, // Success
|
|
k_EPurchaseResultFail = 2, // Generic error
|
|
k_EPurchaseResultInvalidParam = 3, // Invalid parameter
|
|
k_EPurchaseResultInternalError = 4, // Internal error
|
|
k_EPurchaseResultNotApproved = 5, // Tried to finalize a transaction that has not yet been approved
|
|
k_EPurchaseResultAlreadyCommitted = 6, // Tried to finalize a transaction that has already been committed
|
|
k_EPurchaseResultUserNotLoggedIn = 7, // User is not logged into Steam
|
|
k_EPurchaseResultWrongCurrency = 8, // Microtransaction's currency does not match user's wallet currency
|
|
k_EPurchaseResultAccountError = 9, // User's account does not exist or is temporarily unavailable
|
|
k_EPurchaseResultInvalidItem = 10, // User is trying to purchase an item that doesn't exist or is not for sale
|
|
k_EPurchaseResultNotEnoughBackpackSpace = 11, // User did not have enough backpack space
|
|
k_EPurchaseResultLimitedQuantityItemsUnavailable = 12, // User tried to purchase limited-quantity items but there weren't enough left in stock
|
|
|
|
k_EPurchaseResultInsufficientFunds = 100, // User does not have wallet funds
|
|
k_EPurchaseResultTimedOut = 101, // Time limit for finalization has been exceeded
|
|
k_EPurchaseResultAcctDisabled = 102, // Steam account is disabled
|
|
k_EPurchaseResultAcctCannotPurchase = 103, // Steam account is not allowed to make a purchase
|
|
k_EMicroTxnResultFailedFraudChecks = 104, // Fraud checks inside of Steam failed
|
|
|
|
k_EPurchaseResultOldPriceSheet = 150, // Information on the purchase didn't match the current price sheet
|
|
k_EPurchaseResultTxnNotFound = 151 // Could not find the transaction specified
|
|
};
|
|
|
|
|
|
const char *PchNameFromEPurchaseResult( EPurchaseResult ePurchaseState );
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: State of a transaction
|
|
//
|
|
// WARNING: VALUES STORED IN DATABASE. DO NOT RENUMBER!!!
|
|
//-----------------------------------------------------------------------------
|
|
enum EPurchaseState
|
|
{
|
|
k_EPurchaseStateInvalid = 0, // Invalid
|
|
k_EPurchaseStateInit = 1, // We have sent InitPurchase to Steam
|
|
k_EPurchaseStateWaitingForAuthorization = 2, // We have gotten initial authorization from Steam. Waiting for user to authorize.
|
|
k_EPurchaseStatePending = 3, // We are attempting to commit the transaction
|
|
k_EPurchaseStateComplete = 4, // The transaction was successful
|
|
k_EPurchaseStateFailed = 5, // The transaction failed
|
|
k_EPurchaseStateCanceled = 6, // The transaction was canceled
|
|
k_EPurchaseStateRefunded = 7, // The transaction was refunded
|
|
k_EPurchaseStateChargeback = 8, // The transaction was charged back
|
|
k_EPurchaseStateChargebackReversed = 9, // A chargeback has failed and we got the money
|
|
k_EPurchaseStateLast = k_EPurchaseStateChargebackReversed,
|
|
};
|
|
|
|
const char *PchNameFromEPurchaseState( EPurchaseState ePurchaseState );
|
|
|
|
// DO NOT RENUMBER! These values are stored in the audit log table.
|
|
enum EGCTransactionAuditReason
|
|
{
|
|
k_EGCTransactionAudit_GCTransactionCompleted = 0, // The transaction completed successfully on the GC.
|
|
k_EGCTransactionAudit_GCTransactionInit = 1, // The transaction was initialized.
|
|
k_EGCTransactionAudit_GCTransactionPostInit = 2, // The result of attempting to initialize the transaction. This is where the SteamTxnID is set.
|
|
k_EGCTransactionAudit_GCTransactionFinalize = 3, // We have started to finalize the transaction (so probably set it to pending).
|
|
k_EGCTransactionAudit_GCTransactionFinalizeFailed = 4, // Our attempt to finalize the transaction failed for some reason (not due to a timeout).
|
|
k_EGCTransactionAudit_GCTransactionCanceled = 5, // The client requested that we cancel the transaction.
|
|
k_EGCTransactionAudit_SteamFailedMismatch = 6, // Steam failed the transaction but we did not.
|
|
k_EGCTransactionAudit_GCRemovePurchasedItems = 7, // We are attempting to remove the purchased items from their backpack (due to rollback or failure).
|
|
k_EGCTransactionAudit_GCTransactionInsert = 8, // We are inserting a transaction, usually one created by a web interface (i.e.: a cd-key operation) instead of a standard store interaction.
|
|
k_EGCTransactionAudit_GCTransactionCompletedPostChargeback = 9, // We thought this transaction had been charged back but Steam came back later and told us it was successful after all.
|
|
|
|
k_EGCTransactionAuditLast = k_EGCTransactionAudit_GCTransactionCompletedPostChargeback,
|
|
};
|
|
|
|
const char *PchNameFromEGCTransactionAuditReason( EGCTransactionAuditReason eAuditReason );
|
|
|
|
enum EGCTransactionAuditInsertReason
|
|
{
|
|
k_EGCTransactionAuditInsert_Invalid = 0, //
|
|
k_EGCTransactionAuditInsert_CDKey = 1, // A CD Key was used for this transaction.
|
|
k_EGCTransactionAuditInsert_SettlementNoMatch_Failed = 2, // We inserted a failed record during settlement to unblock the process.
|
|
k_EGCTransactionAuditInsert_SettlementNoMatch_Pending = 3, // We inserted a pending record during settlement to unblock the process.
|
|
|
|
k_EGCTransactionAuditInsertLast = k_EGCTransactionAuditInsert_SettlementNoMatch_Pending,
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Currencies we support
|
|
//
|
|
// WARNING: VALUES STORED IN DATABASE. DO NOT RENUMBER!!!
|
|
// WARNING: THESE DON'T MATCH THE STEAM NUMERIC IDS!!! WE TALK USING CURRENCY
|
|
// CODES LIKE "VND" AND IF YOU SAY "15" TERRIBLE THINGS WILL HAPPEN
|
|
//-----------------------------------------------------------------------------
|
|
enum ECurrency
|
|
{
|
|
k_ECurrencyFirst = 0,
|
|
k_ECurrencyUSD = 0,
|
|
k_ECurrencyGBP = 1,
|
|
k_ECurrencyEUR = 2,
|
|
k_ECurrencyRUB = 3,
|
|
k_ECurrencyBRL = 4,
|
|
// space for Dota currencies
|
|
k_ECurrencyJPY = 8,
|
|
k_ECurrencyNOK = 9,
|
|
k_ECurrencyIDR = 10,
|
|
k_ECurrencyMYR = 11,
|
|
k_ECurrencyPHP = 12,
|
|
k_ECurrencySGD = 13,
|
|
k_ECurrencyTHB = 14,
|
|
k_ECurrencyVND = 15,
|
|
k_ECurrencyKRW = 16,
|
|
k_ECurrencyTRY = 17,
|
|
k_ECurrencyUAH = 18,
|
|
k_ECurrencyMXN = 19,
|
|
k_ECurrencyCAD = 20,
|
|
k_ECurrencyAUD = 21,
|
|
k_ECurrencyNZD = 22,
|
|
k_ECurrencyPLN = 23,
|
|
k_ECurrencyCHF = 24,
|
|
k_ECurrencyCNY = 25,
|
|
k_ECurrencyTWD = 26,
|
|
k_ECurrencyHKD = 27,
|
|
k_ECurrencyINR = 28,
|
|
k_ECurrencyAED = 29,
|
|
k_ECurrencySAR = 30,
|
|
k_ECurrencyZAR = 31,
|
|
k_ECurrencyCOP = 32,
|
|
k_ECurrencyPEN = 33,
|
|
k_ECurrencyCLP = 34,
|
|
|
|
// NOTE: Not actually the Maximum currency value, but the Terminator for the possible currency code range.
|
|
k_ECurrencyMax = 35,
|
|
|
|
// make this a big number so we can avoid having to move it when we add another currency type
|
|
k_ECurrencyInvalid = 255,
|
|
k_ECurrencyCDKeyTransaction = k_ECurrencyInvalid,
|
|
};
|
|
|
|
// Macro for looping across all valid currencies
|
|
#define FOR_EACH_CURRENCY( _i ) for ( ECurrency _i = GetFirstValidCurrency(); _i != k_ECurrencyInvalid; _i = GetNextValidCurrency( _i ) )
|
|
|
|
const char *PchNameFromECurrency( ECurrency eCurrency ); // NOTE: Defined with ENUMSTRINGS_START/ENUMSTRINGS_REVERSE macros
|
|
ECurrency ECurrencyFromName( const char *pchName ); //
|
|
|
|
inline bool BIsCurrencyValid( ECurrency eCurrency )
|
|
{
|
|
switch ( eCurrency )
|
|
{
|
|
case k_ECurrencyUSD:
|
|
case k_ECurrencyGBP:
|
|
case k_ECurrencyEUR:
|
|
case k_ECurrencyRUB:
|
|
case k_ECurrencyBRL:
|
|
case k_ECurrencyJPY:
|
|
case k_ECurrencyNOK:
|
|
case k_ECurrencyIDR:
|
|
case k_ECurrencyMYR:
|
|
case k_ECurrencyPHP:
|
|
case k_ECurrencySGD:
|
|
case k_ECurrencyTHB:
|
|
case k_ECurrencyVND:
|
|
case k_ECurrencyKRW:
|
|
case k_ECurrencyTRY:
|
|
case k_ECurrencyUAH:
|
|
case k_ECurrencyMXN:
|
|
case k_ECurrencyCAD:
|
|
case k_ECurrencyAUD:
|
|
case k_ECurrencyNZD:
|
|
//case k_ECurrencyPLN:
|
|
case k_ECurrencyCHF:
|
|
case k_ECurrencyCNY:
|
|
case k_ECurrencyTWD:
|
|
case k_ECurrencyHKD:
|
|
case k_ECurrencyINR:
|
|
case k_ECurrencyAED:
|
|
case k_ECurrencySAR:
|
|
case k_ECurrencyZAR:
|
|
case k_ECurrencyCOP:
|
|
case k_ECurrencyPEN:
|
|
case k_ECurrencyCLP:
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
inline ECurrency GetFirstValidCurrency()
|
|
{
|
|
for ( int i = k_ECurrencyFirst; i < k_ECurrencyMax; i++ )
|
|
{
|
|
if ( BIsCurrencyValid( (ECurrency)i ) )
|
|
return (ECurrency)i;
|
|
}
|
|
return k_ECurrencyInvalid;
|
|
}
|
|
|
|
inline ECurrency GetNextValidCurrency( ECurrency ePrevious )
|
|
{
|
|
for ( int i = ePrevious + 1; i < k_ECurrencyMax; i++ )
|
|
{
|
|
if ( BIsCurrencyValid( (ECurrency)i ) )
|
|
return (ECurrency)i;
|
|
}
|
|
return k_ECurrencyInvalid;
|
|
}
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Simple struct for pairing a sort type with a localization string
|
|
//-----------------------------------------------------------------------------
|
|
struct ItemSortTypeData_t
|
|
{
|
|
const char *szSortDesc; // localization string
|
|
uint32 iSortType; // maps to the GC-specific sort value
|
|
};
|
|
|
|
// Description of a single item for sale
|
|
struct econ_store_entry_t
|
|
{
|
|
// Constructor
|
|
econ_store_entry_t()
|
|
: m_pchCategoryTags( NULL ),
|
|
m_unGiftSteamPackageID( 0 ),
|
|
m_bHighlighted( false )
|
|
{
|
|
V_memset( m_unBaseCosts, 0, sizeof(m_unBaseCosts) );
|
|
V_memset( m_unSaleCosts, 0, sizeof(m_unSaleCosts) );
|
|
}
|
|
|
|
void SetItemDefinitionIndex( item_definition_index_t usDefIndex );
|
|
item_definition_index_t GetItemDefinitionIndex() const { return m_usDefIndex; }
|
|
|
|
void InitCategoryTags( const char *pTags ); // Sets m_pchCategoryTags and initializes m_vecTagIds and m_fRentalPriceScale
|
|
|
|
bool IsListedInCategory( StoreCategoryID_t unID ) const; // Is this item listed in the given category?
|
|
bool IsListedInSubcategories( const CEconStoreCategoryManager::StoreCategory_t &Category ) const; // Is this item listed in one of Category's subcategories?
|
|
bool IsListedInCategoryOrSubcategories( const CEconStoreCategoryManager::StoreCategory_t &Category ) const; // Is this item listed in Category or one of Category's subcategories?
|
|
|
|
bool IsOnSale( ECurrency eCurrency ) const;
|
|
bool IsRentable() const;
|
|
#ifdef CLIENT_DLL
|
|
bool HasDiscount( ECurrency eCurrency, item_price_t *out_punOptionalBasePrice ) const; // returns true if we're on sale or if we're a bundle with a discounted total price
|
|
#endif // CLIENT_DLL
|
|
item_price_t GetCurrentPrice( ECurrency eCurrency ) const;
|
|
float GetRentalPriceScale() const;
|
|
|
|
uint32 GetGiftSteamPackageID() const { return m_unGiftSteamPackageID; }
|
|
|
|
// Helper function -- so we do this calculation in a single place.
|
|
static item_price_t GetDiscountedPrice( ECurrency eCurrency, item_price_t unBasePrice, float fDiscountPercentage );
|
|
|
|
static item_price_t CalculateSalePrice( const econ_store_entry_t* pSaleStoreEntry, ECurrency eCurrency, float fDiscountPercentage, int32 *out_pAdjustedDiscountPercentage = NULL );
|
|
|
|
item_price_t GetBasePrice( ECurrency eCurrency ) const
|
|
{
|
|
Assert( eCurrency >= k_ECurrencyFirst );
|
|
Assert( eCurrency < k_ECurrencyMax );
|
|
if ( !( eCurrency >= 0 && eCurrency < k_ECurrencyMax ) )
|
|
return 0;
|
|
#ifdef CLIENT_DLL
|
|
if ( m_bIsMarketItem )
|
|
{
|
|
const client_market_data_t *pClientMarketData = GetClientMarketData( GetItemDefinitionIndex(), AE_UNIQUE );
|
|
if ( !pClientMarketData )
|
|
return 0;
|
|
return pClientMarketData->m_unLowestPrice;
|
|
}
|
|
#endif
|
|
// Weird-looking pattern: we're making sure that the value we're about to return fits correctly
|
|
// into the variable we're about to put it into. We do this to avoid integer conversion problems,
|
|
// especially overflow (!) where someone changes one of the return type or the storage type but
|
|
// not the other.
|
|
Assert( (item_price_t)m_unBaseCosts[eCurrency] == m_unBaseCosts[eCurrency] );
|
|
return m_unBaseCosts[eCurrency];
|
|
}
|
|
|
|
item_price_t GetSalePrice( ECurrency eCurrency ) const
|
|
{
|
|
Assert( eCurrency >= k_ECurrencyFirst );
|
|
Assert( eCurrency < k_ECurrencyMax );
|
|
if ( !( eCurrency >= 0 && eCurrency < k_ECurrencyMax ) )
|
|
return 0;
|
|
#ifdef CLIENT_DLL
|
|
if ( m_bIsMarketItem )
|
|
{
|
|
const client_market_data_t *pClientMarketData = GetClientMarketData( GetItemDefinitionIndex(), AE_UNIQUE );
|
|
if ( !pClientMarketData )
|
|
return 0;
|
|
return pClientMarketData->m_unLowestPrice;
|
|
}
|
|
#endif
|
|
// Weird-looking pattern: we're making sure that the value we're about to return fits correctly
|
|
// into the variable we're about to put it into. We do this to avoid integer conversion problems,
|
|
// especially overflow (!) where someone changes one of the return type or the storage type but
|
|
// not the other.
|
|
Assert( (item_price_t)m_unSaleCosts[eCurrency] == m_unSaleCosts[eCurrency] );
|
|
return m_unSaleCosts[eCurrency];
|
|
}
|
|
|
|
uint16 GetQuantity() const
|
|
{
|
|
return m_usQuantity;
|
|
}
|
|
|
|
const char* GetDate() const
|
|
{
|
|
return m_strDate.Get();
|
|
}
|
|
|
|
bool CanPreview() const
|
|
{
|
|
// No previewing of new items or weapons.
|
|
return m_bPreviewAllowed;
|
|
}
|
|
|
|
void SetQuantity( uint16 usQuantity )
|
|
{
|
|
Assert( usQuantity > 0 );
|
|
m_usQuantity = usQuantity;
|
|
}
|
|
|
|
void ValidatePrice( ECurrency eCurrency, item_price_t unPrice );
|
|
|
|
void SetBasePrice( ECurrency eCurrency, item_price_t unPrice )
|
|
{
|
|
Assert( eCurrency >= k_ECurrencyFirst );
|
|
Assert( eCurrency < k_ECurrencyMax );
|
|
if ( !( eCurrency >= 0 && eCurrency < k_ECurrencyMax ) )
|
|
return;
|
|
|
|
ValidatePrice( eCurrency, unPrice );
|
|
|
|
m_unBaseCosts[eCurrency] = unPrice;
|
|
}
|
|
|
|
void SetSalePrice( ECurrency eCurrency, item_price_t unPrice )
|
|
{
|
|
Assert( eCurrency >= k_ECurrencyFirst );
|
|
Assert( eCurrency < k_ECurrencyMax );
|
|
if ( !( eCurrency >= 0 && eCurrency < k_ECurrencyMax ) )
|
|
return;
|
|
|
|
ValidatePrice( eCurrency, unPrice );
|
|
|
|
// It's legal to have a sale price of zero, meaninig "this item is not on sale" in this
|
|
// currency.
|
|
// Assert( unPrice > 0 );
|
|
m_unSaleCosts[eCurrency] = unPrice;
|
|
}
|
|
|
|
void SetSteamGiftPackageID( uint32 unGiftSteamPackageID )
|
|
{
|
|
m_unGiftSteamPackageID = unGiftSteamPackageID;
|
|
}
|
|
|
|
void SetDate( const char* pszDate )
|
|
{
|
|
m_strDate.Set( pszDate );
|
|
}
|
|
|
|
|
|
bool IsValidCategoryTagIndex( uint32 iIndex ) const
|
|
{
|
|
AssertMsg( m_vecCategoryTags.IsValidIndex( iIndex ), "Category tag index out of range." );
|
|
return m_vecCategoryTags.IsValidIndex( iIndex );
|
|
}
|
|
|
|
uint32 GetCategoryTagCount() const
|
|
{
|
|
return m_vecCategoryTags.Count();
|
|
}
|
|
|
|
const char *GetCategoryTagNameFromIndex( uint32 iIndex ) const
|
|
{
|
|
if ( !IsValidCategoryTagIndex( iIndex ) )
|
|
return NULL;
|
|
|
|
return m_vecCategoryTags[ iIndex ].m_strName;
|
|
}
|
|
|
|
StoreCategoryID_t GetCategoryTagIDFromIndex( uint32 iIndex ) const;
|
|
|
|
const char *GetCategoryTagString() const
|
|
{
|
|
return m_pchCategoryTags;
|
|
}
|
|
|
|
bool m_bLimited; // Item is a limited sale
|
|
bool m_bNew; // Item is new
|
|
bool m_bHighlighted; // Item is highlighted
|
|
CUtlString m_strDate; // Date Added
|
|
bool m_bSoldOut; // True if the item is sold out from the store (for example if the item is a ticket or another physical item)
|
|
bool m_bPreviewAllowed; // Is this item previewable?
|
|
bool m_bIsPackItem; // Is this item a pack item? Pack items are items which are not individually for sale, but are sold via a bundle known as a "pack bundle"
|
|
|
|
bool m_bIsMarketItem; // Is Market Item Link
|
|
|
|
private:
|
|
item_definition_index_t m_usDefIndex; // DefIndex of the item
|
|
|
|
// Private data so that we can check in the accessor functions that the data fits before returning it.
|
|
item_price_t m_unBaseCosts[k_ECurrencyMax]; // Costs of the items indexed by ECurrency -- if the items are on sale, this will be the current sale price
|
|
item_price_t m_unSaleCosts[k_ECurrencyMax]; // Original costs of the items indexed by ECurrency -- if the items are on sale, this will be the pre-sale price
|
|
uint16 m_usQuantity; // Quantity sold in a single purchase (ie., dueling pistols come in stacks of five)
|
|
float m_fRentalPriceScale; // 100.0 or greater means "unavailable to rent"
|
|
uint32 m_unGiftSteamPackageID; // if non-zero, when this item is purchased (including inside bundles, etc.), grant a gift copy of this Steam package
|
|
|
|
struct CategoryTag_t
|
|
{
|
|
CUtlString m_strName; // Individual tag name, like "Weapons," "New," etc.
|
|
StoreCategoryID_t m_unID; // The category ID
|
|
};
|
|
CCopyableUtlVector< CategoryTag_t > m_vecCategoryTags; // Category tag data
|
|
|
|
const char *m_pchCategoryTags; // All tags - this string will something like: "New" or "Weapons+New" etc.
|
|
};
|
|
|
|
#ifdef GC_DLL
|
|
struct econ_store_timed_sale_item_t
|
|
{
|
|
item_definition_index_t m_unItemDef;
|
|
float m_fPricePercentage; // 100.0 = regular price; 50.0 = half price
|
|
};
|
|
|
|
struct econ_store_timed_sale_t
|
|
{
|
|
bool m_bSaleCurrentlyActive; // set in ::UpdatePricesForTimedSales()
|
|
CUtlConstString m_sIdentifier; // can't point to memory in the base KV because we toss it afterwards
|
|
RTime32 m_SaleStartTime;
|
|
RTime32 m_SaleEndTime;
|
|
CUtlVector<econ_store_timed_sale_item_t> m_vecSaleItems;
|
|
|
|
// Work around protected default vector constructor.
|
|
econ_store_timed_sale_t() { }
|
|
econ_store_timed_sale_t( const econ_store_timed_sale_t& other )
|
|
: m_bSaleCurrentlyActive( other.m_bSaleCurrentlyActive )
|
|
, m_sIdentifier( other.m_sIdentifier )
|
|
, m_SaleStartTime( other.m_SaleStartTime )
|
|
, m_SaleEndTime( other.m_SaleEndTime )
|
|
{
|
|
m_vecSaleItems.CopyArray( other.m_vecSaleItems.Base(), other.m_vecSaleItems.Count() );
|
|
}
|
|
};
|
|
#endif // GC_DLL
|
|
|
|
// Spend xxx amount of money, get a free item from the loot list
|
|
struct store_promotion_spend_for_free_item_t
|
|
{
|
|
const CEconItemDefinition *m_pItemDef;
|
|
item_price_t m_rgusPriceThreshold[k_ECurrencyMax]; // Price threshold to get an item from the loot list indexed by ECurrency
|
|
};
|
|
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: Class that represents what's currently for sale in TF
|
|
//-----------------------------------------------------------------------------
|
|
typedef enum
|
|
{
|
|
kEconStoreSortType_Price_HighestToLowest = 0,
|
|
kEconStoreSortType_Price_LowestToHighest = 1,
|
|
kEconStoreSortType_DevName_AToZ = 2,
|
|
kEconStoreSortType_DevName_ZToA = 3,
|
|
kEconStoreSortType_Name_AToZ = 4,
|
|
kEconStoreSortType_Name_ZToA = 5,
|
|
kEconStoreSortType_ItemDefIndex = 6,
|
|
kEconStoreSortType_ReverseItemDefIndex = 7,
|
|
kEconStoreSortType_DateNewest = 8,
|
|
kEconStoreSortType_DateOldest = 9,
|
|
} eEconStoreSortType;
|
|
|
|
struct price_point_map_key_t
|
|
{
|
|
item_price_t m_unPriceUSD;
|
|
ECurrency m_eCurrency;
|
|
|
|
static bool Less( const price_point_map_key_t& a, const price_point_map_key_t& b )
|
|
{
|
|
if ( a.m_eCurrency == b.m_eCurrency )
|
|
return a.m_unPriceUSD < b.m_unPriceUSD;
|
|
|
|
return a.m_eCurrency < b.m_eCurrency;
|
|
}
|
|
};
|
|
|
|
typedef CUtlMap<price_point_map_key_t, item_price_t> CurrencyPricePointMap_t;
|
|
|
|
class CEconStorePriceSheet
|
|
{
|
|
public:
|
|
typedef CUtlMap<item_definition_index_t, econ_store_entry_t> StoreEntryMap_t;
|
|
typedef CUtlMap<const char *, float> RentalPriceScaleMap_t;
|
|
typedef CUtlVector<item_definition_index_t> FeaturedItems_t;
|
|
|
|
CEconStorePriceSheet();
|
|
~CEconStorePriceSheet();
|
|
|
|
bool InitFromKV( KeyValues *pKVPrices );
|
|
|
|
// Gets or sets the version stamp. This is just a number the GC can use
|
|
// to know if the client is in sync without sending it down on every
|
|
// request.
|
|
RTime32 GetVersionStamp( void ) const { return m_RTimeVersionStamp; }
|
|
void SetVersionStamp( RTime32 stamp ) { m_RTimeVersionStamp = stamp; }
|
|
|
|
uint32 GetHashForAllItems() const { return m_unHashForAllItems; }
|
|
|
|
typedef CUtlMap<uint16, econ_store_entry_t> EconStoreEntryMap_t;
|
|
EconStoreEntryMap_t &GetEntries() { return m_mapEntries; }
|
|
|
|
#ifdef GC_DLL
|
|
econ_store_entry_t *GetEntryWriteable( item_definition_index_t unDefIndex );
|
|
#endif // GC_DLL
|
|
|
|
const StoreEntryMap_t &GetEntries() const { return m_mapEntries; }
|
|
const CEconStoreCategoryManager::StoreCategory_t *GetFeaturedItems( void ) { return &m_FeaturedItems; }
|
|
const econ_store_entry_t *GetEntry( item_definition_index_t usDefIndex ) const;
|
|
|
|
uint32 GetFeaturedItemIndex() const { return m_unFeaturedItemIndex; }
|
|
void SetFeaturedItemIndex( uint32 unIdx ) { m_unFeaturedItemIndex = unIdx; }
|
|
|
|
void SetEconStoreSortType( eEconStoreSortType eType ) { m_eEconStoreSortType = eType; }
|
|
eEconStoreSortType GetEconStoreSortType() { return m_eEconStoreSortType; }
|
|
|
|
const store_promotion_spend_for_free_item_t *GetStorePromotion_SpendForFreeItem() const { return &m_StorePromotionSpendForFreeItem; }
|
|
const CEconItemDefinition * GetStorePromotion_FirstTimePurchaseItem() const { return m_pStorePromotionFirstTimePurchaseItem; }
|
|
const CEconItemDefinition * GetStorePromotion_FirstTimeWebPurchaseItem() const { return m_pStorePromotionFirstTimeWebPurchaseItem; }
|
|
|
|
uint32 GetPreviewPeriod() const { return m_unPreviewPeriod; }
|
|
uint32 GetBonusDiscountPeriod() const { return m_unBonusDiscountPeriod; }
|
|
float GetPreviewPeriodDiscount() const { return m_flPreviewPeriodDiscount; }
|
|
|
|
bool BItemExistsInPriceSheet( item_definition_index_t unDefIndex ) const;
|
|
|
|
float GetRentalPriceScale( const char *pszCategory ) const
|
|
{
|
|
RentalPriceScaleMap_t::IndexType_t i = m_mapRentalPriceScales.Find( pszCategory );
|
|
if ( i == RentalPriceScaleMap_t::InvalidIndex() )
|
|
return 1.0f;
|
|
|
|
return m_mapRentalPriceScales[i];
|
|
}
|
|
|
|
KeyValues *GetRawData() const { return m_pKVRaw; }
|
|
|
|
#ifdef GC_DLL
|
|
void UpdatePricesForTimedSales( const RTime32 curTime );
|
|
void DumpTimeSaleState( const RTime32 curTime ) const;
|
|
#endif // GC_DLL
|
|
|
|
#ifdef CLIENT_DLL
|
|
const FeaturedItems_t& GetFeaturedItems() const { return m_vecFeaturedItems; }
|
|
#endif // CLIENT_DLL
|
|
|
|
private:
|
|
bool BInitEntryFromKV( KeyValues *pKVEntry );
|
|
#ifdef CLIENT_DLL
|
|
bool BInitMarketEntryFromKV( KeyValues *pKVEntry );
|
|
#endif // CLIENT_DLL
|
|
|
|
#ifdef GC_DLL
|
|
bool InitTimedSaleEntryFromKV( KeyValues *pKVTimedSaleEntry );
|
|
bool VerifyTimedSaleEntries();
|
|
#endif // GC_DLL
|
|
|
|
private:
|
|
void Clear();
|
|
uint32 CalculateHashFromItems() const;
|
|
|
|
KeyValues *m_pKVRaw;
|
|
RTime32 m_RTimeVersionStamp;
|
|
CEconStoreCategoryManager::StoreCategory_t m_FeaturedItems; // Special section, not a tab, kept outside m_vecContents
|
|
StoreEntryMap_t m_mapEntries;
|
|
RentalPriceScaleMap_t m_mapRentalPriceScales;
|
|
store_promotion_spend_for_free_item_t m_StorePromotionSpendForFreeItem;
|
|
CEconItemDefinition* m_pStorePromotionFirstTimePurchaseItem;
|
|
CEconItemDefinition* m_pStorePromotionFirstTimeWebPurchaseItem;
|
|
|
|
#ifdef CLIENT_DLL
|
|
FeaturedItems_t m_vecFeaturedItems;
|
|
#endif // CLIENT_DLL
|
|
|
|
#ifdef GC_DLL
|
|
CUtlVector<econ_store_timed_sale_t> m_vecTimedSales;
|
|
#endif // GC_DLL
|
|
|
|
// changes based on experiments
|
|
uint32 m_unFeaturedItemIndex;
|
|
eEconStoreSortType m_eEconStoreSortType;
|
|
|
|
uint32 m_unPreviewPeriod;
|
|
uint32 m_unBonusDiscountPeriod;
|
|
float m_flPreviewPeriodDiscount;
|
|
uint32 m_unHashForAllItems;
|
|
|
|
// price point lookup
|
|
CurrencyPricePointMap_t m_mapCurrencyPricePoints;
|
|
};
|
|
|
|
#ifdef CLIENT_DLL
|
|
void MakeMoneyString( wchar_t *pchDest, uint32 nDest, item_price_t unPrice, ECurrency eCurrencyCode );
|
|
|
|
bool ShouldUseNewStore();
|
|
int GetStoreVersion();
|
|
#endif // CLIENT_DLL
|
|
|
|
const CEconStorePriceSheet *GetEconPriceSheet();
|
|
|
|
#endif // ECON_STORE_H
|