BotoX
/
hl2_src-leak-2017
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
hl2_src-leak-2017/src/game/client/tf/tf_consumables.cpp

2234 lines
78 KiB
C++
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose:
//
// $NoKeywords: $
//=============================================================================
#include "cbase.h"
// for messaging with the GC
#include "econ_gcmessages.h"
#include "econ_item_inventory.h"
#include "tf_gcmessages.h"
#include "tf_duel_summary.h"
#include "gc_clientsystem.h"
// other
#include "c_playerresource.h"
#include "c_tf_player.h"
#include "tf_item_wearable.h"
#include "econ_notifications.h"
#include "tf_hud_chat.h"
#include "c_tf_gamestats.h"
#include "tf_gamerules.h"
#include "tf_item_tools.h"
#include "c_tf_freeaccount.h"
#include "tf_item_powerup_bottle.h"
#include "tf_weapon_grapplinghook.h"
// for UI
#include "clientmode_tf.h"
#include "confirm_dialog.h"
#include "select_player_dialog.h"
#include "econ_notifications.h"
#include "vgui/ISurface.h"
#include "vgui/character_info_panel.h"
#include "tf_hud_mainmenuoverride.h"
#include "econ_ui.h"
#include "backpack_panel.h"
#include "store/v1/tf_store_page.h"
#include "econ_item_description.h"
#include "weapon_selection.h"
// memdbgon must be the last include file in a .cpp file!!!
#include <tier0/memdbgon.h>
//-----------------------------------------------------------------------------
// Wrapped Gift Declarations
void UseGift( CEconItemView* pItem, CSteamID targetID );
extern void PerformToolAction_UnwrapGift( vgui::Panel* pParent, CEconItemView *pGiftItem );
extern void ShowWaitingDialog( CGenericWaitingDialog *pWaitingDialog, const char* pUpdateText, bool bAnimate, bool bShowCancel, float flMaxDuration );
class CDeliverGiftSelectDialog;
CDeliverGiftSelectDialog *OpenDeliverGiftDialog( vgui::Panel *pParent, CEconItemView *pItem );
//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------
// Duel Declarations
bool DuelMiniGame_IsDuelingLocalPlayer( C_TFPlayer *pPlayer );
bool DuelMiniGame_IsDueling();
//-----------------------------------------------------------------------------
class CWaitForPackageDialog : public CGenericWaitingDialog
{
public:
CWaitForPackageDialog( vgui::Panel *pParent ) : CGenericWaitingDialog( pParent )
{
}
protected:
virtual void OnTimeout()
{
// Play an exciting sound!
vgui::surface()->PlaySound( "misc/achievement_earned.wav" );
// Show them their loot!
InventoryManager()->ShowItemsPickedUp( true );
}
};
bool IgnoreRequestFromUser( const CSteamID &steamID )
{
// ignore blocked players
if ( steamapicontext && steamapicontext->SteamFriends() )
{
EFriendRelationship eRelationship = steamapicontext->SteamFriends()->GetFriendRelationship( steamID );
switch ( eRelationship )
{
case k_EFriendRelationshipBlocked:
{
return true;
}
}
}
return false;
}
static void ShowSelectDuelTargetDialog( uint64 iItemID );
enum EServerPlayersGCSend
{
kServerPlayers_DontSend,
kServerPlayers_Send,
};
struct CUseItemConfirmContext
{
public:
CUseItemConfirmContext( CEconItemView *pEconItemView, EServerPlayersGCSend eSendServerPlayers, const char* pszConfirmUseSound = NULL )
: m_pEconItemView( pEconItemView )
, m_bSendServerPlayers( eSendServerPlayers == kServerPlayers_Send )
, m_pszConfirmUseSound( pszConfirmUseSound )
{
Assert( eSendServerPlayers == kServerPlayers_DontSend || eSendServerPlayers == kServerPlayers_Send );
}
void OnConfirmUse()
{
if ( m_pszConfirmUseSound && *m_pszConfirmUseSound )
{
vgui::surface()->PlaySound( m_pszConfirmUseSound );
}
}
const char* m_pszConfirmUseSound;
CEconItemView *m_pEconItemView;
bool m_bSendServerPlayers;
};
static void UseItemConfirm( bool bConfirmed, void *pContext )
{
static CSchemaAttributeDefHandle pAttrDef_UnlimitedUse( "unlimited quantity" );
CUseItemConfirmContext *pConfirmContext = (CUseItemConfirmContext *)pContext;
CEconItemView *pEconItemView = pConfirmContext->m_pEconItemView;
if ( bConfirmed )
{
pConfirmContext->OnConfirmUse();
if ( pEconItemView && !pEconItemView->FindAttribute( pAttrDef_UnlimitedUse ) )
{
GCSDK::CProtoBufMsg<CMsgUseItem> msg( k_EMsgGCUseItemRequest );
msg.Body().set_item_id( pConfirmContext->m_pEconItemView->GetItemID() );
if ( pConfirmContext->m_bSendServerPlayers )
{
for ( int i = 1; i <= gpGlobals->maxClients; i++ )
{
CBasePlayer *pPlayer = UTIL_PlayerByIndex( i );
if ( pPlayer == NULL )
continue;
CSteamID steamIDPlayer;
if ( !pPlayer->GetSteamID( &steamIDPlayer ) )
continue;
msg.Body().add_gift__potential_targets( steamIDPlayer.GetAccountID() );
}
}
GCClientSystem()->BSendMessage( msg );
}
EconUI()->Gamestats_ItemTransaction( IE_ITEM_USED_CONSUMABLE, pEconItemView, NULL );
// CBaseHudChat *pHUDChat = (CBaseHudChat *)GET_HUDELEMENT( CHudChat );
// if ( pHUDChat )
// {
// char szAnsi[1024];
// Q_snprintf( szAnsi, 1024, "Using item: %ull", pItem->GetItemID() );
// pHUDChat->Printf( CHAT_FILTER_NONE, "%s", szAnsi );
// }
}
delete pConfirmContext;
}
static void OpenPass( bool bConfirmed, void *pContext )
{
if ( bConfirmed )
{
vgui::surface()->PlaySound( "ui/item_gift_wrap_unwrap.wav" );
ShowWaitingDialog( new CWaitForPackageDialog( NULL ), "#ToolRedeemingPass", true, false, 5.0f );
}
UseItemConfirm( bConfirmed, pContext );
}
static void PrintTextToChat( const char *pText, KeyValues *pKeyValues )
{
GetClientModeTFNormal()->PrintTextToChat( pText, pKeyValues );
}
void GetPlayerNameBySteamID( const CSteamID &steamID, OUT_Z_CAP(maxLenInChars) char *pDestBuffer, int maxLenInChars )
{
// always attempt to precache this user's name -- we may need it later after they leave the server, for instance,
// even if that's where they are now
InventoryManager()->PersonaName_Precache( steamID.GetAccountID() );
// first, look through players on our connected gameserver if available -- we already have this information and
// if there's a disagreement between Steam and the gameserver the gameserver view is what the player is probably
// expecting anyway
if ( engine->IsInGame() )
{
for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
{
if ( g_PR->IsConnected( iPlayerIndex ) )
{
player_info_t pi;
if ( !engine->GetPlayerInfo( iPlayerIndex, &pi ) )
continue;
if ( !pi.friendsID )
continue;
CSteamID steamIDTemp( pi.friendsID, 1, GetUniverse(), k_EAccountTypeIndividual );
if ( steamIDTemp == steamID )
{
V_strncpy( pDestBuffer, pi.name, maxLenInChars );
return;
}
}
}
}
// try the persona name cache
// this goes to steam if necessary
const char *pszName = InventoryManager()->PersonaName_Get( steamID.GetAccountID() );
if ( pszName != NULL )
{
V_strncpy( pDestBuffer, pszName, maxLenInChars );
return;
}
// otherwise, return what we would normally return
V_strncpy( pDestBuffer, steamapicontext->SteamFriends()->GetFriendPersonaName( steamID ), maxLenInChars );
}
static bool IsGCUseableItem( const GameItemDefinition_t *pItemDef )
{
Assert( pItemDef );
return (pItemDef->GetCapabilities() & ITEM_CAP_USABLE_GC) != 0;
}
//-----------------------------------------------------------------------------
// Purpose: Implementation of the local response for someone who used a dueling minigame
//-----------------------------------------------------------------------------
void CEconTool_DuelingMinigame::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
Assert( pItem );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
Assert( pLocalPlayer );
if ( DuelMiniGame_IsDueling() )
{
// can't duel if already dueling
ShowMessageBox( "#TF_Duel_Title", "#TF_Duel_InADuel_Initiator", "#GameUI_OK" );
return;
}
if ( pLocalPlayer->GetTeamNumber() != TF_TEAM_RED && pLocalPlayer->GetTeamNumber() != TF_TEAM_BLUE )
{
// can't duel from spectator mode, etc.
ShowMessageBox( "#TF_UseFail_NotOnTeam_Title", "#TF_UseFail_NotOnTeam", "#GameUI_OK" );
return;
}
if ( TFGameRules() && !TFGameRules()->CanInitiateDuels() )
{
ShowMessageBox( "#TF_Duel_Title", "#TF_Duel_CannotUse", "#GameUI_OK" );
return;
}
ShowSelectDuelTargetDialog( pItem->GetItemID() );
}
//-----------------------------------------------------------------------------
// Purpose: Implementation of the local response for someone who used a noisemaker
//-----------------------------------------------------------------------------
void CEconTool_Noisemaker::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
Assert( pItem );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
Assert( pLocalPlayer );
if ( gpGlobals->curtime < pLocalPlayer->m_Shared.GetNextNoiseMakerTime() )
return;
if ( !pLocalPlayer->IsAlive() )
return;
if ( pLocalPlayer->GetTeamNumber() < FIRST_GAME_TEAM )
return;
// This may not be ideal. We're going to have the game server do the noise effect,
// without checking the GC to see whether we have charges available. Querying the
// GC would cause a significant delay before the item was used, so we simulate.
// Tell the game server to play the sound.
KeyValues *kv = new KeyValues( "use_action_slot_item_server" );
engine->ServerCmdKeyValues( kv );
// Tell the GC to consume a charge.
CUseItemConfirmContext *context = new CUseItemConfirmContext( pItem, kServerPlayers_DontSend );
UseItemConfirm( true, context );
// Notify the player that they used their last charge.
if ( pItem->GetItemQuantity() <= 1 )
{
CEconNotification *pNotification = new CEconNotification();
pNotification->SetText( "#TF_NoiseMaker_Exhausted" );
pNotification->SetLifetime( 7.0f );
NotificationQueue_Add( pNotification );
}
}
//-----------------------------------------------------------------------------
// Purpose: Implementation of the local response for someone who used a gift-wrapped item
//-----------------------------------------------------------------------------
void UseUntargetedGiftConfirm( bool bConfirmed, void *pContext )
{
if ( bConfirmed )
{
UseGift( static_cast<CEconItemView *>( pContext ), k_steamIDNil );
}
}
void CEconTool_WrappedGift::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
Assert( pItem );
if ( BIsDirectGift() )
{
OpenDeliverGiftDialog( pParent, pItem );
}
else
{
// ...otherwise, we should try and open the gift!
PerformToolAction_UnwrapGift( pParent, pItem );
}
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEconTool_WeddingRing::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
Assert( pItem );
// Don't do anything if we haven't been gifted already -- we don't expect to
// ever get in here, really.
static CSchemaAttributeDefHandle pAttrDef_GifterAccountID( "gifter account id" );
uint32 unAccountID;
if ( !pItem->FindAttribute( pAttrDef_GifterAccountID, &unAccountID ) )
return;
// We have been gifted, so pop up a dialog box to allow the user to accept/reject
// the proposal.
CTFGenericConfirmDialog *pDialog = ShowConfirmDialog( "#TF_UseWeddingRing_Title", "#TF_UseWeddingRing_Text",
"#TF_WeddingRing_AcceptProposal", "#TF_WeddingRing_RejectProposal",
&UseItemConfirm );
pDialog->AddStringToken( "item_name", pItem->GetItemName() );
CUtlConstWideString sProposerPersonaName;
GLocalizationProvider()->ConvertUTF8ToLocchar( TFInventoryManager()->PersonaName_Get( unAccountID ), &sProposerPersonaName );
pDialog->AddStringToken( "proposer_name", sProposerPersonaName.Get() );
pDialog->SetContext( new CUseItemConfirmContext( pItem, kServerPlayers_DontSend ) );
}
//-----------------------------------------------------------------------------
// Purpose: Implementation of the local response for someone who used a backpack expander
//-----------------------------------------------------------------------------
void CEconTool_BackpackExpander::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
Assert( pItem );
// first validate that they aren't already at max inventory size and can use the item
uint32 unExtraSlots =GetBackpackSlots();
if ( unExtraSlots == 0 )
{
return;
}
uint32 unNewNumSlots = TFInventoryManager()->GetLocalTFInventory()->GetMaxItemCount() + unExtraSlots;
if ( unNewNumSlots > MAX_NUM_BACKPACK_SLOTS )
{
ShowMessageBox( "#TF_UseBackpackExpanderFail_Title", "#TF_UseBackpackExpanderFail_Text", "#GameUI_OK" );
return;
}
// Free Trials can use expanders but max out at a smaller value since premium gains a bunch of free slots
if ( IsFreeTrialAccount() && unNewNumSlots > MAX_NUM_BACKPACK_SLOTS - (DEFAULT_NUM_BACKPACK_SLOTS - DEFAULT_NUM_BACKPACK_SLOTS_FREE_TRIAL_ACCOUNT) )
{
ShowMessageBox( "#TF_UseBackpackExpanderFail_Title", "#TF_UseBackpackExpanderFail_Text", "#GameUI_OK" );
return;
}
CTFGenericConfirmDialog *pDialog = ShowConfirmDialog( "#TF_UseBackpackExpander_Title", "#TF_UseBackpackExpander_Text",
"#GameUI_OK", "#Cancel",
&UseItemConfirm );
pDialog->AddStringToken( "item_name", pItem->GetItemName() );
wchar_t wszUsesLeft[32];
_snwprintf( wszUsesLeft, ARRAYSIZE(wszUsesLeft), L"%d", pItem->GetItemQuantity() );
pDialog->AddStringToken( "uses_left", wszUsesLeft );
wchar_t wszNewSize[32];
_snwprintf( wszNewSize, ARRAYSIZE(wszNewSize), L"%d", unNewNumSlots );
pDialog->AddStringToken( "new_size", wszNewSize );
pDialog->SetContext( new CUseItemConfirmContext( pItem, kServerPlayers_DontSend ) );
}
//-----------------------------------------------------------------------------
// Purpose: Implementation of the local response for someone who used an account upgrade
//-----------------------------------------------------------------------------
void CEconTool_AccountUpgradeToPremium::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
Assert( pItem );
// if the account is already premium, abort here
if ( !IsFreeTrialAccount() )
{
ShowMessageBox( "#TF_UseAccountUpgradeToPremiumFail_Title", "#TF_UseAccountUpgradeToPremiumFail_Text", "#GameUI_OK" );
return;
}
// show a confirmation dialog to make sure they want to consume the charge
CTFGenericConfirmDialog *pDialog = ShowConfirmDialog( "#TF_UseAccountUpgradeToPremium_Title", "#TF_UseAccountUpgradeToPremium_Text",
"#GameUI_OK", "#Cancel",
&UseItemConfirm );
pDialog->AddStringToken( "item_name", pItem->GetItemName() );
wchar_t wszUsesLeft[32];
_snwprintf( wszUsesLeft, ARRAYSIZE(wszUsesLeft), L"%d", pItem->GetItemQuantity() );
pDialog->AddStringToken( "uses_left", wszUsesLeft );
pDialog->SetContext( new CUseItemConfirmContext( pItem, kServerPlayers_DontSend ) );
}
//-----------------------------------------------------------------------------
// Purpose: Implementation of the local response for someone who used a claim code item
//-----------------------------------------------------------------------------
void CEconTool_ClaimCode::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
Assert( pItem );
CTFGenericConfirmDialog *pDialog = ShowConfirmDialog( "#TF_UseClaimCode_Title", "#TF_UseClaimCode_Text",
"#GameUI_OK", "#Cancel",
&UseItemConfirm );
pDialog->AddStringToken( "item_name", pItem->GetItemName() );
const char *pszClaimValue = GetClaimType();
if ( pszClaimValue )
{
wchar_t wszClaimType[128];
KeyValuesAD pkvDummy( "dummy" );
g_pVGuiLocalize->ConstructString_safe( wszClaimType, pszClaimValue, pkvDummy );
pDialog->AddStringToken( "claim_type", wszClaimType );
}
pDialog->SetContext( new CUseItemConfirmContext( pItem, kServerPlayers_DontSend ) );
}
//-----------------------------------------------------------------------------
// Purpose: Implementation of the local response for someone who used an item that doesn't have
// special-case handling (ie., paint); called into from other code
//-----------------------------------------------------------------------------
static bool s_bConsumableToolOpeningGift = false;
static void ClientConsumableTool_Generic( CEconItemView *pItem, vgui::Panel *pParent )
{
Assert( pItem );
Assert( pItem->GetItemDefinition() );
Assert( pItem->GetItemDefinition()->GetEconTool() );
CTFGenericConfirmDialog *pDialog = ShowConfirmDialog( "#TF_UseItem_Title", "#TF_UseItem_Text",
"#GameUI_OK", "#Cancel",
&UseItemConfirm );
pDialog->AddStringToken( "item_name", pItem->GetItemName() );
wchar_t wszUsesLeft[32];
_snwprintf( wszUsesLeft, ARRAYSIZE(wszUsesLeft), L"%d", pItem->GetItemQuantity() );
pDialog->AddStringToken( "uses_left", wszUsesLeft );
pDialog->SetContext(
new CUseItemConfirmContext( pItem,
pItem->GetItemDefinition()->GetTypedEconTool<CEconTool_Gift>()
? kServerPlayers_Send
: kServerPlayers_DontSend ) );
// Minor Hack to get sound to play differently. Add a look up table
s_bConsumableToolOpeningGift = false;
const CEconTool_Gift *pGiftTool = pItem->GetItemDefinition()->GetTypedEconTool<CEconTool_Gift>();
if ( pGiftTool && pGiftTool->GetTargetRule() == kGiftTargetRule_OnlySelf)
{
s_bConsumableToolOpeningGift = true;
}
}
//-----------------------------------------------------------------------------
// Purpose: Generic Response
//-----------------------------------------------------------------------------
void CEconTool_Xifier::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
ClientConsumableTool_Generic( pItem, pParent );
}
//-----------------------------------------------------------------------------
void CEconTool_ItemEaterRecharger::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
// Tell the GC to consume a charge.
CUseItemConfirmContext *context = new CUseItemConfirmContext( pItem, kServerPlayers_DontSend );
UseItemConfirm( true, context );
}
//-----------------------------------------------------------------------------
// Purpose: Implementation of the local response for someone who used (tried to redeem) a collection
//-----------------------------------------------------------------------------
void CEconTool_PaintCan::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
ClientConsumableTool_Generic( pItem, pParent );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEconTool_Gift::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
ClientConsumableTool_Generic( pItem, pParent );
}
//-----------------------------------------------------------------------------
// Purpose: Implementation of the local response for someone who used (tried to redeem) a collection
//-----------------------------------------------------------------------------
void CEconTool_Default::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
ClientConsumableTool_Generic( pItem, pParent );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
void CEconTool_TFEventEnableHalloween::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
Assert( pItem );
// Tell the GC we want to use this item.
GCSDK::CProtoBufMsg<CMsgGC_Client_UseServerModificationItem> msg( k_EMsgGC_Client_UseServerModificationItem );
msg.Body().set_item_id( pItem->GetItemID() );
GCClientSystem()->BSendMessage( msg );
}
//-----------------------------------------------------------------------------
void CEconTool_DuckToken::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
ClientConsumableTool_Generic( pItem, pParent );
}
//-----------------------------------------------------------------------------
void CEconTool_GrantOperationPass::OnClientUseConsumable( CEconItemView *pItem, vgui::Panel *pParent ) const
{
Assert( pItem );
const CEconTool_GrantOperationPass *pEconToolOperationPass = pItem->GetItemDefinition()->GetTypedEconTool<CEconTool_GrantOperationPass>();
if ( !pEconToolOperationPass )
{
ShowMessageBox( "#TF_UseOperationPassFail_Title", "#TF_UseOperationPassFail_Text", "#GameUI_OK" );
return;
}
// Check that the player doesn't already have an active pass
const char *szPassName = pEconToolOperationPass->m_pOperationPassName;
CEconItemDefinition *pActivePassItemDef = GetItemSchema()->GetItemDefinitionByName( szPassName );
CPlayerInventory *pLocalInv = TFInventoryManager()->GetLocalInventory();
if ( !pLocalInv || !pActivePassItemDef )
{
ShowMessageBox( "#TF_UseOperationPassFail_Title", "#TF_UseOperationPassFail_Text", "#GameUI_OK" );
return;
}
for ( int i = 0; i < pLocalInv->GetItemCount(); ++i )
{
CEconItemView *pItemLocal = pLocalInv->GetItem( i );
Assert( pItemLocal );
if ( pItemLocal->GetItemDefinition() == pActivePassItemDef )
{
ShowMessageBox( "#TF_UseOperationPassAlreadyActive_Title", "#TF_UseOperationPassAlreadyActive_Text", "#GameUI_OK" );
return;
}
}
vgui::surface()->PlaySound( "ui/quest_operation_pass_buy.wav" );
const char *pszTitle = "#TF_UseOperationPass_Title";
const char *pszBody = "#TF_UseOperationPass_Text";
static CSchemaItemDefHandle pItemDef_InvasionPass( "Unused Invasion Pass" );
if ( pItem->GetItemDefinition() == pItemDef_InvasionPass )
{
pszBody = "#TF_UseInvasionPass_Text";
}
// show a confirmation dialog to make sure they want to consume the charge
CTFGenericConfirmDialog *pDialog = ShowConfirmDialog( pszTitle, pszBody,
"#GameUI_OK", "#Cancel",
&OpenPass );
pDialog->AddStringToken( "item_name", pItem->GetItemName() );
wchar_t wszUsesLeft[32];
_snwprintf( wszUsesLeft, ARRAYSIZE( wszUsesLeft ), L"%d", pItem->GetItemQuantity() );
pDialog->AddStringToken( "uses_left", wszUsesLeft );
pDialog->SetContext( new CUseItemConfirmContext( pItem, kServerPlayers_DontSend, "ui/quest_operation_pass_use.wav" ) );
}
//-----------------------------------------------------------------------------
// Purpose:
//-----------------------------------------------------------------------------
class CGCEventEnableResponse : public GCSDK::CGCClientJob
{
public:
CGCEventEnableResponse( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CProtoBufMsg<CMsgGC_Client_UseServerModificationItem_Response> msg( pNetPacket );
switch ( msg.Body().response_code() )
{
case CMsgGC_Client_UseServerModificationItem_Response::kServerModificationItemResponse_AlreadyInUse:
ShowMessageBox( "#TF_ServerEnchantmentType", "#TF_Eternaween__AlreadyInUse", (KeyValues *)NULL );
break;
case CMsgGC_Client_UseServerModificationItem_Response::kServerModificationItemResponse_NotOnAuthenticatedServer:
ShowMessageBox( "#TF_ServerEnchantmentType", "#TF_Eternaween__AuthenticatedServerRequired", (KeyValues *)NULL );
break;
case CMsgGC_Client_UseServerModificationItem_Response::kServerModificationItemResponse_ServerReject:
ShowMessageBox( "#TF_ServerEnchantmentType", "#TF_Eternaween__ServerReject", (KeyValues *)NULL );
break;
case CMsgGC_Client_UseServerModificationItem_Response::kServerModificationItemResponse_InternalError:
ShowMessageBox( "#TF_ServerEnchantmentType", "#TF_Eternaween__InternalError", (KeyValues *)NULL );
break;
case CMsgGC_Client_UseServerModificationItem_Response::kServerModificationItemResponse_EventAlreadyActive:
ShowMessageBox( "#TF_ServerEnchantmentType", "#TF_Eternaween__EventAlreadyActive", (KeyValues *)NULL );
break;
}
return true;
}
};
GC_REG_JOB( GCSDK::CGCClient, CGCEventEnableResponse, "CGCEventEnableResponse", k_EMsgGC_Client_UseServerModificationItem_Response, GCSDK::k_EServerTypeGCClient );
// invoked when the local player attempts to consume the given item
void UseConsumableItem( CEconItemView *pItem, vgui::Panel *pParent )
{
Assert( pItem );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
const GameItemDefinition_t *pItemDef = pItem->GetStaticData();
Assert( pItemDef );
bool bUsableOutOfGame = (pItemDef->GetCapabilities() & ITEM_CAP_USABLE_OUT_OF_GAME) != 0;
// if we aren't useable outside of the game then make sure that we're in a game and that
// we have a local player we can use
if ( !bUsableOutOfGame )
{
if ( !engine->IsInGame() )
{
ShowMessageBox( "#TF_UseFail_NotInGame_Title", "#TF_UseFail_NotInGame", "#GameUI_OK" );
return;
}
if ( pLocalPlayer == NULL )
return;
}
// make sure this item meets our baseline useable criteria
if ( pItem->GetItemQuantity() <= 0 )
return;
if ( !IsGCUseableItem( pItemDef ) )
return;
const IEconTool *pEconTool = pItemDef->GetEconTool();
if ( !pEconTool )
return;
// do whatever client work needs to be done, send a request to the GC to use the item, etc.
pEconTool->OnClientUseConsumable( pItem, pParent );
}
// Called from the trade dialog when the player selects a target user ID.
void UseGift( CEconItemView* pItem, CSteamID targetID )
{
// Validate pItem...
if ( !pItem )
return;
const GameItemDefinition_t *pItemDef = pItem->GetItemDefinition();
if ( !pItemDef )
return;
if ( !IsGCUseableItem( pItemDef ) )
return;
if ( !pItemDef->GetTypedEconTool<CEconTool_WrappedGift>() )
return;
GCSDK::CGCMsg< MsgGCDeliverGift_t > msg( k_EMsgGCDeliverGift );
msg.Body().m_unGiftID = pItem->GetItemID();
msg.Body().m_ulTargetSteamID = targetID.ConvertToUint64();
GCClientSystem()->BSendMessage( msg );
CSteamID steamID = steamapicontext->SteamUser()->GetSteamID();
C_CTF_GameStats.Event_Trading( IE_TRADING_ITEM_GIFTED, pItem, true,
steamID.ConvertToUint64(), targetID.ConvertToUint64() );
}
class CDeliverGiftSelectDialog : public CSelectPlayerDialog
{
public:
CDeliverGiftSelectDialog( vgui::Panel *parent );
virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
void SetItem( CEconItemView* pItem ) { m_pItem = pItem; }
virtual bool AllowOutOfGameFriends() { return true; }
virtual void OnSelectPlayer( const CSteamID &steamID )
{
UseGift( m_pItem, steamID );
}
private:
CEconItemView* m_pItem;
};
CDeliverGiftSelectDialog::CDeliverGiftSelectDialog( vgui::Panel *parent )
: CSelectPlayerDialog( parent )
{
}
void CDeliverGiftSelectDialog::ApplySchemeSettings( vgui::IScheme *pScheme )
{
CSelectPlayerDialog::ApplySchemeSettings( pScheme );
SetDialogVariable( "title", g_pVGuiLocalize->Find( "TF_DeliverGiftDialog_Title" ) );
}
static vgui::DHANDLE<CDeliverGiftSelectDialog> g_hDeliverGiftDialog;
CDeliverGiftSelectDialog *OpenDeliverGiftDialog( vgui::Panel *pParent, CEconItemView *pItem )
{
if (!g_hDeliverGiftDialog.Get())
{
g_hDeliverGiftDialog = vgui::SETUP_PANEL( new CDeliverGiftSelectDialog( pParent ) );
}
g_hDeliverGiftDialog->InvalidateLayout( false, true );
g_hDeliverGiftDialog->Reset();
g_hDeliverGiftDialog->SetVisible( true );
g_hDeliverGiftDialog->MakePopup();
g_hDeliverGiftDialog->MoveToFront();
g_hDeliverGiftDialog->SetKeyBoardInputEnabled(true);
g_hDeliverGiftDialog->SetMouseInputEnabled(true);
g_hDeliverGiftDialog->SetItem( pItem );
TFModalStack()->PushModal( g_hDeliverGiftDialog );
return g_hDeliverGiftDialog;
}
// This is the command the user will execute.
// We want this to happen on the client, before forwarding to the game server, since we don't trust
// the game server.
static bool g_bUsedGCItem = false;
static void StartUseActionSlotItem( const CCommand &args )
{
if ( !engine->IsInGame() )
{
return;
}
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer == NULL )
{
return;
}
pLocalPlayer->SetUsingActionSlot( true );
// Ghosts cant use action items!
if ( pLocalPlayer->m_Shared.InCond( TF_COND_HALLOWEEN_GHOST_MODE ) )
{
return;
}
// If we're in Mann Vs MAchine, and we're dead, we can use this to respawn instantly.
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() && pLocalPlayer->IsObserver() )
{
float flNextRespawn = TFGameRules()->GetNextRespawnWave( pLocalPlayer->GetTeamNumber(), pLocalPlayer );
if ( flNextRespawn )
{
int iRespawnWait = (flNextRespawn - gpGlobals->curtime);
if ( iRespawnWait > 1.0 )
{
engine->ClientCmd_Unrestricted( "td_buyback\n" );
return;
}
}
}
// trying to pick up a dropped weapon?
if ( pLocalPlayer->GetDroppedWeaponInRange() != NULL )
{
KeyValues *kv = new KeyValues( "+use_action_slot_item_server" );
engine->ServerCmdKeyValues( kv );
return;
}
if ( TFGameRules() && TFGameRules()->IsUsingGrapplingHook() )
{
CTFGrapplingHook *pGrapplingHook = dynamic_cast< CTFGrapplingHook* >( pLocalPlayer->GetEntityForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
if ( pGrapplingHook )
{
if ( pLocalPlayer->GetActiveTFWeapon() != pGrapplingHook )
{
pLocalPlayer->Weapon_Switch( pGrapplingHook );
}
KeyValues *kv = new KeyValues( "+use_action_slot_item_server" );
engine->ServerCmdKeyValues( kv );
return;
}
}
// send a request to the GC to use the item
g_bUsedGCItem = false;
CEconItemView *pItem = CTFPlayerSharedUtils::GetEconItemViewByLoadoutSlot( pLocalPlayer, LOADOUT_POSITION_ACTION );
if( pItem )
{
const IEconTool *pEconTool = pItem->GetItemDefinition()->GetEconTool();
bool bIsRecharger = ( pEconTool && FStrEq( pEconTool->GetTypeName(), "item_eater_recharger" ) );
if ( IsGCUseableItem( pItem->GetItemDefinition() ) && pItem->GetItemQuantity() >= 1 && !bIsRecharger )
{
UseConsumableItem( pItem, NULL );
g_bUsedGCItem = true;
}
}
// otherwise, forward to game server
if ( !g_bUsedGCItem )
{
KeyValues *kv = new KeyValues( "+use_action_slot_item_server" );
engine->ServerCmdKeyValues( kv );
}
}
static ConCommand start_use_action_slot_item( "+use_action_slot_item", StartUseActionSlotItem, "Use the item in the action slot." );
static void EndUseActionSlotItem( const CCommand &args )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( !pLocalPlayer )
return;
pLocalPlayer->SetUsingActionSlot( false );
if ( TFGameRules() && TFGameRules()->IsUsingGrapplingHook() && pLocalPlayer->GetActiveTFWeapon() )
{
// if we're using the hook, switch back to the last weapon
if ( pLocalPlayer->GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_GRAPPLINGHOOK )
{
KeyValues *kv = new KeyValues( "-use_action_slot_item_server" );
engine->ServerCmdKeyValues( kv );
C_BaseCombatWeapon* pLastWeapon = pLocalPlayer->GetLastWeapon();
// switch away from the hook
if ( pLastWeapon && pLocalPlayer->Weapon_CanSwitchTo( pLastWeapon ) )
{
pLocalPlayer->Weapon_Switch( pLastWeapon );
}
else
{
// in case we failed to switch back to last weapon for some reason, just find the next best
pLocalPlayer->SwitchToNextBestWeapon( pLastWeapon );
}
return;
}
}
// tell the game server we let go of the button if this wasn't a GC item
if ( !g_bUsedGCItem )
{
KeyValues *kv = new KeyValues( "-use_action_slot_item_server" );
engine->ServerCmdKeyValues( kv );
}
}
static ConCommand end_use_action_slot_item( "-use_action_slot_item", EndUseActionSlotItem );
static void StartContextAction( const CCommand &args )
{
// Assume we're going to taunt
bool bDoTaunt = true;
if ( TFGameRules() && TFGameRules()->IsMannVsMachineMode() )
{
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer )
{
CTFPowerupBottle *pPowerupBottle = dynamic_cast< CTFPowerupBottle* >( pLocalPlayer->GetEquippedWearableForLoadoutSlot( LOADOUT_POSITION_ACTION ) );
if ( pPowerupBottle && pPowerupBottle->GetNumCharges() > 0 )
{
// They're in MvM and have a bottle with a charge, so do an action instead
bDoTaunt = false;
}
if ( pLocalPlayer->IsPlayerClass( TF_CLASS_HEAVYWEAPONS ) && pLocalPlayer->GetActiveTFWeapon() && pLocalPlayer->GetActiveTFWeapon()->GetWeaponID() == TF_WEAPON_MINIGUN )
{
int iRage = 0;
CALL_ATTRIB_HOOK_INT_ON_OTHER( pLocalPlayer, iRage, generate_rage_on_dmg );
if ( iRage )
{
if ( pLocalPlayer->m_Shared.GetRageMeter() >= 100.f && !pLocalPlayer->m_Shared.IsRageDraining() )
{
// They have rage ready to go, do the taunt
bDoTaunt = true;
}
}
}
}
}
if ( bDoTaunt )
{
// Taunt
engine->ClientCmd_Unrestricted( "+taunt\n" );
}
else
{
// Action item
StartUseActionSlotItem( args );
}
}
static ConCommand start_context_action( "+context_action", StartContextAction, "Use the item in the action slot." );
static void EndContextAction( const CCommand &args )
{
// Undo both to be on the safe side
EndUseActionSlotItem( args );
engine->ClientCmd_Unrestricted( "-taunt\n" );
}
static ConCommand end_context_action( "-context_action", EndContextAction );
//-----------------------------------------------------------------------------
class CTFGiftNotification : public CEconNotification
{
public:
CTFGiftNotification( GCSDK::CProtoBufMsg<CMsgGCGiftedItems> &msg )
: CEconNotification()
{
const EUniverse eUniverse = GetUniverse();
Assert( msg.Body().recipient_account_ids_size() > 0 );
SetLifetime( 30.0f );
m_bRandomPerson = msg.Body().has_was_random_person()
&& msg.Body().was_random_person();
const CSteamID gifterSteamID( msg.Body().gifter_steam_id(), eUniverse, k_EAccountTypeIndividual );
SetSteamID( gifterSteamID );
if ( m_bRandomPerson )
{
const CSteamID recipientSteamID( msg.Body().recipient_account_ids(0), eUniverse, k_EAccountTypeIndividual );
if ( msg.Body().recipient_account_ids_size() > 0 )
{
// This might not really be a random gift but might instead be a gift they opened
// themselves (ie., a shipment box).
if ( recipientSteamID == gifterSteamID )
{
SetText( "#TF_GifterText_SelfOpen" );
}
else
{
SetText( "#TF_GifterText_Random" );
char szRecipientName[ MAX_PLAYER_NAME_LENGTH ];
GetPlayerNameBySteamID( recipientSteamID, szRecipientName, sizeof( szRecipientName ) );
g_pVGuiLocalize->ConvertANSIToUnicode( szRecipientName, m_wszPlayerName, sizeof( m_wszPlayerName ) );
AddStringToken( "recipient", m_wszPlayerName );
m_vecSteamIDRecipients.AddToTail( recipientSteamID );
}
}
}
else
{
SetText( "#TF_GifterText_All" );
for ( int i = 0; i < msg.Body().recipient_account_ids_size(); ++i )
{
const CSteamID recipientSteamID( msg.Body().recipient_account_ids(i), eUniverse, k_EAccountTypeIndividual );
m_vecSteamIDRecipients.AddToTail( recipientSteamID );
}
}
char szGifterName[ MAX_PLAYER_NAME_LENGTH ];
GetPlayerNameBySteamID( m_steamID, szGifterName, sizeof( szGifterName ) );
g_pVGuiLocalize->ConvertANSIToUnicode( szGifterName, m_wszPlayerName, sizeof( m_wszPlayerName ) );
AddStringToken( "giver", m_wszPlayerName );
PrintToChatLog();
SetSoundFilename( "misc/happy_birthday.wav" );
}
void PrintToChatLog()
{
CBaseHudChat *pHUDChat = (CBaseHudChat *)GET_HUDELEMENT( CHudChat );
if ( pHUDChat )
{
wchar_t *pFormat = g_pVGuiLocalize->Find( "TF_GiftedItems" );
if ( pFormat == NULL )
{
return;
}
FOR_EACH_VEC( m_vecSteamIDRecipients, i )
{
const CSteamID &steamIDRecipient = m_vecSteamIDRecipients[i];
char szRecipientName[ MAX_PLAYER_NAME_LENGTH ];
szRecipientName[0] = '\0';
GetPlayerNameBySteamID( steamIDRecipient, szRecipientName, sizeof( szRecipientName ) );
if ( szRecipientName[0] == '\0' )
{
continue;
}
wchar_t wszRecipientName[MAX_PLAYER_NAME_LENGTH];
g_pVGuiLocalize->ConvertANSIToUnicode( szRecipientName, wszRecipientName, sizeof( wszRecipientName ) );
wchar_t wszNotification[1024]=L"";
g_pVGuiLocalize->ConstructString_safe( wszNotification,
pFormat,
2, m_wszPlayerName, wszRecipientName );
char szAnsi[1024];
g_pVGuiLocalize->ConvertUnicodeToANSI( wszNotification, szAnsi, sizeof(szAnsi) );
pHUDChat->Printf( CHAT_FILTER_NONE, "%s", szAnsi );
}
}
}
virtual EType NotificationType() { return eType_Basic; }
wchar_t m_wszPlayerName[ MAX_PLAYER_NAME_LENGTH ];
bool m_bRandomPerson;
CUtlVector< CSteamID > m_vecSteamIDRecipients;
};
//#ifdef _DEBUG
//CON_COMMAND( cl_gifts_test, "tests the gift ui." )
//{
// if ( !engine->IsInGame() )
// {
// return;
// }
//
// C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
// if ( pLocalPlayer == NULL )
// {
// return;
// }
//
// if ( steamapicontext == NULL || steamapicontext->SteamUser() == NULL )
// {
// return;
// }
//
// CSteamID steamID = steamapicontext->SteamUser()->GetSteamID();
// GCSDK::CProtoBufMsg< CMsgGCGiftedItems > msg( k_EMsgGCGiftedItems );
// msg.Body().m_ulGifterSteamID = steamID.ConvertToUint64();
// msg.Body().m_bRandomPerson = ( args.ArgC() >= 2 );
// msg.Body().m_unNumGiftRecipients = msg.Body().m_bRandomPerson ? 1 : 31;
// for ( int i = 0; i < msg.Body().m_unNumGiftRecipients; ++i )
// {
// msg.AddUint64Data( steamID.ConvertToUint64() );
// }
// msg.ResetReadPtr();
// NotificationQueue_Add( new CTFGiftNotification( msg ) );
//}
//#endif
//-----------------------------------------------------------------------------
// Purpose: Feedback to the local player who used an item
//-----------------------------------------------------------------------------
class CTFUseItemNotification : public CEconNotification
{
public:
CTFUseItemNotification( EGCMsgUseItemResponse eResponse)
: CEconNotification()
{
switch ( eResponse )
{
case k_EGCMsgUseItemResponse_ItemUsed:
SetText( "#TF_UseItem_Success" );
break;
case k_EGCMsgUseItemResponse_GiftNoOtherPlayers:
SetText( "#TF_UseItem_GiftNoPlayers" );
break;
case k_EGCMsgUseItemResponse_ServerError:
SetText( "#TF_UseItem_Error" );
break;
case k_EGCMsgUseItemResponse_MiniGameAlreadyStarted:
SetText( "#TF_UseItem_MiniGameAlreadyStarted" );
break;
case k_EGCMsgUseItemResponse_CannotBeUsedByAccount:
SetText( "#TF_UseItem_CannotBeUsedByAccount" );
break;
default:
Assert( !"Unknown response in CTFUseItemNotification!" );
}
SetLifetime( 20.0f );
}
virtual EType NotificationType() { return eType_Basic; }
};
//-----------------------------------------------------------------------------
// Purpose: Local player used an item and the GC responded with the status of that request
//-----------------------------------------------------------------------------
class CGCUseItemResponse : public GCSDK::CGCClientJob
{
public:
CGCUseItemResponse( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CGCMsg<MsgGCUseItemResponse_t> msg( pNetPacket );
EGCMsgUseItemResponse eResponse = (EGCMsgUseItemResponse)msg.Body().m_eResponse;
if ( eResponse == k_EGCMsgUseItemResponse_ItemUsed_ItemsGranted )
{
if ( s_bConsumableToolOpeningGift )
{
vgui::surface()->PlaySound( "ui/item_gift_wrap_unwrap.wav" );
}
else
{
vgui::surface()->PlaySound( "ui/item_open_crate.wav" );
}
ShowWaitingDialog( new CWaitForPackageDialog( NULL ), "#ToolDecodeInProgress", true, false, 5.0f );
}
else if ( eResponse != k_EGCMsgUseItemResponse_ItemUsed )
{
NotificationQueue_Add( new CTFUseItemNotification( (EGCMsgUseItemResponse)msg.Body().m_eResponse ) );
}
else
{
// refresh the backpack
if ( EconUI()->GetBackpackPanel() )
{
EconUI()->GetBackpackPanel()->UpdateModelPanels();
}
}
return true;
}
};
GC_REG_JOB( GCSDK::CGCClient, CGCUseItemResponse, "CGCUseItemResponse", k_EMsgGCUseItemResponse, GCSDK::k_EServerTypeGCClient );
//-----------------------------------------------------------------------------
// Purpose: A player has gifted items
//-----------------------------------------------------------------------------
class CGCGiftedItems : public GCSDK::CGCClientJob
{
public:
CGCGiftedItems( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CProtoBufMsg<CMsgGCGiftedItems> msg( pNetPacket );
if ( steamapicontext == NULL || steamapicontext->SteamFriends() == NULL )
{
return true;
}
char szGifterName[ MAX_PLAYER_NAME_LENGTH ];
szGifterName[0] = '\0';
GetPlayerNameBySteamID( CSteamID( msg.Body().gifter_steam_id(), GetUniverse(), k_EAccountTypeIndividual ), szGifterName, sizeof( szGifterName ) );
if ( szGifterName[0] == '\0' )
{
return true;
}
// notify UI
NotificationQueue_Add( new CTFGiftNotification( msg ) );
return true;
}
};
GC_REG_JOB( GCSDK::CGCClient, CGCGiftedItems, "CGCGiftedItems", k_EMsgGCGiftedItems, GCSDK::k_EServerTypeGCClient );
//-----------------------------------------------------------------------------
// Purpose: A player has used a claim code item
//-----------------------------------------------------------------------------
class CGCUsedClaimCodeItem : public GCSDK::CGCClientJob
{
public:
CGCUsedClaimCodeItem( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CGCMsg<MsgGCUsedClaimCodeItem_t> msg( pNetPacket );
if ( steamapicontext == NULL )
{
return true;
}
CUtlString url;
if ( msg.BReadStr( &url ) )
{
steamapicontext->SteamFriends()->ActivateGameOverlayToWebPage( url.Get() );
IViewPortPanel *pMMOverride = ( gViewPortInterface->FindPanelByName( PANEL_MAINMENUOVERRIDE ) );
if ( pMMOverride )
{
((CHudMainMenuOverride*)pMMOverride)->UpdatePromotionalCodes();
}
}
return true;
}
};
GC_REG_JOB( GCSDK::CGCClient, CGCUsedClaimCodeItem, "CGCUsedClaimCodeItem", k_EMsgGCUsedClaimCodeItem, GCSDK::k_EServerTypeGCClient );
//-----------------------------------------------------------------------------
// Duel mini-game
//-----------------------------------------------------------------------------
class CDuelMiniGameEventListener;
struct duel_minigame_local_data_t
{
duel_minigame_local_data_t()
: m_pEventListener( NULL )
, m_steamIDOpponent()
, m_unMyScore( 0 )
, m_unOpponentScore( 0 )
, m_iRequiredPlayerClass( TF_CLASS_UNDEFINED )
{
}
uint32 m_unMyScore;
uint32 m_unOpponentScore;
int m_iRequiredPlayerClass;
CDuelMiniGameEventListener *m_pEventListener;
CSteamID m_steamIDOpponent;
};
static duel_minigame_local_data_t gDuelMiniGameLocalData;
bool DuelMiniGame_IsDueling()
{
return gDuelMiniGameLocalData.m_steamIDOpponent != CSteamID();
}
int DuelMiniGame_GetRequiredPlayerClass()
{
return gDuelMiniGameLocalData.m_steamIDOpponent != CSteamID() ? gDuelMiniGameLocalData.m_iRequiredPlayerClass : TF_CLASS_UNDEFINED;
}
static void DuelMiniGame_Reset();
static bool RemoveRelatedDuelNotifications( CEconNotification* pNotification );
/**
* Duel info notification
*/
class CTFDuelInfoNotification : public CEconNotification
{
public:
CTFDuelInfoNotification()
{
}
static bool IsDuelInfoNotification( CEconNotification *pNotification )
{
return dynamic_cast< CTFDuelInfoNotification* >( pNotification ) != NULL;
}
};
/**
* Duel Notification
*/
class CTFDuelRequestNotification : public CEconNotification, public CGameEventListener
{
public:
CTFDuelRequestNotification( const char *pInitiatorName, const CSteamID &steamIDInitiator, const CSteamID &steamIDTarget, const int iRequiredPlayerClass )
: CEconNotification()
, m_steamIDInitiator( steamIDInitiator )
, m_steamIDTarget( steamIDTarget )
, m_iRequiredPlayerClass( iRequiredPlayerClass )
{
g_pVGuiLocalize->ConvertANSIToUnicode( pInitiatorName, m_wszPlayerName, sizeof(m_wszPlayerName) );
ListenForGameEvent( "teamplay_round_win" );
ListenForGameEvent( "teamplay_round_stalemate" );
}
virtual EType NotificationType()
{
CSteamID localSteamID;
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer && pLocalPlayer->GetSteamID( &localSteamID ) && localSteamID == m_steamIDTarget )
{
return eType_AcceptDecline;
}
return eType_Basic;
}
// XXX(JohnS): Is there something that manually calls trigger here or is this dead code?
virtual void Trigger()
{
CTFGenericConfirmDialog *pDialog = ShowConfirmDialog( "#TF_Duel_Title", "#TF_Duel_Request", "#GameUI_OK", "#TF_Duel_JoinCancel", &ConfirmDuel );
pDialog->SetContext( this );
pDialog->AddStringToken( "initiator", m_wszPlayerName );
// so we aren't deleted
SetIsInUse( true );
}
virtual void Accept()
{
ConfirmDuel( true, this );
}
virtual void Decline()
{
ConfirmDuel( false, this );
}
static bool IsDuelRequestNotification( CEconNotification *pNotification )
{
return dynamic_cast< CTFDuelRequestNotification* >( pNotification ) != NULL;
}
static void ConfirmDuel( bool bConfirmed, void *pContext )
{
CTFDuelRequestNotification *pNotification = (CTFDuelRequestNotification*)pContext;
// if this is a class restricted duel, then make sure the local player is the same class before
// they can accept
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( bConfirmed && pLocalPlayer && pNotification->m_iRequiredPlayerClass != TF_CLASS_UNDEFINED )
{
int iClass = pLocalPlayer->m_Shared.GetDesiredPlayerClassIndex();
if ( pNotification->m_iRequiredPlayerClass != iClass )
{
KeyValues *pKeyValues = new KeyValues( "DuelConfirm" );
switch ( pNotification->m_iRequiredPlayerClass )
{
case TF_CLASS_SCOUT: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Scout" ) ); break;
case TF_CLASS_SNIPER: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Sniper" ) ); break;
case TF_CLASS_SOLDIER: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Soldier" ) ); break;
case TF_CLASS_DEMOMAN: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Demoman" ) ); break;
case TF_CLASS_MEDIC: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Medic" ) ); break;
case TF_CLASS_HEAVYWEAPONS: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_HWGuy" ) ); break;
case TF_CLASS_PYRO: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Pyro" ) ); break;
case TF_CLASS_SPY: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Spy" ) ); break;
case TF_CLASS_ENGINEER: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Engineer" ) ); break;
}
ShowMessageBox( "#TF_Duel_Title", "#TF_Duel_WrongClass", pKeyValues, "#GameUI_OK" );
return;
}
}
// notify GC of our choice
GCSDK::CGCMsg< MsgGC_Duel_Response_t > msg( k_EMsgGC_Duel_Response );
msg.Body().m_ulInitiatorSteamID = pNotification->m_steamIDInitiator.ConvertToUint64();
msg.Body().m_ulTargetSteamID = pNotification->m_steamIDTarget.ConvertToUint64();
msg.Body().m_bAccepted = bConfirmed;
GCClientSystem()->BSendMessage( msg );
pNotification->SetIsInUse( false );
pNotification->MarkForDeletion();
// remove all duel notifications if we've accepted
if ( bConfirmed )
{
NotificationQueue_Remove( &RemoveRelatedDuelNotifications );
}
}
void FireGameEvent( IGameEvent *event )
{
const char *pEventName = event->GetName();
if ( FStrEq( "teamplay_round_win", pEventName ) || FStrEq( "teamplay_round_stalemate", pEventName ) )
{
Decline();
return;
}
}
CSteamID m_steamIDInitiator;
CSteamID m_steamIDTarget;
int m_iRequiredPlayerClass;
wchar_t m_wszPlayerName[MAX_PLAYER_NAME_LENGTH];
};
/**
* Listens for duel_status events and adds a notification. Ideally adds to a scoreboard or something...
*/
class CDuelMiniGameEventListener : public CGameEventListener
{
public:
CDuelMiniGameEventListener()
{
ListenForGameEvent( "duel_status" );
ListenForGameEvent( "teamplay_round_win" );
ListenForGameEvent( "teamplay_round_stalemate" );
}
virtual void FireGameEvent( IGameEvent *event )
{
const char *pEventName = event->GetName();
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer == NULL )
{
return;
}
if ( Q_strcmp( "teamplay_round_win", pEventName ) == 0 || Q_strcmp( "teamplay_round_stalemate", pEventName ) == 0 )
{
DuelMiniGame_Reset();
return;
}
else if ( Q_strcmp( "duel_status", pEventName ) == 0 )
{
int iKillerID = engine->GetPlayerForUserID( event->GetInt( "killer" ) );
int iInitiatorID = engine->GetPlayerForUserID( event->GetInt( "initiator" ) );
int iTargetID = engine->GetPlayerForUserID( event->GetInt( "target" ) );
const char *pInitiatorName = ( iInitiatorID > 0 ? g_PR->GetPlayerName( iInitiatorID ) : "" );
wchar_t wszInitiatorName[MAX_PLAYER_NAME_LENGTH] = L"";
g_pVGuiLocalize->ConvertANSIToUnicode( pInitiatorName, wszInitiatorName, sizeof(wszInitiatorName) );
const char *pTargetName = ( iTargetID > 0 ? g_PR->GetPlayerName( iTargetID ) : "" );
wchar_t wszTargetName[MAX_PLAYER_NAME_LENGTH] = L"";
g_pVGuiLocalize->ConvertANSIToUnicode( pTargetName, wszTargetName, sizeof(wszTargetName) );
wchar_t wszInitiatorScore[16];
_snwprintf( wszInitiatorScore, ARRAYSIZE( wszInitiatorScore ), L"%i", event->GetInt( "initiator_score", 0 ) );
wchar_t wszTargetScore[16];
_snwprintf( wszTargetScore, ARRAYSIZE( wszTargetScore ), L"%i", event->GetInt( "target_score", 0 ) );
enum
{
kDuelScoreType_Kill,
kDuelScoreType_Assist,
kMaxDuelScoreTypes,
};
int iScoreType = event->GetInt( "score_type" );
KeyValues *pKeyValues = new KeyValues( "DuelStatus" );
pKeyValues->SetWString( "killer", iKillerID == iInitiatorID ? wszInitiatorName : wszTargetName );
pKeyValues->SetWString( "initiator", wszInitiatorName );
pKeyValues->SetWString( "target", wszTargetName );
pKeyValues->SetWString( "initiator_score", wszInitiatorScore );
pKeyValues->SetWString( "target_score", wszTargetScore );
// if we aren't involved in the duel, don't show the notification
if ( pLocalPlayer->entindex() == iInitiatorID || pLocalPlayer->entindex() == iTargetID )
{
// remove existing duel info notifications
NotificationQueue_Remove( &RemoveRelatedDuelNotifications );
// add new one
CTFDuelInfoNotification *pNotification = new CTFDuelInfoNotification();
pNotification->SetLifetime( 10.0f );
pNotification->SetText( iScoreType == kDuelScoreType_Kill ? "TF_Duel_StatusKill" : "TF_Duel_StatusAssist" );
pNotification->SetKeyValues( pKeyValues );
pNotification->SetSoundFilename( "ui/duel_event.wav" );
player_info_t pi;
if ( engine->GetPlayerInfo( iKillerID, &pi ) && pi.friendsID != 0 )
{
CSteamID steamID( pi.friendsID, 1, GetUniverse(), k_EAccountTypeIndividual );
pNotification->SetSteamID( steamID );
}
NotificationQueue_Add( pNotification );
if ( pLocalPlayer->entindex() == iInitiatorID )
{
gDuelMiniGameLocalData.m_unMyScore = event->GetInt( "initiator_score" );
gDuelMiniGameLocalData.m_unOpponentScore = event->GetInt( "target_score" );
}
else
{
gDuelMiniGameLocalData.m_unMyScore = event->GetInt( "target_score" );
gDuelMiniGameLocalData.m_unOpponentScore = event->GetInt( "initiator_score" );
}
}
// print to chat log
PrintTextToChat( iScoreType == kDuelScoreType_Kill ? "TF_Duel_StatusForChat_Kill" : "TF_Duel_StatusForChat_Assist", pKeyValues );
// cleanup
pKeyValues->deleteThis();
}
}
};
/**
* Duel request
*/
class CGC_Duel_Request : public GCSDK::CGCClientJob
{
public:
CGC_Duel_Request( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CGCMsg<MsgGC_Duel_Request_t> msg( pNetPacket );
CSteamID localSteamID;
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer == NULL || pLocalPlayer->GetSteamID( &localSteamID ) == false )
{
return true;
}
// get player names
CSteamID steamIDInitiator( msg.Body().m_ulInitiatorSteamID );
CSteamID steamIDTarget( msg.Body().m_ulTargetSteamID );
// ignore blocked players (we don't want to print out to the console either)
if ( IgnoreRequestFromUser( steamIDInitiator ) || IgnoreRequestFromUser( steamIDTarget ) )
{
GCSDK::CGCMsg< MsgGC_Duel_Response_t > msgGC( k_EMsgGC_Duel_Response );
msgGC.Body().m_ulInitiatorSteamID = steamIDInitiator.ConvertToUint64();
msgGC.Body().m_ulTargetSteamID = steamIDTarget.ConvertToUint64();
msgGC.Body().m_bAccepted = false;
GCClientSystem()->BSendMessage( msgGC );
return true;
}
char szPlayerName_Initiator[ MAX_PLAYER_NAME_LENGTH ];
GetPlayerNameBySteamID( steamIDInitiator, szPlayerName_Initiator, sizeof( szPlayerName_Initiator ) );
char szPlayerName_Target[ MAX_PLAYER_NAME_LENGTH ];
GetPlayerNameBySteamID( steamIDTarget, szPlayerName_Target, sizeof( szPlayerName_Target ) );
wchar_t wszPlayerName_Initiator[MAX_PLAYER_NAME_LENGTH];
wchar_t wszPlayerName_Target[MAX_PLAYER_NAME_LENGTH];
g_pVGuiLocalize->ConvertANSIToUnicode( szPlayerName_Initiator, wszPlayerName_Initiator, sizeof(wszPlayerName_Initiator) );
g_pVGuiLocalize->ConvertANSIToUnicode( szPlayerName_Target, wszPlayerName_Target, sizeof(wszPlayerName_Target) );
// add notification
KeyValues *pKeyValues = new KeyValues( "DuelText" );
pKeyValues->SetWString( "initiator", wszPlayerName_Initiator );
pKeyValues->SetWString( "target", wszPlayerName_Target );
const char *pText = localSteamID == steamIDTarget ? "TF_Duel_Request" : "TF_Duel_Challenge";
const char *pSoundFilename = "ui/duel_challenge.wav";
if ( msg.Body().m_usAsPlayerClass >= TF_FIRST_NORMAL_CLASS && msg.Body().m_usAsPlayerClass < TF_LAST_NORMAL_CLASS )
{
pText = localSteamID == steamIDTarget ? "TF_Duel_Request_Class" : "TF_Duel_Challenge_Class";
pSoundFilename = "ui/duel_challenge_with_restriction.wav";
switch ( msg.Body().m_usAsPlayerClass )
{
case TF_CLASS_SCOUT: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Scout" ) ); break;
case TF_CLASS_SNIPER: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Sniper" ) ); break;
case TF_CLASS_SOLDIER: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Soldier" ) ); break;
case TF_CLASS_DEMOMAN: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Demoman" ) ); break;
case TF_CLASS_MEDIC: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Medic" ) ); break;
case TF_CLASS_HEAVYWEAPONS: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_HWGuy" ) ); break;
case TF_CLASS_PYRO: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Pyro" ) ); break;
case TF_CLASS_SPY: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Spy" ) ); break;
case TF_CLASS_ENGINEER: pKeyValues->SetWString( "player_class", g_pVGuiLocalize->Find( "#TF_Class_Name_Engineer" ) ); break;
}
}
if ( localSteamID == steamIDInitiator || localSteamID == steamIDTarget )
{
CTFDuelRequestNotification *pNotification = new CTFDuelRequestNotification( szPlayerName_Initiator, steamIDInitiator, steamIDTarget, msg.Body().m_usAsPlayerClass );
pNotification->SetLifetime( localSteamID == steamIDTarget ? 30.0f : 7.0f );
pNotification->SetText( pText );
pNotification->SetKeyValues( pKeyValues );
pNotification->SetSteamID( steamIDInitiator );
pNotification->SetSoundFilename( pSoundFilename );
NotificationQueue_Add( pNotification );
}
// print to chat log
PrintTextToChat( pText, pKeyValues );
pKeyValues->deleteThis();
return true;
}
protected:
};
GC_REG_JOB( GCSDK::CGCClient, CGC_Duel_Request, "CGC_Duel_Request", k_EMsgGC_Duel_Request, GCSDK::k_EServerTypeGCClient );
/**
* Duel response
*/
class CGCClient_Duel_Response : public GCSDK::CGCClientJob
{
public:
CGCClient_Duel_Response( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CGCMsg<MsgGC_Duel_Response_t> msg( pNetPacket );
CSteamID localSteamID;
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer == NULL || pLocalPlayer->GetSteamID( &localSteamID ) == false )
return true;
// get player names
CSteamID steamIDInitiator( msg.Body().m_ulInitiatorSteamID );
CSteamID steamIDTarget( msg.Body().m_ulTargetSteamID );
char szPlayerName_Initiator[ MAX_PLAYER_NAME_LENGTH ];
GetPlayerNameBySteamID( steamIDInitiator, szPlayerName_Initiator, sizeof( szPlayerName_Initiator ) );
char szPlayerName_Target[ MAX_PLAYER_NAME_LENGTH ];
GetPlayerNameBySteamID( steamIDTarget, szPlayerName_Target, sizeof( szPlayerName_Target ) );
wchar_t wszPlayerName_Initiator[MAX_PLAYER_NAME_LENGTH];
wchar_t wszPlayerName_Target[MAX_PLAYER_NAME_LENGTH];
g_pVGuiLocalize->ConvertANSIToUnicode( szPlayerName_Initiator, wszPlayerName_Initiator, sizeof(wszPlayerName_Initiator) );
g_pVGuiLocalize->ConvertANSIToUnicode( szPlayerName_Target, wszPlayerName_Target, sizeof(wszPlayerName_Target) );
KeyValues *pKeyValues = new KeyValues( "DuelText" );
pKeyValues->SetWString( "initiator", wszPlayerName_Initiator );
pKeyValues->SetWString( "target", wszPlayerName_Target );
bool bIsClassDuel = msg.Body().m_usAsPlayerClass >= TF_FIRST_NORMAL_CLASS && msg.Body().m_usAsPlayerClass < TF_LAST_NORMAL_CLASS;
// add notification
const char *pText = "TF_Duel_Accept";
const char *pSoundFilename = bIsClassDuel ? "ui/duel_challenge_accepted_with_restriction.wav" : "ui/duel_challenge_accepted.wav";
if ( msg.Body().m_bAccepted == false )
{
const char *kDeclineStrings[] = {
"TF_Duel_Decline",
"TF_Duel_Decline2",
"TF_Duel_Decline3"
};
pText = kDeclineStrings[ RandomInt( 0, ARRAYSIZE( kDeclineStrings ) - 1 ) ];
pSoundFilename = bIsClassDuel ? "ui/duel_challenge_rejected_with_restriction.wav" : "ui/duel_challenge_rejected.wav";
}
if ( ( TFGameRules() && TFGameRules()->CanInitiateDuels() ) || msg.Body().m_bAccepted )
{
if ( localSteamID == steamIDInitiator || localSteamID == steamIDTarget )
{
// remove existing duel info notifications
NotificationQueue_Remove( &RemoveRelatedDuelNotifications );
// add new one
CTFDuelInfoNotification *pNotification = new CTFDuelInfoNotification();
pNotification->SetLifetime( 7.0f );
pNotification->SetText( pText );
pNotification->SetKeyValues( pKeyValues );
pNotification->SetSteamID( steamIDInitiator );
pNotification->SetSoundFilename( pSoundFilename );
NotificationQueue_Add( pNotification );
}
// print to chat
PrintTextToChat( pText, pKeyValues );
}
// store away opponent id and create event listener if applicable
if ( msg.Body().m_bAccepted )
{
if ( localSteamID == steamIDInitiator )
{
gDuelMiniGameLocalData.m_steamIDOpponent = steamIDTarget;
}
else if ( localSteamID == steamIDTarget )
{
gDuelMiniGameLocalData.m_steamIDOpponent = steamIDInitiator;
}
if ( gDuelMiniGameLocalData.m_pEventListener == NULL )
{
gDuelMiniGameLocalData.m_pEventListener = new CDuelMiniGameEventListener();
}
gDuelMiniGameLocalData.m_iRequiredPlayerClass = msg.Body().m_usAsPlayerClass;
}
pKeyValues->deleteThis();
return true;
}
protected:
};
GC_REG_JOB( GCSDK::CGCClient, CGCClient_Duel_Response, "CGCClient_Duel_Response", k_EMsgGC_Duel_Response, GCSDK::k_EServerTypeGCClient );
/**
* Duel status (whether the duel is in progress or cancelled)
*/
class CGC_Duel_Status : public GCSDK::CGCClientJob
{
public:
CGC_Duel_Status( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CGCMsg<MsgGC_Duel_Status_t> msg( pNetPacket );
// get player names
CSteamID steamIDInitiator( msg.Body().m_ulInitiatorSteamID );
CSteamID steamIDTarget( msg.Body().m_ulTargetSteamID );
char szPlayerName_Initiator[ MAX_PLAYER_NAME_LENGTH ];
GetPlayerNameBySteamID( steamIDInitiator, szPlayerName_Initiator, sizeof( szPlayerName_Initiator ) );
char szPlayerName_Target[ MAX_PLAYER_NAME_LENGTH ];
GetPlayerNameBySteamID( steamIDTarget, szPlayerName_Target, sizeof( szPlayerName_Target ) );
wchar_t wszPlayerName_Initiator[MAX_PLAYER_NAME_LENGTH];
wchar_t wszPlayerName_Target[MAX_PLAYER_NAME_LENGTH];
g_pVGuiLocalize->ConvertANSIToUnicode( szPlayerName_Initiator, wszPlayerName_Initiator, sizeof(wszPlayerName_Initiator) );
g_pVGuiLocalize->ConvertANSIToUnicode( szPlayerName_Target, wszPlayerName_Target, sizeof(wszPlayerName_Target) );
// add notification
const char *pText = "TF_Duel_InProgress";
switch ( msg.Body().m_usStatus )
{
case kDuel_Status_AlreadyInDuel_Inititator:
pText = "TF_Duel_InADuel_Initiator";
break;
case kDuel_Status_AlreadyInDuel_Target:
pText = "TF_Duel_InADuel_Target";
break;
case kDuel_Status_DuelBanned_Initiator:
pText = "TF_Duel_TempBanned_Initiator";
break;
case kDuel_Status_DuelBanned_Target:
pText = "TF_Duel_TempBanned_Target";
break;
case kDuel_Status_Cancelled:
pText = "TF_Duel_Cancelled";
break;
case kDuel_Status_MissingSession:
pText = "TF_Duel_UserTemporarilyUnavailable";
break;
default:
AssertMsg1( false, "Unknown duel status %i in CGC_Duel_Status!", msg.Body().m_usStatus );
}
// remove existing duel info notifications
NotificationQueue_Remove( &RemoveRelatedDuelNotifications );
// add new one
CTFDuelInfoNotification *pNotification = new CTFDuelInfoNotification();
pNotification->SetLifetime( 7.0f );
pNotification->SetText( pText );
pNotification->AddStringToken( "initiator", wszPlayerName_Initiator );
pNotification->AddStringToken( "target", wszPlayerName_Target );
pNotification->SetSteamID( steamIDInitiator );
pNotification->SetSoundFilename( "ui/duel_event.wav" );
NotificationQueue_Add( pNotification );
return true;
}
protected:
};
GC_REG_JOB( GCSDK::CGCClient, CGC_Duel_Status, "CGC_Duel_Status", k_EMsgGC_Duel_Status, GCSDK::k_EServerTypeGCClient );
/**
* Duel Results--ideally this is a scoreboard as well.
*/
class CGC_Duel_Results : public GCSDK::CGCClientJob
{
public:
CGC_Duel_Results( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CGCMsg<MsgGC_Duel_Results_t> msg( pNetPacket );
if ( steamapicontext == NULL || steamapicontext->SteamUser() == NULL )
return true;
CSteamID localSteamID = steamapicontext->SteamUser()->GetSteamID();
// get player names
CSteamID steamIDWinner( msg.Body().m_ulWinnerSteamID );
CSteamID steamIDInitiator( msg.Body().m_ulInitiatorSteamID );
CSteamID steamIDTarget( msg.Body().m_ulTargetSteamID );
char szPlayerName_Winner[ MAX_PLAYER_NAME_LENGTH ];
GetPlayerNameBySteamID( steamIDWinner, szPlayerName_Winner, sizeof( szPlayerName_Winner ) );
char szPlayerName_Initiator[ MAX_PLAYER_NAME_LENGTH ];
GetPlayerNameBySteamID( steamIDInitiator, szPlayerName_Initiator, sizeof( szPlayerName_Initiator ) );
char szPlayerName_Target[ MAX_PLAYER_NAME_LENGTH ];
GetPlayerNameBySteamID( steamIDTarget, szPlayerName_Target, sizeof( szPlayerName_Target ) );
wchar_t wszPlayerName_Winner[MAX_PLAYER_NAME_LENGTH];
wchar_t wszPlayerName_Initiator[MAX_PLAYER_NAME_LENGTH];
wchar_t wszPlayerName_Target[MAX_PLAYER_NAME_LENGTH];
g_pVGuiLocalize->ConvertANSIToUnicode( szPlayerName_Winner, wszPlayerName_Winner, sizeof(wszPlayerName_Winner) );
g_pVGuiLocalize->ConvertANSIToUnicode( szPlayerName_Initiator, wszPlayerName_Initiator, sizeof(wszPlayerName_Initiator) );
g_pVGuiLocalize->ConvertANSIToUnicode( szPlayerName_Target, wszPlayerName_Target, sizeof(wszPlayerName_Target) );
// build text
bool bTie = msg.Body().m_usScoreInitiator == msg.Body().m_usScoreTarget;
const char *pText = "TF_Duel_Win";
switch ( msg.Body().m_usEndReason )
{
case kDuelEndReason_DuelOver:
break;
case kDuelEndReason_PlayerDisconnected:
bTie = false;
pText = "TF_Duel_Win_Disconnect";
break;
case kDuelEndReason_PlayerSwappedTeams:
bTie = false;
pText = "TF_Duel_Win_SwappedTeams";
break;
case kDuelEndReason_LevelShutdown:
bTie = true;
pText = "TF_Duel_Refund_LevelShutdown";
break;
case kDuelEndReason_ScoreTiedAtZero:
bTie = true;
pText = "TF_Duel_Refund_ScoreTiedAtZero";
break;
case kDuelEndReason_ScoreTied:
bTie = true;
pText = "TF_Duel_Tie";
break;
case kDuelEndReason_PlayerKicked:
bTie = true;
pText = "TF_Duel_Refund_Kicked";
break;
case kDuelEndReason_PlayerForceSwappedTeams:
bTie = true;
pText = "TF_Duel_Refund_ForceTeamSwap";
break;
case kDuelEndReason_Cancelled:
bTie = true;
pText = "TF_Duel_Cancelled";
break;
}
KeyValues *pKeyValues = new KeyValues( "DuelResults" );
if ( bTie == false )
{
pKeyValues->SetWString( "winner", wszPlayerName_Winner );
pKeyValues->SetWString( "loser", steamIDWinner == steamIDInitiator ? wszPlayerName_Target : wszPlayerName_Initiator );
wchar_t wszScoreInitiator[16];
wchar_t wszScoreTarget[16];
_snwprintf( wszScoreInitiator, ARRAYSIZE( wszScoreInitiator ), L"%u", (uint32)msg.Body().m_usScoreInitiator );
_snwprintf( wszScoreTarget, ARRAYSIZE( wszScoreTarget ), L"%u", (uint32)msg.Body().m_usScoreTarget );
pKeyValues->SetWString( "winner_score", steamIDWinner == steamIDInitiator ? wszScoreInitiator : wszScoreTarget );
pKeyValues->SetWString( "loser_score", steamIDWinner == steamIDInitiator ? wszScoreTarget : wszScoreInitiator );
}
else
{
wchar_t wszScoreInitiator[16];
_snwprintf( wszScoreInitiator, ARRAYSIZE( wszScoreInitiator ), L"%u", (uint32)msg.Body().m_usScoreInitiator );
pKeyValues->SetWString( "score", wszScoreInitiator );
pKeyValues->SetWString( "initiator", wszPlayerName_Initiator );
pKeyValues->SetWString( "target", wszPlayerName_Target );
}
// add notification
if ( localSteamID == steamIDInitiator || localSteamID == steamIDTarget )
{
// remove existing duel info notifications
NotificationQueue_Remove( &RemoveRelatedDuelNotifications );
// add new one
CTFDuelInfoNotification *pNotification = new CTFDuelInfoNotification();
pNotification->SetText( pText );
pNotification->SetKeyValues( pKeyValues );
pNotification->SetSteamID( bTie == false ? steamIDWinner : ( localSteamID == steamIDInitiator ? steamIDTarget : steamIDInitiator ) );
pNotification->SetSoundFilename( "ui/duel_event.wav" );
NotificationQueue_Add( pNotification );
gDuelMiniGameLocalData.m_steamIDOpponent = CSteamID();
}
// print out to chat
PrintTextToChat( pText, pKeyValues );
// cleanup
pKeyValues->deleteThis();
// reset the dueling minigame
DuelMiniGame_Reset();
return true;
}
protected:
};
GC_REG_JOB( GCSDK::CGCClient, CGC_Duel_Results, "CGC_Duel_Results", k_EMsgGC_Duel_Results, GCSDK::k_EServerTypeGCClient );
static bool RemoveRelatedDuelNotifications( CEconNotification *pNotification )
{
return ( CTFDuelRequestNotification::IsDuelRequestNotification( pNotification ) ||
CTFDuelInfoNotification::IsDuelInfoNotification( pNotification ) );
}
static void DuelMiniGame_Reset()
{
delete gDuelMiniGameLocalData.m_pEventListener;
gDuelMiniGameLocalData.m_pEventListener = NULL;
gDuelMiniGameLocalData.m_steamIDOpponent = CSteamID();
gDuelMiniGameLocalData.m_unMyScore = 0;
gDuelMiniGameLocalData.m_unOpponentScore = 0;
gDuelMiniGameLocalData.m_iRequiredPlayerClass = TF_CLASS_UNDEFINED;
}
bool DuelMiniGame_IsDuelingLocalPlayer( C_TFPlayer *pPlayer )
{
CSteamID steamID;
if ( pPlayer->GetSteamID( &steamID ) )
{
return ( steamID == gDuelMiniGameLocalData.m_steamIDOpponent );
}
return false;
}
bool DuelMiniGame_GetStats( C_TFPlayer **ppPlayer, uint32 &unMyScore, uint32 &unOpponentScore )
{
*ppPlayer = NULL;
int iLocalPlayerIndex = GetLocalPlayerIndex();
for( int iPlayerIndex = 1 ; iPlayerIndex <= MAX_PLAYERS; iPlayerIndex++ )
{
// find all players who are on the local player's team
if( ( iPlayerIndex != iLocalPlayerIndex ) && ( g_PR->IsConnected( iPlayerIndex ) ) )
{
CSteamID steamID;
C_TFPlayer *pPlayer = ToTFPlayer( UTIL_PlayerByIndex( iPlayerIndex ) );
if ( pPlayer && pPlayer->GetSteamID( &steamID ) && steamID == gDuelMiniGameLocalData.m_steamIDOpponent )
{
*ppPlayer = pPlayer;
break;
}
}
}
static bool sbTesting = false;
if ( sbTesting )
{
*ppPlayer = ToTFPlayer( C_BasePlayer::GetLocalPlayer() );
}
if ( *ppPlayer != NULL )
{
CSteamID steamID = steamapicontext->SteamUser()->GetSteamID();
unMyScore = gDuelMiniGameLocalData.m_unMyScore;
unOpponentScore = gDuelMiniGameLocalData.m_unOpponentScore;
return true;
}
return false;
}
/**
* Select player for duel dialog.
*/
class CSelectPlayerForDuelDialog : public CSelectPlayerDialog, public CGameEventListener
{
DECLARE_CLASS_SIMPLE( CSelectPlayerForDuelDialog, CSelectPlayerDialog );
public:
CSelectPlayerForDuelDialog( uint64 iItemID );
virtual ~CSelectPlayerForDuelDialog();
virtual void OnSelectPlayer( const CSteamID &steamID );
virtual void ApplySchemeSettings( vgui::IScheme *pScheme );
virtual void FireGameEvent( IGameEvent *event );
MESSAGE_FUNC_PARAMS( OnClassIconSelected, "ClassIconSelected", data );
MESSAGE_FUNC_PARAMS( OnShowClassIconMouseover, "ShowClassIconMouseover", data );
MESSAGE_FUNC( OnHideClassIconMouseover, "HideClassIconMouseover" );
protected:
virtual const char *GetResFile() { return "resource/ui/SelectPlayerDialog_Duel.res"; }
void SetSelectedClass( int iClass );
void SetupClassImage( const char *pImageControlName, int iClass );
uint64 m_iItemID;
uint8 m_iPlayerClass;
vgui::Label *m_pClassIconMouseoverLabel;
};
static vgui::DHANDLE< CSelectPlayerForDuelDialog > g_pSelectPlayerForDuelingDialog;
CSelectPlayerForDuelDialog::CSelectPlayerForDuelDialog( uint64 iItemID )
: CSelectPlayerDialog( NULL )
, m_iItemID( iItemID )
, m_iPlayerClass( TF_CLASS_UNDEFINED )
{
g_pSelectPlayerForDuelingDialog = this;
m_bAllowSameTeam = false;
m_bAllowOutsideServer = false;
m_pClassIconMouseoverLabel = new vgui::Label( this, "ClassUsageMouseoverLabel", "" );
ListenForGameEvent( "teamplay_round_win" );
ListenForGameEvent( "teamplay_round_stalemate" );
}
CSelectPlayerForDuelDialog::~CSelectPlayerForDuelDialog()
{
g_pSelectPlayerForDuelingDialog = NULL;
}
void CSelectPlayerForDuelDialog::OnSelectPlayer( const CSteamID &steamID )
{
GCSDK::CProtoBufMsg<CMsgUseItem> msg( k_EMsgGCUseItemRequest );
msg.Body().set_item_id( m_iItemID );
msg.Body().set_target_steam_id( steamID.ConvertToUint64() );
msg.Body().set_duel__class_lock( m_iPlayerClass );
GCClientSystem()->BSendMessage( msg );
}
void CSelectPlayerForDuelDialog::ApplySchemeSettings( vgui::IScheme *pScheme )
{
CSelectPlayerDialog::ApplySchemeSettings( pScheme );
SetDialogVariable( "title", g_pVGuiLocalize->Find( "TF_DuelDialog_Title" ) );
SetupClassImage( "ClassUsageImage_Any", TF_CLASS_UNDEFINED );
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
SetupClassImage( "ClassUsageImage_Locked", pLocalPlayer->m_Shared.GetDesiredPlayerClassIndex() );
SetSelectedClass( TF_CLASS_UNDEFINED );
}
void CSelectPlayerForDuelDialog::SetupClassImage( const char *pImageControlName, int iClass )
{
CStorePreviewClassIcon *pClassImage = dynamic_cast<CStorePreviewClassIcon*>( FindChildByName( pImageControlName ) );
if ( pClassImage )
{
pClassImage->SetClass( iClass );
}
}
void CSelectPlayerForDuelDialog::FireGameEvent( IGameEvent *event )
{
const char *pEventName = event->GetName();
C_TFPlayer *pLocalPlayer = C_TFPlayer::GetLocalTFPlayer();
if ( pLocalPlayer == NULL )
{
OnCommand( "cancel" );
return;
}
if ( Q_strcmp( "teamplay_round_win", pEventName ) == 0 || Q_strcmp( "teamplay_round_stalemate", pEventName ) == 0 )
{
OnCommand( "cancel" );
return;
}
}
void CSelectPlayerForDuelDialog::OnClassIconSelected( KeyValues *data )
{
int iClass = data->GetInt( "class", 0 );
SetSelectedClass( iClass );
}
void CSelectPlayerForDuelDialog::OnHideClassIconMouseover( void )
{
if ( m_pClassIconMouseoverLabel )
{
m_pClassIconMouseoverLabel->SetVisible( false );
}
}
void CSelectPlayerForDuelDialog::OnShowClassIconMouseover( KeyValues *data )
{
if ( m_pClassIconMouseoverLabel )
{
// Set the text to the correct string
int iClass = data->GetInt( "class", 0 );
if ( iClass >= TF_FIRST_NORMAL_CLASS && iClass < TF_LAST_NORMAL_CLASS )
{
wchar_t wzLocalized[256];
const char *pszLocString = "#TF_SelectPlayer_Duel_PlayerClass";
g_pVGuiLocalize->ConstructString_safe( wzLocalized, g_pVGuiLocalize->Find( pszLocString ), 1, g_pVGuiLocalize->Find( g_aPlayerClassNames[iClass] ) );
m_pClassIconMouseoverLabel->SetText( wzLocalized );
}
else
{
const char *pszLocString = "#TF_SelectPlayer_Duel_AnyClass";
m_pClassIconMouseoverLabel->SetText( pszLocString );
}
m_pClassIconMouseoverLabel->SetVisible( true );
}
}
void CSelectPlayerForDuelDialog::SetSelectedClass( int iClass )
{
m_iPlayerClass = iClass;
const char* pClassName = "#TF_SelectPlayer_DuelClass_None";
switch ( m_iPlayerClass )
{
case TF_CLASS_SCOUT: pClassName = "#TF_Class_Name_Scout"; break;
case TF_CLASS_SNIPER: pClassName = "#TF_Class_Name_Sniper"; break;
case TF_CLASS_SOLDIER: pClassName = "#TF_Class_Name_Soldier"; break;
case TF_CLASS_DEMOMAN: pClassName = "#TF_Class_Name_Demoman"; break;
case TF_CLASS_MEDIC: pClassName = "#TF_Class_Name_Medic"; break;
case TF_CLASS_HEAVYWEAPONS: pClassName = "#TF_Class_Name_HWGuy"; break;
case TF_CLASS_PYRO: pClassName = "#TF_Class_Name_Pyro"; break;
case TF_CLASS_SPY: pClassName = "#TF_Class_Name_Spy"; break;
case TF_CLASS_ENGINEER: pClassName = "#TF_Class_Name_Engineer"; break;
}
wchar_t wszText[1024]=L"";
g_pVGuiLocalize->ConstructString_safe( wszText,
g_pVGuiLocalize->Find( "#TF_SelectPlayer_DuelClass" ),
1,
g_pVGuiLocalize->Find( pClassName ) );
SetDialogVariable( "player_class", wszText );
}
static void ShowSelectDuelTargetDialog( uint64 iItemID )
{
CSelectPlayerForDuelDialog *pDialog = vgui::SETUP_PANEL( new CSelectPlayerForDuelDialog( iItemID ) );
pDialog->InvalidateLayout( false, true );
pDialog->Reset();
pDialog->SetVisible( true );
pDialog->MakePopup();
pDialog->MoveToFront();
pDialog->SetKeyBoardInputEnabled(true);
pDialog->SetMouseInputEnabled(true);
TFModalStack()->PushModal( pDialog );
}
//-----------------------------------------------------------------------------
void CL_Consumables_LevelShutdown()
{
DuelMiniGame_Reset();
if ( g_pSelectPlayerForDuelingDialog )
{
g_pSelectPlayerForDuelingDialog->OnCommand( "cancel" );
}
NotificationQueue_Remove( &CTFDuelRequestNotification::IsDuelRequestNotification );
}
//
// Players see this whenever a person on their server uses a name tool
//
class CTFNameItemNotification : public GCSDK::CGCClientJob
{
public:
CTFNameItemNotification( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CProtoBufMsg<CMsgGCNameItemNotification> msg( pNetPacket );
if ( steamapicontext == NULL || steamapicontext->SteamUser() == NULL )
return true;
if ( !engine->IsInGame() )
return true;
CBaseHudChat *pHUDChat = (CBaseHudChat *)GET_HUDELEMENT( CHudChat );
if ( pHUDChat )
{
// Player
wchar_t wszPlayerName[MAX_PLAYER_NAME_LENGTH];
char szPlayerName[ MAX_PLAYER_NAME_LENGTH ];
GetPlayerNameBySteamID( msg.Body().player_steamid(), szPlayerName, sizeof( szPlayerName ) );
g_pVGuiLocalize->ConvertANSIToUnicode( szPlayerName, wszPlayerName, sizeof( wszPlayerName ) );
// Item
item_definition_index_t nDefIndex = msg.Body().item_def_index();
const GameItemDefinition_t *pItemDefinition = dynamic_cast<GameItemDefinition_t *>( GetItemSchema()->GetItemDefinition( nDefIndex ) );
if ( !pItemDefinition )
return true;
entityquality_t iItemQuality = pItemDefinition->GetQuality();
// Name
wchar_t wszCustomName[MAX_ITEM_CUSTOM_NAME_LENGTH];
g_pVGuiLocalize->ConvertANSIToUnicode( msg.Body().item_name_custom().c_str(), wszCustomName, sizeof( wszCustomName ) );
wchar_t wszItemRenamed[256];
_snwprintf( wszItemRenamed, ARRAYSIZE( wszItemRenamed ), L"%ls", g_pVGuiLocalize->Find( "#Item_Named" ) );
const char *pszQualityColorString = EconQuality_GetColorString( (EEconItemQuality)iItemQuality );
if ( pszQualityColorString )
{
pHUDChat->SetCustomColor( pszQualityColorString );
}
wchar_t wszLocalizedString[256];
g_pVGuiLocalize->ConstructString_safe( wszLocalizedString, wszItemRenamed, 3, wszPlayerName, CEconItemLocalizedFullNameGenerator( GLocalizationProvider(), pItemDefinition, iItemQuality ).GetFullName(), wszCustomName );
char szLocalized[256];
g_pVGuiLocalize->ConvertUnicodeToANSI( wszLocalizedString, szLocalized, sizeof( szLocalized ) );
pHUDChat->ChatPrintf( 0, CHAT_FILTER_SERVERMSG, "%s", szLocalized );
}
return true;
}
};
GC_REG_JOB( GCSDK::CGCClient, CTFNameItemNotification, "CTFNameItemNotification", k_EMsgGCNameItemNotification, GCSDK::k_EServerTypeGCClient );
//
// A wrapper for a generic message sent down from the GC to clients. The clients do localization
// and layout.
//
class CClientDisplayNotification : public CEconNotification
{
public:
CClientDisplayNotification( GCSDK::IMsgNetPacket *pNetPacket )
: m_msg( pNetPacket )
{
SetText( m_msg.Body().notification_body_localization_key().c_str() );
SetLifetime( 23.0f );
if ( m_msg.Body().body_substring_keys_size() == m_msg.Body().body_substring_values_size() )
{
for ( int i = 0; i < m_msg.Body().body_substring_keys_size(); i++ )
{
const char *pszSubstringKey = m_msg.Body().body_substring_keys( i ).c_str();
const char *pszSubstringValue = m_msg.Body().body_substring_values( i ).c_str();
if ( pszSubstringValue[0] == '#' )
{
AddStringToken( pszSubstringKey, GLocalizationProvider()->Find( pszSubstringValue ) );
}
else
{
CUtlConstWideString wsSubstringValue;
GLocalizationProvider()->ConvertUTF8ToLocchar( pszSubstringValue, &wsSubstringValue ) ;
AddStringToken( pszSubstringKey, wsSubstringValue.Get() );
}
}
}
}
private:
// We make a local copy of the full message because dynamic-length strings are sent down from the
// GC and we need to make sure they stay in memory until the user looks at the notification.
GCSDK::CProtoBufMsg<CMsgGCClientDisplayNotification> m_msg;
};
class CTFClientDisplayNotification : public GCSDK::CGCClientJob
{
public:
CTFClientDisplayNotification( GCSDK::CGCClient *pClient ) : GCSDK::CGCClientJob( pClient ) {}
virtual bool BYieldingRunGCJob( GCSDK::IMsgNetPacket *pNetPacket )
{
GCSDK::CProtoBufMsg<CMsgGCClientDisplayNotification> msg( pNetPacket );
if ( steamapicontext == NULL || steamapicontext->SteamUser() == NULL )
return true;
NotificationQueue_Add( new CClientDisplayNotification( pNetPacket ) );
return true;
}
};
GC_REG_JOB( GCSDK::CGCClient, CTFClientDisplayNotification, "CTFClientDisplayNotification", k_EMsgGCClientDisplayNotification, GCSDK::k_EServerTypeGCClient );
Reference in New Issue View Git Blame Copy Permalink