networking

2025-07-13 15:47:42 +03:00
parent f5b26be510
commit a9c28b8940
345 changed files with 142130 additions and 174 deletions
--- a/external/steamworks/steamworksexample/SpaceWarClient.h
+++ b/external/steamworks/steamworksexample/SpaceWarClient.h
@@ -0,0 +1,560 @@
+//========= Copyright <20> 1996-2008, Valve LLC, All rights reserved. ============
+//
+// Purpose: Main class for the space war game client
+//
+// $NoKeywords: $
+//=============================================================================
+
+#ifndef SPACEWARCLIENT_H
+#define SPACEWARCLIENT_H
+
+
+#include "GameEngine.h"
+#include "SpaceWar.h"
+#include "Messages.h"
+#include "StarField.h"
+#include "Sun.h"
+#include "Ship.h"
+#include "StatsAndAchievements.h"
+#include "RemoteStorage.h"
+#include "musicplayer.h"
+#include "steam/isteamnetworkingsockets.h"
+#include "steam/isteamnetworkingutils.h"
+
+// Forward class declaration
+class CConnectingMenu;
+class CMainMenu; 
+class CQuitMenu;
+class CSpaceWarServer;
+class CServerBrowser;
+class CLobbyBrowser;
+class CLobby;
+class CLeaderboards;
+class CFriendsList;
+class CClanChatRoom;
+class CP2PAuthPlayer;
+class CP2PAuthedGame;
+class CVoiceChat;
+class CHTMLSurface;
+class CRemotePlayList;
+class CItemStore;
+class COverlayExamples;
+class CTimeline;
+
+// Height of the HUD font
+#define HUD_FONT_HEIGHT 18
+
+// Height for the instructions font
+#define INSTRUCTIONS_FONT_HEIGHT 24
+
+// Enum for various client connection states
+enum EClientConnectionState
+{
+	k_EClientNotConnected,							// Initial state, not connected to a server
+	k_EClientConnectedPendingAuthentication,		// We've established communication with the server, but it hasn't authed us yet
+	k_EClientConnectedAndAuthenticated,				// Final phase, server has authed us, we are actually able to play on it
+};
+
+// a game server as shown in the find servers menu
+struct ServerBrowserMenuData_t
+{
+	EClientGameState m_eStateToTransitionTo;
+	CSteamID m_steamIDGameServer;
+};
+
+// a lobby as shown in the find lobbies menu
+struct LobbyBrowserMenuItem_t
+{
+	CSteamID m_steamIDLobby;
+	EClientGameState m_eStateToTransitionTo;
+};
+
+// a user as shown in the lobby screen
+struct LobbyMenuItem_t
+{
+	enum ELobbyMenuItemCommand
+	{
+		k_ELobbyMenuItemUser,
+		k_ELobbyMenuItemStartGame,
+		k_ELobbyMenuItemToggleReadState,
+		k_ELobbyMenuItemLeaveLobby,
+		k_ELobbyMenuItemInviteToLobby
+	};
+
+	CSteamID m_steamIDUser;		// the user who this is in the lobby
+	ELobbyMenuItemCommand m_eCommand;
+	CSteamID m_steamIDLobby;	// set if k_ELobbyMenuItemInviteToLobby	
+};
+
+// a leaderboard item
+struct LeaderboardMenuItem_t
+{
+	bool m_bBack;
+	bool m_bNextLeaderboard;
+};
+
+// a friends list item
+struct FriendsListMenuItem_t
+{
+	CSteamID m_steamIDFriend;
+};
+
+// a Remote Play session list item
+struct RemotePlayListMenuItem_t
+{
+	uint32 m_unSessionID;
+};
+
+#define MAX_WORKSHOP_ITEMS 16
+
+// a Steam Workshop item
+class CWorkshopItem : public CVectorEntity
+{
+public:
+
+	CWorkshopItem( IGameEngine *pGameEngine, uint32 uCollisionRadius ) : CVectorEntity( pGameEngine, uCollisionRadius )
+	{
+		memset( &m_ItemDetails, 0, sizeof(m_ItemDetails) );
+	}
+	
+	void OnUGCDetailsResult(SteamUGCRequestUGCDetailsResult_t *pCallback, bool bIOFailure)
+	{
+		m_ItemDetails = pCallback->m_details;
+	}
+
+	SteamUGCDetails_t m_ItemDetails; // meta data
+	CCallResult<CWorkshopItem, SteamUGCRequestUGCDetailsResult_t> m_SteamCallResultUGCDetails;
+};
+
+struct PurchaseableItem_t
+{
+	SteamItemDef_t m_nItemDefID;
+	uint64 m_ulPrice;
+};
+
+struct OverlayExample_t
+{
+	enum EOverlayExampleItem
+	{
+		k_EOverlayExampleItem_BackToMenu,
+		k_EOverlayExampleItem_Invalid,
+		k_EOverlayExampleItem_ActivateGameOverlay,
+		k_EOverlayExampleItem_ActivateGameOverlayToUser,
+		k_EOverlayExampleItem_ActivateGameOverlayToWebPage,
+		k_EOverlayExampleItem_ActivateGameOverlayToWebPageModal,
+		k_EOverlayExampleItem_ActivateGameOverlayToStore,
+		// k_EOverlayExampleItem_ActivateGameOverlayRemotePlayTogetherInviteDialog,
+		k_EOverlayExampleItem_ActivateGameOverlayInviteDialogConnectString,
+		k_EOverlayExampleItem_HookScreenshots,
+		k_EOverlayExampleItem_RequestKeyboard,
+		k_EOverlayExampleItem_Notification_SetInset,
+		k_EOverlayExampleItem_Notification_SetPosition,
+		k_EOverlayExampleItem_Timeline_OpenOverlayToTimelineEvent,
+		k_EOverlayExampleItem_Timeline_OpenOverlayToGamePhase,
+	};
+
+	EOverlayExampleItem m_eItem;
+	const char *m_pchExtraCommandData;
+};
+
+
+class CSpaceWarClient 
+{
+public:
+	//Constructor
+	CSpaceWarClient( IGameEngine *pEngine );
+
+	// Shared init for all constructors
+	void Init( IGameEngine *pGameEngine );
+
+	// Destructor
+	~CSpaceWarClient();
+
+	// Run a game frame
+	void RunFrame();
+
+	void RenderTimer();
+
+	// Service calls that need to happen less frequently than every frame (e.g. every second)
+	void RunOccasionally();
+
+	// Checks for any incoming network data, then dispatches it
+	void ReceiveNetworkData();
+
+	// Connect to a server at a given IP address or game server steamID
+	void InitiateServerConnection( CSteamID steamIDGameServer );
+	void InitiateServerConnection( uint32 unServerAddress, const int32 nPort );
+
+	// Send data to a client at the given ship index
+	bool BSendServerData( const void *pData, uint32 nSizeOfData, int nSendFlags );
+
+	// Menu callback handler (handles a bunch of menus that just change state with no extra data)
+	void OnMenuSelection( EClientGameState eState ) { SetGameState( eState ); }
+
+	// Menu callback handler (handles server browser selections with extra data)
+	void OnMenuSelection( ServerBrowserMenuData_t selection ) 
+	{ 
+		if ( selection.m_eStateToTransitionTo == k_EClientGameConnecting )
+		{
+			InitiateServerConnection( selection.m_steamIDGameServer );
+		}
+		else
+		{
+			SetGameState( selection.m_eStateToTransitionTo ); 
+		}
+	}
+
+	void OnMenuSelection( LobbyBrowserMenuItem_t selection )
+	{
+		// start joining the lobby
+		if ( selection.m_eStateToTransitionTo == k_EClientJoiningLobby )
+		{
+			SteamAPICall_t hSteamAPICall = SteamMatchmaking()->JoinLobby( selection.m_steamIDLobby );
+			// set the function to call when this API completes
+			m_SteamCallResultLobbyEntered.Set( hSteamAPICall, this, &CSpaceWarClient::OnLobbyEntered );
+		}
+
+		SetGameState( selection.m_eStateToTransitionTo );
+	}
+
+	void OnMenuSelection( LobbyMenuItem_t selection );
+	void OnMenuSelection( LeaderboardMenuItem_t selection );
+	void OnMenuSelection( FriendsListMenuItem_t selection );
+	void OnMenuSelection( RemotePlayListMenuItem_t selection );
+	void OnMenuSelection( ERemoteStorageSyncMenuCommand selection );
+	void OnMenuSelection( PurchaseableItem_t selection );
+	void OnMenuSelection( OverlayExample_t selection );
+
+	void OnMenuSelection( MusicPlayerMenuItem_t selection ) { m_pMusicPlayer->OnMenuSelection( selection ); }
+
+	// Set game state
+	void SetGameState( EClientGameState eState );
+	EClientGameState GetGameState() { return m_eGameState; }
+
+	// set failure text
+	void SetConnectionFailureText( const char *pchErrorText );
+
+	// Were we the winner?
+	bool BLocalPlayerWonLastGame();
+
+	// Get the steam id for the local user at this client
+	CSteamID GetLocalSteamID() { return m_SteamIDLocalUser; }
+
+	// Get the local players name
+	const char* GetLocalPlayerName() 
+	{ 
+		return SteamFriends()->GetFriendPersonaName( m_SteamIDLocalUser ); 
+	}
+
+	// Scale screen size to "real" size
+	float PixelsToFeet( float flPixels );
+
+	// Get a Steam-supplied image
+	HGAMETEXTURE GetSteamImageAsTexture( int iImage );
+
+	void RetrieveEncryptedAppTicket();
+
+	void ExecCommandLineConnect( const char *pchServerAddress, const char *pchLobbyID );
+
+	void SetShowTimer( bool bShowTimer ) { m_bShowTimer = bShowTimer; }
+
+	uint32 GetLastGamePhaseID() const { return m_unLastGamePhaseID; }
+	uint64 GetLastCrashIntoSunEvent() const { return m_ulLastCrashIntoSunEvent;  }
+private:
+
+	// Receive a response from the server for a connection attempt
+	void OnReceiveServerInfo( CSteamID steamIDGameServer, bool bVACSecure, const char *pchServerName );
+
+	// Receive a response from the server for a connection attempt
+	void OnReceiveServerAuthenticationResponse( bool bSuccess, uint32 uPlayerPosition );
+
+	// Recieved a response that the server is full
+	void OnReceiveServerFullResponse();
+
+	// Receive a state update from the server
+	void OnReceiveServerUpdate( ServerSpaceWarUpdateData_t *pUpdateData );
+
+	// Handle the server exiting
+	void OnReceiveServerExiting();
+
+	// Disconnects from a server (telling it so) if we are connected
+	void DisconnectFromServer();
+
+	// game state changes
+	void OnGameStateChanged( EClientGameState eGameStateNew );
+
+	// Draw the HUD text (should do this after drawing all the objects)
+	void DrawHUDText();
+
+	// Draw instructions for how to play the game
+	void DrawInstructions();
+
+	// Draw text telling the players who won (or that their was a draw)
+	void DrawWinnerDrawOrWaitingText();
+
+	// Draw text telling the user that the connection attempt has failed
+	void DrawConnectionFailureText();
+
+	// Draw connect to server text
+	void DrawConnectToServerText();
+
+	// Draw text telling the user a connection attempt is in progress
+	void DrawConnectionAttemptText();
+
+	// Updates what we show to friends about what we're doing and how to connect
+	void UpdateRichPresenceConnectionInfo();
+
+	// Draw description for all subscribed workshop items
+	void DrawWorkshopItems();
+
+	// load subscribed workshop items
+	void LoadWorkshopItems();
+	void QueryWorkshopItems();
+
+	// Set appropriate rich presence keys for a player who is currently in-game and
+	// return the value that should go in steam_display
+	const char *SetInGameRichPresence() const;
+
+	// Sets the player scores in the game phase
+	void UpdateScoreInGamePhase( bool bFinal );
+
+	// load a workshop item from file
+	bool LoadWorkshopItem( PublishedFileId_t workshopItemID );
+	CWorkshopItem *LoadWorkshopItemFromFile( const char *pszFileName );
+
+	// draw the in-game store
+	void DrawInGameStore();
+
+	// Server we are connected to
+	CSpaceWarServer *m_pServer;
+
+	// SteamID for the local user on this client
+	CSteamID m_SteamIDLocalUser;
+
+	// Our ship position in the array below
+	uint32 m_uPlayerShipIndex;
+
+	// List of steamIDs for each player
+	CSteamID m_rgSteamIDPlayers[MAX_PLAYERS_PER_SERVER];
+
+	// Ships for players, doubles as a way to check for open slots (pointer is NULL meaning open)
+	CShip *m_rgpShips[MAX_PLAYERS_PER_SERVER];
+
+	// Player scores
+	uint32 m_rguPlayerScores[MAX_PLAYERS_PER_SERVER];
+
+	// Who just won the game? Should be set if we go into the k_EGameWinner state
+	uint32 m_uPlayerWhoWonGame;
+
+	// Current game state
+	EClientGameState m_eGameState;
+
+	// true if we only just transitioned state
+	bool m_bTransitionedGameState;
+
+	// Font handle for drawing the HUD text
+	HGAMEFONT m_hHUDFont;
+
+	// Font handle for drawing the instructions text
+	HGAMEFONT m_hInstructionsFont;
+
+	// Font handle for drawing the in-game store
+	HGAMEFONT m_hInGameStoreFont;
+
+	// Time the last state transition occurred (so we can count-down round restarts)
+	uint64 m_ulStateTransitionTime;
+
+	// Time we started our last connection attempt
+	uint64 m_ulLastConnectionAttemptRetryTime;
+
+	// Time we last got data from the server
+	uint64 m_ulLastNetworkDataReceivedTime;
+
+	// Time when we sent our ping
+	uint64 m_ulPingSentTime;
+
+	// Text to display if we are in an error state
+	char m_rgchErrorText[256];
+
+	// Server address data
+	CSteamID m_steamIDGameServer;
+	CSteamID m_steamIDGameServerFromBrowser;
+	uint32 m_unServerIP;
+	uint16 m_usServerPort;
+	HAuthTicket m_hAuthTicket;
+	HSteamNetConnection m_hConnServer;
+
+	// keep track of if we opened the overlay for a gamewebcallback
+	bool m_bSentWebOpen;
+
+	// true if we want to show an on-screen timer in our main menu
+	bool m_bShowTimer;
+	uint32 m_unTicksAtLaunch;
+	HGAMEFONT m_hTimerFont;
+
+	// simple class to marshal callbacks from pinging a game server
+	class CGameServerPing : public ISteamMatchmakingPingResponse
+	{
+	public:
+		CGameServerPing()
+		{
+			m_hGameServerQuery = HSERVERQUERY_INVALID;
+			m_pSpaceWarsClient = NULL;
+		}
+
+		void RetrieveSteamIDFromGameServer( CSpaceWarClient *pSpaceWarClient, uint32 unIP, uint16 unPort )
+		{
+			m_pSpaceWarsClient = pSpaceWarClient;
+			m_hGameServerQuery = SteamMatchmakingServers()->PingServer( unIP, unPort, this );
+		}
+
+		void CancelPing()
+		{
+			m_hGameServerQuery = HSERVERQUERY_INVALID;
+		}
+
+		// Server has responded successfully and has updated data
+		virtual void ServerResponded( gameserveritem_t &server )
+		{
+			if ( m_hGameServerQuery != HSERVERQUERY_INVALID && server.m_steamID.IsValid() )
+			{
+				m_pSpaceWarsClient->InitiateServerConnection( server.m_steamID );
+			}
+
+			m_hGameServerQuery = HSERVERQUERY_INVALID;
+		}
+
+		// Server failed to respond to the ping request
+		virtual void ServerFailedToRespond()
+		{
+			m_hGameServerQuery = HSERVERQUERY_INVALID;
+		}
+
+	private:
+		HServerQuery m_hGameServerQuery;	// we're ping a game server, so we can convert IP:Port to a steamID
+		CSpaceWarClient *m_pSpaceWarsClient;
+	};
+	CGameServerPing m_GameServerPing;
+	
+
+	// Track whether we are connected to a server (and what specific state that connection is in)
+	EClientConnectionState m_eConnectedStatus;
+
+	// Star field instance
+	CStarField *m_pStarField;
+
+	// Sun instance
+	CSun *m_pSun;
+
+	// Steam Workshop items
+	CWorkshopItem *m_rgpWorkshopItems[ MAX_WORKSHOP_ITEMS ];
+	int m_nNumWorkshopItems; // items in m_rgpWorkshopItem
+
+	// Main menu instance
+	CMainMenu *m_pMainMenu;
+
+	// Connecting menu instance
+	CConnectingMenu *m_pConnectingMenu;
+
+	// Pause menu instance
+	CQuitMenu *m_pQuitMenu;
+
+	// pointer to game engine instance we are running under
+	IGameEngine *m_pGameEngine;
+
+	// track which steam image indexes we have textures for, and what handle that texture has
+	std::map<int, HGAMETEXTURE> m_MapSteamImagesToTextures;
+
+	CStatsAndAchievements *m_pStatsAndAchievements;
+	CTimeline *m_pTimeline;
+	uint32 m_unGamePhaseID = 0;
+	uint32 m_unLastGamePhaseID = 0;
+	uint64 m_ulLastCrashIntoSunEvent = 0;
+
+	CLeaderboards *m_pLeaderboards;
+	CFriendsList *m_pFriendsList;
+	CMusicPlayer *m_pMusicPlayer;
+	CClanChatRoom *m_pClanChatRoom;
+	CServerBrowser *m_pServerBrowser;
+	CRemotePlayList *m_pRemotePlayList;
+	CRemoteStorage *m_pRemoteStorage;
+	CItemStore *m_pItemStore;
+	COverlayExamples *m_pOverlayExamples;
+
+	// lobby handling
+	// the name of the lobby we're connected to
+	CSteamID m_steamIDLobby;
+	// callback for when we're creating a new lobby
+	void OnLobbyCreated( LobbyCreated_t *pCallback, bool bIOFailure );
+	CCallResult<CSpaceWarClient, LobbyCreated_t> m_SteamCallResultLobbyCreated;
+
+	// callback for when we've joined a lobby
+	void OnLobbyEntered( LobbyEnter_t *pCallback, bool bIOFailure );
+	CCallResult<CSpaceWarClient, LobbyEnter_t> m_SteamCallResultLobbyEntered;
+
+	// callback for when the lobby game server has started
+	STEAM_CALLBACK( CSpaceWarClient, OnLobbyGameCreated, LobbyGameCreated_t );
+	STEAM_CALLBACK( CSpaceWarClient, OnGameJoinRequested, GameRichPresenceJoinRequested_t );
+	STEAM_CALLBACK( CSpaceWarClient, OnAvatarImageLoaded, AvatarImageLoaded_t );
+	STEAM_CALLBACK( CSpaceWarClient, OnNewUrlLaunchParameters, NewUrlLaunchParameters_t );
+	STEAM_CALLBACK( CSpaceWarClient, OnGameOverlayActivated, GameOverlayActivated_t );
+	
+	// callback when getting the results of a web call
+	STEAM_CALLBACK( CSpaceWarClient, OnGameWebCallback, GameWebCallback_t );
+
+	// callback when new Workshop item was installed
+	STEAM_CALLBACK(CSpaceWarClient, OnWorkshopItemInstalled, ItemInstalled_t);
+	void OnUGCQueryCompleted( SteamUGCQueryCompleted_t *pParam, bool bIOFailure );
+	CCallResult<CSpaceWarClient, SteamUGCQueryCompleted_t> m_SteamCallResultUGCQueryCompleted;
+
+	// callback when a Remote Play Together guest invite has been created
+	STEAM_CALLBACK( CSpaceWarClient, OnSteamRemotePlayTogetherGuestInvite, SteamRemotePlayTogetherGuestInvite_t );
+
+	// Steam China support. duration control callback can be posted asynchronously, but we also
+	// call it directly.
+	STEAM_CALLBACK( CSpaceWarClient, OnDurationControl, DurationControl_t );
+
+	// callresult callback, handles io failure
+	void OnDurationControlCallResult( DurationControl_t *pParam, bool bIOFailure )
+	{
+		if ( !bIOFailure )
+		{
+			OnDurationControl( pParam );
+		}
+	}
+	CCallResult< CSpaceWarClient, DurationControl_t > m_SteamCallResultDurationControl;
+
+	// lobby browser menu
+	CLobbyBrowser *m_pLobbyBrowser;
+
+	// local lobby display
+	CLobby *m_pLobby;
+	
+	// p2p game auth manager
+	CP2PAuthedGame *m_pP2PAuthedGame;
+	
+	// p2p voice chat 
+	CVoiceChat *m_pVoiceChat;
+
+	// html page viewer
+	CHTMLSurface *m_pHTMLSurface;
+
+	// Called when we get new connections, or the state of a connection changes
+	STEAM_CALLBACK(CSpaceWarClient, OnNetConnectionStatusChanged, SteamNetConnectionStatusChangedCallback_t);
+
+	// ipc failure handler
+	STEAM_CALLBACK( CSpaceWarClient, OnIPCFailure, IPCFailure_t );
+
+	// Steam wants to shut down, Game for Windows applications should shutdown too
+	STEAM_CALLBACK( CSpaceWarClient, OnSteamShutdown, SteamShutdown_t );
+
+	// Called when SteamUser()->RequestEncryptedAppTicket() returns asynchronously
+	void OnRequestEncryptedAppTicket( EncryptedAppTicketResponse_t *pEncryptedAppTicketResponse, bool bIOFailure );
+	CCallResult< CSpaceWarClient, EncryptedAppTicketResponse_t > m_SteamCallResultEncryptedAppTicket;
+};
+
+// Must define this stuff before BaseMenu.h as it depends on calling back into us through these accessors
+extern CSpaceWarClient *g_pSpaceWarClient;
+CSpaceWarClient *SpaceWarClient();
+
+#endif // SPACEWARCLIENT_H