305 lines
10 KiB
C++
305 lines
10 KiB
C++
//========= Copyright Valve Corporation, All rights reserved. ============//
|
|
//
|
|
// Purpose: Container that allows client & server access to data in player inventories & loadouts
|
|
//
|
|
//=============================================================================
|
|
|
|
#ifndef TF_ITEM_INVENTORY_H
|
|
#define TF_ITEM_INVENTORY_H
|
|
#ifdef _WIN32
|
|
#pragma once
|
|
#endif
|
|
|
|
#include "econ_item_inventory.h"
|
|
#include "tf_shareddefs.h"
|
|
#include "econ_item_constants.h"
|
|
#include "tf_item_constants.h"
|
|
|
|
#ifdef CLIENT_DLL
|
|
#include "econ_notifications.h"
|
|
#endif
|
|
|
|
#define LOADOUT_SLOT_USE_BASE_ITEM 0
|
|
|
|
namespace vgui
|
|
{
|
|
class Panel;
|
|
}
|
|
|
|
struct baseitemcriteria_t;
|
|
|
|
//===============================================================================================================
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose: A single TF player's inventory.
|
|
// On the client, the inventory manager contains an instance of this for the local player.
|
|
// On the server, each player contains an instance of this.
|
|
//-----------------------------------------------------------------------------
|
|
class CTFPlayerInventory : public CPlayerInventory
|
|
{
|
|
DECLARE_CLASS( CTFPlayerInventory, CPlayerInventory );
|
|
public:
|
|
CTFPlayerInventory();
|
|
virtual ~CTFPlayerInventory();
|
|
|
|
virtual CEconItemView *GetItemInLoadout( int iClass, int iSlot );
|
|
|
|
#ifdef CLIENT_DLL
|
|
// Removes any item in a loadout slot. If the slot has a base item,
|
|
// the player essentially returns to using that item.
|
|
// NOTE: This can fail if the player has no backpack space to contain the equipped item.
|
|
bool ClearLoadoutSlot( int iClass, int iSlot );
|
|
CEconItemView *GetCacheServerItemInLoadout( int iClass, int iSlot );
|
|
|
|
void UpdateWeaponSkinRequest();
|
|
#endif
|
|
|
|
virtual int GetMaxItemCount( void ) const;
|
|
virtual bool CanPurchaseItems( int iItemCount ) const;
|
|
virtual int GetPreviewItemDef( void ) const;
|
|
|
|
// Derived inventory hooks
|
|
virtual void ItemHasBeenUpdated( CEconItemView *pItem, bool bUpdateAckFile, bool bWriteAckFile ) OVERRIDE;
|
|
virtual void ItemIsBeingRemoved( CEconItemView *pItem );
|
|
bool UpdateEquipStateForClass( const itemid_t& itemID, equipped_slot_t nSlot, itemid_t *pLoadout, int nCount );
|
|
|
|
// Debugging
|
|
virtual void DumpInventoryToConsole( bool bRoot );
|
|
|
|
bool ClassLoadoutHasChanged( int iClass ) { return m_bLoadoutChanged[iClass]; }
|
|
void ClearClassLoadoutChangeTracking( void );
|
|
|
|
virtual void NotifyHasNewItems() { OnHasNewItems(); }
|
|
|
|
#ifdef CLIENT_DLL
|
|
virtual ITexture *GetWeaponSkinBaseLowRes( itemid_t nItemId, int iTeam ) const;
|
|
#endif
|
|
|
|
void OnHasNewQuest();
|
|
|
|
static CEconItemView *GetFirstItemOfItemDef( item_definition_index_t nDefIndex, CPlayerInventory* pInventory = NULL );
|
|
|
|
protected:
|
|
virtual void SOCreated( const CSteamID & steamIDOwner, const GCSDK::CSharedObject *pObject, GCSDK::ESOCacheEvent eEvent ) OVERRIDE;
|
|
#ifdef CLIENT_DLL
|
|
// Converts an old format inventory to the new format.
|
|
void ConvertOldFormatInventoryToNew( void );
|
|
|
|
virtual void PostSOUpdate( const CSteamID & steamIDOwner, GCSDK::ESOCacheEvent eEvent ) OVERRIDE;
|
|
virtual void SOCacheSubscribed( const CSteamID & steamIDOwner, GCSDK::ESOCacheEvent eEvent ) OVERRIDE;
|
|
|
|
virtual bool AddEconItem( CEconItem * pItem, bool bUpdateAckFile, bool bWriteAckFile, bool bCheckForNewItems ) OVERRIDE;
|
|
|
|
void VerifyChangedLoadoutsAreValid();
|
|
void VerifyLoadoutItemsAreValid( int iClass );
|
|
#endif
|
|
|
|
virtual void OnHasNewItems();
|
|
virtual void ValidateInventoryPositions( void );
|
|
|
|
// Extracts the position that should be used to sort items in the inventory from the backend position.
|
|
// Necessary if your inventory packs a bunch of info into the position instead of using it just as a position.
|
|
virtual int ExtractInventorySortPosition( uint32 iBackendPosition )
|
|
{
|
|
// Consider unack'd items as -1, so they get stacked up before the 0th slot item
|
|
if ( IsUnacknowledged(iBackendPosition) )
|
|
return -1;
|
|
return ExtractBackpackPositionFromBackend(iBackendPosition);
|
|
}
|
|
|
|
virtual void SOUpdated( const CSteamID & steamIDOwner, const GCSDK::CSharedObject *pObject, GCSDK::ESOCacheEvent eEvent ) OVERRIDE;
|
|
|
|
#ifdef CLIENT_DLL
|
|
private:
|
|
void CheckSaxtonMaskAchievement( const CEconItem *pEconItem );
|
|
void UpdateCachedServerLoadoutItems();
|
|
#endif
|
|
|
|
protected:
|
|
// Global indices of the items in our inventory in the loadout slots
|
|
#ifdef CLIENT_DLL
|
|
struct SkinRequest_t
|
|
{
|
|
int m_nTeam;
|
|
itemid_t m_nID;
|
|
MDLHandle_t m_hModel;
|
|
};
|
|
CUtlVector< SkinRequest_t > m_vecWeaponSkinRequestList;
|
|
|
|
|
|
itemid_t m_CachedServerLoadoutItems[ TF_CLASS_COUNT ][ CLASS_LOADOUT_POSITION_COUNT ];
|
|
|
|
CUtlMap< itemid_t, ITexture* > m_CachedBaseTextureLowRes[ TF_TEAM_COUNT ];
|
|
|
|
#endif // CLIENT_DLL
|
|
itemid_t m_LoadoutItems[ TF_CLASS_COUNT ][ CLASS_LOADOUT_POSITION_COUNT ];
|
|
bool m_bLoadoutChanged[ TF_CLASS_COUNT ];
|
|
itemid_t m_AccountLoadoutItems[ ACCOUNT_LOADOUT_POSITION_COUNT ];
|
|
|
|
|
|
friend class CTFInventoryManager;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
// Purpose:
|
|
//-----------------------------------------------------------------------------
|
|
class CTFInventoryManager : public CInventoryManager
|
|
{
|
|
DECLARE_CLASS( CTFInventoryManager, CInventoryManager );
|
|
public:
|
|
CTFInventoryManager();
|
|
~CTFInventoryManager();
|
|
|
|
virtual void PostInit( void );
|
|
|
|
#ifdef CLIENT_DLL
|
|
virtual CPlayerInventory *GeneratePlayerInventoryObject() const { return new CTFPlayerInventory; }
|
|
|
|
//-----------------------------------------------------------------------
|
|
// CLIENT PICKUP UI HANDLING
|
|
//-----------------------------------------------------------------------
|
|
|
|
// Get the number of items picked up
|
|
virtual int GetNumItemPickedUpItems( void );
|
|
|
|
// Show the player a pickup screen with any items they've collected recently, if any
|
|
virtual bool ShowItemsPickedUp( bool bForce = false, bool bReturnToGame = true, bool bNoPanel = false );
|
|
|
|
// Show the player a pickup screen with the items they've crafted
|
|
virtual void ShowItemsCrafted( CUtlVector<itemid_t> *vecCraftedIndices );
|
|
|
|
// Force the player to discard an item to make room for a new item, if they have one
|
|
virtual bool CheckForRoomAndForceDiscard( void );
|
|
|
|
// Tells the GC that the player has acknowledged an item and attempts to move it in to the first available BP slot
|
|
virtual void AcknowledgeItem( CEconItemView *pItem, bool bMoveToBackpack = true );
|
|
|
|
// Gets called each frame
|
|
virtual void Update( float frametime ) OVERRIDE;
|
|
#endif
|
|
|
|
// Returns the item data for the base item in the loadout slot for a given class
|
|
CEconItemView *GetBaseItemForClass( int iClass, int iSlot );
|
|
void GenerateBaseItems( void );
|
|
|
|
// Gets the specified inventory for the steam ID
|
|
CTFPlayerInventory *GetInventoryForPlayer( const CSteamID &playerID );
|
|
|
|
// Returns the item in the specified loadout slot for a given class
|
|
CEconItemView *GetItemInLoadoutForClass( int iClass, int iSlot, CSteamID *pID = NULL );
|
|
|
|
CEconItemView *GetItemInLoadoutForAccount( int nSlot, CSteamID *pID = NULL );
|
|
|
|
// Fills out the vector with the sets that are currently active on the specified player & class
|
|
void GetActiveSets( CUtlVector<const CEconItemSetDefinition *> *pItemSets, CSteamID steamIDForPlayer, int iClass );
|
|
|
|
// We're generating a base item. We need to add the game-specific keys to the criteria so that it'll find the right base item.
|
|
virtual void AddBaseItemCriteria( baseitemcriteria_t *pCriteria, CItemSelectionCriteria *pSelectionCriteria );
|
|
|
|
bool SlotContainsBaseItems( EEquipType_t eType, int iSlot );
|
|
|
|
int GetBaseItemCount( ) { return m_pBaseLoadoutItems.Count(); }
|
|
CEconItemView* GetBaseItem( int iIndex ) { return m_pBaseLoadoutItems[iIndex]; }
|
|
|
|
private:
|
|
// Base items, returned for slots that the player doesn't have anything in
|
|
CEconItemView *m_pDefaultItem;
|
|
CUtlVector<CEconItemView*> m_pBaseLoadoutItems;
|
|
|
|
#ifdef CLIENT_DLL
|
|
// On the client, we have a single inventory for the local player. Stored here, instead of in the
|
|
// local player entity, because players need to access it while not being connected to a server.
|
|
public:
|
|
CPlayerInventory *GetLocalInventory( void ) { return &m_LocalInventory; }
|
|
CTFPlayerInventory *GetLocalTFInventory( void );
|
|
|
|
// Try and equip the specified item in the specified class's loadout slot
|
|
bool EquipItemInLoadout( int iClass, int iSlot, itemid_t iItemID );
|
|
|
|
// Fills out pList with all inventory items that could fit into the specified loadout slot for a given class
|
|
int GetAllUsableItemsForSlot( int iClass, int iSlot, CUtlVector<CEconItemView*> *pList );
|
|
|
|
virtual int GetBackpackPositionFromBackend( uint32 iBackendPosition ) { return ExtractBackpackPositionFromBackend(iBackendPosition); }
|
|
|
|
// Fills out pList with all quest item in the local inventory
|
|
int GetAllQuestItems( CUtlVector<CEconItemView*> *pList );
|
|
|
|
private:
|
|
CTFPlayerInventory m_LocalInventory;
|
|
#endif // CLIENT_DLL
|
|
};
|
|
|
|
CTFInventoryManager *TFInventoryManager( void );
|
|
|
|
|
|
|
|
#ifdef CLIENT_DLL
|
|
//-----------------------------------------------------------------------------
|
|
// Econ Notifications
|
|
//-----------------------------------------------------------------------------
|
|
class CEconNotification_HasNewItems : public CEconNotification
|
|
{
|
|
public:
|
|
CEconNotification_HasNewItems();
|
|
~CEconNotification_HasNewItems();
|
|
|
|
virtual void SetLifetime( float flSeconds )
|
|
{
|
|
m_flExpireTime = engine->Time() + flSeconds;
|
|
}
|
|
|
|
virtual float GetExpireTime() const
|
|
{
|
|
if ( m_flExpireTime != 0 )
|
|
return -1.0f;
|
|
return 0;
|
|
}
|
|
|
|
virtual float GetInGameLifeTime() const
|
|
{
|
|
return m_flExpireTime;
|
|
}
|
|
|
|
virtual void MarkForDeletion()
|
|
{
|
|
m_bHasTriggered = true;
|
|
CEconNotification::MarkForDeletion();
|
|
}
|
|
|
|
virtual EType NotificationType() { return eType_Trigger; }
|
|
virtual void Trigger()
|
|
{
|
|
m_bHasTriggered = true;
|
|
TFInventoryManager()->ShowItemsPickedUp( true );
|
|
MarkForDeletion();
|
|
}
|
|
|
|
virtual bool BShowInGameElements() const
|
|
{
|
|
return m_bShowInGame;
|
|
}
|
|
|
|
static bool IsNotificationType( CEconNotification *pNotification ) { return dynamic_cast<CEconNotification_HasNewItems *>( pNotification ) != NULL; }
|
|
|
|
protected:
|
|
|
|
bool m_bHasTriggered;
|
|
bool m_bShowInGame;
|
|
};
|
|
|
|
//-----------------------------------------------------------------------------
|
|
class CEconNotification_HasNewItemsOnKill : public CEconNotification_HasNewItems
|
|
{
|
|
public:
|
|
CEconNotification_HasNewItemsOnKill( int iVictimID );
|
|
|
|
virtual EType NotificationType() { return eType_Basic; }
|
|
virtual void Trigger() {}
|
|
|
|
static bool HasUnacknowledgedItems();
|
|
static bool IsNotificationType( CEconNotification *pNotification ) { return dynamic_cast<CEconNotification_HasNewItemsOnKill *>( pNotification ) != NULL; }
|
|
};
|
|
#endif
|
|
|
|
|
|
#endif // TF_ITEM_INVENTORY_H
|