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.
82 Commits
25 Branches
6 Tags
221 MiB
 
 
 
 
 
 
Tree: 81b976c384
Branches Tags
${ item.name }
Create tag ${ searchTerm }
Create branch ${ searchTerm }
from '81b976c384'
${ noResults }
source-engine/game/client/tf/tf_presence.cpp

531 lines
16 KiB
Raw Blame History

//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: Rich Presence support.
// HACK: This file has also become the client wing of matchmaking. Matchmaking should
// be re-factored to make a more complete client/server/engine interface
//
//=====================================================================================//
#include "cbase.h"
#include "tf_presence.h"
#include "c_team_objectiveresource.h"
#include "tf_gamerules.h"
#include "c_tf_team.h"
#include "c_tf_playerresource.h"
#include "engine/imatchmaking.h"
#include "ixboxsystem.h"
// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"
// Global singleton
static CTF_Presence s_presence;
struct s_MapName
{
const char *pDiskName;
const char *pDisplayName;
};
// This array must match the define order in hl2orange.spa.h
static s_MapName s_Scenarios[] = {
{ "ctf_2fort", "2Fort" },
{ "cp_dustbowl", "Dustbowl" },
{ "cp_granary", "Granary" },
{ "cp_well", "Well" },
{ "cp_gravelpit", "Gravel Pit" },
{ "tc_hydro", "Hydro" },
{ "cloak", "Cloak (CTF)" },
{ "cp_cloak", "Cloak (CP)" },
};
struct s_PresenceTranslation
{
uint id;
const char *pString;
};
// Only presence IDs can be searched by id number, because they're guaranteed to be unique
static s_PresenceTranslation s_PresenceIds[] = {
{ CONTEXT_SCENARIO, "CONTEXT_SCENARIO" },
{ PROPERTY_CAPS_OWNED, "PROPERTY_CAPS_OWNED" },
{ PROPERTY_CAPS_TOTAL, "PROPERTY_CAPS_TOTAL" },
{ PROPERTY_FLAG_CAPTURE_LIMIT, "PROPERTY_FLAG_CAPTURE_LIMIT" },
{ PROPERTY_NUMBER_OF_ROUNDS, "PROPERTY_NUMBER_OF_ROUNDS" },
{ PROPERTY_WIN_LIMIT, "PROPERTY_WIN_LIMIT" },
{ PROPERTY_GAME_SIZE, "PROPERTY_GAME_SIZE" },
{ PROPERTY_AUTOBALANCE, "PROPERTY_AUTOBALANCE" },
{ PROPERTY_PRIVATE_SLOTS, "PROPERTY_PRIVATE_SLOTS" },
{ PROPERTY_MAX_GAME_TIME, "PROPERTY_MAX_GAME_TIME" },
{ PROPERTY_NUMBER_OF_TEAMS, "PROPERTY_NUMBER_OF_TEAMS" },
{ PROPERTY_TEAM, "PROPERTY_TEAM" },
#if defined( _X360 )
{ X_CONTEXT_GAME_MODE, "CONTEXT_GAME_MODE" },
{ X_CONTEXT_GAME_TYPE, "CONTEXT_GAME_TYPE" },
#endif
};
// Presence values cannot be searched by id number, because they are not unique
static s_PresenceTranslation s_PresenceValues[] = {
{ SESSION_MATCH_QUERY_PLAYER_MATCH, "SESSION_MATCH_QUERY_PLAYER_MATCH" },
{ CONTEXT_GAME_MODE_MULTIPLAYER, "CONTEXT_GAME_MODE_MULTIPLAYER" },
{ CONTEXT_SCENARIO_CTF_2FORT, "CONTEXT_SCENARIO_CTF_2FORT" },
{ CONTEXT_SCENARIO_CP_DUSTBOWL, "CONTEXT_SCENARIO_CP_DUSTBOWL" },
{ CONTEXT_SCENARIO_CP_GRANARY, "CONTEXT_SCENARIO_CP_GRANARY" },
{ CONTEXT_SCENARIO_CP_WELL, "CONTEXT_SCENARIO_CP_WELL" },
{ CONTEXT_SCENARIO_CP_GRAVELPIT, "CONTEXT_SCENARIO_CP_GRAVELPIT" },
{ CONTEXT_SCENARIO_TC_HYDRO, "CONTEXT_SCENARIO_TC_HYDRO" },
{ CONTEXT_SCENARIO_CTF_CLOAK, "CONTEXT_SCENARIO_CTF_CLOAK" },
{ CONTEXT_SCENARIO_CP_CLOAK, "CONTEXT_SCENARIO_CP_CLOAK" },
#if defined( _X360 )
{ XSESSION_CREATE_LIVE_MULTIPLAYER_STANDARD, "SESSION_CREATE_LIVE_MULTIPLAYER_STANDARD" },
{ XSESSION_CREATE_LIVE_MULTIPLAYER_RANKED, "SESSION_CREATE_LIVE_MULTIPLAYER_RANKED" },
{ XSESSION_CREATE_SYSTEMLINK, "SESSION_CREATE_SYSTEMLINK" },
{ X_CONTEXT_GAME_TYPE_STANDARD, "CONTEXT_GAME_TYPE_STANDARD" },
{ X_CONTEXT_GAME_TYPE_RANKED, "CONTEXT_GAME_TYPE_RANKED" },
#endif
};
//-----------------------------------------------------------------------------
// Convert a map name to a defined ID.
//-----------------------------------------------------------------------------
static unsigned int GetMapID( const char *pMapName )
{
for ( int i = 0; i < ARRAYSIZE( s_Scenarios ); ++i )
{
if ( !Q_stricmp( s_Scenarios[i].pDiskName, pMapName ) )
{
return i;
}
}
return 0;
}
//-----------------------------------------------------------------------------
// Convert a session property string to a display string for gameUI.
//-----------------------------------------------------------------------------
void CTF_Presence::GetPropertyDisplayString( uint id, uint value, char *pOutput, int nBytes )
{
const char *pDisplayString = "";
switch( id )
{
#if defined( _X360 )
case X_CONTEXT_GAME_TYPE:
switch( value )
{
case X_CONTEXT_GAME_TYPE_STANDARD:
pDisplayString = "#TF_Unranked";
break;
case X_CONTEXT_GAME_TYPE_RANKED:
pDisplayString = "#TF_Ranked";
break;
}
break;
#endif
case CONTEXT_SCENARIO:
pDisplayString = s_Scenarios[value].pDisplayName;
break;
case PROPERTY_FLAG_CAPTURE_LIMIT:
case PROPERTY_NUMBER_OF_ROUNDS:
case PROPERTY_WIN_LIMIT:
Q_snprintf( pOutput, nBytes, "%d", value );
return;
case PROPERTY_MAX_GAME_TIME:
if ( value >= NO_TIME_LIMIT )
{
Q_strncpy( pOutput, "#TF_MaxTimeNoLimit", nBytes );
}
else
{
Q_snprintf( pOutput, nBytes, "%d:00", value );
}
return;
case PROPERTY_TEAM:
switch ( value )
{
case 0:
pDisplayString = "blue";
break;
case 1:
pDisplayString = "red";
break;
case 2:
pDisplayString = "spectator";
break;
}
break;
default:
pDisplayString = "Unknown";
break;
}
Q_strncpy( pOutput, pDisplayString, nBytes );
}
//-----------------------------------------------------------------------------
// Convert a presence ID to a string.
//-----------------------------------------------------------------------------
const char *CTF_Presence::GetPropertyIdString( const uint id )
{
for ( int i = 0; i < ARRAYSIZE( s_PresenceIds ); ++i )
{
if ( s_PresenceIds[i].id == id )
{
return s_PresenceIds[i].pString;
}
}
return "Unknown";
}
//-----------------------------------------------------------------------------
// Convert a session property string to an ID.
//-----------------------------------------------------------------------------
uint CTF_Presence::GetPresenceID( const char *pIDName )
{
for ( int i = 0; i < ARRAYSIZE( s_PresenceIds ); ++i )
{
if ( !Q_stricmp( s_PresenceIds[i].pString, pIDName ) )
{
return s_PresenceIds[i].id;
}
}
for ( int i = 0; i < ARRAYSIZE( s_PresenceValues ); ++i )
{
if ( !Q_stricmp( s_PresenceValues[i].pString, pIDName ) )
{
return s_PresenceValues[i].id;
}
}
Warning( "Presence ID not found for %s\n", pIDName );
return 0;
}
//-----------------------------------------------------------------------------
// Purpose: Level init
//-----------------------------------------------------------------------------
void CTF_Presence::LevelInitPreEntity( void )
{
m_bIsInCommentary = false;
const char *pMapName = MapName();
if ( pMapName )
{
UserSetContext( XBX_GetPrimaryUserId(), CONTEXT_SCENARIO, GetMapID( pMapName ), true );
}
}
//-----------------------------------------------------------------------------
// Purpose: Init
//-----------------------------------------------------------------------------
bool CTF_Presence::Init()
{
presence = &s_presence;
ListenForGameEvent( "controlpoint_initialized" );
ListenForGameEvent( "controlpoint_updateowner" );
ListenForGameEvent( "teamplay_round_start" );
ListenForGameEvent( "ctf_flag_captured" );
ListenForGameEvent( "playing_commentary" );
return CBasePresence::Init();
}
//-----------------------------------------------------------------------------
// Get game session properties from matchmaking.
//-----------------------------------------------------------------------------
void CTF_Presence::SetupGameProperties( CUtlVector< XUSER_CONTEXT > &contexts, CUtlVector< XUSER_PROPERTY > &properties )
{
// Session properties have been set for this game. Use our knowledge of
// the properties that have been defined for this game to set rules, cvars, etc.
char buffer[MAX_PATH];
#if 0 // defined( _X360 ) // absolutely nothing happens in this loop, so I disabled it. It was breaking the compiler in LTCG mode. -egr
int count = contexts.Count();
for ( int i = 0; i < count; ++i )
{
XUSER_CONTEXT &ctx = contexts[i];
switch( ctx.dwContextId )
{
case X_CONTEXT_GAME_TYPE:
if ( ctx.dwValue == X_CONTEXT_GAME_TYPE_RANKED )
{
}
else if ( ctx.dwValue == X_CONTEXT_GAME_TYPE_STANDARD )
{
}
break;
}
}
#endif
for ( int i = 0; i < properties.Count(); ++i )
{
XUSER_PROPERTY &prop = properties[i];
switch( prop.dwPropertyId )
{
case PROPERTY_FLAG_CAPTURE_LIMIT:
Q_snprintf( buffer, sizeof( buffer ), "tf_flag_caps_per_round %d", prop.value.nData );
engine->ClientCmd( buffer );
break;
case PROPERTY_NUMBER_OF_ROUNDS:
Q_snprintf( buffer, sizeof( buffer ), "mp_maxrounds %d", prop.value.nData );
engine->ClientCmd( buffer );
break;
case PROPERTY_WIN_LIMIT:
Q_snprintf( buffer, sizeof( buffer ), "mp_winlimit %d", prop.value.nData );
engine->ClientCmd( buffer );
break;
case PROPERTY_GAME_SIZE:
Q_snprintf( buffer, sizeof( buffer ), "maxplayers %d", prop.value.nData );
engine->ClientCmd( buffer );
break;
case PROPERTY_AUTOBALANCE:
Q_snprintf( buffer, sizeof( buffer ), "mp_autoteambalance %d", prop.value.nData );
engine->ClientCmd( buffer );
break;
case PROPERTY_MAX_GAME_TIME:
Q_snprintf( buffer, sizeof( buffer ), "mp_timelimit %d", prop.value.nData );
engine->ClientCmd( buffer );
break;
}
}
}
//-----------------------------------------------------------------------------
// Respond to TF game events.
//-----------------------------------------------------------------------------
void CTF_Presence::FireGameEvent( IGameEvent *event )
{
const char *eventname = event->GetName();
if ( !Q_stricmp( "teamplay_round_start", eventname ) )
{
// Set presence for this map
// TODO: Set appropriate presence mode based on game type
#if defined( _X360 )
if ( TFGameRules() && !m_bIsInCommentary )
{
if ( TFGameRules()->GetGameType() == TF_GAMETYPE_CP )
{
UserSetContext( XBX_GetPrimaryUserId(), X_CONTEXT_PRESENCE, CONTEXT_PRESENCE_TF_CP, true );
}
else if ( TFGameRules()->GetGameType() == TF_GAMETYPE_CTF )
{
// ctf games start tied
int zeroscore = 0;
UserSetProperty( XBX_GetPrimaryUserId(), PROPERTY_PLAYER_TEAM_SCORE, sizeof(int), &zeroscore, true );
UserSetProperty( XBX_GetPrimaryUserId(), PROPERTY_OPPONENT_TEAM_SCORE, sizeof(int), &zeroscore, true );
UserSetContext( XBX_GetPrimaryUserId(), X_CONTEXT_PRESENCE, CONTEXT_PRESENCE_TF_CTF_TIED, true );
}
}
#endif
}
else if ( !Q_stricmp( "controlpoint_initialized", eventname ) )
{
int nPoints = ObjectiveResource()->GetNumControlPoints();
int nOwned = ObjectiveResource()->GetNumControlPointsOwned();
UserSetProperty( XBX_GetPrimaryUserId(), PROPERTY_CAPS_TOTAL, sizeof(int), &nPoints, true );
UserSetProperty( XBX_GetPrimaryUserId(), PROPERTY_CAPS_OWNED, sizeof(int), &nOwned, true );
}
else if ( !Q_stricmp( "controlpoint_updateowner", eventname ) )
{
int nOwned = ObjectiveResource()->GetNumControlPointsOwned();
UserSetProperty( XBX_GetPrimaryUserId(), PROPERTY_CAPS_OWNED, sizeof(int), &nOwned, true );
}
else if ( !Q_stricmp( "ctf_flag_captured", eventname ) )
{
C_TFTeam *pLocalTeam = GetGlobalTFTeam( GetLocalPlayerTeam() );
if ( pLocalTeam )
{
int iOtherScore = 0;
int iTeamScore = 0;
int iCappingTeam = event->GetInt( "capping_team" );
int iCappingTeamScore = event->GetInt( "capping_team_score" );
// If the local player is on the team that just captured
if ( iCappingTeam == pLocalTeam->GetTeamNumber() )
{
// the newly capped score is our current score
iTeamScore = iCappingTeamScore;
}
else // Other team capped
{
// Start other team score at the newly capped score set by the game event.
// It can be higher than any we have locally recorded because of networking lag.
iOtherScore = iCappingTeamScore;
iTeamScore = pLocalTeam->GetFlagCaptures();
}
// highest score of any other team is the opposing score
for ( int i = 0; i < g_Teams.Count(); i++ )
{
C_TFTeam* pCurTeam = ( dynamic_cast< C_TFTeam* >( g_Teams[i] ) );
if ( pCurTeam )
{
if ( GetLocalPlayerTeam() == pCurTeam->GetTeamNumber() )
continue;
int iCurScore = pCurTeam->GetFlagCaptures();
if ( iCurScore > iOtherScore )
{
iOtherScore = iCurScore;
}
}
}
UserSetProperty( XBX_GetPrimaryUserId(), PROPERTY_PLAYER_TEAM_SCORE, sizeof(int), &iTeamScore, true );
UserSetProperty( XBX_GetPrimaryUserId(), PROPERTY_OPPONENT_TEAM_SCORE, sizeof(int), &iOtherScore, true );
#if defined ( _X360 )
if ( !m_bIsInCommentary )
{
if ( iTeamScore > iOtherScore )
{
UserSetContext( XBX_GetPrimaryUserId(), X_CONTEXT_PRESENCE, CONTEXT_PRESENCE_TF_CTF_WINNING, true );
}
else if ( iOtherScore > iTeamScore )
{
UserSetContext( XBX_GetPrimaryUserId(), X_CONTEXT_PRESENCE, CONTEXT_PRESENCE_TF_CTF_LOSING, true );
}
else
{
UserSetContext( XBX_GetPrimaryUserId(), X_CONTEXT_PRESENCE, CONTEXT_PRESENCE_TF_CTF_TIED, true );
}
}
#endif
}
}
else if ( !Q_stricmp( "playing_commentary", eventname ) )
{
m_bIsInCommentary = true;
#if defined ( _X360 )
UserSetContext( XBX_GetPrimaryUserId(), X_CONTEXT_PRESENCE, CONTEXT_PRESENCE_COMMENTARY, true );
UserSetContext( XBX_GetPrimaryUserId(), X_CONTEXT_GAME_MODE, CONTEXT_GAME_MODE_SINGLEPLAYER, true );
#endif
}
}
//-----------------------------------------------------------------------------
// Purpose: Upload player stats to Live.
//-----------------------------------------------------------------------------
void CTF_Presence::UploadStats()
{
#if defined( _X360 )
if ( m_bReportingStats )
{
m_ViewProperties[0].dwViewId = X_STATS_VIEW_SKILL;
m_ViewProperties[1].dwViewId = m_bArbitrated ? STATS_VIEW_PLAYER_MAX_RANKED : STATS_VIEW_PLAYER_MAX_UNRANKED;
m_ViewProperties[2].dwViewId = STATS_VIEW_PLAYER_MAX_UNRANKED;
CUtlVector< XUSER_PROPERTY > skillStats;
if ( !g_TF_PR )
return;
XUID localId = matchmaking->PlayerIdToXuid( GetLocalPlayerIndex() );
for ( int i = 1; i <= gpGlobals->maxClients; ++i )
{
XUID id = matchmaking->PlayerIdToXuid( i );
if ( id == 0 )
continue;
// For non-ranked sessions, only the local player's stats are written
if ( !m_bArbitrated && id != localId )
continue;
skillStats.RemoveAll();
int viewCt = 1;
if ( id != 0 )
{
Msg( "XUID: %d\n", id );
XUSER_PROPERTY prop;
int nScore = g_TF_PR->GetTotalScore( i );
// Write the player's skill stats
prop.dwPropertyId = X_PROPERTY_RELATIVE_SCORE;
prop.value.type = XUSER_DATA_TYPE_INT32;
prop.value.nData = nScore;
skillStats.AddToTail( prop );
prop.dwPropertyId = X_PROPERTY_SESSION_TEAM;
prop.value.type = XUSER_DATA_TYPE_INT32;
prop.value.nData = i;
skillStats.AddToTail( prop );
m_ViewProperties[0].dwNumProperties = skillStats.Count();
m_ViewProperties[0].pProperties = skillStats.Base();
Msg( "Skill:\n" );
Msg( "Relative Score: %d\n" , skillStats[0].value.nData );
Msg( "Team: %d\n" , skillStats[1].value.nData );
if ( id != localId )
{
// Write the remote player's points scored
prop.dwPropertyId = PROPERTY_POINTS_SCORED;
prop.value.type = XUSER_DATA_TYPE_INT64;
prop.value.nData = nScore;
m_ViewProperties[1].dwNumProperties = 1;
m_ViewProperties[1].pProperties = &prop;
viewCt = 2;
Msg( "Points Scored: %d\n" , prop.value.nData );
}
else
{
// Write the local player's points scored
prop.dwPropertyId = PROPERTY_POINTS_SCORED;
prop.value.type = XUSER_DATA_TYPE_INT64;
prop.value.nData = nScore;
m_ViewProperties[1].dwNumProperties = 1;
m_ViewProperties[1].pProperties = &prop;
// Include the local player's array of personal stats
m_ViewProperties[2].dwNumProperties = m_PlayerStats.Count();
m_ViewProperties[2].pProperties = m_PlayerStats.Base();
viewCt = 3;
Msg( "Points Scored: %d\n" , prop.value.nData );
Msg( "Unranked stat count: %d\n", m_ViewProperties[2].dwNumProperties );
}
}
DWORD ret = xboxsystem->WriteStats( m_hSession, id , viewCt, m_ViewProperties, false );
if ( ret != ERROR_SUCCESS )
{
Warning( "Write stats failed with error %d\n", ret );
}
}
m_PlayerStats.RemoveAll();
m_bReportingStats = false;
}
#endif
}