Ticket #3241: t3241_kick_v3.patch

binaries/data/mods/public/gui/common/network.js

@@ -5 +5 @@
     {
     case 0: return translate("Unknown reason");
     case 1: return translate("Unexpected shutdown");
     case 2: return translate("Incorrect network protocol version");
     case 3: return translate("Game has already started");
+    case 4: return translate("You have been kicked from the match");
+    case 5: return translate("You have been banned from the match");
     default: return sprintf(translate("\\[Invalid value %(id)s]"), { id: id });
     }
 }
 
 function reportDisconnect(reason)

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

@@ -1695 +1695 @@
     }
 }
 
 function addChatMessage(msg)
 {
-    var username = "";
+    let username = "";
     if (msg.username)
         username = escapeText(msg.username);
     else if (msg.guid && g_PlayerAssignments[msg.guid])
         username = escapeText(g_PlayerAssignments[msg.guid].name);
 
-    var message = "";
+    let message;
     if ("text" in msg && msg.text)
         message = escapeText(msg.text);
 
+    // Kick / ban players
+    if ("text" in msg)
+    {
+        let split = msg.text.split(/\s/);
+        let kick = msg.text.indexOf("/kick") == 0;
+        let ban = msg.text.indexOf("/ban") == 0;
+        let playerGUID = Engine.GetPlayerGUID();
+        if (kick || ban)
+        {
+            if (!g_IsNetworked || !g_IsController || msg.guid != playerGUID)
+                return;
+            let trimmed = msg.text.substr(split[0].length + 1);
+            let matched = "";
+            // Reject names which don't match or are a superset of the intended name.
+            for each (let player in g_PlayerAssignments)
+                if (trimmed.indexOf(player.name) == 0 && player.name.length > matched.length)
+                    matched = player.name;
+            // Prevent the host from kicking him/herself 
+            if (matched.length && matched != g_PlayerAssignments[playerGUID].name)
+            {
+                // Sending the message takes a while, so we phrase this past tense.
+                // The text should be translated for each client individually (see #3304)
+                Engine.SendNetworkChat(matched + " has been " + (ban ? "banned" : "kicked") + ".");
+                Engine.KickPlayer(matched, ban);
+            }
+            return;
+        }
+    }
+
     // TODO: Maybe host should have distinct font/color?
-    var color = "white";
+    let color = "white";
 
     if (msg.guid && g_PlayerAssignments[msg.guid] && g_PlayerAssignments[msg.guid].player != -1)
     {
         // Valid player who has been assigned - get player color
-        var player = g_PlayerAssignments[msg.guid].player - 1;
-        var mapName = g_GameAttributes.map;
-        var mapData = loadMapData(mapName);
-        var mapSettings = (mapData && mapData.settings ? mapData.settings : {});
-        var pData = mapSettings.PlayerData ? mapSettings.PlayerData[player] : {};
-        var pDefs = g_DefaultPlayerData ? g_DefaultPlayerData[player] : {};
+        let player = g_PlayerAssignments[msg.guid].player - 1;
+        let mapName = g_GameAttributes.map;
+        let mapData = loadMapData(mapName);
+        let mapSettings = (mapData && mapData.settings ? mapData.settings : {});
+        let pData = mapSettings.PlayerData ? mapSettings.PlayerData[player] : {};
+        let pDefs = g_DefaultPlayerData ? g_DefaultPlayerData[player] : {};
 
         color = rgbToGuiColor(getSetting(pData, pDefs, "Color"));
     }
 
-    var formatted;
+    let formatted, formattedUsername, formattedUsernamePrefix;
     switch (msg.type)
     {
     case "connect":
-        var formattedUsername = '[color="'+ color +'"]' + username + '[/color]';
+        formattedUsername = '[color="'+ color +'"]' + username + '[/color]';
         formatted = '[font="sans-bold-13"] ' + sprintf(translate("== %(message)s"), { message: sprintf(translate("%(username)s has joined"), { username: formattedUsername }) }) + '[/font]';
         break;
 
     case "disconnect":
-        var formattedUsername = '[color="'+ color +'"]' + username + '[/color]';
+        formattedUsername = '[color="'+ color +'"]' + username + '[/color]';
         formatted = '[font="sans-bold-13"] ' + sprintf(translate("== %(message)s"), { message: sprintf(translate("%(username)s has left"), { username: formattedUsername }) }) + '[/font]';
         break;
 
     case "message":
-        var formattedUsername = '[color="'+ color +'"]' + username + '[/color]';
-        var formattedUsernamePrefix = '[font="sans-bold-13"]' + sprintf(translate("<%(username)s>"), { username: formattedUsername }) + '[/font]'
+        formattedUsername = '[color="'+ color +'"]' + username + '[/color]';
+        formattedUsernamePrefix = '[font="sans-bold-13"]' + sprintf(translate("<%(username)s>"), { username: formattedUsername }) + '[/font]'
         formatted = sprintf(translate("%(username)s %(message)s"), { username: formattedUsernamePrefix, message: message });
         break;
 
     case "ready":
-        var formattedUsername = '[font="sans-bold-13"][color="'+ color +'"]' + username + '[/color][/font]'
+        formattedUsername = '[font="sans-bold-13"][color="'+ color +'"]' + username + '[/color][/font]'
         if (msg.ready)
             formatted = ' ' + sprintf(translate("* %(username)s is ready!"), { username: formattedUsername });
         else
             formatted = ' ' + sprintf(translate("* %(username)s is not ready."), { username: formattedUsername });
         break;

binaries/data/mods/public/gui/session/messages.js

@@ -11 +11 @@
 var notificationsTimers = [];
 var cheats = getCheatsData();
 
 function getCheatsData()
 {
-    var cheats = {};
-    var cheatFileList = getJSONFileList("simulation/data/cheats/");
-    for each (var fileName in cheatFileList)
+    let cheats = {};
+    let cheatFileList = getJSONFileList("simulation/data/cheats/");
+    for each (let fileName in cheatFileList)
     {
-        var currentCheat = Engine.ReadJSONFile("simulation/data/cheats/"+fileName+".json");
+        let currentCheat = Engine.ReadJSONFile("simulation/data/cheats/"+fileName+".json");
         if (!currentCheat)
             continue;
         if (Object.keys(cheats).indexOf(currentCheat.Name) !== -1)
             warn("Cheat name '" + currentCheat.Name + "' is already present");
         else
@@ -30 +30 @@
 
 var g_NotificationsTypes =
 {
     "chat": function(notification, player)
     {
-        var message = {
+        let message = {
             "type": "message",
             "text": notification.message
         }
-        var guid = findGuidForPlayerID(g_PlayerAssignments, player);
+        let guid = findGuidForPlayerID(g_PlayerAssignments, player);
         if (guid == undefined)
         {
             message["guid"] = -1;
             message["player"] = player;
         } else {
@@ -46 +46 @@
         }
         addChatMessage(message);
     },
     "aichat": function(notification, player)
     {
-        var message = {
+        let message = {
             "type": "message",
             "text": notification.message
         }
         message["translate"] = true;
         if ("translateParameters" in notification)
@@ -64 +64 @@
                     continue;
                 let colorName = getUsernameAndColor(+message["parameters"][param]);
                 message["parameters"][param] = "[color=\"" + colorName[1] + "\"]" + colorName[0] + "[/color]";
             }
         }
-        var guid = findGuidForPlayerID(g_PlayerAssignments, player);
+        let guid = findGuidForPlayerID(g_PlayerAssignments, player);
         if (guid == undefined)
         {
             message["guid"] = -1;
             message["player"] = player;
         } else {
@@ -137 +137 @@
 };
 
 // Notifications
 function handleNotifications()
 {
-    var notifications = Engine.GuiInterfaceCall("GetNotifications");
+    let notifications = Engine.GuiInterfaceCall("GetNotifications");
 
-    for (var notification of notifications)
+    for (let notification of notifications)
     {
         if (!notification.type)
         {
             error("Notification without type found.\n"+uneval(notification))
             continue;
@@ -153 +153 @@
         {
             error("Notification without players found.\n"+uneval(notification))
             continue;
         }
         
-        var action = g_NotificationsTypes[notification.type];
+        let action = g_NotificationsTypes[notification.type];
         if (!action)
         {
             error("Unknown notification type '" + notification.type + "' found.");
             continue;
         }
         
-        for (var player of notification.players)
+        for (let player of notification.players)
             action(notification, player);
     }
 }
 
 function updateDiplomacy()
@@ -176 +176 @@
         openDiplomacy();
 }
 
 function updateTimeNotifications()
 {
-    var notifications =  Engine.GuiInterfaceCall("GetTimeNotifications");
-    var notificationText = "";
-    var playerID = Engine.GetPlayerID();
-    for (var n of notifications)
+    let notifications =  Engine.GuiInterfaceCall("GetTimeNotifications");
+    let notificationText = "";
+    let playerID = Engine.GetPlayerID();
+    for (let n of notifications)
     {
-        var message = n.message;
+        let message = n.message;
         if (n.translateMessage)
             message = translate(message);
-        var parameters = n.parameters || {};
+        let parameters = n.parameters || {};
         if (n.translateParameters)
             translateObjectKeys(parameters, n.translateParameters);
         parameters.time = timeToString(n.endTime - g_SimState.timeElapsed);
         notificationText += sprintf(message, parameters) + "\n";
     }
@@ -197 +197 @@
 
 // Returns [username, playercolor] for the given player
 function getUsernameAndColor(player)
 {
     // This case is hit for AIs, whose names don't exist in playerAssignments.
-    var color = g_Players[player].color;
+    let color = g_Players[player].color;
     return [
         escapeText(g_Players[player].name),
         color.r + " " + color.g + " " + color.b,
     ];
 }
@@ -216 +216 @@
     case "netstatus":
         // If we lost connection, further netstatus messages are useless
         if (g_Disconnected)
             return;
 
-        var obj = Engine.GetGUIObjectByName("netStatus");
+        let obj = Engine.GetGUIObjectByName("netStatus");
         switch (message.status)
         {
         case "waiting_for_players":
             obj.caption = translate("Waiting for other players to connect...");
             obj.hidden = false;
@@ -241 +241 @@
             obj.caption = translate("Connection to the server has been authenticated.");
             obj.hidden = false;
             break;
         case "disconnected":
             g_Disconnected = true;
-            obj.caption = translate("Connection to the server has been lost.") + "\n\n" + translate("The game has ended.");
+            obj.caption = translate("Connection to the server has been lost.") + "\n" +  
+                getDisconnectReason(message.reason)
+            if (!message.reason)
+                obj.caption += ".\n" + translate("The game has ended.");
             obj.hidden = false;
             break;
         default:
             error("Unrecognised netstatus type '" + message.status + "'");
             break;
         }
         break;
 
     case "players":
         // Find and report all leavings
-        for (var host in g_PlayerAssignments)
+        for (let host in g_PlayerAssignments)
         {
             if (!message.hosts[host])
             {
                 // Tell the user about the disconnection
                 addChatMessage({ "type": "disconnect", "guid": host });
@@ -265 +268 @@
                 updatePlayerDataRemove(g_Players, host);
             }
         }
 
         // Find and report all joinings
-        for (var host in message.hosts)
+        for (let host in message.hosts)
         {
             if (!g_PlayerAssignments[host])
             {
                 // Update the cached player data, so we can display the correct name
                 updatePlayerDataAdd(g_Players, host, message.hosts[host]);
@@ -281 +284 @@
 
         g_PlayerAssignments = message.hosts;
 
         if (g_IsController && Engine.HasXmppClient())
         {
-            var players = [ assignment.name for each (assignment in g_PlayerAssignments) ]
+            let players = [ assignment.name for each (assignment in g_PlayerAssignments) ]
             Engine.SendChangeStateGame(Object.keys(g_PlayerAssignments).length, players.join(", "));
         }
 
         break;
 
@@ -322 +325 @@
     }
 }
 
 function submitChatInput()
 {
-    var input = Engine.GetGUIObjectByName("chatInput");
-    var text = input.caption;
-    var isCheat = false;
+    let input = Engine.GetGUIObjectByName("chatInput");
+    let text = input.caption;
+    let isCheat = false;
+
     if (text.length)
     {
+        // Check cheats
         if (!g_IsObserver && g_Players[Engine.GetPlayerID()].cheatsEnabled)
         {
-            for each (var cheat in Object.keys(cheats))
+            for each (let cheat in Object.keys(cheats))
             {
                 // Line must start with the cheat.
                 if (text.indexOf(cheat) !== 0)
                     continue;
 
                 // test for additional parameter which is the rest of the string after the cheat
-                var parameter = "";
+                let parameter = "";
                 if (cheats[cheat].DefaultParameter !== undefined)
                 {
-                    var par = text.substr(cheat.length);
+                    let par = text.substr(cheat.length);
                     par = par.replace(/^\W+/, '').replace(/\W+$/, ''); // remove whitespaces at start and end
 
                     // check, if the isNumeric flag is set
                     if (cheats[cheat].isNumeric)
                     {
                         // Match the first word in the substring.
-                        var match = par.match(/\S+/);
+                        let match = par.match(/\S+/);
                         if (match && match[0])
                             par = Math.floor(match[0]);
                         // check, if valid number could be parsed
                         if (par <= 0 || isNaN(par))
                             par = "";
@@ -374 +379 @@
                 isCheat = true;
                 break;
             }
         }
 
-        // Observers should only send messages to "/all"
-        if (!isCheat && (!g_IsObserver || text.indexOf("/") == -1 || text.indexOf("/all ") == 0))
+        if (!isCheat)
         {
-            if (Engine.GetGUIObjectByName("toggleTeamChat").checked)
-                text = "/team " + text;
-
-            if (g_IsNetworked)
-                Engine.SendNetworkChat(text);
+            if (text.trim() == "/list")
+                addChatMessage({ "type": "clientlist", "guid": "local"});
             else
-                addChatMessage({ "type": "message", "guid": "local", "text": text });
+            {
+                if (Engine.GetGUIObjectByName("toggleTeamChat").checked)
+                    text = "/team " + text;
+
+                if (g_IsNetworked)
+                    Engine.SendNetworkChat(text);
+                else
+                    addChatMessage({ "type": "message", "guid": "local", "text": text });
+            }
         }
         input.caption = ""; // Clear chat input
     }
 
     input.blur(); // Remove focus
@@ -400 +409 @@
     // Default to global assignments, but allow overriding for when reporting
     // new players joining
     if (!playerAssignments)
         playerAssignments = g_PlayerAssignments;
 
-    var playerColor, username;
+    let playerColor, username;
 
     // No context by default. May be set by parseChatCommands().
     msg.context = "";
 
     if ("guid" in msg && playerAssignments[msg.guid])
     {
-        var n = playerAssignments[msg.guid].player;
+        let n = playerAssignments[msg.guid].player;
         // Observers have an ID of -1 which is not a valid index.
         if (n < 0)
             n = 0;
         playerColor = g_Players[n].color.r + " " + g_Players[n].color.g + " " + g_Players[n].color.b;
         username = escapeText(playerAssignments[msg.guid].name);
@@ -433 +442 @@
     {
         playerColor = "255 255 255";
         username = translate("Unknown player");
     }
 
-    var formatted;
+    let formatted, message;
 
     switch (msg.type)
     {
     case "connect":
         formatted = sprintf(translate("%(player)s is starting to rejoin the game."), { player: "[color=\"" + playerColor + "\"]" + username + "[/color]" });
@@ -453 +462 @@
         if (!g_IsNetworked && msg.player == Engine.GetPlayerID())
             formatted = translate("You have been defeated.");
         else
             formatted = sprintf(translate("%(player)s has been defeated."), { player: "[color=\"" + playerColor + "\"]" + username + "[/color]" });
         break;
+    case "clientlist":
+        let userlist = Object.keys(playerAssignments).sort(function(a,b)
+        {
+            let playerA = playerAssignments[a].player;
+            let playerB = playerAssignments[b].player;
+            if (playerA == -1 || playerB == -1)
+                return 1;
+            else
+                return playerA - playerB;
+        }).map(guid => playerAssignments[guid].name).join(",");
+        formatted = sprintf(translate("Users: %(users)s."), { "users": userlist });
+        break;
     case "diplomacy":
-        var message;
         if (msg.player == Engine.GetPlayerID())
         {
             [username, playerColor] = getUsernameAndColor(msg.player1);
             if (msg.status == "ally")
                 message = translate("You are now allied with %(player)s.");
@@ -516 +536 @@
 
         [username, playerColor] = getUsernameAndColor(msg.attacker);
         // Since livestock can be attacked/gathered by other players,
         // we display a more specific notification in this case to not confuse the player
         if (msg.targetIsDomesticAnimal)
-            var message = translate("Your livestock have been attacked by %(attacker)s!");
+            message = translate("Your livestock have been attacked by %(attacker)s!");
         else
-            var message = translate("You have been attacked by %(attacker)s!");
+            message = translate("You have been attacked by %(attacker)s!");
         formatted = sprintf(message, { attacker: "[color=\"" + playerColor + "\"]" + username + "[/color]" });
         break;
     case "message":
         // May have been hidden by the 'team' command.
         if (msg.hide)
             return;
 
-        var message;
         if ("translate" in msg && msg.translate)
         {
             message = translate(msg.text); // No need to escape, not a user message.
             if ("translateParameters" in msg && msg.translateParameters)
             {
-                var parameters = msg.parameters || {};
+                let parameters = msg.parameters || {};
                 translateObjectKeys(parameters, msg.translateParameters);
                 message = sprintf(message, parameters);
             }
         }
         else
@@ -560 +579 @@
                 });
             }
         }
         else
         {
-            var userTag = sprintf(translate("<%(user)s>"), { user: username })
-            var formattedUserTag = sprintf(translate("<%(user)s>"), { user: "[color=\"" + playerColor + "\"]" + username + "[/color]" })
+            let userTag = sprintf(translate("<%(user)s>"), { user: username })
+            let formattedUserTag = sprintf(translate("<%(user)s>"), { user: "[color=\"" + playerColor + "\"]" + username + "[/color]" })
             if (msg.context !== "")
             {
                 formatted = sprintf(translate("(%(context)s) %(userTag)s %(message)s"), {
                     context: msg.context,
                     userTag: formattedUserTag,
@@ -605 +624 @@
 {
     // Only interested in messages that start with '/'.
     if (!msg.text || msg.text[0] != '/')
         return;
 
-    var sender;
+    let sender;
     if (playerAssignments[msg.guid])
         sender = playerAssignments[msg.guid].player;
     else
         sender = msg.player;
 
     // TODO: It would be nice to display multiple different contexts.
     // It should be made clear that only players matching the union of those receive the message.
-    var recurse = false;
-    var split = msg.text.split(/\s/);
-
+    let recurse = false, ban = false;
+    let split = msg.text.split(/\s/)
+    let trimmed, matched;
     // Parse commands embedded in the message.
     switch (split[0])
     {
     case "/all":
         // Resets values that 'team' or 'enemy' may have set.
@@ -627 +646 @@
         msg.hide = false;
         recurse = true;
         break;
     case "/team":
         // Check if we are in a team.
-        if (g_Players[Engine.GetPlayerID()] && g_Players[Engine.GetPlayerID()].team != -1)
+        if (!g_IsObserver && g_Players[Engine.GetPlayerID()] && g_Players[Engine.GetPlayerID()].team != -1)
         {
             if (g_Players[Engine.GetPlayerID()].team != g_Players[sender].team)
                 msg.hide = true;
             else
                 msg.context = translate("Team");
@@ -641 +660 @@
         recurse = true;
         break;
     case "/ally":
     case "/allies":
         // Check if we sent the message, or are the sender's (mutual) ally
-        if (Engine.GetPlayerID() == sender || (g_Players[sender] && g_Players[sender].isMutualAlly[Engine.GetPlayerID()]))
+        if (!g_IsObserver && (Engine.GetPlayerID() == sender || (g_Players[sender] && g_Players[sender].isMutualAlly[Engine.GetPlayerID()])))
             msg.context = translate("Ally");
         else
             msg.hide = true;
 
         recurse = true;
         break;
     case "/enemy":
     case "/enemies":
         // Check if we sent the message, or are the sender's enemy
-        if (Engine.GetPlayerID() == sender || (g_Players[sender] && g_Players[sender].isEnemy[Engine.GetPlayerID()]))
+        if (!g_IsObserver && (Engine.GetPlayerID() == sender || (g_Players[sender] && g_Players[sender].isEnemy[Engine.GetPlayerID()])))
             msg.context = translate("Enemy");
         else
             msg.hide = true;
 
         recurse = true;
         break;
     case "/me":
         msg.action = true;
         break;
+    case "/ban":
+        ban = true;
+    case "/kick":
+        msg.hide = true;
+        if (!g_IsNetworked || !g_IsController || msg.guid != Engine.GetPlayerGUID())
+            break;
+        trimmed = msg.text.substr(split[0].length + 1);
+        matched = "";
+        let playerGUID = Engine.GetPlayerGUID();
+        // Reject names which don't match or are a superset of the intended name.
+        for each (let player in playerAssignments)
+            if (trimmed.indexOf(player.name) == 0 && player.name.length > matched.length)
+                matched = player.name;
+        // Prevent the host from kicking him/herself 
+        if (matched.length && matched != g_PlayerAssignments[playerGUID].name)
+        {
+            Engine.KickPlayer(matched, ban);
+            // Sending the message takes a while, so we phrase this past tense.
+            // The text should be translated for each client individually (see #3304)
+            submitChatDirectly(matched + " has been " + (ban ? "banned" : "kicked") + ".");
+        }
+        return;
     case "/msg":
-        var trimmed = msg.text.substr(split[0].length + 1);
-        var matched = "";
+        trimmed = msg.text.substr(split[0].length + 1);
+        matched = "";
 
+        // Don't show private messages from observers to players
+        if (g_PlayerAssignments[msg.guid].player == -1 && g_PlayerAssignments[Engine.GetPlayerGUID()].player != -1)
+        {
+            msg.hide = true;
+            return;
+        }
+        
         // Reject names which don't match or are a superset of the intended name.
-        for each (var player in playerAssignments)
+        for each (let player in playerAssignments)
             if (trimmed.indexOf(player.name + " ") == 0 && player.name.length > matched.length)
                 matched = player.name;
 
         // If the local player's name was the longest one matched, show the message.
-        var playerName = g_Players[Engine.GetPlayerID()].name;
-        if (matched.length && (matched == playerName || sender == Engine.GetPlayerID()))
+        // Show the message only for sender and recipient.
+        if (matched.length && (msg.guid == Engine.GetPlayerGUID() || matched == g_PlayerAssignments[Engine.GetPlayerGUID()].name))
         {
             msg.context = translate("Private");
             msg.text = trimmed.substr(matched.length + 1);
             msg.hide = false; // Might override team message hiding.
             return;
@@ -712 +760 @@
     resumeGame();
 }
 
 function openDialog(dialogName, data, player)
 {
-    var dialog = Engine.GetGUIObjectByName(dialogName+"-dialog");
+    let dialog = Engine.GetGUIObjectByName(dialogName+"-dialog");
     if (!dialog)
     {
         warn("messages.js: Unknow dialog with name "+dialogName);
         return;
     }
     dialog.hidden = false;
 
-    for (var objName in data)
+    for (let objName in data)
     {
-        var obj = Engine.GetGUIObjectByName(dialogName + "-dialog-" + objName);
+        let obj = Engine.GetGUIObjectByName(dialogName + "-dialog-" + objName);
         if (!obj)
         {
             warn("messages.js: Key '" + objName + "' not found in '" + dialogName + "' dialog.");
             continue;
         }
-        for (var key in data[objName])
+        for (let key in data[objName])
         {
-            var n = data[objName][key];
+            let n = data[objName][key];
             if (typeof n == "object" && n.message)
             {
-                var message = n.message;
+                let message = n.message;
                 if (n.translateMessage)
                     message = translate(message);
-                var parameters = n.parameters || {};
+                let parameters = n.parameters || {};
                 if (n.translateParameters)
                     translateObjectKeys(parameters, n.translateParameters);
                 obj[key] = sprintf(message, parameters);
             }
             else

binaries/data/mods/public/gui/session/session.xml

@@ -5 +5 @@
 <script file="gui/common/colorFades.js"/>
 <script file="gui/common/functions_civinfo.js"/>
 <script file="gui/common/functions_global_object.js"/>
 <script file="gui/common/functions_utility.js"/>
 <script file="gui/common/l10n.js"/>
+<script file="gui/common/network.js"/>
 <script file="gui/common/music.js"/>
 <script file="gui/common/timer.js"/>
 <script file="gui/common/tooltips.js"/>
 <!-- load all scripts in this directory -->
 <script directory="gui/session/"/>

source/gui/scripting/ScriptFunctions.cpp

@@ -186 +186 @@
     if (g_Game)
         return g_Game->GetPlayerID();
     return -1;
 }
 
+std::string GetPlayerGUID(ScriptInterface::CxPrivate* UNUSED(pCxPrivate))
+{
+    if (g_NetServer)
+        return g_NetServer->GetHostGUID();
+    else if (g_NetClient)
+        return g_NetClient->GetGUID();
+    else
+        return "";
+}
+
 void SetPlayerID(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), int id)
 {
     if (g_Game)
         g_Game->SetPlayerID(id);
 }
@@ -345 +355 @@
     SAFE_DELETE(g_NetServer);
     SAFE_DELETE(g_NetClient);
     SAFE_DELETE(g_Game);
 }
 
+void KickPlayer(ScriptInterface::CxPrivate* UNUSED(pCxPrivate), std::wstring playerName, bool ban)
+{
+    if (g_NetServer)
+        g_NetServer->KickPlayer(playerName, ban);
+}
+
 JS::Value PollNetworkClient(ScriptInterface::CxPrivate* pCxPrivate)
 {
     if (!g_NetClient)
         return JS::UndefinedValue();
 
@@ -954 +970 @@
     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, &DisconnectNetworkGame>("DisconnectNetworkGame");
+    scriptInterface.RegisterFunction<void, std::wstring, bool, &KickPlayer>("KickPlayer");
     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");
     scriptInterface.RegisterFunction<void, &ClearAllPlayerReady>("ClearAllPlayerReady");
@@ -977 +994 @@
     scriptInterface.RegisterFunction<void, &QuickLoad>("QuickLoad");
 
     // Misc functions
     scriptInterface.RegisterFunction<std::wstring, std::wstring, &SetCursor>("SetCursor");
     scriptInterface.RegisterFunction<int, &GetPlayerID>("GetPlayerID");
+    scriptInterface.RegisterFunction<std::string, &GetPlayerGUID>("GetPlayerGUID");
     scriptInterface.RegisterFunction<void, int, &SetPlayerID>("SetPlayerID");
     scriptInterface.RegisterFunction<void, std::string, &OpenURL>("OpenURL");
     scriptInterface.RegisterFunction<std::wstring, &GetMatchID>("GetMatchID");
     scriptInterface.RegisterFunction<void, &RestartInAtlas>("RestartInAtlas");
     scriptInterface.RegisterFunction<bool, &AtlasIsAvailable>("AtlasIsAvailable");

source/network/NetClient.cpp

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

source/network/NetClient.h

@@ -86 +86 @@
      * Set the user's name that will be displayed to all players.
      * This must not be called after the connection setup.
      */
     void SetUserName(const CStrW& username);
 
+    /** Returns the GUID of the client. */
+    CStr GetGUID();
+
     /**
      * 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
      */

source/network/NetHost.h

@@ -1 @@
-/* Copyright (C) 2011 Wildfire Games.
+/* 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
@@ -60 +60 @@
 enum NetDisconnectReason
 {
     NDR_UNKNOWN = 0,
     NDR_UNEXPECTED_SHUTDOWN,
     NDR_INCORRECT_PROTOCOL_VERSION,
-    NDR_SERVER_ALREADY_IN_GAME
+    NDR_SERVER_ALREADY_IN_GAME,
+    NDR_KICKED,
+    NDR_BANNED
 };
 
 class CNetHost
 {
 public:

source/network/NetServer.cpp

@@ -127 +127 @@
 
     m_ServerTurnManager = NULL;
 
     m_ServerName = DEFAULT_SERVER_NAME;
     m_WelcomeMessage = DEFAULT_WELCOME_MESSAGE;
+    m_HostGUID = std::string("");
 }
 
 CNetServerWorker::~CNetServerWorker()
 {
     if (m_State != SERVER_STATE_UNCONNECTED)
@@ -604 +605 @@
     session->SetFirstState(NSS_HANDSHAKE);
 }
 
 bool CNetServerWorker::HandleConnect(CNetServerSession* session)
 {
+    CNetServerWorker& server = session->GetServer();
+
+    // Disconnect banned IPs
+    std::string ipAddress = session -> GetIPAddress();
+    if(std::find(server.m_BannedIPs.begin(), server.m_BannedIPs.end(), ipAddress) != server.m_BannedIPs.end())
+    {
+        session->Disconnect(NDR_BANNED);
+        return false;
+    }
+
+    // Send handshake challenge
     CSrvHandshakeMessage handshake;
     handshake.m_Magic = PS_PROTOCOL_MAGIC;
     handshake.m_ProtocolVersion = PS_PROTOCOL_VERSION;
     handshake.m_SoftwareVersion = PS_PROTOCOL_VERSION;
     return session->SendMessage(&handshake);
@@ -615 +627 @@
 
 void CNetServerWorker::OnUserJoin(CNetServerSession* session)
 {
     AddPlayer(session->GetGUID(), session->GetUserName());
 
+    if (m_HostGUID == "")
+        m_HostGUID = session->GetGUID();
+
     CGameSetupMessage gameSetupMessage(GetScriptInterface());
     gameSetupMessage.m_Data = m_GameAttributes.get();
     session->SendMessage(&gameSetupMessage);
 
     CPlayerAssignmentMessage assignMessage;
@@ -630 +645 @@
 {
     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
-    // back to AI control, or something?
 }
 
 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)
@@ -707 +719 @@
         it->second.m_Status = 0;
 
     SendPlayerAssignments();
 }
 
+void CNetServerWorker::KickPlayer(const CStrW& playerName, bool ban)
+{
+    if (ban)
+    {
+        // Add playername to blacklist
+        if (std::find(m_BannedPlayers.begin(), m_BannedPlayers.end(), playerName) == m_BannedPlayers.end())
+            m_BannedPlayers.push_back(playerName);
+
+        // Add IP address to blacklist
+        std::string ipAddress = GetPlayerIPAddress(playerName);
+        if (std::find(m_BannedIPs.begin(), m_BannedIPs.end(), ipAddress) == m_BannedIPs.end())
+            m_BannedIPs.push_back(ipAddress);
+    }
+
+    // Disconnect everyone with that nick except the host
+    for (auto session : m_Sessions)
+    {
+        if (session->GetUserName() == playerName && session->GetGUID() != m_HostGUID)
+            session->Disconnect(ban ? NDR_BANNED : NDR_KICKED);
+    }
+}
+
+std::string CNetServerWorker::GetPlayerIPAddress(const CStrW& playerName)
+{
+    std::string ipAddress = "error";
+    for (auto session : m_Sessions)
+    {
+        if (session->GetUserName() == playerName)
+            return session->GetIPAddress();
+    }
+    return ipAddress;
+}
+
+std::string CNetServerWorker::GetHostGUID()
+{
+    return m_HostGUID;
+}
+
 void CNetServerWorker::AssignPlayer(int playerID, const CStr& guid)
 {
     // Remove anyone who's already assigned to this player
     for (PlayerAssignmentMap::iterator it = m_PlayerAssignments.begin(); it != m_PlayerAssignments.end(); ++it)
     {
@@ -764 +814 @@
     ENSURE(event->GetType() == (uint)NMT_CLIENT_HANDSHAKE);
 
     CNetServerSession* session = (CNetServerSession*)context;
     CNetServerWorker& server = session->GetServer();
 
+    // Check protocol version
     CCliHandshakeMessage* message = (CCliHandshakeMessage*)event->GetParamRef();
     if (message->m_ProtocolVersion != PS_PROTOCOL_VERSION)
     {
         session->Disconnect(NDR_INCORRECT_PROTOCOL_VERSION);
         return false;
     }
 
+    // Send handshake response
     CSrvHandshakeResponseMessage handshakeResponse;
     handshakeResponse.m_UseProtocolVersion = PS_PROTOCOL_VERSION;
     handshakeResponse.m_Message = server.m_WelcomeMessage;
     handshakeResponse.m_Flags = 0;
     session->SendMessage(&handshakeResponse);
@@ -791 +843 @@
 
     CAuthenticateMessage* message = (CAuthenticateMessage*)event->GetParamRef();
 
     CStrW username = server.DeduplicatePlayerName(SanitisePlayerName(message->m_Name));
 
+    // Disconnect banned usernames
+    if(std::find(server.m_BannedPlayers.begin(), server.m_BannedPlayers.end(), username) != server.m_BannedPlayers.end())
+    {
+        session->Disconnect(NDR_BANNED);
+        return true;
+    }
+
     bool isRejoining = false;
 
     if (server.m_State != SERVER_STATE_PREGAME)
     {
 //      isRejoining = true; // uncomment this to test rejoining even if the player wasn't connected previously
@@ -1145 +1204 @@
 {
     CScopeLock lock(m_Worker->m_WorkerMutex);
     m_Worker->m_PlayerReadyQueue.push_back(std::make_pair(guid, ready));
 }
 
+void CNetServer::KickPlayer(const CStrW& playerName, bool ban)
+{
+    CScopeLock lock(m_Worker->m_WorkerMutex);
+    m_Worker->KickPlayer(playerName, ban);
+}
+
+std::string CNetServer::GetHostGUID()
+{
+    CScopeLock lock(m_Worker->m_WorkerMutex);
+    return m_Worker->GetHostGUID();
+}
+
 void CNetServer::ClearAllPlayerReady()
 {
     CScopeLock lock(m_Worker->m_WorkerMutex);
     m_Worker->m_PlayerResetReadyQueue.push_back(false);
 }

source/network/NetServer.h

@@ -134 +134 @@
      * The changes will be asynchronously propagated to all clients.
      */
     void ClearAllPlayerReady();
     
     /**
+     * Disconnects a player from the gamesetup / session.
+     */
+    void KickPlayer(const CStrW& playerName, bool ban);
+
+    /**
+     * Returns the GUID of the host.
+     */
+    std::string GetHostGUID();
+
+    /**
      * Call from the GUI to asynchronously notify all clients that they should start loading the game.
      */
     void StartGame();
 
     /**
@@ -181 +191 @@
      * Send a message to the given network peer.
      */
     bool SendMessage(ENetPeer* peer, const CNetMessage* message);
 
     /**
+     * Disconnected a player from the match / gamesetup and optionally prevents him/her from rejoining.
+     */
+    void KickPlayer(const CStrW& playerName, bool ban);
+
+    /**
      * 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);
 
+    /**
+     * Returns the IP address of the given connected player.
+     */
+    std::string GetPlayerIPAddress(const CStrW& playerName);
+
 private:
     friend class CNetServer;
     friend class CNetFileReceiveTask_ServerRejoin;
 
     CNetServerWorker(int autostartPlayers);
@@ -244 +264 @@
     void SetTurnLength(u32 msecs);
 
     void AddPlayer(const CStr& guid, const CStrW& name);
     void RemovePlayer(const CStr& guid);
     void SetPlayerReady(const CStr& guid, const int ready); 
+    std::string GetHostGUID();
     void SendPlayerAssignments();
     void ClearAllPlayerReady();
 
     void SetupSession(CNetServerSession* session);
     bool HandleConnect(CNetServerSession* session);
@@ -269 +290 @@
 
     void ConstructPlayerAssignmentMessage(CPlayerAssignmentMessage& message);
 
     void HandleMessageReceive(const CNetMessage* message, CNetServerSession* session);
 
-
     /**
      * Internal script context for (de)serializing script messages,
      * and for storing game attributes.
      * (TODO: we shouldn't bother deserializing (except for debug printing of messages),
      * we should just forward messages blindly and efficiently.)
@@ -285 +305 @@
     /**
      * Stores the most current game attributes.
      */
     DefPersistentRooted<JS::Value> m_GameAttributes;
 
+    std::vector<std::string> m_BannedIPs;
+    std::vector<std::wstring> m_BannedPlayers;
+
     int m_AutostartPlayers;
 
     ENetHost* m_Host;
     std::vector<CNetServerSession*> m_Sessions;
 
@@ -301 +324 @@
 
     u32 m_NextHostID;
 
     CNetServerTurnManager* m_ServerTurnManager;
 
+    std::string m_HostGUID;
+
     /**
      * A copy of all simulation commands received so far, indexed by
      * turn number, to simplify support for rejoining etc.
      * TODO: verify this doesn't use too much RAM.
      */

source/network/NetSession.cpp

@@ -1 @@
-/* Copyright (C) 2011 Wildfire Games.
+/* 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
@@ -173 +173 @@
 CNetServerSession::CNetServerSession(CNetServerWorker& server, ENetPeer* peer) :
     m_Server(server), m_FileTransferer(this), m_Peer(peer)
 {
 }
 
+std::string CNetServerSession::GetIPAddress()
+{
+    char ipAddress[256] = "(error)";
+    enet_address_get_host_ip(&(m_Peer->address), ipAddress, ARRAY_SIZE(ipAddress));
+    return std::string(ipAddress);
+}
+
 void CNetServerSession::Disconnect(u32 reason)
 {
     Update((uint)NMT_CONNECTION_LOST, NULL);
 
     enet_peer_disconnect(m_Peer, reason);

source/network/NetSession.h

@@ -1 @@
-/* Copyright (C) 2011 Wildfire Games.
+/* 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
@@ -121 +121 @@
 
     u32 GetHostID() const { return m_HostID; }
     void SetHostID(u32 id) { m_HostID = id; }
 
     /**
+     * Returns the IP address of the client.
+     */
+    std::string 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

@@ -680 +680 @@
 }
 
 
 void EndGame()
 {
+    //TODO: The server should send a message telling the clients that the host quit on purpose
     SAFE_DELETE(g_NetClient);
     SAFE_DELETE(g_NetServer);
     SAFE_DELETE(g_Game);
 
     ISoundManager::CloseGame();