d4708
/
source-engine
mirror of https://github.com/nillerusr/source-engine.git
1
0
Fork 0
Code Issues Projects Releases Wiki Activity
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.
55 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 850fca74ee
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '850fca74ee'
${ noResults }
source-engine/game/shared/tf/tf_item_inventory.cpp

1819 lines
58 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
//=============================================================================
#include "cbase.h"
#include "tf_item_inventory.h"
#include "econ_entity_creation.h"
#include "tf_item_system.h"
#include "vgui/ILocalize.h"
#include "tier3/tier3.h"
#ifdef CLIENT_DLL
#include "c_tf_player.h"
#include "item_pickup_panel.h"
#include "KeyValues.h"
#include "filesystem.h"
#include "character_info_panel.h"
#include "ienginevgui.h"
#include "c_tf_gamestats.h"
#include "econ_notifications.h"
#include "achievementmgr.h"
#include "baseachievement.h"
#include "achievements_tf.h"
#include "econ/econ_item_preset.h"
#include "tf_shared_content_manager.h"
#include "c_playerresource.h"
#include "quest_log_panel.h"
#include "backpack_panel.h"
#include "materialsystem/itexture.h"
#else
#include "tf_player.h"
#endif
#include "gc_clientsystem.h"
#include "econ_game_account_client.h"
#include "gcsdk/gcclientsdk.h"
#include "econ_gcmessages.h"
#include "tf_gamerules.h"
#include "tf_gcmessages.h"
#include "econ_item.h"
#include "game_item_schema.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
using namespace GCSDK;
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
CEconNotification_HasNewItems::CEconNotification_HasNewItems() : CEconNotification()
{
m_bHasTriggered = false;
m_flExpireTime = -1.0f; // Does not initially expire
m_bShowInGame = false;
// Check to see if any items are not drops, if so show in game
// do not show in game if the new items are only drops
CPlayerInventory *pLocalInv = InventoryManager()->GetLocalInventory();
if ( pLocalInv )
{
// Go through the root inventory and find any items that are in the "found" position
int iCount = pLocalInv->GetItemCount();
for ( int i = 0; i < iCount; i++ )
{
CEconItemView *pTmp = pLocalInv->GetItem(i);
if ( !pTmp )
continue;
if ( pTmp->GetStaticData()->IsHidden() )
continue;
uint32 iPosition = pTmp->GetInventoryPosition();
if ( IsUnacknowledged(iPosition) == false )
continue;
if ( InventoryManager()->GetBackpackPositionFromBackend(iPosition) != 0 )
continue;
// Now make sure we haven't got a clientside saved ack for this item.
if ( InventoryManager()->HasBeenAckedByClient( pTmp ) )
continue;
// If item is not a drop we want to show the notification otherwise they'll get the notification on death
int iFoundMethod = GetUnacknowledgedReason( iPosition );
if ( iFoundMethod > UNACK_ITEM_DROPPED )
{
m_bShowInGame = true;
break;
}
}
}
}
CEconNotification_HasNewItems::~CEconNotification_HasNewItems()
{
if ( !m_bHasTriggered )
{
m_bHasTriggered = true;
TFInventoryManager()->ShowItemsPickedUp( true, true, true );
}
}
//-----------------------------------------------------------------------------
CEconNotification_HasNewItemsOnKill::CEconNotification_HasNewItemsOnKill( int iVictimID )
{
m_bHasTriggered = false;
SetLifetime( 3.0f );
SetText( "#TF_EnemyDroppedItem" );
wchar_t wszPlayerName[MAX_PLAYER_NAME_LENGTH];
g_pVGuiLocalize->ConvertANSIToUnicode( g_PR->GetPlayerName( iVictimID ), wszPlayerName, sizeof( wszPlayerName ) );
AddStringToken( "victim", wszPlayerName );
m_bShowInGame = true;
}
/*static*/ bool CEconNotification_HasNewItemsOnKill::HasUnacknowledgedItems ()
{
// Check to see if any items are not drops, if so show in game
// do not show in game if the new items are only drops
CPlayerInventory *pLocalInv = InventoryManager()->GetLocalInventory();
if ( pLocalInv )
{
// Go through the root inventory and find any items that are in the "found" position
int iCount = pLocalInv->GetItemCount();
for ( int i = 0; i < iCount; i++ )
{
CEconItemView *pTmp = pLocalInv->GetItem( i );
if ( !pTmp )
continue;
if ( pTmp->GetStaticData()->IsHidden() )
continue;
uint32 iPosition = pTmp->GetInventoryPosition();
if ( IsUnacknowledged( iPosition ) == false )
continue;
if ( InventoryManager()->GetBackpackPositionFromBackend( iPosition ) != 0 )
continue;
// Now make sure we haven't got a clientside saved ack for this item.
if ( InventoryManager()->HasBeenAckedByClient( pTmp ) )
continue;
// If item is not a drop we want to show the notification otherwise they'll get the notification on death
int iFoundMethod = GetUnacknowledgedReason( iPosition );
if ( iFoundMethod > UNACK_ITEM_DROPPED )
{
return true;
}
}
}
return false;
}
#endif
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool AreSlotsConsideredIdentical( EEquipType_t eEquipType, int iBaseSlot, int iTestSlot )
{
if ( eEquipType == EQUIP_TYPE_CLASS )
{
if ( iBaseSlot == LOADOUT_POSITION_MISC )
{
return IsMiscSlot( iTestSlot );
}
if ( iBaseSlot == LOADOUT_POSITION_BUILDING )
{
return IsBuildingSlot( iTestSlot );
}
if ( iBaseSlot == LOADOUT_POSITION_TAUNT )
{
return IsTauntSlot( iTestSlot );
}
}
else if ( eEquipType == EQUIP_TYPE_ACCOUNT )
{
if ( iBaseSlot == ACCOUNT_LOADOUT_POSITION_ACCOUNT1 )
{
return IsQuestSlot( iTestSlot );
}
}
return iBaseSlot == iTestSlot;
}
//-----------------------------------------------------------------------------
CTFInventoryManager g_TFInventoryManager;
CInventoryManager *InventoryManager( void )
{
return &g_TFInventoryManager;
}
CTFInventoryManager *TFInventoryManager( void )
{
return &g_TFInventoryManager;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFInventoryManager::CTFInventoryManager( void )
{
}
CTFInventoryManager::~CTFInventoryManager( void )
{
m_pBaseLoadoutItems.PurgeAndDeleteElements();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFInventoryManager::PostInit( void )
{
BaseClass::PostInit();
GenerateBaseItems();
}
//-----------------------------------------------------------------------------
// Purpose: Generate & store the base item details for each class & loadout slot
//-----------------------------------------------------------------------------
void CTFInventoryManager::GenerateBaseItems( void )
{
// Purge our lists and make new
m_pBaseLoadoutItems.PurgeAndDeleteElements();
// Load a base top level invalid item
{
m_pDefaultItem = new CEconItemView;
m_pDefaultItem->Invalidate();
}
//
const CEconItemSchema::BaseItemDefinitionMap_t& mapItems = GetItemSchema()->GetBaseItemDefinitionMap();
int iStart = 0;
for ( int it = iStart; it != mapItems.InvalidIndex(); it = mapItems.NextInorder( it ) )
{
CEconItemView *pItem = new CEconItemView;
pItem->Init( mapItems[it]->GetDefinitionIndex(), AE_USE_SCRIPT_VALUE, AE_USE_SCRIPT_VALUE, false );
m_pBaseLoadoutItems.AddToTail( pItem );
}
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFInventoryManager::EquipItemInLoadout( int iClass, int iSlot, itemid_t iItemID )
{
if ( !steamapicontext || !steamapicontext->SteamUser() )
return false;
// If they pass in a INVALID_ITEM_ID item id, we're just clearing the loadout slot
if ( iItemID == INVALID_ITEM_ID )
return m_LocalInventory.ClearLoadoutSlot( iClass, iSlot );
CEconItemView *pItem = m_LocalInventory.GetInventoryItemByItemID( iItemID );
if ( !pItem )
return false;
// We check for validity on the GC when we equip items, but we can't really trust anyone
// and so we check here as well.
if ( !AreSlotsConsideredIdentical( pItem->GetStaticData()->GetEquipType(), pItem->GetStaticData()->GetLoadoutSlot(iClass), iSlot ) )
{
return false;
}
if ( !pItem->GetStaticData()->CanBeUsedByClass( iClass ) )
{
return false;
}
// Equip the new item
UpdateInventoryEquippedState( &m_LocalInventory, iItemID, iClass, iSlot );
// TODO: Prediction
// Item has been moved, so update our loadout.
//m_LoadoutItems[iClass][iSlot] = iItemID;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Fills out pList with all inventory items that could fit into the specified loadout slot for a given class
//-----------------------------------------------------------------------------
int CTFInventoryManager::GetAllUsableItemsForSlot( int iClass, int iSlot, CUtlVector<CEconItemView*> *pList )
{
bool bIsAccountIndex = iClass == GEconItemSchema().GetAccountIndex();
if ( bIsAccountIndex )
{
Assert( IsQuestSlot( iSlot ) );
}
else
{
Assert( iClass >= TF_FIRST_NORMAL_CLASS && iClass < TF_CLASS_COUNT );
Assert( iSlot >= -1 && iSlot < CLASS_LOADOUT_POSITION_COUNT );
}
int iCount = m_LocalInventory.GetItemCount();
for ( int i = 0; i < iCount; i++ )
{
CEconItemView *pItem = m_LocalInventory.GetItem(i);
CTFItemDefinition *pItemData = pItem->GetStaticData();
if ( bIsAccountIndex != ( pItemData->GetEquipType() == EEquipType_t::EQUIP_TYPE_ACCOUNT ) )
continue;
if ( !bIsAccountIndex && !pItemData->CanBeUsedByClass(iClass) )
continue;
// Passing in iSlot of -1 finds all items usable by the class
if ( iSlot >= 0 && pItem->GetStaticData()->GetLoadoutSlot( iClass ) != iSlot )
continue;
// Ignore unpack'd items
if ( IsUnacknowledged( pItem->GetInventoryPosition() ) )
continue;
pList->AddToTail( m_LocalInventory.GetItem(i) );
}
return pList->Count();
}
//-----------------------------------------------------------------------------
// Purpose: Fills out pList with all quest item in the local inventory
//-----------------------------------------------------------------------------
int CTFInventoryManager::GetAllQuestItems( CUtlVector<CEconItemView*> *pList )
{
if ( !pList )
return 0;
pList->RemoveAll();
for ( int i = 0 ; i < m_LocalInventory.GetItemCount() ; ++i )
{
CEconItemView *pItem = m_LocalInventory.GetItem( i );
// Cheapest test
if ( pItem->GetItemDefinition()->GetQuestDef() == NULL )
continue;
pList->AddToTail( pItem );
}
return pList->Count();
}
#endif // CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CEconItemView *CTFInventoryManager::GetItemInLoadoutForClass( int iClass, int iSlot, CSteamID *pID )
{
#ifdef CLIENT_DLL
if ( !pID )
{
// If they didn't specify a steamID, use the local player
if ( !steamapicontext || !steamapicontext->SteamUser() )
return NULL;
CSteamID localSteamID = steamapicontext->SteamUser()->GetSteamID();
pID = &localSteamID;
}
#endif
CTFPlayerInventory *pInv = GetInventoryForPlayer( *pID );
if ( !pInv )
return GetBaseItemForClass( iClass, iSlot );
return pInv->GetItemInLoadout( iClass, iSlot );
}
CEconItemView *CTFInventoryManager::GetItemInLoadoutForAccount( int iSlot, CSteamID *pID )
{
#ifdef CLIENT_DLL
if ( !pID )
{
// If they didn't specify a steamID, use the local player
if ( !steamapicontext || !steamapicontext->SteamUser() )
return NULL;
CSteamID localSteamID = steamapicontext->SteamUser()->GetSteamID();
pID = &localSteamID;
}
#endif
CTFPlayerInventory *pInv = GetInventoryForPlayer( *pID );
if ( !pInv )
return NULL;
return pInv->GetItemInLoadout( GEconItemSchema().GetAccountIndex(), iSlot );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFPlayerInventory *CTFInventoryManager::GetInventoryForPlayer( const CSteamID &playerID )
{
for ( int i = 0; i < m_pInventories.Count(); i++ )
{
if ( m_pInventories[i].pInventory->GetOwner() != playerID )
continue;
return assert_cast<CTFPlayerInventory*>( m_pInventories[i].pInventory );
}
return NULL;
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFInventoryManager::GetNumItemPickedUpItems( void )
{
int iResult = 0;
int iCount = m_LocalInventory.GetItemCount();
for ( int i = 0; i < iCount; i++ )
{
if ( IsUnacknowledged( m_LocalInventory.GetItem(i)->GetInventoryPosition() ) && !m_LocalInventory.GetItem(i)->GetStaticData()->IsHidden() )
{
++iResult;
}
}
return iResult;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFInventoryManager::ShowItemsPickedUp( bool bForce, bool bReturnToGame, bool bNoPanel )
{
// don't show new items in training, unless forced to do so
// i.e. purchased something or traded...
if ( bForce == false && TFGameRules() && ( TFGameRules()->IsInTraining() || TFGameRules()->IsCompetitiveMode() ) )
{
return false;
}
// Don't bring it up if we're already browsing something in the gameUI
vgui::VPANEL gameuiPanel = enginevgui->GetPanel( PANEL_GAMEUIDLL );
if ( !bForce && vgui::ipanel()->IsVisible( gameuiPanel ) )
return false;
CUtlVector<CEconItemView*> aItemsFound;
// Go through the root inventory and find any items that are in the "found" position
int iCount = m_LocalInventory.GetItemCount();
for ( int i = 0; i < iCount; i++ )
{
CEconItemView *pTmp = m_LocalInventory.GetItem(i);
if ( !pTmp )
continue;
if ( pTmp->GetStaticData()->IsHidden() )
continue;
uint32 iPosition = pTmp->GetInventoryPosition();
if ( IsUnacknowledged(iPosition) == false )
continue;
if ( GetBackpackPositionFromBackend(iPosition) != 0 )
continue;
// Now make sure we haven't got a clientside saved ack for this item.
// This makes sure we don't show multiple pickups for items that we've found,
// but haven't been able to move out of unack'd position due to the GC being unavailable.
if ( HasBeenAckedByClient( pTmp ) )
continue;
aItemsFound.AddToTail( pTmp );
}
if ( !aItemsFound.Count() )
return CheckForRoomAndForceDiscard();
// We're not forcing the player to make room yet. Just show the pickup panel.
NotificationQueue_Remove( &CEconNotification_HasNewItems::IsNotificationType );
CItemPickupPanel *pItemPanel = bNoPanel ? NULL : EconUI()->OpenItemPickupPanel();
if ( pItemPanel )
{
pItemPanel->SetReturnToGame( bReturnToGame );
}
// Only acknowledge items if there is no panel
// Panel will make calls to acknowledge items itself
for ( int i = 0; i < aItemsFound.Count(); i++ )
{
if ( pItemPanel )
{
pItemPanel->AddItem( aItemsFound[i] );
}
else
{
AcknowledgeItem( aItemsFound[i] );
}
}
if ( pItemPanel )
{
pItemPanel->MoveToFront();
}
else
{
SaveAckFile();
}
aItemsFound.Purge();
return true;
}
//-----------------------------------------------------------------------------
void CTFInventoryManager::AcknowledgeItem( CEconItemView *pItem, bool bMoveToBackpack /* = true */ )
{
SetAckedByClient( pItem );
int iMethod = GetUnacknowledgedReason( pItem->GetInventoryPosition() ) - 1;
if ( iMethod >= ARRAYSIZE( g_pszItemPickupMethodStringsUnloc ) || iMethod < 0 )
iMethod = 0;
EconUI()->Gamestats_ItemTransaction( IE_ITEM_RECEIVED, pItem, g_pszItemPickupMethodStringsUnloc[iMethod] );
if ( iMethod+1 == UNACK_ITEM_PREVIEW_ITEM_PURCHASED )
{
// If we found a purchased preview item, we want to refresh the store view to remove the discount indicator.
CStorePage* pStorePage = dynamic_cast<CStorePage*>( EconUI()->GetStorePanel()->GetActivePage() );
if ( pStorePage )
{
pStorePage->UpdateModelPanels();
}
}
// Move it to the first empty backpack position.
if ( bMoveToBackpack )
{
SetItemBackpackPosition( pItem, 0, false, true );
}
}
void CTFInventoryManager::Update( float frametime )
{
TM_ZONE_DEFAULT( TELEMETRY_LEVEL0 );
m_LocalInventory.UpdateWeaponSkinRequest();
BaseClass::Update( frametime );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFInventoryManager::ShowItemsCrafted( CUtlVector<itemid_t> *vecCraftedIndices )
{
CUtlVector<CEconItemView*> aItemsFound;
FOR_EACH_VEC( *vecCraftedIndices, i )
{
CEconItemView *pItem = m_LocalInventory.GetInventoryItemByItemID( vecCraftedIndices->Element(i) );
if ( pItem )
{
// Now make sure we haven't got a clientside saved ack for this item.
// This makes sure we don't show multiple pickups for items that we've found,
// but haven't been able to move out of unack'd position due to the GC being unavailable.
if ( !HasBeenAckedByClient( pItem ) )
{
aItemsFound.AddToTail( pItem );
}
}
}
if ( !aItemsFound.Count() )
return;
NotificationQueue_Remove( &CEconNotification_HasNewItems::IsNotificationType );
CItemPickupPanel *pItemPanel = EconUI()->OpenItemPickupPanel();
for ( int i = 0; i < aItemsFound.Count(); i++ )
{
pItemPanel->AddItem( aItemsFound[i] );
SetAckedByClient( aItemsFound[i] );
#ifdef CLIENT_DLL
EconUI()->Gamestats_ItemTransaction( IE_ITEM_RECEIVED, aItemsFound[i], "crafted" );
#endif
// Then move it to the first empty backpack position
SetItemBackpackPosition( aItemsFound[i], 0, false, true );
}
SaveAckFile();
pItemPanel->MoveToFront();
aItemsFound.Purge();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFInventoryManager::CheckForRoomAndForceDiscard( void )
{
// Go through the inventory and attempt to move any items outside the backpack into valid positions.
// Remember the first item that we failed to move, so we can force a discard later.
CEconItemView *pItem = NULL;
const int iMaxItems = m_LocalInventory.GetMaxItemCount();
int iCount = m_LocalInventory.GetItemCount();
for ( int i = 0; i < iCount; i++ )
{
CEconItemView *pTmp = m_LocalInventory.GetItem(i);
if ( !pTmp )
continue;
if ( pTmp->GetStaticData()->IsHidden() )
continue;
uint32 iPosition = pTmp->GetInventoryPosition();
if ( IsUnacknowledged(iPosition) || GetBackpackPositionFromBackend(iPosition) > iMaxItems )
{
if ( !SetItemBackpackPosition( pTmp, 0, false, false ) )
{
pItem = pTmp;
break;
}
}
}
// If we're not over the limit, we're done.
if ( ( iCount - m_iPredictedDiscards ) <= iMaxItems )
return false;
if ( !pItem )
return false;
// We're forcing the player to make room for items he's found. Bring up that panel with the first item over the limit.
CItemDiscardPanel *pDiscardPanel = EconUI()->OpenItemDiscardPanel();
pDiscardPanel->SetItem( pItem );
return true;
}
#endif
bool CTFInventoryManager::SlotContainsBaseItems( EEquipType_t eType, int iSlot )
{
Assert( eType != EEquipType_t::EQUIP_TYPE_INVALID );
if ( eType == EEquipType_t::EQUIP_TYPE_ACCOUNT )
{
return !IsQuestSlot( iSlot );
}
// Passtime gun
if ( (iSlot == LOADOUT_POSITION_UTILITY) && TFGameRules() && TFGameRules()->IsPasstimeMode() )
{
return true;
}
// Halloween spellbook
if ( iSlot == LOADOUT_POSITION_ACTION )
{
if ( TFGameRules() && TFGameRules()->IsUsingSpells() )
return true;
if ( TFGameRules() && TFGameRules()->IsUsingGrapplingHook() )
return true;
}
#ifdef STAGING_ONLY
return ( ( iSlot < LOADOUT_POSITION_HEAD && iSlot != LOADOUT_POSITION_UTILITY && !IsTauntSlot( iSlot ) ) // Allow utility slots to be empty
|| iSlot == LOADOUT_POSITION_PDA3 );
#else // STAGING_ONLY
// Normal game
return iSlot < LOADOUT_POSITION_HEAD;
#endif // #else
}
//-----------------------------------------------------------------------------
// Purpose: Returns the item data for the base item in the loadout slot for a given class
//-----------------------------------------------------------------------------
CEconItemView *CTFInventoryManager::GetBaseItemForClass( int iClass, int iSlot )
{
// There is no base account item
if ( iClass == GEconItemSchema().GetAccountIndex() )
return m_pDefaultItem;
if ( !HushAsserts() )
{
AssertMsg( iClass >= TF_FIRST_NORMAL_CLASS && iClass < TF_CLASS_COUNT, "Invalid TF_CLASS_: %d", iClass );
}
Assert( iSlot >= 0 && iSlot < CLASS_LOADOUT_POSITION_COUNT );
if ( iClass < TF_FIRST_NORMAL_CLASS || iClass >= TF_CLASS_COUNT || iSlot < 0 || iSlot >= CLASS_LOADOUT_POSITION_COUNT )
return m_pDefaultItem;
// Halloween spellbook
if ( iSlot == LOADOUT_POSITION_ACTION )
{
CUtlVector< item_definition_index_t > stockActionItemDefIndices;
static CSchemaItemDefHandle pItemDef_SpellBook( "TF_WEAPON_SPELLBOOK" );
if ( TFGameRules() && TFGameRules()->IsUsingSpells() && pItemDef_SpellBook )
{
stockActionItemDefIndices.AddToTail( pItemDef_SpellBook->GetDefinitionIndex() );
}
static CSchemaItemDefHandle pItemDef_GrapplingHook( "TF_WEAPON_GRAPPLINGHOOK" );
if ( TFGameRules() && TFGameRules()->IsUsingGrapplingHook() && pItemDef_GrapplingHook )
{
stockActionItemDefIndices.AddToTail( pItemDef_GrapplingHook->GetDefinitionIndex() );
}
static CSchemaItemDefHandle pItemDef_MvMCanteen( "Default Power Up Canteen (MvM)" );
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && pItemDef_MvMCanteen )
{
stockActionItemDefIndices.AddToTail( pItemDef_MvMCanteen->GetDefinitionIndex() );
}
// Traverse List
for ( CEconItemView *pActionItem : m_pBaseLoadoutItems )
{
for ( item_definition_index_t defIndex : stockActionItemDefIndices )
{
if ( pActionItem->GetItemDefIndex() == defIndex )
return pActionItem;
}
}
}
if ( iSlot >= LOADOUT_POSITION_HEAD )
return m_pDefaultItem;
// Traverse List
FOR_EACH_VEC( m_pBaseLoadoutItems, iItem )
{
if ( m_pBaseLoadoutItems[iItem]->GetItemDefinition()->GetLoadoutSlot( iClass ) == iSlot )
return m_pBaseLoadoutItems[iItem];
}
return m_pDefaultItem;
}
//-----------------------------------------------------------------------------
// Purpose: Fills out the vector with the sets that are currently active on the specified player & class
//-----------------------------------------------------------------------------
void CTFInventoryManager::GetActiveSets( CUtlVector<const CEconItemSetDefinition *> *pItemSets, CSteamID steamIDForPlayer, int iClass )
{
pItemSets->Purge();
CEconItemSchema *pSchema = ItemSystem()->GetItemSchema();
if ( !pSchema )
return;
// Loop through all the items we have equipped, and build a list of only set items
// Accumulate a list of our equipped set items.
CUtlVector<CEconItemView*> equippedSetItems;
for ( int i = 0; i < CLASS_LOADOUT_POSITION_COUNT; i++ )
{
CEconItemView *pItem = NULL;
#ifdef GAME_DLL
// On the server we need to look at what the player actually has equipped
// because they might be on a tournament server that's using an item_whitelist
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerBySteamID( steamIDForPlayer ) );
if ( pPlayer && pPlayer->Inventory() )
{
pItem = pPlayer->GetEquippedItemForLoadoutSlot( i );
}
#else
pItem = TFInventoryManager()->GetItemInLoadoutForClass( iClass, i, &steamIDForPlayer );
#endif
if ( !pItem )
continue;
CEconItemDefinition* pData = pItem->GetStaticData();
if ( !pData )
continue;
// Ignore items that don't have set bonuses.
if ( !pData->GetItemSetDefinition() )
continue;
// Make sure this item isn't failing a Holiday restriction before giving out the set bonus!
if ( pData->GetHolidayRestriction() )
{
int iHolidayRestriction = UTIL_GetHolidayForString( pData->GetHolidayRestriction() );
if ( iHolidayRestriction != kHoliday_None && (!TFGameRules() || !TFGameRules()->IsHolidayActive( iHolidayRestriction )) )
continue;
}
equippedSetItems.AddToTail( pItem );
}
// Find out which sets to apply.
CUtlVector<const char*> testedSets;
for ( int inv = 0; inv < equippedSetItems.Count(); inv++ )
{
CEconItemView *pItem = equippedSetItems[inv];
if ( !pItem )
continue;
const CEconItemSetDefinition *pItemSet = pItem->GetStaticData()->GetItemSetDefinition();
if ( !pItemSet )
continue;
if ( testedSets.HasElement( pItemSet->m_pszName ) )
continue; // Don't try to apply set bonuses we have already tested.
testedSets.AddToTail( pItemSet->m_pszName );
// Count how much of this set we have equipped.
int iSetItemsEquipped = 0;
for ( int i=0; i<pItemSet->m_iItemDefs.Count(); i++ )
{
unsigned int iIndex = pItemSet->m_iItemDefs[i];
for ( int j=0; j<equippedSetItems.Count(); j++ )
{
const CEconItemView *pTestItem = equippedSetItems[j];
const item_definition_index_t unEquippedItemSetDefIndex = pTestItem->GetItemDefinition()->GetSetItemRemap();
if ( iIndex == unEquippedItemSetDefIndex )
{
iSetItemsEquipped++;
break;
}
}
}
// Note: this logic will break if we ever have sets that have misc-slot items where we can have multiple items
// of the same type with different remaps equipped.
if ( iSetItemsEquipped == pItemSet->m_iItemDefs.Count() )
{
// The entire set is equipped.
pItemSets->AddToTail( pItemSet );
}
}
}
//-----------------------------------------------------------------------------
// Purpose: 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.
//-----------------------------------------------------------------------------
void CTFInventoryManager::AddBaseItemCriteria( baseitemcriteria_t *pCriteria, CItemSelectionCriteria *pSelectionCriteria )
{
pSelectionCriteria->BAddCondition( "used_by_classes", k_EOperator_Subkey_Contains, ItemSystem()->GetItemSchema()->GetClassUsabilityStrings()[pCriteria->iClass], true );
pSelectionCriteria->BAddCondition( "item_slot", k_EOperator_String_EQ, ItemSystem()->GetItemSchema()->GetLoadoutStrings( EEquipType_t::EQUIP_TYPE_CLASS )[pCriteria->iSlot], true );
}
//=======================================================================================================================
// TF PLAYER INVENTORY
//=======================================================================================================================
// Inventory Less function.
// Used to sort the inventory items into their positions.
class CTFInventoryListLess
{
public:
bool Less( const CEconItemView &src1, const CEconItemView &src2, void *pCtx )
{
if ( src1.GetInventoryPosition() > src2.GetInventoryPosition() )
return true;
return false;
}
};
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFPlayerInventory::CTFPlayerInventory()
{
m_aInventoryItems.SetLessContext( this );
#ifdef CLIENT_DLL
for ( int i = 0; i < TF_TEAM_COUNT; ++i )
m_CachedBaseTextureLowRes[ i ].SetLessFunc( DefLessFunc( itemid_t ) );
#endif
memset( m_LoadoutItems, LOADOUT_SLOT_USE_BASE_ITEM, sizeof( m_LoadoutItems ) );
memset( m_AccountLoadoutItems, LOADOUT_SLOT_USE_BASE_ITEM, sizeof( m_AccountLoadoutItems ) );
ClearClassLoadoutChangeTracking();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
CTFPlayerInventory::~CTFPlayerInventory()
{
#ifdef CLIENT_DLL
for ( int iTeam = 0; iTeam < TF_TEAM_COUNT; ++iTeam )
{
FOR_EACH_MAP_FAST( m_CachedBaseTextureLowRes[ iTeam ], i )
m_CachedBaseTextureLowRes[ iTeam ][ i ]->Release();
m_CachedBaseTextureLowRes[ iTeam ].RemoveAll();
}
#endif
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerInventory::CheckSaxtonMaskAchievement( const CEconItem *pEconItem )
{
if ( pEconItem )
{
if ( pEconItem->GetDefinitionIndex() == 277 && pEconItem->GetOrigin() == kEconItemOrigin_Crafted ) // Saxton mask is item index 277
{
g_AchievementMgrTF.OnAchievementEvent( ACHIEVEMENT_TF_HALLOWEEN_CRAFT_SAXTON_MASK );
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerInventory::UpdateCachedServerLoadoutItems()
{
V_memcpy( m_CachedServerLoadoutItems, m_LoadoutItems, sizeof( itemid_t ) * ARRAYSIZE( m_CachedServerLoadoutItems ) * ARRAYSIZE( m_CachedServerLoadoutItems[0] ) );
}
#endif // CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerInventory::SOUpdated( const CSteamID & steamIDOwner, const GCSDK::CSharedObject *pObject, GCSDK::ESOCacheEvent eEvent )
{
BaseClass::SOUpdated( steamIDOwner, pObject, eEvent );
#ifdef CLIENT_DLL
if ( pObject->GetTypeID() != CEconItem::k_nTypeID )
return;
// Clear out any predicted backpack slots when items move into them
CEconItem *pEconItem = (CEconItem *)pObject;
if ( eEvent == eSOCacheEvent_Incremental )
{
EconUI()->GetBackpackPanel()->MarkItemIDDirty( pEconItem->GetItemID() );
}
int iBackpackPos = TFInventoryManager()->GetBackpackPositionFromBackend( pEconItem->GetInventoryToken() );
TFInventoryManager()->PredictedBackpackPosFilled( iBackpackPos );
#endif // CLIENT_DLL
}
void CTFPlayerInventory::OnHasNewItems()
{
BaseClass::OnHasNewItems();
#ifdef CLIENT_DLL
if ( TFGameRules() && TFGameRules()->IsInTraining() )
return;
NotificationQueue_Remove( &CEconNotification_HasNewItems::IsNotificationType );
CEconNotification_HasNewItems *pNotification = new CEconNotification_HasNewItems();
pNotification->SetText( "TF_HasNewItems" );
pNotification->SetLifetime( 7.0f );
NotificationQueue_Add( pNotification );
#endif
}
void CTFPlayerInventory::OnHasNewQuest()
{
#ifdef CLIENT_DLL
#endif
}
#ifdef _DEBUG
#ifdef CLIENT_DLL
CON_COMMAND( cl_newitem_test, "Tests the new item ui notification." )
{
if ( steamapicontext == NULL || steamapicontext->SteamUser() == NULL )
return;
CEconNotification_HasNewItems *pNotification = new CEconNotification_HasNewItems();
pNotification->SetText( "TF_HasNewItems" );
pNotification->SetLifetime( 7.0f );
NotificationQueue_Add( pNotification );
}
#endif
#endif // _DEBUG
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerInventory::ValidateInventoryPositions( void )
{
BaseClass::ValidateInventoryPositions();
#ifdef CLIENT_DLL
bool bHasNewItems = false;
const int iMaxItems = GetMaxItemCount();
// First, check for duplicate positions
int iCount = m_aInventoryItems.Count();
for ( int i = iCount-1; i >= 0; i-- )
{
CEconItemView *pEconItemView = &m_aInventoryItems[i];
CheckSaxtonMaskAchievement( pEconItemView->GetSOCData() );
uint32 iPosition = pEconItemView->GetInventoryPosition();
// Waiting to be acknowledged?
if ( IsUnacknowledged(iPosition) )
{
if ( !pEconItemView->GetStaticData()->IsHidden() )
{
bHasNewItems = true;
}
continue;
}
bool bInvalidSlot = false;
if ( !IsNewPositionFormat(iPosition) )
{
ConvertOldFormatInventoryToNew();
break;
}
// Inside the backpack?
if ( i < (iCount-1) )
{
// We're not in an invalid slot yet. But if we're in the same position as another item, we should be moved too.
int iPos1 = TFInventoryManager()->GetBackpackPositionFromBackend(iPosition);
int iPos2 = TFInventoryManager()->GetBackpackPositionFromBackend(m_aInventoryItems[i+1].GetInventoryPosition());
if ( iPos1 == iPos2 )
{
Warning("WARNING: Found item in a duplicate backpack position. Moving to the backpack end.\n" );
bInvalidSlot = true;
}
}
// Make sure it's not outside the backpack extents
if ( !bInvalidSlot )
{
bInvalidSlot = (TFInventoryManager()->GetBackpackPositionFromBackend(iPosition) > iMaxItems);
}
if ( bInvalidSlot )
{
// The item is NOT hidden and is in an invalid slot. Move it back to the backpack.
if ( pEconItemView->GetItemDefinition() && !pEconItemView->GetItemDefinition()->IsHidden() && !TFInventoryManager()->SetItemBackpackPosition( pEconItemView, 0, true ) )
{
// We failed to move it to the backpack, because the player has no room.
// Force them to "refind" the item, which will make them throw something out.
TFInventoryManager()->UpdateInventoryPosition( this, pEconItemView->GetItemID(), GetUnacknowledgedPositionFor(UNACK_ITEM_DROPPED) );
}
}
// Make sure it isn't equipped by any invalid classes.
for ( int j = TF_FIRST_NORMAL_CLASS; j <= TF_LAST_NORMAL_CLASS; j++ )
{
if ( !pEconItemView->GetStaticData()->CanBeUsedByClass( j ) &&
pEconItemView->IsEquippedForClass( j ) )
{
// Unequip this item from this class.
InventoryManager()->UpdateInventoryEquippedState( this, INVALID_ITEM_ID, j, pEconItemView->GetEquippedPositionForClass( j ) );
}
}
}
if ( bHasNewItems )
{
OnHasNewItems();
}
#endif
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerInventory::ConvertOldFormatInventoryToNew( void )
{
uint32 iBackpackPos = 1;
// Loop through all items in the inventory. Move them all to the backpack, and in order.
int iCount = m_aInventoryItems.Count();
for ( int i = 0; i < iCount; i++ )
{
uint32 iPosition = m_aInventoryItems[i].GetInventoryPosition();
// Waiting to be acknowledged?
if ( IsUnacknowledged(iPosition) )
continue;
TFInventoryManager()->SetItemBackpackPosition( &m_aInventoryItems[i], iBackpackPos, true );
iBackpackPos++;
}
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Creates a script item and associates it with this econ item
//-----------------------------------------------------------------------------
void CTFPlayerInventory::SOCreated( const CSteamID & steamIDOwner, const GCSDK::CSharedObject *pObject, GCSDK::ESOCacheEvent eEvent )
{
BaseClass::SOCreated( steamIDOwner, pObject, eEvent );
if ( pObject->GetTypeID() != CEconItem::k_nTypeID )
return;
CEconItem *pEconItem = (CEconItem *)pObject;
// CEconItem *pEconItem = assert_cast<CEconItem*>( pObject );
#ifdef CLIENT_DLL
if ( InventoryManager()->GetLocalInventory() == this && GetOwner() == steamIDOwner )
{
if ( pObject->GetTypeID() == CEconItem::k_nTypeID )
{
CheckSaxtonMaskAchievement( (CEconItem*)pObject );
}
}
// CSteamID ownerSteamID( pEconItem->GetAccountID(), GetUniverse(), k_EAccountTypeIndividual );
// if ( ownerSteamID == ClientSteamContext().GetLocalPlayerSteamID() )
// {
// CheckSaxtonMaskAchievement( pEconItem );
// }
static CSchemaItemDefHandle pItemDef_HardyLaurel( "The Hardy Laurel" );
if ( pEconItem->GetItemDefinition() == pItemDef_HardyLaurel )
{
if ( TFSharedContentManager() )
{
TFSharedContentManager()->OfferSharedVision( TF_VISION_FILTER_ROME, pEconItem->GetAccountID() );
}
}
#else
// Summer 2015 Operation Pass so players can display the coin
//tagES remove this when we have a coin equip slot
static CSchemaItemDefHandle pItemDef_Summer2015Operation( "Activated Summer 2015 Operation Pass" );
if ( pEconItem->GetItemDefinition() == pItemDef_Summer2015Operation )
{
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerBySteamID( GetOwner() ) );
if ( pPlayer )
{
pPlayer->SetCampaignMedalActive( CAMPAIGN_MEDAL_SUMMER2015 );
}
}
// Invasion Community Update Pass so players can display the coin
//tagES remove this when we have a coin equip slot
static CSchemaItemDefHandle pItemDef_InvasionPass( "Activated Invasion Pass" );
if ( pEconItem->GetItemDefinition() == pItemDef_InvasionPass )
{
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerBySteamID( GetOwner() ) );
if ( pPlayer )
{
pPlayer->SetCampaignMedalActive( CAMPAIGN_MEDAL_INVASION );
}
}
// Halloween Pass so players can display the coin
//tagES remove this when we have a coin equip slot
static CSchemaItemDefHandle pItemDef_HalloweenPass( "Activated Halloween Pass" );
if ( pEconItem->GetItemDefinition() == pItemDef_HalloweenPass )
{
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerBySteamID( GetOwner() ) );
if ( pPlayer )
{
pPlayer->SetCampaignMedalActive( CAMPAIGN_MEDAL_HALLOWEEN );
}
}
// Winter2016 Pass so players can display the stamp
//tagES remove this when we have a coin equip slot
static CSchemaItemDefHandle pItemDef_Winter2016Pass( "Activated Operation Tough Break Pass" );
if ( pEconItem->GetItemDefinition() == pItemDef_Winter2016Pass )
{
CTFPlayer *pPlayer = ToTFPlayer( GetPlayerBySteamID( GetOwner() ) );
if ( pPlayer )
{
pPlayer->SetCampaignMedalActive( CAMPAIGN_MEDAL_WINTER2016 );
}
}
#endif
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerInventory::DumpInventoryToConsole( bool bRoot )
{
if ( bRoot )
{
Msg("========================================\n");
#ifdef CLIENT_DLL
Msg("(CLIENT) Inventory:\n");
#else
Msg("(SERVER) Inventory for account (%d):\n", m_OwnerID.GetAccountID() );
#endif
Msg(" Version: %llu:\n", m_pSOCache ? m_pSOCache->GetVersion() : -1 );
}
int iCount = m_aInventoryItems.Count();
Msg(" Num items: %d\n", iCount );
for ( int i = 0; i < iCount; i++ )
{
Msg(" %s (ID %llu) at backpack slot %d\n", m_aInventoryItems[i].GetStaticData()->GetDefinitionName(), m_aInventoryItems[i].GetItemID(), TFInventoryManager()->GetBackpackPositionFromBackend( m_aInventoryItems[i].GetInventoryPosition() ) );
int iEquipped = 0;
for ( equipped_class_t eq = TF_FIRST_NORMAL_CLASS; eq < TF_LAST_NORMAL_CLASS; eq++ )
{
if ( m_aInventoryItems[i].IsEquippedForClass( eq ) )
{
if ( iEquipped == 0 )
{
iEquipped++;
Msg(" -> EQUIPPED: ");
}
Msg("%s ", g_aPlayerClassNames_NonLocalized[eq] );
}
}
if ( iEquipped )
{
Msg("\n");
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerInventory::ClearClassLoadoutChangeTracking( void )
{
memset(m_bLoadoutChanged,0, sizeof(m_bLoadoutChanged));
#ifdef CLIENT_DLL
UpdateCachedServerLoadoutItems();
#endif // CLIENT_DLL
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose: Find the low res
//-----------------------------------------------------------------------------
ITexture *CTFPlayerInventory::GetWeaponSkinBaseLowRes( itemid_t nItemId, int iTeam ) const
{
Assert( iTeam >= 0 && iTeam < TF_TEAM_COUNT );
int index = m_CachedBaseTextureLowRes[ iTeam ].Find( nItemId );
if ( index == m_CachedBaseTextureLowRes[ iTeam ].InvalidIndex() )
return NULL;
return m_CachedBaseTextureLowRes[ iTeam ][ index ];
}
#endif
//-----------------------------------------------------------------------------
// Purpose: Find the first item in the local user's inventory with the given def index
//-----------------------------------------------------------------------------
CEconItemView *CTFPlayerInventory::GetFirstItemOfItemDef( item_definition_index_t nDefIndex, CPlayerInventory* pInventory )
{
#ifdef CLIENT_DLL
if ( pInventory == NULL )
{
pInventory = InventoryManager()->GetLocalInventory();
}
#endif
if ( !pInventory )
return NULL;
for ( int i = 0; i < pInventory->GetItemCount(); i++ )
{
CEconItemView *pItem = pInventory->GetItem(i);
if ( pItem->GetItemDefIndex() == nDefIndex )
{
return pItem;
}
}
return NULL;
}
//-----------------------------------------------------------------------------
// Purpose: Returns the item in the specified loadout slot for a given class
//-----------------------------------------------------------------------------
CEconItemView *CTFPlayerInventory::GetItemInLoadout( int iClass, int iSlot )
{
if ( iSlot < 0 || iSlot >= CLASS_LOADOUT_POSITION_COUNT )
return NULL;
if ( iClass == GEconItemSchema().GetAccountIndex() )
{
return GetInventoryItemByItemID( m_AccountLoadoutItems[ iSlot ] );
}
else
{
if ( iClass < TF_FIRST_NORMAL_CLASS || iClass >= TF_LAST_NORMAL_CLASS )
return NULL;
// If we don't have an item in the loadout at that slot, we return the base item
if ( m_LoadoutItems[iClass][iSlot] != LOADOUT_SLOT_USE_BASE_ITEM )
{
CEconItemView *pItem = GetInventoryItemByItemID( m_LoadoutItems[iClass][iSlot] );
// To protect against users lying to the backend about the position of their items,
// we need to validate their position on the server when we retrieve them.
if ( pItem && AreSlotsConsideredIdentical( pItem->GetStaticData()->GetEquipType(), pItem->GetStaticData()->GetLoadoutSlot( iClass ), iSlot ) )
return pItem;
}
}
return TFInventoryManager()->GetBaseItemForClass( iClass, iSlot );
}
#ifdef CLIENT_DLL
CEconItemView *CTFPlayerInventory::GetCacheServerItemInLoadout( int iClass, int iSlot )
{
if ( iSlot < 0 || iSlot >= CLASS_LOADOUT_POSITION_COUNT )
return NULL;
if ( iClass < TF_FIRST_NORMAL_CLASS || iClass >= TF_LAST_NORMAL_CLASS )
return NULL;
// If we don't have an item in the loadout at that slot, we return the base item
if ( m_CachedServerLoadoutItems[iClass][iSlot] != LOADOUT_SLOT_USE_BASE_ITEM )
{
CEconItemView *pItem = GetInventoryItemByItemID( m_CachedServerLoadoutItems[iClass][iSlot] );
// To protect against users lying to the backend about the position of their items,
// we need to validate their position on the server when we retrieve them.
if ( pItem && AreSlotsConsideredIdentical( pItem->GetStaticData()->GetEquipType(), pItem->GetStaticData()->GetLoadoutSlot( iClass ), iSlot ) )
return pItem;
}
return TFInventoryManager()->GetBaseItemForClass( iClass, iSlot );
}
#endif // CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
static CEconGameAccountClient *GetSOCacheGameAccountClient( CGCClientSharedObjectCache *pSOCache )
{
if ( !pSOCache )
return NULL;
return pSOCache->GetSingleton<CEconGameAccountClient>();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFPlayerInventory::GetPreviewItemDef( void ) const
{
CEconGameAccountClient *pGameAccountClient = GetSOCacheGameAccountClient( m_pSOCache );
if ( !pGameAccountClient )
return 0;
return pGameAccountClient->Obj().preview_item_def();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerInventory::CanPurchaseItems( int iItemCount ) const
{
// If we're not a free trial account, we fall back to our default logic of "do
// we have enough empty slots?".
CEconGameAccountClient *pGameAccountClient = GetSOCacheGameAccountClient( m_pSOCache );
if ( !pGameAccountClient || !pGameAccountClient->Obj().trial_account() )
return BaseClass::CanPurchaseItems( iItemCount );
// We're a free trial account, so when we purchase these items, our inventory
// will actually expand. We check to make sure that we have room for these
// items against what will be our new maximum backpack size, not our current
// backpack limit.
int iNewItemCount = GetItemCount() + iItemCount,
iAfterPurchaseMaxItemCount = DEFAULT_NUM_BACKPACK_SLOTS
+ (pGameAccountClient ? pGameAccountClient->Obj().additional_backpack_slots() : 0);
return iNewItemCount <= iAfterPurchaseMaxItemCount;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
int CTFPlayerInventory::GetMaxItemCount( void ) const
{
int iMaxItems = DEFAULT_NUM_BACKPACK_SLOTS;
CEconGameAccountClient *pGameAccountClient = GetSOCacheGameAccountClient( m_pSOCache );
if ( pGameAccountClient )
{
if ( pGameAccountClient->Obj().trial_account() )
{
iMaxItems = DEFAULT_NUM_BACKPACK_SLOTS_FREE_TRIAL_ACCOUNT;
}
iMaxItems += pGameAccountClient->Obj().additional_backpack_slots();
}
return MIN( iMaxItems, MAX_NUM_BACKPACK_SLOTS );
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose: Removes any item in a loadout slot. If the slot has a base item,
// the player essentially returns to using that item.
//-----------------------------------------------------------------------------
bool CTFPlayerInventory::ClearLoadoutSlot( int iClass, int iSlot )
{
if ( iSlot < 0 || iSlot >= CLASS_LOADOUT_POSITION_COUNT )
return false;
if ( iClass == GEconItemSchema().GetAccountIndex() )
{
if ( m_AccountLoadoutItems[iSlot] == LOADOUT_SLOT_USE_BASE_ITEM )
return false;
}
else
{
if ( iClass < TF_FIRST_NORMAL_CLASS || iClass >= TF_LAST_NORMAL_CLASS )
return false;
if ( m_LoadoutItems[iClass][iSlot] == LOADOUT_SLOT_USE_BASE_ITEM )
return false;
}
CEconItemView *pItemInSlot = GetItemInLoadout( iClass, iSlot );
if ( !pItemInSlot )
return false;
InventoryManager()->UpdateInventoryEquippedState( this, INVALID_ITEM_ID, iClass, iSlot );
// TODO: Prediction
// It's been moved to the backpack, so clear out loadout entry
//m_LoadoutItems[iClass][iSlot] = LOADOUT_SLOT_USE_BASE_ITEM;
return true;
}
//-----------------------------------------------------------------------------
// Purpose: Update weapon skin request list
//-----------------------------------------------------------------------------
void CTFPlayerInventory::UpdateWeaponSkinRequest()
{
TM_ZONE_DEFAULT( TELEMETRY_LEVEL0 );
FOR_EACH_VEC_BACK( m_vecWeaponSkinRequestList, i )
{
SkinRequest_t &req = m_vecWeaponSkinRequestList[i];
CEconItemView *pItem = GetInventoryItemByItemID( req.m_nID );
Assert( pItem );
if ( !pItem )
{
m_vecWeaponSkinRequestList.Remove( i );
continue;
}
// Have we loaded this one yet? If not, do it here.
if ( mdlcache->IsErrorModel( req.m_hModel ) )
{
const char *pszModelName = pItem->GetPlayerDisplayModel( 0, 0 );
if ( pszModelName )
{
MDLHandle_t hItemMDL = mdlcache->FindMDL( pszModelName );
if ( mdlcache->IsErrorModel( hItemMDL ) )
{
AssertMsg( 0, "failed to find %s from mdlcache", pszModelName );
m_vecWeaponSkinRequestList.Remove( i );
continue;
}
req.m_hModel = hItemMDL;
}
else
{
AssertMsg( 0, "failed to precache weapon skin because there's no model" );
m_vecWeaponSkinRequestList.Remove( i );
}
}
// Draw!
{
CMDL mdl;
mdl.SetMDL( req.m_hModel );
mdl.m_pProxyData = static_cast<IClientRenderable*>( pItem );
pItem->SetWeaponSkinUseLowRes( true );
int nRestoreTeam = pItem->GetTeamNumber();
pItem->SetTeamNumber( req.m_nTeam );
matrix3x4_t matIdentity;
SetIdentityMatrix( matIdentity );
IMaterial *pOverrideMaterial = pItem->GetMaterialOverride( pItem->GetTeamNumber() );
if ( pOverrideMaterial )
modelrender->ForcedMaterialOverride( pOverrideMaterial );
mdl.Draw( matIdentity );
if ( pOverrideMaterial )
modelrender->ForcedMaterialOverride( NULL );
pItem->SetTeamNumber( nRestoreTeam );
pItem->SetWeaponSkinUseLowRes( false );
}
// Don't remove until it's complete.
if ( pItem->GetWeaponSkinBase() )
{
Assert( pItem->GetWeaponSkinBaseCompositor() == NULL );
ITexture* pTex = pItem->GetWeaponSkinBase();
if ( pTex )
{
pTex->AddRef(); // We need to hold a ref to the texture.
m_CachedBaseTextureLowRes[ req.m_nTeam ].Insert( req.m_nID, pTex );
pItem->SetWeaponSkinBase( NULL ); // Clean up.
}
// We do RED, then BLUE. Then drop it out of the list.
if ( req.m_nTeam == TF_TEAM_BLUE )
{
Assert( !mdlcache->IsErrorModel( req.m_hModel ) );
mdlcache->Release( req.m_hModel );
m_vecWeaponSkinRequestList.Remove( i );
}
else
{
Assert( req.m_nTeam == TF_TEAM_RED );
req.m_nTeam = TF_TEAM_BLUE;
}
}
// Only do one of these per frame to avoid hitching.
break;
}
}
#endif // CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerInventory::ItemHasBeenUpdated( CEconItemView *pItem, bool bUpdateAckFile, bool bWriteAckFile )
{
Assert( pItem );
BaseClass::ItemHasBeenUpdated( pItem, bUpdateAckFile, bWriteAckFile );
const CEconItem *pEconItem = pItem->GetSOCData();
#ifdef CLIENT_DLL
static CSchemaAttributeDefHandle pAttrib_WeaponAllowInspect( "weapon_allow_inspect" );
bool bLocalInv = InventoryManager()->GetLocalInventory() == this;
#endif // CLIENT_DLL
for ( equipped_class_t iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; iClass++ )
{
equipped_slot_t unSlot = pEconItem ? pEconItem->GetEquippedPositionForClass( iClass ) : INVALID_EQUIPPED_SLOT;
Assert( GetInventoryItemByItemID( pItem->GetItemID() ) );
bool bThisClassLoadoutChanged = UpdateEquipStateForClass( pItem->GetItemID(), unSlot, m_LoadoutItems[iClass], ARRAYSIZE( m_LoadoutItems[iClass] ) );
if ( bThisClassLoadoutChanged )
{
m_bLoadoutChanged[iClass] = true;
#ifdef CLIENT_DLL
// if we can inspect this item, it has unique skin.
// draw it once per team to tell the system to generate unique skin
float flInspect = 0;
if ( bLocalInv && FindAttribute_UnsafeBitwiseCast<attrib_value_t>( pItem, pAttrib_WeaponAllowInspect, &flInspect ) )
{
SkinRequest_t req = { TF_TEAM_RED, pItem->GetItemID(), MDLHANDLE_INVALID };
m_vecWeaponSkinRequestList.AddToTail( req );
}
#endif // CLIENT_DLL
}
}
// Update account items as well
equipped_slot_t unSlot = pEconItem ? pEconItem->GetEquippedPositionForClass( GEconItemSchema().GetAccountIndex() ) : INVALID_EQUIPPED_SLOT;
UpdateEquipStateForClass( pItem->GetItemID(), unSlot, m_AccountLoadoutItems, ARRAYSIZE( m_AccountLoadoutItems ) );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
bool CTFPlayerInventory::UpdateEquipStateForClass( const itemid_t& itemID, equipped_slot_t nSlot, itemid_t *pLoadout, int nCount )
{
bool bThisClassLoadoutChanged = false;
// For each slot this item may have been equipped in, set to the base item, unless that slot
// is the current slot. (ie., if an item moves from slot 10 to slot 12, slot 10 will be set to
// base item, and slot 12 will be set to this item ID)
for ( int i = 0; i < nCount; i++ )
{
itemid_t& refLoadoutItemID = *( pLoadout + i );
if ( i == nSlot )
{
// This may be an invalid slot for the item, but CTFPlayerInventory::InventoryReceived()
// will have detected that and sent off a request already to move it. The response
// to that will clear this loadout slot.
refLoadoutItemID = itemID;
bThisClassLoadoutChanged = true;
}
else if ( refLoadoutItemID == itemID )
{
refLoadoutItemID = LOADOUT_SLOT_USE_BASE_ITEM;
bThisClassLoadoutChanged = true;
}
}
return bThisClassLoadoutChanged;
}
#ifdef CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerInventory::PostSOUpdate( const CSteamID & steamIDOwner, GCSDK::ESOCacheEvent eEvent )
{
BaseClass::PostSOUpdate( steamIDOwner, eEvent );
VerifyChangedLoadoutsAreValid();
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerInventory::SOCacheSubscribed( const CSteamID & steamIDOwner, GCSDK::ESOCacheEvent eEvent )
{
BaseClass::SOCacheSubscribed( steamIDOwner, eEvent );
VerifyChangedLoadoutsAreValid();
UpdateCachedServerLoadoutItems();
}
//-----------------------------------------------------------------------------
// Purpose: Helper function to add a new item for a econ item
//-----------------------------------------------------------------------------
bool CTFPlayerInventory::AddEconItem( CEconItem * pItem, bool bUpdateAckFile, bool bWriteAckFile, bool bCheckForNewItems )
{
if ( BaseClass::AddEconItem( pItem, bUpdateAckFile, bWriteAckFile, bCheckForNewItems ) )
{
if ( bCheckForNewItems && InventoryManager()->GetLocalInventory() == this )
{
if ( IsUnacknowledged( pItem->GetInventoryToken() ) )
{
OnHasNewQuest();
}
}
return true;
}
return false;
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerInventory::VerifyLoadoutItemsAreValid( int iClass )
{
// Important note: currently this function walks the loadout slots in order causing slots towards
// the beginning of the list to take priority over slots later in the list. This means that currently
// weapons take priority over hats, hats take priority over misc slots, etc. which is all well and good.
// If later we want the order in which slots claim their equip regions to change, we'll want to change
// the iteration order here and also change GenerateEquipRegionMaskUpToSlot(), which is used for
// filling out the UI.
equip_region_mask_t unCumulativeRegionMask = 0;
for ( int i = 0; i < CLASS_LOADOUT_POSITION_COUNT; i++ )
{
CEconItemView *pEquippedItemView = GetItemInLoadout( iClass, i );
if ( !pEquippedItemView )
continue;
// Does this item use the same regions as some item that we already have equipped?
equip_region_mask_t unItemEquipMask = pEquippedItemView->GetItemDefinition()->GetEquipRegionMask();
if ( unItemEquipMask & unCumulativeRegionMask )
{
// Unequip this item. This will wind up calling into ::ItemHasBeenUpdated() once the
// unequip makes it to the GC and back.
InventoryManager()->UpdateInventoryEquippedState( this, INVALID_ITEM_ID, iClass, pEquippedItemView->GetEquippedPositionForClass( iClass ) );
}
else
{
unCumulativeRegionMask |= unItemEquipMask;
}
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerInventory::VerifyChangedLoadoutsAreValid()
{
// We maybe changed equip state for an item and it's possible if we're sending bad messages and/or
// hacking state that we'll now have conflicting items equipped. Walk all of our items for this class
// to verify our state is good.
for ( equipped_class_t iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; iClass++ )
{
if ( m_bLoadoutChanged[iClass] )
{
VerifyLoadoutItemsAreValid( iClass );
}
}
}
#endif // CLIENT_DLL
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CTFPlayerInventory::ItemIsBeingRemoved( CEconItemView *pItem )
{
for ( int iClass = TF_FIRST_NORMAL_CLASS; iClass < TF_LAST_NORMAL_CLASS; iClass++ )
{
if ( pItem->IsEquippedForClass( iClass ) )
{
for ( int iSlot = 0; iSlot < CLASS_LOADOUT_POSITION_COUNT; iSlot++ )
{
if ( m_LoadoutItems[iClass][iSlot] == pItem->GetItemID() )
{
m_LoadoutItems[iClass][iSlot] = LOADOUT_SLOT_USE_BASE_ITEM;
m_bLoadoutChanged[iClass] = true;
}
}
}
}
}
//=======================================================================================================================
// TF PLAYER INVENTORY
//=======================================================================================================================
#ifdef CLIENT_DLL
// WTF: Declaring this inline caused a compiler bug.
CTFPlayerInventory *CTFInventoryManager::GetLocalTFInventory( void )
{
return &m_LocalInventory;
}
#endif
#ifdef _DEBUG
#if defined(CLIENT_DLL)
CON_COMMAND_F( item_dumpinv_other, "Dumps the contents of a specified client inventory. Format: item_dumpinv_other <player index>", FCVAR_NONE )
{
if ( args.ArgC() > 1 )
{
C_TFPlayer *pOther = ToTFPlayer( UTIL_PlayerByIndex( atoi(args[1]) ) );
if ( pOther )
{
pOther->Inventory()->DumpInventoryToConsole( true );
return;
}
}
Msg("Couldn't find specified player.\nFormat: item_dumpinv_other <player index>\n");
}
#endif
#endif // _DEBUG
#ifdef _DEBUG
#if defined(CLIENT_DLL)
CON_COMMAND_F( item_dumpinv, "Dumps the contents of a specified client inventory. Format: item_dumpinv", FCVAR_CHEAT )
#else
CON_COMMAND_F( item_dumpinv_sv, "Dumps the contents of a specified server inventory. Format: item_dumpinv_sv", FCVAR_CHEAT )
#endif
{
#if defined(CLIENT_DLL)
CSteamID steamID = steamapicontext->SteamUser()->GetSteamID();
#else
CSteamID steamID;
CTFPlayer *pPlayer = ToTFPlayer( UTIL_GetCommandClient() );
pPlayer->GetSteamID( &steamID );
#endif
CPlayerInventory *pInventory = TFInventoryManager()->GetInventoryForPlayer( steamID );
if ( !pInventory )
{
Msg("No inventory for that player.\n");
return;
}
pInventory->DumpInventoryToConsole( true );
}
#endif
#ifdef _DEBUG
#if defined(CLIENT_DLL)
CON_COMMAND_F( item_deleteunknowns, "Deletes all items in your inventory that we don't have static data for. Useful for removing items that have been removed from the backend.", FCVAR_CHEAT )
{
int iDeleted = TFInventoryManager()->DeleteUnknowns( InventoryManager()->GetLocalInventory() );
Msg("Deleted %d unknown items.\n", iDeleted);
}
#endif
#endif
#if defined( TF_CLIENT_DLL )
CON_COMMAND( load_itempreset, "Equip all items for a given preset on the player." )
{
C_TFPlayer *pPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pPlayer )
return;
if ( args.ArgC() != 2 )
{
Msg( "Usage: \"load_itempreset <preset index>\" - <preset index> can be 0 to 3." );
return;
}
if ( pPlayer->m_Shared.InCond( TF_COND_TAUNTING ) )
return;
equipped_class_t unClass = pPlayer->GetPlayerClass()->GetClassIndex();
equipped_preset_t unPreset = atoi( args[1] );
if ( TFInventoryManager()->LoadPreset( unClass, unPreset ) )
{
// Tell the GC to tell server that we should respawn if we're in a respawn room
extern ConVar tf_respawn_on_loadoutchanges;
if ( tf_respawn_on_loadoutchanges.GetBool() )
{
GCSDK::CGCMsg< ::MsgGCEmpty_t > msg( k_EMsgGCRespawnPostLoadoutChange );
GCClientSystem()->BSendMessage( msg );
}
}
}
#endif // TF_CLIENT_DLL