Add C# dedicated server replacement
This commit is contained in:
Nomads_Reach
@@ -0,0 +1,39 @@
|
||||
name: CSharp Server Gate
|
||||
|
||||
on:
|
||||
push:
|
||||
branches:
|
||||
- rewrite/csharp-server
|
||||
paths:
|
||||
- "server/**/*.cs"
|
||||
- "server/**/*.csproj"
|
||||
- ".github/workflows/csharp-server.yml"
|
||||
workflow_dispatch:
|
||||
|
||||
jobs:
|
||||
build-and-test:
|
||||
runs-on: [self-hosted, Linux, X64]
|
||||
defaults:
|
||||
run:
|
||||
working-directory: server
|
||||
steps:
|
||||
- uses: actions/checkout@v4
|
||||
|
||||
- uses: actions/setup-dotnet@v4
|
||||
with:
|
||||
dotnet-version: "8.0.x"
|
||||
|
||||
- name: Report .NET
|
||||
run: dotnet --info
|
||||
|
||||
- name: Build C# server
|
||||
run: dotnet build CommonwealthOnline.Server.csproj -c Release --nologo
|
||||
|
||||
- name: Run C# server tests
|
||||
run: dotnet run --project tests/CommonwealthOnline.Server.Tests.csproj -c Release --no-restore
|
||||
|
||||
- name: Publish Linux server
|
||||
run: dotnet publish CommonwealthOnline.Server.csproj -c Release -r linux-x64 --self-contained false -o publish/linux-x64 --nologo
|
||||
|
||||
- name: Verify published entrypoint
|
||||
run: test -f publish/linux-x64/CommonwealthOnline.Server.dll
|
||||
@@ -0,0 +1,311 @@
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using System.Security.Cryptography;
|
||||
using System.Text;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
|
||||
namespace CommonwealthOnline.Server;
|
||||
|
||||
internal static class AdminTokenStore
|
||||
{
|
||||
public static string LoadOrCreate(string path)
|
||||
{
|
||||
var full = Path.GetFullPath(path);
|
||||
Directory.CreateDirectory(Path.GetDirectoryName(full)!);
|
||||
if (File.Exists(full))
|
||||
{
|
||||
var existing = File.ReadAllText(full, Encoding.UTF8).Trim();
|
||||
if (!string.IsNullOrEmpty(existing)) return existing;
|
||||
}
|
||||
var token = Convert.ToBase64String(RandomNumberGenerator.GetBytes(32)).TrimEnd('=').Replace('+', '-').Replace('/', '_');
|
||||
var temp = Path.Combine(Path.GetDirectoryName(full)!, $".{Path.GetFileName(full)}.{Environment.ProcessId}.{Guid.NewGuid():N}.tmp");
|
||||
try
|
||||
{
|
||||
using (var stream = new FileStream(temp, FileMode.CreateNew, FileAccess.Write, FileShare.None, 4096, FileOptions.WriteThrough))
|
||||
using (var writer = new StreamWriter(stream, new UTF8Encoding(false)))
|
||||
{
|
||||
writer.WriteLine(token);
|
||||
writer.Flush();
|
||||
stream.Flush(true);
|
||||
}
|
||||
BanStore.TryRestrictPermissions(temp);
|
||||
File.Move(temp, full, true);
|
||||
BanStore.TryRestrictPermissions(full);
|
||||
return token;
|
||||
}
|
||||
catch
|
||||
{
|
||||
try { File.Delete(temp); } catch { }
|
||||
if (File.Exists(full))
|
||||
{
|
||||
var existing = File.ReadAllText(full, Encoding.UTF8).Trim();
|
||||
if (!string.IsNullOrEmpty(existing)) return existing;
|
||||
}
|
||||
throw;
|
||||
}
|
||||
}
|
||||
|
||||
public static string Load(string path)
|
||||
{
|
||||
var token = File.ReadAllText(Path.GetFullPath(path), Encoding.UTF8).Trim();
|
||||
return string.IsNullOrEmpty(token) ? throw new InvalidOperationException($"Admin token file is empty: {path}") : token;
|
||||
}
|
||||
|
||||
public static bool EqualsConstantTime(string supplied, string expected)
|
||||
{
|
||||
var left = Encoding.UTF8.GetBytes(supplied);
|
||||
var right = Encoding.UTF8.GetBytes(expected);
|
||||
return left.Length == right.Length && CryptographicOperations.FixedTimeEquals(left, right);
|
||||
}
|
||||
}
|
||||
|
||||
internal sealed class AdminControlServer : IAsyncDisposable
|
||||
{
|
||||
private readonly AuthoritativeServer _server;
|
||||
private readonly ServerOptions _options;
|
||||
private readonly string _token;
|
||||
private readonly CancellationTokenSource _shutdown = new();
|
||||
private readonly List<Task> _clientTasks = new();
|
||||
private readonly object _gate = new();
|
||||
private TcpListener? _listener;
|
||||
private Task? _acceptTask;
|
||||
|
||||
public AdminControlServer(AuthoritativeServer server, ServerOptions options)
|
||||
{
|
||||
_server = server;
|
||||
_options = options;
|
||||
_token = AdminTokenStore.LoadOrCreate(options.AdminTokenPath);
|
||||
}
|
||||
|
||||
public void Start()
|
||||
{
|
||||
_listener = new TcpListener(IPAddress.Loopback, _options.AdminPort);
|
||||
_listener.Start();
|
||||
_acceptTask = Task.Run(() => AcceptLoopAsync(_shutdown.Token));
|
||||
_server.Log($"Admin control listening on 127.0.0.1:{_options.AdminPort} (localhost, authenticated)");
|
||||
}
|
||||
|
||||
private async Task AcceptLoopAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
while (!cancellationToken.IsCancellationRequested)
|
||||
{
|
||||
TcpClient client;
|
||||
try { client = await _listener!.AcceptTcpClientAsync(cancellationToken).ConfigureAwait(false); }
|
||||
catch (OperationCanceledException) { break; }
|
||||
catch (ObjectDisposedException) { break; }
|
||||
catch (SocketException) { if (cancellationToken.IsCancellationRequested) break; else continue; }
|
||||
var task = HandleClientAsync(client, cancellationToken);
|
||||
lock (_gate) _clientTasks.Add(task);
|
||||
_ = task.ContinueWith(_ => { lock (_gate) _clientTasks.Remove(task); }, TaskScheduler.Default);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task HandleClientAsync(TcpClient client, CancellationToken cancellationToken)
|
||||
{
|
||||
using (client)
|
||||
{
|
||||
var stream = client.GetStream();
|
||||
var read = new byte[4096];
|
||||
using var line = new MemoryStream();
|
||||
try
|
||||
{
|
||||
while (!cancellationToken.IsCancellationRequested)
|
||||
{
|
||||
var count = await stream.ReadAsync(read, cancellationToken).ConfigureAwait(false);
|
||||
if (count == 0) break;
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
if (read[i] == (byte)'\n')
|
||||
{
|
||||
var data = line.ToArray(); line.SetLength(0);
|
||||
if (data.Length == 0) continue;
|
||||
var response = data.Length > ProtocolConstants.MaxMessageBytes
|
||||
? Fail("Admin request is too large.")
|
||||
: await DispatchAsync(data).ConfigureAwait(false);
|
||||
var encoded = JsonSerializer.SerializeToUtf8Bytes(response);
|
||||
await stream.WriteAsync(encoded, cancellationToken).ConfigureAwait(false);
|
||||
await stream.WriteAsync(new byte[] { (byte)'\n' }, cancellationToken).ConfigureAwait(false);
|
||||
continue;
|
||||
}
|
||||
line.WriteByte(read[i]);
|
||||
if (line.Length > ProtocolConstants.MaxMessageBytes) return;
|
||||
}
|
||||
}
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or SocketException or OperationCanceledException) { }
|
||||
}
|
||||
}
|
||||
|
||||
private async Task<JsonObject> DispatchAsync(byte[] data)
|
||||
{
|
||||
JsonObject request;
|
||||
try { request = JsonNode.Parse(data) as JsonObject ?? throw new JsonException("request must be an object"); }
|
||||
catch (JsonException ex) { return Fail($"Invalid JSON: {ex.Message}"); }
|
||||
var supplied = JsonHelpers.String(request["adminToken"]);
|
||||
request.Remove("adminToken");
|
||||
if (supplied is null || !AdminTokenStore.EqualsConstantTime(supplied, _token)) return Fail("Unauthorized admin request.");
|
||||
var command = (JsonHelpers.String(request["cmd"] ?? request["command"]) ?? string.Empty).Trim().ToLowerInvariant();
|
||||
var id = request["id"]?.DeepClone();
|
||||
|
||||
JsonObject Ok(JsonNode? body = null, string? message = null)
|
||||
{
|
||||
var response = new JsonObject { ["ok"] = true };
|
||||
if (id is not null) response["id"] = id.DeepClone();
|
||||
if (!string.IsNullOrEmpty(message)) response["message"] = message;
|
||||
if (body is not null) response["data"] = body;
|
||||
return response;
|
||||
}
|
||||
JsonObject LocalFail(string error)
|
||||
{
|
||||
var response = Fail(error);
|
||||
if (id is not null) response["id"] = id.DeepClone();
|
||||
return response;
|
||||
}
|
||||
|
||||
switch (command)
|
||||
{
|
||||
case "ping": return Ok(new JsonObject { ["pong"] = true });
|
||||
case "stats": case "status": return Ok(_server.GetAdminStats());
|
||||
case "clients": case "users":
|
||||
{
|
||||
var clients = _server.GetAdminClients();
|
||||
return Ok(new JsonObject { ["total_clients"] = clients.Count, ["clients"] = clients });
|
||||
}
|
||||
case "bans":
|
||||
{
|
||||
var bans = new JsonArray(_server.ListBans().Select(x => (JsonNode)new JsonObject { ["ip"] = x.Ip, ["reason"] = x.Reason, ["bannedAt"] = x.BannedAt }).ToArray());
|
||||
return Ok(new JsonObject { ["bans"] = bans });
|
||||
}
|
||||
case "kick":
|
||||
{
|
||||
if (!JsonHelpers.TryUInt32(request["playerId"] ?? request["player_id"], 1, uint.MaxValue, out var playerId)) return LocalFail("kick requires playerId");
|
||||
var result = await _server.KickAsync(playerId, JsonHelpers.String(request["reason"]) ?? string.Empty).ConfigureAwait(false);
|
||||
return result.Ok ? Ok(result.Data, result.Message) : LocalFail(result.Message);
|
||||
}
|
||||
case "ban":
|
||||
{
|
||||
var reason = JsonHelpers.String(request["reason"]) ?? string.Empty;
|
||||
if (JsonHelpers.TryUInt32(request["playerId"] ?? request["player_id"], 1, uint.MaxValue, out var playerId))
|
||||
{
|
||||
var result = await _server.BanPlayerAsync(playerId, reason).ConfigureAwait(false);
|
||||
return result.Ok ? Ok(result.Data, result.Message) : LocalFail(result.Message);
|
||||
}
|
||||
var ip = JsonHelpers.String(request["ip"]);
|
||||
if (string.IsNullOrWhiteSpace(ip)) return LocalFail("ban requires playerId or ip");
|
||||
var ban = await _server.BanIpAsync(ip, reason).ConfigureAwait(false);
|
||||
return ban.Ok ? Ok(ban.Data, ban.Message) : LocalFail(ban.Message);
|
||||
}
|
||||
case "unban":
|
||||
{
|
||||
var ip = JsonHelpers.String(request["ip"]);
|
||||
if (string.IsNullOrWhiteSpace(ip)) return LocalFail("unban requires ip");
|
||||
var result = _server.Unban(ip);
|
||||
return result.Ok ? Ok(new JsonObject { ["ip"] = ip }, result.Message) : LocalFail(result.Message);
|
||||
}
|
||||
case "world_time":
|
||||
{
|
||||
var hhmm = JsonHelpers.String(request["hhmm"] ?? request["time"]);
|
||||
if (string.IsNullOrWhiteSpace(hhmm)) return LocalFail("world_time requires hhmm");
|
||||
return await _server.SetServerTimeAsync(hhmm).ConfigureAwait(false) ? Ok(message: $"Server time set to {hhmm}.") : LocalFail("Invalid time format. Use HHmm (e.g., 1430 for 14:30).");
|
||||
}
|
||||
case "world_weather":
|
||||
{
|
||||
var weather = JsonHelpers.String(request["weather"] ?? request["fw"]);
|
||||
if (string.IsNullOrWhiteSpace(weather)) return LocalFail("world_weather requires weather");
|
||||
return await _server.SetServerWeatherAsync(weather).ConfigureAwait(false) ? Ok(message: $"Server weather updated to {weather}.") : LocalFail("Invalid weather ID. Use an 8-digit hex form ID.");
|
||||
}
|
||||
default: return LocalFail($"Unknown admin command: {(string.IsNullOrEmpty(command) ? "(empty)" : command)}");
|
||||
}
|
||||
}
|
||||
|
||||
private static JsonObject Fail(string error) => new() { ["ok"] = false, ["error"] = error };
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
_shutdown.Cancel();
|
||||
try { _listener?.Stop(); } catch { }
|
||||
if (_acceptTask is not null) { try { await _acceptTask.ConfigureAwait(false); } catch { } }
|
||||
Task[] tasks; lock (_gate) tasks = _clientTasks.ToArray();
|
||||
if (tasks.Length > 0) { try { await Task.WhenAll(tasks).WaitAsync(TimeSpan.FromSeconds(2)); } catch { } }
|
||||
_shutdown.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
internal static class AdminClient
|
||||
{
|
||||
public static async Task<JsonObject> SendAsync(JsonObject request, int port, string tokenPath, CancellationToken cancellationToken = default)
|
||||
{
|
||||
var authenticated = (JsonObject)request.DeepClone();
|
||||
authenticated["adminToken"] = AdminTokenStore.Load(tokenPath);
|
||||
var encoded = JsonSerializer.SerializeToUtf8Bytes(authenticated);
|
||||
using var client = new TcpClient();
|
||||
await client.ConnectAsync(IPAddress.Loopback, port, cancellationToken).ConfigureAwait(false);
|
||||
var stream = client.GetStream();
|
||||
await stream.WriteAsync(encoded, cancellationToken).ConfigureAwait(false);
|
||||
await stream.WriteAsync(new byte[] { (byte)'\n' }, cancellationToken).ConfigureAwait(false);
|
||||
using var line = new MemoryStream();
|
||||
var one = new byte[1];
|
||||
while (line.Length <= ProtocolConstants.MaxMessageBytes)
|
||||
{
|
||||
var count = await stream.ReadAsync(one, cancellationToken).ConfigureAwait(false);
|
||||
if (count == 0) throw new IOException("Admin server closed the connection without a response.");
|
||||
if (one[0] == (byte)'\n') break;
|
||||
line.WriteByte(one[0]);
|
||||
}
|
||||
if (line.Length > ProtocolConstants.MaxMessageBytes) throw new InvalidDataException("Admin response exceeded the maximum size.");
|
||||
return JsonNode.Parse(line.ToArray()) as JsonObject ?? throw new InvalidDataException("Admin response must be a JSON object.");
|
||||
}
|
||||
}
|
||||
|
||||
internal sealed class LanDiscoveryService : IAsyncDisposable
|
||||
{
|
||||
public const int DiscoveryPort = 7778;
|
||||
public const string ProtocolName = "commonwealth-online";
|
||||
private readonly AuthoritativeServer _server;
|
||||
private readonly ServerOptions _options;
|
||||
private readonly CancellationTokenSource _shutdown = new();
|
||||
private UdpClient? _udp;
|
||||
private Task? _task;
|
||||
|
||||
public LanDiscoveryService(AuthoritativeServer server, ServerOptions options) { _server = server; _options = options; }
|
||||
|
||||
public void Start()
|
||||
{
|
||||
_udp = new UdpClient(new IPEndPoint(IPAddress.Any, DiscoveryPort));
|
||||
_udp.EnableBroadcast = true;
|
||||
_task = Task.Run(() => RunAsync(_shutdown.Token));
|
||||
_server.Log($"LAN discovery listening on UDP port {DiscoveryPort}");
|
||||
}
|
||||
|
||||
private async Task RunAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
while (!cancellationToken.IsCancellationRequested)
|
||||
{
|
||||
UdpReceiveResult result;
|
||||
try { result = await _udp!.ReceiveAsync(cancellationToken).ConfigureAwait(false); }
|
||||
catch (OperationCanceledException) { break; }
|
||||
catch (ObjectDisposedException) { break; }
|
||||
catch (SocketException) { continue; }
|
||||
JsonObject? request;
|
||||
try { request = JsonNode.Parse(result.Buffer) as JsonObject; } catch (JsonException) { continue; }
|
||||
if (request is null || JsonHelpers.String(request["type"]) != "discover" || JsonHelpers.String(request["protocol"]) != ProtocolName) continue;
|
||||
var core = _server.GetCoreStats();
|
||||
var response = new JsonObject
|
||||
{
|
||||
["type"] = "discoverResponse", ["protocol"] = ProtocolName, ["version"] = 1, ["name"] = _options.ServerName,
|
||||
["description"] = _options.ServerDescription, ["port"] = _options.Port, ["players"] = core["connectedClients"]?.DeepClone(), ["maxPlayers"] = _options.MaxPlayers
|
||||
};
|
||||
var bytes = JsonSerializer.SerializeToUtf8Bytes(response);
|
||||
try { await _udp.SendAsync(bytes, result.RemoteEndPoint, cancellationToken).ConfigureAwait(false); } catch { }
|
||||
}
|
||||
}
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
_shutdown.Cancel();
|
||||
_udp?.Dispose();
|
||||
if (_task is not null) { try { await _task.ConfigureAwait(false); } catch { } }
|
||||
_shutdown.Dispose();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,3 @@
|
||||
using System.Runtime.CompilerServices;
|
||||
|
||||
[assembly: InternalsVisibleTo("CommonwealthOnline.Server.Tests")]
|
||||
@@ -0,0 +1,836 @@
|
||||
using System.Collections.Concurrent;
|
||||
using System.Net;
|
||||
using System.Text.Json.Nodes;
|
||||
|
||||
namespace CommonwealthOnline.Server;
|
||||
|
||||
internal sealed class AuthoritativeServer : IServerIngress, IAsyncDisposable
|
||||
{
|
||||
private const int MaxPacketsPerSecond = 120;
|
||||
private const int MaxConnectAttempts = 8;
|
||||
private const double ConnectAttemptWindowSeconds = 10.0;
|
||||
private const double ClientIdleTimeoutSeconds = 60.0;
|
||||
private const double ClientHandshakeTimeoutSeconds = 10.0;
|
||||
|
||||
private readonly ServerOptions _options;
|
||||
private readonly BanStore _banStore;
|
||||
private readonly object _gate = new();
|
||||
private readonly Dictionary<string, ClientSession> _clients = new(StringComparer.Ordinal);
|
||||
private readonly Dictionary<uint, JsonObject> _lastPlayerStateByPlayerId = new();
|
||||
private readonly Dictionary<ScopeKey, JsonObject> _lastNpcStateByScope = new();
|
||||
private readonly NpcAuthorityManager _npcAuthority = new();
|
||||
private readonly Dictionary<string, Queue<double>> _connectAttempts = new(StringComparer.Ordinal);
|
||||
private readonly Dictionary<string, long> _stats = new(StringComparer.Ordinal);
|
||||
private readonly Dictionary<string, string> _serverWorldState = new(StringComparer.Ordinal);
|
||||
private readonly CancellationTokenSource _shutdown = new();
|
||||
private readonly Task _maintenanceTask;
|
||||
private JsonObject? _lastLegacyNpcState;
|
||||
private uint _nextPlayerId = 1;
|
||||
private uint? _worldStateHostPlayerId;
|
||||
private readonly double _startedAt = JsonHelpers.UnixTime();
|
||||
|
||||
public AuthoritativeServer(ServerOptions options)
|
||||
{
|
||||
_options = options;
|
||||
_banStore = new BanStore(options.BansPath);
|
||||
foreach (var name in new[]
|
||||
{
|
||||
"clientsConnected", "clientsDisconnected", "pendingConnectionsRejected", "packetsReceived", "packetsSent", "packetsBroadcast",
|
||||
"packetsRejected", "rateLimitedPackets", "transformPacketsReceived", "transformPacketsBroadcast", "transformPacketsInterestFiltered",
|
||||
"playerStatePacketsReceived", "playerStatePacketsBroadcast", "movementPacketsRejected", "movementCorrectionsSent",
|
||||
"worldStatePacketsReceived", "worldStatePacketsBroadcast", "npcStatePacketsReceived", "npcStatePacketsBroadcast",
|
||||
"npcAuthorityChanges", "npcAuthorityRejects", "combatHitsReceived", "combatHitsRouted", "worldStateHostPacketsBroadcast",
|
||||
"serverWorldStatePacketsBroadcast", "sessionEndedPacketsSent", "bannedConnectionsRejected", "disconnectPacketsBroadcast",
|
||||
"protocolV2Connections", "legacyConnections"
|
||||
}) _stats[name] = 0;
|
||||
_maintenanceTask = Task.Run(() => MaintenanceLoopAsync(_shutdown.Token));
|
||||
}
|
||||
|
||||
public event Action<string, string>? LogMessage;
|
||||
|
||||
public void Log(string message, string level = "info")
|
||||
{
|
||||
if (!ShouldLog(level)) return;
|
||||
LogMessage?.Invoke(message, level);
|
||||
}
|
||||
|
||||
private bool ShouldLog(string level)
|
||||
{
|
||||
static int Rank(string value) => value switch { "debug" => 10, "info" => 20, "warning" => 30, "error" => 40, _ => 20 };
|
||||
return Rank(level) >= Rank(_options.LogVerbosity);
|
||||
}
|
||||
|
||||
public async Task<bool> AcceptConnectionAsync(IGameConnection connection, CancellationToken cancellationToken)
|
||||
{
|
||||
var ip = connection.RemoteEndpoint.Address.ToString();
|
||||
var ban = _banStore.GetBan(ip);
|
||||
if (ban is not null)
|
||||
{
|
||||
Increment("bannedConnectionsRejected");
|
||||
await SendDirectSessionEndedAsync(connection, "banned", ban.Value.Reason, cancellationToken).ConfigureAwait(false);
|
||||
await connection.DisconnectAsync(0, "Banned");
|
||||
return false;
|
||||
}
|
||||
if (!AllowConnectAttempt(ip))
|
||||
{
|
||||
Increment("pendingConnectionsRejected");
|
||||
await SendDirectSessionEndedAsync(connection, "rate_limited", "Too many connection attempts.", cancellationToken).ConfigureAwait(false);
|
||||
await connection.DisconnectAsync(0, "Connection attempt rate limited");
|
||||
return false;
|
||||
}
|
||||
|
||||
ClientSession client;
|
||||
lock (_gate)
|
||||
{
|
||||
var maxPending = Math.Max(16, _options.MaxPlayers * 2);
|
||||
var pending = _clients.Values.Count(x => !x.GameplayActive);
|
||||
if (pending >= maxPending) client = null!;
|
||||
else
|
||||
{
|
||||
client = new ClientSession(connection, _nextPlayerId++);
|
||||
_clients[connection.ConnectionKey] = client;
|
||||
}
|
||||
}
|
||||
if (client is null)
|
||||
{
|
||||
Increment("pendingConnectionsRejected");
|
||||
await SendDirectSessionEndedAsync(connection, "rate_limited", "Too many pending connections.", cancellationToken).ConfigureAwait(false);
|
||||
await connection.DisconnectAsync(0, "Too many pending connections");
|
||||
return false;
|
||||
}
|
||||
|
||||
var capabilities = new JsonArray("interest-v1", "hello-v2", "bounded-framing", "rate-limit-v1", "movement-correction-v1", "npc-authority-epoch-v1", "player-state-v1");
|
||||
if (connection.TransportName == "gns")
|
||||
{
|
||||
capabilities.Add("gns-message-transport-v1");
|
||||
capabilities.Add("gns-snapshot-sequence-v1");
|
||||
}
|
||||
var welcome = new JsonObject
|
||||
{
|
||||
["type"] = "welcome",
|
||||
["playerId"] = client.PlayerId,
|
||||
["serverTime"] = JsonHelpers.UnixTime(),
|
||||
["serverName"] = _options.ServerName,
|
||||
["serverDescription"] = _options.ServerDescription,
|
||||
["protocolVersion"] = ProtocolConstants.ProtocolVersion,
|
||||
["capabilities"] = capabilities
|
||||
};
|
||||
Log($"{connection.TransportName.ToUpperInvariant()} accept: {client.Label} (provisional player {client.PlayerId})", "debug");
|
||||
if (!await SendPacketAsync(client, welcome, false, cancellationToken).ConfigureAwait(false))
|
||||
{
|
||||
await DisconnectClientAsync(client).ConfigureAwait(false);
|
||||
return false;
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
public async Task HandleMessageAsync(IGameConnection connection, ReadOnlyMemory<byte> payload, CancellationToken cancellationToken)
|
||||
{
|
||||
var client = FindByConnection(connection);
|
||||
if (client is null) { await connection.DisconnectAsync(0, "Unknown session"); return; }
|
||||
if (!await AllowPacketAsync(client).ConfigureAwait(false)) return;
|
||||
client.RecordReceived();
|
||||
Increment("packetsReceived");
|
||||
|
||||
JsonObject packet;
|
||||
try { packet = PacketCodec.Decode(payload.Span); }
|
||||
catch (PacketCodecException ex) { Reject(client, ex.Message); return; }
|
||||
await DispatchPacketAsync(client, packet, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
public async Task HandleTransportRejectAsync(IGameConnection connection, string reason, bool warning = false)
|
||||
{
|
||||
var client = FindByConnection(connection);
|
||||
if (client is null) return;
|
||||
if (!await AllowPacketAsync(client).ConfigureAwait(false)) return;
|
||||
client.RecordReceived();
|
||||
Increment("packetsReceived");
|
||||
Reject(client, reason, warning);
|
||||
}
|
||||
|
||||
public Task HandleConnectionClosedAsync(IGameConnection connection)
|
||||
{
|
||||
var client = FindByConnection(connection);
|
||||
return client is null ? Task.CompletedTask : DisconnectClientAsync(client);
|
||||
}
|
||||
|
||||
public async Task EndSessionForTransportAsync(IGameConnection connection, string code, string reason)
|
||||
{
|
||||
var client = FindByConnection(connection);
|
||||
if (client is null)
|
||||
{
|
||||
await SendDirectSessionEndedAsync(connection, code, reason, CancellationToken.None).ConfigureAwait(false);
|
||||
await connection.DisconnectAsync(0, reason);
|
||||
return;
|
||||
}
|
||||
await EndSessionAsync(client, code, reason).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task DispatchPacketAsync(ClientSession client, JsonObject packet, CancellationToken cancellationToken)
|
||||
{
|
||||
var packetType = JsonHelpers.String(packet["type"]);
|
||||
if (packetType == "hello") { await HandleHelloAsync(client, packet, cancellationToken).ConfigureAwait(false); return; }
|
||||
if (packetType == "keepAlive") return;
|
||||
|
||||
if (!client.GameplayActive)
|
||||
{
|
||||
if (packetType is not ("transform" or "worldState" or "npcState" or "combatHit"))
|
||||
{
|
||||
Reject(client, "Gameplay packet received before session activation");
|
||||
return;
|
||||
}
|
||||
if (!await ActivateClientAsync(client, ProtocolConstants.LegacyProtocolVersion, cancellationToken).ConfigureAwait(false))
|
||||
{
|
||||
await EndSessionAsync(client, "server_full", "Server is full.").ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
Log($"Legacy client player {client.PlayerId} activated without hello; client upgrade recommended.", "warning");
|
||||
}
|
||||
|
||||
switch (packetType)
|
||||
{
|
||||
case "transform": await HandleTransformAsync(client, packet, cancellationToken).ConfigureAwait(false); break;
|
||||
case "playerState": await HandlePlayerStateAsync(client, packet, cancellationToken).ConfigureAwait(false); break;
|
||||
case "worldState": await HandleWorldStateAsync(client, packet, cancellationToken).ConfigureAwait(false); break;
|
||||
case "npcState": await HandleNpcStateAsync(client, packet, cancellationToken).ConfigureAwait(false); break;
|
||||
case "combatHit": await HandleCombatHitAsync(client, packet, cancellationToken).ConfigureAwait(false); break;
|
||||
default: Reject(client, $"Unknown packet type: {packetType ?? "<null>"}"); break;
|
||||
}
|
||||
}
|
||||
|
||||
private async Task HandleHelloAsync(ClientSession client, JsonObject packet, CancellationToken cancellationToken)
|
||||
{
|
||||
if (!JsonHelpers.TryUInt32(packet["protocolVersion"], 1, ushort.MaxValue, out var version) || version != ProtocolConstants.ProtocolVersion)
|
||||
{
|
||||
await EndSessionAsync(client, "protocol_mismatch", $"Server requires protocol {ProtocolConstants.ProtocolVersion}.").ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
if (!await ActivateClientAsync(client, (int)version, cancellationToken).ConfigureAwait(false))
|
||||
await EndSessionAsync(client, "server_full", "Server is full.").ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task<bool> ActivateClientAsync(ClientSession client, int protocolVersion, CancellationToken cancellationToken)
|
||||
{
|
||||
bool becameHost;
|
||||
lock (_gate)
|
||||
{
|
||||
if (client.GameplayActive) return true;
|
||||
if (_clients.Values.Count(x => x.GameplayActive) >= _options.MaxPlayers) return false;
|
||||
if (!client.Activate(protocolVersion)) return true;
|
||||
_stats["clientsConnected"]++;
|
||||
_stats[protocolVersion >= ProtocolConstants.ProtocolVersion ? "protocolV2Connections" : "legacyConnections"]++;
|
||||
becameHost = _worldStateHostPlayerId is null;
|
||||
if (becameHost) _worldStateHostPlayerId = client.PlayerId;
|
||||
}
|
||||
|
||||
Log($"Client connected: {client.Label} (player {client.PlayerId}, protocol {protocolVersion})");
|
||||
var ready = new JsonObject
|
||||
{
|
||||
["type"] = "sessionReady", ["playerId"] = client.PlayerId, ["protocolVersion"] = protocolVersion,
|
||||
["serverProtocolVersion"] = ProtocolConstants.ProtocolVersion, ["worldStateHostPlayerId"] = _worldStateHostPlayerId,
|
||||
["serverTime"] = JsonHelpers.UnixTime()
|
||||
};
|
||||
if (!await SendPacketAsync(client, ready, false, cancellationToken).ConfigureAwait(false)) return false;
|
||||
await SendExistingTransformsAsync(client, cancellationToken).ConfigureAwait(false);
|
||||
await SendExistingPlayerStatesAsync(client, cancellationToken).ConfigureAwait(false);
|
||||
await SendExistingNpcStateAsync(client, cancellationToken).ConfigureAwait(false);
|
||||
if (becameHost) await BroadcastWorldStateHostAsync(client.PlayerId, cancellationToken).ConfigureAwait(false);
|
||||
return true;
|
||||
}
|
||||
|
||||
private async Task HandleTransformAsync(ClientSession client, JsonObject packet, CancellationToken cancellationToken)
|
||||
{
|
||||
var normalized = ProtocolValidation.NormalizeTransform(packet);
|
||||
if (normalized is null) { Reject(client, "Malformed transform"); return; }
|
||||
if (client.ProtocolVersion >= ProtocolConstants.ProtocolVersion)
|
||||
foreach (var field in new[] { "equippedItems", "appearance", "actionEvents", "characterName" }) normalized.Remove(field);
|
||||
var previous = client.TransformAnchor();
|
||||
var acceptedMonotonic = MonotonicClock.Now;
|
||||
var movement = ProtocolValidation.ValidateMovement(previous.Transform, previous.Monotonic, normalized, acceptedMonotonic);
|
||||
if (!movement.Accepted)
|
||||
{
|
||||
Increment("movementPacketsRejected");
|
||||
Reject(client, movement.Reason);
|
||||
await SendPositionCorrectionAsync(client, movement.Reason, cancellationToken).ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
var previousScope = AuthorityScopeFromTransform(previous.Transform);
|
||||
normalized["playerId"] = client.PlayerId;
|
||||
normalized["serverTime"] = JsonHelpers.UnixTime();
|
||||
client.RecordTransform(normalized, acceptedMonotonic);
|
||||
Increment("transformPacketsReceived");
|
||||
await BroadcastTransformAsync(client, normalized, cancellationToken).ConfigureAwait(false);
|
||||
await ReconcileNpcAuthorityAsync(cancellationToken).ConfigureAwait(false);
|
||||
var currentScope = AuthorityScopeFromTransform(normalized);
|
||||
if (currentScope is not null && currentScope != previousScope) await SendNpcAuthorityForClientAsync(client, currentScope.Value, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task HandlePlayerStateAsync(ClientSession client, JsonObject packet, CancellationToken cancellationToken)
|
||||
{
|
||||
if (client.ProtocolVersion < ProtocolConstants.ProtocolVersion) { Reject(client, "playerState requires Protocol V2", false); return; }
|
||||
var normalized = ProtocolValidation.NormalizePlayerState(packet);
|
||||
if (normalized is null) { Reject(client, "Malformed playerState"); return; }
|
||||
normalized["playerId"] = client.PlayerId;
|
||||
normalized["serverTime"] = JsonHelpers.UnixTime();
|
||||
var durable = new[] { "equippedItems", "appearance", "characterName" };
|
||||
lock (_gate)
|
||||
{
|
||||
if (durable.Any(normalized.ContainsKey))
|
||||
{
|
||||
var cached = _lastPlayerStateByPlayerId.TryGetValue(client.PlayerId, out var existing) ? JsonHelpers.CloneObject(existing) : new JsonObject();
|
||||
cached["type"] = "playerState"; cached["playerId"] = client.PlayerId; cached["serverTime"] = normalized["serverTime"]?.DeepClone();
|
||||
foreach (var field in durable) if (normalized.ContainsKey(field)) cached[field] = normalized[field]?.DeepClone();
|
||||
cached.Remove("actionEvents");
|
||||
_lastPlayerStateByPlayerId[client.PlayerId] = cached;
|
||||
}
|
||||
_stats["playerStatePacketsReceived"]++;
|
||||
}
|
||||
await BroadcastPlayerStateAsync(client, normalized, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task HandleWorldStateAsync(ClientSession client, JsonObject packet, CancellationToken cancellationToken)
|
||||
{
|
||||
lock (_gate) if (_worldStateHostPlayerId != client.PlayerId) { RejectLocked(client, "worldState from non-authority client", false); return; }
|
||||
var normalized = ProtocolValidation.NormalizeWorldState(packet);
|
||||
if (normalized is null) { Reject(client, "Malformed worldState"); return; }
|
||||
normalized["playerId"] = client.PlayerId; normalized["serverTime"] = JsonHelpers.UnixTime();
|
||||
Increment("worldStatePacketsReceived");
|
||||
await BroadcastWorldStateAsync(client, normalized, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task HandleNpcStateAsync(ClientSession client, JsonObject packet, CancellationToken cancellationToken)
|
||||
{
|
||||
var normalized = ProtocolValidation.NormalizeNpcState(packet);
|
||||
if (normalized is null) { Reject(client, "Malformed npcState"); return; }
|
||||
if (client.ProtocolVersion >= ProtocolConstants.ProtocolVersion)
|
||||
{
|
||||
var scope = AuthorityScopeFromPacket(normalized);
|
||||
if (scope is null || !JsonHelpers.TryUInt32(normalized["authorityEpoch"], 1, uint.MaxValue, out var epoch))
|
||||
{
|
||||
Increment("npcAuthorityRejects"); Reject(client, "Protocol V2 npcState missing valid authority scope/epoch"); return;
|
||||
}
|
||||
lock (_gate)
|
||||
{
|
||||
if (!_npcAuthority.Authorize(client.PlayerId, scope.Value, epoch)) { _stats["npcAuthorityRejects"]++; RejectLocked(client, "Stale or unauthorized npcState authority epoch"); return; }
|
||||
}
|
||||
var npcs = (JsonArray)normalized["npcs"]!;
|
||||
foreach (var node in npcs)
|
||||
{
|
||||
var npc = (JsonObject)node!;
|
||||
if (JsonHelpers.String(npc["cellId"]) != scope.Value.CellId || (JsonHelpers.String(npc["worldspaceId"]) ?? string.Empty) != scope.Value.WorldspaceId)
|
||||
{
|
||||
Increment("npcAuthorityRejects"); Reject(client, "npcState contains NPCs outside declared authority scope"); return;
|
||||
}
|
||||
}
|
||||
normalized["authorityCellId"] = scope.Value.CellId; normalized["authorityWorldspaceId"] = scope.Value.WorldspaceId;
|
||||
lock (_gate) _lastNpcStateByScope[scope.Value] = JsonHelpers.CloneObject(normalized);
|
||||
}
|
||||
else
|
||||
{
|
||||
lock (_gate) if (_worldStateHostPlayerId != client.PlayerId) { RejectLocked(client, "Legacy npcState from non-authority client", false); return; }
|
||||
lock (_gate) _lastLegacyNpcState = JsonHelpers.CloneObject(normalized);
|
||||
}
|
||||
normalized["playerId"] = client.PlayerId; normalized["serverTime"] = JsonHelpers.UnixTime(); normalized["fullReplace"] = true;
|
||||
Increment("npcStatePacketsReceived");
|
||||
await BroadcastNpcStateAsync(client, normalized, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task HandleCombatHitAsync(ClientSession client, JsonObject packet, CancellationToken cancellationToken)
|
||||
{
|
||||
var normalized = ProtocolValidation.NormalizeCombatHit(packet);
|
||||
if (normalized is null) { Reject(client, "Malformed combatHit"); return; }
|
||||
JsonHelpers.TryUInt32(normalized["sequence"], 1, uint.MaxValue, out var sequence);
|
||||
if (sequence <= client.LastCombatSequence) { Reject(client, "Duplicate or out-of-order combat sequence", false); return; }
|
||||
client.LastCombatSequence = sequence;
|
||||
normalized["playerId"] = client.PlayerId; normalized["serverTime"] = JsonHelpers.UnixTime();
|
||||
Increment("combatHitsReceived");
|
||||
await RouteCombatHitAsync(client, normalized, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task<bool> AllowPacketAsync(ClientSession client)
|
||||
{
|
||||
var now = MonotonicClock.Now;
|
||||
if (now - client.RateWindowStart >= 1.0)
|
||||
{
|
||||
if (client.RateWindowCount <= MaxPacketsPerSecond) client.RateViolations = Math.Max(0, client.RateViolations - 1);
|
||||
client.RateWindowStart = now; client.RateWindowCount = 0; client.RateWindowBlocked = false;
|
||||
}
|
||||
client.RateWindowCount++;
|
||||
if (client.RateWindowCount <= MaxPacketsPerSecond) return true;
|
||||
Increment("rateLimitedPackets");
|
||||
if (!client.RateWindowBlocked)
|
||||
{
|
||||
client.RateWindowBlocked = true; client.RateViolations++;
|
||||
Log($"Packet-rate limit exceeded by player {client.PlayerId} ({client.RateViolations}/3 windows)", "warning");
|
||||
}
|
||||
if (client.RateViolations >= 3) await EndSessionAsync(client, "rate_limited", "Sustained packet-rate limit exceeded.").ConfigureAwait(false);
|
||||
return false;
|
||||
}
|
||||
|
||||
private bool AllowConnectAttempt(string ip)
|
||||
{
|
||||
var now = MonotonicClock.Now;
|
||||
var cutoff = now - ConnectAttemptWindowSeconds;
|
||||
lock (_gate)
|
||||
{
|
||||
if (!_connectAttempts.TryGetValue(ip, out var queue)) _connectAttempts[ip] = queue = new Queue<double>();
|
||||
while (queue.Count > 0 && queue.Peek() < cutoff) queue.Dequeue();
|
||||
queue.Enqueue(now);
|
||||
return queue.Count <= MaxConnectAttempts;
|
||||
}
|
||||
}
|
||||
|
||||
private async Task SendPositionCorrectionAsync(ClientSession client, string reason, CancellationToken cancellationToken)
|
||||
{
|
||||
var previous = client.TransformAnchor().Transform;
|
||||
if (previous is null) return;
|
||||
var packet = new JsonObject
|
||||
{
|
||||
["type"] = "positionCorrection", ["reason"] = reason[..Math.Min(reason.Length, 160)],
|
||||
["x"] = previous["x"]?.DeepClone(), ["y"] = previous["y"]?.DeepClone(), ["z"] = previous["z"]?.DeepClone(),
|
||||
["angleZ"] = previous["angleZ"]?.DeepClone(), ["cellId"] = previous["cellId"]?.DeepClone(),
|
||||
["worldspaceId"] = previous["worldspaceId"]?.DeepClone(), ["serverTime"] = JsonHelpers.UnixTime()
|
||||
};
|
||||
if (await SendPacketAsync(client, packet, false, cancellationToken).ConfigureAwait(false)) Increment("movementCorrectionsSent");
|
||||
else await DisconnectClientAsync(client).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task SendExistingTransformsAsync(ClientSession target, CancellationToken cancellationToken)
|
||||
{
|
||||
var targetTransform = target.TransformAnchor().Transform;
|
||||
ClientSession[] peers;
|
||||
lock (_gate) peers = _clients.Values.Where(x => x.GameplayActive && x.Connection.ConnectionKey != target.Connection.ConnectionKey && x.LastTransform is not null).ToArray();
|
||||
var sent = 0;
|
||||
foreach (var peer in peers)
|
||||
{
|
||||
var transform = peer.TransformAnchor().Transform;
|
||||
if (!ProtocolValidation.StatesShareInterest(transform, targetTransform)) continue;
|
||||
if (transform is null) continue;
|
||||
transform["serverTime"] = JsonHelpers.UnixTime();
|
||||
if (!await SendPacketAsync(target, transform, true, cancellationToken).ConfigureAwait(false)) break;
|
||||
sent++;
|
||||
}
|
||||
Add("transformPacketsBroadcast", sent);
|
||||
}
|
||||
|
||||
private async Task SendExistingPlayerStatesAsync(ClientSession target, CancellationToken cancellationToken)
|
||||
{
|
||||
if (target.ProtocolVersion < ProtocolConstants.ProtocolVersion) return;
|
||||
JsonObject[] packets;
|
||||
lock (_gate) packets = _lastPlayerStateByPlayerId.Where(x => x.Key != target.PlayerId).Select(x => JsonHelpers.CloneObject(x.Value)).ToArray();
|
||||
var sent = 0;
|
||||
foreach (var packet in packets)
|
||||
{
|
||||
packet["serverTime"] = JsonHelpers.UnixTime();
|
||||
if (!await SendPacketAsync(target, packet, true, cancellationToken).ConfigureAwait(false)) break;
|
||||
sent++;
|
||||
}
|
||||
Add("playerStatePacketsBroadcast", sent);
|
||||
}
|
||||
|
||||
private async Task BroadcastTransformAsync(ClientSession sender, JsonObject packet, CancellationToken cancellationToken)
|
||||
{
|
||||
ClientSession[] recipients;
|
||||
lock (_gate) recipients = _clients.Values.Where(x => x.GameplayActive && x.Connection.ConnectionKey != sender.Connection.ConnectionKey).ToArray();
|
||||
var sent = 0; var filtered = 0;
|
||||
foreach (var recipient in recipients)
|
||||
{
|
||||
if (!ProtocolValidation.StatesShareInterest(packet, recipient.TransformAnchor().Transform)) { filtered++; continue; }
|
||||
if (await SendPacketAsync(recipient, packet, true, cancellationToken).ConfigureAwait(false)) sent++;
|
||||
else await DisconnectClientAsync(recipient).ConfigureAwait(false);
|
||||
}
|
||||
Add("transformPacketsBroadcast", sent); Add("transformPacketsInterestFiltered", filtered);
|
||||
}
|
||||
|
||||
private async Task BroadcastPlayerStateAsync(ClientSession sender, JsonObject packet, CancellationToken cancellationToken)
|
||||
{
|
||||
ClientSession[] recipients;
|
||||
lock (_gate) recipients = _clients.Values.Where(x => x.GameplayActive && x.Connection.ConnectionKey != sender.Connection.ConnectionKey && x.ProtocolVersion >= ProtocolConstants.ProtocolVersion).ToArray();
|
||||
var durable = new[] { "equippedItems", "appearance", "characterName" };
|
||||
var senderTransform = sender.TransformAnchor().Transform;
|
||||
var senderScopeKnown = ProtocolValidation.ScopeFromState(senderTransform) is not null;
|
||||
var sent = 0;
|
||||
foreach (var recipient in recipients)
|
||||
{
|
||||
var relay = JsonHelpers.CloneObject(packet);
|
||||
if (relay.ContainsKey("actionEvents"))
|
||||
{
|
||||
var targetTransform = recipient.TransformAnchor().Transform;
|
||||
var targetScopeKnown = ProtocolValidation.ScopeFromState(targetTransform) is not null;
|
||||
if (!senderScopeKnown || !targetScopeKnown || !ProtocolValidation.StatesShareInterest(senderTransform, targetTransform)) relay.Remove("actionEvents");
|
||||
}
|
||||
if (!relay.ContainsKey("actionEvents") && !durable.Any(relay.ContainsKey)) continue;
|
||||
if (await SendPacketAsync(recipient, relay, true, cancellationToken).ConfigureAwait(false)) sent++;
|
||||
else await DisconnectClientAsync(recipient).ConfigureAwait(false);
|
||||
}
|
||||
Add("playerStatePacketsBroadcast", sent);
|
||||
}
|
||||
|
||||
private async Task BroadcastWorldStateAsync(ClientSession sender, JsonObject packet, CancellationToken cancellationToken)
|
||||
{
|
||||
var sent = await BroadcastAsync(packet, sender, false, cancellationToken).ConfigureAwait(false);
|
||||
Add("worldStatePacketsBroadcast", sent);
|
||||
}
|
||||
|
||||
private JsonObject NpcPacketForRecipient(JsonObject packet, ClientSession recipient)
|
||||
{
|
||||
var target = recipient.TransformAnchor().Transform;
|
||||
if (target is null) return JsonHelpers.CloneObject(packet);
|
||||
var clean = JsonHelpers.CloneObject(packet);
|
||||
var output = new JsonArray();
|
||||
if (packet["npcs"] is JsonArray npcs)
|
||||
foreach (var node in npcs) if (node is JsonObject npc && ProtocolValidation.StatesShareInterest(npc, target)) output.Add(npc.DeepClone());
|
||||
clean["npcs"] = output;
|
||||
return clean;
|
||||
}
|
||||
|
||||
private async Task BroadcastNpcStateAsync(ClientSession sender, JsonObject packet, CancellationToken cancellationToken)
|
||||
{
|
||||
ClientSession[] recipients;
|
||||
lock (_gate) recipients = _clients.Values.Where(x => x.GameplayActive && x.Connection.ConnectionKey != sender.Connection.ConnectionKey).ToArray();
|
||||
var sent = 0;
|
||||
foreach (var recipient in recipients)
|
||||
{
|
||||
if (await SendPacketAsync(recipient, NpcPacketForRecipient(packet, recipient), true, cancellationToken).ConfigureAwait(false)) sent++;
|
||||
else await DisconnectClientAsync(recipient).ConfigureAwait(false);
|
||||
}
|
||||
Add("npcStatePacketsBroadcast", sent);
|
||||
}
|
||||
|
||||
private async Task SendExistingNpcStateAsync(ClientSession client, CancellationToken cancellationToken)
|
||||
{
|
||||
JsonObject? snapshot;
|
||||
if (client.ProtocolVersion >= ProtocolConstants.ProtocolVersion)
|
||||
{
|
||||
var scope = AuthorityScopeFromTransform(client.TransformAnchor().Transform);
|
||||
lock (_gate) snapshot = scope is not null && _lastNpcStateByScope.TryGetValue(scope.Value, out var stored) ? JsonHelpers.CloneObject(stored) : null;
|
||||
}
|
||||
else lock (_gate) snapshot = _lastLegacyNpcState is null ? null : JsonHelpers.CloneObject(_lastLegacyNpcState);
|
||||
if (snapshot is null || (JsonHelpers.TryUInt32(snapshot["playerId"], 0, uint.MaxValue, out var owner) && owner == client.PlayerId)) return;
|
||||
var scoped = NpcPacketForRecipient(snapshot, client); scoped["serverTime"] = JsonHelpers.UnixTime();
|
||||
if (await SendPacketAsync(client, scoped, true, cancellationToken).ConfigureAwait(false)) Increment("npcStatePacketsBroadcast");
|
||||
}
|
||||
|
||||
private async Task RouteCombatHitAsync(ClientSession sender, JsonObject packet, CancellationToken cancellationToken)
|
||||
{
|
||||
JsonHelpers.TryUInt32(packet["targetPlayerId"], 1, uint.MaxValue, out var targetId);
|
||||
if (targetId == sender.PlayerId) { Reject(sender, "Self-targeted combatHit", false); return; }
|
||||
ClientSession? recipient;
|
||||
lock (_gate) recipient = _clients.Values.FirstOrDefault(x => x.GameplayActive && x.PlayerId == targetId);
|
||||
if (recipient is null) { Reject(sender, $"Combat target {targetId} is not connected", false); return; }
|
||||
if (!ProtocolValidation.StatesShareInterest(sender.TransformAnchor().Transform, recipient.TransformAnchor().Transform)) { Reject(sender, $"Combat target {targetId} is outside interest scope", true); return; }
|
||||
if (await SendPacketAsync(recipient, packet, false, cancellationToken).ConfigureAwait(false)) Increment("combatHitsRouted");
|
||||
else await DisconnectClientAsync(recipient).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task ReconcileNpcAuthorityAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
IReadOnlyList<AuthorityChange> changes;
|
||||
lock (_gate)
|
||||
{
|
||||
var players = _clients.Values.Where(x => x.GameplayActive && x.ProtocolVersion >= ProtocolConstants.ProtocolVersion)
|
||||
.Select(x => (x.PlayerId, Scope: AuthorityScopeFromTransform(x.TransformAnchor().Transform)))
|
||||
.Where(x => x.Scope is not null).Select(x => (x.PlayerId, x.Scope!.Value));
|
||||
changes = _npcAuthority.Reconcile(players);
|
||||
foreach (var change in changes) _lastNpcStateByScope.Remove(change.Scope);
|
||||
}
|
||||
foreach (var change in changes)
|
||||
{
|
||||
var packet = AuthorityPacket(change.PlayerId, change.Epoch, change.Scope);
|
||||
await BroadcastAsync(packet, null, true, cancellationToken).ConfigureAwait(false);
|
||||
Increment("npcAuthorityChanges");
|
||||
Log($"NPC authority scope {change.Scope.CellId}/{(string.IsNullOrEmpty(change.Scope.WorldspaceId) ? "<interior>" : change.Scope.WorldspaceId)}: {change.PreviousPlayerId} -> {change.PlayerId}, epoch {change.Epoch}");
|
||||
}
|
||||
}
|
||||
|
||||
private async Task SendNpcAuthorityForClientAsync(ClientSession client, ScopeKey scope, CancellationToken cancellationToken)
|
||||
{
|
||||
if (client.ProtocolVersion < ProtocolConstants.ProtocolVersion) return;
|
||||
AuthorityAssignment? assignment;
|
||||
lock (_gate) assignment = _npcAuthority.Get(scope);
|
||||
if (assignment is null) return;
|
||||
if (!await SendPacketAsync(client, AuthorityPacket(assignment.Value.PlayerId, assignment.Value.Epoch, scope), false, cancellationToken).ConfigureAwait(false)) await DisconnectClientAsync(client).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private static JsonObject AuthorityPacket(uint playerId, uint epoch, ScopeKey scope) => new()
|
||||
{
|
||||
["type"] = "npcAuthority", ["authorityPlayerId"] = playerId, ["authorityEpoch"] = epoch,
|
||||
["authorityCellId"] = scope.CellId, ["authorityWorldspaceId"] = scope.WorldspaceId, ["serverTime"] = JsonHelpers.UnixTime()
|
||||
};
|
||||
|
||||
private static ScopeKey? AuthorityScopeFromTransform(JsonObject? transform)
|
||||
{
|
||||
if (transform is null) return null;
|
||||
var cell = JsonHelpers.String(transform["cellId"]); var world = JsonHelpers.String(transform["worldspaceId"]) ?? string.Empty;
|
||||
return cell is null || !JsonHelpers.IsHexFormId(cell, false, false) || !JsonHelpers.IsHexFormId(world, true, true)
|
||||
? null : new ScopeKey(JsonHelpers.NormalizeFormId(cell), world.Length == 0 ? string.Empty : JsonHelpers.NormalizeFormId(world));
|
||||
}
|
||||
|
||||
private static ScopeKey? AuthorityScopeFromPacket(JsonObject packet)
|
||||
{
|
||||
var cell = JsonHelpers.String(packet["authorityCellId"]); var world = JsonHelpers.String(packet["authorityWorldspaceId"]) ?? string.Empty;
|
||||
return cell is null || !JsonHelpers.IsHexFormId(cell, false, false) || !JsonHelpers.IsHexFormId(world, true, true)
|
||||
? null : new ScopeKey(JsonHelpers.NormalizeFormId(cell), world.Length == 0 ? string.Empty : JsonHelpers.NormalizeFormId(world));
|
||||
}
|
||||
|
||||
private async Task<int> BroadcastAsync(JsonObject packet, ClientSession? exclude, bool v2Only, CancellationToken cancellationToken)
|
||||
{
|
||||
ClientSession[] recipients;
|
||||
lock (_gate) recipients = _clients.Values.Where(x => x.GameplayActive && (exclude is null || x.Connection.ConnectionKey != exclude.Connection.ConnectionKey) && (!v2Only || x.ProtocolVersion >= ProtocolConstants.ProtocolVersion)).ToArray();
|
||||
var sent = 0;
|
||||
foreach (var recipient in recipients)
|
||||
{
|
||||
if (await SendPacketAsync(recipient, packet, true, cancellationToken).ConfigureAwait(false)) sent++;
|
||||
else await DisconnectClientAsync(recipient).ConfigureAwait(false);
|
||||
}
|
||||
return sent;
|
||||
}
|
||||
|
||||
private async Task BroadcastWorldStateHostAsync(uint playerId, CancellationToken cancellationToken)
|
||||
{
|
||||
var sent = await BroadcastAsync(new JsonObject { ["type"] = "worldStateHost", ["worldStateHostPlayerId"] = playerId, ["serverTime"] = JsonHelpers.UnixTime() }, null, false, cancellationToken).ConfigureAwait(false);
|
||||
Add("worldStateHostPacketsBroadcast", sent);
|
||||
}
|
||||
|
||||
private async Task BroadcastDisconnectAsync(ClientSession client)
|
||||
{
|
||||
var sent = await BroadcastAsync(new JsonObject { ["type"] = "disconnect", ["playerId"] = client.PlayerId, ["serverTime"] = JsonHelpers.UnixTime() }, null, false, CancellationToken.None).ConfigureAwait(false);
|
||||
Add("disconnectPacketsBroadcast", sent);
|
||||
}
|
||||
|
||||
private async Task<bool> SendPacketAsync(ClientSession client, JsonObject packet, bool broadcast, CancellationToken cancellationToken)
|
||||
{
|
||||
EncodedPacket encoded;
|
||||
try { encoded = PacketCodec.Encode(packet); }
|
||||
catch (PacketCodecException) { return false; }
|
||||
var result = await client.Connection.SendAsync(encoded, cancellationToken).ConfigureAwait(false);
|
||||
var success = result == SendOutcome.Sent || (encoded.Delivery == Delivery.UnreliableSequenced && result is SendOutcome.Dropped or SendOutcome.Backpressure);
|
||||
if (!success) return false;
|
||||
client.RecordSent(broadcast);
|
||||
lock (_gate) { _stats["packetsSent"]++; if (broadcast) _stats["packetsBroadcast"]++; }
|
||||
return true;
|
||||
}
|
||||
|
||||
private async Task SendDirectSessionEndedAsync(IGameConnection connection, string code, string reason, CancellationToken cancellationToken)
|
||||
{
|
||||
var packet = new JsonObject { ["type"] = "sessionEnded", ["code"] = code, ["reason"] = reason ?? string.Empty, ["serverTime"] = JsonHelpers.UnixTime() };
|
||||
try
|
||||
{
|
||||
var result = await connection.SendAsync(PacketCodec.Encode(packet), cancellationToken).ConfigureAwait(false);
|
||||
if (result == SendOutcome.Sent) lock (_gate) { _stats["sessionEndedPacketsSent"]++; _stats["packetsSent"]++; }
|
||||
}
|
||||
catch { }
|
||||
}
|
||||
|
||||
private async Task EndSessionAsync(ClientSession client, string code, string reason)
|
||||
{
|
||||
var packet = new JsonObject { ["type"] = "sessionEnded", ["code"] = code, ["reason"] = reason ?? string.Empty, ["serverTime"] = JsonHelpers.UnixTime() };
|
||||
if (await SendPacketAsync(client, packet, false, CancellationToken.None).ConfigureAwait(false)) Increment("sessionEndedPacketsSent");
|
||||
await DisconnectClientAsync(client).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task DisconnectClientAsync(ClientSession client)
|
||||
{
|
||||
bool removed; bool wasActive; bool wasHost;
|
||||
lock (_gate)
|
||||
{
|
||||
wasActive = client.GameplayActive; wasHost = wasActive && _worldStateHostPlayerId == client.PlayerId;
|
||||
removed = _clients.Remove(client.Connection.ConnectionKey);
|
||||
if (removed) _lastPlayerStateByPlayerId.Remove(client.PlayerId);
|
||||
if (removed && wasActive) _stats["clientsDisconnected"]++;
|
||||
}
|
||||
if (!removed) return;
|
||||
await client.Connection.DisconnectAsync(0, "Commonwealth Online disconnect");
|
||||
if (!wasActive) { Log($"Closed pending/probe connection: {client.Label}", "debug"); return; }
|
||||
Log($"Client disconnected: {client.Label} (player {client.PlayerId})");
|
||||
await BroadcastDisconnectAsync(client).ConfigureAwait(false);
|
||||
await ReconcileNpcAuthorityAsync(CancellationToken.None).ConfigureAwait(false);
|
||||
if (wasHost) await ReassignWorldStateHostAsync().ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task ReassignWorldStateHostAsync()
|
||||
{
|
||||
uint? newHost;
|
||||
lock (_gate)
|
||||
{
|
||||
var active = _clients.Values.Where(x => x.GameplayActive).ToArray();
|
||||
if (active.Length == 0) { _worldStateHostPlayerId = null; _lastLegacyNpcState = null; return; }
|
||||
newHost = active.Min(x => x.PlayerId); _worldStateHostPlayerId = newHost; _lastLegacyNpcState = null;
|
||||
}
|
||||
await BroadcastWorldStateHostAsync(newHost!.Value, CancellationToken.None).ConfigureAwait(false);
|
||||
Log($"Reassigned world-state host to player {newHost.Value}.");
|
||||
}
|
||||
|
||||
private void Reject(ClientSession client, string reason, bool warning = true)
|
||||
{
|
||||
lock (_gate) RejectLocked(client, reason, warning);
|
||||
}
|
||||
|
||||
private void RejectLocked(ClientSession client, string reason, bool warning = true)
|
||||
{
|
||||
_stats["packetsRejected"]++;
|
||||
Log($"Rejected packet from {client.Label} (player {client.PlayerId}): {reason}", warning ? "warning" : "debug");
|
||||
}
|
||||
|
||||
private ClientSession? FindByConnection(IGameConnection connection)
|
||||
{
|
||||
lock (_gate) return _clients.TryGetValue(connection.ConnectionKey, out var client) ? client : null;
|
||||
}
|
||||
|
||||
private void Increment(string name) { lock (_gate) _stats[name]++; }
|
||||
private void Add(string name, long amount) { lock (_gate) _stats[name] += amount; }
|
||||
|
||||
private async Task MaintenanceLoopAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
while (!cancellationToken.IsCancellationRequested)
|
||||
{
|
||||
try { await Task.Delay(500, cancellationToken).ConfigureAwait(false); } catch (OperationCanceledException) { break; }
|
||||
ClientSession[] snapshot;
|
||||
lock (_gate) snapshot = _clients.Values.ToArray();
|
||||
var now = JsonHelpers.UnixTime();
|
||||
foreach (var client in snapshot)
|
||||
{
|
||||
if (!client.GameplayActive && now - client.ConnectedAt > ClientHandshakeTimeoutSeconds)
|
||||
{
|
||||
Log($"Handshake timeout: {client.Label}", "warning");
|
||||
await DisconnectClientAsync(client).ConfigureAwait(false);
|
||||
}
|
||||
else if (client.GameplayActive && client.LastPacketAt is { } last && now - last > ClientIdleTimeoutSeconds)
|
||||
{
|
||||
Log($"Idle timeout: player {client.PlayerId}", "warning");
|
||||
await DisconnectClientAsync(client).ConfigureAwait(false);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
public JsonObject GetCoreStats()
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
var active = _clients.Values.Count(x => x.GameplayActive);
|
||||
var stats = new JsonObject();
|
||||
foreach (var pair in _stats) stats[pair.Key] = pair.Value;
|
||||
stats["host"] = _options.Host; stats["port"] = _options.Port; stats["serverName"] = _options.ServerName;
|
||||
stats["serverDescription"] = _options.ServerDescription; stats["maxPlayers"] = _options.MaxPlayers; stats["isRunning"] = true;
|
||||
stats["startedAt"] = _startedAt; stats["uptimeSeconds"] = JsonHelpers.UnixTime() - _startedAt; stats["connectedClients"] = active;
|
||||
stats["pendingConnections"] = _clients.Count - active; stats["nextPlayerId"] = _nextPlayerId; stats["protocolVersion"] = ProtocolConstants.ProtocolVersion;
|
||||
stats["npcAuthorityScopes"] = _npcAuthority.Assignments.Count;
|
||||
return stats;
|
||||
}
|
||||
}
|
||||
|
||||
public JsonObject GetAdminStats()
|
||||
{
|
||||
var core = GetCoreStats();
|
||||
return new JsonObject
|
||||
{
|
||||
["is_running"] = true, ["host"] = _options.Host, ["port"] = _options.Port.ToString(), ["server_name"] = _options.ServerName,
|
||||
["server_description"] = _options.ServerDescription, ["uptime_seconds"] = core["uptimeSeconds"]?.DeepClone(),
|
||||
["connected_clients"] = core["connectedClients"]?.DeepClone(), ["packets_received"] = core["packetsReceived"]?.DeepClone(),
|
||||
["packets_sent"] = core["packetsSent"]?.DeepClone(), ["transform_packets_received"] = core["transformPacketsReceived"]?.DeepClone(),
|
||||
["transform_packets_broadcast"] = core["transformPacketsBroadcast"]?.DeepClone(), ["world_state_packets_received"] = core["worldStatePacketsReceived"]?.DeepClone(),
|
||||
["world_state_packets_broadcast"] = core["worldStatePacketsBroadcast"]?.DeepClone()
|
||||
};
|
||||
}
|
||||
|
||||
public JsonArray GetClientSnapshots()
|
||||
{
|
||||
lock (_gate) return new JsonArray(_clients.Values.Where(x => x.GameplayActive).Select(x => (JsonNode)x.Snapshot()).ToArray());
|
||||
}
|
||||
|
||||
public JsonArray GetAdminClients()
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
return new JsonArray(_clients.Values.Where(x => x.GameplayActive).Select(client =>
|
||||
{
|
||||
var snapshot = client.Snapshot();
|
||||
var endpoint = client.Label;
|
||||
return (JsonNode)new JsonObject
|
||||
{
|
||||
["player_id"] = client.PlayerId, ["address"] = endpoint, ["label"] = endpoint, ["connected_at"] = client.ConnectedAt,
|
||||
["packets_sent"] = client.PacketsSent, ["packets_received"] = client.PacketsReceived, ["last_transform"] = snapshot["lastTransform"]?.DeepClone()
|
||||
};
|
||||
}).ToArray());
|
||||
}
|
||||
}
|
||||
|
||||
public IReadOnlyList<BanEntry> ListBans() => _banStore.List();
|
||||
|
||||
public async Task<(bool Ok, string Message, JsonObject? Data)> KickAsync(uint playerId, string reason)
|
||||
{
|
||||
ClientSession? client; lock (_gate) client = _clients.Values.FirstOrDefault(x => x.GameplayActive && x.PlayerId == playerId);
|
||||
if (client is null) return (false, $"No connected player with id {playerId}", null);
|
||||
var data = new JsonObject { ["playerId"] = playerId, ["ip"] = client.RemoteEndpoint.Address.ToString(), ["code"] = "kicked", ["reason"] = reason ?? string.Empty };
|
||||
await EndSessionAsync(client, "kicked", reason ?? string.Empty).ConfigureAwait(false);
|
||||
return (true, $"Kicked player {playerId}.", data);
|
||||
}
|
||||
|
||||
public async Task<(bool Ok, string Message, JsonObject? Data)> BanPlayerAsync(uint playerId, string reason)
|
||||
{
|
||||
ClientSession? client; lock (_gate) client = _clients.Values.FirstOrDefault(x => x.GameplayActive && x.PlayerId == playerId);
|
||||
return client is null ? (false, $"No connected player with id {playerId}", null) : await BanIpAsync(client.RemoteEndpoint.Address.ToString(), reason).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
public async Task<(bool Ok, string Message, JsonObject? Data)> BanIpAsync(string ip, string reason)
|
||||
{
|
||||
BanEntry entry;
|
||||
try { entry = _banStore.Ban(ip, reason ?? string.Empty); } catch (ArgumentException ex) { return (false, ex.Message, null); }
|
||||
ClientSession[] sessions; lock (_gate) sessions = _clients.Values.Where(x => x.RemoteEndpoint.Address.ToString() == entry.Ip).ToArray();
|
||||
foreach (var session in sessions) await EndSessionAsync(session, "banned", entry.Reason).ConfigureAwait(false);
|
||||
var data = new JsonObject { ["ip"] = entry.Ip, ["reason"] = entry.Reason, ["bannedAt"] = entry.BannedAt, ["sessionsEnded"] = sessions.Length };
|
||||
Log($"Banned IP {entry.Ip}{(string.IsNullOrEmpty(entry.Reason) ? string.Empty : $" (reason: {entry.Reason})")}");
|
||||
return (true, $"Banned IP {entry.Ip}.", data);
|
||||
}
|
||||
|
||||
public (bool Ok, string Message) Unban(string ip)
|
||||
{
|
||||
var removed = _banStore.Unban(ip);
|
||||
if (removed) Log($"Unbanned IP {ip}");
|
||||
return removed ? (true, $"Unbanned IP {ip}.") : (false, $"IP {ip} is not banned.");
|
||||
}
|
||||
|
||||
public async Task<bool> SetServerTimeAsync(string hhmm)
|
||||
{
|
||||
if (WorldStatePresets.HhmmToGameHour(hhmm) is null) return false;
|
||||
var normalized = hhmm.Trim().PadLeft(4, '0');
|
||||
lock (_gate) _serverWorldState["timeHHmm"] = normalized;
|
||||
await BroadcastServerWorldStateAsync().ConfigureAwait(false);
|
||||
return true;
|
||||
}
|
||||
|
||||
public async Task<bool> SetServerWeatherAsync(string value)
|
||||
{
|
||||
string normalized;
|
||||
try { normalized = WorldStatePresets.NormalizeWeatherConsoleArg(value); } catch { return false; }
|
||||
lock (_gate) { _serverWorldState["weatherConsoleArg"] = normalized; _serverWorldState["weatherFormId"] = WorldStatePresets.RelayWeatherFormId(normalized); }
|
||||
await BroadcastServerWorldStateAsync().ConfigureAwait(false);
|
||||
return true;
|
||||
}
|
||||
|
||||
private async Task BroadcastServerWorldStateAsync()
|
||||
{
|
||||
Dictionary<string, string> snapshot; lock (_gate) snapshot = new Dictionary<string, string>(_serverWorldState, StringComparer.Ordinal);
|
||||
var packets = new List<JsonObject>();
|
||||
if (snapshot.TryGetValue("timeHHmm", out var time)) packets.Add(new JsonObject { ["type"] = "serverWorldState", ["timeHHmm"] = time, ["serverTime"] = JsonHelpers.UnixTime() });
|
||||
if (snapshot.TryGetValue("weatherConsoleArg", out var weather))
|
||||
{
|
||||
var packet = new JsonObject { ["type"] = "serverWorldState", ["weatherConsoleArg"] = weather, ["serverTime"] = JsonHelpers.UnixTime() };
|
||||
if (snapshot.TryGetValue("weatherFormId", out var form)) packet["weatherFormId"] = form;
|
||||
packets.Add(packet);
|
||||
}
|
||||
var sent = 0;
|
||||
foreach (var packet in packets) sent += await BroadcastAsync(packet, null, false, CancellationToken.None).ConfigureAwait(false);
|
||||
Add("serverWorldStatePacketsBroadcast", sent);
|
||||
}
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
_shutdown.Cancel();
|
||||
try { await _maintenanceTask.ConfigureAwait(false); } catch { }
|
||||
ClientSession[] clients; lock (_gate) { clients = _clients.Values.ToArray(); _clients.Clear(); }
|
||||
foreach (var client in clients) await client.Connection.DisposeAsync();
|
||||
_shutdown.Dispose();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,15 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
<PropertyGroup>
|
||||
<OutputType>Exe</OutputType>
|
||||
<TargetFramework>net8.0</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<LangVersion>latest</LangVersion>
|
||||
<AllowUnsafeBlocks>true</AllowUnsafeBlocks>
|
||||
<AssemblyName>CommonwealthOnline.Server</AssemblyName>
|
||||
<RootNamespace>CommonwealthOnline.Server</RootNamespace>
|
||||
</PropertyGroup>
|
||||
<ItemGroup>
|
||||
<Compile Remove="tests/**/*.cs" />
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
@@ -0,0 +1,135 @@
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
|
||||
namespace CommonwealthOnline.Server;
|
||||
|
||||
internal sealed class ServerOptions
|
||||
{
|
||||
public string Host { get; set; } = "0.0.0.0";
|
||||
public int Port { get; set; } = 7777;
|
||||
public string ServerName { get; set; } = "Commonwealth Online Server";
|
||||
public string ServerDescription { get; set; } = string.Empty;
|
||||
public int MaxPlayers { get; set; } = 16;
|
||||
public string LogVerbosity { get; set; } = "info";
|
||||
public int AdminPort { get; set; } = 7779;
|
||||
public bool EnableGnsTransport { get; set; }
|
||||
public string? GnsBridgePath { get; set; }
|
||||
public string ConfigPath { get; set; } = Path.GetFullPath("commonwealth-server.json");
|
||||
|
||||
public string BaseDirectory => Path.GetDirectoryName(ConfigPath)!;
|
||||
public string BansPath => Path.Combine(BaseDirectory, "bans.json");
|
||||
public string AdminTokenPath => Path.Combine(BaseDirectory, ".admin-token");
|
||||
|
||||
public static ServerOptions Load(string path)
|
||||
{
|
||||
var fullPath = Path.GetFullPath(path);
|
||||
if (!File.Exists(fullPath)) throw new FileNotFoundException("Config file not found", fullPath);
|
||||
var root = JsonNode.Parse(File.ReadAllBytes(fullPath)) as JsonObject ?? throw new InvalidDataException("Config file must contain a JSON object at root level.");
|
||||
var options = new ServerOptions { ConfigPath = fullPath };
|
||||
options.Host = JsonHelpers.String(root["host"]) ?? options.Host;
|
||||
options.Port = ReadInt(root["port"], options.Port, "port");
|
||||
options.ServerName = JsonHelpers.String(root["server_name"] ?? root["serverName"]) ?? options.ServerName;
|
||||
options.ServerDescription = JsonHelpers.String(root["server_description"] ?? root["serverDescription"]) ?? options.ServerDescription;
|
||||
options.MaxPlayers = ReadInt(root["max_players"] ?? root["maxPlayers"], options.MaxPlayers, "max_players");
|
||||
options.LogVerbosity = (JsonHelpers.String(root["log_verbosity"] ?? root["logVerbosity"]) ?? options.LogVerbosity).Trim().ToLowerInvariant();
|
||||
options.AdminPort = ReadInt(root["admin_port"] ?? root["adminPort"], options.AdminPort, "admin_port");
|
||||
options.EnableGnsTransport = ReadBool(root["enable_gns_transport"] ?? root["enableGnsTransport"], false, "enable_gns_transport");
|
||||
var bridge = JsonHelpers.String(root["gns_bridge_path"] ?? root["gnsBridgePath"]);
|
||||
options.GnsBridgePath = string.IsNullOrWhiteSpace(bridge) ? null : bridge.Trim();
|
||||
return options;
|
||||
}
|
||||
|
||||
public static ServerOptions CreateDefault(string path)
|
||||
{
|
||||
var options = new ServerOptions { ConfigPath = Path.GetFullPath(path) };
|
||||
options.Save();
|
||||
return options;
|
||||
}
|
||||
|
||||
public void Save()
|
||||
{
|
||||
Directory.CreateDirectory(BaseDirectory);
|
||||
var root = new JsonObject
|
||||
{
|
||||
["host"] = Host,
|
||||
["port"] = Port,
|
||||
["server_name"] = ServerName,
|
||||
["server_description"] = ServerDescription,
|
||||
["max_players"] = MaxPlayers,
|
||||
["log_verbosity"] = LogVerbosity,
|
||||
["admin_port"] = AdminPort,
|
||||
["enable_gns_transport"] = EnableGnsTransport,
|
||||
["gns_bridge_path"] = GnsBridgePath
|
||||
};
|
||||
using var stream = File.Create(ConfigPath);
|
||||
JsonSerializer.Serialize(stream, root, new JsonSerializerOptions { WriteIndented = true });
|
||||
stream.WriteByte((byte)'\n');
|
||||
}
|
||||
|
||||
public IReadOnlyList<string> Validate()
|
||||
{
|
||||
var errors = new List<string>();
|
||||
if (string.IsNullOrWhiteSpace(Host))
|
||||
errors.Add("host cannot be empty");
|
||||
else if (!TryResolveIpv4(Host, out _))
|
||||
errors.Add($"host '{Host}' is not a valid IPv4 address or resolvable hostname");
|
||||
else if (EnableGnsTransport && (!IPAddress.TryParse(Host.Trim(), out var gnsAddress) || gnsAddress.AddressFamily != AddressFamily.InterNetwork))
|
||||
errors.Add("enable_gns_transport requires host to be an explicit IPv4 bind address such as 0.0.0.0 or 127.0.0.1");
|
||||
|
||||
if (Port is < 1 or > 65535) errors.Add($"port must be 1-65535, got {Port}");
|
||||
if (AdminPort is < 1 or > 65535) errors.Add($"admin_port must be 1-65535, got {AdminPort}");
|
||||
else if (AdminPort == Port) errors.Add("admin_port must differ from the game port");
|
||||
if (string.IsNullOrEmpty(ServerName)) errors.Add("server_name cannot be empty");
|
||||
else if (ServerName.Length > 64) errors.Add($"server_name must be <= 64 characters, got {ServerName.Length}");
|
||||
if (ServerDescription.Length > 256) errors.Add($"server_description must be <= 256 characters, got {ServerDescription.Length}");
|
||||
if (MaxPlayers < 1) errors.Add($"max_players must be >= 1, got {MaxPlayers}");
|
||||
else if (MaxPlayers > 256) errors.Add($"max_players must be <= 256, got {MaxPlayers}");
|
||||
if (LogVerbosity is not ("debug" or "info" or "warning" or "error")) errors.Add($"log_verbosity must be debug/info/warning/error, got {LogVerbosity}");
|
||||
return errors;
|
||||
}
|
||||
|
||||
public static bool TryResolveIpv4(string host, out IPAddress address)
|
||||
{
|
||||
if (IPAddress.TryParse(host.Trim(), out var parsed) && parsed.AddressFamily == AddressFamily.InterNetwork)
|
||||
{
|
||||
address = parsed;
|
||||
return true;
|
||||
}
|
||||
try
|
||||
{
|
||||
address = Dns.GetHostAddresses(host.Trim()).First(x => x.AddressFamily == AddressFamily.InterNetwork);
|
||||
return true;
|
||||
}
|
||||
catch
|
||||
{
|
||||
address = IPAddress.None;
|
||||
return false;
|
||||
}
|
||||
}
|
||||
|
||||
private static int ReadInt(JsonNode? node, int defaultValue, string field)
|
||||
{
|
||||
if (node is null) return defaultValue;
|
||||
if (node is JsonValue value && value.TryGetValue<int>(out var number)) return number;
|
||||
if (node is JsonValue textValue && textValue.TryGetValue<string>(out var text) && int.TryParse(text, out number)) return number;
|
||||
throw new InvalidDataException($"Invalid numeric config field: {field}");
|
||||
}
|
||||
|
||||
private static bool ReadBool(JsonNode? node, bool defaultValue, string field)
|
||||
{
|
||||
if (node is null) return defaultValue;
|
||||
if (node is JsonValue value && value.TryGetValue<bool>(out var boolean)) return boolean;
|
||||
if (node is JsonValue intValue && intValue.TryGetValue<int>(out var number) && number is 0 or 1) return number == 1;
|
||||
if (node is JsonValue textValue && textValue.TryGetValue<string>(out var text))
|
||||
{
|
||||
switch (text.Trim().ToLowerInvariant())
|
||||
{
|
||||
case "1": case "true": case "yes": case "on": return true;
|
||||
case "0": case "false": case "no": case "off": case "": return false;
|
||||
}
|
||||
}
|
||||
throw new InvalidDataException($"{field} must be a boolean or one of true/false, yes/no, on/off, 1/0");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,317 @@
|
||||
using System.Collections.Concurrent;
|
||||
using System.Net;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
|
||||
namespace CommonwealthOnline.Server;
|
||||
|
||||
internal readonly record struct ScopeKey(string CellId, string WorldspaceId) : IComparable<ScopeKey>
|
||||
{
|
||||
public int CompareTo(ScopeKey other)
|
||||
{
|
||||
var cell = string.Compare(CellId, other.CellId, StringComparison.Ordinal);
|
||||
return cell != 0 ? cell : string.Compare(WorldspaceId, other.WorldspaceId, StringComparison.Ordinal);
|
||||
}
|
||||
}
|
||||
|
||||
internal readonly record struct StateScope(string CellId, string WorldspaceId, double X, double Y);
|
||||
internal readonly record struct AuthorityAssignment(ScopeKey Scope, uint PlayerId, uint Epoch);
|
||||
internal readonly record struct AuthorityChange(ScopeKey Scope, uint PreviousPlayerId, uint PlayerId, uint Epoch);
|
||||
|
||||
internal sealed class NpcAuthorityManager
|
||||
{
|
||||
private readonly Dictionary<ScopeKey, AuthorityAssignment> _assignments = new();
|
||||
private readonly Dictionary<ScopeKey, uint> _lastEpoch = new();
|
||||
|
||||
public void Clear()
|
||||
{
|
||||
_assignments.Clear();
|
||||
_lastEpoch.Clear();
|
||||
}
|
||||
|
||||
public AuthorityAssignment? Get(ScopeKey scope) => _assignments.TryGetValue(scope, out var value) ? value : null;
|
||||
public IReadOnlyCollection<AuthorityAssignment> Assignments => _assignments.OrderBy(x => x.Key).Select(x => x.Value).ToArray();
|
||||
|
||||
public bool Authorize(uint playerId, ScopeKey scope, uint epoch) =>
|
||||
_assignments.TryGetValue(scope, out var assignment) && assignment.PlayerId == playerId && assignment.Epoch == epoch;
|
||||
|
||||
public IReadOnlyList<AuthorityChange> Reconcile(IEnumerable<(uint PlayerId, ScopeKey Scope)> players)
|
||||
{
|
||||
var desired = players
|
||||
.Where(x => x.PlayerId > 0)
|
||||
.GroupBy(x => x.Scope)
|
||||
.ToDictionary(group => group.Key, group => group.Min(x => x.PlayerId));
|
||||
|
||||
var scopes = _assignments.Keys.Concat(desired.Keys).Distinct().OrderBy(x => x).ToArray();
|
||||
var changes = new List<AuthorityChange>();
|
||||
foreach (var scope in scopes)
|
||||
{
|
||||
var previous = _assignments.TryGetValue(scope, out var oldAssignment) ? oldAssignment.PlayerId : 0;
|
||||
var next = desired.TryGetValue(scope, out var nextPlayer) ? nextPlayer : 0;
|
||||
if (previous == next) continue;
|
||||
var epoch = _lastEpoch.TryGetValue(scope, out var last) ? checked(last + 1) : 1;
|
||||
_lastEpoch[scope] = epoch;
|
||||
if (next == 0) _assignments.Remove(scope);
|
||||
else _assignments[scope] = new AuthorityAssignment(scope, next, epoch);
|
||||
changes.Add(new AuthorityChange(scope, previous, next, epoch));
|
||||
}
|
||||
return changes;
|
||||
}
|
||||
}
|
||||
|
||||
internal sealed class ClientSession
|
||||
{
|
||||
private readonly object _gate = new();
|
||||
|
||||
public ClientSession(IGameConnection connection, uint playerId)
|
||||
{
|
||||
Connection = connection;
|
||||
PlayerId = playerId;
|
||||
ConnectedAt = JsonHelpers.UnixTime();
|
||||
RateWindowStart = MonotonicClock.Now;
|
||||
}
|
||||
|
||||
public IGameConnection Connection { get; }
|
||||
public uint PlayerId { get; }
|
||||
public IPEndPoint RemoteEndpoint => Connection.RemoteEndpoint;
|
||||
public string Label => $"{RemoteEndpoint.Address}:{RemoteEndpoint.Port}";
|
||||
public double ConnectedAt { get; }
|
||||
public double? LastPacketAt { get; private set; }
|
||||
public JsonObject? LastTransform { get; private set; }
|
||||
public double? LastTransformMonotonic { get; private set; }
|
||||
public long PacketsReceived { get; private set; }
|
||||
public long PacketsSent { get; private set; }
|
||||
public long PacketsBroadcast { get; private set; }
|
||||
public bool GameplayActive { get; private set; }
|
||||
public int ProtocolVersion { get; private set; }
|
||||
public double RateWindowStart { get; set; }
|
||||
public int RateWindowCount { get; set; }
|
||||
public int RateViolations { get; set; }
|
||||
public bool RateWindowBlocked { get; set; }
|
||||
public uint LastCombatSequence { get; set; }
|
||||
|
||||
public void RecordReceived()
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
LastPacketAt = JsonHelpers.UnixTime();
|
||||
PacketsReceived++;
|
||||
}
|
||||
}
|
||||
|
||||
public void RecordTransform(JsonObject packet, double acceptedMonotonic)
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
LastTransform = JsonHelpers.CloneObject(packet);
|
||||
LastTransformMonotonic = acceptedMonotonic;
|
||||
}
|
||||
}
|
||||
|
||||
public (JsonObject? Transform, double? Monotonic) TransformAnchor()
|
||||
{
|
||||
lock (_gate)
|
||||
return (LastTransform is null ? null : JsonHelpers.CloneObject(LastTransform), LastTransformMonotonic);
|
||||
}
|
||||
|
||||
public void RecordSent(bool broadcast)
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
PacketsSent++;
|
||||
if (broadcast) PacketsBroadcast++;
|
||||
}
|
||||
}
|
||||
|
||||
public bool Activate(int protocolVersion)
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
if (GameplayActive) return false;
|
||||
GameplayActive = true;
|
||||
ProtocolVersion = protocolVersion;
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
public JsonObject Snapshot()
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
return new JsonObject
|
||||
{
|
||||
["playerId"] = PlayerId,
|
||||
["address"] = RemoteEndpoint.Address.ToString(),
|
||||
["port"] = RemoteEndpoint.Port,
|
||||
["connectedAt"] = ConnectedAt,
|
||||
["lastPacketAt"] = LastPacketAt,
|
||||
["lastTransform"] = LastTransform?.DeepClone(),
|
||||
["packetsReceived"] = PacketsReceived,
|
||||
["packetsSent"] = PacketsSent,
|
||||
["packetsBroadcast"] = PacketsBroadcast,
|
||||
["gameplayActive"] = GameplayActive,
|
||||
["protocolVersion"] = ProtocolVersion
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
internal readonly record struct BanEntry(string Ip, string Reason, double BannedAt);
|
||||
|
||||
internal sealed class BanStore
|
||||
{
|
||||
private readonly object _gate = new();
|
||||
private readonly string _path;
|
||||
private Dictionary<string, BanEntry> _bans = new(StringComparer.Ordinal);
|
||||
|
||||
public BanStore(string path)
|
||||
{
|
||||
_path = Path.GetFullPath(path);
|
||||
Load();
|
||||
}
|
||||
|
||||
public BanEntry? GetBan(string ip)
|
||||
{
|
||||
if (!TryNormalizeIp(ip, out var normalized)) return null;
|
||||
lock (_gate) return _bans.TryGetValue(normalized, out var entry) ? entry : null;
|
||||
}
|
||||
|
||||
public IReadOnlyList<BanEntry> List()
|
||||
{
|
||||
lock (_gate) return _bans.Values.OrderBy(x => x.Ip, StringComparer.Ordinal).ToArray();
|
||||
}
|
||||
|
||||
public BanEntry Ban(string ip, string reason)
|
||||
{
|
||||
if (!TryNormalizeIp(ip, out var normalized)) throw new ArgumentException($"Invalid IP address: '{ip}'", nameof(ip));
|
||||
var entry = new BanEntry(normalized, (reason ?? string.Empty)[..Math.Min((reason ?? string.Empty).Length, 1024)], JsonHelpers.UnixTime());
|
||||
lock (_gate)
|
||||
{
|
||||
_bans[normalized] = entry;
|
||||
SaveLocked();
|
||||
}
|
||||
return entry;
|
||||
}
|
||||
|
||||
public bool Unban(string ip)
|
||||
{
|
||||
if (!TryNormalizeIp(ip, out var normalized)) return false;
|
||||
lock (_gate)
|
||||
{
|
||||
if (!_bans.Remove(normalized)) return false;
|
||||
SaveLocked();
|
||||
return true;
|
||||
}
|
||||
}
|
||||
|
||||
private void Load()
|
||||
{
|
||||
lock (_gate)
|
||||
{
|
||||
if (!File.Exists(_path)) { _bans = new(StringComparer.Ordinal); return; }
|
||||
JsonObject root;
|
||||
try
|
||||
{
|
||||
root = JsonNode.Parse(File.ReadAllBytes(_path)) as JsonObject ?? throw new InvalidDataException("root is not an object");
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or UnauthorizedAccessException or JsonException or InvalidDataException)
|
||||
{
|
||||
throw new InvalidOperationException($"Could not load ban file {_path}: {ex.Message}", ex);
|
||||
}
|
||||
if (root["banned_ips"] is not JsonArray array) throw new InvalidOperationException($"Ban file {_path} has an invalid schema.");
|
||||
var bans = new Dictionary<string, BanEntry>(StringComparer.Ordinal);
|
||||
var invalid = 0;
|
||||
foreach (var node in array)
|
||||
{
|
||||
if (node is not JsonObject item || !TryNormalizeIp(JsonHelpers.String(item["ip"]) ?? string.Empty, out var ip)) { invalid++; continue; }
|
||||
var reason = JsonHelpers.String(item["reason"]) ?? string.Empty;
|
||||
if (reason.Length > 1024) reason = reason[..1024];
|
||||
var bannedAt = JsonHelpers.TryDouble(item["bannedAt"] ?? item["banned_at"], double.MinValue, double.MaxValue, out var value) ? value : 0.0;
|
||||
bans[ip] = new BanEntry(ip, reason, bannedAt);
|
||||
}
|
||||
if (invalid > 0) throw new InvalidOperationException($"Ban file {_path} contains {invalid} invalid {(invalid == 1 ? "entry" : "entries")}.");
|
||||
_bans = bans;
|
||||
}
|
||||
}
|
||||
|
||||
private void SaveLocked()
|
||||
{
|
||||
var directory = Path.GetDirectoryName(_path)!;
|
||||
Directory.CreateDirectory(directory);
|
||||
var root = new JsonObject
|
||||
{
|
||||
["banned_ips"] = new JsonArray(_bans.Values.OrderBy(x => x.Ip, StringComparer.Ordinal).Select(entry => (JsonNode)new JsonObject
|
||||
{
|
||||
["ip"] = entry.Ip,
|
||||
["reason"] = entry.Reason,
|
||||
["bannedAt"] = entry.BannedAt
|
||||
}).ToArray())
|
||||
};
|
||||
var temp = Path.Combine(directory, $".{Path.GetFileName(_path)}.{Environment.ProcessId}.{Guid.NewGuid():N}.tmp");
|
||||
using (var stream = new FileStream(temp, FileMode.CreateNew, FileAccess.Write, FileShare.None, 4096, FileOptions.WriteThrough))
|
||||
{
|
||||
JsonSerializer.Serialize(stream, root, new JsonSerializerOptions { WriteIndented = true });
|
||||
stream.WriteByte((byte)'\n');
|
||||
stream.Flush(true);
|
||||
}
|
||||
TryRestrictPermissions(temp);
|
||||
File.Move(temp, _path, true);
|
||||
TryRestrictPermissions(_path);
|
||||
}
|
||||
|
||||
private static bool TryNormalizeIp(string value, out string normalized)
|
||||
{
|
||||
normalized = string.Empty;
|
||||
if (!IPAddress.TryParse(value.Trim(), out var address)) return false;
|
||||
normalized = address.ToString();
|
||||
return true;
|
||||
}
|
||||
|
||||
internal static void TryRestrictPermissions(string path)
|
||||
{
|
||||
if (OperatingSystem.IsWindows()) return;
|
||||
try { File.SetUnixFileMode(path, UnixFileMode.UserRead | UnixFileMode.UserWrite); } catch { }
|
||||
}
|
||||
}
|
||||
|
||||
internal static class MonotonicClock
|
||||
{
|
||||
private static readonly double Frequency = System.Diagnostics.Stopwatch.Frequency;
|
||||
public static double Now => System.Diagnostics.Stopwatch.GetTimestamp() / Frequency;
|
||||
}
|
||||
|
||||
internal static class WorldStatePresets
|
||||
{
|
||||
public static readonly IReadOnlyList<(string Label, string Value)> Weather = new (string, string)[]
|
||||
{
|
||||
("Clear", "0002b52a"), ("Cloudy", "001cc186"), ("Overcast", "001c8556"), ("Fog", "001c3473"),
|
||||
("Rain", "001ca7e4"), ("Radstorm", "001c3d5e"), ("Glowing Sea", "000f1033")
|
||||
};
|
||||
|
||||
public static readonly IReadOnlyList<(string Label, string Value)> Time = new (string, string)[]
|
||||
{
|
||||
("Midnight", "0000"), ("Dawn", "0600"), ("Morning", "0900"), ("Noon", "1200"),
|
||||
("Afternoon", "1500"), ("Evening", "1800"), ("Dusk (7 PM)", "1900"), ("Night", "2200")
|
||||
};
|
||||
|
||||
public static string NormalizeWeatherConsoleArg(string value)
|
||||
{
|
||||
var text = value.Trim();
|
||||
if (text.StartsWith("0x", StringComparison.OrdinalIgnoreCase)) text = text[2..];
|
||||
if (!uint.TryParse(text, System.Globalization.NumberStyles.AllowHexSpecifier, System.Globalization.CultureInfo.InvariantCulture, out var parsed))
|
||||
throw new ArgumentException("invalid weather form id", nameof(value));
|
||||
return parsed.ToString("x8", System.Globalization.CultureInfo.InvariantCulture);
|
||||
}
|
||||
|
||||
public static string RelayWeatherFormId(string value) => uint.Parse(value, System.Globalization.NumberStyles.AllowHexSpecifier, System.Globalization.CultureInfo.InvariantCulture).ToString("X8", System.Globalization.CultureInfo.InvariantCulture);
|
||||
|
||||
public static double? HhmmToGameHour(string hhmm)
|
||||
{
|
||||
var text = hhmm.Trim();
|
||||
if (text.Length is < 1 or > 4 || !text.All(char.IsDigit)) return null;
|
||||
text = text.PadLeft(4, '0');
|
||||
var hours = int.Parse(text[..2]);
|
||||
var minutes = int.Parse(text[2..]);
|
||||
return hours > 23 || minutes > 59 ? null : hours + minutes / 60.0;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,320 @@
|
||||
using System.Net;
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text;
|
||||
using System.Text.Json.Nodes;
|
||||
|
||||
namespace CommonwealthOnline.Server;
|
||||
|
||||
internal enum GnsEventType : uint { None = 0, Connected = 1, Disconnected = 2, Message = 3, OversizeMessage = 4 }
|
||||
|
||||
internal sealed unsafe class GnsNativeServer : IDisposable
|
||||
{
|
||||
[StructLayout(LayoutKind.Sequential)]
|
||||
private struct NativeEvent
|
||||
{
|
||||
public uint Type;
|
||||
public uint ConnectionId;
|
||||
public int Reason;
|
||||
public uint PayloadSize;
|
||||
public fixed byte Debug[128];
|
||||
}
|
||||
|
||||
[UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate int CreateDelegate([MarshalAs(UnmanagedType.LPUTF8Str)] string bindHost, ushort port, out IntPtr handle, IntPtr errorBuffer, nuint errorBufferSize);
|
||||
[UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate void DestroyDelegate(IntPtr handle);
|
||||
[UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate ushort LocalPortDelegate(IntPtr handle);
|
||||
[UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate uint ConnectionCountDelegate(IntPtr handle);
|
||||
[UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate int PollDelegate(IntPtr handle, NativeEvent* outEvent, IntPtr payloadBuffer, uint payloadCapacity);
|
||||
[UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate int SendDelegate(IntPtr handle, uint connectionId, IntPtr payload, uint payloadSize, uint delivery);
|
||||
[UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate int DisconnectDelegate(IntPtr handle, uint connectionId, int reason, [MarshalAs(UnmanagedType.LPUTF8Str)] string debug);
|
||||
[UnmanagedFunctionPointer(CallingConvention.Cdecl)] private delegate int RemoteIpv4Delegate(IntPtr handle, uint connectionId, out uint ipv4HostOrder, out ushort port);
|
||||
|
||||
private readonly IntPtr _library;
|
||||
private IntPtr _handle;
|
||||
private readonly DestroyDelegate _destroy;
|
||||
private readonly LocalPortDelegate _localPort;
|
||||
private readonly ConnectionCountDelegate _connectionCount;
|
||||
private readonly PollDelegate _poll;
|
||||
private readonly SendDelegate _send;
|
||||
private readonly DisconnectDelegate _disconnect;
|
||||
private readonly RemoteIpv4Delegate _remoteIpv4;
|
||||
private readonly IntPtr _payloadBuffer = Marshal.AllocHGlobal(ProtocolConstants.MaxMessageBytes);
|
||||
private int _disposed;
|
||||
|
||||
public GnsNativeServer(string bindHost, int port, string? configuredPath, string serverBaseDirectory)
|
||||
{
|
||||
var libraryPath = ResolveLibrary(configuredPath, serverBaseDirectory);
|
||||
_library = NativeLibrary.Load(libraryPath);
|
||||
var create = Get<CreateDelegate>("co_gns_server_create");
|
||||
_destroy = Get<DestroyDelegate>("co_gns_server_destroy");
|
||||
_localPort = Get<LocalPortDelegate>("co_gns_server_local_port");
|
||||
_connectionCount = Get<ConnectionCountDelegate>("co_gns_server_connection_count");
|
||||
_poll = Get<PollDelegate>("co_gns_server_poll");
|
||||
_send = Get<SendDelegate>("co_gns_server_send");
|
||||
_disconnect = Get<DisconnectDelegate>("co_gns_server_disconnect");
|
||||
_remoteIpv4 = Get<RemoteIpv4Delegate>("co_gns_server_remote_ipv4");
|
||||
|
||||
var errorBuffer = Marshal.AllocHGlobal(512);
|
||||
try
|
||||
{
|
||||
new Span<byte>((void*)errorBuffer, 512).Clear();
|
||||
var result = create(bindHost, checked((ushort)port), out _handle, errorBuffer, 512);
|
||||
if (result != 1 || _handle == IntPtr.Zero)
|
||||
throw new InvalidOperationException(Marshal.PtrToStringUTF8(errorBuffer) ?? "GNS native bridge failed to start");
|
||||
}
|
||||
finally { Marshal.FreeHGlobal(errorBuffer); }
|
||||
}
|
||||
|
||||
public ushort LocalPort => _localPort(_handle);
|
||||
public uint ConnectionCount => _connectionCount(_handle);
|
||||
|
||||
public (GnsEventType Type, uint ConnectionId, int Reason, byte[] Payload, string Debug)? Poll()
|
||||
{
|
||||
NativeEvent native = default;
|
||||
var result = _poll(_handle, &native, _payloadBuffer, ProtocolConstants.MaxMessageBytes);
|
||||
if (result == 0) return null;
|
||||
if (result < 0) throw new IOException($"GNS native poll failed with result {result}");
|
||||
if (!Enum.IsDefined(typeof(GnsEventType), native.Type)) throw new IOException($"GNS native bridge returned unknown event type {native.Type}");
|
||||
var type = (GnsEventType)native.Type;
|
||||
if (native.PayloadSize > ProtocolConstants.MaxMessageBytes && type != GnsEventType.OversizeMessage) throw new IOException("GNS native bridge returned an oversized message payload");
|
||||
var payload = Array.Empty<byte>();
|
||||
if (type == GnsEventType.Message && native.PayloadSize > 0)
|
||||
{
|
||||
payload = new byte[native.PayloadSize];
|
||||
Marshal.Copy(_payloadBuffer, payload, 0, payload.Length);
|
||||
}
|
||||
string debug;
|
||||
fixed (byte* pointer = native.Debug)
|
||||
{
|
||||
var length = 0;
|
||||
while (length < 128 && pointer[length] != 0) length++;
|
||||
debug = Encoding.UTF8.GetString(pointer, length);
|
||||
}
|
||||
return (type, native.ConnectionId, native.Reason, payload, debug);
|
||||
}
|
||||
|
||||
public SendOutcome Send(uint connectionId, ReadOnlySpan<byte> payload, Delivery delivery)
|
||||
{
|
||||
if (payload.Length > ProtocolConstants.MaxMessageBytes) return SendOutcome.TooLarge;
|
||||
fixed (byte* pointer = payload)
|
||||
{
|
||||
return _send(_handle, connectionId, (IntPtr)pointer, (uint)payload.Length, (uint)delivery) switch
|
||||
{
|
||||
0 => SendOutcome.Sent,
|
||||
1 => SendOutcome.Dropped,
|
||||
2 => SendOutcome.Backpressure,
|
||||
3 => SendOutcome.NotConnected,
|
||||
4 => SendOutcome.TooLarge,
|
||||
_ => SendOutcome.Error
|
||||
};
|
||||
}
|
||||
}
|
||||
|
||||
public void Disconnect(uint connectionId, int reason, string debug) => _disconnect(_handle, connectionId, reason, debug);
|
||||
|
||||
public IPEndPoint? RemoteEndpoint(uint connectionId)
|
||||
{
|
||||
if (_remoteIpv4(_handle, connectionId, out var ipv4, out var port) != 1) return null;
|
||||
var bytes = new[] { (byte)(ipv4 >> 24), (byte)(ipv4 >> 16), (byte)(ipv4 >> 8), (byte)ipv4 };
|
||||
return new IPEndPoint(new IPAddress(bytes), port);
|
||||
}
|
||||
|
||||
private T Get<T>(string name) where T : Delegate => Marshal.GetDelegateForFunctionPointer<T>(NativeLibrary.GetExport(_library, name));
|
||||
|
||||
private static string ResolveLibrary(string? configuredPath, string serverBaseDirectory)
|
||||
{
|
||||
if (!string.IsNullOrWhiteSpace(configuredPath))
|
||||
{
|
||||
var full = Path.GetFullPath(configuredPath, serverBaseDirectory);
|
||||
if (File.Exists(full)) return full;
|
||||
throw new FileNotFoundException("Configured GNS bridge was not found", full);
|
||||
}
|
||||
var name = OperatingSystem.IsWindows() ? "commonwealth_online_gns_bridge.dll" : OperatingSystem.IsMacOS() ? "libcommonwealth_online_gns_bridge.dylib" : "libcommonwealth_online_gns_bridge.so";
|
||||
var candidates = new[]
|
||||
{
|
||||
Path.Combine(AppContext.BaseDirectory, name),
|
||||
Path.Combine(AppContext.BaseDirectory, "native_transport", name),
|
||||
Path.Combine(serverBaseDirectory, name),
|
||||
Path.Combine(serverBaseDirectory, "native_transport", name),
|
||||
Path.Combine(Environment.CurrentDirectory, "native_transport", name)
|
||||
};
|
||||
return candidates.FirstOrDefault(File.Exists) ?? throw new FileNotFoundException($"Commonwealth Online GNS native bridge was not found. Searched: {string.Join(", ", candidates)}");
|
||||
}
|
||||
|
||||
public void Dispose()
|
||||
{
|
||||
if (Interlocked.Exchange(ref _disposed, 1) != 0) return;
|
||||
if (_handle != IntPtr.Zero) { _destroy(_handle); _handle = IntPtr.Zero; }
|
||||
Marshal.FreeHGlobal(_payloadBuffer);
|
||||
if (_library != IntPtr.Zero) NativeLibrary.Free(_library);
|
||||
}
|
||||
}
|
||||
|
||||
internal sealed class GnsGameConnection : IGameConnection
|
||||
{
|
||||
private readonly GnsNativeServer _native;
|
||||
private readonly uint _id;
|
||||
private readonly object _gate = new();
|
||||
private readonly Dictionary<string, SequenceCounter> _outgoingSequences = new(StringComparer.Ordinal)
|
||||
{
|
||||
["transform"] = new SequenceCounter(), ["npcState"] = new SequenceCounter()
|
||||
};
|
||||
private int _closed;
|
||||
|
||||
public GnsGameConnection(GnsNativeServer native, uint id, IPEndPoint remoteEndpoint) { _native = native; _id = id; RemoteEndpoint = remoteEndpoint; ConnectionKey = $"gns:{id}"; }
|
||||
public string ConnectionKey { get; }
|
||||
public string TransportName => "gns";
|
||||
public IPEndPoint RemoteEndpoint { get; }
|
||||
public bool IsClosed => Volatile.Read(ref _closed) != 0;
|
||||
public uint NativeId => _id;
|
||||
|
||||
public ValueTask<SendOutcome> SendAsync(EncodedPacket packet, CancellationToken cancellationToken = default)
|
||||
{
|
||||
if (IsClosed) return ValueTask.FromResult(SendOutcome.NotConnected);
|
||||
lock (_gate)
|
||||
{
|
||||
if (IsClosed) return ValueTask.FromResult(SendOutcome.NotConnected);
|
||||
ReadOnlySpan<byte> wire = packet.Payload;
|
||||
byte[]? envelope = null;
|
||||
if (TransportPolicy.IsSnapshot(packet.PacketType))
|
||||
{
|
||||
envelope = GnsSnapshotEnvelope.Encode(packet.PacketType, packet.Payload, _outgoingSequences[packet.PacketType].Advance());
|
||||
wire = envelope;
|
||||
}
|
||||
return ValueTask.FromResult(_native.Send(_id, wire, packet.Delivery));
|
||||
}
|
||||
}
|
||||
|
||||
public ValueTask DisconnectAsync(int reason, string debug)
|
||||
{
|
||||
if (Interlocked.Exchange(ref _closed, 1) == 0) { try { _native.Disconnect(_id, reason, debug); } catch { } }
|
||||
return ValueTask.CompletedTask;
|
||||
}
|
||||
internal void MarkRemoteClosed() => Interlocked.Exchange(ref _closed, 1);
|
||||
public ValueTask DisposeAsync() => DisconnectAsync(0, "dispose");
|
||||
}
|
||||
|
||||
internal sealed class GnsServerTransport : IAsyncDisposable
|
||||
{
|
||||
private readonly ServerOptions _options;
|
||||
private readonly IServerIngress _server;
|
||||
private readonly CancellationTokenSource _shutdown = new();
|
||||
private readonly Dictionary<uint, GnsGameConnection> _connections = new();
|
||||
private readonly Dictionary<(uint ConnectionId, string PacketType), SequenceWindow> _incomingSequences = new();
|
||||
private readonly object _gate = new();
|
||||
private GnsNativeServer? _native;
|
||||
private Task? _pumpTask;
|
||||
|
||||
public GnsServerTransport(ServerOptions options, IServerIngress server) { _options = options; _server = server; }
|
||||
|
||||
public void Start()
|
||||
{
|
||||
if (_pumpTask is not null) return;
|
||||
_native = new GnsNativeServer(_options.Host, _options.Port, _options.GnsBridgePath, _options.BaseDirectory);
|
||||
if (_native.LocalPort != _options.Port) throw new InvalidOperationException($"GNS transport bound UDP {_native.LocalPort}, expected UDP {_options.Port}.");
|
||||
_pumpTask = Task.Run(() => PumpAsync(_shutdown.Token));
|
||||
_server.Log($"GameNetworkingSockets gameplay transport listening on UDP {_options.Port}.");
|
||||
}
|
||||
|
||||
private async Task PumpAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
while (!cancellationToken.IsCancellationRequested)
|
||||
{
|
||||
(GnsEventType Type, uint ConnectionId, int Reason, byte[] Payload, string Debug)? evt;
|
||||
try { evt = _native!.Poll(); }
|
||||
catch (Exception ex)
|
||||
{
|
||||
if (!cancellationToken.IsCancellationRequested) _server.Log($"GNS poll error: {ex.Message}", "error");
|
||||
try { await Task.Delay(10, cancellationToken).ConfigureAwait(false); } catch (OperationCanceledException) { break; }
|
||||
continue;
|
||||
}
|
||||
if (evt is null)
|
||||
{
|
||||
try { await Task.Delay(2, cancellationToken).ConfigureAwait(false); } catch (OperationCanceledException) { break; }
|
||||
continue;
|
||||
}
|
||||
var value = evt.Value;
|
||||
switch (value.Type)
|
||||
{
|
||||
case GnsEventType.Connected: await HandleConnectedAsync(value.ConnectionId, cancellationToken).ConfigureAwait(false); break;
|
||||
case GnsEventType.Message: await HandleMessageAsync(value.ConnectionId, value.Payload, cancellationToken).ConfigureAwait(false); break;
|
||||
case GnsEventType.OversizeMessage:
|
||||
if (TryGetConnection(value.ConnectionId, out var oversized)) await _server.EndSessionForTransportAsync(oversized, "packet_too_large", "Packet exceeded maximum message size.").ConfigureAwait(false);
|
||||
else _native!.Disconnect(value.ConnectionId, 0, "Oversized pre-session packet");
|
||||
break;
|
||||
case GnsEventType.Disconnected: await HandleDisconnectedAsync(value.ConnectionId).ConfigureAwait(false); break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
private async Task HandleConnectedAsync(uint id, CancellationToken cancellationToken)
|
||||
{
|
||||
var endpoint = _native!.RemoteEndpoint(id);
|
||||
if (endpoint is null) { _native.Disconnect(id, 0, "Remote endpoint unavailable"); return; }
|
||||
var connection = new GnsGameConnection(_native, id, endpoint);
|
||||
lock (_gate) _connections[id] = connection;
|
||||
bool accepted;
|
||||
try { accepted = await _server.AcceptConnectionAsync(connection, cancellationToken).ConfigureAwait(false); }
|
||||
catch (Exception ex) { _server.Log($"GNS admission failed for {endpoint}: {ex.Message}", "warning"); accepted = false; }
|
||||
if (!accepted) { lock (_gate) _connections.Remove(id); await connection.DisposeAsync(); }
|
||||
}
|
||||
|
||||
private async Task HandleMessageAsync(uint id, byte[] payload, CancellationToken cancellationToken)
|
||||
{
|
||||
if (!TryGetConnection(id, out var connection)) { _native!.Disconnect(id, 0, "Message before GNS admission"); return; }
|
||||
ReadOnlyMemory<byte> gameplayPayload = payload;
|
||||
if (GnsSnapshotEnvelope.TryDecode(payload, out var envelope, out var envelopeError))
|
||||
{
|
||||
if (envelopeError is not null) { await _server.HandleTransportRejectAsync(connection, $"Malformed GNS snapshot envelope: {envelopeError}").ConfigureAwait(false); return; }
|
||||
bool accepted;
|
||||
lock (_gate)
|
||||
{
|
||||
if (!_incomingSequences.TryGetValue((id, envelope.PacketType), out var window)) _incomingSequences[(id, envelope.PacketType)] = window = new SequenceWindow();
|
||||
accepted = window.Accept(envelope.Sequence);
|
||||
}
|
||||
if (!accepted) { await _server.HandleTransportRejectAsync(connection, "Stale or duplicate GNS snapshot sequence", false).ConfigureAwait(false); return; }
|
||||
JsonObject packet;
|
||||
try { packet = PacketCodec.Decode(envelope.Payload); }
|
||||
catch (PacketCodecException ex) { await _server.HandleTransportRejectAsync(connection, $"Invalid GNS snapshot payload: {ex.Message}").ConfigureAwait(false); return; }
|
||||
if (JsonHelpers.String(packet["type"]) != envelope.PacketType) { await _server.HandleTransportRejectAsync(connection, "GNS snapshot envelope family does not match packet type").ConfigureAwait(false); return; }
|
||||
gameplayPayload = envelope.Payload;
|
||||
}
|
||||
else
|
||||
{
|
||||
try
|
||||
{
|
||||
var packet = PacketCodec.Decode(payload);
|
||||
var type = JsonHelpers.String(packet["type"])!;
|
||||
if (TransportPolicy.IsSnapshot(type)) { await _server.HandleTransportRejectAsync(connection, "GNS snapshot missing required sequence envelope").ConfigureAwait(false); return; }
|
||||
}
|
||||
catch (PacketCodecException) { }
|
||||
}
|
||||
await _server.HandleMessageAsync(connection, gameplayPayload, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private async Task HandleDisconnectedAsync(uint id)
|
||||
{
|
||||
GnsGameConnection? connection;
|
||||
lock (_gate)
|
||||
{
|
||||
_connections.Remove(id, out connection);
|
||||
foreach (var key in _incomingSequences.Keys.Where(x => x.ConnectionId == id).ToArray()) _incomingSequences.Remove(key);
|
||||
}
|
||||
if (connection is null) return;
|
||||
connection.MarkRemoteClosed();
|
||||
await _server.HandleConnectionClosedAsync(connection).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
private bool TryGetConnection(uint id, out GnsGameConnection connection) { lock (_gate) return _connections.TryGetValue(id, out connection!); }
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
_shutdown.Cancel();
|
||||
if (_pumpTask is not null) { try { await _pumpTask.ConfigureAwait(false); } catch { } }
|
||||
GnsGameConnection[] connections;
|
||||
lock (_gate) { connections = _connections.Values.ToArray(); _connections.Clear(); _incomingSequences.Clear(); }
|
||||
foreach (var connection in connections) await connection.DisposeAsync();
|
||||
_native?.Dispose();
|
||||
_native = null;
|
||||
_shutdown.Dispose();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,337 @@
|
||||
using System.Runtime.InteropServices;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
|
||||
namespace CommonwealthOnline.Server;
|
||||
|
||||
internal static class Program
|
||||
{
|
||||
public static async Task<int> Main(string[] args)
|
||||
{
|
||||
try
|
||||
{
|
||||
return await RunAsync(args).ConfigureAwait(false);
|
||||
}
|
||||
catch (Exception ex)
|
||||
{
|
||||
Console.Error.WriteLine($"[ERROR] {ex.Message}");
|
||||
return 2;
|
||||
}
|
||||
}
|
||||
|
||||
private static async Task<int> RunAsync(string[] args)
|
||||
{
|
||||
if (args.Length == 0 || args[0] is "help" or "--help" or "-h")
|
||||
{
|
||||
PrintHelp();
|
||||
return 0;
|
||||
}
|
||||
|
||||
var command = args[0].ToLowerInvariant();
|
||||
return command switch
|
||||
{
|
||||
"serve" => await ServeAsync(args[1..]).ConfigureAwait(false),
|
||||
"status" => await AdminCommandAsync(new JsonObject { ["cmd"] = "status" }, args[1..]).ConfigureAwait(false),
|
||||
"clients" or "users" => await AdminCommandAsync(new JsonObject { ["cmd"] = "clients" }, args[1..]).ConfigureAwait(false),
|
||||
"bans" => await AdminCommandAsync(new JsonObject { ["cmd"] = "bans" }, args[1..]).ConfigureAwait(false),
|
||||
"kick" => await KickAsync(args[1..]).ConfigureAwait(false),
|
||||
"ban" => await BanAsync(args[1..]).ConfigureAwait(false),
|
||||
"unban" => await UnbanAsync(args[1..]).ConfigureAwait(false),
|
||||
"world" => await WorldAsync(args[1..]).ConfigureAwait(false),
|
||||
"config" => ConfigCommand(args[1..]),
|
||||
"load-test" => await LoadTestAsync(args[1..]).ConfigureAwait(false),
|
||||
_ => Unknown(command)
|
||||
};
|
||||
}
|
||||
|
||||
private static async Task<int> ServeAsync(string[] args)
|
||||
{
|
||||
var configPath = GetOption(args, "--config", "-c") ?? "commonwealth-server.json";
|
||||
var fullConfigPath = Path.GetFullPath(configPath);
|
||||
if (!File.Exists(fullConfigPath))
|
||||
{
|
||||
Console.WriteLine($"Generating default configuration at {fullConfigPath}");
|
||||
ServerOptions.CreateDefault(fullConfigPath);
|
||||
}
|
||||
var options = ServerOptions.Load(fullConfigPath);
|
||||
if (GetOption(args, "--host", "-H") is { } host) options.Host = host;
|
||||
if (GetOption(args, "--port", "-p") is { } portText)
|
||||
{
|
||||
if (!int.TryParse(portText, out var port)) throw new ArgumentException("--port requires an integer.");
|
||||
options.Port = port;
|
||||
}
|
||||
var errors = options.Validate();
|
||||
if (errors.Count > 0)
|
||||
{
|
||||
foreach (var error in errors) Console.Error.WriteLine($"[ERROR] {error}");
|
||||
return 2;
|
||||
}
|
||||
|
||||
await using var runtime = new ServerRuntime(options);
|
||||
runtime.Server.LogMessage += (message, level) =>
|
||||
{
|
||||
var timestamp = DateTime.Now.ToString("yyyy-MM-dd HH:mm:ss");
|
||||
Console.WriteLine($"{timestamp} {level.ToUpperInvariant()} {message}");
|
||||
};
|
||||
|
||||
runtime.Start();
|
||||
PrintStartup(options);
|
||||
using var shutdown = new CancellationTokenSource();
|
||||
Console.CancelKeyPress += (_, eventArgs) => { eventArgs.Cancel = true; shutdown.Cancel(); };
|
||||
PosixSignalRegistration? sigterm = null;
|
||||
if (!OperatingSystem.IsWindows())
|
||||
{
|
||||
sigterm = PosixSignalRegistration.Create(PosixSignal.SIGTERM, context => { context.Cancel = true; shutdown.Cancel(); });
|
||||
}
|
||||
try
|
||||
{
|
||||
if (HasFlag(args, "--interactive", "-i") && !Console.IsInputRedirected)
|
||||
await RunInteractiveAsync(options, shutdown).ConfigureAwait(false);
|
||||
else
|
||||
await Task.Delay(Timeout.InfiniteTimeSpan, shutdown.Token).ConfigureAwait(false);
|
||||
}
|
||||
catch (OperationCanceledException) { }
|
||||
finally { sigterm?.Dispose(); }
|
||||
return 0;
|
||||
}
|
||||
|
||||
private static async Task RunInteractiveAsync(ServerOptions options, CancellationTokenSource shutdown)
|
||||
{
|
||||
Console.WriteLine("Type help for commands. Type quit to stop.");
|
||||
while (!shutdown.IsCancellationRequested)
|
||||
{
|
||||
Console.Write("commonwealth> ");
|
||||
var line = Console.ReadLine();
|
||||
if (line is null) break;
|
||||
var parts = SplitCommandLine(line);
|
||||
if (parts.Length == 0) continue;
|
||||
if (parts[0] is "quit" or "exit" or "stop") { shutdown.Cancel(); break; }
|
||||
if (parts[0] == "help") { PrintInteractiveHelp(); continue; }
|
||||
var forwarded = parts[0] switch
|
||||
{
|
||||
"users" => new JsonObject { ["cmd"] = "clients" },
|
||||
"clients" => new JsonObject { ["cmd"] = "clients" },
|
||||
"status" => new JsonObject { ["cmd"] = "status" },
|
||||
"bans" => new JsonObject { ["cmd"] = "bans" },
|
||||
_ => null
|
||||
};
|
||||
if (forwarded is not null)
|
||||
{
|
||||
await PrintAdminResponseAsync(forwarded, options).ConfigureAwait(false);
|
||||
continue;
|
||||
}
|
||||
if (parts[0] == "kick" && parts.Length >= 2 && uint.TryParse(parts[1], out var kickId))
|
||||
{
|
||||
await PrintAdminResponseAsync(new JsonObject { ["cmd"] = "kick", ["playerId"] = kickId, ["reason"] = ReadReason(parts, 2) }, options).ConfigureAwait(false);
|
||||
continue;
|
||||
}
|
||||
if (parts[0] == "ban" && parts.Length >= 2)
|
||||
{
|
||||
var request = new JsonObject { ["cmd"] = "ban", ["reason"] = ReadReason(parts, 2) };
|
||||
if (uint.TryParse(parts[1], out var banId)) request["playerId"] = banId; else request["ip"] = parts[1];
|
||||
await PrintAdminResponseAsync(request, options).ConfigureAwait(false);
|
||||
continue;
|
||||
}
|
||||
if (parts[0] == "unban" && parts.Length >= 2)
|
||||
{
|
||||
await PrintAdminResponseAsync(new JsonObject { ["cmd"] = "unban", ["ip"] = parts[1] }, options).ConfigureAwait(false);
|
||||
continue;
|
||||
}
|
||||
if (parts.Length >= 3 && parts[0] == "world" && parts[1] == "time")
|
||||
{
|
||||
await PrintAdminResponseAsync(new JsonObject { ["cmd"] = "world_time", ["hhmm"] = parts[2] }, options).ConfigureAwait(false);
|
||||
continue;
|
||||
}
|
||||
if (parts.Length >= 3 && parts[0] == "world" && parts[1] == "weather")
|
||||
{
|
||||
await PrintAdminResponseAsync(new JsonObject { ["cmd"] = "world_weather", ["weather"] = parts[2] }, options).ConfigureAwait(false);
|
||||
continue;
|
||||
}
|
||||
Console.WriteLine("Unknown command. Type help.");
|
||||
}
|
||||
}
|
||||
|
||||
private static async Task<int> AdminCommandAsync(JsonObject request, string[] args)
|
||||
{
|
||||
var options = LoadOptionsForAdmin(args);
|
||||
return await PrintAdminResponseAsync(request, options).ConfigureAwait(false) ? 0 : 1;
|
||||
}
|
||||
|
||||
private static async Task<int> KickAsync(string[] args)
|
||||
{
|
||||
if (args.Length == 0 || !uint.TryParse(args[0], out var id)) throw new ArgumentException("kick requires PLAYER_ID");
|
||||
var options = LoadOptionsForAdmin(args[1..]);
|
||||
var request = new JsonObject { ["cmd"] = "kick", ["playerId"] = id, ["reason"] = GetOption(args, "--reason") ?? string.Empty };
|
||||
return await PrintAdminResponseAsync(request, options).ConfigureAwait(false) ? 0 : 1;
|
||||
}
|
||||
|
||||
private static async Task<int> BanAsync(string[] args)
|
||||
{
|
||||
if (args.Length == 0) throw new ArgumentException("ban requires PLAYER_ID_OR_IP");
|
||||
var request = new JsonObject { ["cmd"] = "ban", ["reason"] = GetOption(args, "--reason") ?? string.Empty };
|
||||
if (uint.TryParse(args[0], out var id)) request["playerId"] = id; else request["ip"] = args[0];
|
||||
var options = LoadOptionsForAdmin(args[1..]);
|
||||
return await PrintAdminResponseAsync(request, options).ConfigureAwait(false) ? 0 : 1;
|
||||
}
|
||||
|
||||
private static async Task<int> UnbanAsync(string[] args)
|
||||
{
|
||||
if (args.Length == 0) throw new ArgumentException("unban requires IP");
|
||||
var options = LoadOptionsForAdmin(args[1..]);
|
||||
return await PrintAdminResponseAsync(new JsonObject { ["cmd"] = "unban", ["ip"] = args[0] }, options).ConfigureAwait(false) ? 0 : 1;
|
||||
}
|
||||
|
||||
private static async Task<int> WorldAsync(string[] args)
|
||||
{
|
||||
if (args.Length < 2) throw new ArgumentException("world requires 'time HHmm' or 'weather FORM_ID'");
|
||||
var request = args[0].ToLowerInvariant() switch
|
||||
{
|
||||
"time" => new JsonObject { ["cmd"] = "world_time", ["hhmm"] = args[1] },
|
||||
"weather" => new JsonObject { ["cmd"] = "world_weather", ["weather"] = args[1] },
|
||||
_ => throw new ArgumentException("world requires 'time' or 'weather'")
|
||||
};
|
||||
var options = LoadOptionsForAdmin(args[2..]);
|
||||
return await PrintAdminResponseAsync(request, options).ConfigureAwait(false) ? 0 : 1;
|
||||
}
|
||||
|
||||
private static int ConfigCommand(string[] args)
|
||||
{
|
||||
if (args.Length == 0 || args[0] != "init") throw new ArgumentException("config requires 'init [OUTPUT_PATH]'");
|
||||
var path = Path.GetFullPath(args.Length > 1 ? args[1] : "commonwealth-server.json");
|
||||
if (File.Exists(path)) throw new IOException($"Config already exists: {path}");
|
||||
ServerOptions.CreateDefault(path);
|
||||
Console.WriteLine(path);
|
||||
return 0;
|
||||
}
|
||||
|
||||
private static async Task<int> LoadTestAsync(string[] args)
|
||||
{
|
||||
var host = GetOption(args, "--host", "-H") ?? "127.0.0.1";
|
||||
var port = int.TryParse(GetOption(args, "--port", "-p"), out var parsedPort) ? parsedPort : 7777;
|
||||
var count = int.TryParse(GetOption(args, "--clients", "-n"), out var parsedCount) ? parsedCount : 16;
|
||||
if (count is < 1 or > 256) throw new ArgumentOutOfRangeException(nameof(count), "client count must be 1-256");
|
||||
var clients = new List<SyntheticProtocolClient>();
|
||||
using var timeout = new CancellationTokenSource(TimeSpan.FromSeconds(20));
|
||||
try
|
||||
{
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
var client = new SyntheticProtocolClient();
|
||||
await client.ConnectAsync(host, port, timeout.Token).ConfigureAwait(false);
|
||||
clients.Add(client);
|
||||
var cell = (0x1000 + i).ToString("X8");
|
||||
await client.SendTransformAsync(i * 1000.0, 0, 0, cell, string.Empty, "spawn", timeout.Token).ConfigureAwait(false);
|
||||
}
|
||||
var ids = clients.Select(x => x.PlayerId).ToArray();
|
||||
if (ids.Distinct().Count() != ids.Length) throw new InvalidOperationException("Server assigned duplicate player IDs.");
|
||||
Console.WriteLine($"Connected {clients.Count} clients with unique server-owned IDs: {string.Join(", ", ids)}");
|
||||
return 0;
|
||||
}
|
||||
finally
|
||||
{
|
||||
foreach (var client in clients) await client.DisposeAsync();
|
||||
}
|
||||
}
|
||||
|
||||
private static ServerOptions LoadOptionsForAdmin(string[] args)
|
||||
{
|
||||
var configPath = GetOption(args, "--config", "-c") ?? "commonwealth-server.json";
|
||||
return ServerOptions.Load(Path.GetFullPath(configPath));
|
||||
}
|
||||
|
||||
private static async Task<bool> PrintAdminResponseAsync(JsonObject request, ServerOptions options)
|
||||
{
|
||||
JsonObject response;
|
||||
try { response = await AdminClient.SendAsync(request, options.AdminPort, options.AdminTokenPath).ConfigureAwait(false); }
|
||||
catch (Exception ex)
|
||||
{
|
||||
Console.Error.WriteLine($"Error talking to admin port 127.0.0.1:{options.AdminPort}: {ex.Message}");
|
||||
return false;
|
||||
}
|
||||
Console.WriteLine(response.ToJsonString(new JsonSerializerOptions { WriteIndented = true }));
|
||||
return JsonHelpers.Boolean(response["ok"]) == true;
|
||||
}
|
||||
|
||||
private static void PrintStartup(ServerOptions options)
|
||||
{
|
||||
Console.WriteLine($"Commonwealth Online Server\nBind: {options.Host}:{options.Port}\nMax players: {options.MaxPlayers}\nLAN discovery: UDP {LanDiscoveryService.DiscoveryPort}\nAdmin: 127.0.0.1:{options.AdminPort}\nGNS: {(options.EnableGnsTransport ? "enabled" : "disabled")}\n");
|
||||
}
|
||||
|
||||
private static string? GetOption(string[] args, params string[] names)
|
||||
{
|
||||
for (var i = 0; i < args.Length; i++)
|
||||
{
|
||||
foreach (var name in names)
|
||||
{
|
||||
if (args[i] == name)
|
||||
{
|
||||
if (i + 1 >= args.Length) throw new ArgumentException($"{name} requires a value.");
|
||||
return args[i + 1];
|
||||
}
|
||||
if (args[i].StartsWith(name + "=", StringComparison.Ordinal)) return args[i][(name.Length + 1)..];
|
||||
}
|
||||
}
|
||||
return null;
|
||||
}
|
||||
|
||||
private static bool HasFlag(string[] args, params string[] names) => args.Any(arg => names.Contains(arg, StringComparer.Ordinal));
|
||||
|
||||
private static string[] SplitCommandLine(string input)
|
||||
{
|
||||
var result = new List<string>();
|
||||
var current = new System.Text.StringBuilder();
|
||||
var quoted = false;
|
||||
for (var i = 0; i < input.Length; i++)
|
||||
{
|
||||
var ch = input[i];
|
||||
if (ch == '"') { quoted = !quoted; continue; }
|
||||
if (char.IsWhiteSpace(ch) && !quoted)
|
||||
{
|
||||
if (current.Length > 0) { result.Add(current.ToString()); current.Clear(); }
|
||||
continue;
|
||||
}
|
||||
current.Append(ch);
|
||||
}
|
||||
if (current.Length > 0) result.Add(current.ToString());
|
||||
return result.ToArray();
|
||||
}
|
||||
|
||||
private static string ReadReason(string[] parts, int start)
|
||||
{
|
||||
var index = Array.IndexOf(parts, "--reason", start);
|
||||
return index >= 0 && index + 1 < parts.Length ? parts[index + 1] : string.Empty;
|
||||
}
|
||||
|
||||
private static int Unknown(string command)
|
||||
{
|
||||
Console.Error.WriteLine($"Unknown command: {command}");
|
||||
PrintHelp();
|
||||
return 2;
|
||||
}
|
||||
|
||||
private static void PrintHelp()
|
||||
{
|
||||
Console.WriteLine("""
|
||||
Commonwealth Online Server
|
||||
|
||||
Commands:
|
||||
serve [--config PATH] [--host HOST] [--port PORT] [--interactive]
|
||||
status [--config PATH]
|
||||
clients [--config PATH]
|
||||
users [--config PATH]
|
||||
kick PLAYER_ID [--reason TEXT] [--config PATH]
|
||||
ban PLAYER_ID_OR_IP [--reason TEXT] [--config PATH]
|
||||
unban IP [--config PATH]
|
||||
bans [--config PATH]
|
||||
world time HHmm [--config PATH]
|
||||
world weather FORM_ID [--config PATH]
|
||||
config init [OUTPUT_PATH]
|
||||
load-test [--host HOST] [--port PORT] [--clients N]
|
||||
""");
|
||||
}
|
||||
|
||||
private static void PrintInteractiveHelp()
|
||||
{
|
||||
Console.WriteLine("help | status | users | kick ID [--reason TEXT] | ban ID_OR_IP [--reason TEXT] | unban IP | bans | world time HHmm | world weather FORM_ID | quit");
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,176 @@
|
||||
using System.Buffers.Binary;
|
||||
using System.Globalization;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
|
||||
namespace CommonwealthOnline.Server;
|
||||
|
||||
internal static class ProtocolConstants
|
||||
{
|
||||
public const int ProtocolVersion = 2;
|
||||
public const int LegacyProtocolVersion = 1;
|
||||
public const int MaxMessageBytes = 64 * 1024;
|
||||
public const double MaxAbsCoordinate = 10_000_000.0;
|
||||
public const double MaxMovementSpeed = 100_000.0;
|
||||
public const int MaxActionEvents = 16;
|
||||
public const int MaxNpcsPerPacket = 64;
|
||||
public const double ExteriorInterestRadius = 8192.0;
|
||||
public const double MaxNormalMovementSpeed = 2500.0;
|
||||
public const double MovementGraceDistance = 512.0;
|
||||
public const double MaxMovementValidationElapsedSeconds = 5.0;
|
||||
|
||||
public static readonly HashSet<string> MovementTransitionTypes = new(StringComparer.Ordinal)
|
||||
{
|
||||
"teleport", "cell_change", "worldspace_change", "load", "spawn", "fast_travel"
|
||||
};
|
||||
|
||||
public static readonly HashSet<string> AllowedMovementTypes = new(MovementTransitionTypes, StringComparer.Ordinal) { "normal" };
|
||||
}
|
||||
|
||||
internal enum Delivery : uint { UnreliableSequenced = 0, ReliableOrdered = 1 }
|
||||
internal readonly record struct EncodedPacket(string PacketType, byte[] Payload, Delivery Delivery);
|
||||
|
||||
internal static class TransportPolicy
|
||||
{
|
||||
public static Delivery ForPacketType(string packetType) => packetType is "transform" or "npcState" ? Delivery.UnreliableSequenced : Delivery.ReliableOrdered;
|
||||
public static bool IsSnapshot(string packetType) => ForPacketType(packetType) == Delivery.UnreliableSequenced;
|
||||
}
|
||||
|
||||
internal sealed class PacketCodecException(string message) : Exception(message);
|
||||
|
||||
internal static class PacketCodec
|
||||
{
|
||||
private static readonly JsonSerializerOptions Compact = new() { WriteIndented = false };
|
||||
|
||||
public static EncodedPacket Encode(JsonObject packet)
|
||||
{
|
||||
var type = JsonHelpers.String(packet["type"]);
|
||||
if (string.IsNullOrEmpty(type)) throw new PacketCodecException("packet type must be a non-empty string");
|
||||
byte[] payload;
|
||||
try { payload = JsonSerializer.SerializeToUtf8Bytes(packet, Compact); }
|
||||
catch (Exception ex) when (ex is JsonException or NotSupportedException) { throw new PacketCodecException($"packet is not JSON serializable: {ex.Message}"); }
|
||||
if (payload.Length > ProtocolConstants.MaxMessageBytes) throw new PacketCodecException("packet exceeds maximum message size");
|
||||
return new EncodedPacket(type, payload, TransportPolicy.ForPacketType(type));
|
||||
}
|
||||
|
||||
public static JsonObject Decode(ReadOnlySpan<byte> payload)
|
||||
{
|
||||
if (payload.Length > ProtocolConstants.MaxMessageBytes) throw new PacketCodecException("packet exceeds maximum message size");
|
||||
JsonNode? node;
|
||||
try
|
||||
{
|
||||
node = JsonNode.Parse(payload, documentOptions: new JsonDocumentOptions { AllowTrailingCommas = false, CommentHandling = JsonCommentHandling.Disallow });
|
||||
}
|
||||
catch (JsonException ex) { throw new PacketCodecException($"invalid JSON packet: {ex.Message}"); }
|
||||
if (node is not JsonObject packet) throw new PacketCodecException("packet must be a JSON object");
|
||||
var type = JsonHelpers.String(packet["type"]);
|
||||
if (string.IsNullOrEmpty(type)) throw new PacketCodecException("packet type must be a non-empty string");
|
||||
return packet;
|
||||
}
|
||||
}
|
||||
|
||||
internal static class JsonHelpers
|
||||
{
|
||||
public static string? String(JsonNode? node) => node is JsonValue value && value.TryGetValue<string>(out var text) ? text : null;
|
||||
public static bool? Boolean(JsonNode? node) => node is JsonValue value && value.TryGetValue<bool>(out var result) ? result : null;
|
||||
|
||||
public static bool TryUInt32(JsonNode? node, uint min, uint max, out uint result)
|
||||
{
|
||||
result = 0;
|
||||
if (node is not JsonValue value || value.TryGetValue<bool>(out _)) return false;
|
||||
if (value.TryGetValue<uint>(out var u) && u >= min && u <= max) { result = u; return true; }
|
||||
if (value.TryGetValue<long>(out var l) && l >= min && l <= max) { result = (uint)l; return true; }
|
||||
if (value.TryGetValue<double>(out var d) && double.IsFinite(d) && d == Math.Truncate(d) && d >= min && d <= max) { result = (uint)d; return true; }
|
||||
return false;
|
||||
}
|
||||
|
||||
public static bool TryDouble(JsonNode? node, double min, double max, out double result)
|
||||
{
|
||||
result = 0;
|
||||
if (node is not JsonValue value || value.TryGetValue<bool>(out _)) return false;
|
||||
double d;
|
||||
if (value.TryGetValue<double>(out var direct)) d = direct;
|
||||
else if (value.TryGetValue<long>(out var l)) d = l;
|
||||
else if (value.TryGetValue<decimal>(out var m)) d = (double)m;
|
||||
else return false;
|
||||
if (!double.IsFinite(d) || d < min || d > max) return false;
|
||||
result = d;
|
||||
return true;
|
||||
}
|
||||
|
||||
public static bool IsHexFormId(JsonNode? node, bool allowEmpty = false, bool allowZero = true) => String(node) is { } text && IsHexFormId(text, allowEmpty, allowZero);
|
||||
public static bool IsHexFormId(string text, bool allowEmpty = false, bool allowZero = true)
|
||||
{
|
||||
if (allowEmpty && text.Length == 0) return true;
|
||||
if (text.Length is < 1 or > 8) return false;
|
||||
if (!uint.TryParse(text, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out var parsed)) return false;
|
||||
return allowZero || parsed != 0;
|
||||
}
|
||||
public static string NormalizeFormId(string text) => uint.Parse(text, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture).ToString("X8", CultureInfo.InvariantCulture);
|
||||
public static JsonObject CloneObject(JsonObject source) => (JsonObject)source.DeepClone();
|
||||
public static double UnixTime() => DateTimeOffset.UtcNow.ToUnixTimeMilliseconds() / 1000.0;
|
||||
}
|
||||
|
||||
internal sealed class SequenceCounter
|
||||
{
|
||||
private uint _value;
|
||||
public uint Current => _value;
|
||||
public uint Advance() { unchecked { _value++; } if (_value == 0) _value = 1; return _value; }
|
||||
public void Reset() => _value = 0;
|
||||
}
|
||||
|
||||
internal sealed class SequenceWindow
|
||||
{
|
||||
private uint _lastAccepted;
|
||||
public uint LastAccepted => _lastAccepted;
|
||||
public bool Accept(uint candidate) { if (!IsNewer(candidate, _lastAccepted)) return false; _lastAccepted = candidate; return true; }
|
||||
public void Reset() => _lastAccepted = 0;
|
||||
public static bool IsNewer(uint candidate, uint baseline)
|
||||
{
|
||||
if (candidate == 0) return false;
|
||||
if (baseline == 0) return true;
|
||||
var delta = unchecked(candidate - baseline);
|
||||
return delta > 0 && delta < 0x80000000u;
|
||||
}
|
||||
}
|
||||
|
||||
internal readonly record struct SnapshotEnvelope(string PacketType, uint Sequence, byte[] Payload);
|
||||
|
||||
internal static class GnsSnapshotEnvelope
|
||||
{
|
||||
private static ReadOnlySpan<byte> Magic => "COG2"u8;
|
||||
private const byte Version = 1;
|
||||
public const int HeaderSize = 12;
|
||||
|
||||
public static byte[] Encode(string packetType, ReadOnlySpan<byte> payload, uint sequence)
|
||||
{
|
||||
var family = packetType switch { "transform" => (byte)1, "npcState" => (byte)2, _ => throw new ArgumentException($"packet type '{packetType}' is not a GNS snapshot family", nameof(packetType)) };
|
||||
if (sequence == 0) throw new ArgumentOutOfRangeException(nameof(sequence));
|
||||
if (payload.IsEmpty) throw new ArgumentException("snapshot payload cannot be empty", nameof(payload));
|
||||
if (HeaderSize + payload.Length > ProtocolConstants.MaxMessageBytes) throw new ArgumentException("snapshot envelope exceeds maximum GNS message size");
|
||||
var output = new byte[HeaderSize + payload.Length];
|
||||
Magic.CopyTo(output);
|
||||
output[4] = Version;
|
||||
output[5] = family;
|
||||
BinaryPrimitives.WriteUInt16BigEndian(output.AsSpan(6, 2), 0);
|
||||
BinaryPrimitives.WriteUInt32BigEndian(output.AsSpan(8, 4), sequence);
|
||||
payload.CopyTo(output.AsSpan(HeaderSize));
|
||||
return output;
|
||||
}
|
||||
|
||||
public static bool TryDecode(ReadOnlySpan<byte> message, out SnapshotEnvelope envelope, out string? error)
|
||||
{
|
||||
envelope = default; error = null;
|
||||
if (message.Length < 4 || !message[..4].SequenceEqual(Magic)) return false;
|
||||
if (message.Length < HeaderSize) { error = "truncated GNS snapshot envelope"; return true; }
|
||||
if (message[4] != Version || BinaryPrimitives.ReadUInt16BigEndian(message.Slice(6, 2)) != 0) { error = "invalid GNS snapshot envelope header"; return true; }
|
||||
var type = message[5] switch { 1 => "transform", 2 => "npcState", _ => null };
|
||||
if (type is null) { error = "unknown GNS snapshot family"; return true; }
|
||||
var sequence = BinaryPrimitives.ReadUInt32BigEndian(message.Slice(8, 4));
|
||||
if (sequence == 0) { error = "snapshot sequence zero is reserved"; return true; }
|
||||
var payload = message[HeaderSize..].ToArray();
|
||||
if (payload.Length == 0) { error = "snapshot envelope payload is empty"; return true; }
|
||||
envelope = new SnapshotEnvelope(type, sequence, payload);
|
||||
return true;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,341 @@
|
||||
using System.Text.Json.Nodes;
|
||||
|
||||
namespace CommonwealthOnline.Server;
|
||||
|
||||
internal static class ProtocolValidation
|
||||
{
|
||||
private const int MaxCharacterNameChars = 128;
|
||||
private const int MaxEquippedItems = 32;
|
||||
private const int MaxEquipmentSlotChars = 64;
|
||||
private const int MaxHeadParts = 64;
|
||||
private const int MaxMorphs = 128;
|
||||
private const int MaxMorphRegions = 128;
|
||||
private const int MaxFacialBoneMorphs = 128;
|
||||
private const int MaxTints = 128;
|
||||
|
||||
public static JsonArray NormalizeActionEvents(JsonNode? value, bool strict)
|
||||
{
|
||||
var output = new JsonArray();
|
||||
if (value is not JsonArray input) return output;
|
||||
var count = Math.Min(input.Count, ProtocolConstants.MaxActionEvents);
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
if (input[i] is not JsonObject item)
|
||||
{
|
||||
if (strict) return new JsonArray();
|
||||
continue;
|
||||
}
|
||||
if (!JsonHelpers.TryUInt32(item["sequence"], 1, uint.MaxValue, out var sequence) ||
|
||||
!JsonHelpers.TryUInt32(item["type"], 1, 3, out var actionType) ||
|
||||
JsonHelpers.String(item["eventName"]) is not { } eventName ||
|
||||
!((actionType is 1 or 2 && eventName == "meleeattackStart") || (actionType == 3 && eventName == "fireSingle")))
|
||||
{
|
||||
if (strict) return new JsonArray();
|
||||
continue;
|
||||
}
|
||||
var clean = new JsonObject { ["sequence"] = sequence, ["type"] = actionType, ["eventName"] = eventName };
|
||||
foreach (var name in new[] { "actorStateFlags1", "actorStateFlags2" })
|
||||
if (JsonHelpers.TryUInt32(item[name], 0, uint.MaxValue, out var flags)) clean[name] = flags;
|
||||
output.Add(clean);
|
||||
}
|
||||
return output;
|
||||
}
|
||||
|
||||
public static JsonObject? NormalizePlayerState(JsonObject packet)
|
||||
{
|
||||
var clean = new JsonObject { ["type"] = "playerState" };
|
||||
var hasState = false;
|
||||
if (packet.ContainsKey("equippedItems"))
|
||||
{
|
||||
if (packet["equippedItems"] is not JsonArray items || items.Count > MaxEquippedItems) return null;
|
||||
var cleanItems = new JsonArray();
|
||||
foreach (var node in items)
|
||||
{
|
||||
if (node is not JsonObject item) return null;
|
||||
var slot = JsonHelpers.String(item["slot"]);
|
||||
var form = JsonHelpers.String(item["formId"]) ?? string.Empty;
|
||||
if (slot is null || slot.Length is < 1 or > MaxEquipmentSlotChars || !JsonHelpers.IsHexFormId(form, true, true)) return null;
|
||||
cleanItems.Add(new JsonObject { ["slot"] = slot, ["formId"] = form.Length == 0 ? string.Empty : JsonHelpers.NormalizeFormId(form) });
|
||||
}
|
||||
clean["equippedItems"] = cleanItems;
|
||||
hasState = true;
|
||||
}
|
||||
if (packet.ContainsKey("appearance"))
|
||||
{
|
||||
if (packet["appearance"] is not JsonObject appearance) return null;
|
||||
var normalizedAppearance = NormalizeAppearance(appearance);
|
||||
if (normalizedAppearance is null) return null;
|
||||
clean["appearance"] = normalizedAppearance;
|
||||
hasState = true;
|
||||
}
|
||||
if (packet.ContainsKey("actionEvents"))
|
||||
{
|
||||
if (packet["actionEvents"] is not JsonArray actions) return null;
|
||||
var normalized = NormalizeActionEvents(actions, true);
|
||||
if (normalized.Count != actions.Count) return null;
|
||||
clean["actionEvents"] = normalized;
|
||||
hasState = true;
|
||||
}
|
||||
if (packet.ContainsKey("characterName"))
|
||||
{
|
||||
var name = JsonHelpers.String(packet["characterName"]);
|
||||
if (name is null || name.Length > MaxCharacterNameChars) return null;
|
||||
clean["characterName"] = name;
|
||||
hasState = true;
|
||||
}
|
||||
return hasState ? clean : null;
|
||||
}
|
||||
|
||||
private static JsonObject? NormalizeAppearance(JsonObject value)
|
||||
{
|
||||
var clean = new JsonObject();
|
||||
uint version = 4;
|
||||
if (value.ContainsKey("version") && !JsonHelpers.TryUInt32(value["version"], 1, 1000, out version)) return null;
|
||||
clean["version"] = version;
|
||||
foreach (var name in new[] { "raceFormId", "hairColorFormId", "facialHairColorFormId", "complexionFormId" })
|
||||
{
|
||||
if (!value.ContainsKey(name)) continue;
|
||||
var form = JsonHelpers.String(value[name]);
|
||||
if (form is null || !JsonHelpers.IsHexFormId(form, true, true)) return null;
|
||||
clean[name] = form.Length == 0 ? string.Empty : JsonHelpers.NormalizeFormId(form);
|
||||
}
|
||||
if (value.ContainsKey("height"))
|
||||
{
|
||||
if (!JsonHelpers.TryDouble(value["height"], 0.25, 4.0, out var height)) return null;
|
||||
clean["height"] = height;
|
||||
}
|
||||
if (value.ContainsKey("isFemale"))
|
||||
{
|
||||
var female = JsonHelpers.Boolean(value["isFemale"]);
|
||||
if (female is null) return null;
|
||||
clean["isFemale"] = female.Value;
|
||||
}
|
||||
if (value.ContainsKey("morphWeight"))
|
||||
{
|
||||
if (value["morphWeight"] is not JsonObject weights) return null;
|
||||
var normalized = new JsonObject();
|
||||
foreach (var name in new[] { "thin", "muscular", "large" })
|
||||
{
|
||||
if (!JsonHelpers.TryDouble(weights[name], -100, 100, out var weight)) return null;
|
||||
normalized[name] = weight;
|
||||
}
|
||||
clean["morphWeight"] = normalized;
|
||||
}
|
||||
if (value.ContainsKey("bodyTintColor"))
|
||||
{
|
||||
if (value["bodyTintColor"] is not JsonObject color) return null;
|
||||
var normalized = new JsonObject();
|
||||
foreach (var name in new[] { "r", "g", "b", "a" })
|
||||
{
|
||||
if (!JsonHelpers.TryUInt32(color[name], 0, 255, out var component)) return null;
|
||||
normalized[name] = component;
|
||||
}
|
||||
clean["bodyTintColor"] = normalized;
|
||||
}
|
||||
if (value.ContainsKey("headParts"))
|
||||
{
|
||||
if (value["headParts"] is not JsonArray parts || parts.Count > MaxHeadParts) return null;
|
||||
var normalized = new JsonArray();
|
||||
foreach (var node in parts)
|
||||
{
|
||||
var form = JsonHelpers.String(node);
|
||||
if (form is null || !JsonHelpers.IsHexFormId(form, false, true)) return null;
|
||||
normalized.Add(JsonHelpers.NormalizeFormId(form));
|
||||
}
|
||||
clean["headParts"] = normalized;
|
||||
}
|
||||
if (value.ContainsKey("morphs"))
|
||||
{
|
||||
if (value["morphs"] is not JsonArray morphs || morphs.Count > MaxMorphs) return null;
|
||||
var normalized = new JsonArray();
|
||||
foreach (var node in morphs)
|
||||
{
|
||||
if (node is not JsonObject morph) return null;
|
||||
var id = JsonHelpers.String(morph["id"]);
|
||||
if (id is null || !JsonHelpers.IsHexFormId(id, false, true) || !JsonHelpers.TryDouble(morph["value"], -1000, 1000, out var amount)) return null;
|
||||
normalized.Add(new JsonObject { ["id"] = JsonHelpers.NormalizeFormId(id), ["value"] = amount });
|
||||
}
|
||||
clean["morphs"] = normalized;
|
||||
}
|
||||
if (value.ContainsKey("morphRegions"))
|
||||
{
|
||||
if (value["morphRegions"] is not JsonArray regions || regions.Count > MaxMorphRegions) return null;
|
||||
var normalized = new JsonArray();
|
||||
foreach (var node in regions)
|
||||
{
|
||||
if (!JsonHelpers.TryDouble(node, -1000, 1000, out var amount)) return null;
|
||||
normalized.Add(amount);
|
||||
}
|
||||
clean["morphRegions"] = normalized;
|
||||
}
|
||||
if (value.ContainsKey("facialBoneMorphs"))
|
||||
{
|
||||
if (value["facialBoneMorphs"] is not JsonArray morphs || morphs.Count > MaxFacialBoneMorphs) return null;
|
||||
var normalized = new JsonArray();
|
||||
foreach (var node in morphs)
|
||||
{
|
||||
if (node is not JsonObject morph) return null;
|
||||
var id = JsonHelpers.String(morph["id"]);
|
||||
var position = NormalizeVec3(morph["position"], -10000, 10000);
|
||||
var rotation = NormalizeVec3(morph["rotation"], -10000, 10000);
|
||||
var scale = NormalizeVec3(morph["scale"], -100, 100);
|
||||
if (id is null || !JsonHelpers.IsHexFormId(id, false, true) || position is null || rotation is null || scale is null) return null;
|
||||
normalized.Add(new JsonObject { ["id"] = JsonHelpers.NormalizeFormId(id), ["position"] = position, ["rotation"] = rotation, ["scale"] = scale });
|
||||
}
|
||||
clean["facialBoneMorphs"] = normalized;
|
||||
}
|
||||
if (value.ContainsKey("tints"))
|
||||
{
|
||||
if (value["tints"] is not JsonArray tints || tints.Count > MaxTints) return null;
|
||||
var normalized = new JsonArray();
|
||||
foreach (var node in tints)
|
||||
{
|
||||
if (node is not JsonObject tint || !JsonHelpers.TryUInt32(tint["id"], 0, ushort.MaxValue, out var id) ||
|
||||
!JsonHelpers.TryUInt32(tint["type"], 0, uint.MaxValue, out var type) || !JsonHelpers.TryUInt32(tint["value"], 0, 255, out var amount)) return null;
|
||||
var cleanTint = new JsonObject { ["id"] = id, ["type"] = type, ["value"] = amount };
|
||||
if (tint.ContainsKey("color"))
|
||||
{
|
||||
var color = JsonHelpers.String(tint["color"]);
|
||||
var swatchNode = tint["swatch"] ?? JsonValue.Create(0);
|
||||
if (color is null || !JsonHelpers.IsHexFormId(color, false, true) || !JsonHelpers.TryUInt32(swatchNode, 0, ushort.MaxValue, out var swatch)) return null;
|
||||
cleanTint["color"] = JsonHelpers.NormalizeFormId(color);
|
||||
cleanTint["swatch"] = swatch;
|
||||
}
|
||||
normalized.Add(cleanTint);
|
||||
}
|
||||
clean["tints"] = normalized;
|
||||
}
|
||||
return clean;
|
||||
}
|
||||
|
||||
private static JsonArray? NormalizeVec3(JsonNode? node, double min, double max)
|
||||
{
|
||||
if (node is not JsonArray array || array.Count != 3) return null;
|
||||
var output = new JsonArray();
|
||||
foreach (var component in array)
|
||||
{
|
||||
if (!JsonHelpers.TryDouble(component, min, max, out var value)) return null;
|
||||
output.Add(value);
|
||||
}
|
||||
return output;
|
||||
}
|
||||
|
||||
public static JsonObject? NormalizeTransform(JsonObject packet)
|
||||
{
|
||||
foreach (var field in new[] { "x", "y", "z", "angleZ" })
|
||||
if (!JsonHelpers.TryDouble(packet[field], -ProtocolConstants.MaxAbsCoordinate, ProtocolConstants.MaxAbsCoordinate, out _)) return null;
|
||||
var cell = JsonHelpers.String(packet["cellId"]);
|
||||
var world = JsonHelpers.String(packet["worldspaceId"]) ?? string.Empty;
|
||||
if (cell is null || !JsonHelpers.IsHexFormId(cell, false, false) || !JsonHelpers.IsHexFormId(world, true, true)) return null;
|
||||
var movementType = JsonHelpers.String(packet["movementType"]) ?? "normal";
|
||||
if (!ProtocolConstants.AllowedMovementTypes.Contains(movementType)) return null;
|
||||
var normalized = JsonHelpers.CloneObject(packet);
|
||||
foreach (var field in new[] { "x", "y", "z", "angleZ" }) { JsonHelpers.TryDouble(packet[field], -ProtocolConstants.MaxAbsCoordinate, ProtocolConstants.MaxAbsCoordinate, out var v); normalized[field] = v; }
|
||||
normalized["cellId"] = JsonHelpers.NormalizeFormId(cell);
|
||||
normalized["worldspaceId"] = world.Length == 0 ? string.Empty : JsonHelpers.NormalizeFormId(world);
|
||||
normalized["movementType"] = movementType;
|
||||
foreach (var field in new[] { "movementSpeed", "animationGraphSpeed" })
|
||||
{
|
||||
if (!packet.ContainsKey(field)) continue;
|
||||
var min = field == "animationGraphSpeed" ? -1.0 : 0.0;
|
||||
if (JsonHelpers.TryDouble(packet[field], min, ProtocolConstants.MaxMovementSpeed, out var value)) normalized[field] = value; else normalized.Remove(field);
|
||||
}
|
||||
foreach (var (field, min, max) in new[] { ("animationDirection", -360.0, 360.0), ("aimPitch", -180.0, 180.0), ("turnDelta", -10000.0, 10000.0) })
|
||||
{
|
||||
if (!packet.ContainsKey(field)) continue;
|
||||
if (JsonHelpers.TryDouble(packet[field], min, max, out var value)) normalized[field] = value; else normalized.Remove(field);
|
||||
}
|
||||
foreach (var field in new[] { "isMoving", "isSprinting", "isSneaking", "isJumping", "isCrouching", "weaponDrawn" })
|
||||
if (packet.ContainsKey(field) && JsonHelpers.Boolean(packet[field]) is null) normalized.Remove(field);
|
||||
foreach (var field in new[] { "actorStateFlags1", "actorStateFlags2" })
|
||||
if (packet.ContainsKey(field) && !JsonHelpers.TryUInt32(packet[field], 0, uint.MaxValue, out _)) normalized.Remove(field);
|
||||
if (packet.ContainsKey("actionEvents")) normalized["actionEvents"] = NormalizeActionEvents(packet["actionEvents"], false);
|
||||
return normalized;
|
||||
}
|
||||
|
||||
public static (bool Accepted, string Reason) ValidateMovement(JsonObject? previous, double? previousMonotonic, JsonObject current, double nowMonotonic)
|
||||
{
|
||||
if (previous is null || previousMonotonic is null) return (true, "first transform");
|
||||
var movementType = JsonHelpers.String(current["movementType"]) ?? "normal";
|
||||
if (ProtocolConstants.MovementTransitionTypes.Contains(movementType)) return (true, $"explicit {movementType} transition");
|
||||
if ((JsonHelpers.String(previous["cellId"]) ?? string.Empty) != (JsonHelpers.String(current["cellId"]) ?? string.Empty) ||
|
||||
(JsonHelpers.String(previous["worldspaceId"]) ?? string.Empty) != (JsonHelpers.String(current["worldspaceId"]) ?? string.Empty))
|
||||
return (false, "scope changed without an explicit movement transition");
|
||||
var elapsed = nowMonotonic - previousMonotonic.Value;
|
||||
if (!double.IsFinite(elapsed) || elapsed < 0) elapsed = 0;
|
||||
elapsed = Math.Min(elapsed, ProtocolConstants.MaxMovementValidationElapsedSeconds);
|
||||
JsonHelpers.TryDouble(current["x"], -ProtocolConstants.MaxAbsCoordinate, ProtocolConstants.MaxAbsCoordinate, out var x);
|
||||
JsonHelpers.TryDouble(current["y"], -ProtocolConstants.MaxAbsCoordinate, ProtocolConstants.MaxAbsCoordinate, out var y);
|
||||
JsonHelpers.TryDouble(current["z"], -ProtocolConstants.MaxAbsCoordinate, ProtocolConstants.MaxAbsCoordinate, out var z);
|
||||
JsonHelpers.TryDouble(previous["x"], -ProtocolConstants.MaxAbsCoordinate, ProtocolConstants.MaxAbsCoordinate, out var px);
|
||||
JsonHelpers.TryDouble(previous["y"], -ProtocolConstants.MaxAbsCoordinate, ProtocolConstants.MaxAbsCoordinate, out var py);
|
||||
JsonHelpers.TryDouble(previous["z"], -ProtocolConstants.MaxAbsCoordinate, ProtocolConstants.MaxAbsCoordinate, out var pz);
|
||||
var dx = x - px; var dy = y - py; var dz = z - pz;
|
||||
var distance = Math.Sqrt(dx * dx + dy * dy + dz * dz);
|
||||
var allowed = ProtocolConstants.MovementGraceDistance + ProtocolConstants.MaxNormalMovementSpeed * elapsed;
|
||||
return double.IsFinite(distance) && distance <= allowed ? (true, "normal movement accepted") : (false, $"normal movement exceeded server envelope: distance={distance:F1}, allowed={allowed:F1}, elapsed={elapsed:F3}s");
|
||||
}
|
||||
|
||||
public static JsonObject? NormalizeWorldState(JsonObject packet)
|
||||
{
|
||||
var normalized = JsonHelpers.CloneObject(packet);
|
||||
if (packet.ContainsKey("gameHour")) { if (!JsonHelpers.TryDouble(packet["gameHour"], 0, 24, out var hour)) return null; normalized["gameHour"] = hour; }
|
||||
if (packet.ContainsKey("gameDaysPassed")) { if (!JsonHelpers.TryDouble(packet["gameDaysPassed"], 0, 10_000_000, out var days)) return null; normalized["gameDaysPassed"] = days; }
|
||||
if (packet.ContainsKey("weatherFormId"))
|
||||
{
|
||||
var weather = JsonHelpers.String(packet["weatherFormId"]);
|
||||
if (weather is null || !JsonHelpers.IsHexFormId(weather, true, true)) return null;
|
||||
normalized["weatherFormId"] = weather.Length == 0 ? string.Empty : JsonHelpers.NormalizeFormId(weather);
|
||||
}
|
||||
return normalized;
|
||||
}
|
||||
|
||||
public static JsonObject? NormalizeNpcState(JsonObject packet)
|
||||
{
|
||||
if (packet["npcs"] is not JsonArray npcs || npcs.Count > ProtocolConstants.MaxNpcsPerPacket) return null;
|
||||
var cleanNpcs = new JsonArray();
|
||||
foreach (var node in npcs)
|
||||
{
|
||||
if (node is not JsonObject npc) return null;
|
||||
var source = JsonHelpers.String(npc["sourceFormId"]); var cell = JsonHelpers.String(npc["cellId"]); var world = JsonHelpers.String(npc["worldspaceId"]) ?? string.Empty;
|
||||
if (source is null || cell is null || !JsonHelpers.IsHexFormId(source, false, false) || !JsonHelpers.IsHexFormId(cell, false, false) || !JsonHelpers.IsHexFormId(world, true, true)) return null;
|
||||
foreach (var field in new[] { "x", "y", "z", "angleZ" }) if (!JsonHelpers.TryDouble(npc[field], -ProtocolConstants.MaxAbsCoordinate, ProtocolConstants.MaxAbsCoordinate, out _)) return null;
|
||||
var clean = JsonHelpers.CloneObject(npc);
|
||||
clean["sourceFormId"] = JsonHelpers.NormalizeFormId(source); clean["cellId"] = JsonHelpers.NormalizeFormId(cell); clean["worldspaceId"] = world.Length == 0 ? string.Empty : JsonHelpers.NormalizeFormId(world);
|
||||
foreach (var field in new[] { "x", "y", "z", "angleZ" }) { JsonHelpers.TryDouble(npc[field], -ProtocolConstants.MaxAbsCoordinate, ProtocolConstants.MaxAbsCoordinate, out var v); clean[field] = v; }
|
||||
cleanNpcs.Add(clean);
|
||||
}
|
||||
var normalized = JsonHelpers.CloneObject(packet); normalized["npcs"] = cleanNpcs;
|
||||
if (packet.ContainsKey("authorityEpoch")) { if (!JsonHelpers.TryUInt32(packet["authorityEpoch"], 1, uint.MaxValue, out var epoch)) return null; normalized["authorityEpoch"] = epoch; }
|
||||
if (packet.ContainsKey("authorityCellId")) { var cell = JsonHelpers.String(packet["authorityCellId"]); if (cell is null || !JsonHelpers.IsHexFormId(cell, false, false)) return null; normalized["authorityCellId"] = JsonHelpers.NormalizeFormId(cell); }
|
||||
if (packet.ContainsKey("authorityWorldspaceId")) { var world = JsonHelpers.String(packet["authorityWorldspaceId"]); if (world is null || !JsonHelpers.IsHexFormId(world, true, true)) return null; normalized["authorityWorldspaceId"] = world.Length == 0 ? string.Empty : JsonHelpers.NormalizeFormId(world); }
|
||||
return normalized;
|
||||
}
|
||||
|
||||
public static JsonObject? NormalizeCombatHit(JsonObject packet)
|
||||
{
|
||||
if (!JsonHelpers.TryUInt32(packet["targetPlayerId"], 1, uint.MaxValue, out var target) || !JsonHelpers.TryUInt32(packet["sequence"], 1, uint.MaxValue, out var sequence) || !JsonHelpers.TryDouble(packet["damage"], 0.000001, 10000, out var damage)) return null;
|
||||
var normalized = JsonHelpers.CloneObject(packet); normalized["targetPlayerId"] = target; normalized["sequence"] = sequence; normalized["damage"] = damage;
|
||||
if (packet.ContainsKey("weaponFormId")) { var weapon = JsonHelpers.String(packet["weaponFormId"]); if (weapon is null || !JsonHelpers.IsHexFormId(weapon, false, true)) return null; normalized["weaponFormId"] = JsonHelpers.NormalizeFormId(weapon); }
|
||||
return normalized;
|
||||
}
|
||||
|
||||
public static StateScope? ScopeFromState(JsonObject? state)
|
||||
{
|
||||
if (state is null) return null;
|
||||
var cell = JsonHelpers.String(state["cellId"]); var world = JsonHelpers.String(state["worldspaceId"]) ?? string.Empty;
|
||||
if (cell is null || !JsonHelpers.IsHexFormId(cell, false, false) || !JsonHelpers.IsHexFormId(world, true, true)) return null;
|
||||
if (!JsonHelpers.TryDouble(state["x"], -ProtocolConstants.MaxAbsCoordinate, ProtocolConstants.MaxAbsCoordinate, out var x) || !JsonHelpers.TryDouble(state["y"], -ProtocolConstants.MaxAbsCoordinate, ProtocolConstants.MaxAbsCoordinate, out var y)) return null;
|
||||
return new StateScope(JsonHelpers.NormalizeFormId(cell), world.Length == 0 ? string.Empty : JsonHelpers.NormalizeFormId(world), x, y);
|
||||
}
|
||||
|
||||
public static bool StatesShareInterest(JsonObject? a, JsonObject? b)
|
||||
{
|
||||
var left = ScopeFromState(a); var right = ScopeFromState(b);
|
||||
if (left is null || right is null) return true;
|
||||
if (left.Value.CellId == right.Value.CellId) return true;
|
||||
if (string.IsNullOrEmpty(left.Value.WorldspaceId) || left.Value.WorldspaceId != right.Value.WorldspaceId) return false;
|
||||
var dx = left.Value.X - right.Value.X; var dy = left.Value.Y - right.Value.Y;
|
||||
return Math.Sqrt(dx * dx + dy * dy) <= ProtocolConstants.ExteriorInterestRadius;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,53 @@
|
||||
namespace CommonwealthOnline.Server;
|
||||
|
||||
internal sealed class ServerRuntime : IAsyncDisposable
|
||||
{
|
||||
private readonly ServerOptions _options;
|
||||
private readonly AuthoritativeServer _server;
|
||||
private readonly TcpServerTransport _tcp;
|
||||
private readonly GnsServerTransport? _gns;
|
||||
private readonly AdminControlServer _admin;
|
||||
private readonly LanDiscoveryService _discovery;
|
||||
private int _started;
|
||||
|
||||
public ServerRuntime(ServerOptions options)
|
||||
{
|
||||
_options = options;
|
||||
_server = new AuthoritativeServer(options);
|
||||
_tcp = new TcpServerTransport(options, _server);
|
||||
_gns = options.EnableGnsTransport ? new GnsServerTransport(options, _server) : null;
|
||||
_admin = new AdminControlServer(_server, options);
|
||||
_discovery = new LanDiscoveryService(_server, options);
|
||||
}
|
||||
|
||||
public AuthoritativeServer Server => _server;
|
||||
|
||||
public void Start()
|
||||
{
|
||||
if (Interlocked.Exchange(ref _started, 1) != 0) return;
|
||||
_admin.Start();
|
||||
try
|
||||
{
|
||||
_tcp.Start();
|
||||
_gns?.Start();
|
||||
try { _discovery.Start(); }
|
||||
catch (Exception ex) { _server.Log($"LAN discovery unavailable on UDP {LanDiscoveryService.DiscoveryPort}: {ex.Message}. Direct connections still work.", "warning"); }
|
||||
}
|
||||
catch
|
||||
{
|
||||
DisposeAsync().AsTask().GetAwaiter().GetResult();
|
||||
throw;
|
||||
}
|
||||
_server.Log($"Commonwealth Online server listening on {_options.Host}:{_options.Port}");
|
||||
_server.Log($"Protocol v{ProtocolConstants.ProtocolVersion} negotiation enabled; legacy TCP clients remain temporarily compatible.");
|
||||
}
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
if (_gns is not null) await _gns.DisposeAsync();
|
||||
await _tcp.DisposeAsync();
|
||||
await _discovery.DisposeAsync();
|
||||
await _admin.DisposeAsync();
|
||||
await _server.DisposeAsync();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,76 @@
|
||||
using System.Net.Sockets;
|
||||
using System.Text.Json;
|
||||
using System.Text.Json.Nodes;
|
||||
|
||||
namespace CommonwealthOnline.Server;
|
||||
|
||||
internal sealed class SyntheticProtocolClient : IAsyncDisposable
|
||||
{
|
||||
private readonly TcpClient _client = new();
|
||||
private NetworkStream? _stream;
|
||||
private readonly MemoryStream _buffer = new();
|
||||
|
||||
public uint PlayerId { get; private set; }
|
||||
|
||||
public async Task ConnectAsync(string host, int port, CancellationToken cancellationToken = default)
|
||||
{
|
||||
await _client.ConnectAsync(host, port, cancellationToken).ConfigureAwait(false);
|
||||
_client.NoDelay = true;
|
||||
_stream = _client.GetStream();
|
||||
var welcome = await ReceiveAsync(cancellationToken).ConfigureAwait(false);
|
||||
if (JsonHelpers.String(welcome["type"]) != "welcome") throw new InvalidDataException("Server did not send welcome packet.");
|
||||
await SendAsync(new JsonObject { ["type"] = "hello", ["protocolVersion"] = ProtocolConstants.ProtocolVersion }, cancellationToken).ConfigureAwait(false);
|
||||
while (true)
|
||||
{
|
||||
var packet = await ReceiveAsync(cancellationToken).ConfigureAwait(false);
|
||||
if (JsonHelpers.String(packet["type"]) != "sessionReady") continue;
|
||||
if (!JsonHelpers.TryUInt32(packet["playerId"], 1, uint.MaxValue, out var id)) throw new InvalidDataException("sessionReady did not contain a valid playerId.");
|
||||
PlayerId = id;
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
public async Task SendAsync(JsonObject packet, CancellationToken cancellationToken = default)
|
||||
{
|
||||
if (_stream is null) throw new InvalidOperationException("Client is not connected.");
|
||||
var encoded = JsonSerializer.SerializeToUtf8Bytes(packet);
|
||||
if (encoded.Length > ProtocolConstants.MaxMessageBytes) throw new InvalidDataException("Synthetic packet exceeds maximum message size.");
|
||||
await _stream.WriteAsync(encoded, cancellationToken).ConfigureAwait(false);
|
||||
await _stream.WriteAsync(new byte[] { (byte)'\n' }, cancellationToken).ConfigureAwait(false);
|
||||
}
|
||||
|
||||
public async Task<JsonObject> ReceiveAsync(CancellationToken cancellationToken = default)
|
||||
{
|
||||
if (_stream is null) throw new InvalidOperationException("Client is not connected.");
|
||||
var one = new byte[1];
|
||||
_buffer.SetLength(0);
|
||||
while (_buffer.Length <= ProtocolConstants.MaxMessageBytes)
|
||||
{
|
||||
var count = await _stream.ReadAsync(one, cancellationToken).ConfigureAwait(false);
|
||||
if (count == 0) throw new EndOfStreamException("Server closed the connection.");
|
||||
if (one[0] == (byte)'\n')
|
||||
{
|
||||
var data = _buffer.ToArray();
|
||||
if (data.Length > 0 && data[^1] == (byte)'\r') Array.Resize(ref data, data.Length - 1);
|
||||
return JsonNode.Parse(data) as JsonObject ?? throw new InvalidDataException("Server message was not a JSON object.");
|
||||
}
|
||||
_buffer.WriteByte(one[0]);
|
||||
}
|
||||
throw new InvalidDataException("Server message exceeded maximum size.");
|
||||
}
|
||||
|
||||
public Task SendTransformAsync(double x, double y, double z, string cellId, string worldspaceId = "", string movementType = "normal", CancellationToken cancellationToken = default) =>
|
||||
SendAsync(new JsonObject
|
||||
{
|
||||
["type"] = "transform", ["x"] = x, ["y"] = y, ["z"] = z, ["angleZ"] = 0.0,
|
||||
["cellId"] = cellId, ["worldspaceId"] = worldspaceId, ["movementType"] = movementType
|
||||
}, cancellationToken);
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
try { _stream?.Dispose(); } catch { }
|
||||
try { _client.Dispose(); } catch { }
|
||||
_buffer.Dispose();
|
||||
await ValueTask.CompletedTask;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,169 @@
|
||||
using System.Collections.Concurrent;
|
||||
using System.Net;
|
||||
using System.Net.Sockets;
|
||||
|
||||
namespace CommonwealthOnline.Server;
|
||||
|
||||
internal sealed class TcpGameConnection : IGameConnection
|
||||
{
|
||||
private readonly TcpClient _client;
|
||||
private readonly NetworkStream _stream;
|
||||
private readonly SemaphoreSlim _sendGate = new(1, 1);
|
||||
private int _closed;
|
||||
|
||||
public TcpGameConnection(TcpClient client)
|
||||
{
|
||||
_client = client;
|
||||
_client.NoDelay = true;
|
||||
_stream = client.GetStream();
|
||||
RemoteEndpoint = (IPEndPoint)(_client.Client.RemoteEndPoint ?? throw new InvalidOperationException("TCP remote endpoint missing"));
|
||||
ConnectionKey = $"tcp:{RemoteEndpoint.Address}:{RemoteEndpoint.Port}:{Guid.NewGuid():N}";
|
||||
}
|
||||
|
||||
public string ConnectionKey { get; }
|
||||
public string TransportName => "tcp";
|
||||
public IPEndPoint RemoteEndpoint { get; }
|
||||
public bool IsClosed => Volatile.Read(ref _closed) != 0;
|
||||
internal NetworkStream Stream => _stream;
|
||||
|
||||
public async ValueTask<SendOutcome> SendAsync(EncodedPacket packet, CancellationToken cancellationToken = default)
|
||||
{
|
||||
if (IsClosed) return SendOutcome.NotConnected;
|
||||
if (packet.Payload.Length > ProtocolConstants.MaxMessageBytes) return SendOutcome.TooLarge;
|
||||
if (packet.Payload.AsSpan().IndexOf((byte)'\n') >= 0 || packet.Payload.AsSpan().IndexOf((byte)'\r') >= 0) return SendOutcome.Error;
|
||||
await _sendGate.WaitAsync(cancellationToken).ConfigureAwait(false);
|
||||
try
|
||||
{
|
||||
if (IsClosed) return SendOutcome.NotConnected;
|
||||
await _stream.WriteAsync(packet.Payload, cancellationToken).ConfigureAwait(false);
|
||||
await _stream.WriteAsync(new byte[] { (byte)'\n' }, cancellationToken).ConfigureAwait(false);
|
||||
return SendOutcome.Sent;
|
||||
}
|
||||
catch (Exception ex) when (ex is IOException or SocketException or ObjectDisposedException)
|
||||
{
|
||||
return SendOutcome.NotConnected;
|
||||
}
|
||||
finally { _sendGate.Release(); }
|
||||
}
|
||||
|
||||
public ValueTask DisconnectAsync(int reason, string debug)
|
||||
{
|
||||
if (Interlocked.Exchange(ref _closed, 1) != 0) return ValueTask.CompletedTask;
|
||||
try { _client.Client.Shutdown(SocketShutdown.Both); } catch { }
|
||||
try { _client.Close(); } catch { }
|
||||
return ValueTask.CompletedTask;
|
||||
}
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
await DisconnectAsync(0, "dispose");
|
||||
_sendGate.Dispose();
|
||||
_stream.Dispose();
|
||||
_client.Dispose();
|
||||
}
|
||||
}
|
||||
|
||||
internal sealed class TcpServerTransport : IAsyncDisposable
|
||||
{
|
||||
private readonly ServerOptions _options;
|
||||
private readonly IServerIngress _server;
|
||||
private readonly CancellationTokenSource _shutdown = new();
|
||||
private readonly ConcurrentDictionary<string, Task> _clientTasks = new();
|
||||
private TcpListener? _listener;
|
||||
private Task? _acceptTask;
|
||||
|
||||
public TcpServerTransport(ServerOptions options, IServerIngress server) { _options = options; _server = server; }
|
||||
|
||||
public void Start()
|
||||
{
|
||||
if (_acceptTask is not null) return;
|
||||
if (!ServerOptions.TryResolveIpv4(_options.Host, out var address)) throw new InvalidOperationException($"Could not resolve IPv4 bind host {_options.Host}");
|
||||
_listener = new TcpListener(address, _options.Port);
|
||||
_listener.Start();
|
||||
_acceptTask = Task.Run(() => AcceptLoopAsync(_shutdown.Token));
|
||||
_server.Log($"TCP compatibility transport listening on {_options.Host}:{_options.Port}");
|
||||
}
|
||||
|
||||
private async Task AcceptLoopAsync(CancellationToken cancellationToken)
|
||||
{
|
||||
while (!cancellationToken.IsCancellationRequested)
|
||||
{
|
||||
TcpClient client;
|
||||
try { client = await _listener!.AcceptTcpClientAsync(cancellationToken).ConfigureAwait(false); }
|
||||
catch (OperationCanceledException) { break; }
|
||||
catch (ObjectDisposedException) { break; }
|
||||
catch (SocketException ex)
|
||||
{
|
||||
if (!cancellationToken.IsCancellationRequested) _server.Log($"TCP accept error: {ex.Message}", "warning");
|
||||
continue;
|
||||
}
|
||||
var connection = new TcpGameConnection(client);
|
||||
bool accepted;
|
||||
try { accepted = await _server.AcceptConnectionAsync(connection, cancellationToken).ConfigureAwait(false); }
|
||||
catch (Exception ex)
|
||||
{
|
||||
_server.Log($"TCP admission failed for {connection.RemoteEndpoint}: {ex.Message}", "warning");
|
||||
await connection.DisposeAsync();
|
||||
continue;
|
||||
}
|
||||
if (!accepted) { await connection.DisposeAsync(); continue; }
|
||||
var task = RunClientAsync(connection, cancellationToken);
|
||||
_clientTasks[connection.ConnectionKey] = task;
|
||||
_ = task.ContinueWith(_ => _clientTasks.TryRemove(connection.ConnectionKey, out _), TaskScheduler.Default);
|
||||
}
|
||||
}
|
||||
|
||||
private async Task RunClientAsync(TcpGameConnection connection, CancellationToken cancellationToken)
|
||||
{
|
||||
var readBuffer = new byte[4096];
|
||||
using var message = new MemoryStream(4096);
|
||||
try
|
||||
{
|
||||
while (!cancellationToken.IsCancellationRequested && !connection.IsClosed)
|
||||
{
|
||||
int count;
|
||||
try { count = await connection.Stream.ReadAsync(readBuffer, cancellationToken).ConfigureAwait(false); }
|
||||
catch (OperationCanceledException) { break; }
|
||||
catch (Exception ex) when (ex is IOException or SocketException or ObjectDisposedException) { break; }
|
||||
if (count == 0) break;
|
||||
for (var i = 0; i < count; i++)
|
||||
{
|
||||
var value = readBuffer[i];
|
||||
if (value == (byte)'\n')
|
||||
{
|
||||
var data = message.ToArray();
|
||||
message.SetLength(0);
|
||||
if (data.Length > 0 && data[^1] == (byte)'\r') Array.Resize(ref data, data.Length - 1);
|
||||
if (data.Length == 0) continue;
|
||||
await _server.HandleMessageAsync(connection, data, cancellationToken).ConfigureAwait(false);
|
||||
if (connection.IsClosed) return;
|
||||
}
|
||||
else
|
||||
{
|
||||
message.WriteByte(value);
|
||||
if (message.Length > ProtocolConstants.MaxMessageBytes)
|
||||
{
|
||||
await _server.EndSessionForTransportAsync(connection, "packet_too_large", "Packet exceeded maximum line size.").ConfigureAwait(false);
|
||||
return;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
finally
|
||||
{
|
||||
await _server.HandleConnectionClosedAsync(connection).ConfigureAwait(false);
|
||||
await connection.DisposeAsync();
|
||||
}
|
||||
}
|
||||
|
||||
public async ValueTask DisposeAsync()
|
||||
{
|
||||
_shutdown.Cancel();
|
||||
try { _listener?.Stop(); } catch { }
|
||||
if (_acceptTask is not null) { try { await _acceptTask.ConfigureAwait(false); } catch { } }
|
||||
var tasks = _clientTasks.Values.ToArray();
|
||||
if (tasks.Length > 0) { try { await Task.WhenAll(tasks).WaitAsync(TimeSpan.FromSeconds(2)); } catch { } }
|
||||
_shutdown.Dispose();
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,25 @@
|
||||
using System.Net;
|
||||
|
||||
namespace CommonwealthOnline.Server;
|
||||
|
||||
internal enum SendOutcome { Sent, Dropped, Backpressure, NotConnected, TooLarge, Error }
|
||||
|
||||
internal interface IGameConnection : IAsyncDisposable
|
||||
{
|
||||
string ConnectionKey { get; }
|
||||
string TransportName { get; }
|
||||
IPEndPoint RemoteEndpoint { get; }
|
||||
bool IsClosed { get; }
|
||||
ValueTask<SendOutcome> SendAsync(EncodedPacket packet, CancellationToken cancellationToken = default);
|
||||
ValueTask DisconnectAsync(int reason, string debug);
|
||||
}
|
||||
|
||||
internal interface IServerIngress
|
||||
{
|
||||
Task<bool> AcceptConnectionAsync(IGameConnection connection, CancellationToken cancellationToken);
|
||||
Task HandleMessageAsync(IGameConnection connection, ReadOnlyMemory<byte> payload, CancellationToken cancellationToken);
|
||||
Task HandleConnectionClosedAsync(IGameConnection connection);
|
||||
Task HandleTransportRejectAsync(IGameConnection connection, string reason, bool warning = false);
|
||||
Task EndSessionForTransportAsync(IGameConnection connection, string code, string reason);
|
||||
void Log(string message, string level = "info");
|
||||
}
|
||||
@@ -0,0 +1,14 @@
|
||||
<Project Sdk="Microsoft.NET.Sdk">
|
||||
<PropertyGroup>
|
||||
<OutputType>Exe</OutputType>
|
||||
<TargetFramework>net8.0</TargetFramework>
|
||||
<ImplicitUsings>enable</ImplicitUsings>
|
||||
<Nullable>enable</Nullable>
|
||||
<LangVersion>latest</LangVersion>
|
||||
<AssemblyName>CommonwealthOnline.Server.Tests</AssemblyName>
|
||||
<RootNamespace>CommonwealthOnline.Server.Tests</RootNamespace>
|
||||
</PropertyGroup>
|
||||
<ItemGroup>
|
||||
<ProjectReference Include="../CommonwealthOnline.Server.csproj" />
|
||||
</ItemGroup>
|
||||
</Project>
|
||||
@@ -0,0 +1,349 @@
|
||||
using System.Net;
|
||||
using System.Text;
|
||||
using System.Text.Json.Nodes;
|
||||
using CommonwealthOnline.Server;
|
||||
|
||||
namespace CommonwealthOnline.Server.Tests;
|
||||
|
||||
internal static class Program
|
||||
{
|
||||
private static int _passed;
|
||||
private static int _failed;
|
||||
|
||||
public static async Task<int> Main()
|
||||
{
|
||||
await Run("transport policy", TestTransportPolicy);
|
||||
await Run("packet codec", TestPacketCodec);
|
||||
await Run("snapshot sequence", TestSnapshotSequence);
|
||||
await Run("snapshot envelope", TestSnapshotEnvelope);
|
||||
await Run("player state validation", TestPlayerStateValidation);
|
||||
await Run("npc authority epochs", TestNpcAuthority);
|
||||
await Run("interest filtering", TestInterestFiltering);
|
||||
await Run("config compatibility", TestConfigCompatibility);
|
||||
await Run("ban persistence", TestBanStore);
|
||||
await Run("authoritative server ids and interest", TestAuthoritativeServer);
|
||||
await Run("durable player state relay", TestPlayerStateRelay);
|
||||
await Run("npc authority validation", TestNpcAuthorityIntegration);
|
||||
await Run("combat interest routing", TestCombatInterest);
|
||||
|
||||
Console.WriteLine($"C# server tests: {_passed} passed, {_failed} failed");
|
||||
return _failed == 0 ? 0 : 1;
|
||||
}
|
||||
|
||||
private static async Task Run(string name, Func<Task> test)
|
||||
{
|
||||
try { await test(); _passed++; Console.WriteLine($"PASS {name}"); }
|
||||
catch (Exception ex) { _failed++; Console.Error.WriteLine($"FAIL {name}: {ex.Message}"); }
|
||||
}
|
||||
|
||||
private static Task TestTransportPolicy()
|
||||
{
|
||||
Equal(Delivery.UnreliableSequenced, TransportPolicy.ForPacketType("transform"));
|
||||
Equal(Delivery.UnreliableSequenced, TransportPolicy.ForPacketType("npcState"));
|
||||
Equal(Delivery.ReliableOrdered, TransportPolicy.ForPacketType("playerState"));
|
||||
Equal(Delivery.ReliableOrdered, TransportPolicy.ForPacketType("futureControl"));
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
private static Task TestPacketCodec()
|
||||
{
|
||||
var packet = new JsonObject { ["type"] = "playerState", ["characterName"] = "Nomad" };
|
||||
var encoded = PacketCodec.Encode(packet);
|
||||
Equal("playerState", encoded.PacketType);
|
||||
Equal(Delivery.ReliableOrdered, encoded.Delivery);
|
||||
var decoded = PacketCodec.Decode(encoded.Payload);
|
||||
Equal("Nomad", JsonHelpers.String(decoded["characterName"]));
|
||||
Throws<PacketCodecException>(() => PacketCodec.Encode(new JsonObject { ["type"] = "x", ["blob"] = new string('a', ProtocolConstants.MaxMessageBytes + 1) }));
|
||||
Throws<PacketCodecException>(() => PacketCodec.Decode("[]"u8));
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
private static Task TestSnapshotSequence()
|
||||
{
|
||||
var window = new SequenceWindow();
|
||||
True(window.Accept(1));
|
||||
True(window.Accept(3));
|
||||
False(window.Accept(2));
|
||||
False(window.Accept(3));
|
||||
True(SequenceWindow.IsNewer(1, uint.MaxValue));
|
||||
var counter = new SequenceCounter();
|
||||
Equal(1u, counter.Advance());
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
private static Task TestSnapshotEnvelope()
|
||||
{
|
||||
var payload = Encoding.UTF8.GetBytes("{\"type\":\"transform\"}");
|
||||
var wire = GnsSnapshotEnvelope.Encode("transform", payload, 7);
|
||||
Equal(ProtocolConstants.MaxMessageBytes >= wire.Length, true);
|
||||
True(GnsSnapshotEnvelope.TryDecode(wire, out var envelope, out var error));
|
||||
Equal<string?>(null, error);
|
||||
Equal("transform", envelope.PacketType);
|
||||
Equal(7u, envelope.Sequence);
|
||||
SequenceEqual(payload, envelope.Payload);
|
||||
False(GnsSnapshotEnvelope.TryDecode(payload, out _, out _));
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
private static Task TestPlayerStateValidation()
|
||||
{
|
||||
var state = new JsonObject
|
||||
{
|
||||
["type"] = "playerState",
|
||||
["characterName"] = "Nomad",
|
||||
["equippedItems"] = new JsonArray(new JsonObject { ["slot"] = "RightHand", ["formId"] = "ABC" }),
|
||||
["appearance"] = new JsonObject
|
||||
{
|
||||
["version"] = 4,
|
||||
["raceFormId"] = "13746",
|
||||
["hairColorFormId"] = "123",
|
||||
["facialHairColorFormId"] = "124",
|
||||
["complexionFormId"] = "125",
|
||||
["height"] = 1.0,
|
||||
["isFemale"] = false,
|
||||
["morphWeight"] = new JsonObject { ["thin"] = 0.0, ["muscular"] = 0.0, ["large"] = 0.0 },
|
||||
["bodyTintColor"] = new JsonObject { ["r"] = 255, ["g"] = 255, ["b"] = 255, ["a"] = 255 }
|
||||
},
|
||||
["actionEvents"] = new JsonArray(new JsonObject { ["sequence"] = 1, ["type"] = 3, ["eventName"] = "fireSingle" })
|
||||
};
|
||||
var normalized = ProtocolValidation.NormalizePlayerState(state);
|
||||
NotNull(normalized);
|
||||
Equal("00000123", JsonHelpers.String(((JsonObject)normalized!["appearance"]!)["hairColorFormId"]));
|
||||
var bad = (JsonObject)state.DeepClone();
|
||||
((JsonArray)bad["actionEvents"]!)[0]!["eventName"] = "bogus";
|
||||
Equal<JsonObject?>(null, ProtocolValidation.NormalizePlayerState(bad));
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
private static Task TestNpcAuthority()
|
||||
{
|
||||
var manager = new NpcAuthorityManager();
|
||||
var scope = new ScopeKey("00000001", "");
|
||||
var changes = manager.Reconcile(new[] { (2u, scope), (1u, scope) });
|
||||
Equal(1, changes.Count);
|
||||
Equal(1u, changes[0].PlayerId);
|
||||
Equal(1u, changes[0].Epoch);
|
||||
True(manager.Authorize(1, scope, 1));
|
||||
changes = manager.Reconcile(Array.Empty<(uint, ScopeKey)>());
|
||||
Equal(2u, changes[0].Epoch);
|
||||
changes = manager.Reconcile(new[] { (3u, scope) });
|
||||
Equal(3u, changes[0].Epoch);
|
||||
False(manager.Authorize(1, scope, 1));
|
||||
True(manager.Authorize(3, scope, 3));
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
private static Task TestInterestFiltering()
|
||||
{
|
||||
var a = Transform("00000001", "000000AA", 0, 0);
|
||||
var sameCell = Transform("00000001", "000000BB", 999999, 999999);
|
||||
var near = Transform("00000002", "000000AA", 1000, 1000);
|
||||
var far = Transform("00000003", "000000AA", 20000, 0);
|
||||
var otherWorld = Transform("00000004", "000000BB", 0, 0);
|
||||
True(ProtocolValidation.StatesShareInterest(a, sameCell));
|
||||
True(ProtocolValidation.StatesShareInterest(a, near));
|
||||
False(ProtocolValidation.StatesShareInterest(a, far));
|
||||
False(ProtocolValidation.StatesShareInterest(a, otherWorld));
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
private static Task TestConfigCompatibility()
|
||||
{
|
||||
var dir = TempDir();
|
||||
try
|
||||
{
|
||||
var path = Path.Combine(dir, "commonwealth-server.json");
|
||||
File.WriteAllText(path, "{\"host\":\"0.0.0.0\",\"port\":7777,\"max_players\":16,\"admin_port\":7779,\"enable_gns_transport\":\"false\"}");
|
||||
var options = ServerOptions.Load(path);
|
||||
False(options.EnableGnsTransport);
|
||||
Equal(7777, options.Port);
|
||||
Equal(0, options.Validate().Count);
|
||||
}
|
||||
finally { Directory.Delete(dir, true); }
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
private static Task TestBanStore()
|
||||
{
|
||||
var dir = TempDir();
|
||||
try
|
||||
{
|
||||
var path = Path.Combine(dir, "bans.json");
|
||||
var store = new BanStore(path);
|
||||
store.Ban("127.0.0.1", "test");
|
||||
var reloaded = new BanStore(path);
|
||||
Equal("test", reloaded.GetBan("127.0.0.1")?.Reason);
|
||||
True(reloaded.Unban("127.0.0.1"));
|
||||
Equal(0, new BanStore(path).List().Count);
|
||||
}
|
||||
finally { Directory.Delete(dir, true); }
|
||||
return Task.CompletedTask;
|
||||
}
|
||||
|
||||
private static async Task TestAuthoritativeServer()
|
||||
{
|
||||
var fixture = CreateServerFixture();
|
||||
await using var server = fixture.Server;
|
||||
var a = new MemoryConnection("a", 31001);
|
||||
var b = new MemoryConnection("b", 31002);
|
||||
True(await server.AcceptConnectionAsync(a, CancellationToken.None));
|
||||
True(await server.AcceptConnectionAsync(b, CancellationToken.None));
|
||||
await Send(server, a, new JsonObject { ["type"] = "hello", ["protocolVersion"] = 2 });
|
||||
await Send(server, b, new JsonObject { ["type"] = "hello", ["protocolVersion"] = 2 });
|
||||
var aId = ReadyId(a); var bId = ReadyId(b);
|
||||
True(aId != bId);
|
||||
|
||||
await Send(server, a, Transform("00000001", "000000AA", 0, 0, "spawn"));
|
||||
await Send(server, b, Transform("00000002", "000000BB", 0, 0, "spawn"));
|
||||
a.Clear(); b.Clear();
|
||||
await Send(server, a, Transform("00000001", "000000AA", 1, 0));
|
||||
False(b.SentPackets.Any(p => JsonHelpers.String(p["type"]) == "transform" && JsonHelpers.TryUInt32(p["playerId"], 1, uint.MaxValue, out var id) && id == aId));
|
||||
}
|
||||
|
||||
private static async Task TestPlayerStateRelay()
|
||||
{
|
||||
var fixture = CreateServerFixture();
|
||||
await using var server = fixture.Server;
|
||||
var a = new MemoryConnection("a", 32001); var b = new MemoryConnection("b", 32002);
|
||||
await Activate(server, a, b);
|
||||
await Send(server, a, Transform("00000001", "000000AA", 0, 0, "spawn"));
|
||||
await Send(server, b, Transform("00000002", "000000BB", 0, 0, "spawn"));
|
||||
a.Clear(); b.Clear();
|
||||
await Send(server, a, new JsonObject
|
||||
{
|
||||
["type"] = "playerState",
|
||||
["characterName"] = "Nomad",
|
||||
["actionEvents"] = new JsonArray(new JsonObject { ["sequence"] = 1, ["type"] = 3, ["eventName"] = "fireSingle" })
|
||||
});
|
||||
var relay = b.SentPackets.Single(p => JsonHelpers.String(p["type"]) == "playerState");
|
||||
Equal("Nomad", JsonHelpers.String(relay["characterName"]));
|
||||
False(relay.ContainsKey("actionEvents"));
|
||||
}
|
||||
|
||||
private static async Task TestNpcAuthorityIntegration()
|
||||
{
|
||||
var fixture = CreateServerFixture();
|
||||
await using var server = fixture.Server;
|
||||
var a = new MemoryConnection("a", 33001);
|
||||
True(await server.AcceptConnectionAsync(a, CancellationToken.None));
|
||||
await Send(server, a, new JsonObject { ["type"] = "hello", ["protocolVersion"] = 2 });
|
||||
await Send(server, a, Transform("00000010", "", 0, 0, "spawn"));
|
||||
var authority = a.SentPackets.Last(p => JsonHelpers.String(p["type"]) == "npcAuthority");
|
||||
JsonHelpers.TryUInt32(authority["authorityEpoch"], 1, uint.MaxValue, out var epoch);
|
||||
a.Clear();
|
||||
await Send(server, a, new JsonObject
|
||||
{
|
||||
["type"] = "npcState",
|
||||
["authorityEpoch"] = epoch,
|
||||
["authorityCellId"] = "00000010",
|
||||
["authorityWorldspaceId"] = "",
|
||||
["npcs"] = new JsonArray(new JsonObject
|
||||
{
|
||||
["sourceFormId"] = "00000020", ["cellId"] = "00000010", ["worldspaceId"] = "",
|
||||
["x"] = 1.0, ["y"] = 2.0, ["z"] = 3.0, ["angleZ"] = 0.0
|
||||
})
|
||||
});
|
||||
var stats = server.GetCoreStats();
|
||||
True(JsonHelpers.TryUInt32(stats["npcStatePacketsReceived"], 0, uint.MaxValue, out var received) && received == 1);
|
||||
await Send(server, a, new JsonObject
|
||||
{
|
||||
["type"] = "npcState", ["authorityEpoch"] = Math.Max(1u, epoch - 1), ["authorityCellId"] = "00000010", ["authorityWorldspaceId"] = "",
|
||||
["npcs"] = new JsonArray()
|
||||
});
|
||||
stats = server.GetCoreStats();
|
||||
True(JsonHelpers.TryUInt32(stats["npcAuthorityRejects"], 0, uint.MaxValue, out var rejects) && rejects >= 1);
|
||||
}
|
||||
|
||||
private static async Task TestCombatInterest()
|
||||
{
|
||||
var fixture = CreateServerFixture();
|
||||
await using var server = fixture.Server;
|
||||
var a = new MemoryConnection("a", 34001); var b = new MemoryConnection("b", 34002);
|
||||
await Activate(server, a, b);
|
||||
var bId = ReadyId(b);
|
||||
await Send(server, a, Transform("00000100", "000000AA", 0, 0, "spawn"));
|
||||
await Send(server, b, Transform("00000200", "000000BB", 0, 0, "spawn"));
|
||||
a.Clear(); b.Clear();
|
||||
await Send(server, a, new JsonObject { ["type"] = "combatHit", ["targetPlayerId"] = bId, ["sequence"] = 1, ["damage"] = 10.0 });
|
||||
False(b.SentPackets.Any(p => JsonHelpers.String(p["type"]) == "combatHit"));
|
||||
var stats = server.GetCoreStats();
|
||||
True(JsonHelpers.TryUInt32(stats["packetsRejected"], 0, uint.MaxValue, out var rejected) && rejected >= 1);
|
||||
}
|
||||
|
||||
private static (AuthoritativeServer Server, string Dir) CreateServerFixture()
|
||||
{
|
||||
var dir = TempDir();
|
||||
var path = Path.Combine(dir, "commonwealth-server.json");
|
||||
var options = new ServerOptions { ConfigPath = path, Host = "127.0.0.1", Port = 7777, AdminPort = 7779, MaxPlayers = 32 };
|
||||
return (new AuthoritativeServer(options), dir);
|
||||
}
|
||||
|
||||
private static async Task Activate(AuthoritativeServer server, params MemoryConnection[] connections)
|
||||
{
|
||||
foreach (var connection in connections)
|
||||
{
|
||||
True(await server.AcceptConnectionAsync(connection, CancellationToken.None));
|
||||
await Send(server, connection, new JsonObject { ["type"] = "hello", ["protocolVersion"] = 2 });
|
||||
}
|
||||
}
|
||||
|
||||
private static uint ReadyId(MemoryConnection connection)
|
||||
{
|
||||
var ready = connection.SentPackets.Last(p => JsonHelpers.String(p["type"]) == "sessionReady");
|
||||
True(JsonHelpers.TryUInt32(ready["playerId"], 1, uint.MaxValue, out var id));
|
||||
return id;
|
||||
}
|
||||
|
||||
private static Task Send(AuthoritativeServer server, MemoryConnection connection, JsonObject packet) =>
|
||||
server.HandleMessageAsync(connection, PacketCodec.Encode(packet).Payload, CancellationToken.None);
|
||||
|
||||
private static JsonObject Transform(string cell, string world, double x, double y, string movement = "normal") => new()
|
||||
{
|
||||
["type"] = "transform", ["x"] = x, ["y"] = y, ["z"] = 0.0, ["angleZ"] = 0.0,
|
||||
["cellId"] = cell, ["worldspaceId"] = world, ["movementType"] = movement
|
||||
};
|
||||
|
||||
private static string TempDir()
|
||||
{
|
||||
var path = Path.Combine(Path.GetTempPath(), "co-csharp-tests-" + Guid.NewGuid().ToString("N"));
|
||||
Directory.CreateDirectory(path);
|
||||
return path;
|
||||
}
|
||||
|
||||
private static void True(bool value) { if (!value) throw new Exception("expected true"); }
|
||||
private static void False(bool value) { if (value) throw new Exception("expected false"); }
|
||||
private static void NotNull(object? value) { if (value is null) throw new Exception("expected non-null"); }
|
||||
private static void Equal<T>(T expected, T actual) where T : notnull { if (!EqualityComparer<T>.Default.Equals(expected, actual)) throw new Exception($"expected {expected}, got {actual}"); }
|
||||
private static void SequenceEqual(byte[] expected, byte[] actual) { if (!expected.AsSpan().SequenceEqual(actual)) throw new Exception("byte sequences differ"); }
|
||||
private static void Throws<T>(Action action) where T : Exception { try { action(); } catch (T) { return; } throw new Exception($"expected {typeof(T).Name}"); }
|
||||
|
||||
private sealed class MemoryConnection : IGameConnection
|
||||
{
|
||||
private readonly object _gate = new();
|
||||
private readonly List<JsonObject> _sent = new();
|
||||
private int _closed;
|
||||
|
||||
public MemoryConnection(string name, int port)
|
||||
{
|
||||
ConnectionKey = "memory:" + name;
|
||||
RemoteEndpoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), port);
|
||||
}
|
||||
|
||||
public string ConnectionKey { get; }
|
||||
public string TransportName => "memory";
|
||||
public IPEndPoint RemoteEndpoint { get; }
|
||||
public bool IsClosed => Volatile.Read(ref _closed) != 0;
|
||||
public IReadOnlyList<JsonObject> SentPackets { get { lock (_gate) return _sent.Select(JsonHelpers.CloneObject).ToArray(); } }
|
||||
|
||||
public ValueTask<SendOutcome> SendAsync(EncodedPacket packet, CancellationToken cancellationToken = default)
|
||||
{
|
||||
if (IsClosed) return ValueTask.FromResult(SendOutcome.NotConnected);
|
||||
lock (_gate) _sent.Add(PacketCodec.Decode(packet.Payload));
|
||||
return ValueTask.FromResult(SendOutcome.Sent);
|
||||
}
|
||||
|
||||
public ValueTask DisconnectAsync(int reason, string debug) { Interlocked.Exchange(ref _closed, 1); return ValueTask.CompletedTask; }
|
||||
public ValueTask DisposeAsync() => DisconnectAsync(0, "dispose");
|
||||
public void Clear() { lock (_gate) _sent.Clear(); }
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user