Unisce origin/main (audio, ere e obsolescenza, scheda dell'industria e schermata di connessione) e corregge i rilievi della revisione del tutorial (ADR 0023 aggiornato). - Chiave dell'avanzamento senza l'impronta del terreno, che il server ricalcola e che cambia giocando (città, industrie): origine della partita, seme, lato, anno d'inizio, regione e compagnia. Un tutorial ripreso dopo un anno di gioco ritrova la sua voce. - «Tutorial» apre una partita locale di prova sempre nuova in user://tutorial-server invece di riprendere l'autosalvataggio del giocatore e rifare il tutorial lì dentro; con salvataggi locali già presenti la casella «Mostra il tutorial» parte spenta. Casella e pulsante passano nella nuova ConnectScreen (MenuScreen non c'è più). - La casella spuntata vale anche su una voce chiusa o completata (stesso seme di una partita vecchia). - Contorno ritagliato dai contenitori a scorrimento, con l'elemento portato in vista; del tutto nascosto si usa il ripiego. - Pulsanti del riquadro senza fuoco: Invio e spazio restano alla partita (Costruisci, pausa) e non saltano il passo. - La base di «increase» è presa al completamento del passo precedente e gli esiti dei comandi si valutano subito: un binario costruito appena dopo conta per il passo nuovo. - Velocità contata solo dalle richieste di questo client. - Copione mancante o non valido segnalato nella partita; validazione dei null ammessi dal JSON. - Test: chiave stabile con impronta diversa, base al completamento, piano con la casella, null nel copione. 228 test (208 senza i lenti). Refs #45. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
153 lines
5.2 KiB
C#
153 lines
5.2 KiB
C#
using Godot;
|
|
using RailEnterprise.Core.Commands;
|
|
using RailEnterprise.Core.Data;
|
|
using RailEnterprise.Protocol;
|
|
using RailEnterprise.Protocol.Client;
|
|
using RailEnterprise.Protocol.Messages;
|
|
|
|
namespace RailEnterprise.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; }
|
|
|
|
/// <summary>Velocità chieste finora da questo client (il tutorial non conta i cambi fatti da altri giocatori).</summary>
|
|
public int SpeedRequests { get; private set; }
|
|
|
|
public void SetSpeed(byte speed)
|
|
{
|
|
RequestedSpeed = speed;
|
|
SpeedRequests++;
|
|
Send(new SetSpeed { Speed = speed });
|
|
}
|
|
|
|
public async ValueTask DisposeAsync()
|
|
{
|
|
await Connection.DisposeAsync();
|
|
LocalServer?.Dispose();
|
|
}
|
|
}
|