Files
Rail_Enterprise/client/ViaFerrea.Client/scripts/Net/GameSession.cs
T
Claude ebf6163a4b F5: client con i pannelli Industrie, Compagnie e borsa e la Cronaca finale
- Pannello «Industrie»: elenco, scheda del proprietario con condizione, resa degli impianti,
  fermi, ricambi e macchinari, budget, ricambi da ordinare, fermo programmato, ammodernamento
  e acquisto al prezzo chiesto.
- Pannello a tutto schermo «Compagnie e borsa»: listino, offerte con difese, scheda della
  compagnia con libro dei soci e storico, compravendita, quotazione, dividendi, riacquisto,
  offerte pubbliche, fusione, aste; banner dell'amministrazione controllata.
- Cronaca finale e provvisoria, modalità osservatore.
- Tema applicato a ogni radice dell'interfaccia (prima non arrivava ai controlli), menu e
  connessione a tutta finestra, barra degli strumenti scorrevole; 228 nuove chiavi it/en.
- Schermate docs/screenshots/f5-*.jpg dal pilota automatico.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0191R7vXgtbAvSV4V8tj8uzL
2026-10-12 10:57:19 +00:00

149 lines
5.0 KiB
C#

using Godot;
using ViaFerrea.Core.Commands;
using ViaFerrea.Core.Data;
using ViaFerrea.Protocol;
using ViaFerrea.Protocol.Client;
using ViaFerrea.Protocol.Messages;
namespace ViaFerrea.Client.Net;
/// <summary>
/// Sessione di gioco del client: connessione, copia locale del mondo, esiti dei comandi e
/// notifiche. I messaggi si applicano sul thread principale in <see cref="Poll"/>.
/// </summary>
public sealed class GameSession : IAsyncDisposable
{
private readonly Dictionary<uint, Action<CommandResultMessage>> _callbacks = [];
private long _pingSentMs;
private ulong _pingNonce;
public ProtocolClient Connection { get; }
public ClientWorld World { get; }
public string ServerLabel { get; }
/// <summary>Preset di difficoltà della partita (dal Welcome; serve a «Nuova partita+»).</summary>
public string Difficulty { get; private set; } = "";
public LocalServerLauncher? LocalServer { get; set; }
/// <summary>Istante di arrivo (ms) dell'ultimo moto di ogni treno, per l'interpolazione.</summary>
public Dictionary<int, long> MotionReceivedMs { get; } = [];
/// <summary>Ritardo di andata e ritorno dell'ultimo ping (ms).</summary>
public double LatencyMs { get; private set; }
public event Action<IMessage>? MessageApplied;
public event Action<EventInfo>? Notified;
public event Action<CommandResultMessage>? CommandFailed;
private GameSession(ProtocolClient connection, ClientWorld world, string label)
{
Connection = connection;
World = world;
ServerLabel = label;
}
public static async Task<GameSession> ConnectAsync(GameData data, Uri uri, string token, string label, CancellationToken ct = default)
{
var connection = await ProtocolClient.ConnectAsync(uri, ct);
try
{
var welcome = await connection.HandshakeAsync(new Hello
{
ClientVersion = typeof(GameSession).Assembly.GetName().Version?.ToString() ?? "0",
Token = token,
DataHash = data.Hash,
}, ct);
var world = new ClientWorld(data);
world.Apply(welcome);
return new GameSession(connection, world, label) { Difficulty = welcome.Difficulty };
}
catch
{
await connection.DisposeAsync();
throw;
}
}
public bool IsOpen => Connection.IsOpen;
/// <summary>Applica i messaggi arrivati (al massimo maxMessages per fotogramma).</summary>
public int Poll(int maxMessages = 2000)
{
int n = 0;
while (n < maxMessages && Connection.TryReceive(out var message))
{
n++;
World.Apply(message);
switch (message)
{
case CommandResultMessage r:
if (_callbacks.Remove(r.Seq, out var callback)) callback(r);
if (!r.Ok) CommandFailed?.Invoke(r);
break;
case TrainMotion motion:
MotionReceivedMs[motion.TrainId] = (long)Time.GetTicksMsec();
break;
case Notification note:
Notified?.Invoke(note.Event);
break;
case DailyDigest digest when RequestedSpeed == digest.Speed:
RequestedSpeed = null;
break;
case Welcome welcome:
Difficulty = welcome.Difficulty;
break;
case Pong pong when pong.Nonce == _pingNonce:
LatencyMs = (long)Time.GetTicksMsec() - _pingSentMs;
break;
}
MessageApplied?.Invoke(message);
}
if ((long)Time.GetTicksMsec() - _pingSentMs > 2000) Ping();
return n;
}
private void Ping()
{
_pingSentMs = (long)Time.GetTicksMsec();
_pingNonce++;
Send(new Ping { Nonce = _pingNonce });
}
public void Send(IMessage message) => _ = SendSafe(message);
private async Task SendSafe(IMessage message)
{
try
{
await Connection.SendAsync(message);
}
catch (Exception e)
{
GD.PrintErr($"Invio non riuscito: {e.Message}");
}
}
/// <summary>Invia un comando; la callback riceve l'esito sul thread principale.</summary>
public void Command(GameCommand command, Action<CommandResultMessage>? onResult = null)
{
uint seq = Connection.ReserveSeq();
if (onResult is not null) _callbacks[seq] = onResult;
Send(new CommandMessage { Seq = seq, Command = command });
}
/// <summary>Ultima velocità chiesta da questo client (mostrata finché il resoconto non la conferma).</summary>
public byte? RequestedSpeed { get; private set; }
public void SetSpeed(byte speed)
{
RequestedSpeed = speed;
Send(new SetSpeed { Speed = speed });
}
public async ValueTask DisposeAsync()
{
await Connection.DisposeAsync();
LocalServer?.Dispose();
}
}