272 lines
10 KiB
C#
272 lines
10 KiB
C#
using System.Net.WebSockets;
|
|
using System.Text;
|
|
using Microsoft.Extensions.Logging;
|
|
using SVSim.BattleNode.Lifecycle;
|
|
using SVSim.BattleNode.Protocol;
|
|
using SVSim.BattleNode.Reliability;
|
|
using SVSim.BattleNode.Wire;
|
|
|
|
namespace SVSim.BattleNode.Sessions;
|
|
|
|
/// <summary>
|
|
/// One per connected client. Owns the WebSocket + reliability ledgers + lifecycle phase.
|
|
/// </summary>
|
|
public sealed class BattleSession
|
|
{
|
|
private readonly WebSocket _ws;
|
|
private readonly ILogger<BattleSession> _log;
|
|
|
|
public string BattleId { get; }
|
|
public long ViewerId { get; }
|
|
public BattleSessionPhase Phase { get; internal set; } = BattleSessionPhase.AwaitingInitNetwork;
|
|
public InboundTracker Inbound { get; } = new();
|
|
public OutboundSequencer Outbound { get; } = new();
|
|
|
|
public BattleSession(WebSocket ws, string battleId, long viewerId, ILogger<BattleSession> log)
|
|
{
|
|
_ws = ws;
|
|
_log = log;
|
|
BattleId = battleId;
|
|
ViewerId = viewerId;
|
|
}
|
|
|
|
/// <summary>
|
|
/// Send the EIO3 open handshake then enter the read loop. Returns when the WS closes.
|
|
/// Dispatch is a no-op in this task; Task 13 fills it in.
|
|
/// </summary>
|
|
public async Task RunAsync(CancellationToken cancellation)
|
|
{
|
|
await SendEioOpenAsync(cancellation);
|
|
|
|
var buffer = new byte[8192];
|
|
var pendingAttachments = new List<byte[]>();
|
|
SocketIoFrame? pendingFrame = null;
|
|
|
|
while (_ws.State == WebSocketState.Open && !cancellation.IsCancellationRequested)
|
|
{
|
|
var msg = await ReadCompleteMessageAsync(buffer, cancellation);
|
|
if (msg is null) break;
|
|
|
|
if (msg.Value.IsText)
|
|
{
|
|
var text = Encoding.UTF8.GetString(msg.Value.Bytes);
|
|
if (text.Length == 0) continue;
|
|
var eio = EngineIoFrame.Parse(text);
|
|
if (eio.Type == EngineIoPacketType.Ping)
|
|
{
|
|
await SendTextAsync("3", cancellation); // EIO3 pong
|
|
continue;
|
|
}
|
|
if (eio.Type != EngineIoPacketType.Message) continue;
|
|
|
|
// SIO inside the message payload.
|
|
var sio = SocketIoFrame.Parse(eio.Payload);
|
|
if (sio.AttachmentCount > 0)
|
|
{
|
|
pendingFrame = sio;
|
|
pendingAttachments.Clear();
|
|
continue;
|
|
}
|
|
DispatchSocketIo(sio);
|
|
}
|
|
else
|
|
{
|
|
// Binary frame — an attachment for a pending binary event.
|
|
pendingAttachments.Add(msg.Value.Bytes);
|
|
if (pendingFrame is not null && pendingAttachments.Count == pendingFrame.AttachmentCount)
|
|
{
|
|
var assembled = pendingFrame.WithAttachments(pendingAttachments.ToArray());
|
|
pendingFrame = null;
|
|
DispatchSocketIo(assembled);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
private async void DispatchSocketIo(SocketIoFrame frame)
|
|
{
|
|
if (frame.Type is SocketIoPacketType.Event or SocketIoPacketType.BinaryEvent)
|
|
{
|
|
switch (frame.EventName)
|
|
{
|
|
case "msg" when frame.BinaryAttachments.Count == 1:
|
|
await HandleMsgEventAsync(frame);
|
|
return;
|
|
case "alive" when frame.BinaryAttachments.Count == 1:
|
|
await HandleAliveEventAsync(frame);
|
|
return;
|
|
}
|
|
}
|
|
// hand / unknown events: log and drop.
|
|
_log.LogDebug("BattleSession {Bid}: dropping SIO event={Event}", BattleId, frame.EventName);
|
|
}
|
|
|
|
private async Task HandleMsgEventAsync(SocketIoFrame frame)
|
|
{
|
|
MsgEnvelope env;
|
|
try { env = MsgPayloadCodec.Decode(frame.BinaryAttachments[0]); }
|
|
catch (Exception ex)
|
|
{
|
|
_log.LogWarning(ex, "BattleSession {Bid}: failed to decode msg envelope", BattleId);
|
|
return;
|
|
}
|
|
|
|
// Ack tracking + dedupe.
|
|
bool shouldDispatch = true;
|
|
if (env.PubSeq.HasValue)
|
|
{
|
|
shouldDispatch = Inbound.Observe(env.PubSeq.Value);
|
|
if (frame.AckId.HasValue)
|
|
{
|
|
await SendSioAckAsync(frame.AckId.Value, (int)env.PubSeq.Value);
|
|
}
|
|
}
|
|
if (!shouldDispatch) return;
|
|
|
|
// Run the pure-logic decision and drive sends.
|
|
var responses = ComputeResponses(env);
|
|
foreach (var (responseEnv, noStock) in responses)
|
|
{
|
|
if (noStock)
|
|
await PushNoStockAsync(responseEnv);
|
|
else
|
|
await PushOrderedAsync(responseEnv);
|
|
}
|
|
}
|
|
|
|
private async Task HandleAliveEventAsync(SocketIoFrame frame)
|
|
{
|
|
// Client emits Gungnir every 5s with an SIO ack callback expecting just liveness confirmation
|
|
// (payload ignored). We ack immediately, then push our own alive back with scs/ocs ONLINE
|
|
// placeholders — the only response the client uses to drive its scs/ocs state machine.
|
|
if (frame.AckId.HasValue)
|
|
{
|
|
await SendSioAckAsync(frame.AckId.Value, 0);
|
|
}
|
|
var aliveEnv = new MsgEnvelope(
|
|
Uri: NetworkBattleUri.Gungnir,
|
|
ViewerId: ScriptedLifecycle.FakeOpponentViewerId,
|
|
Uuid: "node-stub",
|
|
Bid: null,
|
|
Try: 0,
|
|
Cat: EmitCategory.General,
|
|
PubSeq: null,
|
|
PlaySeq: null,
|
|
Body: Gungnir.BuildAlivePushBody());
|
|
await PushNoStockAsync(aliveEnv, eventName: "alive");
|
|
}
|
|
|
|
internal IReadOnlyList<(MsgEnvelope Envelope, bool NoStock)> ComputeResponses(MsgEnvelope env)
|
|
{
|
|
var result = new List<(MsgEnvelope Envelope, bool NoStock)>();
|
|
switch (env.Uri)
|
|
{
|
|
case NetworkBattleUri.InitNetwork:
|
|
result.Add((BuildAckedEnvelope(NetworkBattleUri.InitNetwork), NoStock: true));
|
|
result.Add((ScriptedLifecycle.BuildMatched(ViewerId, ScriptedLifecycle.FakeOpponentViewerId, BattleId), NoStock: false));
|
|
result.Add((ScriptedLifecycle.BuildBattleStart(ViewerId), NoStock: false));
|
|
Phase = BattleSessionPhase.AwaitingLoaded;
|
|
break;
|
|
case NetworkBattleUri.Loaded:
|
|
result.Add((ScriptedLifecycle.BuildDeal(), NoStock: false));
|
|
Phase = BattleSessionPhase.AwaitingSwap;
|
|
break;
|
|
case NetworkBattleUri.Swap:
|
|
result.Add((ScriptedLifecycle.BuildSwapResponse(ExtractIdxList(env)), NoStock: false));
|
|
result.Add((ScriptedLifecycle.BuildReady(), NoStock: false));
|
|
Phase = BattleSessionPhase.AfterReady;
|
|
break;
|
|
case NetworkBattleUri.Retire:
|
|
case NetworkBattleUri.Kill:
|
|
result.Add((BuildBattleFinishNoContest(), NoStock: true));
|
|
Phase = BattleSessionPhase.Terminal;
|
|
break;
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private MsgEnvelope BuildAckedEnvelope(NetworkBattleUri uri) => new(
|
|
uri,
|
|
ViewerId: ScriptedLifecycle.FakeOpponentViewerId,
|
|
Uuid: "node-stub",
|
|
Bid: null,
|
|
Try: 0,
|
|
Cat: EmitCategory.General,
|
|
PubSeq: null,
|
|
PlaySeq: null,
|
|
Body: new Dictionary<string, object?> { ["resultCode"] = 1 });
|
|
|
|
private MsgEnvelope BuildBattleFinishNoContest() => new(
|
|
NetworkBattleUri.BattleFinish,
|
|
ViewerId: ScriptedLifecycle.FakeOpponentViewerId,
|
|
Uuid: "node-stub",
|
|
Bid: null,
|
|
Try: 0,
|
|
Cat: EmitCategory.Battle,
|
|
PubSeq: null,
|
|
PlaySeq: null,
|
|
Body: new Dictionary<string, object?> { ["result"] = 1, ["resultCode"] = 1 });
|
|
|
|
private static IReadOnlyList<long> ExtractIdxList(MsgEnvelope env)
|
|
{
|
|
if (env.Body.TryGetValue("idxList", out var raw) && raw is List<object?> lst)
|
|
return lst.OfType<long>().ToList();
|
|
return Array.Empty<long>();
|
|
}
|
|
|
|
private Task PushOrderedAsync(MsgEnvelope env, string eventName = "synchronize") =>
|
|
EncodeAndSendAsync(Outbound.AssignAndArchive(env), eventName);
|
|
|
|
private Task PushNoStockAsync(MsgEnvelope env, string eventName = "synchronize") =>
|
|
EncodeAndSendAsync(Outbound.WrapNoStock(env), eventName);
|
|
|
|
private async Task EncodeAndSendAsync(MsgEnvelope env, string eventName)
|
|
{
|
|
var seq = 0;
|
|
var key = NodeCrypto.GenerateKey(() => (seq++ * 11) % 16);
|
|
var bytes = MsgPayloadCodec.Encode(env, key);
|
|
var sio = SocketIoFrame.BinaryEventWithAttachments(eventName, new[] { bytes });
|
|
var (text, bins) = sio.Encode();
|
|
var eioText = $"{(int)EngineIoPacketType.Message}{text}";
|
|
await SendTextAsync(eioText, CancellationToken.None);
|
|
foreach (var bin in bins)
|
|
await _ws.SendAsync(bin, WebSocketMessageType.Binary, endOfMessage: true, CancellationToken.None);
|
|
}
|
|
|
|
private async Task SendSioAckAsync(int ackId, int arg)
|
|
{
|
|
var ack = SocketIoFrame.AckResponse(ackId, arg);
|
|
var (text, _) = ack.Encode();
|
|
var eioText = $"{(int)EngineIoPacketType.Message}{text}";
|
|
await SendTextAsync(eioText, CancellationToken.None);
|
|
}
|
|
|
|
private async Task SendEioOpenAsync(CancellationToken ct)
|
|
{
|
|
var sid = Guid.NewGuid().ToString("N").Substring(0, 16);
|
|
var handshake = new EngineIoHandshake(sid, Array.Empty<string>(), 25000, 60000).ToJson();
|
|
await SendTextAsync($"0{handshake}", ct);
|
|
}
|
|
|
|
private Task SendTextAsync(string text, CancellationToken ct)
|
|
{
|
|
var bytes = Encoding.UTF8.GetBytes(text);
|
|
return _ws.SendAsync(bytes, WebSocketMessageType.Text, endOfMessage: true, ct);
|
|
}
|
|
|
|
private async Task<(byte[] Bytes, bool IsText)?> ReadCompleteMessageAsync(byte[] buffer, CancellationToken ct)
|
|
{
|
|
using var ms = new MemoryStream();
|
|
WebSocketReceiveResult result;
|
|
do
|
|
{
|
|
try { result = await _ws.ReceiveAsync(buffer, ct); }
|
|
catch (OperationCanceledException) { return null; }
|
|
catch (WebSocketException) { return null; }
|
|
if (result.MessageType == WebSocketMessageType.Close) return null;
|
|
ms.Write(buffer, 0, result.Count);
|
|
} while (!result.EndOfMessage);
|
|
return (ms.ToArray(), result.MessageType == WebSocketMessageType.Text);
|
|
}
|
|
}
|