id/doom3-bfg
0
0
Fork 0
mirror of https://github.com/id-Software/DOOM-3-BFG.git synced 2024-12-14 06:21:31 +00:00
Code Issues Projects Releases Packages Wiki Activity
doom3-bfg/neo/sys/sys_session.h

749 lines
27 KiB
C++
Raw Blame History

/*
===========================================================================
Doom 3 BFG Edition GPL Source Code
Copyright (C) 1993-2012 id Software LLC, a ZeniMax Media company.
This file is part of the Doom 3 BFG Edition GPL Source Code ("Doom 3 BFG Edition Source Code").
Doom 3 BFG Edition Source Code is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
Doom 3 BFG Edition Source Code is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with Doom 3 BFG Edition Source Code. If not, see <http://www.gnu.org/licenses/>.
In addition, the Doom 3 BFG Edition Source Code is also subject to certain additional terms. You should have received a copy of these additional terms immediately following the terms and conditions of the GNU General Public License which accompanied the Doom 3 BFG Edition Source Code. If not, please request a copy in writing from id Software at the address below.
If you have questions concerning this license or the applicable additional terms, you may contact in writing id Software LLC, c/o ZeniMax Media Inc., Suite 120, Rockville, Maryland 20850 USA.
===========================================================================
*/
#ifndef __SYS_SESSION_H__
#define __SYS_SESSION_H__
#include "../framework/Serializer.h"
#include "sys_localuser.h"
typedef uint8 peerMask_t;
static const int MAX_PLAYERS = 8;
static const int MAX_REDUNDANT_CMDS = 3;
static const int MAX_LOCAL_PLAYERS = 2;
static const int MAX_INPUT_DEVICES = 4;
enum matchFlags_t
{
MATCH_STATS = BIT( 0 ), // Match will upload leaderboard/achievement scores
MATCH_ONLINE = BIT( 1 ), // Match will require users to be online
MATCH_RANKED = BIT( 2 ), // Match will affect rank
MATCH_PRIVATE = BIT( 3 ), // Match will NOT be searchable through FindOrCreateMatch
MATCH_INVITE_ONLY = BIT( 4 ), // Match visible through invite only
MATCH_REQUIRE_PARTY_LOBBY = BIT( 5 ), // This session uses a party lobby
MATCH_PARTY_INVITE_PLACEHOLDER = BIT( 6 ), // Party is never shown in the UI, it's simply used as a placeholder for invites
MATCH_JOIN_IN_PROGRESS = BIT( 7 ), // Join in progress supported for this match
};
ID_INLINE bool MatchTypeIsOnline( uint8 matchFlags )
{
return ( matchFlags & MATCH_ONLINE ) ? true : false;
}
ID_INLINE bool MatchTypeIsLocal( uint8 matchFlags )
{
return !MatchTypeIsOnline( matchFlags );
}
ID_INLINE bool MatchTypeIsPrivate( uint8 matchFlags )
{
return ( matchFlags & MATCH_PRIVATE ) ? true : false;
}
ID_INLINE bool MatchTypeIsRanked( uint8 matchFlags )
{
return ( matchFlags & MATCH_RANKED ) ? true : false;
}
ID_INLINE bool MatchTypeHasStats( uint8 matchFlags )
{
return ( matchFlags & MATCH_STATS ) ? true : false;
}
ID_INLINE bool MatchTypeInviteOnly( uint8 matchFlags )
{
return ( matchFlags & MATCH_INVITE_ONLY ) ? true : false;
}
ID_INLINE bool MatchTypeIsSearchable( uint8 matchFlags )
{
return !MatchTypeIsPrivate( matchFlags );
}
ID_INLINE bool MatchTypeIsJoinInProgress( uint8 matchFlags )
{
return ( matchFlags & MATCH_JOIN_IN_PROGRESS ) ? true : false;
}
class idCompressor;
class idLeaderboardSubmission;
class idLeaderboardQuery;
class idSignInManagerBase;
class idPlayerProfile;
class idGameSpawnInfo;
class idSaveLoadParms;
class idSaveGameManager;
class idLocalUser;
class idDedicatedServerSearch;
class idAchievementSystem;
class idLeaderboardCallback;
struct leaderboardDefinition_t;
struct column_t;
const int8 GAME_MODE_RANDOM = -1;
const int8 GAME_MODE_SINGLEPLAYER = -2;
const int8 GAME_MAP_RANDOM = -1;
const int8 GAME_MAP_SINGLEPLAYER = -2;
const int8 GAME_EPISODE_UNKNOWN = -1;
const int8 GAME_SKILL_DEFAULT = -1;
const int DefaultPartyFlags = MATCH_JOIN_IN_PROGRESS | MATCH_ONLINE;
const int DefaultPublicGameFlags = MATCH_JOIN_IN_PROGRESS | MATCH_REQUIRE_PARTY_LOBBY | MATCH_RANKED | MATCH_STATS;
const int DefaultPrivateGameFlags = MATCH_JOIN_IN_PROGRESS | MATCH_REQUIRE_PARTY_LOBBY | MATCH_PRIVATE;
/*
================================================
idMatchParameters
================================================
*/
class idMatchParameters
{
public:
idMatchParameters() :
numSlots( MAX_PLAYERS ),
gameMode( GAME_MODE_RANDOM ),
gameMap( GAME_MAP_RANDOM ),
gameEpisode( GAME_EPISODE_UNKNOWN ),
gameSkill( GAME_SKILL_DEFAULT ),
matchFlags( 0 )
{}
void Write( idBitMsg& msg )
{
idSerializer s( msg, true );
Serialize( s );
}
void Read( idBitMsg& msg )
{
idSerializer s( msg, false );
Serialize( s );
}
void Serialize( idSerializer& serializer )
{
serializer.Serialize( gameMode );
serializer.Serialize( gameMap );
serializer.Serialize( gameEpisode );
serializer.Serialize( gameSkill );
serializer.Serialize( numSlots );
serializer.Serialize( matchFlags );
serializer.SerializeString( mapName );
serverInfo.Serialize( serializer );
}
uint8 numSlots;
int8 gameMode;
int8 gameMap;
int8 gameEpisode; // Episode for doom classic support.
int8 gameSkill; // Skill for doom classic support.
uint8 matchFlags;
idStr mapName; // This is only used for SP (gameMap == GAME_MAP_SINGLEPLAYER)
idDict serverInfo;
};
/*
================================================
serverInfo_t
Results from calling ListServers/ServerInfo for game browser / system link.
================================================
*/
struct serverInfo_t
{
serverInfo_t() :
gameMode( GAME_MODE_RANDOM ),
gameMap( GAME_MAP_RANDOM ),
joinable(),
numPlayers(),
maxPlayers()
{}
void Write( idBitMsg& msg )
{
idSerializer s( msg, true );
Serialize( s );
}
void Read( idBitMsg& msg )
{
idSerializer s( msg, false );
Serialize( s );
}
void Serialize( idSerializer& serializer )
{
serializer.SerializeString( serverName );
serializer.Serialize( gameMode );
serializer.Serialize( gameMap );
SERIALIZE_BOOL( serializer, joinable );
serializer.Serialize( numPlayers );
serializer.Serialize( maxPlayers );
}
idStr serverName;
int8 gameMode;
int8 gameMap;
bool joinable;
int numPlayers;
int maxPlayers;
};
//------------------------
// voiceState_t
//------------------------
enum voiceState_t
{
VOICECHAT_STATE_NO_MIC,
VOICECHAT_STATE_MUTED_LOCAL,
VOICECHAT_STATE_MUTED_REMOTE,
VOICECHAT_STATE_MUTED_ALL,
VOICECHAT_STATE_NOT_TALKING,
VOICECHAT_STATE_TALKING,
VOICECHAT_STATE_TALKING_GLOBAL,
NUM_VOICECHAT_STATE
};
//------------------------
// voiceStateDisplay_t
//------------------------
enum voiceStateDisplay_t
{
VOICECHAT_DISPLAY_NONE,
VOICECHAT_DISPLAY_NOTTALKING,
VOICECHAT_DISPLAY_TALKING,
VOICECHAT_DISPLAY_TALKING_GLOBAL,
VOICECHAT_DISPLAY_MUTED,
VOICECHAT_DISPLAY_MAX
};
static const int QOS_RESULT_CRAPPY = 200;
static const int QOS_RESULT_WEAK = 100;
static const int QOS_RESULT_GOOD = 50;
static const int QOS_RESULT_GREAT = 0;
//------------------------
// qosState_t
//------------------------
enum qosState_t
{
QOS_STATE_CRAPPY = 1,
QOS_STATE_WEAK,
QOS_STATE_GOOD,
QOS_STATE_GREAT,
QOS_STATE_MAX,
};
//------------------------
// leaderboardDisplayError_t
//------------------------
enum leaderboardDisplayError_t
{
LEADERBOARD_DISPLAY_ERROR_NONE,
LEADERBOARD_DISPLAY_ERROR_FAILED, // General error occurred
LEADERBOARD_DISPLAY_ERROR_NOT_ONLINE, // No longer online
LEADERBOARD_DISPLAY_ERROR_NOT_RANKED, // Attempting to view a "My Score" leaderboard you aren't ranked on
LEADERBOARD_DISPLAY_ERROR_MAX
};
/*
================================================
lobbyUserID_t
================================================
*/
struct lobbyUserID_t
{
public:
lobbyUserID_t() : lobbyType( 0xFF ) {}
explicit lobbyUserID_t( localUserHandle_t localUser_, byte lobbyType_ ) : localUserHandle( localUser_ ), lobbyType( lobbyType_ ) {}
bool operator == ( const lobbyUserID_t& other ) const
{
return localUserHandle == other.localUserHandle && lobbyType == other.lobbyType; // Lobby type must match
}
bool operator != ( const lobbyUserID_t& other ) const
{
return !( *this == other );
}
bool operator < ( const lobbyUserID_t& other ) const
{
if( localUserHandle == other.localUserHandle )
{
return lobbyType < other.lobbyType; // Lobby type tie breaker
}
return localUserHandle < other.localUserHandle;
}
bool CompareIgnoreLobbyType( const lobbyUserID_t& other ) const
{
return localUserHandle == other.localUserHandle;
}
localUserHandle_t GetLocalUserHandle() const
{
return localUserHandle;
}
byte GetLobbyType() const
{
return lobbyType;
}
bool IsValid() const
{
return localUserHandle.IsValid() && lobbyType != 0xFF;
}
void WriteToMsg( idBitMsg& msg )
{
localUserHandle.WriteToMsg( msg );
msg.WriteByte( lobbyType );
}
void ReadFromMsg( const idBitMsg& msg )
{
localUserHandle.ReadFromMsg( msg );
lobbyType = msg.ReadByte();
}
void Serialize( idSerializer& ser );
private:
localUserHandle_t localUserHandle;
byte lobbyType;
};
/*
================================================
idLobbyBase
================================================
*/
class idLobbyBase
{
public:
// General lobby functionality
virtual bool IsHost() const = 0;
virtual bool IsPeer() const = 0;
virtual bool HasActivePeers() const = 0;
virtual int GetNumLobbyUsers() const = 0;
virtual int GetNumActiveLobbyUsers() const = 0;
virtual bool IsLobbyUserConnected( int index ) const = 0;
virtual lobbyUserID_t GetLobbyUserIdByOrdinal( int userIndex ) const = 0;
virtual int GetLobbyUserIndexFromLobbyUserID( lobbyUserID_t lobbyUserID ) const = 0;
virtual void SendReliable( int type, idBitMsg& msg, bool callReceiveReliable = true, peerMask_t sessionUserMask = MAX_UNSIGNED_TYPE( peerMask_t ) ) = 0;
virtual void SendReliableToLobbyUser( lobbyUserID_t lobbyUserID, int type, idBitMsg& msg ) = 0;
virtual void SendReliableToHost( int type, idBitMsg& msg ) = 0;
// Lobby user access
virtual const char* GetLobbyUserName( lobbyUserID_t lobbyUserID ) const = 0;
virtual void KickLobbyUser( lobbyUserID_t lobbyUserID ) = 0;
virtual bool IsLobbyUserValid( lobbyUserID_t lobbyUserID ) const = 0;
virtual bool IsLobbyUserLoaded( lobbyUserID_t lobbyUserID ) const = 0;
virtual bool LobbyUserHasFirstFullSnap( lobbyUserID_t lobbyUserID ) const = 0;
virtual void EnableSnapshotsForLobbyUser( lobbyUserID_t lobbyUserID ) = 0;
virtual int GetLobbyUserSkinIndex( lobbyUserID_t lobbyUserID ) const = 0;
virtual bool GetLobbyUserWeaponAutoReload( lobbyUserID_t lobbyUserID ) const = 0;
virtual bool GetLobbyUserWeaponAutoSwitch( lobbyUserID_t lobbyUserID ) const = 0;
virtual int GetLobbyUserLevel( lobbyUserID_t lobbyUserID ) const = 0;
virtual int GetLobbyUserQoS( lobbyUserID_t lobbyUserID ) const = 0;
virtual int GetLobbyUserTeam( lobbyUserID_t lobbyUserID ) const = 0;
virtual bool SetLobbyUserTeam( lobbyUserID_t lobbyUserID, int teamNumber ) = 0;
virtual int GetLobbyUserPartyToken( lobbyUserID_t lobbyUserID ) const = 0;
virtual idPlayerProfile* GetProfileFromLobbyUser( lobbyUserID_t lobbyUserID ) = 0;
virtual idLocalUser* GetLocalUserFromLobbyUser( lobbyUserID_t lobbyUserID ) = 0;
virtual int GetNumLobbyUsersOnTeam( int teamNumber ) const = 0;
virtual int PeerIndexFromLobbyUser( lobbyUserID_t lobbyUserID ) const = 0;
virtual int GetPeerTimeSinceLastPacket( int peerIndex ) const = 0;
virtual int PeerIndexForHost() const = 0;
virtual lobbyUserID_t AllocLobbyUserSlotForBot( const char* botName ) = 0;
virtual void RemoveBotFromLobbyUserList( lobbyUserID_t lobbyUserID ) = 0;
virtual bool GetLobbyUserIsBot( lobbyUserID_t lobbyUserID ) const = 0;
virtual const char* GetHostUserName() const = 0;
virtual const idMatchParameters& GetMatchParms() const = 0;
virtual bool IsLobbyFull() const = 0;
// Peer access
virtual bool EnsureAllPeersHaveBaseState() = 0;
virtual bool AllPeersInGame() const = 0;
virtual int GetNumConnectedPeers() const = 0;
virtual int GetNumConnectedPeersInGame() const = 0;
virtual int PeerIndexOnHost() const = 0;
virtual bool IsPeerDisconnected( int peerIndex ) const = 0;
// Snapshots
virtual bool AllPeersHaveStaleSnapObj( int objId ) = 0;
virtual bool AllPeersHaveExpectedSnapObj( int objId ) = 0;
virtual void RefreshSnapObj( int objId ) = 0;
virtual void MarkSnapObjDeleted( int objId ) = 0;
virtual void AddSnapObjTemplate( int objID, idBitMsg& msg ) = 0;
// Debugging
virtual void DrawDebugNetworkHUD() const = 0;
virtual void DrawDebugNetworkHUD2() const = 0;
virtual void DrawDebugNetworkHUD_ServerSnapshotMetrics( bool draw ) = 0;
};
/*
================================================
idSession
================================================
*/
class idSession
{
public:
enum sessionState_t
{
PRESS_START,
IDLE,
SEARCHING,
CONNECTING,
PARTY_LOBBY,
GAME_LOBBY,
LOADING,
INGAME,
BUSY,
MAX_STATES
};
enum sessionOption_t
{
OPTION_LEAVE_WITH_PARTY = BIT( 0 ), // As a party leader, whether or not to drag your party members with you when you leave a game lobby
OPTION_ALL = 0xFFFFFFFF
};
idSession() :
signInManager( NULL ),
saveGameManager( NULL ),
achievementSystem( NULL ),
dedicatedServerSearch( NULL ) { }
virtual ~idSession();
virtual void Initialize() = 0;
virtual void Shutdown() = 0;
virtual void InitializeSoundRelatedSystems() = 0;
virtual void ShutdownSoundRelatedSystems() = 0;
//=====================================================================================================
// Lobby management
//=====================================================================================================
virtual void CreatePartyLobby( const idMatchParameters& parms_ ) = 0;
virtual void FindOrCreateMatch( const idMatchParameters& parms_ ) = 0;
virtual void CreateMatch( const idMatchParameters& parms_ ) = 0;
virtual void CreateGameStateLobby( const idMatchParameters& parms_ ) = 0;
virtual void UpdateMatchParms( const idMatchParameters& parms_ ) = 0;
virtual void UpdatePartyParms( const idMatchParameters& parms_ ) = 0;
virtual void StartMatch() = 0;
virtual void EndMatch( bool premature = false ) = 0; // Meant for host to end match gracefully, go back to lobby, tally scores, etc
virtual void MatchFinished() = 0; // this is for when the game is over before we go back to lobby. Need this incase the host leaves during this time
virtual void QuitMatch() = 0; // Meant for host or peer to quit the match before it ends, will instigate host migration, etc
virtual void QuitMatchToTitle() = 0; // Will forcefully quit the match and return to the title screen.
virtual void SetSessionOption( sessionOption_t option ) = 0;
virtual void ClearSessionOption( sessionOption_t option ) = 0;
virtual sessionState_t GetBackState() = 0;
virtual void Cancel() = 0;
virtual void MoveToPressStart() = 0;
virtual void FinishDisconnect() = 0;
virtual void LoadingFinished() = 0;
virtual bool IsCurrentLobbyMigrating() const = 0;
virtual bool IsLosingConnectionToHost() const = 0;
virtual bool WasMigrationGame() const = 0;
virtual bool ShouldRelaunchMigrationGame() const = 0;
virtual bool WasGameLobbyCoalesced() const = 0;
virtual bool GetMigrationGameData( idBitMsg& msg, bool reading ) = 0;
virtual bool GetMigrationGameDataUser( lobbyUserID_t lobbyUserID, idBitMsg& msg, bool reading ) = 0;
virtual bool GetMatchParamUpdate( int& peer, int& msg ) = 0;
virtual void Pump() = 0;
virtual void ProcessSnapAckQueue() = 0;
virtual void InviteFriends() = 0;
virtual void InviteParty() = 0;
virtual void ShowPartySessions() = 0;
virtual bool IsPlatformPartyInLobby() = 0;
// Lobby user/peer access
// The party and game lobby are the two platform lobbies that notify the backends (Steam/PSN/LIVE of changes)
virtual idLobbyBase& GetPartyLobbyBase() = 0;
virtual idLobbyBase& GetGameLobbyBase() = 0;
// Game state lobby is the lobby used while in-game. It is so the dedicated server can host this lobby
// and have all platform clients join. It does NOT notify the backends of changes, it's purely for the dedicated
// server to be able to host the in-game lobby.
virtual idLobbyBase& GetActingGameStateLobbyBase() = 0;
// GetActivePlatformLobbyBase will return either the game or party lobby, it won't return the game state lobby
// This function is generally used for menus, in-game code should refer to GetActingGameStateLobby
virtual idLobbyBase& GetActivePlatformLobbyBase() = 0;
virtual idLobbyBase& GetLobbyFromLobbyUserID( lobbyUserID_t lobbyUserID ) = 0;
virtual idPlayerProfile* GetProfileFromMasterLocalUser() = 0;
virtual bool ProcessInputEvent( const sysEvent_t* ev ) = 0;
virtual float GetUpstreamDropRate() = 0;
virtual float GetUpstreamQueueRate() = 0;
virtual int GetQueuedBytes() = 0;
virtual int GetLoadingID() = 0;
virtual bool IsAboutToLoad() const = 0;
virtual const char* GetLocalUserName( int i ) const = 0;
virtual sessionState_t GetState() const = 0;
virtual const char* GetStateString() const = 0;
virtual int NumServers() const = 0;
virtual void ListServers( const idCallback& callback ) = 0;
virtual void CancelListServers() = 0;
virtual void ConnectToServer( int i ) = 0;
virtual const serverInfo_t* ServerInfo( int i ) const = 0;
virtual const idList< idStr >* ServerPlayerList( int i ) = 0;
virtual void ShowServerGamerCardUI( int i ) = 0;
virtual void ShowOnlineSignin() = 0;
virtual void DropClient( int peerNum, int lobbyType ) = 0;
virtual void JoinAfterSwap( void* joinID ) = 0;
//=====================================================================================================
// Downloadable Content
//=====================================================================================================
virtual void EnumerateDownloadableContent() = 0;
virtual int GetNumContentPackages() const = 0;
virtual int GetContentPackageID( int contentIndex ) const = 0;
virtual const char* GetContentPackagePath( int contentIndex ) const = 0;
virtual int GetContentPackageIndexForID( int contentID ) const = 0;
virtual void ShowSystemMarketplaceUI() const = 0;
virtual bool GetSystemMarketplaceHasNewContent() const = 0;
virtual void SetSystemMarketplaceHasNewContent( bool hasNewContent ) = 0;
//=====================================================================================================
// Title Storage Vars
//=====================================================================================================
virtual float GetTitleStorageFloat( const char* name, float defaultFloat ) const = 0;
virtual int GetTitleStorageInt( const char* name, int defaultInt ) const = 0;
virtual bool GetTitleStorageBool( const char* name, bool defaultBool ) const = 0;
virtual const char* GetTitleStorageString( const char* name, const char* defaultString ) const = 0;
virtual bool GetTitleStorageFloat( const char* name, float defaultFloat, float& out ) const
{
out = defaultFloat;
return false;
}
virtual bool GetTitleStorageInt( const char* name, int defaultInt, int& out ) const
{
out = defaultInt;
return false;
}
virtual bool GetTitleStorageBool( const char* name, bool defaultBool, bool& out ) const
{
out = defaultBool;
return false;
}
virtual bool GetTitleStorageString( const char* name, const char* defaultString, const char** out ) const
{
if( out != NULL )
{
*out = defaultString;
}
return false;
}
virtual bool IsTitleStorageLoaded() = 0;
//=====================================================================================================
// Leaderboard
//=====================================================================================================
virtual void LeaderboardUpload( lobbyUserID_t lobbyUserID, const leaderboardDefinition_t* leaderboard, const column_t* stats, const idFile_Memory* attachment = NULL ) = 0;
virtual void LeaderboardDownload( int sessionUserIndex, const leaderboardDefinition_t* leaderboard, int startingRank, int numRows, const idLeaderboardCallback& callback ) = 0;
virtual void LeaderboardDownloadAttachment( int sessionUserIndex, const leaderboardDefinition_t* leaderboard, int64 attachmentID ) = 0;
virtual void LeaderboardFlush() = 0;
//=====================================================================================================
// Scoring (currently just for TrueSkill)
//=====================================================================================================
virtual void SetLobbyUserRelativeScore( lobbyUserID_t lobbyUserID, int relativeScore, int team ) = 0;
//=====================================================================================================
// Savegames
//
// Default async implementations, saves to a folder, uses game.details file to describe each save.
// Files saved are up to the game and provide through a callback mechanism. If you want to be notified when
// one of these operations have completed, either modify the framework's completedCallback of each of the
// savegame processors or create your own processors and execute with the savegameManager.
//=====================================================================================================
virtual saveGameHandle_t SaveGameSync( const char* name, const saveFileEntryList_t& files, const idSaveGameDetails& description ) = 0;
virtual saveGameHandle_t SaveGameAsync( const char* name, const saveFileEntryList_t& files, const idSaveGameDetails& description ) = 0;
virtual saveGameHandle_t LoadGameSync( const char* name, saveFileEntryList_t& files ) = 0;
virtual saveGameHandle_t EnumerateSaveGamesSync() = 0;
virtual saveGameHandle_t EnumerateSaveGamesAsync() = 0;
virtual saveGameHandle_t DeleteSaveGameSync( const char* name ) = 0;
virtual saveGameHandle_t DeleteSaveGameAsync( const char* name ) = 0;
virtual bool IsSaveGameCompletedFromHandle( const saveGameHandle_t& handle ) const = 0;
virtual void CancelSaveGameWithHandle( const saveGameHandle_t& handle ) = 0;
// Needed for main menu integration
virtual bool IsEnumerating() const = 0;
virtual saveGameHandle_t GetEnumerationHandle() const = 0;
// Returns the known list of savegames, must first enumerate for the savegames ( via session->Enumerate() )
virtual const saveGameDetailsList_t& GetEnumeratedSavegames() const = 0;
// These are on session and not idGame so it can persist across game deallocations
virtual void SetCurrentSaveSlot( const char* slotName ) = 0;
virtual const char* GetCurrentSaveSlot() const = 0;
// Error checking
virtual bool IsDLCAvailable( const char* mapName ) = 0;
virtual bool LoadGameCheckDiscNumber( idSaveLoadParms& parms ) = 0;
//=====================================================================================================
// GamerCard UI
//=====================================================================================================
virtual void ShowLobbyUserGamerCardUI( lobbyUserID_t lobbyUserID ) = 0;
//=====================================================================================================
virtual void UpdateRichPresence() = 0;
virtual void SendUsercmds( idBitMsg& msg ) = 0;
virtual void SendSnapshot( class idSnapShot& ss ) = 0;
virtual int GetInputRouting( int inputRouting[ MAX_INPUT_DEVICES ] );
virtual void UpdateSignInManager() = 0;
idSignInManagerBase& GetSignInManager()
{
return *signInManager;
}
idSaveGameManager& GetSaveGameManager()
{
return *saveGameManager;
}
idAchievementSystem& GetAchievementSystem()
{
return *achievementSystem;
}
bool HasSignInManager() const
{
return ( signInManager != NULL );
}
bool HasAchievementSystem() const
{
return ( achievementSystem != NULL );
}
virtual bool IsSystemUIShowing() const = 0;
virtual void SetSystemUIShowing( bool show ) = 0;
//=====================================================================================================
// Voice chat
//=====================================================================================================
virtual voiceState_t GetLobbyUserVoiceState( lobbyUserID_t lobbyUserID ) = 0;
virtual voiceStateDisplay_t GetDisplayStateFromVoiceState( voiceState_t voiceState ) const = 0;
virtual void ToggleLobbyUserVoiceMute( lobbyUserID_t lobbyUserID ) = 0;
virtual void SetActiveChatGroup( int groupIndex ) = 0;
virtual void CheckVoicePrivileges() = 0;
virtual void SetVoiceGroupsToTeams() = 0;
virtual void ClearVoiceGroups() = 0;
//=====================================================================================================
// Bandwidth / QoS checking
//=====================================================================================================
virtual bool StartOrContinueBandwidthChallenge( bool forceStart ) = 0;
virtual void DebugSetPeerSnaprate( int peerIndex, int snapRateMS ) = 0;
virtual float GetIncomingByteRate() = 0;
//=====================================================================================================
// Invites
//=====================================================================================================
virtual void HandleBootableInvite( int64 lobbyId = 0 ) = 0;
virtual void HandleExitspawnInvite( const lobbyConnectInfo_t& connectInfo ) {}
virtual void ClearBootableInvite() = 0;
virtual void ClearPendingInvite() = 0;
virtual bool HasPendingBootableInvite() = 0;
virtual void SetDiscSwapMPInvite( void* parm ) = 0;
virtual void* GetDiscSwapMPInviteParms() = 0;
virtual bool IsDiscSwapMPInviteRequested() const = 0;
//=====================================================================================================
// Notifications
//=====================================================================================================
// This is called when a LocalUser is signed in/out
virtual void OnLocalUserSignin( idLocalUser* user ) = 0;
virtual void OnLocalUserSignout( idLocalUser* user ) = 0;
// This is called when the master LocalUser is signed in/out, these are called after OnLocalUserSignin/out()
virtual void OnMasterLocalUserSignout() = 0;
virtual void OnMasterLocalUserSignin() = 0;
// After a local user has signed in and their profile has loaded
virtual void OnLocalUserProfileLoaded( idLocalUser* user ) = 0;
protected:
idSignInManagerBase* signInManager; // pointer so we can treat dynamically bind platform-specific impl
idSaveGameManager* saveGameManager;
idAchievementSystem* achievementSystem; // pointer so we can treat dynamically bind platform-specific impl
idDedicatedServerSearch* dedicatedServerSearch;
};
/*
========================
idSession::idGetInputRouting
========================
*/
ID_INLINE int idSession::GetInputRouting( int inputRouting[ MAX_INPUT_DEVICES ] )
{
for( int i = 0; i < MAX_INPUT_DEVICES; i++ )
{
inputRouting[ i ] = -1;
}
inputRouting[0] = 0;
return 1;
}
extern idSession* session;
#endif // __SYS_SESSION_H__
Reference in a new issue View git blame Copy permalink