Ejemplo n.º 1
0
        public void ClientJoined(S server, Connection newConn)
        {
            var defaults = new GameRules.PlayerSettings();

            var client = new Session.Client()
            {
                Index = newConn.PlayerIndex,
                Color1 = defaults.Color1,
                Color2 = defaults.Color2,
                Name = defaults.Name,
                Country = "random",
                State = Session.ClientState.NotReady,
                SpawnPoint = 0,
                Team = 0,
                Slot = ChooseFreeSlot(server),
            };

            var slotData = server.lobbyInfo.Slots.FirstOrDefault( x => x.Index == client.Slot );
            if (slotData != null)
                SyncClientToPlayerReference(client, server.Map.Players[slotData.MapPlayer]);

            server.lobbyInfo.Clients.Add(client);

            Log.Write("server", "Client {0}: Accepted connection from {1}",
                newConn.PlayerIndex, newConn.socket.RemoteEndPoint);

            server.SendChat(newConn, "has joined the game.");
            server.SyncLobbyInfo();
        }
Ejemplo n.º 2
0
        public void ClientJoined(S server, Connection conn)
        {
            var client = server.GetClient(conn);

            // Validate whether color is allowed and get an alternative if it isn't
            if (client.Slot == null || !server.LobbyInfo.Slots[client.Slot].LockColor)
                client.Color = SanitizePlayerColor(server, client.Color, client.Index);
        }
Ejemplo n.º 3
0
        public static bool ValidateCommand(S server, Connection conn, Session.Client client, string cmd)
        {
            if (server.State == ServerState.GameStarted)
            {
                server.SendOrderTo(conn, "Message", "Cannot change state when game started. ({0})".F(cmd));
                return false;
            }
            else if (client.State == Session.ClientState.Ready && !(cmd.StartsWith("state") || cmd == "startgame"))
            {
                server.SendOrderTo(conn, "Message", "Cannot change state when marked as ready.");
                return false;
            }

            return true;
        }
        public static bool ValidateCommand(S server, Connection conn, Session.Client client, string cmd)
        {
            if (server.GameStarted)
            {
                server.SendChatTo(conn, "Cannot change state when game started. ({0})".F(cmd));
                return false;
            }
            else if (client.State == Session.ClientState.Ready && !(cmd == "ready" || cmd == "normalstart"))
            {
                server.SendChatTo(conn, "Cannot change state when marked as ready.");
                return false;
            }

            return true;
        }
Ejemplo n.º 5
0
		static bool ValidateSlotCommand(S server, Connection conn, Session.Client client, string arg, bool requiresHost)
		{
			if (!server.LobbyInfo.Slots.ContainsKey(arg))
			{
				Log.Write("server", "Invalid slot: {0}", arg);
				return false;
			}

			if (requiresHost && !client.IsAdmin)
			{
				server.SendOrderTo(conn, "Message", "Only the host can do that.");
				return false;
			}

			return true;
		}
Ejemplo n.º 6
0
		public void ClientJoined(OpenRA.Server.Server server, Connection conn)
		{
			if (server.LobbyInfo.ClientWithIndex(conn.PlayerIndex).IsAdmin)
				return;

			var defaults = new Session.Global();
			FieldLoader.Load(defaults, Game.ModData.Manifest.LobbyDefaults);

			if (server.LobbyInfo.GlobalSettings.FragileAlliances != defaults.FragileAlliances)
				server.SendOrderTo(conn, "Message", "Diplomacy Changes: {0}".F(server.LobbyInfo.GlobalSettings.FragileAlliances));

			if (server.LobbyInfo.GlobalSettings.AllowCheats != defaults.AllowCheats)
				server.SendOrderTo(conn, "Message", "Allow Cheats: {0}".F(server.LobbyInfo.GlobalSettings.AllowCheats));

			if (server.LobbyInfo.GlobalSettings.Shroud != defaults.Shroud)
				server.SendOrderTo(conn, "Message", "Explored map: {0}".F(!server.LobbyInfo.GlobalSettings.Shroud));

			if (server.LobbyInfo.GlobalSettings.Fog != defaults.Fog)
				server.SendOrderTo(conn, "Message", "Fog of war: {0}".F(server.LobbyInfo.GlobalSettings.Fog));

			if (server.LobbyInfo.GlobalSettings.Crates != defaults.Crates)
				server.SendOrderTo(conn, "Message", "Crates Appear: {0}".F(server.LobbyInfo.GlobalSettings.Crates));

			if (server.LobbyInfo.GlobalSettings.Creeps != defaults.Creeps)
				server.SendOrderTo(conn, "Message", "Creeps Spawn: {0}".F(server.LobbyInfo.GlobalSettings.Creeps));

			if (server.LobbyInfo.GlobalSettings.AllyBuildRadius != defaults.AllyBuildRadius)
				server.SendOrderTo(conn, "Message", "Build off Ally ConYards: {0}".F(server.LobbyInfo.GlobalSettings.AllyBuildRadius));

			if (server.LobbyInfo.GlobalSettings.StartingUnitsClass != defaults.StartingUnitsClass)
			{
				var startUnitsInfo = server.Map.Rules.Actors["world"].TraitInfos<MPStartUnitsInfo>();
				var selectedClass = startUnitsInfo.Where(u => u.Class == server.LobbyInfo.GlobalSettings.StartingUnitsClass).Select(u => u.ClassName).FirstOrDefault();
				var className = selectedClass != null ? selectedClass : server.LobbyInfo.GlobalSettings.StartingUnitsClass;
				server.SendOrderTo(conn, "Message", "Starting Units: {0}".F(className));
			}

			if (server.LobbyInfo.GlobalSettings.StartingCash != defaults.StartingCash)
				server.SendOrderTo(conn, "Message", "Starting Cash: ${0}".F(server.LobbyInfo.GlobalSettings.StartingCash));

			if (server.LobbyInfo.GlobalSettings.TechLevel != defaults.TechLevel)
				server.SendOrderTo(conn, "Message", "Tech Level: {0}".F(server.LobbyInfo.GlobalSettings.TechLevel));

			if (server.LobbyInfo.GlobalSettings.ShortGame != defaults.ShortGame)
				server.SendOrderTo(conn, "Message", "Short Game: {0}".F(server.LobbyInfo.GlobalSettings.ShortGame));
		}
Ejemplo n.º 7
0
        public void ClientJoined(OpenRA.Server.Server server, Connection conn)
        {
            if (server.LobbyInfo.ClientWithIndex(conn.PlayerIndex).IsAdmin)
                return;

            var defaults = new Session.Global();
            LobbyCommands.LoadMapSettings(server, defaults, server.Map.Rules);

            var options = server.Map.Rules.Actors["player"].TraitInfos<ILobbyOptions>()
                .Concat(server.Map.Rules.Actors["world"].TraitInfos<ILobbyOptions>())
                .SelectMany(t => t.LobbyOptions(server.Map.Rules))
                .ToDictionary(o => o.Id, o => o);

            foreach (var kv in server.LobbyInfo.GlobalSettings.LobbyOptions)
            {
                Session.LobbyOptionState def;
                LobbyOption option;
                if (!defaults.LobbyOptions.TryGetValue(kv.Key, out def) || kv.Value.Value != def.Value)
                    if (options.TryGetValue(kv.Key, out option))
                        server.SendOrderTo(conn, "Message", option.Name + ": " + kv.Value.Value);
            }
        }
Ejemplo n.º 8
0
        static HSLColor SanitizePlayerColor(S server, HSLColor askedColor, int playerIndex, Connection connectionToEcho = null)
        {
            var validator = server.ModData.Manifest.Get<ColorValidator>();
            var askColor = askedColor;

            Action<string> onError = message =>
            {
                if (connectionToEcho != null)
                    server.SendOrderTo(connectionToEcho, "Message", message);
            };

            var tileset = server.Map.Rules.TileSet;
            var terrainColors = tileset.TerrainInfo.Where(ti => ti.RestrictPlayerColor).Select(ti => ti.Color).ToList();
            var playerColors = server.LobbyInfo.Clients.Where(c => c.Index != playerIndex).Select(c => c.Color.RGB)
                .Concat(server.Map.Players.Players.Values.Select(p => p.Color.RGB)).ToList();

            return validator.MakeValid(askColor.RGB, server.Random, terrainColors, playerColors, onError);
        }
Ejemplo n.º 9
0
		public static bool ValidatePlayerNewColor(S server, Color askedColor, int playerIndex, Connection connectionToEcho = null)
		{
			Color forbiddenColor;
			return ValidatePlayerNewColor(server, askedColor, playerIndex, out forbiddenColor, connectionToEcho);
		}
Ejemplo n.º 10
0
		public static bool ValidatePlayerNewColor(S server, Color askedColor, int playerIndex, out Color forbiddenColor, Connection connectionToEcho = null)
		{
			// Validate color against the current map tileset
			var tileset = server.Map.Rules.TileSets[server.Map.Tileset];
			var forbiddenColors = tileset.TerrainInfo.Select(terrainInfo => terrainInfo.Color);

			if (!ValidateColorAgainstForbidden(askedColor, forbiddenColors, out forbiddenColor))
			{
				if (connectionToEcho != null)
					server.SendOrderTo(connectionToEcho, "Message", "Color was too similar to the terrain, and has been adjusted.");

				return false;
			}

			// Validate color against other clients
			var playerColors = server.LobbyInfo.Clients.Where(c => c.Index != playerIndex).Select(c => c.Color.RGB);
			if (!ValidateColorAgainstForbidden(askedColor, playerColors, out forbiddenColor))
			{
				if (connectionToEcho != null)
					server.SendOrderTo(connectionToEcho, "Message", "Color was too similar to another player's color, and has been adjusted.");

				return false;
			}

			var mapPlayerColors = server.MapPlayers.Players.Values.Select(p => p.ColorRamp.RGB);

			if (!ValidateColorAgainstForbidden(askedColor, mapPlayerColors, out forbiddenColor))
			{
				if (connectionToEcho != null)
					server.SendOrderTo(connectionToEcho, "Message", "Color was too similar to a non-combatant player, and has been adjusted.");

				return false;
			}

			// Color is valid
			forbiddenColor = default(Color);

			return true;
		}
Ejemplo n.º 11
0
        static bool ValidateSlotCommand(S server, Connection conn, string arg, bool requiresHost)
        {
            if (!server.lobbyInfo.Slots.ContainsKey(arg))
            {
                Log.Write("server", "Invalid slot: {0}", arg );
                return false;
            }

            if (requiresHost && conn.PlayerIndex != 0)
            {
                server.SendChatTo( conn, "Only the host can do that" );
                return false;
            }

            return true;
        }
Ejemplo n.º 12
0
        public bool InterpretCommand( S server, Connection conn, Session.Client client, string cmd)
        {
            if (server.GameStarted)
            {
                server.SendChatTo(conn, "Cannot change state when game started. ({0})".F(cmd));
                return false;
            }
            else if (client.State == Session.ClientState.Ready && !(cmd == "ready" || cmd == "startgame"))
            {
                server.SendChatTo(conn, "Cannot change state when marked as ready.");
                return false;
            }

            var dict = new Dictionary<string, Func<string, bool>>
            {
                { "name",
                    s =>
                    {
                        Log.Write("server", "Player@{0} is now known as {1}", conn.socket.RemoteEndPoint, s);
                        client.Name = s;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "race",
                    s =>
                    {
                        client.Country = s;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "team",
                    s =>
                    {
                        int team;
                        if (!int.TryParse(s, out team)) { Log.Write("server", "Invalid team: {0}", s ); return false; }

                        client.Team = team;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "spawn",
                    s =>
                    {
                        int spawnPoint;
                        if (!int.TryParse(s, out spawnPoint) || spawnPoint < 0 || spawnPoint > server.Map.SpawnPoints.Count())
                        {
                            Log.Write("server", "Invalid spawn point: {0}", s);
                            return false;
                        }

                        if (server.lobbyInfo.Slots[client.Slot].Spectator)
                        {
                            server.SendChatTo( conn, "Can't select a spawnpoint as a spectator" );
                            return false;
                        }

                        if (server.lobbyInfo.Clients.Where( c => c != client ).Any( c => (c.SpawnPoint == spawnPoint) && (c.SpawnPoint != 0) ))
                        {
                            server.SendChatTo( conn, "You can't be at the same spawn point as another player" );
                            return true;
                        }

                        client.SpawnPoint = spawnPoint;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "color",
                    s =>
                    {
                        var c = s.Split(',').Select(cc => int.Parse(cc)).ToArray();
                        client.ColorRamp = new ColorRamp((byte)c[0], (byte)c[1], (byte)c[2], (byte)c[3]);
                        server.SyncLobbyInfo();
                        return true;
                    }}
            };

            var cmdName = cmd.Split(' ').First();
            var cmdValue = string.Join(" ", cmd.Split(' ').Skip(1).ToArray());

            Func<string,bool> a;
            if (!dict.TryGetValue(cmdName, out a))
                return false;

            return a(cmdValue);
        }
Ejemplo n.º 13
0
        public bool InterpretCommand(S server, Connection conn, Session.Client client, string cmd)
        {
            if (!ValidateCommand(server, conn, client, cmd))
                return false;

            var dict = new Dictionary<string, Func<string, bool>>
            {
                { "ready",
                    s =>
                    {
                        // if we're downloading, we can't ready up.
                        if (client.State == Session.ClientState.NotReady)
                            client.State = Session.ClientState.Ready;
                        else if (client.State == Session.ClientState.Ready)
                            client.State = Session.ClientState.NotReady;

                        Log.Write("server", "Player @{0} is {1}",
                            conn.socket.RemoteEndPoint, client.State);

                        server.SyncLobbyInfo();

                        if (server.conns.Count > 0 && server.conns.All(c => server.GetClient(c).State == Session.ClientState.Ready))
                            InterpretCommand(server, conn, client, "startgame");

                        return true;
                    }},
                { "startgame",
                    s =>
                    {
                        server.StartGame();
                        return true;
                    }},
                { "lag",
                    s =>
                    {
                        int lag;
                        if (!int.TryParse(s, out lag)) { Log.Write("server", "Invalid order lag: {0}", s); return false; }

                        Log.Write("server", "Order lag is now {0} frames.", lag);

                        server.lobbyInfo.GlobalSettings.OrderLatency = lag;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "slot",
                    s =>
                    {
                        if (!server.lobbyInfo.Slots.ContainsKey(s))
                        {
                            Log.Write("server", "Invalid slot: {0}", s );
                            return false;
                        }
                        var slot = server.lobbyInfo.Slots[s];

                        if (slot.Closed || server.lobbyInfo.ClientInSlot(s) != null)
                            return false;

                        client.Slot = s;
                        S.SyncClientToPlayerReference(client, server.Map.Players[s]);

                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "spectate",
                    s =>
                    {
                        client.Slot = null;
                        client.SpawnPoint = 0;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "slot_close",
                    s =>
                    {
                        if (!ValidateSlotCommand( server, conn, client, s, true ))
                            return false;

                        // kick any player that's in the slot
                        var occupant = server.lobbyInfo.ClientInSlot(s);
                        if (occupant != null)
                        {
                            if (occupant.Bot != null)
                                server.lobbyInfo.Clients.Remove(occupant);
                            else
                            {
                                var occupantConn = server.conns.FirstOrDefault( c => c.PlayerIndex == occupant.Index );
                                if (occupantConn != null)
                                {
                                    server.SendOrderTo(occupantConn, "ServerError", "Your slot was closed by the host");
                                    server.DropClient(occupantConn);
                                }
                            }
                        }

                        server.lobbyInfo.Slots[s].Closed = true;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "slot_open",
                    s =>
                    {
                        if (!ValidateSlotCommand( server, conn, client, s, true ))
                            return false;

                        var slot = server.lobbyInfo.Slots[s];
                        slot.Closed = false;

                        // Slot may have a bot in it
                        var occupant = server.lobbyInfo.ClientInSlot(s);
                        if (occupant != null && occupant.Bot != null)
                            server.lobbyInfo.Clients.Remove(occupant);

                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "slot_bot",
                    s =>
                    {
                        var parts = s.Split(' ');

                        if (parts.Length < 2)
                        {
                            server.SendChatTo( conn, "Malformed slot_bot command" );
                            return true;
                        }

                        if (!ValidateSlotCommand( server, conn, client, parts[0], true ))
                            return false;

                        var slot = server.lobbyInfo.Slots[parts[0]];
                        var bot = server.lobbyInfo.ClientInSlot(parts[0]);
                        var botType = parts.Skip(1).JoinWith(" ");

                        // Invalid slot
                        if (bot != null && bot.Bot == null)
                        {
                            server.SendChatTo( conn, "Can't add bots to a slot with another client" );
                            return true;
                        }

                        slot.Closed = false;
                        if (bot == null)
                        {
                            // Create a new bot
                            bot = new Session.Client()
                            {
                                Index = server.ChooseFreePlayerIndex(),
                                Name = botType,
                                Bot = botType,
                                Slot = parts[0],
                                Country = "random",
                                SpawnPoint = 0,
                                Team = 0,
                                State = Session.ClientState.NotReady
                            };

                            // pick a random color for the bot
                            var hue = (byte)server.Random.Next(255);
                            var sat = (byte)server.Random.Next(255);
                            var lum = (byte)server.Random.Next(51,255);
                            bot.ColorRamp = new ColorRamp(hue, sat, lum, 10);

                            server.lobbyInfo.Clients.Add(bot);
                        }
                        else
                        {
                            // Change the type of the existing bot
                            bot.Name = botType;
                            bot.Bot = botType;
                        }

                        S.SyncClientToPlayerReference(bot, server.Map.Players[parts[0]]);
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "map",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendChatTo( conn, "Only the host can change the map" );
                            return true;
                        }
                        server.lobbyInfo.GlobalSettings.Map = s;
                        var oldSlots = server.lobbyInfo.Slots.Keys.ToArray();
                        LoadMap(server);

                        // Reassign players into new slots based on their old slots:
                        //  - Observers remain as observers
                        //  - Players who now lack a slot are made observers
                        //  - Bots who now lack a slot are dropped
                        var slots = server.lobbyInfo.Slots.Keys.ToArray();
                        int i = 0;
                        foreach (var os in oldSlots)
                        {
                            var c = server.lobbyInfo.ClientInSlot(os);
                            if (c == null)
                                continue;

                            c.SpawnPoint = 0;
                            c.State = Session.ClientState.NotReady;
                            c.Slot = i < slots.Length ? slots[i++] : null;
                            if (c.Slot != null)
                                S.SyncClientToPlayerReference(c, server.Map.Players[c.Slot]);
                            else if (c.Bot != null)
                                server.lobbyInfo.Clients.Remove(c);
                        }

                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "lockteams",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendChatTo( conn, "Only the host can set that option" );
                            return true;
                        }

                        bool.TryParse(s, out server.lobbyInfo.GlobalSettings.LockTeams);
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "allowcheats",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendChatTo( conn, "Only the host can set that option" );
                            return true;
                        }

                        bool.TryParse(s, out server.lobbyInfo.GlobalSettings.AllowCheats);
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "kick",
                    s =>
                    {

                        if (!client.IsAdmin)
                        {
                            server.SendChatTo( conn, "Only the host can kick players" );
                            return true;
                        }

                        int clientID;
                        int.TryParse( s, out clientID );

                        var connToKick = server.conns.SingleOrDefault( c => server.GetClient(c) != null && server.GetClient(c).Index == clientID);
                        if (connToKick == null)
                        {
                            server.SendChatTo( conn, "Noone in that slot." );
                            return true;
                        }

                        server.SendOrderTo(connToKick, "ServerError", "You have been kicked from the server");
                        server.DropClient(connToKick);
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "name",
                    s =>
                    {
                        Log.Write("server", "Player@{0} is now known as {1}", conn.socket.RemoteEndPoint, s);
                        client.Name = s;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "race",
                    s =>
                    {
                        var parts = s.Split(' ');
                        var targetClient = server.lobbyInfo.ClientWithIndex(int.Parse(parts[0]));

                        // Only the host can change other client's info
                        if (targetClient.Index != client.Index && !client.IsAdmin)
                            return true;

                        // Map has disabled race changes
                        if (server.lobbyInfo.Slots[targetClient.Slot].LockRace)
                            return true;

                        targetClient.Country = parts[1];
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "team",
                    s =>
                    {
                        var parts = s.Split(' ');
                        var targetClient = server.lobbyInfo.ClientWithIndex(int.Parse(parts[0]));

                        // Only the host can change other client's info
                        if (targetClient.Index != client.Index && !client.IsAdmin)
                            return true;

                        // Map has disabled team changes
                        if (server.lobbyInfo.Slots[targetClient.Slot].LockTeam)
                            return true;

                        int team;
                        if (!int.TryParse(parts[1], out team)) { Log.Write("server", "Invalid team: {0}", s ); return false; }

                        targetClient.Team = team;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "spawn",
                    s =>
                    {
                        var parts = s.Split(' ');
                        var targetClient = server.lobbyInfo.ClientWithIndex(int.Parse(parts[0]));

                        // Only the host can change other client's info
                        if (targetClient.Index != client.Index && !client.IsAdmin)
                            return true;

                        // Spectators don't need a spawnpoint
                        if (targetClient.Slot == null)
                            return true;

                        // Map has disabled spawn changes
                        if (server.lobbyInfo.Slots[targetClient.Slot].LockSpawn)
                            return true;

                        int spawnPoint;
                        if (!int.TryParse(parts[1], out spawnPoint) || spawnPoint < 0 || spawnPoint > server.Map.GetSpawnPoints().Length)
                        {
                            Log.Write("server", "Invalid spawn point: {0}", parts[1]);
                            return true;
                        }

                        if (server.lobbyInfo.Clients.Where( cc => cc != client ).Any( cc => (cc.SpawnPoint == spawnPoint) && (cc.SpawnPoint != 0) ))
                        {
                            server.SendChatTo( conn, "You can't be at the same spawn point as another player" );
                            return true;
                        }

                        targetClient.SpawnPoint = spawnPoint;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "color",
                    s =>
                    {
                        var parts = s.Split(' ');
                        var targetClient = server.lobbyInfo.ClientWithIndex(int.Parse(parts[0]));

                        // Only the host can change other client's info
                        if (targetClient.Index != client.Index && !client.IsAdmin)
                            return true;

                        // Map has disabled color changes
                        if (targetClient.Slot != null && server.lobbyInfo.Slots[targetClient.Slot].LockColor)
                            return true;

                        var ci = parts[1].Split(',').Select(cc => int.Parse(cc)).ToArray();
                        targetClient.ColorRamp = new ColorRamp((byte)ci[0], (byte)ci[1], (byte)ci[2], (byte)ci[3]);
                        server.SyncLobbyInfo();
                        return true;
                    }}
            };

            var cmdName = cmd.Split(' ').First();
            var cmdValue = cmd.Split(' ').Skip(1).JoinWith(" ");

            Func<string,bool> a;
            if (!dict.TryGetValue(cmdName, out a))
                return false;

            return a(cmdValue);
        }
Ejemplo n.º 14
0
        public void ClientJoined(S server, Connection conn)
        {
            var client = server.GetClient(conn);

            // Validate whether color is allowed and get an alternative if it isn't
            if (client.Slot == null || !server.LobbyInfo.Slots[client.Slot].LockColor)
                client.Color = SanitizePlayerColor(server, client.Color, client.Index);

            // Report any custom map details
            // HACK: this isn't the best place for this to live, but if we move it somewhere else
            // then we need a larger hack to hook the map change event.
            var briefing = MissionBriefingOrDefault(server);
            if (briefing != null)
                server.SendOrderTo(conn, "Message", briefing);
        }
Ejemplo n.º 15
0
        void CheckAutoStart(S server, Connection conn, Session.Client client)
        {
            var actualPlayers = server.conns
                .Select(c => server.GetClient(c))
                .Where(c => c.Slot != null);

            if (actualPlayers.Count() > 0 && actualPlayers.All(c => c.State == Session.ClientState.Ready))
                InterpretCommand(server, conn, client, "startgame");
        }
Ejemplo n.º 16
0
		public bool InterpretCommand(S server, Connection conn, Session.Client client, string cmd)
		{
			if (server == null || conn == null || client == null || !ValidateCommand(server, conn, client, cmd))
				return false;

			var dict = new Dictionary<string, Func<string, bool>>
			{
				{ "state",
					s =>
					{
						var state = Session.ClientState.Invalid;
						if (!Enum<Session.ClientState>.TryParse(s, false, out state))
						{
							server.SendOrderTo(conn, "Message", "Malformed state command");
							return true;
						}

						client.State = state;

						Log.Write("server", "Player @{0} is {1}",
							conn.Socket.RemoteEndPoint, client.State);

						server.SyncLobbyClients();

						CheckAutoStart(server);

						return true;
					}
				},
				{ "startgame",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can start the game.");
							return true;
						}

						if (server.LobbyInfo.Slots.Any(sl => sl.Value.Required &&
							server.LobbyInfo.ClientInSlot(sl.Key) == null))
						{
							server.SendOrderTo(conn, "Message", "Unable to start the game until required slots are full.");
							return true;
						}

						server.StartGame();
						return true;
					}
				},
				{ "slot",
					s =>
					{
						if (!server.LobbyInfo.Slots.ContainsKey(s))
						{
							Log.Write("server", "Invalid slot: {0}", s);
							return false;
						}

						var slot = server.LobbyInfo.Slots[s];

						if (slot.Closed || server.LobbyInfo.ClientInSlot(s) != null)
							return false;

						client.Slot = s;
						S.SyncClientToPlayerReference(client, server.MapPlayers.Players[s]);

						var validatedColor = ColorValidator.ValidatePlayerColorAndGetAlternative(server, client.Color, client.Index, conn);
						client.PreferredColor = client.Color = validatedColor;

						server.SyncLobbyClients();
						CheckAutoStart(server);

						return true;
					}
				},
				{ "allow_spectators",
					s =>
					{
						if (bool.TryParse(s, out server.LobbyInfo.GlobalSettings.AllowSpectators))
						{
							server.SyncLobbyGlobalSettings();
							return true;
						}
						else
						{
							server.SendOrderTo(conn, "Message", "Malformed allow_spectate command");
							return true;
						}
					}
				},
				{ "spectate",
					s =>
					{
						if (server.LobbyInfo.GlobalSettings.AllowSpectators || client.IsAdmin)
						{
							client.Slot = null;
							client.SpawnPoint = 0;
							client.Color = HSLColor.FromRGB(255, 255, 255);
							server.SyncLobbyClients();
							return true;
						}
						else
							return false;
					}
				},
				{ "slot_close",
					s =>
					{
						if (!ValidateSlotCommand(server, conn, client, s, true))
							return false;

						// kick any player that's in the slot
						var occupant = server.LobbyInfo.ClientInSlot(s);
						if (occupant != null)
						{
							if (occupant.Bot != null)
							{
								server.LobbyInfo.Clients.Remove(occupant);
								server.SyncLobbyClients();
								var ping = server.LobbyInfo.PingFromClient(occupant);
								if (ping != null)
								{
									server.LobbyInfo.ClientPings.Remove(ping);
									server.SyncClientPing();
								}
							}
							else
							{
								var occupantConn = server.Conns.FirstOrDefault(c => c.PlayerIndex == occupant.Index);
								if (occupantConn != null)
								{
									server.SendOrderTo(occupantConn, "ServerError", "Your slot was closed by the host.");
									server.DropClient(occupantConn);
								}
							}
						}

						server.LobbyInfo.Slots[s].Closed = true;
						server.SyncLobbySlots();
						return true;
					}
				},
				{ "slot_open",
					s =>
					{
						if (!ValidateSlotCommand(server, conn, client, s, true))
							return false;

						var slot = server.LobbyInfo.Slots[s];
						slot.Closed = false;
						server.SyncLobbySlots();

						// Slot may have a bot in it
						var occupant = server.LobbyInfo.ClientInSlot(s);
						if (occupant != null && occupant.Bot != null)
						{
							server.LobbyInfo.Clients.Remove(occupant);
							var ping = server.LobbyInfo.PingFromClient(occupant);
							if (ping != null)
							{
								server.LobbyInfo.ClientPings.Remove(ping);
								server.SyncClientPing();
							}
						}

						server.SyncLobbyClients();
						return true;
					}
				},
				{ "slot_bot",
					s =>
					{
						var parts = s.Split(' ');

						if (parts.Length < 3)
						{
							server.SendOrderTo(conn, "Message", "Malformed slot_bot command");
							return true;
						}

						if (!ValidateSlotCommand(server, conn, client, parts[0], true))
							return false;

						var slot = server.LobbyInfo.Slots[parts[0]];
						var bot = server.LobbyInfo.ClientInSlot(parts[0]);
						int controllerClientIndex;
						if (!Exts.TryParseIntegerInvariant(parts[1], out controllerClientIndex))
						{
							Log.Write("server", "Invalid bot controller client index: {0}", parts[1]);
							return false;
						}

						var botType = parts.Skip(2).JoinWith(" ");

						// Invalid slot
						if (bot != null && bot.Bot == null)
						{
							server.SendOrderTo(conn, "Message", "Can't add bots to a slot with another client.");
							return true;
						}

						slot.Closed = false;
						if (bot == null)
						{
							// Create a new bot
							bot = new Session.Client()
							{
								Index = server.ChooseFreePlayerIndex(),
								Name = botType,
								Bot = botType,
								Slot = parts[0],
								Faction = "Random",
								SpawnPoint = 0,
								Team = 0,
								State = Session.ClientState.NotReady,
								BotControllerClientIndex = controllerClientIndex
							};

							// Pick a random color for the bot
							HSLColor botColor;
							do
							{
								var hue = (byte)server.Random.Next(255);
								var sat = (byte)server.Random.Next(255);
								var lum = (byte)server.Random.Next(51, 255);
								botColor = new HSLColor(hue, sat, lum);
							} while (!ColorValidator.ValidatePlayerNewColor(server, botColor.RGB, bot.Index));

							bot.Color = bot.PreferredColor = botColor;

							server.LobbyInfo.Clients.Add(bot);
						}
						else
						{
							// Change the type of the existing bot
							bot.Name = botType;
							bot.Bot = botType;
						}

						S.SyncClientToPlayerReference(bot, server.MapPlayers.Players[parts[0]]);
						server.SyncLobbyClients();
						server.SyncLobbySlots();
						return true;
					}
				},
				{ "map",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can change the map.");
							return true;
						}

						if (server.ModData.MapCache[s].Status != MapStatus.Available)
						{
							server.SendOrderTo(conn, "Message", "Map was not found on server.");
							return true;
						}

						server.LobbyInfo.GlobalSettings.Map = s;

						var oldSlots = server.LobbyInfo.Slots.Keys.ToArray();
						LoadMap(server);
						SetDefaultDifficulty(server);

						// Reset client states
						foreach (var c in server.LobbyInfo.Clients)
							c.State = Session.ClientState.Invalid;

						// Reassign players into new slots based on their old slots:
						//  - Observers remain as observers
						//  - Players who now lack a slot are made observers
						//  - Bots who now lack a slot are dropped
						var slots = server.LobbyInfo.Slots.Keys.ToArray();
						var i = 0;
						foreach (var os in oldSlots)
						{
							var c = server.LobbyInfo.ClientInSlot(os);
							if (c == null)
								continue;

							c.SpawnPoint = 0;
							c.Slot = i < slots.Length ? slots[i++] : null;
							if (c.Slot != null)
							{
								// Remove Bot from slot if slot forbids bots
								if (c.Bot != null && !server.MapPlayers.Players[c.Slot].AllowBots)
									server.LobbyInfo.Clients.Remove(c);
								S.SyncClientToPlayerReference(c, server.MapPlayers.Players[c.Slot]);
							}
							else if (c.Bot != null)
								server.LobbyInfo.Clients.Remove(c);
						}

						foreach (var c in server.LobbyInfo.Clients)
						{
							// Validate if color is allowed and get an alternative it it isn't
							c.Color = c.PreferredColor = ColorValidator.ValidatePlayerColorAndGetAlternative(server, c.Color, c.Index, conn);
						}

						server.SyncLobbyInfo();

						server.SendMessage("{0} changed the map to {1}.".F(client.Name, server.Map.Title));

						if (server.Map.RuleDefinitions.Any())
							server.SendMessage("This map contains custom rules. Game experience may change.");

						return true;
					}
				},
				{ "fragilealliance",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						if (server.Map.Options.FragileAlliances.HasValue)
						{
							server.SendOrderTo(conn, "Message", "Map has disabled alliance configuration.");
							return true;
						}

						bool.TryParse(s, out server.LobbyInfo.GlobalSettings.FragileAlliances);
						server.SyncLobbyGlobalSettings();
						server.SendMessage("{0} {1} Diplomacy Changes."
							.F(client.Name, server.LobbyInfo.GlobalSettings.FragileAlliances ? "enabled" : "disabled"));

						return true;
					}
				},
				{ "allowcheats",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						if (server.Map.Options.Cheats.HasValue)
						{
							server.SendOrderTo(conn, "Message", "Map has disabled cheat configuration.");
							return true;
						}

						bool.TryParse(s, out server.LobbyInfo.GlobalSettings.AllowCheats);
						server.SyncLobbyGlobalSettings();
						server.SendMessage("{0} {1} the Debug Menu."
							.F(client.Name, server.LobbyInfo.GlobalSettings.AllowCheats ? "enabled" : "disabled"));

						return true;
					}
				},
				{ "shroud",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						if (server.Map.Options.Shroud.HasValue)
						{
							server.SendOrderTo(conn, "Message", "Map has disabled shroud configuration.");
							return true;
						}

						bool.TryParse(s, out server.LobbyInfo.GlobalSettings.Shroud);
						server.SyncLobbyGlobalSettings();
						server.SendMessage("{0} {1} Explored map."
							.F(client.Name, server.LobbyInfo.GlobalSettings.Shroud ? "disabled" : "enabled"));

						return true;
					}
				},
				{ "fog",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						if (server.Map.Options.Fog.HasValue)
						{
							server.SendOrderTo(conn, "Message", "Map has disabled fog configuration.");
							return true;
						}

						bool.TryParse(s, out server.LobbyInfo.GlobalSettings.Fog);
						server.SyncLobbyGlobalSettings();
						server.SendMessage("{0} {1} Fog of War."
							.F(client.Name, server.LobbyInfo.GlobalSettings.Fog ? "enabled" : "disabled"));

						return true;
					}
				},
				{ "assignteams",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						int teamCount;
						if (!Exts.TryParseIntegerInvariant(s, out teamCount))
						{
							server.SendOrderTo(conn, "Message", "Number of teams could not be parsed: {0}".F(s));
							return true;
						}

						var maxTeams = (server.LobbyInfo.Clients.Count(c => c.Slot != null) + 1) / 2;
						teamCount = teamCount.Clamp(0, maxTeams);
						var clients = server.LobbyInfo.Slots
							.Select(slot => server.LobbyInfo.ClientInSlot(slot.Key))
							.Where(c => c != null && !server.LobbyInfo.Slots[c.Slot].LockTeam);

						var assigned = 0;
						var clientCount = clients.Count();
						foreach (var player in clients)
						{
							// Free for all
							if (teamCount == 0)
								player.Team = 0;

							// Humans vs Bots
							else if (teamCount == 1)
								player.Team = player.Bot == null ? 1 : 2;
							else
								player.Team = assigned++ * teamCount / clientCount + 1;
						}

						server.SyncLobbyClients();
						return true;
					}
				},
				{ "crates",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						if (server.Map.Options.Crates.HasValue)
						{
							server.SendOrderTo(conn, "Message", "Map has disabled crate configuration.");
							return true;
						}

						bool.TryParse(s, out server.LobbyInfo.GlobalSettings.Crates);
						server.SyncLobbyGlobalSettings();
						server.SendMessage("{0} {1} Crates."
							.F(client.Name, server.LobbyInfo.GlobalSettings.Crates ? "enabled" : "disabled"));

						return true;
					}
				},
				{ "creeps",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						if (server.Map.Options.Creeps.HasValue)
						{
							server.SendOrderTo(conn, "Message", "Map has disabled Creeps spawning configuration.");
							return true;
						}

						bool.TryParse(s, out server.LobbyInfo.GlobalSettings.Creeps);
						server.SyncLobbyGlobalSettings();
						server.SendMessage("{0} {1} Creeps spawning."
							.F(client.Name, server.LobbyInfo.GlobalSettings.Creeps ? "enabled" : "disabled"));

						return true;
					}
				},
				{ "allybuildradius",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						if (server.Map.Options.AllyBuildRadius.HasValue)
						{
							server.SendOrderTo(conn, "Message", "Map has disabled ally build radius configuration.");
							return true;
						}

						bool.TryParse(s, out server.LobbyInfo.GlobalSettings.AllyBuildRadius);
						server.SyncLobbyGlobalSettings();
						server.SendMessage("{0} {1} Build off Allies' ConYards."
							.F(client.Name, server.LobbyInfo.GlobalSettings.AllyBuildRadius ? "enabled" : "disabled"));

						return true;
					}
				},
				{ "difficulty",
					s =>
					{
						if (!server.Map.Options.Difficulties.Any())
							return true;

						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						if (s != null && !server.Map.Options.Difficulties.Contains(s))
						{
							server.SendOrderTo(conn, "Message", "Unsupported difficulty selected: {0}".F(s));
							server.SendOrderTo(conn, "Message", "Supported difficulties: {0}".F(server.Map.Options.Difficulties.JoinWith(",")));
							return true;
						}

						server.LobbyInfo.GlobalSettings.Difficulty = s;
						server.SyncLobbyGlobalSettings();
						server.SendMessage("{0} changed difficulty to {1}.".F(client.Name, s));

						return true;
					}
				},
				{ "startingunits",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						if (!server.Map.Options.ConfigurableStartingUnits)
						{
							server.SendOrderTo(conn, "Message", "Map has disabled start unit configuration.");
							return true;
						}

						var startUnitsInfo = server.Map.Rules.Actors["world"].TraitInfos<MPStartUnitsInfo>();
						var selectedClass = startUnitsInfo.Where(u => u.Class == s).Select(u => u.ClassName).FirstOrDefault();
						var className = selectedClass != null ? selectedClass : s;

						server.LobbyInfo.GlobalSettings.StartingUnitsClass = s;
						server.SyncLobbyGlobalSettings();
						server.SendMessage("{0} changed Starting Units to {1}.".F(client.Name, className));

						return true;
					}
				},
				{ "startingcash",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						if (server.Map.Options.StartingCash.HasValue)
						{
							server.SendOrderTo(conn, "Message", "Map has disabled cash configuration.");
							return true;
						}

						server.LobbyInfo.GlobalSettings.StartingCash = Exts.ParseIntegerInvariant(s);
						server.SyncLobbyGlobalSettings();
						server.SendMessage("{0} changed Starting Cash to ${1}.".F(client.Name, s));

						return true;
					}
				},
				{ "techlevel",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						if (server.Map.Options.TechLevel != null)
						{
							server.SendOrderTo(conn, "Message", "Map has disabled Tech configuration.");
							return true;
						}

						server.LobbyInfo.GlobalSettings.TechLevel = s;
						server.SyncLobbyInfo();
						server.SendMessage("{0} changed Tech Level to {1}.".F(client.Name, s));

						return true;
					}
				},
				{ "gamespeed",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						var gameSpeeds = Game.ModData.Manifest.Get<GameSpeeds>();

						GameSpeed speed;
						if (!gameSpeeds.Speeds.TryGetValue(s, out speed))
						{
							server.SendOrderTo(conn, "Message", "Invalid game speed selected.");
							return true;
						}

						server.LobbyInfo.GlobalSettings.GameSpeedType = s;
						server.LobbyInfo.GlobalSettings.Timestep = speed.Timestep;
						server.LobbyInfo.GlobalSettings.OrderLatency =
							server.LobbyInfo.IsSinglePlayer ? 1 : speed.OrderLatency;

						server.SyncLobbyInfo();
						server.SendMessage("{0} changed Game Speed to {1}.".F(client.Name, speed.Name));

						return true;
					}
				},
				{ "kick",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can kick players.");
							return true;
						}

						var split = s.Split(' ');
						if (split.Length < 2)
						{
							server.SendOrderTo(conn, "Message", "Malformed kick command");
							return true;
						}

						int kickClientID;
						Exts.TryParseIntegerInvariant(split[0], out kickClientID);

						var kickConn = server.Conns.SingleOrDefault(c => server.GetClient(c) != null && server.GetClient(c).Index == kickClientID);
						if (kickConn == null)
						{
							server.SendOrderTo(conn, "Message", "Noone in that slot.");
							return true;
						}

						var kickClient = server.GetClient(kickConn);

						Log.Write("server", "Kicking client {0}.", kickClientID);
						server.SendMessage("{0} kicked {1} from the server.".F(client.Name, kickClient.Name));
						server.SendOrderTo(kickConn, "ServerError", "You have been kicked from the server.");
						server.DropClient(kickConn);

						bool tempBan;
						bool.TryParse(split[1], out tempBan);

						if (tempBan)
						{
							Log.Write("server", "Temporarily banning client {0} ({1}).", kickClientID, kickClient.IpAddress);
							server.SendMessage("{0} temporarily banned {1} from the server.".F(client.Name, kickClient.Name));
							server.TempBans.Add(kickClient.IpAddress);
						}

						server.SyncLobbyClients();
						server.SyncLobbySlots();

						return true;
					}
				},
				{ "name",
					s =>
					{
						var sanitizedName = OpenRA.Settings.SanitizedPlayerName(s);
						if (sanitizedName == client.Name)
							return true;

						Log.Write("server", "Player@{0} is now known as {1}.", conn.Socket.RemoteEndPoint, sanitizedName);
						server.SendMessage("{0} is now known as {1}.".F(client.Name, sanitizedName));
						client.Name = sanitizedName;
						server.SyncLobbyClients();
						return true;
					}
				},
				{ "faction",
					s =>
					{
						var parts = s.Split(' ');
						var targetClient = server.LobbyInfo.ClientWithIndex(Exts.ParseIntegerInvariant(parts[0]));

						// Only the host can change other client's info
						if (targetClient.Index != client.Index && !client.IsAdmin)
							return true;

						// Map has disabled faction changes
						if (server.LobbyInfo.Slots[targetClient.Slot].LockFaction)
							return true;

						targetClient.Faction = parts[1];
						server.SyncLobbyClients();
						return true;
					}
				},
				{ "team",
					s =>
					{
						var parts = s.Split(' ');
						var targetClient = server.LobbyInfo.ClientWithIndex(Exts.ParseIntegerInvariant(parts[0]));

						// Only the host can change other client's info
						if (targetClient.Index != client.Index && !client.IsAdmin)
							return true;

						// Map has disabled team changes
						if (server.LobbyInfo.Slots[targetClient.Slot].LockTeam)
							return true;

						int team;
						if (!Exts.TryParseIntegerInvariant(parts[1], out team))
						{
							Log.Write("server", "Invalid team: {0}", s);
							return false;
						}

						targetClient.Team = team;
						server.SyncLobbyClients();
						return true;
					}
				},
				{ "spawn",
					s =>
					{
						var parts = s.Split(' ');
						var targetClient = server.LobbyInfo.ClientWithIndex(Exts.ParseIntegerInvariant(parts[0]));

						// Only the host can change other client's info
						if (targetClient.Index != client.Index && !client.IsAdmin)
							return true;

						// Spectators don't need a spawnpoint
						if (targetClient.Slot == null)
							return true;

						// Map has disabled spawn changes
						if (server.LobbyInfo.Slots[targetClient.Slot].LockSpawn)
							return true;

						int spawnPoint;
						if (!Exts.TryParseIntegerInvariant(parts[1], out spawnPoint)
							|| spawnPoint < 0 || spawnPoint > server.Map.SpawnPoints.Value.Length)
						{
							Log.Write("server", "Invalid spawn point: {0}", parts[1]);
							return true;
						}

						if (server.LobbyInfo.Clients.Where(cc => cc != client).Any(cc => (cc.SpawnPoint == spawnPoint) && (cc.SpawnPoint != 0)))
						{
							server.SendOrderTo(conn, "Message", "You cannot occupy the same spawn point as another player.");
							return true;
						}

						targetClient.SpawnPoint = spawnPoint;
						server.SyncLobbyClients();
						return true;
					}
				},
				{ "color",
					s =>
					{
						var parts = s.Split(' ');
						var targetClient = server.LobbyInfo.ClientWithIndex(Exts.ParseIntegerInvariant(parts[0]));

						// Only the host can change other client's info
						if (targetClient.Index != client.Index && !client.IsAdmin)
							return true;

						// Spectator or map has disabled color changes
						if (targetClient.Slot == null || server.LobbyInfo.Slots[targetClient.Slot].LockColor)
							return true;

						var newHslColor = FieldLoader.GetValue<HSLColor>("(value)", parts[1]);

						// Validate if color is allowed and get an alternative it it isn't
						var altHslColor = ColorValidator.ValidatePlayerColorAndGetAlternative(server, newHslColor, targetClient.Index, conn);

						targetClient.Color = altHslColor;

						// Only update player's preferred color if new color is valid
						if (newHslColor == altHslColor)
							targetClient.PreferredColor = altHslColor;

						server.SyncLobbyClients();
						return true;
					}
				},
				{ "shortgame",
					s =>
					{
						if (!client.IsAdmin)
						{
							server.SendOrderTo(conn, "Message", "Only the host can set that option.");
							return true;
						}

						if (server.Map.Options.ShortGame.HasValue)
						{
							server.SendOrderTo(conn, "Message", "Map has disabled short game configuration.");
							return true;
						}

						bool.TryParse(s, out server.LobbyInfo.GlobalSettings.ShortGame);
						server.SyncLobbyGlobalSettings();
						server.SendMessage("{0} {1} Short Game."
							.F(client.Name, server.LobbyInfo.GlobalSettings.ShortGame ? "enabled" : "disabled"));

						return true;
					}
				}
			};

			var cmdName = cmd.Split(' ').First();
			var cmdValue = cmd.Split(' ').Skip(1).JoinWith(" ");

			Func<string, bool> a;
			if (!dict.TryGetValue(cmdName, out a))
				return false;

			return a(cmdValue);
		}
Ejemplo n.º 17
0
        public bool InterpretCommand(S server, Connection conn, Session.Client client, string cmd)
        {
            if (server == null || conn == null || client == null || !ValidateCommand(server, conn, client, cmd))
                return false;

            var dict = new Dictionary<string, Func<string, bool>>
            {
                { "state",
                    s =>
                    {
                        var state = Session.ClientState.Invalid;
                        if (!Enum<Session.ClientState>.TryParse(s, false, out state))
                        {
                            server.SendOrderTo(conn, "Message", "Malformed state command");
                            return true;
                        }

                        client.State = state;

                        Log.Write("server", "Player @{0} is {1}",
                            conn.Socket.RemoteEndPoint, client.State);

                        server.SyncLobbyClients();

                        CheckAutoStart(server);

                        return true;
                    }
                },
                { "startgame",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can start the game.");
                            return true;
                        }

                        if (server.LobbyInfo.Slots.Any(sl => sl.Value.Required &&
                            server.LobbyInfo.ClientInSlot(sl.Key) == null))
                        {
                            server.SendOrderTo(conn, "Message", "Unable to start the game until required slots are full.");
                            return true;
                        }

                        if (server.Settings.DisableSinglePlayer &&
                            server.LobbyInfo.Clients.Where(c => c.Bot == null && c.Slot != null).Count() == 1)
                        {
                            server.SendOrderTo(conn, "Message", "Unable to start the game until another player joins.");
                            return true;
                        }

                        server.StartGame();
                        return true;
                    }
                },
                { "slot",
                    s =>
                    {
                        if (!server.LobbyInfo.Slots.ContainsKey(s))
                        {
                            Log.Write("server", "Invalid slot: {0}", s);
                            return false;
                        }

                        var slot = server.LobbyInfo.Slots[s];

                        if (slot.Closed || server.LobbyInfo.ClientInSlot(s) != null)
                            return false;

                        // If the previous slot had a locked spawn then we must not carry that to the new slot
                        var oldSlot = client.Slot != null ? server.LobbyInfo.Slots[client.Slot] : null;
                        if (oldSlot != null && oldSlot.LockSpawn)
                            client.SpawnPoint = 0;

                        client.Slot = s;
                        S.SyncClientToPlayerReference(client, server.Map.Players.Players[s]);

                        if (!slot.LockColor)
                            client.PreferredColor = client.Color = SanitizePlayerColor(server, client.Color, client.Index, conn);

                        server.SyncLobbyClients();
                        CheckAutoStart(server);

                        return true;
                    }
                },
                { "allow_spectators",
                    s =>
                    {
                        if (bool.TryParse(s, out server.LobbyInfo.GlobalSettings.AllowSpectators))
                        {
                            server.SyncLobbyGlobalSettings();
                            return true;
                        }
                        else
                        {
                            server.SendOrderTo(conn, "Message", "Malformed allow_spectate command");
                            return true;
                        }
                    }
                },
                { "spectate",
                    s =>
                    {
                        if (server.LobbyInfo.GlobalSettings.AllowSpectators || client.IsAdmin)
                        {
                            client.Slot = null;
                            client.SpawnPoint = 0;
                            client.Color = HSLColor.FromRGB(255, 255, 255);
                            server.SyncLobbyClients();
                            return true;
                        }
                        else
                            return false;
                    }
                },
                { "slot_close",
                    s =>
                    {
                        if (!ValidateSlotCommand(server, conn, client, s, true))
                            return false;

                        // kick any player that's in the slot
                        var occupant = server.LobbyInfo.ClientInSlot(s);
                        if (occupant != null)
                        {
                            if (occupant.Bot != null)
                            {
                                server.LobbyInfo.Clients.Remove(occupant);
                                server.SyncLobbyClients();
                                var ping = server.LobbyInfo.PingFromClient(occupant);
                                if (ping != null)
                                {
                                    server.LobbyInfo.ClientPings.Remove(ping);
                                    server.SyncClientPing();
                                }
                            }
                            else
                            {
                                var occupantConn = server.Conns.FirstOrDefault(c => c.PlayerIndex == occupant.Index);
                                if (occupantConn != null)
                                {
                                    server.SendOrderTo(occupantConn, "ServerError", "Your slot was closed by the host.");
                                    server.DropClient(occupantConn);
                                }
                            }
                        }

                        server.LobbyInfo.Slots[s].Closed = true;
                        server.SyncLobbySlots();
                        return true;
                    }
                },
                { "slot_open",
                    s =>
                    {
                        if (!ValidateSlotCommand(server, conn, client, s, true))
                            return false;

                        var slot = server.LobbyInfo.Slots[s];
                        slot.Closed = false;
                        server.SyncLobbySlots();

                        // Slot may have a bot in it
                        var occupant = server.LobbyInfo.ClientInSlot(s);
                        if (occupant != null && occupant.Bot != null)
                        {
                            server.LobbyInfo.Clients.Remove(occupant);
                            var ping = server.LobbyInfo.PingFromClient(occupant);
                            if (ping != null)
                            {
                                server.LobbyInfo.ClientPings.Remove(ping);
                                server.SyncClientPing();
                            }
                        }

                        server.SyncLobbyClients();
                        return true;
                    }
                },
                { "slot_bot",
                    s =>
                    {
                        var parts = s.Split(' ');

                        if (parts.Length < 3)
                        {
                            server.SendOrderTo(conn, "Message", "Malformed slot_bot command");
                            return true;
                        }

                        if (!ValidateSlotCommand(server, conn, client, parts[0], true))
                            return false;

                        var slot = server.LobbyInfo.Slots[parts[0]];
                        var bot = server.LobbyInfo.ClientInSlot(parts[0]);
                        int controllerClientIndex;
                        if (!Exts.TryParseIntegerInvariant(parts[1], out controllerClientIndex))
                        {
                            Log.Write("server", "Invalid bot controller client index: {0}", parts[1]);
                            return false;
                        }

                        var botType = parts.Skip(2).JoinWith(" ");

                        // Invalid slot
                        if (bot != null && bot.Bot == null)
                        {
                            server.SendOrderTo(conn, "Message", "Can't add bots to a slot with another client.");
                            return true;
                        }

                        slot.Closed = false;
                        if (bot == null)
                        {
                            // Create a new bot
                            bot = new Session.Client()
                            {
                                Index = server.ChooseFreePlayerIndex(),
                                Name = botType,
                                Bot = botType,
                                Slot = parts[0],
                                Faction = "Random",
                                SpawnPoint = 0,
                                Team = 0,
                                State = Session.ClientState.NotReady,
                                BotControllerClientIndex = controllerClientIndex
                            };

                            // Pick a random color for the bot
                            var validator = server.ModData.Manifest.Get<ColorValidator>();
                            var tileset = server.Map.Rules.TileSet;
                            var terrainColors = tileset.TerrainInfo.Where(ti => ti.RestrictPlayerColor).Select(ti => ti.Color);
                            var playerColors = server.LobbyInfo.Clients.Select(c => c.Color.RGB)
                                .Concat(server.Map.Players.Players.Values.Select(p => p.Color.RGB));
                            bot.Color = bot.PreferredColor = validator.RandomValidColor(server.Random, terrainColors, playerColors);

                            server.LobbyInfo.Clients.Add(bot);
                        }
                        else
                        {
                            // Change the type of the existing bot
                            bot.Name = botType;
                            bot.Bot = botType;
                        }

                        S.SyncClientToPlayerReference(bot, server.Map.Players.Players[parts[0]]);
                        server.SyncLobbyClients();
                        server.SyncLobbySlots();
                        return true;
                    }
                },
                { "map",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can change the map.");
                            return true;
                        }

                        var lastMap = server.LobbyInfo.GlobalSettings.Map;
                        Action<MapPreview> selectMap = map =>
                        {
                            // Make sure the map hasn't changed in the meantime
                            if (server.LobbyInfo.GlobalSettings.Map != lastMap)
                                return;

                            server.LobbyInfo.GlobalSettings.Map = map.Uid;

                            var oldSlots = server.LobbyInfo.Slots.Keys.ToArray();
                            server.Map = server.ModData.MapCache[server.LobbyInfo.GlobalSettings.Map];

                            server.LobbyInfo.Slots = server.Map.Players.Players
                                .Select(p => MakeSlotFromPlayerReference(p.Value))
                                .Where(ss => ss != null)
                                .ToDictionary(ss => ss.PlayerReference, ss => ss);

                            LoadMapSettings(server.LobbyInfo.GlobalSettings, server.Map.Rules);

                            // Reset client states
                            foreach (var c in server.LobbyInfo.Clients)
                                c.State = Session.ClientState.Invalid;

                            // Reassign players into new slots based on their old slots:
                            //  - Observers remain as observers
                            //  - Players who now lack a slot are made observers
                            //  - Bots who now lack a slot are dropped
                            //  - Bots who are not defined in the map rules are dropped
                            var botNames = server.Map.Rules.Actors["player"].TraitInfos<IBotInfo>().Select(t => t.Name);
                            var slots = server.LobbyInfo.Slots.Keys.ToArray();
                            var i = 0;
                            foreach (var os in oldSlots)
                            {
                                var c = server.LobbyInfo.ClientInSlot(os);
                                if (c == null)
                                    continue;

                                c.SpawnPoint = 0;
                                c.Slot = i < slots.Length ? slots[i++] : null;
                                if (c.Slot != null)
                                {
                                    // Remove Bot from slot if slot forbids bots
                                    if (c.Bot != null && (!server.Map.Players.Players[c.Slot].AllowBots || !botNames.Contains(c.Bot)))
                                        server.LobbyInfo.Clients.Remove(c);
                                    S.SyncClientToPlayerReference(c, server.Map.Players.Players[c.Slot]);
                                }
                                else if (c.Bot != null)
                                    server.LobbyInfo.Clients.Remove(c);
                            }

                            // Validate if color is allowed and get an alternative if it isn't
                            foreach (var c in server.LobbyInfo.Clients)
                                if (c.Slot == null || (c.Slot != null && !server.LobbyInfo.Slots[c.Slot].LockColor))
                                    c.Color = c.PreferredColor = SanitizePlayerColor(server, c.Color, c.Index, conn);

                            server.SyncLobbyInfo();

                            server.SendMessage("{0} changed the map to {1}.".F(client.Name, server.Map.Title));

                            if (server.Map.DefinesUnsafeCustomRules)
                                server.SendMessage("This map contains custom rules. Game experience may change.");

                            if (server.Settings.DisableSinglePlayer)
                                server.SendMessage("Singleplayer games have been disabled on this server.");
                            else if (server.Map.Players.Players.Where(p => p.Value.Playable).All(p => !p.Value.AllowBots))
                                server.SendMessage("Bots have been disabled on this map.");
                        };

                        Action queryFailed = () =>
                            server.SendOrderTo(conn, "Message", "Map was not found on server.");

                        var m = server.ModData.MapCache[s];
                        if (m.Status == MapStatus.Available || m.Status == MapStatus.DownloadAvailable)
                            selectMap(m);
                        else if (server.Settings.QueryMapRepository)
                        {
                            server.SendOrderTo(conn, "Message", "Searching for map on the Resource Center...");
                            server.ModData.MapCache.QueryRemoteMapDetails(new[] { s }, selectMap, queryFailed);
                        }
                        else
                            queryFailed();

                        return true;
                    }
                },
                { "allowcheats",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option.");
                            return true;
                        }

                        var devMode = server.Map.Rules.Actors["player"].TraitInfo<DeveloperModeInfo>();
                        if (devMode.Locked)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled cheat configuration.");
                            return true;
                        }

                        bool.TryParse(s, out server.LobbyInfo.GlobalSettings.AllowCheats);
                        server.SyncLobbyGlobalSettings();
                        server.SendMessage("{0} {1} the Debug Menu."
                            .F(client.Name, server.LobbyInfo.GlobalSettings.AllowCheats ? "enabled" : "disabled"));

                        return true;
                    }
                },
                { "shroud",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option.");
                            return true;
                        }

                        var shroud = server.Map.Rules.Actors["player"].TraitInfo<ShroudInfo>();
                        if (shroud.ExploredMapLocked)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled shroud configuration.");
                            return true;
                        }

                        bool.TryParse(s, out server.LobbyInfo.GlobalSettings.Shroud);
                        server.SyncLobbyGlobalSettings();
                        server.SendMessage("{0} {1} Explored map."
                            .F(client.Name, server.LobbyInfo.GlobalSettings.Shroud ? "disabled" : "enabled"));

                        return true;
                    }
                },
                { "fog",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option.");
                            return true;
                        }

                        var shroud = server.Map.Rules.Actors["player"].TraitInfo<ShroudInfo>();
                        if (shroud.FogLocked)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled fog configuration.");
                            return true;
                        }

                        bool.TryParse(s, out server.LobbyInfo.GlobalSettings.Fog);
                        server.SyncLobbyGlobalSettings();
                        server.SendMessage("{0} {1} Fog of War."
                            .F(client.Name, server.LobbyInfo.GlobalSettings.Fog ? "enabled" : "disabled"));

                        return true;
                    }
                },
                { "assignteams",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option.");
                            return true;
                        }

                        int teamCount;
                        if (!Exts.TryParseIntegerInvariant(s, out teamCount))
                        {
                            server.SendOrderTo(conn, "Message", "Number of teams could not be parsed: {0}".F(s));
                            return true;
                        }

                        var maxTeams = (server.LobbyInfo.Clients.Count(c => c.Slot != null) + 1) / 2;
                        teamCount = teamCount.Clamp(0, maxTeams);
                        var clients = server.LobbyInfo.Slots
                            .Select(slot => server.LobbyInfo.ClientInSlot(slot.Key))
                            .Where(c => c != null && !server.LobbyInfo.Slots[c.Slot].LockTeam);

                        var assigned = 0;
                        var clientCount = clients.Count();
                        foreach (var player in clients)
                        {
                            // Free for all
                            if (teamCount == 0)
                                player.Team = 0;

                            // Humans vs Bots
                            else if (teamCount == 1)
                                player.Team = player.Bot == null ? 1 : 2;
                            else
                                player.Team = assigned++ * teamCount / clientCount + 1;
                        }

                        server.SyncLobbyClients();
                        return true;
                    }
                },
                { "crates",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option.");
                            return true;
                        }

                        var crateSpawner = server.Map.Rules.Actors["world"].TraitInfoOrDefault<CrateSpawnerInfo>();
                        if (crateSpawner == null || crateSpawner.Locked)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled crate configuration.");
                            return true;
                        }

                        bool.TryParse(s, out server.LobbyInfo.GlobalSettings.Crates);
                        server.SyncLobbyGlobalSettings();
                        server.SendMessage("{0} {1} Crates."
                            .F(client.Name, server.LobbyInfo.GlobalSettings.Crates ? "enabled" : "disabled"));

                        return true;
                    }
                },
                { "creeps",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option.");
                            return true;
                        }

                        var mapCreeps = server.Map.Rules.Actors["world"].TraitInfoOrDefault<MapCreepsInfo>();
                        if (mapCreeps == null || mapCreeps.Locked)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled Creeps spawning configuration.");
                            return true;
                        }

                        bool.TryParse(s, out server.LobbyInfo.GlobalSettings.Creeps);
                        server.SyncLobbyGlobalSettings();
                        server.SendMessage("{0} {1} Creeps spawning."
                            .F(client.Name, server.LobbyInfo.GlobalSettings.Creeps ? "enabled" : "disabled"));

                        return true;
                    }
                },
                { "allybuildradius",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option.");
                            return true;
                        }

                        var mapBuildRadius = server.Map.Rules.Actors["world"].TraitInfoOrDefault<MapBuildRadiusInfo>();
                        if (mapBuildRadius == null || mapBuildRadius.AllyBuildRadiusLocked)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled ally build radius configuration.");
                            return true;
                        }

                        bool.TryParse(s, out server.LobbyInfo.GlobalSettings.AllyBuildRadius);
                        server.SyncLobbyGlobalSettings();
                        server.SendMessage("{0} {1} Build off Allies' ConYards."
                            .F(client.Name, server.LobbyInfo.GlobalSettings.AllyBuildRadius ? "enabled" : "disabled"));

                        return true;
                    }
                },
                { "difficulty",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option.");
                            return true;
                        }

                        var mapOptions = server.Map.Rules.Actors["world"].TraitInfo<MapOptionsInfo>();
                        if (mapOptions.DifficultyLocked || !mapOptions.Difficulties.Any())
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled difficulty configuration.");
                            return true;
                        }

                        if (s != null && !mapOptions.Difficulties.Contains(s))
                        {
                            server.SendOrderTo(conn, "Message", "Invalid difficulty selected: {0}".F(s));
                            server.SendOrderTo(conn, "Message", "Supported values: {0}".F(mapOptions.Difficulties.JoinWith(", ")));
                            return true;
                        }

                        server.LobbyInfo.GlobalSettings.Difficulty = s;
                        server.SyncLobbyGlobalSettings();
                        server.SendMessage("{0} changed difficulty to {1}.".F(client.Name, s));

                        return true;
                    }
                },
                { "startingunits",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option.");
                            return true;
                        }

                        var startingUnits = server.Map.Rules.Actors["world"].TraitInfoOrDefault<SpawnMPUnitsInfo>();
                        if (startingUnits == null || startingUnits.Locked)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled start unit configuration.");
                            return true;
                        }

                        var startUnitsInfo = server.Map.Rules.Actors["world"].TraitInfos<MPStartUnitsInfo>();
                        var selectedClass = startUnitsInfo.Where(u => u.Class == s).FirstOrDefault();
                        if (selectedClass == null)
                        {
                            server.SendOrderTo(conn, "Message", "Invalid starting units option selected: {0}".F(s));
                            server.SendOrderTo(conn, "Message", "Supported values: {0}".F(startUnitsInfo.Select(su => su.ClassName).JoinWith(", ")));
                            return true;
                        }

                        server.LobbyInfo.GlobalSettings.StartingUnitsClass = selectedClass.Class;
                        server.SyncLobbyGlobalSettings();
                        server.SendMessage("{0} changed Starting Units to {1}.".F(client.Name, selectedClass.ClassName));

                        return true;
                    }
                },
                { "startingcash",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option.");
                            return true;
                        }

                        var playerResources = server.Map.Rules.Actors["player"].TraitInfo<PlayerResourcesInfo>();
                        if (playerResources.DefaultCashLocked)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled cash configuration.");
                            return true;
                        }

                        var startingCashOptions = playerResources.SelectableCash;
                        var requestedCash = Exts.ParseIntegerInvariant(s);
                        if (!startingCashOptions.Contains(requestedCash))
                        {
                            server.SendOrderTo(conn, "Message", "Invalid starting cash value selected: {0}".F(s));
                            server.SendOrderTo(conn, "Message", "Supported values: {0}".F(startingCashOptions.JoinWith(", ")));
                            return true;
                        }

                        server.LobbyInfo.GlobalSettings.StartingCash = requestedCash;
                        server.SyncLobbyGlobalSettings();
                        server.SendMessage("{0} changed Starting Cash to ${1}.".F(client.Name, requestedCash));

                        return true;
                    }
                },
                { "techlevel",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option.");
                            return true;
                        }

                        var mapOptions = server.Map.Rules.Actors["world"].TraitInfo<MapOptionsInfo>();
                        if (mapOptions.TechLevelLocked)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled Tech configuration.");
                            return true;
                        }

                        var techlevels = server.Map.Rules.Actors["player"].TraitInfos<ProvidesTechPrerequisiteInfo>().Select(t => t.Name);
                        if (!techlevels.Contains(s))
                        {
                            server.SendOrderTo(conn, "Message", "Invalid tech level selected: {0}".F(s));
                            server.SendOrderTo(conn, "Message", "Supported values: {0}".F(techlevels.JoinWith(", ")));
                            return true;
                        }

                        server.LobbyInfo.GlobalSettings.TechLevel = s;
                        server.SyncLobbyInfo();
                        server.SendMessage("{0} changed Tech Level to {1}.".F(client.Name, s));

                        return true;
                    }
                },
                { "gamespeed",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option.");
                            return true;
                        }

                        var gameSpeeds = server.ModData.Manifest.Get<GameSpeeds>();

                        GameSpeed speed;
                        if (!gameSpeeds.Speeds.TryGetValue(s, out speed))
                        {
                            server.SendOrderTo(conn, "Message", "Invalid game speed selected.");
                            return true;
                        }

                        server.LobbyInfo.GlobalSettings.GameSpeedType = s;
                        server.LobbyInfo.GlobalSettings.Timestep = speed.Timestep;
                        server.LobbyInfo.GlobalSettings.OrderLatency =
                            server.LobbyInfo.IsSinglePlayer ? 1 : speed.OrderLatency;

                        server.SyncLobbyInfo();
                        server.SendMessage("{0} changed Game Speed to {1}.".F(client.Name, speed.Name));

                        return true;
                    }
                },
                { "kick",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can kick players.");
                            return true;
                        }

                        var split = s.Split(' ');
                        if (split.Length < 2)
                        {
                            server.SendOrderTo(conn, "Message", "Malformed kick command");
                            return true;
                        }

                        int kickClientID;
                        Exts.TryParseIntegerInvariant(split[0], out kickClientID);

                        var kickConn = server.Conns.SingleOrDefault(c => server.GetClient(c) != null && server.GetClient(c).Index == kickClientID);
                        if (kickConn == null)
                        {
                            server.SendOrderTo(conn, "Message", "No-one in that slot.");
                            return true;
                        }

                        var kickClient = server.GetClient(kickConn);

                        Log.Write("server", "Kicking client {0}.", kickClientID);
                        server.SendMessage("{0} kicked {1} from the server.".F(client.Name, kickClient.Name));
                        server.SendOrderTo(kickConn, "ServerError", "You have been kicked from the server.");
                        server.DropClient(kickConn);

                        bool tempBan;
                        bool.TryParse(split[1], out tempBan);

                        if (tempBan)
                        {
                            Log.Write("server", "Temporarily banning client {0} ({1}).", kickClientID, kickClient.IpAddress);
                            server.SendMessage("{0} temporarily banned {1} from the server.".F(client.Name, kickClient.Name));
                            server.TempBans.Add(kickClient.IpAddress);
                        }

                        server.SyncLobbyClients();
                        server.SyncLobbySlots();

                        return true;
                    }
                },
                { "name",
                    s =>
                    {
                        var sanitizedName = Settings.SanitizedPlayerName(s);
                        if (sanitizedName == client.Name)
                            return true;

                        Log.Write("server", "Player@{0} is now known as {1}.", conn.Socket.RemoteEndPoint, sanitizedName);
                        server.SendMessage("{0} is now known as {1}.".F(client.Name, sanitizedName));
                        client.Name = sanitizedName;
                        server.SyncLobbyClients();
                        return true;
                    }
                },
                { "faction",
                    s =>
                    {
                        var parts = s.Split(' ');
                        var targetClient = server.LobbyInfo.ClientWithIndex(Exts.ParseIntegerInvariant(parts[0]));

                        // Only the host can change other client's info
                        if (targetClient.Index != client.Index && !client.IsAdmin)
                            return true;

                        // Map has disabled faction changes
                        if (server.LobbyInfo.Slots[targetClient.Slot].LockFaction)
                            return true;

                        var factions = server.Map.Rules.Actors["world"].TraitInfos<FactionInfo>()
                            .Where(f => f.Selectable).Select(f => f.InternalName);

                        if (!factions.Contains(parts[1]))
                        {
                            server.SendOrderTo(conn, "Message", "Invalid faction selected: {0}".F(parts[1]));
                            server.SendOrderTo(conn, "Message", "Supported values: {0}".F(factions.JoinWith(", ")));
                            return true;
                        }

                        targetClient.Faction = parts[1];
                        server.SyncLobbyClients();
                        return true;
                    }
                },
                { "team",
                    s =>
                    {
                        var parts = s.Split(' ');
                        var targetClient = server.LobbyInfo.ClientWithIndex(Exts.ParseIntegerInvariant(parts[0]));

                        // Only the host can change other client's info
                        if (targetClient.Index != client.Index && !client.IsAdmin)
                            return true;

                        // Map has disabled team changes
                        if (server.LobbyInfo.Slots[targetClient.Slot].LockTeam)
                            return true;

                        int team;
                        if (!Exts.TryParseIntegerInvariant(parts[1], out team))
                        {
                            Log.Write("server", "Invalid team: {0}", s);
                            return false;
                        }

                        targetClient.Team = team;
                        server.SyncLobbyClients();
                        return true;
                    }
                },
                { "spawn",
                    s =>
                    {
                        var parts = s.Split(' ');
                        var targetClient = server.LobbyInfo.ClientWithIndex(Exts.ParseIntegerInvariant(parts[0]));

                        // Only the host can change other client's info
                        if (targetClient.Index != client.Index && !client.IsAdmin)
                            return true;

                        // Spectators don't need a spawnpoint
                        if (targetClient.Slot == null)
                            return true;

                        // Map has disabled spawn changes
                        if (server.LobbyInfo.Slots[targetClient.Slot].LockSpawn)
                            return true;

                        int spawnPoint;
                        if (!Exts.TryParseIntegerInvariant(parts[1], out spawnPoint)
                            || spawnPoint < 0 || spawnPoint > server.Map.SpawnPoints.Length)
                        {
                            Log.Write("server", "Invalid spawn point: {0}", parts[1]);
                            return true;
                        }

                        if (server.LobbyInfo.Clients.Where(cc => cc != client).Any(cc => (cc.SpawnPoint == spawnPoint) && (cc.SpawnPoint != 0)))
                        {
                            server.SendOrderTo(conn, "Message", "You cannot occupy the same spawn point as another player.");
                            return true;
                        }

                        // Check if any other slot has locked the requested spawn
                        if (spawnPoint > 0)
                        {
                            var spawnLockedByAnotherSlot = server.LobbyInfo.Slots.Where(ss => ss.Value.LockSpawn).Any(ss =>
                            {
                                var pr = PlayerReferenceForSlot(server, ss.Value);
                                return pr != null && pr.Spawn == spawnPoint;
                            });

                            if (spawnLockedByAnotherSlot)
                            {
                                server.SendOrderTo(conn, "Message", "The spawn point is locked to another player slot.");
                                return true;
                            }
                        }

                        targetClient.SpawnPoint = spawnPoint;
                        server.SyncLobbyClients();
                        return true;
                    }
                },
                { "color",
                    s =>
                    {
                        var parts = s.Split(' ');
                        var targetClient = server.LobbyInfo.ClientWithIndex(Exts.ParseIntegerInvariant(parts[0]));

                        // Only the host can change other client's info
                        if (targetClient.Index != client.Index && !client.IsAdmin)
                            return true;

                        // Spectator or map has disabled color changes
                        if (targetClient.Slot == null || server.LobbyInfo.Slots[targetClient.Slot].LockColor)
                            return true;

                        // Validate if color is allowed and get an alternative it isn't
                        var newColor = FieldLoader.GetValue<HSLColor>("(value)", parts[1]);
                        targetClient.Color = SanitizePlayerColor(server, newColor, targetClient.Index, conn);

                        // Only update player's preferred color if new color is valid
                        if (newColor == targetClient.Color)
                            targetClient.PreferredColor = targetClient.Color;

                        server.SyncLobbyClients();
                        return true;
                    }
                },
                { "shortgame",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option.");
                            return true;
                        }

                        var mapOptions = server.Map.Rules.Actors["world"].TraitInfo<MapOptionsInfo>();
                        if (mapOptions.ShortGameLocked)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled short game configuration.");
                            return true;
                        }

                        bool.TryParse(s, out server.LobbyInfo.GlobalSettings.ShortGame);
                        server.SyncLobbyGlobalSettings();
                        server.SendMessage("{0} {1} Short Game."
                            .F(client.Name, server.LobbyInfo.GlobalSettings.ShortGame ? "enabled" : "disabled"));

                        return true;
                    }
                },
                { "sync_lobby",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set lobby info");
                            return true;
                        }

                        var lobbyInfo = Session.Deserialize(s);
                        if (lobbyInfo == null)
                        {
                            server.SendOrderTo(conn, "Message", "Invalid Lobby Info Sent");
                            return true;
                        }

                        server.LobbyInfo = lobbyInfo;

                        server.SyncLobbyInfo();
                        return true;
                    }
                }
            };

            var cmdName = cmd.Split(' ').First();
            var cmdValue = cmd.Split(' ').Skip(1).JoinWith(" ");

            Func<string, bool> a;
            if (!dict.TryGetValue(cmdName, out a))
                return false;

            return a(cmdValue);
        }
Ejemplo n.º 18
0
        public bool InterpretCommand(S server, Connection conn, Session.Client client, string cmd)
        {
            if (!ValidateCommand(server, conn, client, cmd))
                return false;

            var dict = new Dictionary<string, Func<string, bool>>
            {
                { "ready",
                    s =>
                    {
                        // if we're downloading, we can't ready up.
                        if (client.State == Session.ClientState.NotReady)
                            client.State = Session.ClientState.Ready;
                        else if (client.State == Session.ClientState.Ready)
                            client.State = Session.ClientState.NotReady;

                        Log.Write("server", "Player @{0} is {1}",
                            conn.socket.RemoteEndPoint, client.State);

                        server.SyncLobbyInfo();

                        CheckAutoStart(server, conn, client);

                        return true;
                    }},
                { "startgame",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can start the game");
                            return true;
                        }

                        if (server.lobbyInfo.Slots.Any(sl => sl.Value.Required &&
                            server.lobbyInfo.ClientInSlot(sl.Key) == null))
                        {
                            server.SendOrderTo(conn, "Message", "Unable to start the game until required slots are full.");
                            return true;
                        }
                        server.StartGame();
                        return true;
                    }},
                { "slot",
                    s =>
                    {
                        if (!server.lobbyInfo.Slots.ContainsKey(s))
                        {
                            Log.Write("server", "Invalid slot: {0}", s );
                            return false;
                        }
                        var slot = server.lobbyInfo.Slots[s];

                        if (slot.Closed || server.lobbyInfo.ClientInSlot(s) != null)
                            return false;

                        client.Slot = s;
                        S.SyncClientToPlayerReference(client, server.Map.Players[s]);

                        server.SyncLobbyInfo();
                        CheckAutoStart(server, conn, client);

                        return true;
                    }},
                { "spectate",
                    s =>
                    {
                        client.Slot = null;
                        client.SpawnPoint = 0;
                        client.Color = HSLColor.FromRGB(255, 255, 255);
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "slot_close",
                    s =>
                    {
                        if (!ValidateSlotCommand( server, conn, client, s, true ))
                            return false;

                        // kick any player that's in the slot
                        var occupant = server.lobbyInfo.ClientInSlot(s);
                        if (occupant != null)
                        {
                            if (occupant.Bot != null)
                                server.lobbyInfo.Clients.Remove(occupant);
                            else
                            {
                                var occupantConn = server.conns.FirstOrDefault( c => c.PlayerIndex == occupant.Index );
                                if (occupantConn != null)
                                {
                                    server.SendOrderTo(occupantConn, "ServerError", "Your slot was closed by the host");
                                    server.DropClient(occupantConn);
                                }
                            }
                        }

                        server.lobbyInfo.Slots[s].Closed = true;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "slot_open",
                    s =>
                    {
                        if (!ValidateSlotCommand( server, conn, client, s, true ))
                            return false;

                        var slot = server.lobbyInfo.Slots[s];
                        slot.Closed = false;

                        // Slot may have a bot in it
                        var occupant = server.lobbyInfo.ClientInSlot(s);
                        if (occupant != null && occupant.Bot != null)
                            server.lobbyInfo.Clients.Remove(occupant);

                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "slot_bot",
                    s =>
                    {
                        var parts = s.Split(' ');

                        if (parts.Length < 3)
                        {
                            server.SendOrderTo(conn, "Message", "Malformed slot_bot command");
                            return true;
                        }

                        if (!ValidateSlotCommand(server, conn, client, parts[0], true))
                            return false;

                        var slot = server.lobbyInfo.Slots[parts[0]];
                        var bot = server.lobbyInfo.ClientInSlot(parts[0]);
                        int controllerClientIndex;
                        if (!int.TryParse(parts[1], out controllerClientIndex))
                        {
                            Log.Write("server", "Invalid bot controller client index: {0}", parts[1]);
                            return false;
                        }
                        var botType = parts.Skip(2).JoinWith(" ");

                        // Invalid slot
                        if (bot != null && bot.Bot == null)
                        {
                            server.SendOrderTo(conn, "Message", "Can't add bots to a slot with another client");
                            return true;
                        }

                        slot.Closed = false;
                        if (bot == null)
                        {
                            // Create a new bot
                            bot = new Session.Client()
                            {
                                Index = server.ChooseFreePlayerIndex(),
                                Name = botType,
                                Bot = botType,
                                Slot = parts[0],
                                Country = "random",
                                SpawnPoint = 0,
                                Team = 0,
                                State = Session.ClientState.NotReady,
                                BotControllerClientIndex = controllerClientIndex
                            };

                            // pick a random color for the bot
                            var hue = (byte)server.Random.Next(255);
                            var sat = (byte)server.Random.Next(255);
                            var lum = (byte)server.Random.Next(51,255);
                            bot.Color = bot.PreferredColor = new HSLColor(hue, sat, lum);

                            server.lobbyInfo.Clients.Add(bot);
                        }
                        else
                        {
                            // Change the type of the existing bot
                            bot.Name = botType;
                            bot.Bot = botType;
                        }

                        S.SyncClientToPlayerReference(bot, server.Map.Players[parts[0]]);
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "map",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can change the map");
                            return true;
                        }

                        if (!server.ModData.AvailableMaps.ContainsKey(s))
                        {
                            server.SendOrderTo(conn, "Message", "Map not found");
                            return true;
                        }
                        server.lobbyInfo.GlobalSettings.Map = s;
                        var oldSlots = server.lobbyInfo.Slots.Keys.ToArray();
                        LoadMap(server);
                        SetDefaultDifficulty(server);

                        // Reassign players into new slots based on their old slots:
                        //  - Observers remain as observers
                        //  - Players who now lack a slot are made observers
                        //  - Bots who now lack a slot are dropped
                        var slots = server.lobbyInfo.Slots.Keys.ToArray();
                        int i = 0;
                        foreach (var os in oldSlots)
                        {
                            var c = server.lobbyInfo.ClientInSlot(os);
                            if (c == null)
                                continue;

                            c.SpawnPoint = 0;
                            c.State = Session.ClientState.NotReady;
                            c.Slot = i < slots.Length ? slots[i++] : null;
                            if (c.Slot != null)
                            {
                                // Remove Bot from slot if slot forbids bots
                                if (c.Bot != null && !server.Map.Players[c.Slot].AllowBots)
                                    server.lobbyInfo.Clients.Remove(c);
                                S.SyncClientToPlayerReference(c, server.Map.Players[c.Slot]);
                            }
                            else if (c.Bot != null)
                                server.lobbyInfo.Clients.Remove(c);
                        }

                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "fragilealliance",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option");
                            return true;
                        }

                        if (server.Map.Options.FragileAlliances.HasValue)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled alliance configuration");
                            return true;
                        }

                        bool.TryParse(s, out server.lobbyInfo.GlobalSettings.FragileAlliances);
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "allowcheats",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option");
                            return true;
                        }

                        if (server.Map.Options.Cheats.HasValue)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled cheat configuration");
                            return true;
                        }

                        bool.TryParse(s, out server.lobbyInfo.GlobalSettings.AllowCheats);
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "shroud",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option");
                            return true;
                        }

                        if (server.Map.Options.Shroud.HasValue)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled shroud configuration");
                            return true;
                        }

                        bool.TryParse(s, out server.lobbyInfo.GlobalSettings.Shroud);
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "fog",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option");
                            return true;
                        }

                        if (server.Map.Options.Fog.HasValue)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled fog configuration");
                            return true;
                        }

                        bool.TryParse(s, out server.lobbyInfo.GlobalSettings.Fog);
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "assignteams",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option");
                            return true;
                        }

                        int teamCount;
                        if (!int.TryParse(s, out teamCount))
                        {
                            server.SendOrderTo(conn, "Message", "Number of teams could not be parsed: {0}".F(s));
                            return true;
                        }

                        var maxTeams = (server.lobbyInfo.Clients.Count(c => c.Slot != null) + 1) / 2;
                        teamCount = teamCount.Clamp(0, maxTeams);
                        var players = server.lobbyInfo.Slots
                            .Select(slot => server.lobbyInfo.ClientInSlot(slot.Key))
                            .Where(c => c != null && !server.lobbyInfo.Slots[c.Slot].LockTeam);

                        var assigned = 0;
                        var playerCount = players.Count();
                        foreach (var player in players)
                        {
                            // Free for all
                            if (teamCount == 0)
                                player.Team = 0;

                            // Humans vs Bots
                            else if (teamCount == 1)
                                player.Team = player.Bot == null ? 1 : 2;

                            else
                                player.Team = assigned++ * teamCount / playerCount + 1;
                        }

                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "crates",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option");
                            return true;
                        }

                        if (server.Map.Options.Crates.HasValue)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled crate configuration");
                            return true;
                        }

                        bool.TryParse(s, out server.lobbyInfo.GlobalSettings.Crates);
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "allybuildradius",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option");
                            return true;
                        }

                        if (server.Map.Options.AllyBuildRadius.HasValue)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled ally build radius configuration");
                            return true;
                        }

                        bool.TryParse(s, out server.lobbyInfo.GlobalSettings.AllyBuildRadius);
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "difficulty",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option");
                            return true;
                        }

                        if (s != null && !server.Map.Options.Difficulties.Contains(s))
                        {
                            server.SendOrderTo(conn, "Message", "Unsupported difficulty selected: {0}".F(s));
                            server.SendOrderTo(conn, "Message", "Supported difficulties: {0}".F(server.Map.Options.Difficulties.JoinWith(",")));
                            return true;
                        }

                        server.lobbyInfo.GlobalSettings.Difficulty = s;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "startingunits",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option");
                            return true;
                        }

                        if (!server.Map.Options.ConfigurableStartingUnits)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled start unit configuration");
                            return true;
                        }

                        server.lobbyInfo.GlobalSettings.StartingUnitsClass = s;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "startingcash",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can set that option");
                            return true;
                        }

                        if (server.Map.Options.StartingCash.HasValue)
                        {
                            server.SendOrderTo(conn, "Message", "Map has disabled cash configuration");
                            return true;
                        }

                        server.lobbyInfo.GlobalSettings.StartingCash = int.Parse(s);
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "kick",
                    s =>
                    {
                        if (!client.IsAdmin)
                        {
                            server.SendOrderTo(conn, "Message", "Only the host can kick players");
                            return true;
                        }

                        var split = s.Split(' ');
                        if (split.Length < 2)
                        {
                            server.SendOrderTo(conn, "Message", "Malformed kick command");
                            return true;
                        }

                        int kickClientID;
                        int.TryParse(split[0], out kickClientID);

                        var kickConn = server.conns.SingleOrDefault(c => server.GetClient(c) != null && server.GetClient(c).Index == kickClientID);
                        if (kickConn == null)
                        {
                            server.SendOrderTo(conn, "Message", "Noone in that slot.");
                            return true;
                        }

                        var kickConnIP = server.GetClient(kickConn).IpAddress;

                        Log.Write("server", "Kicking client {0} as requested", kickClientID);
                        server.SendOrderTo(kickConn, "ServerError", "You have been kicked from the server");
                        server.DropClient(kickConn);

                        bool tempBan;
                        bool.TryParse(split[1], out tempBan);

                        if (tempBan)
                        {
                            Log.Write("server", "Temporarily banning client {0} ({1}) as requested", kickClientID, kickConnIP);
                            server.TempBans.Add(kickConnIP);
                        }

                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "name",
                    s =>
                    {
                        Log.Write("server", "Player@{0} is now known as {1}", conn.socket.RemoteEndPoint, s);
                        client.Name = s;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "race",
                    s =>
                    {
                        var parts = s.Split(' ');
                        var targetClient = server.lobbyInfo.ClientWithIndex(int.Parse(parts[0]));

                        // Only the host can change other client's info
                        if (targetClient.Index != client.Index && !client.IsAdmin)
                            return true;

                        // Map has disabled race changes
                        if (server.lobbyInfo.Slots[targetClient.Slot].LockRace)
                            return true;

                        targetClient.Country = parts[1];
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "team",
                    s =>
                    {
                        var parts = s.Split(' ');
                        var targetClient = server.lobbyInfo.ClientWithIndex(int.Parse(parts[0]));

                        // Only the host can change other client's info
                        if (targetClient.Index != client.Index && !client.IsAdmin)
                            return true;

                        // Map has disabled team changes
                        if (server.lobbyInfo.Slots[targetClient.Slot].LockTeam)
                            return true;

                        int team;
                        if (!int.TryParse(parts[1], out team))
                        {
                            Log.Write("server", "Invalid team: {0}", s );
                            return false;
                        }

                        targetClient.Team = team;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "spawn",
                    s =>
                    {
                        var parts = s.Split(' ');
                        var targetClient = server.lobbyInfo.ClientWithIndex(int.Parse(parts[0]));

                        // Only the host can change other client's info
                        if (targetClient.Index != client.Index && !client.IsAdmin)
                            return true;

                        // Spectators don't need a spawnpoint
                        if (targetClient.Slot == null)
                            return true;

                        // Map has disabled spawn changes
                        if (server.lobbyInfo.Slots[targetClient.Slot].LockSpawn)
                            return true;

                        int spawnPoint;
                        if (!int.TryParse(parts[1], out spawnPoint) || spawnPoint < 0 || spawnPoint > server.Map.GetSpawnPoints().Length)
                        {
                            Log.Write("server", "Invalid spawn point: {0}", parts[1]);
                            return true;
                        }

                        if (server.lobbyInfo.Clients.Where( cc => cc != client ).Any( cc => (cc.SpawnPoint == spawnPoint) && (cc.SpawnPoint != 0) ))
                        {
                            server.SendOrderTo(conn, "Message", "You can't be at the same spawn point as another player");
                            return true;
                        }

                        targetClient.SpawnPoint = spawnPoint;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "color",
                    s =>
                    {
                        var parts = s.Split(' ');
                        var targetClient = server.lobbyInfo.ClientWithIndex(int.Parse(parts[0]));

                        // Only the host can change other client's info
                        if (targetClient.Index != client.Index && !client.IsAdmin)
                            return true;

                        // Spectator or map has disabled color changes
                        if (targetClient.Slot == null || server.lobbyInfo.Slots[targetClient.Slot].LockColor)
                            return true;

                        var ci = parts[1].Split(',').Select(cc => int.Parse(cc)).ToArray();
                        targetClient.Color = targetClient.PreferredColor = new HSLColor((byte)ci[0], (byte)ci[1], (byte)ci[2]);
                        server.SyncLobbyInfo();
                        return true;
                    }}
            };

            var cmdName = cmd.Split(' ').First();
            var cmdValue = cmd.Split(' ').Skip(1).JoinWith(" ");

            Func<string, bool> a;
            if (!dict.TryGetValue(cmdName, out a))
                return false;

            return a(cmdValue);
        }
Ejemplo n.º 19
0
        public bool InterpretCommand(S server, Connection conn, Session.Client client, string cmd)
        {
            if (server.GameStarted)
            {
                server.SendChatTo(conn, "Cannot change state when game started. ({0})".F(cmd));
                return false;
            }
            else if (client.State == Session.ClientState.Ready && !(cmd == "ready" || cmd == "startgame"))
            {
                server.SendChatTo(conn, "Cannot change state when marked as ready.");
                return false;
            }

            var dict = new Dictionary<string, Func<string, bool>>
            {
                { "ready",
                    s =>
                    {
                        // if we're downloading, we can't ready up.
                        if (client.State == Session.ClientState.NotReady)
                            client.State = Session.ClientState.Ready;
                        else if (client.State == Session.ClientState.Ready)
                            client.State = Session.ClientState.NotReady;

                        Log.Write("server", "Player @{0} is {1}",
                            conn.socket.RemoteEndPoint, client.State);

                        server.SyncLobbyInfo();

                        if (server.conns.Count > 0 && server.conns.All(c => server.GetClient(c).State == Session.ClientState.Ready))
                            InterpretCommand(server, conn, client, "startgame");

                        return true;
                    }},
                { "startgame",
                    s =>
                    {
                        server.StartGame();
                        return true;
                    }},
                { "lag",
                    s =>
                    {
                        int lag;
                        if (!int.TryParse(s, out lag)) { Log.Write("server", "Invalid order lag: {0}", s); return false; }

                        Log.Write("server", "Order lag is now {0} frames.", lag);

                        server.lobbyInfo.GlobalSettings.OrderLatency = lag;
                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "spectator",
                    s =>
                        {
                            var slotData = server.lobbyInfo.Slots.Where(ax => ax.Spectator && !server.lobbyInfo.Clients.Any(l => l.Slot == ax.Index)).FirstOrDefault();
                            if (slotData == null)
                                return true;

                            client.Slot = slotData.Index;
                            SyncClientToPlayerReference(client, slotData.MapPlayer != null ? server.Map.Players[slotData.MapPlayer] : null);

                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "slot",
                    s =>
                    {
                        int slot;
                        if (!int.TryParse(s, out slot)) { Log.Write("server", "Invalid slot: {0}", s ); return false; }

                        var slotData = server.lobbyInfo.Slots.FirstOrDefault( x => x.Index == slot );
                        if (slotData == null || slotData.Closed || slotData.Bot != null
                            || server.lobbyInfo.Clients.Any( c => c.Slot == slot ))
                            return false;

                        client.Slot = slot;
                        SyncClientToPlayerReference(client, slotData.MapPlayer != null ? server.Map.Players[slotData.MapPlayer] : null);

                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "slot_close",
                    s =>
                    {
                        int slot;
                        if (!int.TryParse(s, out slot)) { Log.Write("server", "Invalid slot: {0}", s ); return false; }

                        var slotData = server.lobbyInfo.Slots.FirstOrDefault( x => x.Index == slot );
                        if (slotData == null)
                            return false;

                        if (conn.PlayerIndex != 0)
                        {
                            server.SendChatTo( conn, "Only the host can alter slots" );
                            return true;
                        }

                        slotData.Closed = true;
                        slotData.Bot = null;

                        /* kick any player that's in the slot */
                        var occupant = server.lobbyInfo.Clients.FirstOrDefault( c => c.Slot == slotData.Index );
                        if (occupant != null)
                        {
                            var occupantConn = server.conns.FirstOrDefault( c => c.PlayerIndex == occupant.Index );
                            if (occupantConn != null)
                                server.DropClient( occupantConn, new Exception() );
                        }

                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "slot_open",
                    s =>
                    {
                        int slot;
                        if (!int.TryParse(s, out slot)) { Log.Write("server", "Invalid slot: {0}", s ); return false; }

                        var slotData = server.lobbyInfo.Slots.FirstOrDefault( x => x.Index == slot );
                        if (slotData == null)
                            return false;

                        if (conn.PlayerIndex != 0)
                        {
                            server.SendChatTo( conn, "Only the host can alter slots" );
                            return true;
                        }

                        slotData.Closed = false;
                        slotData.Bot = null;

                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "slot_bot",
                    s =>
                    {
                        var parts = s.Split(' ');

                        if (parts.Length != 2)
                        {
                            server.SendChatTo( conn, "Malformed slot_bot command" );
                            return true;
                        }

                        int slot;
                        if (!int.TryParse(parts[0], out slot)) { Log.Write("server", "Invalid slot: {0}", s ); return false; }

                        var slotData = server.lobbyInfo.Slots.FirstOrDefault( x => x.Index == slot );
                        if (slotData == null)
                            return false;

                        if (conn.PlayerIndex != 0)
                        {
                            server.SendChatTo( conn, "Only the host can alter slots" );
                            return true;
                        }

                        slotData.Bot = parts[1];

                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "map",
                    s =>
                    {
                        if (conn.PlayerIndex != 0)
                        {
                            server.SendChatTo( conn, "Only the host can change the map" );
                            return true;
                        }
                        server.lobbyInfo.GlobalSettings.Map = s;
                        LoadMap(server);

                        foreach(var c in server.lobbyInfo.Clients)
                        {
                            c.SpawnPoint = 0;
                            var slotData = server.lobbyInfo.Slots.FirstOrDefault( x => x.Index == c.Slot );
                            if (slotData != null && slotData.MapPlayer != null)
                                SyncClientToPlayerReference(c, server.Map.Players[slotData.MapPlayer]);

                            c.State = Session.ClientState.NotReady;
                        }

                        server.SyncLobbyInfo();
                        return true;
                    }},
                { "lockteams",
                    s =>
                    {
                        if (conn.PlayerIndex != 0)
                        {
                            server.SendChatTo( conn, "Only the host can set that option" );
                            return true;
                        }

                        bool.TryParse(s, out server.lobbyInfo.GlobalSettings.LockTeams);
                        server.SyncLobbyInfo();
                        return true;
                    }},
            };

            var cmdName = cmd.Split(' ').First();
            var cmdValue = string.Join(" ", cmd.Split(' ').Skip(1).ToArray());

            Func<string,bool> a;
            if (!dict.TryGetValue(cmdName, out a))
                return false;

            return a(cmdValue);
        }
Ejemplo n.º 20
0
        void CheckAutoStart(S server, Connection conn, Session.Client client)
        {
            var playerClients = server.lobbyInfo.Clients.Where(c => c.Bot == null && c.Slot != null);

            // Are all players ready?
            if (playerClients.Count() == 0 || playerClients.Any(c => c.State != Session.ClientState.Ready))
                return;

            // Are the map conditions satisfied?
            if (server.lobbyInfo.Slots.Any(sl => sl.Value.Required && server.lobbyInfo.ClientInSlot(sl.Key) == null))
                return;

            server.StartGame();
        }
Ejemplo n.º 21
0
		public bool InterpretCommand(Server server, Connection conn, Session.Client client, string cmd)
		{
			Console.WriteLine("Server received command from player {1}: {0}",cmd, conn.PlayerIndex);
			return false;
		}
Ejemplo n.º 22
0
		public static HSLColor ValidatePlayerColorAndGetAlternative(S server, HSLColor askedColor, int playerIndex, Connection connectionToEcho = null)
		{
			var askColor = askedColor;

			Color invalidColor;
			if (!ValidatePlayerNewColor(server, askColor.RGB, playerIndex, out invalidColor, connectionToEcho))
			{
				var altColor = GetColorAlternative(askColor.RGB, invalidColor);
				if (altColor == null || !ValidatePlayerNewColor(server, altColor.Value, playerIndex))
				{
					// Pick a random color
					do
					{
						var hue = (byte)server.Random.Next(255);
						var sat = (byte)server.Random.Next(255);
						var lum = (byte)server.Random.Next(129, 255);
						askColor = new HSLColor(hue, sat, lum);
					} while (!ValidatePlayerNewColor(server, askColor.RGB, playerIndex));
				}
				else
					askColor = HSLColor.FromRGB(altColor.Value.R, altColor.Value.G, altColor.Value.B);
			}

			return askColor;
		}