Ykkrosh
31699e830d
Remove local sessions (just use ENet for everything instead) because they add far too much complexity. Fix memory leaks. This was SVN commit r7706.
227 lines
6.5 KiB
C++
227 lines
6.5 KiB
C++
/* Copyright (C) 2010 Wildfire Games.
|
|
* This file is part of 0 A.D.
|
|
*
|
|
* 0 A.D. 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 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* 0 A.D. 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 0 A.D. If not, see <http://www.gnu.org/licenses/>.
|
|
*/
|
|
|
|
#ifndef NETSERVER_H
|
|
#define NETSERVER_H
|
|
|
|
#include "NetHost.h"
|
|
|
|
#include "scriptinterface/ScriptVal.h"
|
|
|
|
#include <vector>
|
|
|
|
class CNetServerSession;
|
|
class CNetServerTurnManager;
|
|
class CFsmEvent;
|
|
class ScriptInterface;
|
|
class CPlayerAssignmentMessage;
|
|
class CNetStatsTable;
|
|
|
|
enum NetServerState
|
|
{
|
|
// We haven't opened the port yet, we're just setting some stuff up.
|
|
// This is probably equivalent to the first "Start Network Game" screen
|
|
SERVER_STATE_UNCONNECTED,
|
|
|
|
// The server is open and accepting connections. This is the screen where
|
|
// rules are set up by the operator and where players join and select civs
|
|
// and stuff.
|
|
SERVER_STATE_PREGAME,
|
|
|
|
// All the hosts are connected and are loading the game
|
|
SERVER_STATE_LOADING,
|
|
|
|
// The one with all the killing ;-)
|
|
SERVER_STATE_INGAME,
|
|
|
|
// The game is over and someone has won. Players might linger to chat or
|
|
// download the replay log.
|
|
SERVER_STATE_POSTGAME
|
|
};
|
|
|
|
/**
|
|
* Server session representation of client state
|
|
*/
|
|
enum NetServerSessionState
|
|
{
|
|
// The client has disconnected or been disconnected
|
|
NSS_UNCONNECTED,
|
|
|
|
// The client has just connected and we're waiting for its handshake message,
|
|
// to agree on the protocol version
|
|
NSS_HANDSHAKE,
|
|
|
|
// The client has handshook and we're waiting for its authentication message,
|
|
// to find its name and check its password etc
|
|
NSS_AUTHENTICATE,
|
|
|
|
// The client has fully joined, and is in the pregame setup stage
|
|
// or is loading the game.
|
|
// Server must be in SERVER_STATE_PREGAME or SERVER_STATE_LOADING.
|
|
NSS_PREGAME,
|
|
|
|
// The client is running the game.
|
|
// Server must be in SERVER_STATE_LOADING or SERVER_STATE_INGAME.
|
|
NSS_INGAME
|
|
};
|
|
|
|
/**
|
|
* Network server.
|
|
* Handles all the coordination between players.
|
|
* One person runs this object, and every player (including the host) connects their CNetClient to it.
|
|
*
|
|
* TODO: ideally the ENet server would run in a separate thread so it can receive
|
|
* and forward messages with minimal latency. But that's not supported now.
|
|
*/
|
|
class CNetServer
|
|
{
|
|
NONCOPYABLE(CNetServer);
|
|
public:
|
|
CNetServer();
|
|
virtual ~CNetServer();
|
|
|
|
/**
|
|
* Get the current server's connection/game state.
|
|
*/
|
|
NetServerState GetState() const { return m_State; }
|
|
|
|
/**
|
|
* Begin listening for network connections.
|
|
* @return true on success, false on error (e.g. port already in use)
|
|
*/
|
|
bool SetupConnection();
|
|
|
|
/**
|
|
* Poll the connections for messages from clients and process them, and send
|
|
* any queued messages.
|
|
* This must be called frequently (i.e. once per frame).
|
|
*/
|
|
virtual void Poll();
|
|
|
|
/**
|
|
* Flush any queued outgoing network messages.
|
|
* This should be called soon after sending a group of messages that may be batched together.
|
|
*/
|
|
void Flush();
|
|
|
|
/**
|
|
* Send a message to the given network peer.
|
|
*/
|
|
bool SendMessage(ENetPeer* peer, const CNetMessage* message);
|
|
|
|
/**
|
|
* Send a message to all clients who have completed the full connection process
|
|
* (i.e. are in the pre-game or in-game states).
|
|
*/
|
|
bool Broadcast(const CNetMessage* message);
|
|
|
|
/**
|
|
* Call from the GUI to update the player assignments.
|
|
* The given GUID will be (re)assigned to the given player ID.
|
|
* Any player currently using that ID will be unassigned.
|
|
* The changes will be propagated to all clients.
|
|
*/
|
|
void AssignPlayer(int playerID, const CStr& guid);
|
|
|
|
/**
|
|
* Call from the GUI to notify all clients that they should start loading the game.
|
|
*/
|
|
void StartGame();
|
|
|
|
/**
|
|
* Call from the GUI to update the game setup attributes.
|
|
* This must be called at least once before starting the game.
|
|
* The changes will be propagated to all clients.
|
|
* @param attrs game attributes, in the script context of GetScriptInterface()
|
|
*/
|
|
void UpdateGameAttributes(const CScriptValRooted& attrs);
|
|
|
|
/**
|
|
* Make a player name 'nicer' by limiting the length and removing forbidden characters etc.
|
|
*/
|
|
static CStrW SanitisePlayerName(const CStrW& original);
|
|
|
|
/**
|
|
* Make a player name unique, if it matches any existing session's name.
|
|
*/
|
|
CStrW DeduplicatePlayerName(const CStrW& original);
|
|
|
|
/**
|
|
* Get the script context used for game attributes.
|
|
*/
|
|
ScriptInterface& GetScriptInterface();
|
|
|
|
protected:
|
|
/// Callback for autostart; called when a player has finished connecting
|
|
virtual void OnAddPlayer() { }
|
|
/// Callback for autostart; called when a player has left the game
|
|
virtual void OnRemovePlayer() { }
|
|
|
|
private:
|
|
void AddPlayer(const CStr& guid, const CStrW& name);
|
|
void RemovePlayer(const CStr& guid);
|
|
void SendPlayerAssignments();
|
|
PlayerAssignmentMap m_PlayerAssignments;
|
|
|
|
CScriptValRooted m_GameAttributes;
|
|
|
|
void SetupSession(CNetServerSession* session);
|
|
bool HandleConnect(CNetServerSession* session);
|
|
|
|
void OnUserJoin(CNetServerSession* session);
|
|
void OnUserLeave(CNetServerSession* session);
|
|
|
|
static bool OnClientHandshake(void* context, CFsmEvent* event);
|
|
static bool OnAuthenticate(void* context, CFsmEvent* event);
|
|
static bool OnInGame(void* context, CFsmEvent* event);
|
|
static bool OnChat(void* context, CFsmEvent* event);
|
|
static bool OnLoadedGame(void* context, CFsmEvent* event);
|
|
static bool OnDisconnect(void* context, CFsmEvent* event);
|
|
|
|
void CheckGameLoadStatus(CNetServerSession* changedSession);
|
|
|
|
void ConstructPlayerAssignmentMessage(CPlayerAssignmentMessage& message);
|
|
|
|
void HandleMessageReceive(const CNetMessage* message, CNetServerSession* session);
|
|
|
|
/**
|
|
* Internal script context for (de)serializing script messages.
|
|
* (TODO: we shouldn't bother deserializing (except for debug printing of messages),
|
|
* we should just forward messages blindly and efficiently.)
|
|
*/
|
|
ScriptInterface* m_ScriptInterface;
|
|
|
|
ENetHost* m_Host;
|
|
std::vector<CNetServerSession*> m_Sessions;
|
|
|
|
CNetStatsTable* m_Stats;
|
|
|
|
NetServerState m_State;
|
|
|
|
CStrW m_ServerName;
|
|
CStrW m_WelcomeMessage;
|
|
|
|
u32 m_NextHostID;
|
|
|
|
CNetServerTurnManager* m_ServerTurnManager;
|
|
};
|
|
|
|
/// Global network server for the standard game
|
|
extern CNetServer *g_NetServer;
|
|
|
|
#endif // NETSERVER_H
|