423 lines
13 KiB
C#
423 lines
13 KiB
C#
#region Copyright & License Information
|
|
/*
|
|
* Copyright (c) The OpenRA Developers and Contributors
|
|
* This file is part of OpenRA, which is free software. It is made
|
|
* available to you under the terms of the GNU General Public License
|
|
* as published by the Free Software Foundation, either version 3 of
|
|
* the License, or (at your option) any later version. For more
|
|
* information, see COPYING.
|
|
*/
|
|
#endregion
|
|
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using OpenRA.Server;
|
|
using OpenRA.Traits;
|
|
|
|
namespace OpenRA.Network
|
|
{
|
|
public static class UnitOrders
|
|
{
|
|
public const int ChatMessageMaxLength = 2500;
|
|
|
|
[FluentReference("player")]
|
|
const string Joined = "notification-joined";
|
|
|
|
[FluentReference("player")]
|
|
const string Left = "notification-lobby-disconnected";
|
|
|
|
[FluentReference]
|
|
const string GameStarted = "notification-game-has-started";
|
|
|
|
[FluentReference]
|
|
const string GameSaved = "notification-game-saved";
|
|
|
|
[FluentReference("player")]
|
|
const string GamePaused = "notification-game-paused";
|
|
|
|
[FluentReference("player")]
|
|
const string GameUnpaused = "notification-game-unpaused";
|
|
|
|
public static int? KickVoteTarget { get; internal set; }
|
|
|
|
static Player FindPlayerByClient(this World world, Session.Client c)
|
|
{
|
|
return world.Players.FirstOrDefault(p => p.ClientIndex == c.Index && p.PlayerReference.Playable);
|
|
}
|
|
|
|
static bool OrderNotFromServerOrWorldIsReplay(int clientId, World world) => clientId != 0 || (world != null && world.IsReplay);
|
|
|
|
internal static void ProcessOrder(OrderManager orderManager, World world, int clientId, Order order)
|
|
{
|
|
switch (order.OrderString)
|
|
{
|
|
// Server message
|
|
case "Message":
|
|
TextNotificationsManager.AddSystemLine(order.TargetString);
|
|
break;
|
|
|
|
// Client side resolved server message
|
|
case "FluentMessage":
|
|
{
|
|
if (string.IsNullOrEmpty(order.TargetString))
|
|
break;
|
|
|
|
var yaml = MiniYaml.FromString(order.TargetString, order.OrderString);
|
|
foreach (var node in yaml)
|
|
{
|
|
var localizedMessage = new FluentMessage(node.Value);
|
|
if (localizedMessage.Key == Joined)
|
|
TextNotificationsManager.AddPlayerJoinedLine(localizedMessage.Key, localizedMessage.Arguments);
|
|
else if (localizedMessage.Key == Left)
|
|
TextNotificationsManager.AddPlayerLeftLine(localizedMessage.Key, localizedMessage.Arguments);
|
|
else
|
|
TextNotificationsManager.AddSystemLine(localizedMessage.Key, localizedMessage.Arguments);
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case "DisableChatEntry":
|
|
{
|
|
if (OrderNotFromServerOrWorldIsReplay(clientId, world))
|
|
break;
|
|
|
|
// Server may send MaxValue to indicate that it is disabled until further notice
|
|
if (order.ExtraData == uint.MaxValue)
|
|
TextNotificationsManager.ChatDisabledUntil = uint.MaxValue;
|
|
else
|
|
TextNotificationsManager.ChatDisabledUntil = Game.RunTime + order.ExtraData;
|
|
|
|
break;
|
|
}
|
|
|
|
case "StartKickVote":
|
|
{
|
|
if (OrderNotFromServerOrWorldIsReplay(clientId, world))
|
|
break;
|
|
|
|
KickVoteTarget = (int)order.ExtraData;
|
|
break;
|
|
}
|
|
|
|
case "EndKickVote":
|
|
{
|
|
if (OrderNotFromServerOrWorldIsReplay(clientId, world))
|
|
break;
|
|
|
|
if (KickVoteTarget == (int)order.ExtraData)
|
|
KickVoteTarget = null;
|
|
|
|
break;
|
|
}
|
|
|
|
case "Chat":
|
|
{
|
|
var client = orderManager.LobbyInfo.ClientWithIndex(clientId);
|
|
if (client == null)
|
|
break;
|
|
|
|
// Cut chat messages to the hard limit to avoid exploits
|
|
var message = order.TargetString;
|
|
if (message.Length > ChatMessageMaxLength)
|
|
message = order.TargetString[..ChatMessageMaxLength];
|
|
|
|
// ExtraData 0 means this is a normal chat order, everything else is team chat
|
|
if (order.ExtraData == 0)
|
|
{
|
|
var p = world?.FindPlayerByClient(client);
|
|
var suffix = (p != null && p.WinState == WinState.Lost) ? " (Dead)" : "";
|
|
suffix = client.IsObserver ? " (Spectator)" : suffix;
|
|
|
|
if (orderManager.LocalClient != null && client != orderManager.LocalClient && client.Team > 0 && client.Team == orderManager.LocalClient.Team)
|
|
suffix += " (Ally)";
|
|
|
|
TextNotificationsManager.AddChatLine(clientId, client.Name + suffix, message, client.Color);
|
|
break;
|
|
}
|
|
|
|
// We are still in the lobby
|
|
if (world == null)
|
|
{
|
|
var prefix = order.ExtraData == uint.MaxValue ? "[Spectators] " : "[Team] ";
|
|
if (orderManager.LocalClient != null && client.Team == orderManager.LocalClient.Team)
|
|
TextNotificationsManager.AddChatLine(clientId, prefix + client.Name, message, client.Color);
|
|
|
|
break;
|
|
}
|
|
|
|
var player = world.FindPlayerByClient(client);
|
|
var localClientIsObserver = world.IsReplay || (orderManager.LocalClient != null && orderManager.LocalClient.IsObserver)
|
|
|| (world.LocalPlayer != null && world.LocalPlayer.WinState != WinState.Undefined);
|
|
|
|
// ExtraData gives us the team number, uint.MaxValue means Spectators
|
|
if (order.ExtraData == uint.MaxValue && localClientIsObserver)
|
|
{
|
|
// Validate before adding the line
|
|
if (client.IsObserver || (player != null && player.WinState != WinState.Undefined))
|
|
TextNotificationsManager.AddChatLine(clientId, "[Spectators] " + client.Name, message, client.Color);
|
|
|
|
break;
|
|
}
|
|
|
|
var valid = client.Team == order.ExtraData && player != null && player.WinState == WinState.Undefined;
|
|
var isSameTeam = orderManager.LocalClient != null && order.ExtraData == orderManager.LocalClient.Team
|
|
&& world.LocalPlayer != null && world.LocalPlayer.WinState == WinState.Undefined;
|
|
|
|
if (valid && (isSameTeam || world.IsReplay))
|
|
TextNotificationsManager.AddChatLine(clientId, "[Team" + (world.IsReplay ? " " + order.ExtraData : "") + "] " + client.Name, message, client.Color);
|
|
|
|
break;
|
|
}
|
|
|
|
case "StartGame":
|
|
{
|
|
if (Game.ModData.MapCache[orderManager.LobbyInfo.GlobalSettings.Map].Status != MapStatus.Available)
|
|
{
|
|
Game.Disconnect();
|
|
Game.LoadShellMap();
|
|
|
|
// TODO: After adding a startup error dialog, notify the replay load failure.
|
|
break;
|
|
}
|
|
|
|
if (!string.IsNullOrEmpty(order.TargetString))
|
|
{
|
|
var data = MiniYaml.FromString(order.TargetString, order.OrderString);
|
|
var saveLastOrdersFrame = data.FirstOrDefault(n => n.Key == "SaveLastOrdersFrame");
|
|
if (saveLastOrdersFrame != null)
|
|
orderManager.GameSaveLastFrame =
|
|
FieldLoader.GetValue<int>("saveLastOrdersFrame", saveLastOrdersFrame.Value.Value);
|
|
|
|
var saveSyncFrame = data.FirstOrDefault(n => n.Key == "SaveSyncFrame");
|
|
if (saveSyncFrame != null)
|
|
orderManager.GameSaveLastSyncFrame =
|
|
FieldLoader.GetValue<int>("SaveSyncFrame", saveSyncFrame.Value.Value);
|
|
}
|
|
else
|
|
TextNotificationsManager.AddSystemLine(GameStarted);
|
|
|
|
Game.StartGame(orderManager.LobbyInfo.GlobalSettings.Map, WorldType.Regular);
|
|
break;
|
|
}
|
|
|
|
case "SaveTraitData":
|
|
{
|
|
var data = MiniYaml.FromString(order.TargetString, order.OrderString)[0];
|
|
var traitIndex = Exts.ParseInt32Invariant(data.Key);
|
|
|
|
world?.AddGameSaveTraitData(traitIndex, data.Value);
|
|
|
|
break;
|
|
}
|
|
|
|
case "GameSaved":
|
|
if (!orderManager.World.IsReplay)
|
|
TextNotificationsManager.AddSystemLine(GameSaved);
|
|
|
|
foreach (var nsr in orderManager.World.WorldActor.TraitsImplementing<INotifyGameSaved>())
|
|
nsr.GameSaved(orderManager.World);
|
|
break;
|
|
|
|
case "PauseGame":
|
|
{
|
|
var client = orderManager.LobbyInfo.ClientWithIndex(clientId);
|
|
if (client != null)
|
|
{
|
|
var pause = order.TargetString == "Pause";
|
|
|
|
// Prevent injected unpause orders from restarting a finished game
|
|
if (orderManager.World.IsGameOver && !pause)
|
|
break;
|
|
|
|
if (orderManager.World.Paused != pause && world != null && world.LobbyInfo.NonBotClients.Count() > 1)
|
|
TextNotificationsManager.AddSystemLine(pause ? GamePaused : GameUnpaused, FluentBundle.Arguments("player", client.Name));
|
|
|
|
orderManager.World.Paused = pause;
|
|
orderManager.World.PredictedPaused = pause;
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case "HandshakeRequest":
|
|
{
|
|
// Switch to the server's mod if we need and are able to
|
|
var mod = Game.ModData.Manifest;
|
|
var request = HandshakeRequest.Deserialize(order.TargetString, order.OrderString);
|
|
|
|
var externalKey = ExternalMod.MakeKey(request.Mod, request.Version);
|
|
if ((request.Mod != mod.Id || request.Version != mod.Metadata.Version) &&
|
|
Game.ExternalMods.TryGetValue(externalKey, out var external))
|
|
{
|
|
// The ConnectionFailedLogic will prompt the user to switch mods
|
|
CurrentServerSettings.ServerExternalMod = external;
|
|
orderManager.Connection.Dispose();
|
|
break;
|
|
}
|
|
|
|
Game.Settings.Player.Name = Settings.SanitizedPlayerName(Game.Settings.Player.Name);
|
|
Game.Settings.Save();
|
|
|
|
// Otherwise send the handshake with our current settings and let the server reject us
|
|
var info = new Session.Client()
|
|
{
|
|
Name = Game.Settings.Player.Name,
|
|
PreferredColor = Game.Settings.Player.Color,
|
|
Color = Game.Settings.Player.Color,
|
|
Faction = "Random",
|
|
SpawnPoint = 0,
|
|
Team = 0,
|
|
State = Session.ClientState.Invalid
|
|
};
|
|
|
|
var localProfile = Game.LocalPlayerProfile;
|
|
var response = new HandshakeResponse()
|
|
{
|
|
Client = info,
|
|
Mod = mod.Id,
|
|
Version = mod.Metadata.Version,
|
|
Password = CurrentServerSettings.Password,
|
|
Fingerprint = localProfile.Fingerprint,
|
|
OrdersProtocol = ProtocolVersion.Orders
|
|
};
|
|
|
|
if (request.AuthToken != null && response.Fingerprint != null)
|
|
response.AuthSignature = localProfile.Sign(request.AuthToken);
|
|
|
|
orderManager.IssueOrder(new Order("HandshakeResponse", null, false)
|
|
{
|
|
Type = OrderType.Handshake,
|
|
IsImmediate = true,
|
|
TargetString = response.Serialize()
|
|
});
|
|
|
|
break;
|
|
}
|
|
|
|
case "ServerError":
|
|
{
|
|
orderManager.ServerError = order.TargetString;
|
|
orderManager.AuthenticationFailed = false;
|
|
break;
|
|
}
|
|
|
|
case "AuthenticationError":
|
|
{
|
|
// The ConnectionFailedLogic will prompt the user for the password
|
|
orderManager.ServerError = order.TargetString;
|
|
orderManager.AuthenticationFailed = true;
|
|
break;
|
|
}
|
|
|
|
case "SyncInfo":
|
|
{
|
|
orderManager.LobbyInfo = Session.Deserialize(order.TargetString, order.OrderString);
|
|
Game.SyncLobbyInfo();
|
|
break;
|
|
}
|
|
|
|
case "SyncLobbyClients":
|
|
{
|
|
var clients = new List<Session.Client>();
|
|
var nodes = MiniYaml.FromString(order.TargetString, order.OrderString);
|
|
foreach (var node in nodes)
|
|
{
|
|
var strings = node.Key.Split('@');
|
|
if (strings[0] == "Client")
|
|
clients.Add(Session.Client.Deserialize(node.Value));
|
|
}
|
|
|
|
orderManager.LobbyInfo.Clients = clients;
|
|
Game.SyncLobbyInfo();
|
|
break;
|
|
}
|
|
|
|
case "SyncLobbySlots":
|
|
{
|
|
var slots = new Dictionary<string, Session.Slot>();
|
|
var nodes = MiniYaml.FromString(order.TargetString, order.OrderString);
|
|
foreach (var node in nodes)
|
|
{
|
|
var strings = node.Key.Split('@');
|
|
if (strings[0] == "Slot")
|
|
{
|
|
var slot = Session.Slot.Deserialize(node.Value);
|
|
slots.Add(slot.PlayerReference, slot);
|
|
}
|
|
}
|
|
|
|
orderManager.LobbyInfo.Slots = slots;
|
|
Game.SyncLobbyInfo();
|
|
break;
|
|
}
|
|
|
|
case "SyncLobbyGlobalSettings":
|
|
{
|
|
var nodes = MiniYaml.FromString(order.TargetString, order.OrderString);
|
|
foreach (var node in nodes)
|
|
{
|
|
var strings = node.Key.Split('@');
|
|
if (strings[0] == "GlobalSettings")
|
|
orderManager.LobbyInfo.GlobalSettings = Session.Global.Deserialize(node.Value);
|
|
}
|
|
|
|
Game.SyncLobbyInfo();
|
|
break;
|
|
}
|
|
|
|
case "SyncConnectionQuality":
|
|
{
|
|
var nodes = MiniYaml.FromString(order.TargetString, order.OrderString);
|
|
foreach (var node in nodes)
|
|
{
|
|
var strings = node.Key.Split('@');
|
|
if (strings[0] == "ConnectionQuality")
|
|
{
|
|
var client = orderManager.LobbyInfo.Clients.FirstOrDefault(c => c.Index == Exts.ParseInt32Invariant(strings[1]));
|
|
if (client != null)
|
|
client.ConnectionQuality = FieldLoader.GetValue<Session.ConnectionQuality>("ConnectionQuality", node.Value.Value);
|
|
}
|
|
}
|
|
|
|
break;
|
|
}
|
|
|
|
case "SyncMapPool":
|
|
{
|
|
orderManager.ServerMapPool = FieldLoader.GetValue<HashSet<string>>("SyncMapPool", order.TargetString);
|
|
break;
|
|
}
|
|
|
|
default:
|
|
{
|
|
if (world == null)
|
|
break;
|
|
|
|
if (order.GroupedActors == null)
|
|
ResolveOrder(order, world, orderManager, clientId);
|
|
else
|
|
foreach (var subject in order.GroupedActors)
|
|
ResolveOrder(Order.FromGroupedOrder(order, subject), world, orderManager, clientId);
|
|
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
static void ResolveOrder(Order order, World world, OrderManager orderManager, int clientId)
|
|
{
|
|
if (order.Subject == null || order.Subject.IsDead)
|
|
return;
|
|
|
|
if (world.OrderValidators.All(vo => vo.OrderValidation(orderManager, world, clientId, order)))
|
|
order.Subject.ResolveOrder(order);
|
|
}
|
|
|
|
public static void Clear()
|
|
{
|
|
KickVoteTarget = null;
|
|
}
|
|
}
|
|
}
|