diff --git a/docs/STATE.md b/docs/STATE.md index 95dba3a..bbd1efc 100644 --- a/docs/STATE.md +++ b/docs/STATE.md @@ -89,7 +89,7 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). - Immagini di riferimento 06–09 aggiunte in `reference/`. - Primo rilascio **v0.5.0** (7/11/2026): CI verde, release Gitea con server Windows/Linux e immagine `rail-enterprise-server:0.5.0`/`latest`; collaudo `smoke` contro il server reale superato (ponte di 175 m, scarto 0,00 m). Il gioco desktop di v0.5.0 però parte senza codice C#: mancava la soluzione `client/RailEnterprise.Client/RailEnterprise.Client.sln` che Godot richiede per esportare. Aggiunta la soluzione e un controllo che fa fallire il rilascio senza assembly; correzione in **v0.5.1**. - **v0.5.1** (7/11/2026): il gioco desktop scaricato dalla release funziona. Il pilota automatico (`RailEnterprise.exe -- --autopilot `) avvia il server incluso, costruisce linea, ponte e treni e salva le 17 schermate; esce con codice 0. Restava un difetto: `strings.csv` non era nel gioco esportato (avviso «Traduzioni non trovate», inglese assente), corretto con l'importatore «keep». -- Test instabile sotto carico (issue #24): `BuildLineWithBridgeOverTheNetworkAndWatchTheTrain` (scarto 884 m una volta sul runner), causa ancora da trovare. +- Test instabile sotto carico (issue #24): `BuildLineWithBridgeOverTheNetworkAndWatchTheTrain` (scarto 884 m una volta sul runner). Causa nel test: `TestClient.WaitUntil` ingoiava il tempo scaduto (`ContinueWith(_ => true)`), quindi se il moto dell'ultimo tick non arrivava in 10 s il test confrontava un moto vecchio (il run fallito durò 19 s invece di 7). Il moto non arriva quando la pausa coglie il treno fermo: il server rimanda solo i moti dei treni in marcia. Ora `WaitUntil` fa fallire il test allo scadere e la pausa si ripete finché il treno è in marcia; 24 esecuzioni dei test del server su 24 verdi con 8 processi in parallelo. - `MaintenanceDetailsOnRequest` falliva a volte per un difetto del test: leggeva il registro degli impieghi che il server manda da solo a inizio mese (giorno 0, prima dell'officina) invece della risposta alla richiesta; in locale falliva 2 volte su 4, dopo la correzione 6 su 6 verdi. - **v0.6.0** (7/11/2026): prima versione con i pezzi della F6: Mercato globale (ADR 0015), compravendita in proprio (ADR 0016) ed eventi del mondo (ADR 0017). Il gioco scaricato dalla release passa il pilota automatico (18 schermate, codice 0): il pannello «Mercato globale» si disegna come l'immagine 06, con storico, previsione e banda, offerta, domanda, scorte, «Dove conviene vendere», hub, evento e riquadro della compravendita bloccato al livello 1 (`docs/screenshots/f6-mercato-globale.jpg`). Il riquadro «Eventi in corso» non compare nelle schermate perché nei primi tre mesi della partita del pilota non scatta nessun evento. diff --git a/tests/RailEnterprise.Tests/Server/ServerTests.cs b/tests/RailEnterprise.Tests/Server/ServerTests.cs index 86cea8f..fdf3776 100644 --- a/tests/RailEnterprise.Tests/Server/ServerTests.cs +++ b/tests/RailEnterprise.Tests/Server/ServerTests.cs @@ -102,8 +102,9 @@ public sealed class TestClient : IAsyncDisposable } } - public Task WaitUntil(Func condition, string what, int timeoutMs = 60_000) => - WaitFor(() => condition() ? (object)true : null, what, timeoutMs).ContinueWith(_ => true); + /// Come WaitFor; il tempo scaduto fa fallire il test (prima veniva ingoiato, #24). + public async Task WaitUntil(Func condition, string what, int timeoutMs = 60_000) => + await WaitFor(() => condition() ? (object)true : null, what, timeoutMs); /// Invia un comando e ne attende l'esito. public async Task Do(GameCommand command) @@ -185,19 +186,31 @@ public static class ServerTests await client.Ok(new AssignTrainCommand(new TrainId(train), new LineId(line))); await client.WaitUntil(() => w.Motions.TryGetValue(train, out var m) && m.Speed > 5, "treno in moto", 120_000); - // in pausa: la posizione disegnata dal client coincide con quella del server - await client.Connection.SendAsync(new SetSpeed { Speed = 0 }); - // la pausa vale da quando il ciclo di gioco ha elaborato SetSpeed (sotto carico può tardare) - for (int i = 0; i < 500 && server.Host.Speed != 0; i++) await Task.Delay(10); - Assert.Equal((byte)0, server.Host.Speed); - long tick; - Vec2? head; - while (true) + // in pausa: la posizione disegnata dal client coincide con quella del server. La pausa + // deve cogliere il treno in marcia: fermo (in stazione, a un segnale) il server non + // rimanda il moto e il client ne tiene uno di un tick precedente (#24) + long tick = 0; + Vec2? head = null; + for (int attempt = 0; ; attempt++) { - (tick, head) = await server.Host.InvokeAsync(world => (world.Clock.Tick, Projection.HeadPoint(world, world.Trains[train]))); - await Task.Delay(60); - long again = await server.Host.InvokeAsync(world => world.Clock.Tick); - if (again == tick) break; + await client.Connection.SendAsync(new SetSpeed { Speed = 0 }); + // la pausa vale da quando il ciclo di gioco ha elaborato SetSpeed (sotto carico può tardare) + for (int i = 0; i < 500 && server.Host.Speed != 0; i++) await Task.Delay(10); + Assert.Equal((byte)0, server.Host.Speed); + float speed; + while (true) + { + (tick, head, speed) = await server.Host.InvokeAsync(world => + (world.Clock.Tick, Projection.HeadPoint(world, world.Trains[train]), Projection.Motion(world, world.Trains[train])?.Speed ?? 0f)); + await Task.Delay(60); + long again = await server.Host.InvokeAsync(world => world.Clock.Tick); + if (again == tick) break; + } + if (speed > 0) break; + Assert.True(attempt < 20, "in 20 pause il treno non era mai in marcia"); + await client.Connection.SendAsync(new SetSpeed { Speed = 8 }); + long paused = tick; + await client.WaitUntil(() => w.Motions.TryGetValue(train, out var m) && m.Tick > paused && m.Speed > 0, "treno di nuovo in moto", 120_000); } // in pausa il server rimanda i moti dei treni in marcia ogni 100 ms await client.WaitUntil(() => w.Motions.TryGetValue(train, out var m) && m.Tick == tick, "moto all'ultimo tick", 10_000);