Ticket #3556: t3556_dedicated_server_WIP_v0.3.patch

binaries/system/readme.txt

@@ -4 +4 @@
 -autostart=...      load a map instead of showing main menu (see below)
 -editor             launch the Atlas scenario editor
 -mod=NAME           start the game using NAME mod
 -quickstart         load faster (disables audio and some system info logging)
 
+Dedicated Server:
+-dedicated-host                 starts a dedicated multiplayer server (without graphics)
+                                please specify the mods, for example -mod="public"
+-dedicated-lobby                advertize the game of the dedicated host in the lobby
+
 Autostart:
 -autostart="TYPEDIR/MAPNAME"    enables autostart and sets MAPNAME; TYPEDIR is skirmishes, scenarios, or random
 -autostart-ai=PLAYER:AI         sets the AI for PLAYER (e.g. 2:petra)
 -autostart-aidiff=PLAYER:DIFF   sets the DIFFiculty of PLAYER's AI (0: sandbox, 5: very hard)
 -autostart-civ=PLAYER:CIV       sets PLAYER's civilisation to CIV (skirmish and random maps only)

source/main.cpp

@@ -527 +527 @@
         {
             flags &= ~INIT_MODS;
             Shutdown(SHUTDOWN_FROM_CONFIG);
             continue;
         }
+
+        if (args.Has("dedicated-host"))
+        {
+            g_DedicatedServer = new CDedicatedServer();
+            g_DedicatedServer->StartHosting();
+            delete g_DedicatedServer;
+            Shutdown(0);
+            continue;
+        }
+
         InitGraphics(args, 0);
+
         MainControllerInit();
         while (!quit)
             Frame();
         Shutdown(0);
         MainControllerShutdown();
@@ -579 +590 @@
     RunGameOrAtlas(argc, const_cast<const char**>(argv));
 
     // Shut down profiler initialised by EarlyInit
     g_Profiler2.Shutdown();
 
+    // TODO: crash after leaving main with dedicated server!
+
     return EXIT_SUCCESS;
 }

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/>.
+ */
+
+// TODO: use lobby
+// TODO: manage SERVER_STATE
+// TODO: we should let the clients chose their civs and team numbers (but nothing else) via the regular GUI elements
+// TODO: use ReplayLogger
+// TODO: end the game when somebody won or everybody left
+// TODO: start a new game after one finished
+
+// TODO: config option 1: who is allowed to assign? (everyone|first)
+// TODO: config option 2: autocontrol pop limit ? (yes|no)
+
+// TODO: implement a "bouncer"? the server shall allow 9 clients to be connected. 8 players and one observer slot for the host.
+// Maybe the server could list that observer slot as always connected.
+
+// TODO: #include "precompiled.h" ??
+//#include "DedicatedServer.h"
+#include "NetServer.h"
+#include "ps/CLogger.h"
+
+CDedicatedServer* g_DedicatedServer = nullptr;
+
+CDedicatedServer::CDedicatedServer()
+: m_IsHosting(false), m_Quit(false)
+{
+}
+
+CDedicatedServer::~CDedicatedServer()
+{
+}
+
+void CDedicatedServer::StartHosting()
+{
+    LOGERROR("[HOST] Starting dedicated host");
+
+    g_NetServer = new CNetServer(true);
+
+    if (!g_NetServer->m_Worker->SetupConnection())
+    {
+        LOGERROR("[HOST] Could not setup the connection!");
+        Shutdown();
+        return;
+    }
+
+    m_Quit = false;
+    while (!m_Quit)
+        HandleInput();
+}
+
+void CDedicatedServer::Shutdown()
+{
+    LOGERROR("[HOST] Shutting down server");
+    delete g_NetServer;
+    m_Quit = true;
+}
+
+void CDedicatedServer::Restart()
+{
+    Shutdown();
+    StartHosting();
+}
+
+void CDedicatedServer::HandleInput()
+{
+    CStrW input;
+    std::wcin >> input;
+
+    if (input.at(0) == L'/')
+        ParseHostCommand(input);
+    else
+        SendPublicChat(input);
+}
+
+void CDedicatedServer::ParseHostCommand(CStrW input)
+{
+    CStrW command = input.substr(0, input.find(L" "));
+
+         if (command == L"/exit")    Shutdown();
+    else if (command == L"/quit")    Shutdown();
+    else if (command == L"/restart") Restart();
+    // TODO: else if (command == "/shutdown 60") will shutdown in 60 minutes
+    // TODO: else if (command == "/list")
+    // TODO: else if (command == "/kick")
+    // TODO: else if (command == "/ban")
+}
+
+void CDedicatedServer::SendChat(CNetServerSession* session, CStrW text, bool log)
+{
+    CChatMessage* message = new CChatMessage();
+    message->m_GUID = "-1";
+    message->m_Message = text;
+
+    if (session)
+        session->SendMessage(message);
+    else
+        g_NetServer->m_Worker->Broadcast(message);
+
+    if (log)
+        LOGERROR("[HOST] <host>: %s", utf8_from_wstring(text));
+}
+
+void CDedicatedServer::SendPublicChat(CStrW text, bool log)
+{
+    SendChat(nullptr, text, log);
+}
+
+void CDedicatedServer::StartGame()
+{
+    // TODO: return if not everybody is ready
+    g_DedicatedServer_Gamesetup->StartGame();
+    g_NetServer->m_Worker->StartGame();
+}
+
+void CDedicatedServer::OnTick()
+{
+}
+
+void CDedicatedServer::OnChat(CNetServerSession* session, CChatMessage* message)
+{
+    LOGERROR("[HOST] %s: %s", utf8_from_wstring(session->GetUserName().c_str()), utf8_from_wstring(message->m_Message));
+
+    // TODO: only if game has started
+    g_DedicatedServer_Gamesetup->ParsePlayerChatCommand(session, message->m_Message);
+
+    // TODO: @report command
+
+    // TODO: say something if the name of the host is mentioned?
+}
+
+void CDedicatedServer::OnReady(CNetServerSession* session, CReadyMessage* message)
+{
+    LOGERROR("[HOST] %s is %s", utf8_from_wstring(session->GetUserName().c_str()), message->m_Status ? "ready " : "not ready");
+    StartGame();
+}
+
+void CDedicatedServer::OnUserJoin(CNetServerSession* session)
+{
+    LOGERROR("[HOST] Authenticating %s [%s]", utf8_from_wstring(session->GetUserName()).c_str(), session->GetIPAddress().c_str());
+}
+
+void CDedicatedServer::OnGamesetupJoin(CNetServerSession* session)
+{
+    LOGERROR("[HOST] %s has joined the gamesetup.", utf8_from_wstring(session->GetUserName()).c_str());
+    g_DedicatedServer_Gamesetup->SendWelcomeMessage(session);
+    g_DedicatedServer_Gamesetup->UpdatePlayerAssignments();
+}
+
+void CDedicatedServer::OnUserLeave(CNetServerSession* session)
+{
+    LOGERROR("[HOST] %s has left", utf8_from_wstring(session->GetUserName()));
+    g_DedicatedServer_Gamesetup->UpdatePlayerAssignments();
+}
+
+void CDedicatedServer::OnUpdateGameAttributes()
+{
+    LOGERROR("[HOST] Updated game attributes");
+}
+
+void CDedicatedServer::OnUserRejoining(CNetServerSession* session)
+{
+    LOGERROR("[HOST] %s is starting to rejoin the match.", utf8_from_wstring(g_NetServer->m_Worker->m_PlayerAssignments[session->GetGUID()].m_Name.c_str()));
+}
+
+void CDedicatedServer::OnUserRejoined(CNetServerSession* session)
+{
+    LOGERROR("[HOST] %s has finished rejoining.", utf8_from_wstring(g_NetServer->m_Worker->m_PlayerAssignments[session->GetGUID()].m_Name.c_str()));
+}
+
+void CDedicatedServer::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 NETSERVER_H ?
+
+#include "NetServer.h"
+#include "NetSession.h"
+#include "NetMessage.h"
+
+#include "scriptinterface/ScriptInterface.h"
+
+/**
+ * Contains only network functions, no gamesetup.
+ */
+class CDedicatedServer
+{
+    NONCOPYABLE(CDedicatedServer);
+
+private:
+    friend class NetServer;
+    friend class NetServerWorker;
+    friend class DedicatedServer_Gamesetup;
+
+    /**
+     * Whether or not the service is actually running.
+     */
+    bool m_IsHosting;
+
+    /**
+     * Whether or not we wan't to exit the server.
+     */
+    bool m_Quit;
+
+    /**
+     * Processes command-line-interface keystrokes.
+     */
+    void HandleInput();
+
+public: // TODO: can we make this private?
+
+    CDedicatedServer();
+    ~CDedicatedServer();
+
+    /**
+     * Create the host. Starts listening on UDP port 20595 for player connects.
+     */
+    void StartHosting();
+
+    /**
+     * Exit gracefully and safely disconnect all clients.
+     */
+    void Shutdown();
+
+    /**
+     * Exit gracefully and host a fresh instance.
+     */
+    void Restart();
+
+    /*
+     * Sends the given text message to either a client (if session was provided)
+     * or broadcasts to all clients otherwise.
+     */
+    void SendChat(CNetServerSession* session, CStrW text, bool log = false);
+
+    /*
+     * Sends the given text message to either a client (if session was provided)
+     * or broadcasts to all clients otherwise.
+     */
+    void SendPublicChat(CStrW text, bool log = true);
+
+    /*
+     * Searches for commands in the given commandline text-input.
+     */
+    void ParseHostCommand(CStrW input);
+
+    /*
+     * Should not be called after before all players are ready.
+     */
+    void StartGame();
+
+    /**
+     * Called by periodically CNetServerWorker::Run().
+     * Can be used to process asynchronously while the main thread is waiting for user input.
+     */
+    void OnTick();
+
+    /**
+     * Useless as we didn't authenticate the client yet.
+     */
+    void OnUserJoin(CNetServerSession* session);
+
+    /**
+     * A player has joined the gamesetup.
+     */
+    void OnGamesetupJoin(CNetServerSession* session);
+
+    /**
+     * Updates the player assignments.
+     */
+    void OnUserLeave(CNetServerSession* session);
+
+    /**
+     * Lets the users chose their own civs and team numbers.
+     */
+    void OnChat(CNetServerSession* session, CChatMessage* message);
+
+    /**
+     * Called whenever the server updated its settings.
+     */
+    void OnUpdateGameAttributes();
+
+    /**
+     * Starts the game if all players are ready.
+     */
+    void OnReady(CNetServerSession* session, CReadyMessage* message);
+
+    /**
+     * Used for logging only.
+     */
+    void OnStartGame();
+
+    /**
+     * Used for logging only.
+     */
+    void OnUserRejoining(CNetServerSession* session);
+
+    /**
+     * Used for logging only.
+     */
+    void OnUserRejoined(CNetServerSession* session);
+};
+
+extern CDedicatedServer *g_DedicatedServer;

source/network/DedicatedServer_Gamesetup.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 "NetServer.h"
+
+#include "graphics/MapReader.h"
+#include "ps/CLogger.h"
+#include "ps/GUID.h"
+
+// TODO: for A20, remove the whole class and let one/every user in gamesetup.js control through the GUI
+
+CDedicatedServer_Gamesetup* g_DedicatedServer_Gamesetup = nullptr;
+
+// TODO: define default skirmish / scenario maps
+
+/**
+ * Version of this component. Notice the server can be updated without new releases of 0 A.D.
+ */
+const CStrW g_Version = L"0.0.15";
+
+/**
+ * Date of the last update of this component.
+ */
+const CStrW g_LastUpdate = L"9th Nov 2015";
+
+const int g_MaxPlayers = 8;
+
+const std::set<CStrW> g_MapTypes = { L"random", L"skirmish", L"scenario" };
+
+// TODO: move to mapfilters.json and unify with gamesetup.js?
+const std::set<CStrW> g_MapFilters = { L"default", L"all", L"naval", L"demo" };
+
+// TODO: load from game_speeds.json
+const std::set<float> g_GameSpeeds = { 0.10, 0.25, 0.50, 0.75, 1.0, 1.25, 1.5, 2.0 };
+
+// TODO: load from population_capacities.json
+const std::set<int> g_PopulationCapacities = { 50, 100, 150, 200, 250, 300 };
+
+// TODO: load from starting_resources.json
+const std::set<int> g_Resources = { 100, 300, 500, 1000, 3000, 50000 };
+
+// TODO: load from map_sizes.json
+const std::set<int> g_MapSizes = { 128, 192, 256, 320, 384, 448, 512 };
+
+CDedicatedServer_Gamesetup::CDedicatedServer_Gamesetup(ScriptInterface* scriptInterface) :
+        m_ScriptInterface(scriptInterface),
+        m_MapType(L"random"),
+        m_MapPath(L"/maps/random")
+        // m_PlayerCount(0)
+{
+    Initialize();
+}
+
+CDedicatedServer_Gamesetup::~CDedicatedServer_Gamesetup()
+{
+}
+
+void CDedicatedServer_Gamesetup::SendWelcomeMessage(CNetServerSession* session)
+{
+    g_DedicatedServer->SendChat(session, L"Welcome. This is a public hosting service provided by elexis.");
+    g_DedicatedServer->SendChat(session, L"Type '@help' for a list of available commands.");
+    g_DedicatedServer->SendChat(session, L"This server is running dedicated autohost " + g_Version + L", last update on " + g_LastUpdate);
+    g_DedicatedServer->SendChat(session, L"Abuse will be reported.");
+}
+
+void CDedicatedServer_Gamesetup::SendChatCommandList(CNetServerSession* session)
+{
+    // TODO: list available options from constants like g_MapFilters
+    LOGERROR("[HOST] Sending gamesetup command list");
+    g_DedicatedServer->SendChat(session, L"Available commands:");
+    g_DedicatedServer->SendChat(session, L" - @help               - Shows this message.");
+    g_DedicatedServer->SendChat(session, L" - @maptype [type]     - Decide whether to play skirmish, scenario or random map type. Example: @maptype random");
+    g_DedicatedServer->SendChat(session, L" - @mapfilter [type]   - Select which maps to list. Options: default, all, naval, demo. Example: @mapfilter all");
+    g_DedicatedServer->SendChat(session, L" - @listmaps           - Lists valid maps of the current map type.");
+    g_DedicatedServer->SendChat(session, L" - @selectmap [map]    - Changes the map. Example: @selectmap Random");
+    g_DedicatedServer->SendChat(session, L" - @mapsize [size]     - Changes the size of the map. Example: @mapsize Medium");
+    g_DedicatedServer->SendChat(session, L" - @numplayers [num]   - Changes number of players. Example: @numplayers 2");
+    g_DedicatedServer->SendChat(session, L" - @setplayer [num]    - Assigns yourself to a player slot. Example: @setplayer 1");
+    g_DedicatedServer->SendChat(session, L" - @spectate           - Do not play but observe the match.");
+    g_DedicatedServer->SendChat(session, L" - @civ [civName]      - Selects your civilization. Example: @civ Athenians");
+    g_DedicatedServer->SendChat(session, L" - @team [teamNum]     - Chose your team. Valid teams are 0 (None), 1, 2, 3, and 4. Example: @team 1");
+    g_DedicatedServer->SendChat(session, L" - @popmax [popMax]    - Changes the maximum number of units per player. Example: @popmax 200");
+    g_DedicatedServer->SendChat(session, L" - @resources [amount] - Changes the amount of starting resources. Example: @resources 500");
+    g_DedicatedServer->SendChat(session, L" - @ceasefire [min]    - Changes the time until players can attack each other. Example: @ceasefire 3");
+    g_DedicatedServer->SendChat(session, L" - @gametype [type]    - Changes the victory condition. Example @gametype wonder");
+    g_DedicatedServer->SendChat(session, L" - @treasure [allowed] - Whether or not treasures should be disabled. Example @treasure: false");
+}
+
+void CDedicatedServer_Gamesetup::ParsePlayerChatCommand(CNetServerSession* session, CStrW input)
+{
+    // Parse command and argument as different types
+    CStrW command = input.substr(0, input.find(L" "));
+    CStrW argument = input.substr(input.find(L" ") + 1);
+    int argumentInt = std::atoi(utf8_from_wstring(argument).c_str());
+    float argumentFloat = std::atof(utf8_from_wstring(argument).c_str());
+
+    // Notice: cheats not implemented
+    // TODO: set rated game, set locked teams
+
+         if (command == L"@help")       SendChatCommandList(session);
+    else if (command == L"@maptype")    SetMaptype(session, argument);
+    else if (command == L"@mapfilter")  SetMapFilter(session, argument);
+    else if (command == L"@listmaps")   SendMapList(session);
+    else if (command == L"@selectmap")  SelectMap(session, argument);
+    else if (command == L"@mapsize")    SetMapsize(session, argumentInt);
+    else if (command == L"@numplayers") SetNumberOfPlayers(session, argumentInt);
+    else if (command == L"@setplayer")  SetPlayerID(session, argumentInt);
+    else if (command == L"@spectate")   SetPlayerID(session, -1);
+    else if (command == L"@civ")        SetPlayerCiv(session, argument);
+    else if (command == L"@team")       SetPlayerTeam(session, argumentInt);
+    else if (command == L"@ceasefire")  SetCeasefire(session, argumentInt);
+    else if (command == L"@gamespeed")  SetGamespeed(session, argumentFloat);
+    else if (command == L"@gametype")   SetGametype(session, argument);
+    else if (command == L"@popmax")     SetPopulationCapacity(session, argumentInt);
+    else if (command == L"@resources")  SetResources(session, argumentInt);
+    else if (command == L"@treasure")   DisableTreasure(session, argument);
+    else
+        g_DedicatedServer->SendPublicChat(L"Unknown command: " + command);
+}
+
+void CDedicatedServer_Gamesetup::Initialize()
+{
+    LOGERROR("[HOST] Initial gamesetup");
+
+    // the interface is initialized in CNetServerWorker::Run
+    m_ScriptInterface = g_NetServer->m_Worker->m_ScriptInterface;
+
+    // TODO: get username from config and create servername based on that
+    CStrW serverName(L"elexis' dedicated autohost");
+    //if (g_args.Has("dedicated-host-name"))
+    //  serverName = wstring_from_utf8(g_args.Get("dedicated-host-name"));
+
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+
+    // Needs to be kept in sync with gamesetup.js
+    // TODO: load from a JSON file
+    JS::RootedValue attribs(cx);
+    JS::RootedValue settings(cx);
+    JS::RootedValue playerAssignments(cx);
+    JS::RootedValue PlayerData(cx);
+    JS::RootedValue VictoryScripts(cx);
+
+    m_ScriptInterface->Eval("({})", &attribs);
+    m_ScriptInterface->Eval("({})", &settings);
+    m_ScriptInterface->Eval("({})", &playerAssignments);
+    m_ScriptInterface->Eval("([])", &PlayerData);
+    m_ScriptInterface->Eval("([\"scripts/TriggerHelper.js\",\"scripts/ConquestCommon.js\",\"scripts/Conquest.js\"])", &VictoryScripts);
+
+    m_ScriptInterface->SetProperty(settings, "AISeed", rand());
+    m_ScriptInterface->SetProperty(settings, "Seed", rand());
+    m_ScriptInterface->SetProperty(settings, "Ceasefire", 0);
+    m_ScriptInterface->SetProperty(settings, "CheatsEnabled", false);
+    m_ScriptInterface->SetProperty(settings, "GameType", std::wstring(L"conquest"));
+    m_ScriptInterface->SetProperty(settings, "ObserverLateJoin", true);
+    m_ScriptInterface->SetProperty(settings, "LockTeams", true);
+    m_ScriptInterface->SetProperty(settings, "PlayerData", PlayerData);
+    m_ScriptInterface->SetProperty(settings, "PopulationCap", 300);
+    m_ScriptInterface->SetProperty(settings, "RevealMap", false);
+    m_ScriptInterface->SetProperty(settings, "ExploredMap", false);
+    m_ScriptInterface->SetProperty(settings, "Size", 320); // map size 4
+    m_ScriptInterface->SetProperty(settings, "StartingResources", 500); // medium res for nomad
+    m_ScriptInterface->SetProperty(settings, "VictoryScripts", VictoryScripts);
+// disable treasure, no revealed map, no explored map
+    // "mods": ["mod","public"]
+    //"Preview": "acropolis_bay.png",
+    //CircularMap
+    //Description
+    m_ScriptInterface->SetProperty(attribs, "gameSpeed", 1);
+    m_ScriptInterface->SetProperty(attribs, "isNetworked", true);
+    m_ScriptInterface->SetProperty(attribs, "map", std::wstring(L"random"));
+    m_ScriptInterface->SetProperty(attribs, "mapFilter", std::wstring(L"all"));
+    m_ScriptInterface->SetProperty(attribs, "mapPath", m_MapPath);
+    m_ScriptInterface->SetProperty(attribs, "mapType", m_MapType);
+    m_ScriptInterface->SetProperty(attribs, "matchID", ps_generate_guid().FromUTF8());
+    m_ScriptInterface->SetProperty(attribs, "playerAssignments", playerAssignments);
+    m_ScriptInterface->SetProperty(attribs, "serverName", serverName);
+    m_ScriptInterface->SetProperty(attribs, "settings", settings);
+
+    g_NetServer->m_Worker->UpdateGameAttributes(&attribs);
+}
+
+void CDedicatedServer_Gamesetup::UpdatePlayerAssignments()
+{
+    return;
+    LOGERROR("[HOST] Updating player assignments");
+
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+
+    JS::RootedValue attribs(cx);
+    JS::RootedValue settings(cx);
+    JS::RootedValue PlayerData(cx);
+
+    attribs.set(g_NetServer->m_Worker->m_GameAttributes.get());
+    m_ScriptInterface->GetProperty(attribs, "settings", &settings);
+    m_ScriptInterface->Eval("([])", &PlayerData);
+
+    // Find all player IDs in active use
+/*  std::set<i32> usedIDs;
+    for (PlayerAssignmentMap::iterator it = m_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);
+*/
+    // {"type":"players","hosts":{"DDA0E9792D9168E2":{"name":"elexis3","player":-1,"status":0}}}
+
+    for (PlayerAssignmentMap::iterator it = g_NetServer->m_Worker->m_PlayerAssignments.begin(); it != g_NetServer->m_Worker->m_PlayerAssignments.end(); ++it)
+    {
+        LOGERROR("%s, PlayerID %d", utf8_from_wstring(it->second.m_Name), it->second.m_PlayerID);
+/*      assignment.m_Enabled = true;
+        assignment.m_Name = name;
+        assignment.m_PlayerID = playerID;
+        assignment.m_Status = 0;
+*/  }
+
+    // Update player data
+    for (u8 i=0; i<g_NetServer->m_Worker->m_PlayerAssignments.size(); ++i)
+    {
+        JS::RootedValue player(cx);
+        m_ScriptInterface->Eval("({})", &player);
+        //m_ScriptInterface->SetProperty(player, "Name", "Some player");
+        m_ScriptInterface->SetProperty(player, "Team", -1);
+        m_ScriptInterface->SetProperty(player, "Civ", std::wstring(L"random"));
+        m_ScriptInterface->SetProperty(player, "AI", std::wstring(L""));
+        m_ScriptInterface->SetProperty(player, "AiDiff", 3);
+        m_ScriptInterface->SetPropertyInt(PlayerData, i, player);
+    }
+    m_ScriptInterface->SetProperty(settings, "PlayerData", PlayerData);
+
+    // TODO SPLIT INTO FUNCTION
+    // 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
+    };
+    m_ScriptInterface->SetProperty(settings, "PopulationCap", popCaps[g_NetServer->m_Worker->m_PlayerAssignments.size()]);
+
+    // TODO: send chat that pop cap has been adopted
+
+    m_ScriptInterface->SetProperty(attribs, "settings", settings);
+
+    g_NetServer->m_Worker->UpdateGameAttributes(&attribs);
+
+    // Sends the player assignments
+    g_NetServer->m_Worker->ClearAllPlayerReady();
+}
+
+void CDedicatedServer_Gamesetup::ChangeAttribute(CStr attribute, JS::HandleValue value)
+{
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+
+    // Display the change to the host
+    CStr value_string;
+    if (m_ScriptInterface->FromJSVal(cx, value, value_string))
+        LOGERROR("[HOST] Change gamesetup attribute (%s to %s)", attribute, value_string);
+    else
+        LOGERROR("[HOST] Change gamesetup attribute (%s)", attribute);
+
+    // Save the value
+    JS::RootedValue attribs(cx);
+    attribs.set(g_NetServer->m_Worker->m_GameAttributes.get());
+    m_ScriptInterface->SetProperty(attribs, attribute.c_str(), value);
+    g_NetServer->m_Worker->UpdateGameAttributes(&attribs);
+    g_NetServer->m_Worker->ClearAllPlayerReady();
+}
+
+void CDedicatedServer_Gamesetup::ChangeSetting(CStr setting, JS::HandleValue value)
+{
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+
+    // Display the change to the host
+    CStr value_string;
+    if (m_ScriptInterface->FromJSVal(cx, value, value_string))
+        LOGERROR("[HOST] Change gamesetup setting (%s to %s)", setting, value_string);
+    else
+        LOGERROR("[HOST] Change gamesetup setting (%s)", setting);
+
+    // Save the value
+    JS::RootedValue attribs(cx);
+    JS::RootedValue settings(cx);
+
+    attribs.set(g_NetServer->m_Worker->m_GameAttributes.get());
+
+    m_ScriptInterface->GetProperty(attribs, "settings", &settings);
+    m_ScriptInterface->SetProperty(settings, setting.c_str(), value);
+    m_ScriptInterface->SetProperty(attribs, "settings", settings);
+
+    g_NetServer->m_Worker->UpdateGameAttributes(&attribs);
+    g_NetServer->m_Worker->ClearAllPlayerReady();
+}
+
+void CDedicatedServer_Gamesetup::SetMaptype(CNetServerSession* UNUSED(session), CStrW mapType)
+{
+    if (g_MapTypes.find(mapType) == g_MapTypes.end())
+    {
+        g_DedicatedServer->SendPublicChat(L"Error: unknown maptype: " + mapType);
+        return;
+    }
+
+    m_MapType = mapType;
+
+    if (mapType == L"skirmish")
+        m_MapPath = L"maps/skirmishes/";
+    else if (mapType == L"scenario")
+        m_MapPath = L"maps/scenarios/";
+    else
+        m_MapPath = L"maps/random/";
+
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+    JS::RootedValue jsVal(cx);
+
+    // TODO: only one attribute change
+    m_ScriptInterface->ToJSVal(cx, &jsVal, m_MapType);
+    ChangeAttribute("mapType", jsVal);
+    m_ScriptInterface->ToJSVal(cx, &jsVal, m_MapPath);
+    ChangeAttribute("mapPath", jsVal);
+
+    g_DedicatedServer->SendPublicChat(L"Set map type to " + mapType);
+
+    // TODO: select random map!! previous map can be invalidated
+}
+
+void CDedicatedServer_Gamesetup::SetMapFilter(CNetServerSession* UNUSED(session), CStrW mapFilter)
+{
+    if (g_MapFilters.find(mapFilter) == g_MapFilters.end())
+    {
+        g_DedicatedServer->SendPublicChat(L"Error: unknown mapfilter: " + mapFilter);
+        return;
+    }
+
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+    JS::RootedValue jsVal(cx);
+
+    m_ScriptInterface->ToJSVal(cx, &jsVal, mapFilter);
+    ChangeAttribute("mapFilter", jsVal);
+
+    g_DedicatedServer->SendPublicChat(L"Set map filter to " + mapFilter);
+}
+
+void CDedicatedServer_Gamesetup::SendMapList(CNetServerSession* session)
+{
+    CFileInfos fileInfos;
+    if (g_VFS->GetDirectoryEntries(VfsPath(m_MapPath), &fileInfos, NULL) != INFO::OK)
+    {
+        g_DedicatedServer->SendPublicChat(L"Couldn't list files in map-path");
+        return;
+    }
+
+    LOGERROR("[HOST] Sending map list");
+
+    // TODO: dont log spam
+    g_DedicatedServer->SendPublicChat(L"Sent map list to " + session->GetUserName());
+    g_DedicatedServer->SendChat(session, L"Maps");
+
+    for (CFileInfo &fileInfo : fileInfos)
+    {
+        CStrW filename = fileInfo.Name().string();
+        CStrW fileEnding = (m_MapType == L"random") ? L".json" : L".xml";
+
+        if (filename.substr(filename.length() - fileEnding.length()) != fileEnding)
+            continue;
+
+        // TODO: load & cache map properties
+        // TODO: skip if filter doesnt apply
+
+        CStrW mapname = filename.substr(0, filename.length() - fileEnding.length());
+        g_DedicatedServer->SendChat(session, mapname);
+    }
+}
+
+void CDedicatedServer_Gamesetup::SelectMap(CNetServerSession* UNUSED(session), CStrW map)
+{
+    if (m_MapType == L"random")
+        SelectRandomMap(map);
+    else
+        SelectXMLMap(map);
+}
+
+void CDedicatedServer_Gamesetup::SelectRandomMap(CStrW mapFilename)
+{
+    VfsPath filePath(m_MapPath + mapFilename + L".json");
+
+    if (!VfsFileExists(filePath))
+    {
+        g_DedicatedServer->SendPublicChat(L"Error: map not found: " + mapFilename);
+        return;
+    }
+
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+
+    // Load the file
+    JS::RootedValue mapAttributes(cx);
+    m_ScriptInterface->ReadJSONFile(filePath, &mapAttributes);
+    if (mapAttributes.isNull())
+    {
+        g_DedicatedServer->SendPublicChat(L"Could not load map");
+        return;
+    }
+
+    JS::RootedValue mapSettings(cx);
+    m_ScriptInterface->GetProperty(mapAttributes, "settings", &mapSettings);
+    SaveMapSettings(mapFilename, mapSettings);
+
+    g_NetServer->m_Worker->ClearAllPlayerReady();
+
+    g_DedicatedServer->SendPublicChat(L"Set map: " + mapFilename);
+}
+
+void CDedicatedServer_Gamesetup::SelectXMLMap(CStrW mapFilename)
+{
+    VfsPath filePath(m_MapPath + mapFilename + L".xml");
+    if (!VfsFileExists(filePath))
+    {
+        g_DedicatedServer->SendPublicChat(L"Error: unknown map: " + mapFilename);
+        return;
+    }
+
+    CMapSummaryReader reader;
+    if (reader.LoadMap(filePath) != PSRETURN_OK)
+    {
+        g_DedicatedServer->SendPublicChat(L"Error: Could not load map: " + mapFilename);
+        return;
+    }
+
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+
+    JS::RootedValue mapAttributes(cx);
+    JS::RootedValue mapSettings(cx);
+    reader.GetMapSettings(*m_ScriptInterface, &mapAttributes);
+    m_ScriptInterface->GetProperty(mapAttributes, "settings", &mapSettings);
+    SaveMapSettings(mapFilename, mapSettings);
+
+    // TODO: load victory scripts according to gametype
+
+    g_NetServer->m_Worker->ClearAllPlayerReady();
+
+    g_DedicatedServer->SendPublicChat(L"Set map " + mapFilename);
+}
+
+void CDedicatedServer_Gamesetup::SaveMapSettings(CStrW mapFilename, JS::HandleValue mapSettings)
+{
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+
+    // Load current game settings
+    JS::RootedValue attribs(cx);
+    JS::RootedValue settings(cx);
+    attribs.set(g_NetServer->m_Worker->m_GameAttributes.get());
+    m_ScriptInterface->GetProperty(attribs, "settings", &settings);
+
+    // Copy map settings to game settings
+    std::vector<std::string> settingNames;
+    m_ScriptInterface->EnumeratePropertyNamesWithPrefix(mapSettings, "", settingNames);
+    for (const std::string& settingName : settingNames)
+    {
+        JS::RootedValue value(cx);
+        m_ScriptInterface->GetProperty(mapSettings, settingName.c_str(), &value);
+        m_ScriptInterface->SetProperty(settings, settingName.c_str(), value);
+    }
+
+    // TODO: to ensure previous mapsettings dont remain, we should replace the whole settings property with a clean one
+    // but we lose all previous settings then.
+    // TODO: implement RemoveProperty using JS_DeleteProperty? :-L
+
+    // Updated game attributes
+    m_ScriptInterface->SetProperty(attribs, "map", m_MapPath + mapFilename);
+    m_ScriptInterface->SetProperty(attribs, "settings", settings);
+    if (m_MapType == L"random")
+        m_ScriptInterface->SetProperty(attribs, "script", mapFilename + L".js");
+    else
+        m_ScriptInterface->SetProperty(attribs, "script", NULL);
+
+    g_NetServer->m_Worker->UpdateGameAttributes(&attribs);
+}
+
+void CDedicatedServer_Gamesetup::SetMapsize(CNetServerSession* UNUSED(session), int tiles)
+{
+    // TODO: parse names instead of tiles
+    if (g_MapSizes.find(tiles) == std::end(g_MapSizes))
+    {
+        g_DedicatedServer->SendPublicChat(L"Error: unknown map size");
+        return;
+    }
+
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+    JS::RootedValue jsVal(cx);
+
+    m_ScriptInterface->ToJSVal(cx, &jsVal, tiles);
+    ChangeSetting("Size", jsVal);
+
+    g_DedicatedServer->SendPublicChat(L"Set map size to " + std::to_wstring(tiles));
+}
+
+void CDedicatedServer_Gamesetup::SetNumberOfPlayers(CNetServerSession* UNUSED(session), int UNUSED(players))
+{
+    /*
+    // Only meaningful for random maps
+    if (g_GameAttributes.mapType != "random")
+        return;
+
+    LOGERROR("Setting %d number of players", players);
+*/  /*
+    // Update player data
+    var pData = g_GameAttributes.settings.PlayerData;
+    if (pData && num < pData.length)
+    {
+        // Remove extra player data
+        g_GameAttributes.settings.PlayerData = pData.slice(0, num);
+    }
+    else
+    {
+        // Add player data from defaults
+        for (var i = pData.length; i < num; ++i)
+            g_GameAttributes.settings.PlayerData.push(g_DefaultPlayerData[i]);
+    }
+
+    // Some players may have lost their assigned slot
+    for (var guid in g_PlayerAssignments)
+    {
+        var player = g_PlayerAssignments[guid].player;
+        if (player > num)
+        {
+            if (g_IsNetworked)
+                Engine.AssignNetworkPlayer(player, "");
+            else
+                g_PlayerAssignments = { "local": { "name": translate("You"), "player": 1, "civ": "", "team": -1, "ready": 0} };
+        }
+    }
+
+    updateGameAttributes();
+     */
+}
+
+void CDedicatedServer_Gamesetup::SetGametype(CNetServerSession* UNUSED(session), CStrW UNUSED(gameType))
+{
+    // m_ScriptInterface->SetProperty(settings, "GameType", std::wstring(L"conquest"));
+    // m_ScriptInterface->SetProperty(settings, "VictoryScripts", VictoryScripts);
+    // g_DedicatedServer->SendPublicChat(L"Set game type to " + gameType);
+}
+
+void CDedicatedServer_Gamesetup::SetGamespeed(CNetServerSession* UNUSED(session), float gameSpeed)
+{
+    if (g_GameSpeeds.find(gameSpeed) == std::end(g_GameSpeeds))
+    {
+        g_DedicatedServer->SendPublicChat(L"Error: unknown gamespeed");
+        return;
+    }
+
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+    JS::RootedValue jsVal(cx);
+
+    m_ScriptInterface->ToJSVal(cx, &jsVal, gameSpeed);
+    ChangeAttribute("gameSpeed", jsVal);
+
+    g_DedicatedServer->SendPublicChat(L"Set game speed to " + std::to_wstring(gameSpeed));
+}
+
+void CDedicatedServer_Gamesetup::SetPopulationCapacity(CNetServerSession* UNUSED(session), int populationCapacity)
+{
+    if (g_PopulationCapacities.find(populationCapacity) == std::end(g_PopulationCapacities))
+    {
+        g_DedicatedServer->SendPublicChat(L"Error: unknown population capacity");
+        return;
+    }
+
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+    JS::RootedValue jsVal(cx);
+
+    m_ScriptInterface->ToJSVal(cx, &jsVal, populationCapacity);
+    ChangeSetting("PopulationCap", jsVal);
+
+    g_DedicatedServer->SendPublicChat(L"Set population capacity to " + std::to_wstring(populationCapacity));
+}
+
+void CDedicatedServer_Gamesetup::SetResources(CNetServerSession* UNUSED(session), int resources)
+{
+    if (g_Resources.find(resources) == std::end(g_Resources))
+    {
+        g_DedicatedServer->SendPublicChat(L"Error: unknown resources");
+        return;
+    }
+
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+    JS::RootedValue jsVal(cx);
+
+    m_ScriptInterface->ToJSVal(cx, &jsVal, resources);
+    ChangeSetting("StartingResources", jsVal);
+
+    g_DedicatedServer->SendPublicChat(L"Set starting resources to " + std::to_wstring(resources));
+}
+
+void CDedicatedServer_Gamesetup::SetCeasefire(CNetServerSession* UNUSED(session), int ceasefire)
+{
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+    JS::RootedValue jsVal(cx);
+
+    m_ScriptInterface->ToJSVal(cx, &jsVal, ceasefire);
+    ChangeSetting("Ceasefire", jsVal);
+
+    g_DedicatedServer->SendPublicChat(L"Set ceasefire to " + std::to_wstring(ceasefire));
+}
+
+void CDedicatedServer_Gamesetup::DisableTreasure(CNetServerSession* UNUSED(session), CStrW allowTreasure)
+{
+    bool disableTreasure;
+    if (allowTreasure == L"false")
+        disableTreasure = true;
+    else if (allowTreasure == L"true")
+        disableTreasure = false;
+    else
+    {
+        g_DedicatedServer->SendPublicChat(L"Error: unknown treasure setting");
+        return;
+    }
+
+    JSContext* cx = m_ScriptInterface->GetContext();
+    JSAutoRequest rq(cx);
+    JS::RootedValue jsVal(cx);
+
+    m_ScriptInterface->ToJSVal(cx, &jsVal, disableTreasure);
+    ChangeSetting("DisableTreasures", jsVal);
+
+    g_DedicatedServer->SendPublicChat(disableTreasure ? L"Forbidding treasure." : L"Allowing treasure.");
+}
+
+void CDedicatedServer_Gamesetup::StartGame()
+{
+    // "timestamp": "std::time(nullptr)",
+    // "engine_version": "0.0.19",
+    // "mods":...
+    //m_ScriptInterface->SetProperty(settings, "AISeed", rand());
+    //m_ScriptInterface->SetProperty(settings, "Seed", rand());
+    // TODO: send final game attributes
+}
+
+void CDedicatedServer_Gamesetup::SetPlayerID(CNetServerSession* session, int playerID)
+{
+//  JSContext* cx = m_ScriptInterface->GetContext();
+    //JSAutoRequest rq(cx);
+    //JS::RootedValue jsVal(cx);
+
+    //g_NetServer->m_Worker->m_PlayerAssignments[session->GetGUID()].m_PlayerID = playerID;
+
+    g_NetServer->AssignPlayer(playerID, session->GetGUID());
+
+    g_DedicatedServer->SendPublicChat(L"Assigning " + session->GetUserName() + L" to slot " + std::to_wstring(playerID));
+}
+
+void CDedicatedServer_Gamesetup::SetPlayerCiv(CNetServerSession* UNUSED(session), CStrW UNUSED(civilization))
+{
+    //g_DedicatedServer->SendPublicChat("");
+}
+
+void CDedicatedServer_Gamesetup::SetPlayerTeam(CNetServerSession* UNUSED(session), int UNUSED(team))
+{
+    //g_DedicatedServer->SendPublicChat("");
+}

source/network/DedicatedServer_Gamesetup.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 NETSERVER_H ?
+
+//#include "NetServer.h"
+#include "NetSession.h"
+//#include "DedicatedServer.h"
+//#include "NetMessage.h"
+
+#include "lib/file/file_system.h"
+#include "lib/file/vfs/vfs_util.h"
+#include "ps/Filesystem.h"
+//#include "ps/scripting/JSInterface_VFS.h"
+#include "scriptinterface/ScriptInterface.h"
+
+/**
+ * Contains only gamesetup function, no hosting.
+ */
+class CDedicatedServer_Gamesetup
+{
+    NONCOPYABLE(CDedicatedServer_Gamesetup);
+
+private:
+    friend class NetServer; // TODO: needed ?
+    friend class NetServerWorker; // TODO: needed ?
+    friend class DedicatedServer; // TODO: needed ?
+
+    /**
+     * Used to control the server.
+     */
+    ScriptInterface* m_ScriptInterface;
+
+    /**
+     * Used to setup the game.
+     */
+    //u8 m_PlayerCount;
+
+    /**
+     * Cached values for easier access.
+     */
+    CStrW m_MapType;
+    CStrW m_MapPath;
+
+public:
+    CDedicatedServer_Gamesetup(ScriptInterface* scriptInterface);
+    ~CDedicatedServer_Gamesetup();
+
+public: // TODO: can we make this private?
+    /*
+     * Contains the default gamesetup atributes. Called after CNetServerWorker::Run() initializes the ScriptInterface.
+     */
+    void Initialize();
+
+    /**
+     * Changes a property in the gameAttributes object.
+     */
+    void ChangeAttribute(CStr attribute, JS::HandleValue value);
+
+    /**
+     * Changes a property in the settings object of the gameAttributes object.
+     */
+    void ChangeSetting(CStr setting, JS::HandleValue value);
+
+    /**
+     * 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();
+
+    /**
+     * Choses whether a random, skirmish or scenario map is going to be played.
+     */
+    void SetMaptype(CNetServerSession* session, CStrW mapType);
+
+    /**
+     *
+     */
+    void SetMapFilter(CNetServerSession* session, CStrW mapFilter);
+
+    /**
+     *
+     */
+    void SelectMap(CNetServerSession* session, CStrW map);
+
+    /**
+     * Choses whether a random, skirmish or scenario map is going to be played.
+     */
+    void SetMapsize(CNetServerSession* session, int tiles);
+
+    /**
+     * Saves preview image, description, scripts and more and saves it to the game attributes.
+     */
+    void SelectRandomMap(CStrW mapFilename);
+
+    /**
+     * Saves player assignments, preview image, description, scripts and more and saves it to the game attributes.
+     */
+    void SelectXMLMap(CStrW mapFilename);
+
+    /*
+     * Shared function. Stores the settings loaded from the mapfile to the game attributes.
+     */
+    void SaveMapSettings(CStrW mapFilename, JS::HandleValue mapSettings);
+
+    /**
+     *
+     */
+    void SetNumberOfPlayers(CNetServerSession* session, int players);
+
+    /**
+     *
+     */
+    void SetGametype(CNetServerSession* session, CStrW gameType);
+
+    /**
+     *
+     */
+    void SetGamespeed(CNetServerSession* session, float gameSpeed);
+
+    /**
+     *
+     */
+    void SetPopulationCapacity(CNetServerSession* session, int populationCapacity);
+
+    /**
+     *
+     */
+    void SetResources(CNetServerSession* session, int resources);
+
+    /**
+     *
+     */
+    void DisableTreasure(CNetServerSession* session, CStrW allowTreasure);
+
+    /**
+     *
+     */
+    void SetCeasefire(CNetServerSession* session, int ceasefire);
+
+    /*
+     * Shows some version information and some miscellaneous info.
+     */
+    void SendWelcomeMessage(CNetServerSession* session);
+
+    /**
+     * Shows a list of available commands to select gamesetup options.
+     */
+    void SendChatCommandList(CNetServerSession* session);
+
+    /**
+     * Shows the user which maps can be chosen.
+     */
+    void SendMapList(CNetServerSession* session);
+
+    /**
+     * Allows users to influence the gamesetup via chat.
+     */
+    void ParsePlayerChatCommand(CNetServerSession* session, CStrW input);
+
+    /**
+     *
+     */
+    void SetPlayerID(CNetServerSession* session, int playerID);
+
+    /**
+     *
+     */
+    void SetPlayerCiv(CNetServerSession* session, CStrW civilization);
+
+    /**
+     *
+     */
+    void SetPlayerTeam(CNetServerSession* session, int team);
+
+    /**
+     *
+     */
+    void StartGame();
+};
+
+extern CDedicatedServer_Gamesetup *g_DedicatedServer_Gamesetup;

source/network/NetServer.cpp

@@ -364 +364 @@
 
 void 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 (g_DedicatedServer)
+        g_DedicatedServer_Gamesetup = new CDedicatedServer_Gamesetup(m_ScriptInterface);
+
     while (true)
     {
         if (!RunStep())
             break;
 
+        if (g_DedicatedServer)
+            g_DedicatedServer->OnTick();
         // Implement autostart mode
-        if (m_State == SERVER_STATE_PREGAME && (int)m_PlayerAssignments.size() == m_AutostartPlayers)
+        else if (m_State == SERVER_STATE_PREGAME && (int)m_PlayerAssignments.size() == m_AutostartPlayers)
             StartGame();
 
         // Update profiler stats
         m_Stats->LatchHostState(m_Host);
     }
@@ -617 +622 @@
     return session->SendMessage(&handshake);
 }
 
 void CNetServerWorker::OnUserJoin(CNetServerSession* session)
 {
+    LOGERROR("CNetServerWorker::OnUserJoin");
+    if (g_DedicatedServer)
+        g_DedicatedServer->OnUserJoin(session);
+
+    LOGERROR("CNetServerWorker::OnUserJoin AddPlayer");
     AddPlayer(session->GetGUID(), session->GetUserName());
 
     CGameSetupMessage gameSetupMessage(GetScriptInterface());
     gameSetupMessage.m_Data = m_GameAttributes.get();
     session->SendMessage(&gameSetupMessage);
 
+    LOGERROR("CNetServerWorker::OnUserJoin PlayerAssignmentMessage");
     CPlayerAssignmentMessage assignMessage;
     ConstructPlayerAssignmentMessage(assignMessage);
     session->SendMessage(&assignMessage);
 }
 
@@ -637 +648 @@
     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
     // back to AI control, or something?
+
+    if (g_DedicatedServer)
+        g_DedicatedServer->OnUserLeave(session);
 }
 
 void CNetServerWorker::AddPlayer(const CStr& guid, const CStrW& name)
 {
     // Find all player IDs in active use; we mustn't give them to a second player (excluding the unassigned ID: -1)
@@ -858 +872 @@
         // Request a copy of the current game state from an existing player,
         // so we can send it on to the new player
 
         // Assume session 0 is most likely the local player, so they're
         // the most efficient client to request a copy from
+
+        // TODO: When using a dedicated server we should use the client that didn't reconnect for the longest time
         CNetServerSession* sourceSession = server.m_Sessions.at(0);
         sourceSession->GetFileTransferer().StartTask(
             shared_ptr<CNetFileReceiveTask>(new CNetFileReceiveTask_ServerRejoin(server, newHostID))
         );
 
         session->SetNextState(NSS_JOIN_SYNCING);
     }
 
+    if (g_DedicatedServer)
+    {
+        if (isRejoining)
+            g_DedicatedServer->OnUserRejoining(session);
+        else if (g_DedicatedServer)
+            g_DedicatedServer->OnGamesetupJoin(session);
+    }
+
     return true;
 }
 
 bool CNetServerWorker::OnInGame(void* context, CFsmEvent* event)
 {
@@ -935 +959 @@
 
     message->m_GUID = session->GetGUID();
 
     server.Broadcast(message);
 
+    if (g_DedicatedServer)
+        g_DedicatedServer->OnChat(session, message);
+
     return true;
 }
 
 bool CNetServerWorker::OnReady(void* context, CFsmEvent* event)
 {
@@ -951 +978 @@
 
     message->m_GUID = session->GetGUID();
 
     server.Broadcast(message);
 
+    if (g_DedicatedServer)
+        g_DedicatedServer->OnReady(session, message);
+
     return true;
 }
 
 bool CNetServerWorker::OnLoadedGame(void* context, CFsmEvent* event)
 {
@@ -1034 +1064 @@
 
     message->m_GUID = session->GetGUID();
 
     server.Broadcast(message);
 
+    if (g_DedicatedServer)
+        g_DedicatedServer->OnUserRejoined(session);
+
     return true;
 }
 
 bool CNetServerWorker::OnDisconnect(void* context, CFsmEvent* event)
 {
@@ -1087 +1120 @@
 
     SendPlayerAssignments();
 
     CGameStartMessage gameStart;
     Broadcast(&gameStart);
+
+    if (g_DedicatedServer)
+        g_DedicatedServer->OnStartGame();
 }
 
 void CNetServerWorker::UpdateGameAttributes(JS::MutableHandleValue attrs)
 {
     m_GameAttributes.set(m_ScriptInterface->GetJSRuntime(), attrs);
@@ -1099 +1135 @@
         return;
 
     CGameSetupMessage gameSetupMessage(GetScriptInterface());
     gameSetupMessage.m_Data.set(m_GameAttributes.get());
     Broadcast(&gameSetupMessage);
+
+    if (g_DedicatedServer)
+        g_DedicatedServer->OnUpdateGameAttributes();
 }
 
 CStrW CNetServerWorker::SanitisePlayerName(const CStrW& original)
 {
     const size_t MAX_LENGTH = 32;

source/network/NetServer.h

@@ -16 +16 @@
  */
 
 #ifndef NETSERVER_H
 #define NETSERVER_H
 
+#include "DedicatedServer.h"
+#include "DedicatedServer_Gamesetup.h"
 #include "NetFileTransfer.h"
 #include "NetHost.h"
 
 #include "lib/config2.h"
 #include "ps/ThreadUtil.h"
@@ -89 +91 @@
     NSS_INGAME
 };
 
 /**
  * Network server interface. Handles all the coordination between players.
- * One person runs this object, and every player (including the host) connects their CNetClient to it.
+ * The host runs this object and every player connects their CNetClient to it.
  *
- * The actual work is performed by CNetServerWorker in a separate thread.
+ * If it is a dedicated server, the host will not be a player (nor observer).
+ *
+ * The actual work is performed by CNetServerWorker and CDedicatedServer in a separate thread.
  */
 class CNetServer
 {
     NONCOPYABLE(CNetServer);
 public:
@@ -153 +157 @@
      * TODO: we should replace this with some adapative lag-dependent computation.
      */
     void SetTurnLength(u32 msecs);
 
 private:
+    friend class CDedicatedServer; // TODO: needed?
+    friend class CDedicatedServer_Gamesetup;
+
     CNetServerWorker* m_Worker;
 };
 
 /**
  * Network server worker thread.
@@ -187 +194 @@
      * (i.e. are in the pre-game or in-game states).
      */
     bool Broadcast(const CNetMessage* message);
 
 private:
+    friend class CDedicatedServer; // TODO: needed?
+    friend class CDedicatedServer_Gamesetup;
     friend class CNetServer;
     friend class CNetFileReceiveTask_ServerRejoin;
 
     CNetServerWorker(int autostartPlayers);
     ~CNetServerWorker();

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

@@ -121 +121 @@
 
     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/network/NetTurnManager.cpp

@@ -635 +635 @@
     {
         if (it->first > newest)
             break;
 
         // Assume the host is correct (maybe we should choose the most common instead to help debugging)
+        // TODO: for dedicated hosts, we have to chose the hash of a client that didn't rejoin for the longest period
         std::string expected = it->second.begin()->second;
 
         // Find all players that are OOS on that turn
         std::vector<CStrW> OOSPlayerNames;
         for (std::map<int, std::string>::iterator cit = it->second.begin(); cit != it->second.end(); ++cit)

source/ps/GameSetup/GameSetup.cpp

@@ -684 +684 @@
 {
     SAFE_DELETE(g_NetClient);
     SAFE_DELETE(g_NetServer);
     SAFE_DELETE(g_Game);
 
-    ISoundManager::CloseGame();
+    if (!g_args.Has("dedicated-host"))
+        ISoundManager::CloseGame();
 }
 
 
 void Shutdown(int flags)
 {
@@ -699 +700 @@
 
     SAFE_DELETE(g_XmppClient);
 
     ShutdownPs();
 
-    TIMER_BEGIN(L"shutdown TexMan");
-    delete &g_TexMan;
-    TIMER_END(L"shutdown TexMan");
-
-    // destroy renderer
-    TIMER_BEGIN(L"shutdown Renderer");
-    delete &g_Renderer;
-    g_VBMan.Shutdown();
-    TIMER_END(L"shutdown Renderer");
+    if (!g_args.Has("dedicated-host"))
+    {
+        TIMER_BEGIN(L"shutdown TexMan");
+        delete &g_TexMan;
+        TIMER_END(L"shutdown TexMan");
+
+        // destroy renderer
+        TIMER_BEGIN(L"shutdown Renderer");
+        delete &g_Renderer;
+        g_VBMan.Shutdown();
+        TIMER_END(L"shutdown Renderer");
+    }
 
     g_Profiler2.ShutdownGPU();
 
     #if OS_WIN
         TIMER_BEGIN(L"shutdown wmi");
@@ -720 +724 @@
     #endif
 
     // Free cursors before shutting down SDL, as they may depend on SDL.
     cursor_shutdown();
 
-    TIMER_BEGIN(L"shutdown SDL");
-    ShutdownSDL();
-    TIMER_END(L"shutdown SDL");
-
-    g_VideoMode.Shutdown();
-
-    TIMER_BEGIN(L"shutdown UserReporter");
-    g_UserReporter.Deinitialize();
-    TIMER_END(L"shutdown UserReporter");
-
+    if (!g_args.Has("dedicated-host"))
+    {
+        TIMER_BEGIN(L"shutdown SDL");
+        ShutdownSDL();
+        TIMER_END(L"shutdown SDL");
+
+        g_VideoMode.Shutdown();
+
+        TIMER_BEGIN(L"shutdown UserReporter");
+        g_UserReporter.Deinitialize();
+        TIMER_END(L"shutdown UserReporter");
+    }
 
     // JS debugger temporarily disabled during the SpiderMonkey upgrade (check trac ticket #2348 for details)
     //TIMER_BEGIN(L"shutdown DebuggingServer (if active)");
     //delete g_DebuggingServer;
     //TIMER_END(L"shutdown DebuggingServer (if active)");
@@ -744 +750 @@
     TIMER_BEGIN(L"shutdown ConfigDB");
     delete &g_ConfigDB;
     TIMER_END(L"shutdown ConfigDB");
 
     SAFE_DELETE(g_Console);
+    LOGERROR("test1");
 
     // This is needed to ensure that no callbacks from the JSAPI try to use
     // the profiler when it's already destructed
-    g_ScriptRuntime.reset();
+    //if (!g_args.Has("dedicated-host"))
+        g_ScriptRuntime.reset();
+    LOGERROR("test2");
 
     // resource
     // first shut down all resource owners, and then the handle manager.
     TIMER_BEGIN(L"resource modules");
 
@@ -933 +942 @@
     }
 
     CNetHost::Initialize();
 
 #if CONFIG2_AUDIO
-    ISoundManager::CreateSoundManager();
+    if (!args.Has("dedicated-host"))
+        ISoundManager::CreateSoundManager();
 #endif
 
     // Check if there are mods specified on the command line,
     // or if we already set the mods (~INIT_MODS),
     // else check if there are mods that should be loaded specified