Ticket #3575: wip.v1.patch

binaries/data/mods/public/gui/gamesetup/gamesetup_mp.js

@@ +1 @@
+const g_DefaultPort = 20595;
+
 var g_IsConnecting = false;
 var g_GameType; // "server" or "client"
 var g_ServerName = "";
 
 var g_IsRejoining = false;
@@ -13 +15 @@
     switch (attribs.multiplayerGameType)
     {
     case "join":
         if(Engine.HasXmppClient())
         {
-            if (startJoin(attribs.name, attribs.ip))
+            if (startJoin(attribs.name, attribs.ip, attribs.port || g_DefaultPort))
                 switchSetupPage("pageJoin", "pageConnecting");
         }
         else
         {
             Engine.GetGUIObjectByName("pageJoin").hidden = false;
@@ -198 +200 @@
                 Engine.GetGUIObjectByName("hostFeedback").caption = translate("Game name already in use.");
                 return false;
             }
         }
     }
+    // TODO: should we allow regular users to host under different ports?
     try
     {
         if (g_userRating)
-            Engine.StartNetworkHost(playername + " (" + g_userRating + ")");
+            Engine.StartNetworkHost(playername + " (" + g_userRating + ")", 777);
         else
-            Engine.StartNetworkHost(playername);
+            Engine.StartNetworkHost(playername, 777);
     }
     catch (e)
     {
         cancelSetup();
         messageBox(400, 200,
@@ -222 +225 @@
     if (Engine.HasXmppClient())
         Engine.LobbySetPlayerPresence("playing");
     return true;
 }
 
-function startJoin(playername, ip)
+function startJoin(playername, ip, port)
 {
     try
     {
         if (g_userRating)
-            Engine.StartNetworkJoin(playername + " (" + g_userRating + ")", ip);
+            Engine.StartNetworkJoin(playername + " (" + g_userRating + ")", ip, port);
         else
-            Engine.StartNetworkJoin(playername, ip);
+            Engine.StartNetworkJoin(playername, ip, port);
     }
     catch (e)
     {
         cancelSetup();
         messageBox(400, 200,
@@ -249 +252 @@
         Engine.LobbySetPlayerPresence("playing");
     else {
         // Only save the player name and host address if they're valid and we're not in the lobby
         Engine.ConfigDB_CreateValue("user", "playername", playername);
         Engine.ConfigDB_CreateValue("user", "multiplayerserver", ip);
+        Engine.ConfigDB_CreateValue("user", "multiplayerport", port);
         Engine.ConfigDB_WriteFile("user", "config/user.cfg");
     }
     return true;
 }
 

binaries/data/mods/public/gui/gamesetup/gamesetup_mp.xml

@@ -43 +43 @@
                 <action on="Load">
                     this.caption = Engine.ConfigDB_GetValue("user", "multiplayerserver")
                 </action>
             </object>
 
+            <object type="text" size="20 120 50% 150" style="ModernLabelText" text_align="right">
+                <translatableAttribute id="caption">Server Port:</translatableAttribute>
+            </object>
+
+            <object name="joinPort" type="input" size="50%+10 120 100%-20 144" style="ModernInput">
+                <action on="Load">
+                    this.caption = Engine.ConfigDB_GetValue("user", "multiplayerport");
+                </action>
+            </object>
+
             <object hotkey="confirm" type="button" size="50%+5 100%-45 100%-18 100%-17" style="ModernButtonRed">
                 <translatableAttribute id="caption">Continue</translatableAttribute>
                 <action on="Press">
                     var joinPlayerName = Engine.GetGUIObjectByName("joinPlayerName").caption;
                     var joinServer = Engine.GetGUIObjectByName("joinServer").caption;
-                    if (startJoin(joinPlayerName, joinServer))
+                    var joinPort = Engine.GetGUIObjectByName("joinPort").caption;
+                    if (startJoin(joinPlayerName, joinServer, joinPort))
                         switchSetupPage("pageJoin", "pageConnecting");
                 </action>
             </object>
         </object>
 

binaries/data/mods/public/gui/lobby/lobby.js

@@ -614 +614 @@
     if (gamesBox.selected >= 0)
     {
         var g = gamesBox.list_data[gamesBox.selected];
         var sname = g_Name;
         var sip = g_GameList[g].ip;
+        var sport= g_GameList[g].port;
 
         // TODO: What about valid host names?
         // Check if it looks like an ip address
         if (sip.split('.').length != 4)
         {
             addChatMessage({ "from": "system", "text": sprintf(translate("This game's address '%(ip)s' does not appear to be valid."), { ip: sip }) });
             return;
         }
 
         // Open Multiplayer connection window with join option.
-        Engine.PushGuiPage("page_gamesetup_mp.xml", { multiplayerGameType: "join", name: sname, ip: sip, rating: g_userRating });
+        Engine.PushGuiPage("page_gamesetup_mp.xml", {
+            "multiplayerGameType": "join",
+            "name": sname,
+            "ip": sip,
+            "port": sport,
+            "rating": g_userRating
+        });
     }
 }
 
 /**
  * Start the hosting process.

source/gui/scripting/ScriptFunctions.cpp

@@ -299 +299 @@
     JS::RootedValue attribs(cx, attribs1);
 
     g_NetServer->UpdateGameAttributes(&attribs, *(pCxPrivate->pScriptInterface));
 }
 
-void StartNetworkHost(ScriptInterface::CxPrivate* pCxPrivate, std::wstring playerName)
+void StartNetworkHost(ScriptInterface::CxPrivate* pCxPrivate, std::wstring playerName, unsigned int serverPort)
 {
     ENSURE(!g_NetClient);
     ENSURE(!g_NetServer);
     ENSURE(!g_Game);
 
     g_NetServer = new CNetServer();
-    if (!g_NetServer->SetupConnection())
+    if (!g_NetServer->SetupConnection(serverPort))
     {
         pCxPrivate->pScriptInterface->ReportError("Failed to start server");
         SAFE_DELETE(g_NetServer);
         return;
     }
 
     g_Game = new CGame();
     g_NetClient = new CNetClient(g_Game);
     g_NetClient->SetUserName(playerName);
 
-    if (!g_NetClient->SetupConnection("127.0.0.1"))
+    if (!g_NetClient->SetupConnection("127.0.0.1", serverPort))
     {
         pCxPrivate->pScriptInterface->ReportError("Failed to connect to server");
         SAFE_DELETE(g_NetClient);
         SAFE_DELETE(g_Game);
     }
 }
 
-void StartNetworkJoin(ScriptInterface::CxPrivate* pCxPrivate, std::wstring playerName, std::string serverAddress)
+void StartNetworkJoin(ScriptInterface::CxPrivate* pCxPrivate, std::wstring playerName, std::string serverAddress, unsigned int serverPort)
 {
     ENSURE(!g_NetClient);
     ENSURE(!g_NetServer);
     ENSURE(!g_Game);
 
     g_Game = new CGame();
     g_NetClient = new CNetClient(g_Game);
     g_NetClient->SetUserName(playerName);
-    if (!g_NetClient->SetupConnection(serverAddress))
+    if (!g_NetClient->SetupConnection(serverAddress, serverPort))
     {
         pCxPrivate->pScriptInterface->ReportError("Failed to connect to server");
         SAFE_DELETE(g_NetClient);
         SAFE_DELETE(g_Game);
     }
@@ -958 +958 @@
 
     // Network / game setup functions
     scriptInterface.RegisterFunction<void, &StartNetworkGame>("StartNetworkGame");
     scriptInterface.RegisterFunction<void, JS::HandleValue, int, &StartGame>("StartGame");
     scriptInterface.RegisterFunction<void, &Script_EndGame>("EndGame");
-    scriptInterface.RegisterFunction<void, std::wstring, &StartNetworkHost>("StartNetworkHost");
-    scriptInterface.RegisterFunction<void, std::wstring, std::string, &StartNetworkJoin>("StartNetworkJoin");
+    scriptInterface.RegisterFunction<void, std::wstring, unsigned int, &StartNetworkHost>("StartNetworkHost");
+    scriptInterface.RegisterFunction<void, std::wstring, std::string, unsigned int, &StartNetworkJoin>("StartNetworkJoin");
     scriptInterface.RegisterFunction<void, &DisconnectNetworkGame>("DisconnectNetworkGame");
     scriptInterface.RegisterFunction<JS::Value, &PollNetworkClient>("PollNetworkClient");
     scriptInterface.RegisterFunction<void, JS::HandleValue, &SetNetworkGameAttributes>("SetNetworkGameAttributes");
     scriptInterface.RegisterFunction<void, int, std::string, &AssignNetworkPlayer>("AssignNetworkPlayer");
     scriptInterface.RegisterFunction<void, std::string, int, &SetNetworkPlayerStatus>("SetNetworkPlayerStatus");

source/network/NetClient.cpp

@@ -139 +139 @@
     ENSURE(!m_Session); // must be called before we start the connection
 
     m_UserName = username;
 }
 
-bool CNetClient::SetupConnection(const CStr& server)
+bool CNetClient::SetupConnection(const CStr& server, u16 port)
 {
     CNetClientSession* session = new CNetClientSession(*this);
-    bool ok = session->Connect(PS_DEFAULT_PORT, server);
+    bool ok = session->Connect(port, server);
     SetAndOwnSession(session);
     return ok;
 }
 
 void CNetClient::SetAndOwnSession(CNetClientSession* session)

source/network/NetClient.h

@@ -91 +91 @@
     /**
      * Set up a connection to the remote networked server.
      * @param server IP address or host name to connect to
      * @return true on success, false on connection failure
      */
-    bool SetupConnection(const CStr& server);
+    bool SetupConnection(const CStr& server, u16 port);
 
     /**
      * Destroy the connection to the server.
      * This client probably cannot be used again.
      */

source/network/NetServer.cpp

@@ -161 +161 @@
     }
 
     delete m_ServerTurnManager;
 }
 
-bool CNetServerWorker::SetupConnection()
+bool CNetServerWorker::SetupConnection(u16 port)
 {
     ENSURE(m_State == SERVER_STATE_UNCONNECTED);
     ENSURE(!m_Host);
 
     // Bind to default host
     ENetAddress addr;
     addr.host = ENET_HOST_ANY;
-    addr.port = PS_DEFAULT_PORT;
+    addr.port = port;
 
     // Create ENet server
     m_Host = enet_host_create(&addr, MAX_CLIENTS, CHANNEL_COUNT, 0, 0);
     if (!m_Host)
     {
@@ -1161 +1161 @@
 CNetServer::~CNetServer()
 {
     delete m_Worker;
 }
 
-bool CNetServer::SetupConnection()
+bool CNetServer::SetupConnection(u16 port)
 {
-    return m_Worker->SetupConnection();
+    return m_Worker->SetupConnection(port);
 }
 
 void CNetServer::AssignPlayer(int playerID, const CStr& guid)
 {
     CScopeLock lock(m_Worker->m_WorkerMutex);

source/network/NetServer.h

@@ -111 +111 @@
     /**
      * Begin listening for network connections.
      * This function is synchronous (it won't return until the connection is established).
      * @return true on success, false on error (e.g. port already in use)
      */
-    bool SetupConnection();
+    bool SetupConnection(u16 port);
 
     /**
      * 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.
@@ -197 +197 @@
 
     /**
      * Begin listening for network connections.
      * @return true on success, false on error (e.g. port already in use)
      */
-    bool SetupConnection();
+    bool SetupConnection(u16 port);
 
     /**
      * 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.

source/network/tests/test_Net.h

@@ -22 +22 @@
 #include "lib/external_libraries/libsdl.h"
 #include "lib/tex/tex.h"
 #include "network/NetServer.h"
 #include "network/NetClient.h"
 #include "network/NetTurnManager.h"
+#include "network/NetMessage.h"
+#include "network/NetMessages.h"
 #include "ps/CLogger.h"
 #include "ps/Game.h"
 #include "ps/Filesystem.h"
 #include "ps/Loader.h"
 #include "ps/XML/Xeromyces.h"
@@ -69 +71 @@
         return true;
     }
 
     void connect(CNetServer& server, const std::vector<CNetClient*>& clients)
     {
-        TS_ASSERT(server.SetupConnection());
+        TS_ASSERT(server.SetupConnection(PS_DEFAULT_PORT));
         for (size_t j = 0; j < clients.size(); ++j)
-            TS_ASSERT(clients[j]->SetupConnection("127.0.0.1"));
+            TS_ASSERT(clients[j]->SetupConnection("127.0.0.1", PS_DEFAULT_PORT));
 
         for (size_t i = 0; ; ++i)
         {
 //          debug_printf(".");
             for (size_t j = 0; j < clients.size(); ++j)
@@ -271 +273 @@
         CGame client2BGame(true);
         CNetClient client2B(&client2BGame);
         client2B.SetUserName(L"bob");
         clients.push_back(&client2B);
 
-        TS_ASSERT(client2B.SetupConnection("127.0.0.1"));
+        TS_ASSERT(client2B.SetupConnection("127.0.0.1", PS_DEFAULT_PORT));
 
         for (size_t i = 0; ; ++i)
         {
             debug_printf("[%u]\n", client2B.GetCurrState());
             client2B.Poll();

source/ps/GameSetup/GameSetup.cpp

@@ -47 +47 @@
 #include "gui/scripting/ScriptFunctions.h"
 #include "i18n/L10n.h"
 #include "maths/MathUtil.h"
 #include "network/NetServer.h"
 #include "network/NetClient.h"
+#include "network/NetMessage.h"
+#include "network/NetMessages.h"
 
 #include "ps/CConsole.h"
 #include "ps/CLogger.h"
 #include "ps/ConfigDB.h"
 #include "ps/Filesystem.h"
@@ -1434 +1436 @@
 
         g_NetServer = new CNetServer(maxPlayers);
 
         g_NetServer->UpdateGameAttributes(&attrs, scriptInterface);
 
-        bool ok = g_NetServer->SetupConnection();
+        bool ok = g_NetServer->SetupConnection(PS_DEFAULT_PORT);
         ENSURE(ok);
 
         g_NetClient = new CNetClient(g_Game);
         g_NetClient->SetUserName(userName);
-        g_NetClient->SetupConnection("127.0.0.1");
+        g_NetClient->SetupConnection("127.0.0.1", PS_DEFAULT_PORT);
     }
     else if (args.Has("autostart-client"))
     {
         InitPs(true, L"page_loading.xml", &scriptInterface, mpInitData);
 
@@ -1452 +1454 @@
 
         CStr ip = args.Get("autostart-client");
         if (ip.empty())
             ip = "127.0.0.1";
 
-        bool ok = g_NetClient->SetupConnection(ip);
+        bool ok = g_NetClient->SetupConnection(ip, PS_DEFAULT_PORT);
         ENSURE(ok);
     }
     else
     {
         g_Game->SetPlayerID(1);