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>
204 lines
8.8 KiB
C#
204 lines
8.8 KiB
C#
using Godot;
|
|
using RailEnterprise.Client.App;
|
|
using RailEnterprise.Client.Audio;
|
|
using RailEnterprise.Client.Net;
|
|
using RailEnterprise.Client.Screens;
|
|
using RailEnterprise.Client.Tutorial;
|
|
using RailEnterprise.Core.Data;
|
|
using static RailEnterprise.Client.App.Localization;
|
|
|
|
namespace RailEnterprise.Client;
|
|
|
|
/// <summary>
|
|
/// Nodo radice: tema e traduzioni, dati del gioco, passaggio tra schermata di connessione e partita;
|
|
/// alla chiusura termina la sessione e l'eventuale server locale.
|
|
/// </summary>
|
|
public partial class Main : Node
|
|
{
|
|
private const string SettingsPath = "user://settings.cfg";
|
|
// cartelle del server locale: la partita del giocatore (la apre la schermata di connessione), la
|
|
// partita di prova del tutorial e quella del collaudo (queste due ripartono sempre da una partita nuova)
|
|
private const string LocalDataDir = "user://server";
|
|
private const string TutorialDataDir = "user://tutorial-server";
|
|
private const string AutopilotDataDir = "user://autopilot-server";
|
|
private GameData? _data;
|
|
private Node? _screen;
|
|
private GameSession? _session;
|
|
private string? _autopilot;
|
|
// tutorial della partita che si apre: casella «Mostra il tutorial» e pulsante «Tutorial» (dal primo passo)
|
|
private bool _tutorialRequested, _tutorialRestart;
|
|
|
|
public override void _Ready()
|
|
{
|
|
var cfg = new ConfigFile();
|
|
cfg.Load(SettingsPath);
|
|
string locale = (string)cfg.GetValue("ui", "locale", "it");
|
|
Localization.Load(locale);
|
|
GetWindow().Theme = UiTheme.Build();
|
|
GetWindow().Title = "Rail Enterprise";
|
|
var args = OS.GetCmdlineUserArgs();
|
|
int i = Array.IndexOf(args, "--autopilot");
|
|
// audio: niente nel pilota automatico e senza schermo (non rallenta il collaudo)
|
|
var audio = new AudioManager(enabled: i < 0 && DisplayServer.GetName() != "headless");
|
|
AddChild(audio);
|
|
try
|
|
{
|
|
_data = GodotDataSource.LoadGameData();
|
|
audio.SetEras(_data.Eras.Eras);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
GD.PrintErr($"Dati del gioco non validi: {e.Message}");
|
|
}
|
|
if (i >= 0 && _data is not null)
|
|
_autopilot = i + 1 < args.Length ? args[i + 1] : ProjectSettings.GlobalizePath("user://autopilot");
|
|
// nel collaudo la schermata di connessione non avvia un suo server: lo avvia StartLocal qui sotto
|
|
ShowMenu(_data is null ? T("Dati del gioco non trovati o non validi.") : "", autoStart: _autopilot is null);
|
|
if (_autopilot is not null)
|
|
{
|
|
// collaudo: mappa piccola e seme fisso per il server locale
|
|
System.Environment.SetEnvironmentVariable("RE_MAP_SIZE", "64");
|
|
System.Environment.SetEnvironmentVariable("RE_SEED", "3");
|
|
System.Environment.SetEnvironmentVariable("RE_AUTOSAVE_MIN", "0");
|
|
StartLocal();
|
|
}
|
|
}
|
|
|
|
private void Swap(Node screen)
|
|
{
|
|
_screen?.QueueFree();
|
|
_screen = screen;
|
|
AddChild(screen);
|
|
}
|
|
|
|
/// <summary>Schermata iniziale e di connessione (immagine 09): server locale o in rete, stato, salvataggi.</summary>
|
|
/// <param name="autoStart">Avvia subito la strada scelta l'ultima volta (server locale o in rete).</param>
|
|
/// <param name="handover">Sessione di prova della schermata precedente, ripresa così com'è (cambio di lingua).</param>
|
|
private void ShowMenu(string status = "", bool autoStart = true, GameSession? handover = null)
|
|
{
|
|
if (_data is null)
|
|
{
|
|
// senza dati non si può aprire nessuna sessione: resta solo il messaggio
|
|
var label = UiTheme.Text(status, 16, Palette.Danger);
|
|
label.SetAnchorsAndOffsetsPreset(Control.LayoutPreset.Center);
|
|
Swap(label);
|
|
return;
|
|
}
|
|
// chi aggiorna con una partita locale già salvata non è alla prima partita: casella spenta
|
|
if (!TutorialSettings.Played && HasLocalSaves()) TutorialSettings.Played = true;
|
|
var screen = new ConnectScreen(_data, autoStart: autoStart, handover: handover);
|
|
screen.PlayRequested += session =>
|
|
{
|
|
SetTutorial(screen.ShowTutorial, restart: false);
|
|
ShowGame(session, screen.GameScope);
|
|
};
|
|
screen.TutorialRequested += async () =>
|
|
{
|
|
// la partita di prova ha un suo server: quello della sessione di prova della schermata si chiude
|
|
var trial = screen.TakeSession();
|
|
if (trial is not null) await trial.DisposeAsync();
|
|
SetTutorial(true, restart: true);
|
|
StartLocal(tutorial: true);
|
|
};
|
|
screen.AudioRequested += () => AudioManager.Instance?.ShowSettings();
|
|
screen.LanguageChanged += code =>
|
|
{
|
|
var cfg = new ConfigFile();
|
|
cfg.Load(SettingsPath);
|
|
cfg.SetValue("ui", "locale", code);
|
|
cfg.Save(SettingsPath);
|
|
TranslationServer.SetLocale(code);
|
|
// la schermata si ricrea con i testi nuovi: la sessione di prova (e il server locale) passa a lei
|
|
ShowMenu(handover: screen.TakeSession());
|
|
};
|
|
Swap(screen);
|
|
if (status.Length > 0) screen.SetStatus(status, error: true);
|
|
}
|
|
|
|
private void SetTutorial(bool requested, bool restart)
|
|
{
|
|
_tutorialRequested = requested;
|
|
_tutorialRestart = restart;
|
|
}
|
|
|
|
/// <summary>Vero se la partita locale del giocatore ha già dei salvataggi (file <c>.vfsave</c> del server).</summary>
|
|
private static bool HasLocalSaves()
|
|
{
|
|
try
|
|
{
|
|
string saves = System.IO.Path.Combine(ProjectSettings.GlobalizePath(LocalDataDir), "saves");
|
|
return Directory.Exists(saves) && Directory.EnumerateFiles(saves, "*.vfsave").Any();
|
|
}
|
|
catch (IOException)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Server locale da zero e subito in partita, senza la schermata di connessione: il collaudo e la partita
|
|
/// di prova del tutorial, ciascuno nella sua cartella; la partita del giocatore non si tocca.
|
|
/// </summary>
|
|
/// <param name="tutorial">pulsante «Tutorial»: partita di prova nuova, con il tutorial dal primo passo</param>
|
|
private async void StartLocal(bool tutorial = false)
|
|
{
|
|
if (_data is null) return;
|
|
string? server = LocalServerLauncher.FindServer();
|
|
if (server is null)
|
|
{
|
|
ShowMenu(T("Server locale non trovato: compila src/RailEnterprise.Server o imposta RE_SERVER_PATH."), autoStart: false);
|
|
return;
|
|
}
|
|
if (tutorial && _screen is ConnectScreen connect) connect.SetStatus(T("Avvio della partita di prova del tutorial…"));
|
|
var launcher = new LocalServerLauncher();
|
|
try
|
|
{
|
|
string dataDir = ProjectSettings.GlobalizePath(tutorial ? TutorialDataDir : AutopilotDataDir);
|
|
if (Directory.Exists(dataDir)) Directory.Delete(dataDir, true);
|
|
int port = await launcher.StartAsync(server, dataDir, TimeSpan.FromSeconds(60));
|
|
var session = await GameSession.ConnectAsync(_data, new Uri($"ws://127.0.0.1:{port}/ws"), launcher.Token, T("Partita locale"));
|
|
session.LocalServer = launcher;
|
|
ShowGame(session, tutorial ? "tutorial" : "autopilot");
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
launcher.Dispose();
|
|
ShowMenu($"{T("Partita locale non avviata")}: {e.Message}", autoStart: false);
|
|
}
|
|
}
|
|
|
|
/// <param name="scope">origine della partita (locale, tutorial, server in rete) per la voce del tutorial</param>
|
|
private void ShowGame(GameSession session, string scope)
|
|
{
|
|
_session = session;
|
|
var game = new GameScreen(session);
|
|
game.Exit += async () =>
|
|
{
|
|
// prima si chiude la partita (e il server locale), poi la schermata di connessione ne
|
|
// avvia uno nuovo: due server sulla stessa cartella dei salvataggi non convivono
|
|
var s = _session;
|
|
_session = null;
|
|
if (s is not null) await s.DisposeAsync();
|
|
ShowMenu();
|
|
};
|
|
Swap(game);
|
|
// il pilota automatico non mostra il tutorial: le sue schermate di partita restano quelle di sempre
|
|
if (_autopilot is not null) game.AddChild(new AutoPilot(game, _autopilot));
|
|
else
|
|
{
|
|
game.AddChild(new TutorialController(game, scope, _tutorialRequested, _tutorialRestart));
|
|
TutorialSettings.Played = true;
|
|
_tutorialRestart = false;
|
|
}
|
|
}
|
|
|
|
public override void _Notification(int what)
|
|
{
|
|
if (what != NotificationWMCloseRequest) return;
|
|
// anche la sessione di prova della schermata di connessione chiude il suo server locale
|
|
var session = _session ?? (_screen as ConnectScreen)?.TakeSession();
|
|
_session = null;
|
|
session?.DisposeAsync().AsTask().Wait(TimeSpan.FromSeconds(3));
|
|
}
|
|
}
|