Ticket #3556: t3556_dedicated_server_WIP_v0.1.patch

source/network/DedicatedServer.cpp

@@ +1 @@
+/* Copyright (C) 2015 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/>.
+ */
+
+//#include "precompiled.h" ??
+
+#include "DedicatedServer.h"
+#include "ps/CLogger.h"
+
+u8 g_DedicatedHostPlayers = 0;
+
+// TODO: make this a friend class of NetServer/NetServerWorker
+// TODO: manage SERVER_STATE
+// TODO: use ReplayLogger
+// TODO: end the game when somebody won
+// TODO: end the game when everybody left
+// TODO: start a new game after one finished
+
+void DedicatedServer::InitGameAttributes(ScriptInterface* scriptInterface, CNetServerWorker* serverWorker)
+{
+    LOGERROR("[HOST] Initialize game-attributes");
+
+    CStrW serverName(L"Autohost");
+    //if (g_args.Has("dedicated-host-name"))
+    //  serverName = wstring_from_utf8(g_args.Get("dedicated-host-name"));
+
+    JSContext* cx = scriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+
+    // Needs to be kept in sync with gamesetup.js
+    JS::RootedValue attribs(cx);
+    JS::RootedValue settings(cx);
+    JS::RootedValue playerAssignments(cx);
+    JS::RootedValue PlayerData(cx);
+    JS::RootedValue VictoryScripts(cx);
+
+    scriptInterface->Eval("({})", &attribs);
+    scriptInterface->Eval("({})", &settings);
+    scriptInterface->Eval("({})", &playerAssignments);
+    scriptInterface->Eval("([])", &PlayerData);
+    scriptInterface->Eval("([\"scripts/TriggerHelper.js\",\"scripts/ConquestCommon.js\",\"scripts/Conquest.js\"])", &VictoryScripts);
+
+    scriptInterface->SetProperty(settings, "AISeed", rand());
+    scriptInterface->SetProperty(settings, "Seed", rand());
+    scriptInterface->SetProperty(settings, "Ceasefire", 0);
+    scriptInterface->SetProperty(settings, "CheatsEnabled", false);
+    scriptInterface->SetProperty(settings, "GameType", std::wstring(L"conquest"));
+    scriptInterface->SetProperty(settings, "PlayerData", PlayerData);
+    scriptInterface->SetProperty(settings, "PopulationCap", 300);
+    scriptInterface->SetProperty(settings, "Size", 320); // map size 4
+    scriptInterface->SetProperty(settings, "StartingResources", 500); // medium res for nomad
+    scriptInterface->SetProperty(settings, "VictoryScripts", VictoryScripts);
+// disable treasure, no revealed map, no explored map
+    // "timestamp": "1446043600",
+    // "engine_version": "0.0.19",
+    // "mods": ["mod","public"]
+    //"Preview": "acropolis_bay.png",
+    //CircularMap
+    //Description
+    scriptInterface->SetProperty(attribs, "gameSpeed", 1);
+    scriptInterface->SetProperty(attribs, "isNetworked", true);
+    scriptInterface->SetProperty(attribs, "map", std::wstring(L"random"));
+    scriptInterface->SetProperty(attribs, "mapFilter", std::wstring(L"default"));
+    scriptInterface->SetProperty(attribs, "mapPath", std::wstring(L"maps/random/"));
+    scriptInterface->SetProperty(attribs, "mapType", std::wstring(L"random"));
+    scriptInterface->SetProperty(attribs, "matchID", ps_generate_guid().FromUTF8());
+    scriptInterface->SetProperty(attribs, "playerAssignments", playerAssignments);
+    scriptInterface->SetProperty(attribs, "serverName", serverName);
+    scriptInterface->SetProperty(attribs, "settings", settings);
+
+    serverWorker->UpdateGameAttributes(&attribs);
+}
+
+void DedicatedServer::UpdatePlayerAssignments(ScriptInterface& scriptInterface, CNetServerWorker& serverWorker)
+{
+    JSContext* cx = scriptInterface.GetContext();
+    JSAutoRequest rq(cx);
+
+    JS::RootedValue attribs(cx);
+    JS::RootedValue settings(cx);
+    JS::RootedValue PlayerData(cx);
+
+    attribs.set(serverWorker.m_GameAttributes.get());
+    scriptInterface.GetProperty(attribs, "settings", &settings);
+    scriptInterface.Eval("([])", &PlayerData);
+
+    // Find all player IDs in active use
+/*  std::set<i32> usedIDs;
+    for (PlayerAssignmentMap::iterator it = worker..m_PlayerAssignments.begin(); it != m_PlayerAssignments.end(); ++it)
+        if (it->second.m_Enabled && it->second.m_PlayerID != -1)
+            usedIDs.insert(it->second.m_PlayerID);
+*/
+    // Update player data
+    for (u8 i=0; i < serverWorker.m_PlayerAssignments.size(); i++)
+    {
+        JS::RootedValue player(cx);
+        scriptInterface.Eval("({})", &player);
+        //scriptInterface.SetProperty(player, "Name", "Some player");
+        scriptInterface.SetProperty(player, "Team", -1);
+        scriptInterface.SetProperty(player, "Civ", std::wstring(L"random"));
+        scriptInterface.SetProperty(player, "AI", std::wstring(L""));
+        scriptInterface.SetProperty(player, "AiDiff", 3);
+        scriptInterface.SetPropertyInt(PlayerData, i, player);
+    }
+    scriptInterface.SetProperty(settings, "PlayerData", PlayerData);
+
+    // Limit pop cap according to playercount
+    std::map<int,int> popCaps = {
+       {1, 300}, // 600 pop total, 700 with wonder
+       {2, 300}, // 600 pop total, 750 with wonder
+       {3, 200}, // 600 pop total, 750 with wonder
+       {4, 200}, // 800 pop total, 1000 with wonder
+       {5, 150}, // 750 pop total, 1000 with wonder
+       {6, 150}, // 900 pop total, 1200 with wonder
+       {7, 100}, // 700 pop total, 1050 with wonder
+       {8, 100}  // 800 pop total, 1200 with wonder
+    };
+    scriptInterface.SetProperty(settings, "PopulationCap", popCaps[serverWorker.m_PlayerAssignments.size()]);
+
+    scriptInterface.SetProperty(attribs, "settings", settings);
+
+    serverWorker.UpdateGameAttributes(&attribs);
+
+    // Also sends the player assignments
+    serverWorker.ClearAllPlayerReady();
+}
+
+void DedicatedServer::OnChat(CNetServerSession* session, CChatMessage* message)
+{
+    // CNetServerWorker& serverWorker = session->GetServer();
+    LOGERROR("[HOST] %s: %s", utf8_from_wstring(session->GetUserName().c_str()), utf8_from_wstring(message->m_Message));
+}
+
+void DedicatedServer::OnReady(CNetServerSession* session, CReadyMessage* message)
+{
+    // CNetServerWorker& serverWorker = session->GetServer();
+    LOGERROR("[HOST] %s is %s", utf8_from_wstring(session->GetUserName().c_str()), message->m_Status ? "ready " : "not ready");
+    // TODO: start game if all are ready
+    // StartGame();
+}
+
+void DedicatedServer::OnUserJoin(ScriptInterface* m_ScriptInterface, CNetServerSession* session)
+{
+    CNetServerWorker& serverWorker = session->GetServer();
+    ++g_DedicatedHostPlayers;
+    // TODO: if game has started, show "is starting to rejoin"
+    LOGERROR("[HOST] %s has joined (%s)", utf8_from_wstring(session->GetUserName()).c_str(), session->GetIPAddress().c_str());
+    UpdatePlayerAssignments(*m_ScriptInterface, serverWorker);
+}
+
+void DedicatedServer::OnUserLeave(ScriptInterface* m_ScriptInterface, CNetServerSession* session)
+{
+    CNetServerWorker& serverWorker = session->GetServer();
+    --g_DedicatedHostPlayers;
+    LOGERROR("[HOST] %s has left", utf8_from_wstring(session->GetUserName()));
+    UpdatePlayerAssignments(*m_ScriptInterface, serverWorker);
+}
+
+void DedicatedServer::OnUserRejoined(CNetServerSession* session)
+{
+    CNetServerWorker& serverWorker = session->GetServer();
+    LOGERROR("[HOST] %s has finished rejoining.", utf8_from_wstring(serverWorker.m_PlayerAssignments[session->GetGUID()].m_Name.c_str()));
+}
+
+void DedicatedServer::OnStartGame()
+{
+    LOGERROR("[HOST] The game has started.");
+}

source/network/DedicatedServer.h

@@ +1 @@
+/* Copyright (C) 2015 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/>.
+ */
+
+// TODO: some ifndef define ?
+
+#include "NetServer.h"
+#include "NetSession.h"
+#include "NetMessage.h"
+
+#include "ps/GUID.h"
+#include "scriptinterface/ScriptInterface.h"
+
+/**
+ * Contains functions used by the dedicated server.
+ */
+namespace DedicatedServer
+{
+
+/*
+ * Contains the default gamesetup atributes for autohosted games.
+ *
+ * TODO: load from a JSON file
+ */
+void InitGameAttributes(ScriptInterface* scriptInterface, CNetServerWorker* serverWorker);
+
+/**
+ * Sets the number of players to the number of connected clients,
+ * assigns unassigned players to unassigned slots,
+ * reduces the population count accordingly,
+ * resets ready states,
+ * sends the player assignments.
+ */
+void UpdatePlayerAssignments(ScriptInterface& scriptInterface, CNetServerWorker& serverWorker);
+
+/**
+ * Lets the users chose their own civs and team numbers.
+ *
+ * TODO: we should let the clients chose their civs and team numbers (but nothing else) via the regular GUI elements
+ */
+void OnChat(CNetServerSession* session, CChatMessage* message);
+
+/**
+ * Starts the game if all players are ready.
+ */
+void OnReady(CNetServerSession* session, CReadyMessage* message);
+
+/**
+ * Updates the player assignments.
+ */
+void OnUserJoin(ScriptInterface* scriptInterface, CNetServerSession* session);
+
+/**
+ * Updates the player assignments.
+ */
+void OnUserLeave(ScriptInterface* scriptInterface, CNetServerSession* session);
+
+/**
+ * Used for logging only.
+ */
+void OnUserRejoined(CNetServerSession* session);
+
+/**
+ * Used for logging only.
+ */
+void OnStartGame();
+
+}

source/network/NetServer.cpp

@@ -17 +17 @@
 
 #include "precompiled.h"
 
 #include "NetServer.h"
 
+#include "DedicatedServer.h"
 #include "NetClient.h"
 #include "NetMessage.h"
 #include "NetSession.h"
 #include "NetStats.h"
 #include "NetTurnManager.h"
@@ -116 +117 @@
  * XXX: We use some non-threadsafe functions from the worker thread.
  * See http://trac.wildfiregames.com/ticket/654
  */
 
 CNetServerWorker::CNetServerWorker(int autostartPlayers) :
+    m_IsDedicated(false),
     m_AutostartPlayers(autostartPlayers),
     m_Shutdown(false),
     m_ScriptInterface(NULL),
     m_NextHostID(1), m_Host(NULL), m_Stats(NULL)
 {
@@ -353 +355 @@
     return ok;
 }
 
 void* CNetServerWorker::RunThread(void* data)
 {
+    LOGERROR("CNetServerWorker::RunThread");
     debug_SetThreadName("NetServer");
 
     static_cast<CNetServerWorker*>(data)->Run();
 
     return NULL;
 }
 
 void CNetServerWorker::Run()
 {
+    LOGMESSAGE("CNetServerWorker::Run");
+
     // The script runtime uses the profiler and therefore the thread must be registered before the runtime is created
     g_Profiler2.RegisterCurrentThread("Net server");
-    
+
     // To avoid the need for JS_SetContextThread, we create and use and destroy
     // the script interface entirely within this network thread
     m_ScriptInterface = new ScriptInterface("Engine", "Net server", ScriptInterface::CreateRuntime(g_ScriptRuntime));
     m_GameAttributes.set(m_ScriptInterface->GetJSRuntime(), JS::UndefinedValue());
 
+    if (m_IsDedicated)
+        DedicatedServer::InitGameAttributes(m_ScriptInterface, this);
+
     while (true)
     {
         if (!RunStep())
             break;
 
@@ -617 +625 @@
     return session->SendMessage(&handshake);
 }
 
 void CNetServerWorker::OnUserJoin(CNetServerSession* session)
 {
-    AddPlayer(session->GetGUID(), session->GetUserName());
+    if (m_IsDedicated)
+        DedicatedServer::OnUserJoin(m_ScriptInterface, session);
+    else
+        AddPlayer(session->GetGUID(), session->GetUserName());
 
     CGameSetupMessage gameSetupMessage(GetScriptInterface());
     gameSetupMessage.m_Data = m_GameAttributes.get();
     session->SendMessage(&gameSetupMessage);
 
@@ -630 +641 @@
     session->SendMessage(&assignMessage);
 }
 
 void CNetServerWorker::OnUserLeave(CNetServerSession* session)
 {
-    RemovePlayer(session->GetGUID());
+    if (m_IsDedicated)
+        DedicatedServer::OnUserLeave(m_ScriptInterface, session);
+    else
+        RemovePlayer(session->GetGUID());
 
     if (m_ServerTurnManager && session->GetCurrState() != NSS_JOIN_SYNCING)
         m_ServerTurnManager->UninitialiseClient(session->GetHostID()); // TODO: only for non-observers
 
     // TODO: ought to switch the player controlled by that client
@@ -918 +932 @@
 
     CChatMessage* message = (CChatMessage*)event->GetParamRef();
 
     message->m_GUID = session->GetGUID();
 
+    if (server.m_IsDedicated)
+        DedicatedServer::OnChat(session, message);
+
     server.Broadcast(message);
 
     return true;
 }
 
@@ -936 +953 @@
 
     message->m_GUID = session->GetGUID();
 
     server.Broadcast(message);
 
+    if (server.m_IsDedicated)
+        DedicatedServer::OnReady(session, message);
+
     return true;
 }
 
 bool CNetServerWorker::OnLoadedGame(void* context, CFsmEvent* event)
 {
@@ -1017 +1037 @@
 
     CRejoinedMessage* message = (CRejoinedMessage*)event->GetParamRef();
 
     message->m_GUID = session->GetGUID();
 
+    if (server.m_IsDedicated)
+        DedicatedServer::OnUserRejoined(session);
+
     server.Broadcast(message);
 
     return true;
 }
 
@@ -1051 +1074 @@
     m_State = SERVER_STATE_INGAME;
 }
 
 void CNetServerWorker::StartGame()
 {
+    if (m_IsDedicated)
+        DedicatedServer::OnStartGame();
+
     m_ServerTurnManager = new CNetServerTurnManager(*this);
 
     for (size_t i = 0; i < m_Sessions.size(); ++i)
         m_ServerTurnManager->InitialiseClient(m_Sessions[i]->GetHostID(), 0); // TODO: only for non-observers
 
@@ -1081 +1107 @@
     m_GameAttributes.set(m_ScriptInterface->GetJSRuntime(), attrs);
 
     if (!m_Host)
         return;
 
+    if (m_IsDedicated)
+        LOGMESSAGE("[HOST] The game settings have been updated.");
+
     CGameSetupMessage gameSetupMessage(GetScriptInterface());
     gameSetupMessage.m_Data.set(m_GameAttributes.get());
     Broadcast(&gameSetupMessage);
 }
 
@@ -1151 +1180 @@
 bool CNetServer::SetupConnection()
 {
     return m_Worker->SetupConnection();
 }
 
+void CNetServer::StartDedicatedHost()
+{
+    m_Worker->m_IsDedicated = true;
+
+    LOGMESSAGE("[HOST] Starting dedicated host");
+
+    if (!m_Worker->SetupConnection())
+    {
+        LOGERROR("ERROR: Could not start the server!\n");
+        SAFE_DELETE(g_NetServer);
+        return;
+    }
+
+    // TODO: loop 'til doomsday?
+    while (true);
+}
+
 void CNetServer::AssignPlayer(int playerID, const CStr& guid)
 {
     CScopeLock lock(m_Worker->m_WorkerMutex);
     m_Worker->m_AssignPlayerQueue.emplace_back(playerID, guid);
 }

source/network/NetServer.h

@@ -114 +114 @@
      * @return true on success, false on error (e.g. port already in use)
      */
     bool SetupConnection();
 
     /**
+     * Start the actual hosting.
+     */
+    void StartDedicatedHost();
+
+    /**
      * 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 asynchronously propagated to all clients.
      */
@@ -186 +191 @@
      * 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);
 
-private:
+public:
     friend class CNetServer;
     friend class CNetFileReceiveTask_ServerRejoin;
 
     CNetServerWorker(int autostartPlayers);
     ~CNetServerWorker();
@@ -294 +299 @@
 
     CNetStatsTable* m_Stats;
 
     NetServerState m_State;
 
+    bool m_IsDedicated;
+
     CStrW m_ServerName;
     CStrW m_WelcomeMessage;
 
     u32 m_NextHostID;
 

source/network/NetSession.cpp

@@ -76 +76 @@
         g_ProfileViewer.AddRootTable(m_Stats);
 
     return true;
 }
 
+CStr CNetServerSession::GetIPAddress()
+{
+    char ipAddress[256] = "(error)";
+    enet_address_get_host_ip(&(m_Peer->address), ipAddress, ARRAY_SIZE(ipAddress));
+    return CStr(ipAddress);
+}
+
 void CNetClientSession::Disconnect(u32 reason)
 {
     ENSURE(m_Host && m_Server);
 
     // TODO: ought to do reliable async disconnects, probably

source/network/NetSession.h

@@ -120 +120 @@
     void SetUserName(const CStrW& name) { m_UserName = name; }
 
     u32 GetHostID() const { return m_HostID; }
     void SetHostID(u32 id) { m_HostID = id; }
 
+    /**
+     * Returns the IP address of the client.
+     */
+    CStr GetIPAddress();
+
     /**
      * Sends a disconnection notification to the client,
      * and sends a NMT_CONNECTION_LOST message to the session FSM.
      * The server will receive a disconnection notification after a while.
      * The server will not receive any further messages sent via this session.

source/ps/GameSetup/GameSetup.cpp

@@ -45 +45 @@
 #include "gui/GUI.h"
 #include "gui/GUIManager.h"
 #include "gui/scripting/ScriptFunctions.h"
 #include "i18n/L10n.h"
 #include "maths/MathUtil.h"
+#include "network/DedicatedServer.h"
 #include "network/NetServer.h"
 #include "network/NetClient.h"
 
 #include "ps/CConsole.h"
 #include "ps/CLogger.h"
@@ -1190 +1191 @@
  * -autostart="random/alpine_lakes" -autostart-seed=-1 -autostart-players=2 -autostart-civ=1:athen -autostart-civ=2:brit -autostart-ai=2:petra
 */
 bool Autostart(const CmdLineArgs& args)
 {
     CStr autoStartName = args.Get("autostart");
-
-    if (autoStartName.empty())
+    if (autoStartName.empty() && !args.Has("dedicated-host"))
         return false;
 
     g_Game = new CGame();
 
     ScriptInterface& scriptInterface = g_Game->GetSimulation2()->GetScriptInterface();
@@ -1298 +1298 @@
         if (mapDirectory == L"scenarios")
             mapType = "scenario";
         else
             mapType = "skirmish";
     }
-    else
+    else if (!args.Has("dedicated-host"))
     {
         LOGERROR("Autostart: Unrecognized map type '%s'", utf8_from_wstring(mapDirectory));
         throw PSERROR_Game_World_MapLoadFailed("Unrecognized map type.\nConsult readme.txt for the currently supported types.");
     }
+
     scriptInterface.SetProperty(attrs, "mapType", mapType);
     scriptInterface.SetProperty(attrs, "map", std::string("maps/" + autoStartName));
     scriptInterface.SetProperty(settings, "mapType", mapType);
 
     // Set seed for AIs
@@ -1422 +1423 @@
     if (args.Has("autostart-playername"))
     {
         userName = args.Get("autostart-playername").FromUTF8();
     }
 
-    if (args.Has("autostart-host"))
+    if (args.Has("dedicated-host"))
+    {
+        g_NetServer = new CNetServer();
+        g_NetServer->StartDedicatedHost();
+        CXeromyces::Terminate();
+        return true;
+    }
+    else if (args.Has("autostart-host"))
     {
         InitPs(true, L"page_loading.xml", &scriptInterface, mpInitData);
 
         size_t maxPlayers = 2;
         if (args.Has("autostart-host-players"))