source/network/NetClient.h

   1 /* Copyright (C) 2017 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/ScriptVal.h"
  25
  26 #include "ps/CStr.h"
  27
  28 #include <deque>
  29
  30 class CGame;
  31 class CNetClientSession;
  32 class CNetClientTurnManager;
  33 class CNetServer;
  34 class ScriptInterface;
  35
  36 typedef struct _ENetHost ENetHost;
  37
  38 // NetClient session FSM states
  39 enum
  40 {
  41         NCS_UNCONNECTED,
  42         NCS_CONNECT,
  43         NCS_HANDSHAKE,
  44         NCS_AUTHENTICATE,
  45         NCS_INITIAL_GAMESETUP,
  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, bool isLocalClient);
  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          * Returns the GUID of the local client.
  95          * Used for distinguishing observers.
  96          */
  97         CStr GetGUID() const { return m_GUID; }
  98
  99         /**
 100          * Set up a connection to the remote networked server.
 101          * @param server IP address or host name to connect to
 102          * @return true on success, false on connection failure
 103          */
 104         bool SetupConnection(const CStr& server, const u16 port, ENetHost* enetClient = NULL);
 105
 106         /**
 107          * Destroy the connection to the server.
 108          * This client probably cannot be used again.
 109          */
 110         void DestroyConnection();
 111
 112         /**
 113          * Poll the connection for messages from the server and process them, and send
 114          * any queued messages.
 115          * This must be called frequently (i.e. once per frame).
 116          */
 117         void Poll();
 118
 119         /**
 120          * Locally triggers a GUI message if the connection to the server is being lost or has bad latency.
 121          */
 122         void CheckServerConnection();
 123
 124         /**
 125          * Flush any queued outgoing network messages.
 126          * This should be called soon after sending a group of messages that may be batched together.
 127          */
 128         void Flush();
 129
 130         /**
 131          * Retrieves the next queued GUI message, and removes it from the queue.
 132          * The returned value is in the GetScriptInterface() JS context.
 133          *
 134          * This is the only mechanism for the networking code to send messages to
 135          * the GUI - it is pull-based (instead of push) so the engine code does not
 136          * need to know anything about the code structure of the GUI scripts.
 137          *
 138          * The structure of the messages is <code>{ "type": "...", ... }</code>.
 139          * The exact types and associated data are not specified anywhere - the
 140          * implementation and GUI scripts must make the same assumptions.
 141          *
 142          * @return next message, or the value 'undefined' if the queue is empty
 143          */
 144         void GuiPoll(JS::MutableHandleValue);
 145
 146         /**
 147          * Add a message to the queue, to be read by GuiPoll.
 148          * The script value must be in the GetScriptInterface() JS context.
 149          */
 150         void PushGuiMessage(const JS::HandleValue message);
 151
 152         /**
 153          * Return a concatenation of all messages in the GUI queue,
 154          * for test cases to easily verify the queue contents.
 155          */
 156         std::string TestReadGuiMessages();
 157
 158         /**
 159          * Get the script interface associated with this network client,
 160          * which is equivalent to the one used by the CGame in the constructor.
 161          */
 162         ScriptInterface& GetScriptInterface();
 163
 164         /**
 165          * Send a message to the server.
 166          * @param message message to send
 167          * @return true on success
 168          */
 169         bool SendMessage(const CNetMessage* message);
 170
 171         /**
 172          * Call when the network connection has been successfully initiated.
 173          */
 174         void HandleConnect();
 175
 176         /**
 177          * Call when the network connection has been lost.
 178          */
 179         void HandleDisconnect(u32 reason);
 180
 181         /**
 182          * Call when a message has been received from the network.
 183          */
 184         bool HandleMessage(CNetMessage* message);
 185
 186         /**
 187          * Call when the game has started and all data files have been loaded,
 188          * to signal to the server that we are ready to begin the game.
 189          */
 190         void LoadFinished();
 191
 192         void SendGameSetupMessage(JS::MutableHandleValue attrs, ScriptInterface& scriptInterface);
 193
 194         void SendAssignPlayerMessage(const int playerID, const CStr& guid);
 195
 196         void SendChatMessage(const std::wstring& text);
 197
 198         void SendReadyMessage(const int status);
 199
 200         void SendClearAllReadyMessage();
 201
 202         void SendStartGameMessage();
 203
 204         /**
 205          * Call when the client has rejoined a running match and finished
 206          * the loading screen.
 207          */
 208         void SendRejoinedMessage();
 209
 210         /**
 211          * Call to kick/ban a client
 212          */
 213         void SendKickPlayerMessage(const CStrW& playerName, bool ban);
 214
 215         /**
 216          * Call when the client has paused or unpaused the game.
 217          */
 218         void SendPausedMessage(bool pause);
 219
 220 private:
 221         // Net message / FSM transition handlers
 222         static bool OnConnect(void* context, CFsmEvent* event);
 223         static bool OnHandshake(void* context, CFsmEvent* event);
 224         static bool OnHandshakeResponse(void* context, CFsmEvent* event);
 225         static bool OnAuthenticate(void* context, CFsmEvent* event);
 226         static bool OnChat(void* context, CFsmEvent* event);
 227         static bool OnReady(void* context, CFsmEvent* event);
 228         static bool OnGameSetup(void* context, CFsmEvent* event);
 229         static bool OnPlayerAssignment(void* context, CFsmEvent* event);
 230         static bool OnInGame(void* context, CFsmEvent* event);
 231         static bool OnGameStart(void* context, CFsmEvent* event);
 232         static bool OnJoinSyncStart(void* context, CFsmEvent* event);
 233         static bool OnJoinSyncEndCommandBatch(void* context, CFsmEvent* event);
 234         static bool OnRejoined(void* context, CFsmEvent* event);
 235         static bool OnKicked(void* context, CFsmEvent* event);
 236         static bool OnClientTimeout(void* context, CFsmEvent* event);
 237         static bool OnClientPerformance(void* context, CFsmEvent* event);
 238         static bool OnClientsLoading(void* context, CFsmEvent* event);
 239         static bool OnClientPaused(void* context, CFsmEvent* event);
 240         static bool OnLoadedGame(void* context, CFsmEvent* event);
 241
 242         /**
 243          * Take ownership of a session object, and use it for all network communication.
 244          */
 245         void SetAndOwnSession(CNetClientSession* session);
 246
 247         /**
 248          * Push a message onto the GUI queue listing the current player assignments.
 249          */
 250         void PostPlayerAssignmentsToScript();
 251
 252         CGame *m_Game;
 253         CStrW m_UserName;
 254
 255         /// Current network session (or NULL if not connected)
 256         CNetClientSession* m_Session;
 257
 258         /// Turn manager associated with the current game (or NULL if we haven't started the game yet)
 259         CNetClientTurnManager* m_ClientTurnManager;
 260
 261         /// Unique-per-game identifier of this client, used to identify the sender of simulation commands
 262         u32 m_HostID;
 263
 264         /// True if the player is currently rejoining or has already rejoined the game.
 265         bool m_Rejoin;
 266
 267         /// Whether to prevent the client of the host from timing out
 268         bool m_IsLocalClient;
 269
 270         /// Latest copy of game setup attributes heard from the server
 271         JS::PersistentRootedValue m_GameAttributes;
 272
 273         /// Latest copy of player assignments heard from the server
 274         PlayerAssignmentMap m_PlayerAssignments;
 275
 276         /// Globally unique identifier to distinguish users beyond the lifetime of a single network session
 277         CStr m_GUID;
 278
 279         /// Queue of messages for GuiPoll
 280         std::deque<JS::Heap<JS::Value>> m_GuiMessageQueue;
 281
 282         /// Serialized game state received when joining an in-progress game
 283         std::string m_JoinSyncBuffer;
 284
 285         /// Time when the server was last checked for timeouts and bad latency
 286         std::time_t m_LastConnectionCheck;
 287 };
 288
 289 /// Global network client for the standard game
 290 extern CNetClient *g_NetClient;
 291
 292 #endif  // NETCLIENT_H