source/network/NetClient.h

   1 /* Copyright (C) 2022 Wildfire Games.
   2  * This file is part of 0 A.D.
   3  *
   4  * 0 A.D. is free software: you can redistribute it and/or modify
   5  * it under the terms of the GNU General Public License as published by
   6  * the Free Software Foundation, either version 2 of the License, or
   7  * (at your option) any later version.
   8  *
   9  * 0 A.D. is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12  * GNU General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU General Public License
  15  * along with 0 A.D.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 #ifndef NETCLIENT_H
  19 #define NETCLIENT_H
  20
  21 #include "network/FSM.h"
  22 #include "network/NetFileTransfer.h"
  23 #include "network/NetHost.h"
  24 #include "scriptinterface/Object.h"
  25
  26 #include "ps/CStr.h"
  27
  28 #include <ctime>
  29 #include <deque>
  30 #include <thread>
  31
  32 class CGame;
  33 class CNetClientSession;
  34 class CNetClientTurnManager;
  35 class ScriptInterface;
  36
  37 typedef struct _ENetHost ENetHost;
  38
  39 // NetClient session FSM states
  40 enum
  41 {
  42         NCS_UNCONNECTED,
  43         NCS_CONNECT,
  44         NCS_HANDSHAKE,
  45         NCS_AUTHENTICATE,
  46         NCS_PREGAME,
  47         NCS_LOADING,
  48         NCS_JOIN_SYNCING,
  49         NCS_INGAME
  50 };
  51
  52 /**
  53  * Network client.
  54  * This code is run by every player (including the host, if they are not
  55  * a dedicated server).
  56  * It provides an interface between the GUI, the network (via CNetClientSession),
  57  * and the game (via CGame and CNetClientTurnManager).
  58  */
  59 class CNetClient : public CFsm
  60 {
  61         NONCOPYABLE(CNetClient);
  62
  63         friend class CNetFileReceiveTask_ClientRejoin;
  64
  65 public:
  66         /**
  67          * Construct a client associated with the given game object.
  68          * The game must exist for the lifetime of this object.
  69          */
  70         CNetClient(CGame* game);
  71
  72         virtual ~CNetClient();
  73
  74         /**
  75          * We assume that adding a tracing function that's only called
  76          * during GC is better for performance than using a
  77          * PersistentRooted<T> where each value needs to be added to
  78          * the root set.
  79          */
  80         static void Trace(JSTracer *trc, void *data)
  81         {
  82                 reinterpret_cast<CNetClient*>(data)->TraceMember(trc);
  83         }
  84
  85         void TraceMember(JSTracer *trc);
  86
  87         /**
  88          * Set the user's name that will be displayed to all players.
  89          * This must not be called after the connection setup.
  90          */
  91         void SetUserName(const CStrW& username);
  92
  93         /**
  94          * Store the JID of the host.
  95          * This is needed for the secure lobby authentication.
  96          */
  97         void SetHostJID(const CStr& jid);
  98
  99         void SetControllerSecret(const std::string& secret);
 100
 101         bool IsController() const { return m_IsController; }
 102
 103         /**
 104          * Set the game password.
 105          * Must be called after SetUserName, as that is used to hash further.
 106          */
 107         void SetGamePassword(const CStr& hashedPassword);
 108
 109         /**
 110          * Returns the GUID of the local client.
 111          * Used for distinguishing observers.
 112          */
 113         CStr GetGUID() const { return m_GUID; }
 114
 115         /**
 116          * Set connection data to the remote networked server.
 117          * @param address IP address or host name to connect to
 118          */
 119         void SetupServerData(CStr address, u16 port, bool stun);
 120
 121         /**
 122          * Set up a connection to the remote networked server.
 123          * Must call SetupServerData first.
 124          * @return true on success, false on connection failure
 125          */
 126         bool SetupConnection(ENetHost* enetClient);
 127
 128         /**
 129          * Request connection information over the lobby.
 130          */
 131         void SetupConnectionViaLobby();
 132
 133         /**
 134          * Connect to the remote networked server using lobby.
 135          * Push netstatus messages on failure.
 136          * @param localNetwork - if true, assume we are trying to connect on the local network.
 137          * @return true on success, false on connection failure
 138          */
 139         bool TryToConnect(const CStr& hostJID, bool localNetwork);
 140
 141         /**
 142          * Destroy the connection to the server.
 143          * This client probably cannot be used again.
 144          */
 145         void DestroyConnection();
 146
 147         /**
 148          * Poll the connection for messages from the server and process them, and send
 149          * any queued messages.
 150          * This must be called frequently (i.e. once per frame).
 151          */
 152         void Poll();
 153
 154         /**
 155          * Locally triggers a GUI message if the connection to the server is being lost or has bad latency.
 156          */
 157         void CheckServerConnection();
 158
 159         /**
 160          * Retrieves the next queued GUI message, and removes it from the queue.
 161          * The returned value is in the GetScriptInterface() JS context.
 162          *
 163          * This is the only mechanism for the networking code to send messages to
 164          * the GUI - it is pull-based (instead of push) so the engine code does not
 165          * need to know anything about the code structure of the GUI scripts.
 166          *
 167          * The structure of the messages is <code>{ "type": "...", ... }</code>.
 168          * The exact types and associated data are not specified anywhere - the
 169          * implementation and GUI scripts must make the same assumptions.
 170          *
 171          * @return next message, or the value 'undefined' if the queue is empty
 172          */
 173         void GuiPoll(JS::MutableHandleValue);
 174
 175         /**
 176          * Add a message to the queue, to be read by GuiPoll.
 177          * The script value must be in the GetScriptInterface() JS context.
 178          */
 179         template<typename... Args>
 180         void PushGuiMessage(Args const&... args)
 181         {
 182                 ScriptRequest rq(GetScriptInterface());
 183
 184                 JS::RootedValue message(rq.cx);
 185                 Script::CreateObject(rq, &message, args...);
 186                 m_GuiMessageQueue.push_back(JS::Heap<JS::Value>(message));
 187         }
 188
 189         /**
 190          * Return a concatenation of all messages in the GUI queue,
 191          * for test cases to easily verify the queue contents.
 192          */
 193         std::string TestReadGuiMessages();
 194
 195         /**
 196          * Get the script interface associated with this network client,
 197          * which is equivalent to the one used by the CGame in the constructor.
 198          */
 199         const ScriptInterface& GetScriptInterface();
 200
 201         /**
 202          * Send a message to the server.
 203          * @param message message to send
 204          * @return true on success
 205          */
 206         bool SendMessage(const CNetMessage* message);
 207
 208         /**
 209          * Call when the network connection has been successfully initiated.
 210          */
 211         void HandleConnect();
 212
 213         /**
 214          * Call when the network connection has been lost.
 215          */
 216         void HandleDisconnect(u32 reason);
 217
 218         /**
 219          * Call when a message has been received from the network.
 220          */
 221         bool HandleMessage(CNetMessage* message);
 222
 223         /**
 224          * Call when the game has started and all data files have been loaded,
 225          * to signal to the server that we are ready to begin the game.
 226          */
 227         void LoadFinished();
 228
 229         void SendGameSetupMessage(JS::MutableHandleValue attrs, const ScriptInterface& scriptInterface);
 230
 231         void SendAssignPlayerMessage(const int playerID, const CStr& guid);
 232
 233         void SendChatMessage(const std::wstring& text);
 234
 235         void SendReadyMessage(const int status);
 236
 237         void SendClearAllReadyMessage();
 238
 239         void SendStartGameMessage(const CStr& initAttribs);
 240
 241         /**
 242          * Call when the client has rejoined a running match and finished
 243          * the loading screen.
 244          */
 245         void SendRejoinedMessage();
 246
 247         /**
 248          * Call to kick/ban a client
 249          */
 250         void SendKickPlayerMessage(const CStrW& playerName, bool ban);
 251
 252         /**
 253          * Call when the client has paused or unpaused the game.
 254          */
 255         void SendPausedMessage(bool pause);
 256
 257         /**
 258          * @return Whether the NetClient is shutting down.
 259          */
 260         bool ShouldShutdown() const;
 261
 262         /**
 263          * Called when fetching connection data from the host failed, to inform JS code.
 264          */
 265         void HandleGetServerDataFailed(const CStr& error);
 266 private:
 267
 268         void SendAuthenticateMessage();
 269
 270         // Net message / FSM transition handlers
 271         static bool OnConnect(void* context, CFsmEvent* event);
 272         static bool OnHandshake(void* context, CFsmEvent* event);
 273         static bool OnHandshakeResponse(void* context, CFsmEvent* event);
 274         static bool OnAuthenticateRequest(void* context, CFsmEvent* event);
 275         static bool OnAuthenticate(void* context, CFsmEvent* event);
 276         static bool OnChat(void* context, CFsmEvent* event);
 277         static bool OnReady(void* context, CFsmEvent* event);
 278         static bool OnGameSetup(void* context, CFsmEvent* event);
 279         static bool OnPlayerAssignment(void* context, CFsmEvent* event);
 280         static bool OnInGame(void* context, CFsmEvent* event);
 281         static bool OnGameStart(void* context, CFsmEvent* event);
 282         static bool OnJoinSyncStart(void* context, CFsmEvent* event);
 283         static bool OnJoinSyncEndCommandBatch(void* context, CFsmEvent* event);
 284         static bool OnRejoined(void* context, CFsmEvent* event);
 285         static bool OnKicked(void* context, CFsmEvent* event);
 286         static bool OnClientTimeout(void* context, CFsmEvent* event);
 287         static bool OnClientPerformance(void* context, CFsmEvent* event);
 288         static bool OnClientsLoading(void* context, CFsmEvent* event);
 289         static bool OnClientPaused(void* context, CFsmEvent* event);
 290         static bool OnLoadedGame(void* context, CFsmEvent* event);
 291
 292         /**
 293          * Take ownership of a session object, and use it for all network communication.
 294          */
 295         void SetAndOwnSession(CNetClientSession* session);
 296
 297         /**
 298          * Push a message onto the GUI queue listing the current player assignments.
 299          */
 300         void PostPlayerAssignmentsToScript();
 301
 302         CGame *m_Game;
 303         CStrW m_UserName;
 304
 305         CStr m_HostJID;
 306         CStr m_ServerAddress;
 307         u16 m_ServerPort;
 308         bool m_UseSTUN;
 309
 310         /**
 311          * Password to join the game.
 312          */
 313         CStr m_Password;
 314
 315         /// The 'secret' used to identify the controller of the game.
 316         std::string m_ControllerSecret;
 317
 318         /// Note that this is just a "gui hint" with no actual impact on being controller.
 319         bool m_IsController = false;
 320
 321         /// Current network session (or NULL if not connected)
 322         CNetClientSession* m_Session;
 323
 324         std::thread m_PollingThread;
 325
 326         /// Turn manager associated with the current game (or NULL if we haven't started the game yet)
 327         CNetClientTurnManager* m_ClientTurnManager;
 328
 329         /// Unique-per-game identifier of this client, used to identify the sender of simulation commands
 330         u32 m_HostID;
 331
 332         /// True if the player is currently rejoining or has already rejoined the game.
 333         bool m_Rejoin;
 334
 335         /// Latest copy of player assignments heard from the server
 336         PlayerAssignmentMap m_PlayerAssignments;
 337
 338         /// Globally unique identifier to distinguish users beyond the lifetime of a single network session
 339         CStr m_GUID;
 340
 341         /// Queue of messages for GuiPoll
 342         std::deque<JS::Heap<JS::Value>> m_GuiMessageQueue;
 343
 344         /// Serialized game state received when joining an in-progress game
 345         std::string m_JoinSyncBuffer;
 346
 347         /// Time when the server was last checked for timeouts and bad latency
 348         std::time_t m_LastConnectionCheck;
 349 };
 350
 351 /// Global network client for the standard game
 352 extern CNetClient *g_NetClient;
 353
 354 #endif  // NETCLIENT_H