Modified source engine (2017) developed by valve and leaked in 2020. Not for commercial purporses
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.
 
 
 
 
 
 

304 lines
10 KiB

//========= 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