From b1ee6879a73925945cf6a792f36365e02196e2eb Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Sun, 8 Nov 2026 13:50:07 +0100 Subject: [PATCH 1/7] F6: audio con bus, volumi, effetti, ambienti e musica per era MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit Il client ora ha l'audio della F6 senza file esterni né download: effetti, anelli d'ambiente e temi musicali si sintetizzano in memoria all'avvio, su un altro thread, con classi senza dipendenze da Godot (Synth, MusicComposer, AudioMix) e semi fissi. - Bus Master, Music, Ambience, Sfx, Ui creati da codice in modo idempotente, limitatore sul Master; volumi per bus e muto in user://settings.cfg; pannello «Audio» dal menu e dall'altoparlante della barra superiore, tasto M. - AudioManager (figlio di Main) reagisce solo a ciò che il client riceve: clic dei pulsanti, esiti dei comandi, notifiche per gravità, cantieri completati dal DailyDigest, fischio o tromba all'arrivo in stazione, fino a 3 treni vicini al centro con rotolamento, motore e sbuffi modulati dalla velocità, ambiente dal terreno visibile e dallo zoom, tema per era con dissolvenza. - Nessuna allocazione nel ciclo per fotogramma; audio spento nel pilota automatico e senza schermo. - ADR 0022, STATE e ARCHITECTURE aggiornati; testi in strings.csv. Non ascoltato: Godot non è eseguibile qui. Funzioni pure provate a parte. Refs #46. Co-Authored-By: Claude Opus 5.5 --- .../assets/i18n/strings.csv | 9 + .../scripts/Audio/AudioManager.cs | 643 ++++++++++++++++++ .../scripts/Audio/AudioMix.cs | 142 ++++ .../scripts/Audio/AudioSettings.cs | 91 +++ .../scripts/Audio/AudioSettingsPanel.cs | 105 +++ .../scripts/Audio/MusicComposer.cs | 303 +++++++++ .../scripts/Audio/SpeakerButton.cs | 49 ++ .../scripts/Audio/Synth.cs | 554 +++++++++++++++ .../scripts/Hud/TopBar.cs | 5 +- client/RailEnterprise.Client/scripts/Main.cs | 10 +- .../scripts/Screens/GameScreen.cs | 8 +- .../scripts/Screens/MenuScreen.cs | 6 +- docs/ARCHITECTURE.md | 3 +- docs/STATE.md | 11 +- docs/adr/0022-audio.md | 63 ++ 15 files changed, 1994 insertions(+), 8 deletions(-) create mode 100644 client/RailEnterprise.Client/scripts/Audio/AudioManager.cs create mode 100644 client/RailEnterprise.Client/scripts/Audio/AudioMix.cs create mode 100644 client/RailEnterprise.Client/scripts/Audio/AudioSettings.cs create mode 100644 client/RailEnterprise.Client/scripts/Audio/AudioSettingsPanel.cs create mode 100644 client/RailEnterprise.Client/scripts/Audio/MusicComposer.cs create mode 100644 client/RailEnterprise.Client/scripts/Audio/SpeakerButton.cs create mode 100644 client/RailEnterprise.Client/scripts/Audio/Synth.cs create mode 100644 docs/adr/0022-audio.md diff --git a/client/RailEnterprise.Client/assets/i18n/strings.csv b/client/RailEnterprise.Client/assets/i18n/strings.csv index dd4319d..a1c7550 100644 --- a/client/RailEnterprise.Client/assets/i18n/strings.csv +++ b/client/RailEnterprise.Client/assets/i18n/strings.csv @@ -677,3 +677,12 @@ una leva non oltre {0} (rimborsando {1}),,leverage no higher than {0} (by repayi Per il gradino {0} serve un punteggio di {1}: {2}.,,To reach {0} you need a score of {1}: {2}. In bancarotta non si possono chiedere prestiti,,Loans cannot be requested while bankrupt Fido disponibile {0} su {1}. Tasso di un nuovo prestito: {2} fisso (base {3} + rating {4} {5}) per {6} anni.,,Available credit {0} of {1}. Rate of a new loan: {2} fixed (base {3} + rating {4} {5}) for {6} years. +Audio,,Audio +Volume generale,,Master volume +Musica,,Music +Ambiente,,Ambience +Effetti,,Effects +Interfaccia,,Interface +Muto,,Mute +Il tasto M attiva e toglie il muto durante la partita.,,The M key toggles mute during the game. +Audio (M: muto),,Audio (M: mute) diff --git a/client/RailEnterprise.Client/scripts/Audio/AudioManager.cs b/client/RailEnterprise.Client/scripts/Audio/AudioManager.cs new file mode 100644 index 0000000..1158164 --- /dev/null +++ b/client/RailEnterprise.Client/scripts/Audio/AudioManager.cs @@ -0,0 +1,643 @@ +using Godot; +using RailEnterprise.Client.Map; +using RailEnterprise.Client.Net; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Map; +using RailEnterprise.Core.Rail; +using RailEnterprise.Protocol; +using RailEnterprise.Protocol.Messages; + +namespace RailEnterprise.Client.Audio; + +/// +/// Regia dell'audio, figlia di Main per tutta la vita del client: bus e volumi, effetti +/// dell'interfaccia (clic di ogni pulsante, esito dei comandi), notifiche, cantieri completati, +/// treni vicini al centro della telecamera (rotolamento, motore, sbuffi, fischio all'arrivo), +/// ambiente dal terreno sotto la telecamera e musica per era. Non decide nulla del gioco: reagisce +/// a ciò che il client riceve (esiti, notifiche, DailyDigest, moti dei treni) e alla vista. +/// I suoni si sintetizzano all'avvio su un altro thread (, ); +/// nel ciclo per fotogramma non si alloca (elenchi preparati, nessuna LINQ). +/// +public partial class AudioManager : Node +{ + /// Unica istanza (nulla prima dell'avvio del client). + public static AudioManager? Instance { get; private set; } + + /// Volumi e muto attuali (anche con l'audio disattivato, per il pannello). + public AudioSettings Settings { get; private set; } = new(); + + /// Cambio di volumi o muto (per aggiornare il pannello e l'icona della barra). + public event Action? SettingsChanged; + + private readonly bool _enabled; + private Task? _bankTask; + private bool _loaded; + + // suoni singoli + private AudioStreamWav? _click, _confirm, _error, _build, _whistle, _horn, _chuff; + private readonly AudioStreamWav?[] _notify = new AudioStreamWav?[3]; + private AudioStreamWav[] _birds = []; + private AudioStreamWav? _diesel, _hum; + + // riproduttori polifonici per bus e nomi dei bus già pronti (niente StringName per chiamata) + private readonly StringName _busUi = AudioBuses.Ui, _busSfx = AudioBuses.Sfx, _busAmbience = AudioBuses.Ambience; + private AudioStreamPlaybackPolyphonic? _ui, _sfx, _ambience; + + // ambiente: vento, acqua, mare, città + private const int AmbienceLoops = 4; + private static readonly float[] AmbienceLevel = [0.55f, 0.6f, 0.6f, 0.5f]; + private readonly AudioStreamPlayer[] _ambiencePlayers = new AudioStreamPlayer[AmbienceLoops]; + private readonly float[] _ambienceGain = new float[AmbienceLoops]; + private readonly float[] _ambienceTarget = new float[AmbienceLoops]; + private float _birdsChance; + private float _sinceAmbience = 1, _birdTimer = 3; + + // treni + private sealed class TrainChannel + { + public int Train = -1; + public Traction Traction; + public float Gain, Target, ChuffTimer; + public bool Kept; + public required AudioStreamPlayer Rumble { get; init; } + public required AudioStreamPlayer Engine { get; init; } + } + + private readonly TrainChannel[] _channels = new TrainChannel[AudioMix.TrainChannels]; + private readonly int[] _nearIds = new int[AudioMix.TrainChannels]; + private readonly float[] _nearDistances = new float[AudioMix.TrainChannels]; + private readonly Dictionary _trainStates = []; + + // musica: due riproduttori per la dissolvenza incrociata + private const float MusicLevel = 0.6f; + private const float FadeSeconds = 3f; + private readonly AudioStreamPlayer[] _music = new AudioStreamPlayer[2]; + private readonly float[] _musicGain = new float[2]; + private int _activeMusic; + private int _musicEra = -1; + private readonly Dictionary _themes = []; + private readonly HashSet _failedThemes = []; + private Task? _composing; + private int _composingEra; + private string[] _eraIds = ["steam"]; + private int[] _eraFroms = [0]; + + // partita in corso + private GameSession? _session; + private MapView? _map; + private Dictionary _vehicles = []; + private SynthRng _rng = new(0xA0D10); + private ulong _lastUiMs, _lastNotifyMs, _lastWhistleMs; + + // pannello delle impostazioni + private CanvasLayer? _overlay; + private AudioSettingsPanel? _panel; + + /// Falso nel pilota automatico e senza schermo: niente sintesi né riproduzione, Master muto. + public AudioManager(bool enabled) + { + _enabled = enabled; + Name = "AudioManager"; + } + + public AudioManager() : this(true) + { + } + + public override void _Ready() + { + Instance = this; + AudioBuses.Ensure(); + Settings = AudioSettings.Load(); + ApplySettings(); + if (!_enabled) return; + _bankTask = Task.Run(SoundBank.Create); + GetTree().NodeAdded += OnNodeAdded; + } + + public override void _ExitTree() + { + if (Instance == this) Instance = null; + Unbind(); + } + + /// Ere di eras.json (id e anno d'inizio, crescenti): scelgono il tema musicale. + public void SetEras(IReadOnlyList eras) + { + if (eras.Count == 0) return; + _eraIds = new string[eras.Count]; + _eraFroms = new int[eras.Count]; + for (int i = 0; i < eras.Count; i++) + { + _eraIds[i] = eras[i].Id; + _eraFroms[i] = eras[i].From; + } + } + + // ------------------------------------------------------------------ impostazioni + + private void ApplySettings() + { + Settings.Apply(); + // senza audio (collaudo, server senza schermo) il Master resta muto, senza toccare il file + if (!_enabled) AudioServer.SetBusMute(0, true); + } + + /// Cambia il volume di un bus (indice in ) e lo applica subito. + public void SetVolume(int bus, float value) + { + Settings.Volumes[bus] = Math.Clamp(value, 0, 1); + ApplySettings(); + SettingsChanged?.Invoke(); + } + + public void SetMuted(bool muted) + { + Settings.Muted = muted; + ApplySettings(); + SettingsChanged?.Invoke(); + } + + public void ToggleMute() + { + SetMuted(!Settings.Muted); + Settings.Save(); + } + + public void SaveSettings() => Settings.Save(); + + /// Apre il pannello «Audio» sopra a tutto (menu o partita). + public void ShowSettings() + { + if (_panel is not null && IsInstanceValid(_panel)) return; + if (_overlay is null) + { + _overlay = new CanvasLayer { Layer = 50 }; + AddChild(_overlay); + } + _panel = new AudioSettingsPanel(this); + _panel.TreeExited += () => _panel = null; + _overlay.AddChild(_panel); + } + + public override void _UnhandledKeyInput(InputEvent e) + { + if (e is InputEventKey { Pressed: true, Echo: false, Keycode: Key.M } key && !key.CtrlPressed && !key.AltPressed && !key.MetaPressed) + { + ToggleMute(); + GetViewport().SetInputAsHandled(); + } + } + + // ------------------------------------------------------------------ partita + + /// Collega la partita: messaggi della sessione e vista della mappa. + public void Bind(GameSession session, MapView map) + { + Unbind(); + _session = session; + _map = map; + _vehicles = session.World.Data.Vehicles.ToDictionary(v => v.Id); + SetEras(session.World.Data.Eras.Eras); + session.MessageApplied += OnMessage; + } + + /// + /// Scollega la partita (ritorno al menu): treni e ambiente sfumano. Con «only» scollega solo + /// se è ancora quella sessione (la schermata vecchia esce dall'albero dopo l'arrivo della nuova). + /// + public void Unbind(GameSession? only = null) + { + if (only is not null && !ReferenceEquals(only, _session)) return; + if (_session is not null) _session.MessageApplied -= OnMessage; + _session = null; + _map = null; + _trainStates.Clear(); + } + + private void OnMessage(IMessage message) + { + if (!_loaded) return; + switch (message) + { + case TrainMotion m: + byte previous = _trainStates.TryGetValue(m.TrainId, out byte p) ? p : (byte)255; + _trainStates[m.TrainId] = m.State; + if (previous == (byte)TrainState.Moving && m.State == (byte)TrainState.Loading) Whistle(m.TrainId); + break; + case CommandResultMessage r: + PlayUi(r.Ok ? _confirm : _error, r.Ok ? 0.7f : 0.85f); + break; + case Notification n: + Notify(n.Event); + break; + case DailyDigest d: + int me = _session?.World.Summary?.CompanyId ?? -1; + for (int i = 0; i < d.Events.Count; i++) + { + var e = d.Events[i]; + if (e.Kind == ConstructionEventKind && e.Company == me && me >= 0) + { + Play(_sfx, _build, 0.8f, 1, _busSfx); + break; + } + } + break; + case Welcome: + _trainStates.Clear(); + break; + } + } + + /// Codice di EventKind.Construction nel protocollo (cantiere completato, sempre informativo). + private const byte ConstructionEventKind = 5; + + private void Notify(EventInfo e) + { + int me = _session?.World.Summary?.CompanyId ?? -1; + if (e.Company >= 0 && e.Company != me) return; + int level = e.Severity switch { 3 => 2, 2 => 1, _ => 0 }; + ulong now = Time.GetTicksMsec(); + // più notizie insieme: una sola campanella (le critiche suonano sempre) + if (level < 2 && now - _lastNotifyMs < 600) return; + _lastNotifyMs = now; + Play(_ui, _notify[level], level == 2 ? 0.9f : 0.75f, 1, _busUi); + } + + private void OnNodeAdded(Node node) + { + if (node is BaseButton button) button.Pressed += PlayClick; + } + + private void PlayClick() => PlayUi(_click, 0.6f); + + private void PlayUi(AudioStreamWav? stream, float gain) + { + ulong now = Time.GetTicksMsec(); + if (stream == _click && now - _lastUiMs < 40) return; + _lastUiMs = now; + Play(_ui, stream, gain, 1, _busUi); + } + + private static void Play(AudioStreamPlaybackPolyphonic? playback, AudioStreamWav? stream, float gain, float pitch, StringName bus) + { + if (playback is null || stream is null || gain <= 0.001f) return; + playback.PlayStream(stream, 0, AudioMix.LinearToDb(gain), pitch, AudioServer.PlaybackType.Default, bus); + } + + // ------------------------------------------------------------------ caricamento + + /// Campioni di tutti gli effetti e degli anelli, sintetizzati fuori dal thread principale. + private sealed class SoundBank + { + public required float[] Click, Confirm, Error, Construction, Whistle, Horn, Chuff, Rumble, Diesel, Hum, Wind, River, Sea, City; + public required float[][] Notify, Birds; + + public static SoundBank Create() => new() + { + Click = Synth.Click(), Confirm = Synth.Confirm(), Error = Synth.Error(), Construction = Synth.BuildComplete(), + Whistle = Synth.SteamWhistle(), Horn = Synth.Horn(), Chuff = Synth.Chuff(), Rumble = Synth.RailRumbleLoop(), + Diesel = Synth.DieselDroneLoop(), Hum = Synth.ElectricHumLoop(), Wind = Synth.WindLoop(), River = Synth.RiverLoop(), + Sea = Synth.SeaLoop(), City = Synth.CityLoop(), + Notify = [Synth.Notify(0), Synth.Notify(1), Synth.Notify(2)], + Birds = [Synth.Bird(0), Synth.Bird(1), Synth.Bird(2)], + }; + } + + private static AudioStreamWav Wav(float[] samples, bool loop = false) + { + var w = new AudioStreamWav + { + Format = AudioStreamWav.FormatEnum.Format16Bits, + MixRate = Synth.Rate, + Stereo = false, + Data = AudioMix.ToPcm16(samples), + }; + if (loop) + { + w.LoopMode = AudioStreamWav.LoopModeEnum.Forward; + w.LoopBegin = 0; + w.LoopEnd = samples.Length; + } + return w; + } + + private AudioStreamPlayer Player(string bus, AudioStream? stream = null) + { + var p = new AudioStreamPlayer { Bus = bus, Stream = stream }; + AddChild(p); + return p; + } + + private AudioStreamPlaybackPolyphonic? Polyphonic(string bus, int voices) + { + var p = Player(bus, new AudioStreamPolyphonic { Polyphony = voices }); + p.Play(); + return p.GetStreamPlayback() as AudioStreamPlaybackPolyphonic; + } + + private void Load(SoundBank bank) + { + _click = Wav(bank.Click); + _confirm = Wav(bank.Confirm); + _error = Wav(bank.Error); + _build = Wav(bank.Construction); + _whistle = Wav(bank.Whistle); + _horn = Wav(bank.Horn); + _chuff = Wav(bank.Chuff); + for (int i = 0; i < _notify.Length; i++) _notify[i] = Wav(bank.Notify[i]); + _birds = bank.Birds.Select(b => Wav(b)).ToArray(); + _diesel = Wav(bank.Diesel, loop: true); + _hum = Wav(bank.Hum, loop: true); + var rumble = Wav(bank.Rumble, loop: true); + + _ui = Polyphonic(AudioBuses.Ui, 8); + _sfx = Polyphonic(AudioBuses.Sfx, 16); + _ambience = Polyphonic(AudioBuses.Ambience, 4); + float[][] loops = [bank.Wind, bank.River, bank.Sea, bank.City]; + for (int i = 0; i < AmbienceLoops; i++) + { + var p = Player(AudioBuses.Ambience, Wav(loops[i], loop: true)); + p.VolumeLinear = 0; + _ambiencePlayers[i] = p; + } + for (int i = 0; i < _channels.Length; i++) + { + var r = Player(AudioBuses.Sfx, rumble); + var e = Player(AudioBuses.Sfx); + r.VolumeLinear = e.VolumeLinear = 0; + _channels[i] = new TrainChannel { Rumble = r, Engine = e }; + } + for (int i = 0; i < _music.Length; i++) _music[i] = Player(AudioBuses.Music); + _loaded = true; + } + + // ------------------------------------------------------------------ ciclo + + public override void _Process(double delta) + { + if (!_enabled) return; + if (!_loaded) + { + if (_bankTask is not { IsCompleted: true }) return; + if (_bankTask.IsCompletedSuccessfully) Load(_bankTask.Result); + else + { + GD.PrintErr($"Audio: sintesi non riuscita: {_bankTask.Exception?.GetBaseException().Message}"); + _bankTask = null; + return; + } + } + float dt = (float)Math.Min(delta, 0.1); + UpdateMusic(dt); + UpdateAmbience(dt); + UpdateTrains(dt); + } + + private int WantedEra() + { + var w = _session?.World; + if (w?.Calendar is null) return 0; + return AudioMix.EraIndex(w.Year, _eraFroms); + } + + private void UpdateMusic(float dt) + { + int want = WantedEra(); + if (_composing is { IsCompleted: true }) + { + if (_composing.IsCompletedSuccessfully) _themes[_composingEra] = Wav(_composing.Result, loop: true); + else + { + _failedThemes.Add(_composingEra); + GD.PrintErr($"Audio: tema dell'era non composto: {_composing.Exception?.GetBaseException().Message}"); + } + _composing = null; + } + if (want != _musicEra) + { + if (_themes.TryGetValue(want, out var theme)) + { + // dissolvenza incrociata: il nuovo tema entra sull'altro riproduttore + _activeMusic = 1 - _activeMusic; + var p = _music[_activeMusic]; + p.Stream = theme; + _musicGain[_activeMusic] = 0; + p.VolumeLinear = 0; + p.Play(); + _musicEra = want; + } + else if (_composing is null && !_failedThemes.Contains(want)) + { + int era = want; + string id = _eraIds[Math.Clamp(era, 0, _eraIds.Length - 1)]; + _composingEra = era; + _composing = Task.Run(() => MusicComposer.Compose(era, id)); + } + } + for (int i = 0; i < _music.Length; i++) + { + float target = i == _activeMusic && _musicEra >= 0 ? 1 : 0; + _musicGain[i] = AudioMix.Approach(_musicGain[i], target, 1 / FadeSeconds, dt); + _music[i].VolumeLinear = _musicGain[i] * MusicLevel; + if (_musicGain[i] <= 0 && i != _activeMusic && _music[i].Playing) _music[i].Stop(); + } + } + + private void UpdateAmbience(float dt) + { + _sinceAmbience += dt; + if (_sinceAmbience >= 0.25f) + { + _sinceAmbience = 0; + var gains = _map is not null && _session?.World.Terrain is { } terrain + ? AudioMix.Ambience(_map.Zoom, SampleTerrain(terrain, _map.VisibleRect())) + : default; + _ambienceTarget[0] = gains.Wind; + _ambienceTarget[1] = gains.Water; + _ambienceTarget[2] = gains.Sea; + _ambienceTarget[3] = gains.City; + _birdsChance = gains.Birds; + } + for (int i = 0; i < AmbienceLoops; i++) + { + _ambienceGain[i] = AudioMix.Approach(_ambienceGain[i], _ambienceTarget[i], 0.5f, dt); + var p = _ambiencePlayers[i]; + p.VolumeLinear = _ambienceGain[i] * AmbienceLevel[i]; + if (_ambienceGain[i] > 0 && !p.Playing) p.Play(_rng.Next01() * 4); + else if (_ambienceGain[i] <= 0 && p.Playing) p.Stop(); + } + if (_birdsChance > 0.05f && _birds.Length > 0) + { + _birdTimer -= dt; + if (_birdTimer <= 0) + { + Play(_ambience, _birds[_rng.Next(_birds.Length)], _birdsChance * 0.45f, _rng.Range(0.9f, 1.15f), _busAmbience); + _birdTimer = _rng.Range(1.5f, 6f) / (0.3f + _birdsChance); + } + } + } + + /// Frazioni del terreno su una griglia 8×8 della vista (allargata di un quarto per sentire l'acqua vicina). + private static TerrainMix SampleTerrain(Terrain t, Rect2 view) + { + const int grid = 8; + view = view.Grow(Math.Max(view.Size.X, view.Size.Y) * 0.125f); + int river = 0, lake = 0, sea = 0, town = 0, forest = 0, open = 0, total = 0; + for (int gy = 0; gy < grid; gy++) + { + for (int gx = 0; gx < grid; gx++) + { + double x = view.Position.X + (gx + 0.5) / grid * view.Size.X; + double y = view.Position.Y + (gy + 0.5) / grid * view.Size.Y; + int cx = (int)Math.Floor(x / t.CellSizeM), cy = (int)Math.Floor(y / t.CellSizeM); + if (!t.InBounds(cx, cy)) continue; + int i = t.Index(cx, cy); + total++; + switch ((CellType)t.Types[i]) + { + case CellType.Water when t.RiverWidth[i] > 0: river++; break; + case CellType.Water: lake++; break; + case CellType.Sea: sea++; break; + case CellType.Town or CellType.Industry: town++; break; + case CellType.Forest: forest++; break; + default: open++; break; + } + } + } + if (total == 0) return default; + float k = 1f / total; + return new TerrainMix { River = river * k, Lake = lake * k, Sea = sea * k, Town = town * k, Forest = forest * k, Open = open * k }; + } + + private void UpdateTrains(float dt) + { + var w = _session?.World; + var map = _map; + int count = 0; + Vector2 center = default; + float zoom = 1, radius = 1; + if (w is not null && map is not null && w.Speed > 0) + { + center = map.Camera.GetScreenCenterPosition(); + zoom = map.Zoom; + radius = map.GetViewportRect().Size.Length() / 2; + foreach (var (id, head) in map.Trains.Heads) + { + if (!w.Motions.TryGetValue(id, out var m) || m.State != (byte)TrainState.Moving || m.Speed < 0.5f) continue; + count = AudioMix.InsertNearest(_nearIds, _nearDistances, count, id, head.DistanceTo(center) * zoom); + } + } + // i canali restano ai loro treni finché sono tra i più vicini; gli altri sfumano + foreach (var ch in _channels) ch.Kept = ch.Train >= 0 && Contains(_nearIds, count, ch.Train); + for (int k = 0; k < count; k++) + { + int id = _nearIds[k]; + if (HasChannel(id)) continue; + foreach (var ch in _channels) + { + if (ch.Train >= 0 && (ch.Kept || ch.Gain > 0.01f)) continue; + Assign(ch, id, w!); + ch.Kept = true; + break; + } + } + foreach (var ch in _channels) + { + float speed = 0; + if (ch.Kept && w is not null && map is not null && w.Motions.TryGetValue(ch.Train, out var m) && map.Trains.Heads.TryGetValue(ch.Train, out var head)) + { + speed = m.Speed; + ch.Target = AudioMix.TrainGain(head.DistanceTo(center) * zoom, radius, speed, zoom); + } + else ch.Target = 0; + ch.Gain = AudioMix.Approach(ch.Gain, ch.Target, 2.5f, dt); + if (ch.Train < 0) continue; + if (ch.Gain <= 0 && ch.Target <= 0) + { + ch.Train = -1; + ch.Rumble.Stop(); + ch.Engine.Stop(); + continue; + } + if (speed > 0) + { + ch.Rumble.PitchScale = AudioMix.RumblePitch(speed); + ch.Engine.PitchScale = AudioMix.EnginePitch(speed); + } + ch.Rumble.VolumeLinear = ch.Gain * 0.7f; + bool steam = ch.Traction == Traction.Steam; + ch.Engine.VolumeLinear = steam ? 0 : ch.Gain * 0.45f; + if (steam && speed > 0 && ch.Gain > 0.02f) + { + ch.ChuffTimer -= dt; + if (ch.ChuffTimer <= 0) + { + Play(_sfx, _chuff, ch.Gain * 0.9f, _rng.Range(0.92f, 1.08f), _busSfx); + ch.ChuffTimer = Math.Max(ch.ChuffTimer, 0) + AudioMix.ChuffInterval(speed); + } + } + } + } + + private static bool Contains(int[] ids, int count, int id) + { + for (int i = 0; i < count; i++) + { + if (ids[i] == id) return true; + } + return false; + } + + private bool HasChannel(int train) + { + foreach (var ch in _channels) + { + if (ch.Train == train) return true; + } + return false; + } + + private void Assign(TrainChannel ch, int train, Protocol.Client.ClientWorld w) + { + ch.Train = train; + ch.Traction = TractionOf(train, w); + ch.Gain = 0; + ch.ChuffTimer = _rng.Next01() * 0.2f; + ch.Rumble.VolumeLinear = 0; + ch.Rumble.Play(_rng.Next01() * 1.5f); + ch.Engine.VolumeLinear = 0; + if (ch.Traction == Traction.Steam) ch.Engine.Stop(); + else + { + ch.Engine.Stream = ch.Traction == Traction.Diesel ? _diesel : _hum; + ch.Engine.Play(_rng.Next01() * 0.9f); + } + } + + /// Trazione della prima locomotiva del treno (vapore se non si sa). + private Traction TractionOf(int train, Protocol.Client.ClientWorld w) + { + if (!w.Trains.TryGetValue(train, out var info)) return Traction.Steam; + foreach (int vid in info.Vehicles) + { + if (w.Vehicles.TryGetValue(vid, out var v) && _vehicles.TryGetValue(v.Type, out var def) && def.Kind == VehicleKind.Locomotive && def.Traction is { } traction) return traction; + } + return Traction.Steam; + } + + /// Fischio (vapore) o tromba all'arrivo in stazione di un treno visibile vicino al centro. + private void Whistle(int train) + { + var w = _session?.World; + if (w is null || _map is null || !_map.Trains.Heads.TryGetValue(train, out var head)) return; + ulong now = Time.GetTicksMsec(); + if (now - _lastWhistleMs < 700) return; + float zoom = _map.Zoom; + float d = head.DistanceTo(_map.Camera.GetScreenCenterPosition()) * zoom; + float gain = AudioMix.TrainGain(d, _map.GetViewportRect().Size.Length() * 0.6f, AudioMix.FullSpeedMs, zoom); + if (gain < 0.03f) return; + _lastWhistleMs = now; + Play(_sfx, TractionOf(train, w) == Traction.Steam ? _whistle : _horn, gain * 0.9f, _rng.Range(0.97f, 1.03f), _busSfx); + } +} diff --git a/client/RailEnterprise.Client/scripts/Audio/AudioMix.cs b/client/RailEnterprise.Client/scripts/Audio/AudioMix.cs new file mode 100644 index 0000000..4ababaa --- /dev/null +++ b/client/RailEnterprise.Client/scripts/Audio/AudioMix.cs @@ -0,0 +1,142 @@ +namespace RailEnterprise.Client.Audio; + +/// Frazioni del terreno sotto la telecamera (somma 1 sui campioni letti). +public struct TerrainMix +{ + public float River; + public float Lake; + public float Sea; + public float Town; + public float Forest; + public float Open; +} + +/// Guadagni lineari (0–1) dei quattro anelli d'ambiente e probabilità relativa degli uccelli. +public readonly record struct AmbienceGains(float Wind, float Water, float Sea, float City, float Birds); + +/// +/// Miscelazione dell'audio senza dipendenze da Godot: guadagni dell'ambiente dal terreno e dallo +/// zoom, volume e intonazione dei treni dalla distanza sullo schermo e dalla velocità, scelta dei +/// treni più vicini senza allocazioni, ere dall'anno, dissolvenze e conversione in PCM. Le costanti +/// sono di resa sonora del client, non della simulazione. +/// +public static class AudioMix +{ + /// Zoom (pixel per metro) sotto il quale si sente quasi solo il vento della vista d'insieme. + public const float FarZoom = 0.02f; + /// Zoom da cui ambiente e treni sono al massimo. + public const float NearZoom = 0.5f; + /// Canali dei treni: al più tanti treni suonano insieme. + public const int TrainChannels = 3; + /// Velocità (m/s) a cui il rotolamento è al massimo. + public const float FullSpeedMs = 25f; + /// Metri percorsi tra due sbuffi: ruota motrice di circa 1,6 m, quattro sbuffi a giro. + public const float ChuffSpacingM = 1.26f; + + public static float Clamp01(float x) => x < 0 ? 0 : x > 1 ? 1 : x; + + public static float SmoothStep(float x) + { + x = Clamp01(x); + return x * x * (3 - 2 * x); + } + + /// Vicinanza della telecamera (0 = vista d'insieme, 1 = da vicino) su scala logaritmica dello zoom. + public static float Closeness(float zoom) + { + if (zoom <= 0) return 0; + return SmoothStep((MathF.Log(zoom) - MathF.Log(FarZoom)) / (MathF.Log(NearZoom) - MathF.Log(FarZoom))); + } + + /// + /// Ambiente: il vento c'è sempre (più forte da lontano), acqua, mare e città seguono la + /// frazione del terreno visibile e si attenuano allontanandosi; gli uccelli solo da vicino in + /// campagna e nei boschi. + /// + public static AmbienceGains Ambience(float zoom, in TerrainMix t) + { + float close = Closeness(zoom); + float wind = 0.35f + 0.35f * (1 - close) + 0.15f * t.Open; + float water = Clamp01((t.River * 3 + t.Lake * 1.5f) * (0.25f + 0.75f * close)); + float sea = Clamp01(t.Sea * 1.6f * (0.45f + 0.55f * close)); + float city = Clamp01(t.Town * 4 * (0.15f + 0.85f * close)); + float birds = Clamp01((t.Forest + t.Open * 0.6f) * close * close * (1 - t.Town * 2)); + // l'acqua e la città coprono un po' il vento + wind *= 1 - 0.4f * MathF.Max(sea, city); + return new AmbienceGains(Clamp01(wind), water, sea, city, birds); + } + + /// Volume di un treno: vicinanza al centro dello schermo, velocità e zoom. + /// Distanza in pixel dal centro dello schermo. + /// Raggio oltre il quale non si sente (di solito metà della diagonale). + public static float TrainGain(float distancePx, float radiusPx, float speedMs, float zoom) + { + if (radiusPx <= 0) return 0; + float near = 1 - Clamp01(distancePx / radiusPx); + float speed = Clamp01(speedMs / FullSpeedMs); + return near * near * (0.25f + 0.75f * speed) * (0.15f + 0.85f * Closeness(zoom)); + } + + /// Intonazione del rotolamento: più rapido e acuto con la velocità. + public static float RumblePitch(float speedMs) => 0.55f + 1.0f * Clamp01(speedMs / FullSpeedMs); + + /// Intonazione del motore (diesel o elettrico) con la velocità. + public static float EnginePitch(float speedMs) => 0.8f + 0.5f * Clamp01(speedMs / FullSpeedMs); + + /// Secondi tra due sbuffi della vaporiera alla velocità data. + public static float ChuffInterval(float speedMs) => Math.Clamp(ChuffSpacingM / MathF.Max(speedMs, 0.5f), 0.09f, 1.2f); + + /// + /// Inserisce un candidato nell'elenco ordinato dei più vicini (al più ids.Length): nessuna + /// allocazione, gli elenchi sono preparati una volta sola. Restituisce il nuovo conteggio. + /// + public static int InsertNearest(int[] ids, float[] distances, int count, int id, float distance) + { + int capacity = ids.Length; + if (count == capacity && distance >= distances[capacity - 1]) return count; + int i = Math.Min(count, capacity - 1); + while (i > 0 && distances[i - 1] > distance) + { + ids[i] = ids[i - 1]; + distances[i] = distances[i - 1]; + i--; + } + ids[i] = id; + distances[i] = distance; + return Math.Min(count + 1, capacity); + } + + /// Era dell'anno: l'ultima il cui inizio («from» di eras.json, crescente) non è dopo l'anno. + public static int EraIndex(int year, IReadOnlyList froms) + { + int index = 0; + for (int i = 0; i < froms.Count; i++) + { + if (froms[i] <= year) index = i; + } + return index; + } + + /// Avvicina un valore al bersaglio con velocità costante (unità al secondo). + public static float Approach(float current, float target, float ratePerSecond, float dt) + { + float step = ratePerSecond * dt; + return current < target ? MathF.Min(target, current + step) : MathF.Max(target, current - step); + } + + /// Lineare → decibel, con −80 dB come silenzio. + public static float LinearToDb(float linear) => linear <= 0.0001f ? -80f : 20f * MathF.Log10(linear); + + /// Campioni in [−1, 1] → PCM a 16 bit little-endian (formato di AudioStreamWAV). + public static byte[] ToPcm16(float[] samples) + { + var bytes = new byte[samples.Length * 2]; + for (int i = 0; i < samples.Length; i++) + { + short s = (short)Math.Clamp((int)MathF.Round(samples[i] * 32767f), short.MinValue, short.MaxValue); + bytes[2 * i] = (byte)s; + bytes[2 * i + 1] = (byte)(s >> 8); + } + return bytes; + } +} diff --git a/client/RailEnterprise.Client/scripts/Audio/AudioSettings.cs b/client/RailEnterprise.Client/scripts/Audio/AudioSettings.cs new file mode 100644 index 0000000..3fadbc5 --- /dev/null +++ b/client/RailEnterprise.Client/scripts/Audio/AudioSettings.cs @@ -0,0 +1,91 @@ +using Godot; + +namespace RailEnterprise.Client.Audio; + +/// Bus audio del client: Master e quattro bus che vi confluiscono. +public static class AudioBuses +{ + public const string Master = "Master"; + public const string Music = "Music"; + public const string Ambience = "Ambience"; + public const string Sfx = "Sfx"; + public const string Ui = "Ui"; + + /// Nell'ordine dei cursori delle impostazioni. + public static readonly string[] All = [Master, Music, Ambience, Sfx, Ui]; + + /// + /// Crea i bus che mancano (idempotente: chiamarla più volte non ne aggiunge altri) e un + /// limitatore sul Master, così la somma di musica, ambiente ed effetti non satura. + /// + public static void Ensure() + { + foreach (string name in All) + { + if (name == Master || AudioServer.GetBusIndex(name) >= 0) continue; + int index = AudioServer.BusCount; + AudioServer.AddBus(index); + AudioServer.SetBusName(index, name); + AudioServer.SetBusSend(index, Master); + } + bool limited = false; + for (int i = 0; i < AudioServer.GetBusEffectCount(0); i++) + { + if (AudioServer.GetBusEffect(0, i) is AudioEffectHardLimiter) limited = true; + } + if (!limited) AudioServer.AddBusEffect(0, new AudioEffectHardLimiter { CeilingDb = -0.5f }); + } +} + +/// +/// Volumi per bus (0–1) e muto generale, salvati nella sezione «audio» di +/// user://settings.cfg (lo stesso file della lingua e del server). +/// +public sealed class AudioSettings +{ + public const string Path = "user://settings.cfg"; + private const string Section = "audio"; + + private static readonly float[] Defaults = [0.8f, 0.55f, 0.7f, 0.8f, 0.7f]; + + /// Volumi nell'ordine di . + public float[] Volumes { get; } = (float[])Defaults.Clone(); + + public bool Muted { get; set; } + + public static AudioSettings Load() + { + var s = new AudioSettings(); + var cfg = new ConfigFile(); + if (cfg.Load(Path) != Error.Ok) return s; + for (int i = 0; i < AudioBuses.All.Length; i++) + { + float v = (float)(double)cfg.GetValue(Section, Key(i), Defaults[i]); + s.Volumes[i] = Math.Clamp(v, 0, 1); + } + s.Muted = (bool)cfg.GetValue(Section, "muted", false); + return s; + } + + public void Save() + { + var cfg = new ConfigFile(); + cfg.Load(Path); + for (int i = 0; i < AudioBuses.All.Length; i++) cfg.SetValue(Section, Key(i), Volumes[i]); + cfg.SetValue(Section, "muted", Muted); + cfg.Save(Path); + } + + private static string Key(int i) => AudioBuses.All[i].ToLowerInvariant(); + + /// Applica volumi e muto ai bus (il cursore segue il volume percepito: guadagno = valore²). + public void Apply() + { + for (int i = 0; i < AudioBuses.All.Length; i++) + { + int bus = AudioServer.GetBusIndex(AudioBuses.All[i]); + if (bus >= 0) AudioServer.SetBusVolumeDb(bus, AudioMix.LinearToDb(Volumes[i] * Volumes[i])); + } + AudioServer.SetBusMute(0, Muted); + } +} diff --git a/client/RailEnterprise.Client/scripts/Audio/AudioSettingsPanel.cs b/client/RailEnterprise.Client/scripts/Audio/AudioSettingsPanel.cs new file mode 100644 index 0000000..ef94c42 --- /dev/null +++ b/client/RailEnterprise.Client/scripts/Audio/AudioSettingsPanel.cs @@ -0,0 +1,105 @@ +using Godot; +using RailEnterprise.Client.App; +using static RailEnterprise.Client.App.Localization; + +namespace RailEnterprise.Client.Audio; + +/// +/// Pannello «Audio» sopra a tutto: un cursore per bus (generale, musica, ambiente, effetti, +/// interfaccia) e il muto generale. I cambi si sentono subito; alla chiusura si salvano in +/// user://settings.cfg. Esc o un clic fuori chiudono. +/// +public partial class AudioSettingsPanel : Control +{ + private readonly AudioManager _audio; + private readonly List<(HSlider Slider, Label Value)> _rows = []; + private readonly CheckBox _mute = new() { Text = T("Muto") }; + + private static readonly string[] Captions = ["Volume generale", "Musica", "Ambiente", "Effetti", "Interfaccia"]; + + public AudioSettingsPanel(AudioManager audio) => _audio = audio; + + public override void _Ready() + { + SetAnchorsAndOffsetsPreset(LayoutPreset.FullRect); + UiTheme.Apply(this); + var shade = new ColorRect { Color = new Color(0, 0, 0, 0.5f), MouseFilter = MouseFilterEnum.Stop }; + shade.SetAnchorsPreset(LayoutPreset.FullRect); + shade.GuiInput += e => + { + if (e is InputEventMouseButton { Pressed: true }) Close(); + }; + AddChild(shade); + var center = new CenterContainer { MouseFilter = MouseFilterEnum.Ignore }; + center.SetAnchorsPreset(LayoutPreset.FullRect); + AddChild(center); + var panel = new PanelContainer { CustomMinimumSize = new Vector2(440, 0) }; + center.AddChild(panel); + var col = new VBoxContainer(); + col.AddThemeConstantOverride("separation", 12); + panel.AddChild(col); + col.AddChild(UiTheme.TitleLabel(T("Audio"), 34)); + + for (int i = 0; i < Captions.Length; i++) + { + int bus = i; + var row = new HBoxContainer(); + row.AddThemeConstantOverride("separation", 12); + var caption = UiTheme.Text(T(Captions[i]), 14, Palette.TextSecondary); + caption.CustomMinimumSize = new Vector2(150, 0); + row.AddChild(caption); + var slider = new HSlider + { + MinValue = 0, MaxValue = 1, Step = 0.05, SizeFlagsHorizontal = SizeFlags.ExpandFill, + SizeFlagsVertical = SizeFlags.ShrinkCenter, Value = _audio.Settings.Volumes[i], + }; + var value = UiTheme.Text("", 14, bold: true); + value.CustomMinimumSize = new Vector2(48, 0); + value.HorizontalAlignment = HorizontalAlignment.Right; + slider.ValueChanged += v => _audio.SetVolume(bus, (float)v); + row.AddChild(slider); + row.AddChild(value); + col.AddChild(row); + _rows.Add((slider, value)); + } + _mute.ButtonPressed = _audio.Settings.Muted; + _mute.Toggled += on => _audio.SetMuted(on); + col.AddChild(_mute); + var hint = UiTheme.Text(T("Il tasto M attiva e toglie il muto durante la partita."), 13, Palette.TextSecondary); + hint.AutowrapMode = TextServer.AutowrapMode.WordSmart; + col.AddChild(hint); + var close = UiTheme.Primary(T("Chiudi")); + close.Pressed += Close; + col.AddChild(close); + _audio.SettingsChanged += Refresh; + Refresh(); + } + + public override void _ExitTree() => _audio.SettingsChanged -= Refresh; + + private void Refresh() + { + for (int i = 0; i < _rows.Count; i++) + { + _rows[i].Slider.SetValueNoSignal(_audio.Settings.Volumes[i]); + _rows[i].Value.Text = $"{Math.Round(_audio.Settings.Volumes[i] * 100):0} %"; + } + _mute.SetPressedNoSignal(_audio.Settings.Muted); + } + + public override void _Input(InputEvent e) + { + if (e is InputEventKey { Pressed: true, Keycode: Key.Escape }) + { + Close(); + GetViewport().SetInputAsHandled(); + } + } + + private void Close() + { + if (IsQueuedForDeletion()) return; + _audio.SaveSettings(); + QueueFree(); + } +} diff --git a/client/RailEnterprise.Client/scripts/Audio/MusicComposer.cs b/client/RailEnterprise.Client/scripts/Audio/MusicComposer.cs new file mode 100644 index 0000000..fd2431a --- /dev/null +++ b/client/RailEnterprise.Client/scripts/Audio/MusicComposer.cs @@ -0,0 +1,303 @@ +namespace RailEnterprise.Client.Audio; + +/// +/// Temi musicali procedurali per era, senza dipendenze da Godot. Ogni era ha uno stile (tempo, +/// metro, scala, timbri: valzer da carillon e fisarmonica per il vapore, organo e basso che +/// cammina per il diesel, vibrafono e archi per l'elettrico, arpeggi a impulsi per l'alta +/// velocità); progressione, arpeggio e melodia escono da un seme fisso (hash dell'id dell'era), +/// quindi lo stesso tema a ogni avvio. Forma in 16 battute: introduzione (accompagnamento), +/// melodia, melodia variata, coda; le code delle note rientrano dall'inizio, così l'anello si +/// ripete senza scatti. Uscita mono a Hz. +/// +public static class MusicComposer +{ + public const int Bars = 16; + + public enum Timbre { MusicBox, Accordion, Organ, Vibraphone, Strings, Pulse, Saw, SoftBass, PluckBass } + + public enum Comping { Held, Waltz } + + /// Stile di un'era. + public sealed record Style(int Bpm, int BeatsPerBar, int[] Scale, int RootMidi, Timbre Pad, Comping Comping, + Timbre Arp, int ArpPerBeat, Timbre Lead, Timbre Bass, bool WalkingBass, float Swing); + + private static readonly int[] Major = [0, 2, 4, 5, 7, 9, 11]; + private static readonly int[] Mixolydian = [0, 2, 4, 5, 7, 9, 10]; + private static readonly int[] Dorian = [0, 2, 3, 5, 7, 9, 10]; + + /// Progressioni per grado della scala (0 = primo grado), una battuta per accordo. + private static readonly int[][] Progressions = + [ + [0, 3, 4, 0], [0, 5, 3, 4], [0, 4, 5, 3], [1, 4, 0, 5], [5, 3, 0, 4], [0, 3, 1, 4], + ]; + + /// Stile dell'era per posizione nell'elenco di eras.json (le ere oltre la quarta riprendono il ciclo). + public static Style StyleFor(int eraIndex) => (Math.Max(0, eraIndex) % 4) switch + { + 0 => new Style(116, 3, Major, 62, Timbre.Accordion, Comping.Waltz, Timbre.MusicBox, 0, Timbre.MusicBox, Timbre.SoftBass, false, 0), + 1 => new Style(96, 4, Mixolydian, 60, Timbre.Organ, Comping.Held, Timbre.Vibraphone, 1, Timbre.Organ, Timbre.PluckBass, true, 0.18f), + 2 => new Style(104, 4, Major, 65, Timbre.Strings, Comping.Held, Timbre.Vibraphone, 2, Timbre.Vibraphone, Timbre.SoftBass, false, 0), + _ => new Style(124, 4, Dorian, 57, Timbre.Saw, Comping.Held, Timbre.Pulse, 4, Timbre.Saw, Timbre.SoftBass, false, 0), + }; + + /// Seme fisso del tema: hash dell'id dell'era e della sua posizione. + public static ulong Seed(int eraIndex, string eraId) => SynthRng.Hash(eraId) ^ ((ulong)(eraIndex + 1) * 0x9E3779B97F4A7C15UL); + + /// Durata dell'anello in secondi. + public static float LengthSeconds(Style style) => Bars * style.BeatsPerBar * 60f / style.Bpm; + + // ------------------------------------------------------------------ timbri + + private sealed class Voice + { + public required float[] Table { get; init; } + public float Attack { get; init; } = 0.005f; + /// Decadimento verso il sostegno (s). + public float Decay { get; init; } = 0.3f; + public float Sustain { get; init; } + public float Release { get; init; } = 0.1f; + /// Copie leggermente scordate (coro). + public float[] Detune { get; init; } = [0]; + public float TremoloHz { get; init; } + public float TremoloDepth { get; init; } + public float VibratoDepth { get; init; } + } + + private const int TableSize = 2048; + + /// Forma d'onda di un periodo dalla somma di armoniche (ampiezza della n-esima in harmonics[n−1]). + private static float[] Table(params float[] harmonics) + { + var t = new float[TableSize]; + for (int i = 0; i < TableSize; i++) + { + float x = MathF.PI * 2 * i / TableSize; + float v = 0; + for (int h = 0; h < harmonics.Length; h++) v += harmonics[h] * MathF.Sin(x * (h + 1)); + t[i] = v; + } + Synth.Normalize(t, 1); + return t; + } + + private static float[] SawHarmonics(int n) + { + var h = new float[n]; + for (int i = 0; i < n; i++) h[i] = 1f / (i + 1); + return h; + } + + private static float[] PulseHarmonics(int n, float duty) + { + var h = new float[n]; + for (int i = 0; i < n; i++) h[i] = MathF.Abs(MathF.Sin(MathF.PI * (i + 1) * duty)) / (i + 1); + return h; + } + + private static Voice VoiceFor(Timbre timbre) => timbre switch + { + Timbre.MusicBox => new Voice { Table = Table(1, 0.1f, 0.35f, 0, 0.12f), Attack = 0.002f, Decay = 0.7f, Sustain = 0, Release = 0.6f }, + Timbre.Accordion => new Voice { Table = Table(1, 0.5f, 0.6f, 0.3f, 0.25f, 0.15f), Attack = 0.03f, Decay = 0.2f, Sustain = 0.8f, Release = 0.08f, Detune = [0, 0.004f], TremoloHz = 5, TremoloDepth = 0.12f }, + Timbre.Organ => new Voice { Table = Table(1, 0.8f, 0.6f, 0.4f, 0, 0.3f, 0, 0.2f), Attack = 0.01f, Decay = 0.1f, Sustain = 0.9f, Release = 0.06f, TremoloHz = 6, TremoloDepth = 0.1f }, + Timbre.Vibraphone => new Voice { Table = Table(1, 0, 0, 0.25f), Attack = 0.003f, Decay = 1.1f, Sustain = 0, Release = 0.8f, TremoloHz = 5, TremoloDepth = 0.3f }, + Timbre.Strings => new Voice { Table = Table(SawHarmonics(8)), Attack = 0.3f, Decay = 0.5f, Sustain = 0.85f, Release = 0.35f, Detune = [-0.003f, 0, 0.003f], VibratoDepth = 0.003f }, + Timbre.Pulse => new Voice { Table = Table(PulseHarmonics(9, 0.25f)), Attack = 0.004f, Decay = 0.22f, Sustain = 0, Release = 0.15f }, + Timbre.Saw => new Voice { Table = Table(SawHarmonics(10)), Attack = 0.08f, Decay = 0.4f, Sustain = 0.7f, Release = 0.25f, Detune = [-0.005f, 0.005f], VibratoDepth = 0.002f }, + Timbre.PluckBass => new Voice { Table = Table(1, 0.5f, 0.25f, 0.1f), Attack = 0.005f, Decay = 0.35f, Sustain = 0.15f, Release = 0.08f }, + _ => new Voice { Table = Table(1, 0.3f, 0.1f), Attack = 0.01f, Decay = 0.4f, Sustain = 0.6f, Release = 0.1f }, + }; + + private static float Frequency(float midi) => 440f * MathF.Pow(2, (midi - 69) / 12f); + + /// Suona una nota nell'anello (con la coda che rientra dall'inizio). + private static void Note(float[] loop, Voice v, float startS, float durS, float midi, float gain) + { + int rate = Synth.Rate; + float f = Frequency(midi); + int start = (int)(startS * rate); + float total = durS + v.Release; + int samples = Math.Min(loop.Length, (int)(total * rate)); + foreach (float detune in v.Detune) + { + float inc = f * (1 + detune) * TableSize / rate; + float phase = (detune + 0.5f) * 97 % TableSize; + float g = gain / v.Detune.Length; + for (int i = 0; i < samples; i++) + { + float t = i / (float)rate; + float env = t < v.Attack ? t / v.Attack : v.Sustain + (1 - v.Sustain) * MathF.Exp(-(t - v.Attack) / v.Decay); + if (t > durS) + { + // rilascio dal livello raggiunto alla fine della nota + float atEnd = durS < v.Attack ? durS / v.Attack : v.Sustain + (1 - v.Sustain) * MathF.Exp(-(durS - v.Attack) / v.Decay); + env = atEnd * MathF.Max(0, 1 - (t - durS) / v.Release); + } + if (v.TremoloDepth > 0) env *= 1 - v.TremoloDepth * (0.5f + 0.5f * MathF.Sin(MathF.PI * 2 * v.TremoloHz * t)); + float step = v.VibratoDepth > 0 ? inc * (1 + v.VibratoDepth * MathF.Sin(MathF.PI * 2 * 5.5f * t)) : inc; + phase += step; + if (phase >= TableSize) phase -= TableSize; + int i0 = (int)phase; + float frac = phase - i0; + float s = v.Table[i0] + (v.Table[(i0 + 1) & (TableSize - 1)] - v.Table[i0]) * frac; + loop[(start + i) % loop.Length] += s * env * g; + } + } + } + + /// Altezza MIDI del grado della scala (i gradi oltre la scala salgono d'ottava). + private static int Degree(Style s, int degree) + { + int n = s.Scale.Length; + int octave = (int)Math.Floor(degree / (double)n); + int d = degree - octave * n; + return s.RootMidi + s.Scale[d] + 12 * octave; + } + + /// Compone e sintetizza il tema dell'era: campioni mono in [−1, 1]. + public static float[] Compose(int eraIndex, string eraId) + { + var style = StyleFor(eraIndex); + var rng = new SynthRng(Seed(eraIndex, eraId)); + float beat = 60f / style.Bpm; + float bar = beat * style.BeatsPerBar; + var loop = new float[(int)(LengthSeconds(style) * Synth.Rate)]; + var progression = Progressions[rng.Next(Progressions.Length)]; + var pad = VoiceFor(style.Pad); + var arp = VoiceFor(style.Arp); + var lead = VoiceFor(style.Lead); + var bass = VoiceFor(style.Bass); + bool arpDown = rng.Next(2) == 0; + + // motivo di quattro battute: un ritmo per battuta (in ottavi) e gradi vicini all'accordo + int eighths = style.BeatsPerBar * 2; + var motif = new List<(int Bar, int Eighth, int Length, int Degree)>(); + int current = 7 + progression[0]; + for (int b = 0; b < 4; b++) + { + int chord = progression[b]; + int e = 0; + while (e < eighths) + { + int len = rng.Next(4) switch { 0 => 1, 1 or 2 => 2, _ => 3 }; + len = Math.Min(len, eighths - e); + if (rng.Next(5) == 0 && e > 0) + { + e += len; // pausa + continue; + } + bool strong = e % (style.BeatsPerBar == 3 ? 6 : 4) == 0; + if (strong) + { + // sui tempi forti una nota dell'accordo vicina alla precedente + int best = current, bestD = int.MaxValue; + for (int k = -1; k <= 2; k++) + { + foreach (int ct in new[] { 0, 2, 4 }) + { + int cand = chord + ct + 7 * k; + int dist = Math.Abs(cand - current); + if (cand >= 4 && cand <= 13 && dist < bestD) + { + bestD = dist; + best = cand; + } + } + } + current = best; + } + else current = Math.Clamp(current + rng.Next(5) - 2, 4, 13); + motif.Add((b, e, len, current)); + e += len; + } + } + // l'ultima nota del motivo torna sulla tonica + if (motif.Count > 0) motif[^1] = motif[^1] with { Degree = 7 }; + + for (int barIndex = 0; barIndex < Bars; barIndex++) + { + int chord = progression[barIndex % 4]; + float t0 = barIndex * bar; + int[] tones = [Degree(style, chord), Degree(style, chord + 2), Degree(style, chord + 4)]; + + // accompagnamento + if (style.Comping == Comping.Waltz) + { + for (int k = 1; k < style.BeatsPerBar; k++) + foreach (int m in tones) Note(loop, pad, t0 + k * beat, beat * 0.55f, m, 0.11f); + } + else + { + foreach (int m in tones) Note(loop, pad, t0, bar * 0.95f, m, 0.12f); + } + + // basso: fondamentale (e quinta) o basso che cammina sulle note dell'accordo + int root = Degree(style, chord) - 24; + if (style.WalkingBass) + { + int next = Degree(style, progression[(barIndex + 1) % 4]) - 24; + int[] walk = [root, root + (tones[1] - tones[0]), root + 7, next + (next > root ? -1 : 1)]; + for (int k = 0; k < style.BeatsPerBar; k++) Note(loop, bass, t0 + k * beat, beat * 0.9f, walk[k % walk.Length], 0.32f); + } + else if (style.Comping == Comping.Waltz) Note(loop, bass, t0, beat * 0.9f, root, 0.34f); + else + { + Note(loop, bass, t0, beat * 1.8f, root, 0.32f); + Note(loop, bass, t0 + 2 * beat, beat * 1.8f, root + 7, 0.26f); + } + + // arpeggio (in introduzione e coda più presente) + if (style.ArpPerBeat > 0) + { + int steps = style.BeatsPerBar * style.ArpPerBeat; + float step = beat / style.ArpPerBeat; + float gain = barIndex is < 4 or >= 12 ? 0.13f : 0.08f; + for (int k = 0; k < steps; k++) + { + int idx = arpDown ? 3 - k % 4 : k % 4; + int m = idx < 3 ? tones[idx] + 12 : tones[0] + 24; + float swing = style.Swing > 0 && k % 2 == 1 ? style.Swing * step : 0; + Note(loop, arp, t0 + k * step + swing, step * 0.8f, m, gain); + } + } + + // melodia nelle battute 4–11 (la seconda volta un'ottava sopra le ultime due battute) + if (barIndex is >= 4 and < 12) + { + int motifBar = barIndex % 4; + bool variation = barIndex >= 8; + foreach (var n in motif) + { + if (n.Bar != motifBar) continue; + float eighth = beat / 2; + float swing = style.Swing > 0 && n.Eighth % 2 == 1 ? style.Swing * eighth : 0; + int midi = Degree(style, n.Degree) + (variation && motifBar >= 2 ? 12 : 0); + Note(loop, lead, t0 + n.Eighth * eighth + swing, n.Length * eighth * 0.92f, midi, 0.2f); + } + } + } + + // un po' di spazio: due echi smorzati sull'anello, poi limitazione morbida + Echo(loop, 0.27f, 0.22f); + Echo(loop, 0.41f, 0.15f); + Synth.Normalize(loop, 1); + for (int i = 0; i < loop.Length; i++) loop[i] = MathF.Tanh(loop[i] * 1.2f) * 0.7f; + return loop; + } + + /// Eco con retroazione su un anello (due giri per la continuità all'inizio). + private static void Echo(float[] loop, float delayS, float feedback) + { + int d = Math.Max(1, (int)(delayS * Synth.Rate)); + var lp = Biquad.LowPass(2500, 0.7f, Synth.Rate); + var wet = new float[loop.Length]; + for (int pass = 0; pass < 2; pass++) + { + for (int i = 0; i < loop.Length; i++) + { + int j = (i - d + loop.Length) % loop.Length; + wet[i] = lp.Process(loop[j] + wet[j] * feedback) * feedback; + } + } + for (int i = 0; i < loop.Length; i++) loop[i] += wet[i]; + } +} diff --git a/client/RailEnterprise.Client/scripts/Audio/SpeakerButton.cs b/client/RailEnterprise.Client/scripts/Audio/SpeakerButton.cs new file mode 100644 index 0000000..bd4422d --- /dev/null +++ b/client/RailEnterprise.Client/scripts/Audio/SpeakerButton.cs @@ -0,0 +1,49 @@ +using Godot; +using RailEnterprise.Client.App; +using static RailEnterprise.Client.App.Localization; + +namespace RailEnterprise.Client.Audio; + +/// Altoparlante nella barra superiore: apre il pannello «Audio»; barrato quando il muto è attivo. +public partial class SpeakerButton : Button +{ + public SpeakerButton() + { + Flat = true; + CustomMinimumSize = new Vector2(40, 40); + TooltipText = T("Audio (M: muto)"); + Pressed += () => AudioManager.Instance?.ShowSettings(); + MouseEntered += QueueRedraw; + MouseExited += QueueRedraw; + } + + public override void _EnterTree() + { + if (AudioManager.Instance is { } audio) audio.SettingsChanged += QueueRedraw; + } + + public override void _ExitTree() + { + if (AudioManager.Instance is { } audio) audio.SettingsChanged -= QueueRedraw; + } + + public override void _Draw() + { + bool muted = AudioManager.Instance?.Settings.Muted ?? false; + var col = IsHovered() ? Palette.AmberLight : muted ? Palette.TextSecondary : Palette.Text; + var c = Size / 2; + const float w = 2f; + // cassa e cono + DrawColoredPolygon([c + new Vector2(-10, -4), c + new Vector2(-5, -4), c + new Vector2(1, -10), c + new Vector2(1, 10), c + new Vector2(-5, 4), c + new Vector2(-10, 4)], col); + if (muted) + { + DrawLine(c + new Vector2(5, -5), c + new Vector2(13, 5), Palette.Danger, w); + DrawLine(c + new Vector2(13, -5), c + new Vector2(5, 5), Palette.Danger, w); + } + else + { + DrawArc(c + new Vector2(1, 0), 6, -0.9f, 0.9f, 10, col, w); + DrawArc(c + new Vector2(1, 0), 11, -0.9f, 0.9f, 14, col, w); + } + } +} diff --git a/client/RailEnterprise.Client/scripts/Audio/Synth.cs b/client/RailEnterprise.Client/scripts/Audio/Synth.cs new file mode 100644 index 0000000..4133028 --- /dev/null +++ b/client/RailEnterprise.Client/scripts/Audio/Synth.cs @@ -0,0 +1,554 @@ +namespace RailEnterprise.Client.Audio; + +/// +/// Generatore pseudo-casuale xorshift64* per la sintesi dei suoni. Non è il Rng della +/// simulazione: serve solo a rendere ripetibili rumori, variazioni e temi musicali del client. +/// +public struct SynthRng +{ + private ulong _s; + + public SynthRng(ulong seed) => _s = seed == 0 ? 0x9E3779B97F4A7C15UL : seed; + + public ulong NextU64() + { + _s ^= _s >> 12; + _s ^= _s << 25; + _s ^= _s >> 27; + return _s * 2685821657736338717UL; + } + + /// Numero in [0, 1). + public float Next01() => (NextU64() >> 40) * (1f / (1 << 24)); + + /// Numero in [−1, 1). + public float NextSigned() => Next01() * 2f - 1f; + + /// Intero in [0, n). + public int Next(int n) => (int)((NextU64() >> 33) % (ulong)n); + + /// Numero in [a, b). + public float Range(float a, float b) => a + (b - a) * Next01(); + + /// FNV-1a a 64 bit di una stringa: semi fissi derivati da un identificatore (per esempio l'id dell'era). + public static ulong Hash(string text) + { + ulong h = 14695981039346656037UL; + foreach (char c in text) + { + h ^= c; + h *= 1099511628211UL; + } + return h; + } +} + +/// Filtro biquadratico (formule RBJ): passa-basso, passa-alto, passa-banda a guadagno di picco unitario. +public struct Biquad +{ + private float _b0, _b1, _b2, _a1, _a2, _z1, _z2; + + private static Biquad Make(float b0, float b1, float b2, float a0, float a1, float a2) => + new() { _b0 = b0 / a0, _b1 = b1 / a0, _b2 = b2 / a0, _a1 = a1 / a0, _a2 = a2 / a0 }; + + private static (float Cos, float Alpha) W(float freq, float q, int rate) + { + float w0 = 2 * MathF.PI * Math.Clamp(freq, 1, rate * 0.45f) / rate; + return (MathF.Cos(w0), MathF.Sin(w0) / (2 * q)); + } + + public static Biquad LowPass(float freq, float q, int rate) + { + var (c, a) = W(freq, q, rate); + return Make((1 - c) / 2, 1 - c, (1 - c) / 2, 1 + a, -2 * c, 1 - a); + } + + public static Biquad HighPass(float freq, float q, int rate) + { + var (c, a) = W(freq, q, rate); + return Make((1 + c) / 2, -(1 + c), (1 + c) / 2, 1 + a, -2 * c, 1 - a); + } + + public static Biquad BandPass(float freq, float q, int rate) + { + var (c, a) = W(freq, q, rate); + return Make(a, 0, -a, 1 + a, -2 * c, 1 - a); + } + + /// Cambia i coefficienti mantenendo lo stato (filtri a frequenza variabile). + public void Retune(Biquad coefficients) + { + _b0 = coefficients._b0; + _b1 = coefficients._b1; + _b2 = coefficients._b2; + _a1 = coefficients._a1; + _a2 = coefficients._a2; + } + + public float Process(float x) + { + float y = _b0 * x + _z1; + _z1 = _b1 * x - _a1 * y + _z2; + _z2 = _b2 * x - _a2 * y; + return y; + } +} + +/// +/// Sintesi procedurale di tutti gli effetti del gioco, senza dipendenze da Godot: ogni funzione +/// restituisce campioni mono in virgola mobile a Hz, da convertire in PCM a +/// 16 bit con . Gli anelli («Loop») si ripetono senza scatti: i +/// filtri girano due volte sullo stesso rumore (la seconda passata parte dallo stato della fine), +/// le modulazioni hanno un numero intero di periodi nell'anello e le code degli eventi brevi +/// rientrano dall'inizio. Semi fissi: stesso suono a ogni avvio. +/// +public static class Synth +{ + /// Frequenza di campionamento di tutti i suoni (Hz). + public const int Rate = 22050; + + private const float Tau = MathF.PI * 2; + + public static float[] Buffer(float seconds) => new float[Math.Max(1, (int)(seconds * Rate))]; + + /// Inviluppo attacco lineare e decadimento esponenziale. + public static float Env(float t, float attack, float decay) => + t < 0 ? 0 : t < attack ? t / attack : MathF.Exp(-(t - attack) / decay); + + /// Porta il picco al valore indicato. + public static void Normalize(float[] buffer, float peak) + { + float max = 0; + foreach (float s in buffer) max = Math.Max(max, Math.Abs(s)); + if (max < 1e-6f) return; + float k = peak / max; + for (int i = 0; i < buffer.Length; i++) buffer[i] *= k; + } + + /// Sfuma gli ultimi millisecondi di un suono singolo (niente scatto alla fine). + public static void FadeOut(float[] buffer, float seconds = 0.01f) + { + int n = Math.Min(buffer.Length, (int)(seconds * Rate)); + for (int i = 0; i < n; i++) buffer[buffer.Length - 1 - i] *= i / (float)n; + } + + /// Rumore bianco ripetibile. + public static float[] Noise(int length, ulong seed) + { + var rng = new SynthRng(seed); + var n = new float[length]; + for (int i = 0; i < length; i++) n[i] = rng.NextSigned(); + return n; + } + + /// Filtra un anello due volte: la seconda passata riparte dallo stato della fine della prima. + public static float[] LoopFilter(float[] input, Biquad filter) + { + var output = new float[input.Length]; + for (int pass = 0; pass < 2; pass++) + { + for (int i = 0; i < input.Length; i++) output[i] = filter.Process(input[i]); + } + return output; + } + + /// Rumore marrone in anello: integrazione con perdita del rumore bianco, due passate. + public static float[] BrownLoop(int length, ulong seed, float leak) + { + var white = Noise(length, seed); + var brown = new float[length]; + float acc = 0; + for (int pass = 0; pass < 2; pass++) + { + for (int i = 0; i < length; i++) + { + acc = acc * leak + white[i] * (1 - leak) * 10; + brown[i] = acc; + } + } + return brown; + } + + /// Somma un suono breve nell'anello a partire da «at» campioni, con la coda che rientra dall'inizio. + public static void MixWrapped(float[] loop, float[] sound, int at, float gain) + { + for (int i = 0; i < sound.Length; i++) loop[(at + i) % loop.Length] += sound[i] * gain; + } + + // ------------------------------------------------------------------ interfaccia + + /// Clic dell'interfaccia: un colpetto secco e brillante. + public static float[] Click() + { + var b = Buffer(0.035f); + var noise = Noise(b.Length, 11); + var hp = Biquad.HighPass(2500, 0.7f, Rate); + for (int i = 0; i < b.Length; i++) + { + float t = i / (float)Rate; + b[i] = MathF.Sin(Tau * 1800 * t) * MathF.Exp(-t / 0.006f) * 0.6f + hp.Process(noise[i]) * MathF.Exp(-t / 0.003f) * 0.5f; + } + Normalize(b, 0.5f); + FadeOut(b, 0.005f); + return b; + } + + /// Nota con armoniche (ampiezze in «harmonics», la prima è la fondamentale) e decadimento esponenziale. + private static void Tone(float[] b, float start, float freq, float decay, float gain, float[] harmonics) + { + int s0 = (int)(start * Rate); + for (int i = s0; i < b.Length; i++) + { + float t = (i - s0) / (float)Rate; + float env = Env(t, 0.005f, decay); + if (env < 1e-4f && t > 0.01f) break; + float v = 0; + for (int h = 0; h < harmonics.Length; h++) + { + float f = freq * (h + 1); + if (harmonics[h] != 0 && f < Rate * 0.45f) v += harmonics[h] * MathF.Sin(Tau * f * t); + } + b[i] += v * env * gain; + } + } + + /// Esito positivo di un comando: due note ascendenti (la, mi). + public static float[] Confirm() + { + var b = Buffer(0.32f); + float[] h = [1, 0.3f]; + Tone(b, 0, 880, 0.09f, 1, h); + Tone(b, 0.07f, 1318.5f, 0.11f, 0.9f, h); + Normalize(b, 0.42f); + FadeOut(b); + return b; + } + + /// Comando rifiutato: due note scure discendenti. + public static float[] Error() + { + var b = Buffer(0.38f); + float[] h = [1, 0, 0.33f, 0, 0.2f]; + Tone(b, 0, 330, 0.12f, 1, h); + Tone(b, 0.1f, 247, 0.14f, 1, h); + var lp = Biquad.LowPass(1800, 0.7f, Rate); + for (int i = 0; i < b.Length; i++) b[i] = lp.Process(b[i]); + Normalize(b, 0.45f); + FadeOut(b); + return b; + } + + /// Campana in modulazione di frequenza (portante f, modulante 1,4·f, indice che decade). + private static void Bell(float[] b, float start, float freq, float gain, float decay = 0.6f) + { + int s0 = (int)(start * Rate); + for (int i = s0; i < b.Length; i++) + { + float t = (i - s0) / (float)Rate; + float index = 2.5f * MathF.Exp(-t / 0.3f); + b[i] += MathF.Sin(Tau * freq * t + index * MathF.Sin(Tau * freq * 1.4f * t)) * Env(t, 0.003f, decay) * gain; + } + } + + /// Notifica: 0 = informazione o opportunità, 1 = avviso, 2 = critica. + public static float[] Notify(int level) + { + float[] b; + switch (level) + { + case <= 0: + b = Buffer(1.0f); + Bell(b, 0, 1046.5f, 1); + Bell(b, 0.12f, 1568f, 0.6f); + break; + case 1: + b = Buffer(1.2f); + Bell(b, 0, 784f, 1, 0.7f); + Bell(b, 0.18f, 622.3f, 1, 0.7f); + break; + default: + // tre impulsi dissonanti: si distinguono anche sopra la musica + b = Buffer(1.0f); + float[] h = [1, 0, 0.33f, 0, 0.2f]; + for (int k = 0; k < 3; k++) + { + Tone(b, k * 0.22f, 523.3f, 0.09f, 0.8f, h); + Tone(b, k * 0.22f, 554.4f, 0.09f, 0.6f, h); + } + break; + } + Normalize(b, 0.55f); + FadeOut(b); + return b; + } + + /// Cantiere completato: due colpi metallici e un arpeggio maggiore. + public static float[] BuildComplete() + { + var b = Buffer(1.5f); + var noise = Noise(b.Length, 23); + foreach (var (at, gain) in new[] { (0f, 1f), (0.16f, 0.7f) }) + { + int s0 = (int)(at * Rate); + var bp = Biquad.BandPass(2500, 4, Rate); + for (int i = s0; i < b.Length; i++) + { + float t = (i - s0) / (float)Rate; + float metal = MathF.Sin(Tau * 420 * t + 3 * MathF.Exp(-t / 0.08f) * MathF.Sin(Tau * 420 * 2.76f * t)); + b[i] += (bp.Process(noise[i]) * 2 * Env(t, 0.001f, 0.04f) + metal * Env(t, 0.002f, 0.25f)) * gain * 0.6f; + } + } + float[] pluck = [1, 0.4f, 0.15f]; + float[] notes = [523.3f, 659.3f, 784f, 1046.5f]; + for (int k = 0; k < notes.Length; k++) Tone(b, 0.32f + k * 0.08f, notes[k], k == notes.Length - 1 ? 0.35f : 0.15f, 0.7f, pluck); + Normalize(b, 0.55f); + FadeOut(b, 0.05f); + return b; + } + + // ------------------------------------------------------------------ treni + + /// Fischio a vapore all'arrivo: accordo 4:5:6 con salita d'intonazione, vibrato e soffio. + public static float[] SteamWhistle() + { + var b = Buffer(1.35f); + var noise = Noise(b.Length, 31); + var bp = Biquad.BandPass(1500, 1.2f, Rate); + float[] freqs = [520, 650, 780]; + float[] phase = new float[freqs.Length]; + for (int i = 0; i < b.Length; i++) + { + float t = i / (float)Rate; + float amp = t < 0.06f ? t / 0.06f : t < 1.05f ? 1 : MathF.Max(0, 1 - (t - 1.05f) / 0.3f); + float bend = 0.94f + 0.06f * MathF.Min(1, t / 0.08f) - (t > 1.0f ? 0.03f * (t - 1.0f) : 0); + float vib = 1 + 0.004f * MathF.Sin(Tau * 5.5f * t); + float v = 0; + for (int k = 0; k < freqs.Length; k++) + { + phase[k] += Tau * freqs[k] * bend * vib / Rate; + v += MathF.Sin(phase[k]) / (k + 1.5f); + } + b[i] = (v + bp.Process(noise[i]) * 0.25f) * amp; + } + Normalize(b, 0.6f); + FadeOut(b); + return b; + } + + /// Tromba bitonale delle locomotive diesel ed elettriche. + public static float[] Horn() + { + var b = Buffer(0.95f); + float[] freqs = [311.1f, 370f]; + var lp = Biquad.LowPass(2500, 0.7f, Rate); + for (int i = 0; i < b.Length; i++) + { + float t = i / (float)Rate; + float amp = t < 0.03f ? t / 0.03f : t < 0.78f ? 1 : MathF.Max(0, 1 - (t - 0.78f) / 0.15f); + float v = 0; + foreach (float f in freqs) + { + for (int h = 1; h <= 6; h++) v += MathF.Sin(Tau * f * h * t) / h; + } + b[i] = lp.Process(v) * amp; + } + Normalize(b, 0.55f); + FadeOut(b); + return b; + } + + /// Sbuffo del vapore: rumore filtrato a banda con un tonfo grave. + public static float[] Chuff() + { + var b = Buffer(0.17f); + var noise = Noise(b.Length, 41); + var bp = Biquad.BandPass(900, 0.8f, Rate); + var lp = Biquad.LowPass(2500, 0.7f, Rate); + for (int i = 0; i < b.Length; i++) + { + float t = i / (float)Rate; + b[i] = lp.Process(bp.Process(noise[i])) * Env(t, 0.004f, 0.05f) + MathF.Sin(Tau * 70 * t) * Env(t, 0.002f, 0.04f) * 0.5f; + } + Normalize(b, 0.6f); + FadeOut(b, 0.02f); + return b; + } + + /// Rotolamento in anello (1,6 s a intonazione 1): rumore grave e il «tu-tum» dei carrelli sui giunti. + public static float[] RailRumbleLoop() + { + int n = (int)(1.6f * Rate); + var loop = LoopFilter(BrownLoop(n, 53, 0.995f), Biquad.LowPass(300, 0.7f, Rate)); + Normalize(loop, 0.5f); + var clack = Buffer(0.08f); + var cn = Noise(clack.Length, 59); + var bp = Biquad.BandPass(1800, 2, Rate); + for (int i = 0; i < clack.Length; i++) + { + float t = i / (float)Rate; + clack[i] = bp.Process(cn[i]) * 1.5f * Env(t, 0.001f, 0.012f) + MathF.Sin(Tau * 90 * t) * Env(t, 0.002f, 0.03f) * 0.6f; + } + MixWrapped(loop, clack, (int)(0.20f * Rate), 0.8f); + MixWrapped(loop, clack, (int)(0.32f * Rate), 0.7f); + MixWrapped(loop, clack, (int)(1.00f * Rate), 0.75f); + MixWrapped(loop, clack, (int)(1.12f * Rate), 0.65f); + Normalize(loop, 0.6f); + return loop; + } + + /// Motore diesel in anello (1 s): 48 Hz con armoniche e scoppi a 8 Hz. + public static float[] DieselDroneLoop() + { + int n = Rate; + var b = new float[n]; + var noise = LoopFilter(Noise(n, 61), Biquad.LowPass(900, 0.7f, Rate)); + for (int i = 0; i < n; i++) + { + float t = i / (float)Rate; + float v = 0; + for (int h = 1; h <= 10; h++) v += MathF.Sin(Tau * 48 * h * t) / h; + float firing = 0.7f + 0.3f * MathF.Sin(Tau * 8 * t); + b[i] = v * firing * 0.5f + noise[i] * 0.4f; + } + Normalize(b, 0.6f); + return b; + } + + /// Ronzio elettrico in anello (1 s): 100, 200 e 300 Hz e un fischio dei motori. + public static float[] ElectricHumLoop() + { + int n = Rate; + var b = new float[n]; + var hiss = LoopFilter(Noise(n, 67), Biquad.LowPass(3000, 0.7f, Rate)); + for (int i = 0; i < n; i++) + { + float t = i / (float)Rate; + b[i] = 0.4f * MathF.Sin(Tau * 100 * t) + 0.2f * MathF.Sin(Tau * 200 * t) + 0.25f * MathF.Sin(Tau * 300 * t) + + 0.06f * MathF.Sin(Tau * 1150 * t) * (0.6f + 0.4f * MathF.Sin(Tau * t)) + hiss[i] * 0.12f; + } + Normalize(b, 0.5f); + return b; + } + + // ------------------------------------------------------------------ ambiente + + /// Vento e campagna in anello (8 s): rumore con passa-basso mobile e raffiche. + public static float[] WindLoop() + { + const float seconds = 8; + int n = (int)(seconds * Rate); + var white = Noise(n, 71); + var b = new float[n]; + var f = Biquad.LowPass(400, 0.9f, Rate); + for (int pass = 0; pass < 2; pass++) + { + for (int i = 0; i < n; i++) + { + float t = i / (float)Rate; + float g = 0.55f + 0.25f * MathF.Sin(Tau * t / seconds) + 0.2f * MathF.Sin(Tau * 3 * t / seconds + 1.3f); + if ((i & 127) == 0) f.Retune(Biquad.LowPass(250 + 550 * g, 0.9f, Rate)); + b[i] = f.Process(white[i]) * g; + } + } + Normalize(b, 0.5f); + return b; + } + + /// Acqua di fiume in anello (6 s): rumore a banda con un gorgoglio lento e bolle. + public static float[] RiverLoop() + { + const float seconds = 6; + int n = (int)(seconds * Rate); + var main = LoopFilter(Noise(n, 73), Biquad.BandPass(1200, 0.7f, Rate)); + var mod = LoopFilter(Noise(n, 79), Biquad.LowPass(6, 0.7f, Rate)); + Normalize(mod, 1); + var b = new float[n]; + for (int i = 0; i < n; i++) b[i] = main[i] * (0.6f + 0.4f * mod[i]); + Normalize(b, 1); + var rng = new SynthRng(83); + var bubble = Buffer(0.05f); + for (int k = 0; k < 60; k++) + { + float f0 = rng.Range(400, 1000); + for (int i = 0; i < bubble.Length; i++) + { + float t = i / (float)Rate; + bubble[i] = MathF.Sin(Tau * f0 * (1 + 4 * t) * t) * Env(t, 0.002f, 0.012f); + } + MixWrapped(b, bubble, rng.Next(n), rng.Range(0.1f, 0.3f)); + } + Normalize(b, 0.45f); + return b; + } + + /// Mare in anello (10 s): due onde con risacca e schiuma. + public static float[] SeaLoop() + { + const float seconds = 10; + int n = (int)(seconds * Rate); + var low = LoopFilter(Noise(n, 89), Biquad.LowPass(700, 0.7f, Rate)); + var foam = LoopFilter(Noise(n, 97), Biquad.HighPass(3000, 0.7f, Rate)); + var b = new float[n]; + for (int i = 0; i < n; i++) + { + float t = i / (float)Rate; + float s = 0.5f + 0.5f * MathF.Sin(Tau * 2 * t / seconds - MathF.PI / 2); + float swell = 0.35f + 0.65f * s * s; + b[i] = low[i] * swell + foam[i] * swell * swell * 0.3f; + } + Normalize(b, 0.5f); + return b; + } + + /// Città in anello (8 s): brusio grave, voci lontane e qualche colpo di carri e porte. + public static float[] CityLoop() + { + const float seconds = 8; + int n = (int)(seconds * Rate); + var rumble = LoopFilter(BrownLoop(n, 101, 0.996f), Biquad.LowPass(200, 0.7f, Rate)); + Normalize(rumble, 1); + var murmur = LoopFilter(Noise(n, 103), Biquad.BandPass(500, 1, Rate)); + Normalize(murmur, 1); + var mod = LoopFilter(Noise(n, 107), Biquad.LowPass(3, 0.7f, Rate)); + Normalize(mod, 1); + var b = new float[n]; + for (int i = 0; i < n; i++) b[i] = rumble[i] * 0.5f + murmur[i] * (0.2f + 0.15f * mod[i]); + var rng = new SynthRng(109); + var knock = Buffer(0.06f); + for (int k = 0; k < 24; k++) + { + var kn = Noise(knock.Length, 200 + (ulong)k); + var bp = Biquad.BandPass(rng.Range(1500, 3000), 3, Rate); + float decay = rng.Range(0.01f, 0.03f); + for (int i = 0; i < knock.Length; i++) knock[i] = bp.Process(kn[i]) * 3 * Env(i / (float)Rate, 0.001f, decay); + MixWrapped(b, knock, rng.Next(n), rng.Range(0.2f, 0.5f)); + } + Normalize(b, 0.45f); + return b; + } + + /// Cinguettio (varianti per numero): due–quattro brevi glissati acuti. + public static float[] Bird(int variant) + { + var rng = new SynthRng(300 + (ulong)variant); + int chirps = 2 + rng.Next(3); + float chirp = rng.Range(0.05f, 0.08f); + float gap = rng.Range(0.03f, 0.07f); + var b = Buffer(chirps * (chirp + gap) + 0.02f); + float f0 = rng.Range(2800, 3600), f1 = f0 * rng.Range(1.15f, 1.45f); + if (rng.Next(2) == 0) (f0, f1) = (f1, f0); + for (int k = 0; k < chirps; k++) + { + int s0 = (int)(k * (chirp + gap) * Rate); + float phase = 0; + for (int i = 0; i < (int)(chirp * Rate) && s0 + i < b.Length; i++) + { + float u = i / (chirp * Rate); + phase += Tau * (f0 + (f1 - f0) * u) / Rate; + b[s0 + i] += MathF.Sin(phase) * MathF.Sin(MathF.PI * u); + } + } + Normalize(b, 0.5f); + return b; + } +} diff --git a/client/RailEnterprise.Client/scripts/Hud/TopBar.cs b/client/RailEnterprise.Client/scripts/Hud/TopBar.cs index 62d915c..89bae21 100644 --- a/client/RailEnterprise.Client/scripts/Hud/TopBar.cs +++ b/client/RailEnterprise.Client/scripts/Hud/TopBar.cs @@ -7,7 +7,7 @@ using static RailEnterprise.Client.App.Localization; namespace RailEnterprise.Client.Hud; -/// Barra superiore (immagine 01): compagnia e livello, data, velocità, cassa, patrimonio, rating, stato del server. +/// Barra superiore (immagine 01): compagnia e livello, data, velocità, cassa, patrimonio, rating, stato del server, audio. public partial class TopBar : PanelContainer { private GameSession? _session; @@ -82,6 +82,9 @@ public partial class TopBar : PanelContainer var chipCenter = new CenterContainer(); chipCenter.AddChild(chip); row.AddChild(chipCenter); + var audio = new CenterContainer(); + audio.AddChild(new Audio.SpeakerButton()); + row.AddChild(audio); } private static VBoxContainer Stat(string caption, Label value) diff --git a/client/RailEnterprise.Client/scripts/Main.cs b/client/RailEnterprise.Client/scripts/Main.cs index 2c2d1aa..2f1f4f5 100644 --- a/client/RailEnterprise.Client/scripts/Main.cs +++ b/client/RailEnterprise.Client/scripts/Main.cs @@ -1,5 +1,6 @@ using Godot; using RailEnterprise.Client.App; +using RailEnterprise.Client.Audio; using RailEnterprise.Client.Net; using RailEnterprise.Client.Screens; using RailEnterprise.Core.Data; @@ -27,17 +28,21 @@ public partial class Main : Node 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}"); } ShowMenu(_data is null ? T("Dati del gioco non trovati o non validi.") : ""); - var args = OS.GetCmdlineUserArgs(); - int i = Array.IndexOf(args, "--autopilot"); if (i >= 0 && _data is not null) { // collaudo: mappa piccola e seme fisso per il server locale @@ -61,6 +66,7 @@ public partial class Main : Node var menu = new MenuScreen(); menu.LocalGame += StartLocal; menu.ConnectToServer += ShowConnect; + menu.AudioRequested += () => AudioManager.Instance?.ShowSettings(); menu.LanguageChanged += code => { var cfg = new ConfigFile(); diff --git a/client/RailEnterprise.Client/scripts/Screens/GameScreen.cs b/client/RailEnterprise.Client/scripts/Screens/GameScreen.cs index 581af93..2ddaefd 100644 --- a/client/RailEnterprise.Client/scripts/Screens/GameScreen.cs +++ b/client/RailEnterprise.Client/scripts/Screens/GameScreen.cs @@ -1,5 +1,6 @@ using Godot; using RailEnterprise.Client.App; +using RailEnterprise.Client.Audio; using RailEnterprise.Client.Hud; using RailEnterprise.Client.Map; using RailEnterprise.Client.Net; @@ -240,13 +241,18 @@ public partial class GameScreen : Node _session.MessageApplied += OnMessage; _session.Notified += e => _ticker.Add(e); _session.CommandFailed += r => Toast(r.Message, error: true); + AudioManager.Instance?.Bind(_session, _map); SelectTool(Tool.None); SendViewport(force: true); // il Registro degli impieghi alimenta anche le schede di industrie e città _session.Send(new RequestDetail { Kind = DetailKind.Employment, Target = 0 }); } - public override void _ExitTree() => _session.MessageApplied -= OnMessage; + public override void _ExitTree() + { + _session.MessageApplied -= OnMessage; + AudioManager.Instance?.Unbind(_session); + } /// Codice di EventKind.World nel protocollo (notizie degli eventi del mondo, ADR 0017). private const byte WorldEventKind = 10; diff --git a/client/RailEnterprise.Client/scripts/Screens/MenuScreen.cs b/client/RailEnterprise.Client/scripts/Screens/MenuScreen.cs index 72a4fdd..83ba91e 100644 --- a/client/RailEnterprise.Client/scripts/Screens/MenuScreen.cs +++ b/client/RailEnterprise.Client/scripts/Screens/MenuScreen.cs @@ -4,12 +4,13 @@ using static RailEnterprise.Client.App.Localization; namespace RailEnterprise.Client.Screens; -/// Menu iniziale: partita locale (server figlio), collegamento a un server, lingua, uscita. +/// Menu iniziale: partita locale (server figlio), collegamento a un server, lingua, audio, uscita. public partial class MenuScreen : Control { public event Action? LocalGame; public event Action? ConnectToServer; public event Action? LanguageChanged; + public event Action? AudioRequested; private readonly Label _status = UiTheme.Text("", 14, Palette.TextSecondary); public override void _Ready() @@ -44,6 +45,9 @@ public partial class MenuScreen : Control b.Pressed += () => LanguageChanged?.Invoke(code); lang.AddChild(b); } + var audio = new Button { Text = T("Audio"), ToggleMode = false }; + audio.Pressed += () => AudioRequested?.Invoke(); + lang.AddChild(audio); col.AddChild(lang); var quit = new Button { Text = T("Esci"), CustomMinimumSize = new Vector2(0, 40) }; quit.Pressed += () => GetTree().Quit(); diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index ac549e8..ec79f31 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -127,7 +127,8 @@ Requisito: stesso seme + stessi comandi agli stessi tick ⇒ stesso hash di stat - `Main` → `MenuScreen` / `ConnectScreen` / `GameScreen`. `LocalServerLauncher` avvia il server come processo figlio per la partita locale. - `GameSession` applica i messaggi a `ClientWorld` (Protocol) sul thread principale; i comandi sono l'unico modo di cambiare il mondo; le anteprime del tracciato usano `TrackPreview` di Core. - `MapView` (Node2D + Camera2D): `TerrainLayer` (texture per chunk con fasce, ombreggiatura, sponde e curve di livello; shader per le rive), `EntityLayer` (case, industrie, stazioni, depositi, alberi in MultiMesh), `TrackLayer` (massicciata, traversine, rotaie, opere, cantieri, segnali), `TrainLayer` (veicoli interpolati, fumo, avvisi), `ToolOverlay`; `LabelLayer` disegna le etichette in coordinate schermo. -- HUD: `TopBar`, `Toolbar`, pannello destro (pannelli degli strumenti e schede) con `Minimap`, `Ticker`. Pannelli: binari con profilo, stazione, deposito, treni, linee, officine (politica della flotta, avvisi, flotta per condizione, cartella di manutenzione, Registro officina, scorta di ricambi, mappa di calore), impieghi (Registro degli impieghi e convenzioni), mercato, finanze; a tutto schermo «Compagnie e borsa», «Mercato globale» (`MarketPanel`, immagine 06) e «La tua scalata» (`ClimbPanel`, immagine 08: binario dei livelli, storico del patrimonio con `SeriesChart` e i livelli segnati, requisiti, stato patrimoniale, conto economico, prestiti), che si apre anche dal livello nella `TopBar`; scheda dell'entità (con manutenzione del treno, lavoratori dell'industria, dove lavorano gli abitanti, avvisi degli eventi in corso). Sopra la minimappa il riquadro «Eventi in corso» (`WorldEventsBox`, testi in `WorldEventText`) elenca gli eventi del mondo del `DailyDigest`; il Mercato globale mostra quelli sulla domanda di un bene. +- HUD: `TopBar` (con l'altoparlante dell'audio), `Toolbar`, pannello destro (pannelli degli strumenti e schede) con `Minimap`, `Ticker`. Pannelli: binari con profilo, stazione, deposito, treni, linee, officine (politica della flotta, avvisi, flotta per condizione, cartella di manutenzione, Registro officina, scorta di ricambi, mappa di calore), impieghi (Registro degli impieghi e convenzioni), mercato, finanze; a tutto schermo «Compagnie e borsa», «Mercato globale» (`MarketPanel`, immagine 06) e «La tua scalata» (`ClimbPanel`, immagine 08: binario dei livelli, storico del patrimonio con `SeriesChart` e i livelli segnati, requisiti, stato patrimoniale, conto economico, prestiti), che si apre anche dal livello nella `TopBar`; scheda dell'entità (con manutenzione del treno, lavoratori dell'industria, dove lavorano gli abitanti, avvisi degli eventi in corso). Sopra la minimappa il riquadro «Eventi in corso» (`WorldEventsBox`, testi in `WorldEventText`) elenca gli eventi del mondo del `DailyDigest`; il Mercato globale mostra quelli sulla domanda di un bene. +- Audio (`scripts/Audio/`, ADR 0022): `AudioManager`, figlio di `Main` con `AudioManager.Instance`, crea i bus `Music`, `Ambience`, `Sfx`, `Ui` (`AudioBuses.Ensure`, idempotente), applica i volumi di `AudioSettings` (`user://settings.cfg`, sezione `audio`) e reagisce a ciò che il client riceve: clic dei pulsanti (segnale `node_added`), esiti dei comandi, `Notification`, cantieri completati nel `DailyDigest`, arrivi dei treni (`TrainMotion` da `Moving` a `Loading`), treni visibili vicini al centro (`TrainLayer.Heads`, al più 3 canali), terreno e zoom della vista per l'ambiente, anno corrente per il tema dell'era. I suoni si sintetizzano su un altro thread con classi senza Godot: `Synth` (effetti e anelli senza scatti), `MusicComposer` (temi per era da un seme fisso), `AudioMix` (miscelazione, scelta dei treni senza allocazioni, PCM). Pannello `AudioSettingsPanel` (dal menu e da `SpeakerButton` nella `TopBar`), tasto M per il muto; nel pilota automatico l'audio è spento. - Collaudo: pilota automatico (`-- --autopilot cartella`, `scripts/client-autopilot.sh`) con schermate. ## 10. Prestazioni diff --git a/docs/STATE.md b/docs/STATE.md index 4b2f368..2d44f88 100644 --- a/docs/STATE.md +++ b/docs/STATE.md @@ -141,11 +141,17 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). - client: pannello «Finanze» a tutto schermo (`FinancePanel`): conto economico con «Mesi» e «Anni», rating con misure e «per salire…», soglie e tassi, prestiti con rata, interessi, scadenza, «Rimborsa» ed «Estingui», richiesta con fido e tasso, barra dei giorni di cassa negativa solo con lo scoperto; frasi intere con segnaposto in `strings.csv`; schermata `18_finanze` nel pilota automatico (non provata qui: manca l'editor); - IA invariate: usano gli stessi comandi di prestito; accettazione F5 (un'IA al livello 3 in 15 anni) e F4 (35 / 20 guasti senza la linea, 75 / 2 con la linea) invariate; - test (`Economy/FinanceTests.cs`, 19, più il quadro via WebSocket in `ServerTests` e il round-trip di `FinanceReport`): tasso per rating e fisso, fido dal livello e rifiuti, interessi e quota capitale sul registro, rimborso parziale e totale, rating dalle due misure e leva infinita, spiegazione che porta al gradino sopra e rimborso possibile con la cassa, punteggio che basta già (senza infiniti), margine neutro ai primi incassi, finestra di 12 mesi, conto economico che somma all'utile, stipendi dei depositi, dazi, magazzini, dividendi incassati nell'utile, avvisi e bancarotta ai giorni di ogni preset (lento), rientro e oscillazioni senza notizie, quota dei trasporti senza dividendi, salvataggio versione 7 e migrazione dalla 6, determinismo con gli invarianti, proiezione. 194 test (175 senza i lenti). -- Restano della F6: ere e obsolescenza, pannello 07, tooltip «perché», tutorial, audio, bilanciamento con i bot. +- **Audio (issue #46, ADR 0022)**: + - solo client, nessun file audio: effetti, anelli e temi sintetizzati in memoria all'avvio su un altro thread da classi senza dipendenze da Godot (`Synth`, `MusicComposer`, `AudioMix` in `scripts/Audio/`), semi fissi, PCM a 16 bit in `AudioStreamWav`; + - bus `Master`, `Music`, `Ambience`, `Sfx`, `Ui` creati da codice in modo idempotente, limitatore sul Master; volumi per bus e muto generale nella sezione `audio` di `user://settings.cfg`; pannello «Audio» dal menu e dall'altoparlante nella barra superiore, tasto M per il muto; + - `AudioManager` (figlio di `Main`): clic di ogni pulsante, conferma ed errore dagli esiti dei comandi, campanelle per opportunità, avvisi e notizie critiche, «cantiere completato» dal `DailyDigest`; fino a 3 treni in moto vicini al centro dello schermo con rotolamento, motore diesel o ronzio elettrico e sbuffi del vapore modulati dalla velocità, fischio o tromba all'arrivo in stazione (`Moving` → `Loading`); ambiente (vento e uccelli in campagna, fiume e lago, mare, città) dalla griglia del terreno visibile e dallo zoom; tema per era dall'anno corrente con dissolvenza incrociata di 3 s; + - nel pilota automatico e senza schermo niente sintesi e Master muto; testi in `strings.csv`; + - nessun test nel harness (il client non è referenziato): le funzioni pure sono state provate a parte (nessun NaN, picchi entro i limiti, anelli senza salti, temi identici a ogni composizione; circa 0,1 s per gli effetti, 0,1–0,4 s per tema). Non ascoltato: qui manca l'editor. 194 test (175 senza i lenti), invariati. +- Restano della F6: ere e obsolescenza, pannello 07, tooltip «perché», tutorial, bilanciamento con i bot. ## Prossimo passo -- F6: ere e obsolescenza, pannello 07, tooltip «perché», tutorial, audio, bilanciamento con i bot su `simulate`. +- F6: ere e obsolescenza, pannello 07, tooltip «perché», tutorial, bilanciamento con i bot su `simulate`. ## Limiti noti @@ -155,6 +161,7 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). - Nella vista d'insieme i fiumi larghi una cella mostrano ancora gradini. Le immagini di riferimento 06–09 sono arrivate (novembre 2026): il Mercato globale è allineato alla 06 e «La tua scalata» alla 08 (F6, non ancora provati in Godot: qui manca l'editor); Industria e la schermata di connessione vanno allineati in F6. - Compravendita in proprio (ADR 0016): la quotazione nel pannello non considera la cassa delle industrie compratrici; una spedizione tiene occupato lo spazio di destinazione per tutto il viaggio; se una linea sparisce durante il viaggio la merce si ferma nel magazzino della stazione dove si trova anche oltre la capacità; un treno che lascia la linea in viaggio lascia la merce propria alla prossima fermata senza percorrere il tratto; la merce in attesa in stazione scade come le altre merci (la scadenza riparte a ogni trasbordo); il riquadro non è ancora stato provato in Godot (qui manca l'editor). - Eventi del mondo (ADR 0017): le medie mobili (coperture a 30 giorni, margini) si riprendono gradualmente dopo un evento; il maltempo prende un arco per intero secondo il suo punto medio; la notizia di fine arriva la sera dell'ultimo giorno; il riquadro mostra al massimo quattro eventi; le IA non reagiscono; client non ancora provato in Godot (qui manca l'editor). +- Audio (ADR 0022): suoni mono senza panoramica; timbri semplici di sintesi, da tarare all'ascolto (non ancora provati in Godot: qui manca l'editor); il fischio all'arrivo suona solo per i treni visibili di cui il client riceve il moto. - Mercato globale (ADR 0015): la previsione segue solo la componente mondiale (ciclo e shock), non domanda e offerta della mappa; «Dove conviene vendere» dà il prezzo alla destinazione, senza il costo del trasporto. - Scalata (ADR 0018): il livello non scende; lo storico del patrimonio ha un punto all'anno (più la fondazione e oggi); il capitale iniziale mostrato è quello della difficoltà; il valore contabile si aggiorna a inizio mese, mentre cassa, partecipazioni e debiti sono del giorno; i salvataggi delle versioni 1–5 ripartiscono il totale degli attivi in proporzione alle voci del giorno di caricamento fino al ricalcolo del mese; il pannello non è ancora stato provato in Godot (qui manca l'editor). - In F3 tutte le sessioni guidano la compagnia del giocatore (ADR 0009). diff --git a/docs/adr/0022-audio.md b/docs/adr/0022-audio.md new file mode 100644 index 0000000..b13ce9f --- /dev/null +++ b/docs/adr/0022-audio.md @@ -0,0 +1,63 @@ +# ADR 0022 — Audio del client: bus, volumi, suoni sintetizzati, ambiente e musica per era (F6) + +Stato: accettato (F6, issue #46). + +## Contesto + +La roadmap della F6 (guida §16, punto 14) chiede «audio» senza altri dettagli. Il client non contiene +logica di gioco (§14.3) e il repository non ha file audio; scaricarne durante la build o includere file +con licenze incerte non è accettabile. Godot non è eseguibile nell'ambiente di sviluppo, quindi i suoni +non si possono ascoltare qui: il codice deve essere verificabile almeno nella parte di sintesi. + +## Decisione + +1. **Tutto sintetizzato nel client, niente file audio.** `Synth` (effetti e anelli) e `MusicComposer` + (temi) sono classi C# senza dipendenze da Godot in `client/RailEnterprise.Client/scripts/Audio/`; + producono campioni mono a 22 050 Hz convertiti in PCM a 16 bit (`AudioMix.ToPcm16`) e caricati in + `AudioStreamWav` in memoria. Semi fissi (xorshift64* `SynthRng`, FNV-1a dell'id dell'era): stessi + suoni e stessi temi a ogni avvio. Nessuna licenza da documentare. +2. **Bus**: `Master`, `Music`, `Ambience`, `Sfx`, `Ui`, creati da codice all'avvio (`AudioBuses.Ensure`, + idempotente: un bus esistente non si duplica) con un `AudioEffectHardLimiter` sul Master; niente + `default_bus_layout.tres`, così il progetto resta senza risorse da importare con l'editor. +3. **Impostazioni**: volume per bus (0–1, guadagno = valore², cioè circa il volume percepito) e muto + generale nella sezione `audio` di `user://settings.cfg`, lo stesso file di lingua e server. Pannello + «Audio» sopra a tutto (dal menu e dall'altoparlante nella barra superiore); il tasto **M** attiva e + toglie il muto (solo se nessun campo di testo ha il fuoco: è un input non gestito). +4. **`AudioManager`** è un figlio di `Main` (non un autoload: nessuna modifica a `project.godot`), con + `AudioManager.Instance`. Reagisce solo a ciò che il client riceve già: + - clic di ogni `BaseButton` (agganciato dal segnale `node_added` dell'albero: i pannelli non cambiano); + - `CommandResultMessage`: conferma o errore; + - `Notification`: campanella per opportunità, avviso, critica (una sola ogni 0,6 s, le critiche sempre); + - `DailyDigest`: «cantiere completato» se c'è un evento `Construction` della compagnia del giocatore + (gli eventi informativi arrivano solo dal resoconto, non come `Notification`); + - `TrainMotion`: il passaggio da `Moving` a `Loading` di un treno visibile vicino al centro della + telecamera fa fischiare la vaporiera o suonare la tromba (diesel ed elettrici); + - vista: fino a 3 treni in moto tra quelli disegnati (`TrainLayer.Heads`), i più vicini al centro + dello schermo, hanno un canale con rotolamento (intonazione dalla velocità), motore diesel o ronzio + elettrico, e sbuffi per il vapore ogni 1,26 m percorsi (ruota motrice di circa 1,6 m, quattro sbuffi + a giro, tra 0,09 e 1,2 s); il volume scende con la distanza in pixel e allontanando lo zoom; in pausa + tacciono; + - ambiente: ogni 0,25 s una griglia 8×8 sulla vista (allargata di un quarto) conta fiume, lago, mare, + città e industrie, bosco, campagna; `AudioMix.Ambience` ne ricava i guadagni di vento, acqua, mare e + città con lo zoom (da lontano quasi solo vento) e la probabilità degli uccelli da vicino in campagna; + - musica: l'era viene dall'anno corrente (`ClientWorld.Year`) e da `eras.json`; al cambio d'era il tema + nuovo entra con una dissolvenza incrociata di 3 s su due riproduttori; nel menu suona il tema della + prima era. +5. **Prestazioni**: la sintesi gira su un altro thread (`Task.Run`: circa 0,1 s per gli effetti, 0,1–0,4 s + per tema, solo quando serve); nel ciclo per fotogramma niente LINQ né allocazioni (elenchi dei treni + preparati, `StringName` dei bus già pronti, un riproduttore polifonico per bus per i suoni brevi). +6. **Pilota automatico e server senza schermo**: `AudioManager` non sintetizza né riproduce nulla e il + Master resta muto, senza scrivere il file delle impostazioni. + +## Conseguenze + +- Il client non ha file audio e la build non scarica nulla; il timbro dei suoni è semplice (sintesi + additiva, FM, rumore filtrato) e si può cambiare solo nel codice. +- I suoni sono mono, senza panoramica destra–sinistra: i treni si distinguono per volume, non per lato. +- Le costanti di resa sonora (livelli, zoom di riferimento, numero di canali) stanno in `AudioMix` e in + `AudioManager`: sono del client, non della simulazione, e non vanno in `data/*.json`. +- Il fischio richiede che il client riceva il moto del treno nel momento dell'arrivo: con treni fuori + dalla zona sottoscritta non suona (comunque non sarebbero vicini alla telecamera). +- Nessun test nel harness: le classi pure sono nel progetto Godot, che il harness non referenzia; sono + state provate a parte (nessun NaN, picchi entro i limiti, anelli senza salti, temi identici a ogni + composizione). Nessun ascolto possibile qui. From f7c286bf1daf2e74146454cf8a95561d2b41ba30 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Sun, 8 Nov 2026 13:56:33 +0100 Subject: [PATCH 2/7] F6: ere e obsolescenza dei veicoli MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit La tecnologia avanzava solo come filtro d'acquisto: nessuna notizia del cambio d'era, nessun modello «superato», due formule diverse per valore di libro e rivendita e nessun modo di sostituire i veicoli di un treno. Ora rinnovare la flotta è una scelta con costi e benefici visibili. - vehicles.json: successore per modello (validato: stessa categoria, introdotto dopo) e parametri di obsolescenza; Obsolescence, senza stato, ricava produzione, superato, successore consigliato, curva del valore (gradino all'arrivo del successore, poi ammortamento più rapido) e fattore di manutenzione: una sola fonte per patrimonio, SellVehicle, rinnovo e quadri. - Rinnovo come intervento «renewal» di maintenance.json prenotato con ScheduleService: in officina i veicoli superati si vendono e il successore prende il loro posto. Nessun comando nuovo. - EraSystem: il 1° gennaio la notizia dell'era e delle novità dell'anno lette dai dati, annotata nella Cronaca, una volta sola anche attraverso un salvataggio. - Nessuno stato nuovo, quindi il salvataggio resta alla versione 7. - IA: modelli dei progetti aggiornati quando escono di produzione e rinnovo mensile con una regola in ai.json. - Protocollo: DetailKind.Fleet (10) e FleetReport (136); client: catalogo senza i fuori produzione e con i superati segnati, rivendita, Vendi e Rinnova nel pannello Treni, sezione «Rinnovo della flotta» in Officine. - ADR 0020, STATE, ARCHITECTURE e PROTOCOL aggiornati; ErasTests (11). Accettazione F4 e F5 invariate. Refs #41. Co-Authored-By: Claude Opus 5.5 --- .../assets/i18n/strings.csv | 24 ++ .../scripts/Panels/MaintenancePanel.cs | 111 +++++- .../scripts/Panels/TrainsPanel.cs | 146 ++++++- data/ai.json | 6 + data/maintenance.json | 3 +- data/schema/ai.schema.json | 31 +- data/schema/maintenance.schema.json | 3 +- data/schema/vehicles.schema.json | 31 ++ data/vehicles.json | 11 +- docs/ARCHITECTURE.md | 5 +- docs/PROTOCOL.md | 10 +- docs/STATE.md | 16 +- docs/adr/0020-ere-e-obsolescenza.md | 139 +++++++ src/RailEnterprise.Core/Data/AiDefs.cs | 17 + src/RailEnterprise.Core/Data/DataValidator.cs | 19 + src/RailEnterprise.Core/Data/Enums.cs | 3 +- src/RailEnterprise.Core/Data/GameData.cs | 4 + src/RailEnterprise.Core/Data/VehicleDefs.cs | 24 ++ .../Economy/FleetOutlook.cs | 88 +++++ .../Simulation/Ai/AiAgent.cs | 62 +++ .../Simulation/Ai/AiState.cs | 5 +- .../Simulation/GameEvents.cs | 2 + .../Simulation/MaintenanceCommandHandlers.cs | 12 +- .../Simulation/RailCommandHandlers.cs | 13 +- .../Simulation/SystemPipeline.cs | 3 +- .../Simulation/Systems/EraSystem.cs | 150 ++++++++ .../Simulation/Systems/FinanceSystem.cs | 4 +- .../Simulation/Systems/Fleet.cs | 20 +- .../Systems/FleetMaintenanceSystem.cs | 7 + .../Simulation/Systems/Obsolescence.cs | 157 ++++++++ .../Client/ClientWorld.cs | 8 + src/RailEnterprise.Protocol/Message.cs | 2 + .../Messages/ClientMessages.cs | 2 + .../Messages/FleetMessages.cs | 157 ++++++++ .../Messages/MessageCodec.cs | 1 + src/RailEnterprise.Server/GameHost.cs | 3 + src/RailEnterprise.Server/Projection.cs | 26 ++ .../RailEnterprise.Tests/Economy/ErasTests.cs | 360 ++++++++++++++++++ .../Protocol/ProtocolTests.cs | 16 + 39 files changed, 1648 insertions(+), 53 deletions(-) create mode 100644 docs/adr/0020-ere-e-obsolescenza.md create mode 100644 src/RailEnterprise.Core/Economy/FleetOutlook.cs create mode 100644 src/RailEnterprise.Core/Simulation/Systems/EraSystem.cs create mode 100644 src/RailEnterprise.Core/Simulation/Systems/Obsolescence.cs create mode 100644 src/RailEnterprise.Protocol/Messages/FleetMessages.cs create mode 100644 tests/RailEnterprise.Tests/Economy/ErasTests.cs diff --git a/client/RailEnterprise.Client/assets/i18n/strings.csv b/client/RailEnterprise.Client/assets/i18n/strings.csv index dd4319d..2be5d91 100644 --- a/client/RailEnterprise.Client/assets/i18n/strings.csv +++ b/client/RailEnterprise.Client/assets/i18n/strings.csv @@ -677,3 +677,27 @@ una leva non oltre {0} (rimborsando {1}),,leverage no higher than {0} (by repayi Per il gradino {0} serve un punteggio di {1}: {2}.,,To reach {0} you need a score of {1}: {2}. In bancarotta non si possono chiedere prestiti,,Loans cannot be requested while bankrupt Fido disponibile {0} su {1}. Tasso di un nuovo prestito: {2} fisso (base {3} + rating {4} {5}) per {6} anni.,,Available credit {0} of {1}. Rate of a new loan: {2} fixed (base {3} + rating {4} {5}) for {6} years. +Rinnovo della flotta,,Fleet renewal +Rinnova i veicoli superati,,Renew superseded vehicles +Rinnova,,Renew +Era,,Era +Prossima era,,Next era +Valore della flotta,,Fleet value +Nessun veicolo superato,,No superseded vehicles +Quadro della flotta in arrivo dal server…,,Fleet overview coming from the server… +Cassa insufficiente.,,Not enough cash. +In produzione fino al {0}.,,In production until {0}. +"Rinnovo: {0} veicoli superati, spesa netta {1} dopo le rivendite.",,"Renewal: {0} superseded vehicles, net cost {1} after resale." +Seleziona i veicoli da vendere,,Select the vehicles to sell +Superato dal {0}.,,Superseded since {0}. +"Superato dal {0}: successore {1} ({2} kW, {3} km/h, {4}).",,"Superseded since {0}: successor {1} ({2} kW, {3} km/h, {4})." +da rinnovare,,to renew +e altri {0} veicoli superati,,and {0} more superseded vehicles +fuori produzione,,out of production +manutenzione ×{0:0.##},,maintenance ×{0:0.##} +rivendita {0},,resale {0} +"successore {0} ({1} kW, {2} km/h, {3})",,"successor {0} ({1} kW, {2} km/h, {3})" +superato,,superseded +superato dal {0},,superseded since {0} +valore {0},,value {0} +"{0}: {1} veicoli da rinnovare, spesa netta {2}",,"{0}: {1} vehicles to renew, net cost {2}" diff --git a/client/RailEnterprise.Client/scripts/Panels/MaintenancePanel.cs b/client/RailEnterprise.Client/scripts/Panels/MaintenancePanel.cs index 6447a6b..cd1a524 100644 --- a/client/RailEnterprise.Client/scripts/Panels/MaintenancePanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/MaintenancePanel.cs @@ -3,6 +3,7 @@ using RailEnterprise.Client.App; using RailEnterprise.Client.Net; using RailEnterprise.Core.Commands; using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; using RailEnterprise.Protocol.Messages; using static RailEnterprise.Client.App.Localization; @@ -11,7 +12,8 @@ namespace RailEnterprise.Client.Panels; /// /// Officine (sezione 10.3): politica della flotta, avvisi, flotta ordinata per condizione con la /// mappa di calore, cartella di manutenzione del treno scelto, depositi con il Registro officina e -/// la scorta di ricambi. Le cartelle e i registri arrivano su richiesta dal server. +/// la scorta di ricambi, rinnovo della flotta (ere e obsolescenza, ADR 0020). Le cartelle, i registri +/// e il quadro della flotta arrivano su richiesta dal server: età, successori e valori non si calcolano qui. /// public partial class MaintenancePanel : VBoxContainer { @@ -29,12 +31,15 @@ public partial class MaintenancePanel : VBoxContainer private readonly VBoxContainer _workshop = PanelKit.Column(8); private readonly VBoxContainer _workshopDetails = PanelKit.Column(6); private readonly HBoxContainer _orderRow = PanelKit.Row(); + private readonly VBoxContainer _fleet = PanelKit.Column(6); private readonly Label _status = UiTheme.Text("", 13, Palette.TextSecondary); private readonly List _trainIds = []; private readonly List _depotIds = []; private int _train = -1, _depot = -1; private int _entityVersion = -1, _detailVersion = -1; private double _request; + private long _fleetDay = long.MinValue; + private double _sinceFleet = double.MaxValue; private bool _updating; public event Action? HeatMapToggled; @@ -69,6 +74,9 @@ public partial class MaintenancePanel : VBoxContainer AddChild(_workshop); AddChild(_workshopDetails); AddChild(_orderRow); + AddChild(PanelKit.Separator()); + AddChild(UiTheme.Text(T("Rinnovo della flotta"), 14, bold: true)); + AddChild(_fleet); _status.AutowrapMode = TextServer.AutowrapMode.WordSmart; AddChild(_status); @@ -113,10 +121,26 @@ public partial class MaintenancePanel : VBoxContainer if (_depot >= 0) _session.Send(new RequestDetail { Kind = DetailKind.Workshop, Target = _depot }); } var w = _session.World; + // quadro della flotta: all'apertura e a ogni nuovo giorno; di nuovo dopo 5 s se non arriva + _sinceFleet += delta; + long today = Fmt.Today(w); + if (today != _fleetDay || (w.Fleet is null && _sinceFleet > 5)) RequestFleet(today); if (w.EntityVersion != _entityVersion || w.DetailVersion != _detailVersion) Refresh(); } - private void Result(CommandResultMessage r) => _status.Text = r.Message; + private void RequestFleet(long day) + { + _fleetDay = day; + _sinceFleet = 0; + _session.Send(new RequestDetail { Kind = DetailKind.Fleet, Target = 0 }); + } + + private void Result(CommandResultMessage r) + { + _status.Text = r.Message; + // un rinnovo prenotato o completato cambia il quadro della flotta + RequestFleet(Fmt.Today(_session.World)); + } private void Refresh() { @@ -160,6 +184,7 @@ public partial class MaintenancePanel : VBoxContainer BuildCard(); BuildWorkshop(); + BuildFleet(); } private string DueText(TrainInfo t) @@ -212,6 +237,12 @@ public partial class MaintenancePanel : VBoxContainer { var def = w.Data.Vehicles.FirstOrDefault(d => d.Id == v.Type); _cardDetails.AddChild(UiTheme.Text($"{def?.NameIt ?? v.Type} #{v.Vehicle} · {v.OdometerKm / 1000:0.#} {T("mila km")} · {v.AgeYears:0.#} {T("anni")}", 13, bold: true)); + if (w.Fleet?.Vehicles.FirstOrDefault(f => f.Vehicle == v.Vehicle) is { } info) + { + var value = UiTheme.Text(VehicleOutlook(info), 12, info.Superseded ? Palette.Amber : Palette.TextSecondary); + value.AutowrapMode = TextServer.AutowrapMode.WordSmart; + _cardDetails.AddChild(value); + } foreach (var c in v.Components) { var row = PanelKit.Row(6); @@ -261,6 +292,82 @@ public partial class MaintenancePanel : VBoxContainer actions.AddChild(b); } _cardControls.AddChild(actions); + // rinnovo: l'intervento con effetto «renew» dei dati, vende i veicoli superati e compra i successori + if (w.Data.Maintenance.Interventions.FirstOrDefault(i => i.Effect == InterventionEffect.Renew) is { } renewal) + { + var renew = new Button { Text = renewal.NameIt }; + renew.Pressed += () => _session.Command(new ScheduleServiceCommand(new TrainId(_train), renewal.Id), Result); + _cardControls.AddChild(renew); + } + } + + // ------------------------------------------------------------------ rinnovo della flotta + + /// Riga di obsolescenza di un veicolo: superato, successore con prestazioni e prezzo, valori, costo di manutenzione. + private string VehicleOutlook(FleetVehicleInfo v) + { + var parts = new List(); + if (v.Superseded) + { + parts.Add(string.Format(T("superato dal {0}"), v.SupersededYear)); + var next = _session.World.Data.Vehicles.FirstOrDefault(d => d.Id == v.Successor); + if (next is not null) + parts.Add(string.Format(T("successore {0} ({1} kW, {2} km/h, {3})"), next.NameIt, next.PowerKw, next.MaxSpeedKmh, new Money(next.Price))); + } + if (!v.InProduction) parts.Add(T("fuori produzione")); + parts.Add(string.Format(T("valore {0}"), v.BookValue)); + parts.Add(string.Format(T("rivendita {0}"), v.Resale)); + if (v.MaintenanceFactor > 1.001f) parts.Add(string.Format(T("manutenzione ×{0:0.##}"), v.MaintenanceFactor)); + return string.Join(" · ", parts); + } + + private void BuildFleet() + { + foreach (var c in _fleet.GetChildren()) c.QueueFree(); + var w = _session.World; + var report = w.Fleet; + if (report is null) + { + _fleet.AddChild(UiTheme.Text(T("Quadro della flotta in arrivo dal server…"), 13, Palette.TextSecondary)); + return; + } + _fleet.AddChild(PanelKit.Pair(T("Era"), PanelKit.Value(report.Era))); + if (report.NextEra.Length > 0) + _fleet.AddChild(PanelKit.Pair(T("Prossima era"), PanelKit.Value($"{report.NextEra} · {report.NextEraYear}"))); + _fleet.AddChild(PanelKit.Pair(T("Valore della flotta"), PanelKit.Value(report.BookValueTotal.ToString()))); + var superseded = report.Vehicles.Where(v => v.Superseded).ToList(); + if (superseded.Count == 0) + { + _fleet.AddChild(UiTheme.Text(T("Nessun veicolo superato"), 13, Palette.TextSecondary)); + return; + } + foreach (var v in superseded.Take(8)) + { + var def = w.Data.Vehicles.FirstOrDefault(d => d.Id == v.Type); + string where = v.Train >= 0 && w.Trains.TryGetValue(v.Train, out var t) ? t.Name + : v.Depot >= 0 && w.Depots.TryGetValue(v.Depot, out var d) ? d.Name : ""; + _fleet.AddChild(UiTheme.Text($"{def?.NameIt ?? v.Type} #{v.Vehicle} · {where} · {v.AgeYears:0.#}/{v.LifeYears} {T("anni")}", 13, bold: true)); + var line = UiTheme.Text(VehicleOutlook(v), 12, Palette.Amber); + line.AutowrapMode = TextServer.AutowrapMode.WordSmart; + _fleet.AddChild(line); + } + if (superseded.Count > 8) + _fleet.AddChild(UiTheme.Text(string.Format(T("e altri {0} veicoli superati"), superseded.Count - 8), 12, Palette.TextSecondary)); + foreach (var r in report.Trains) + { + string name = w.Trains.TryGetValue(r.Train, out var t) ? t.Name : $"#{r.Train}"; + var row = PanelKit.Row(6); + var text = UiTheme.Text(string.Format(T("{0}: {1} veicoli da rinnovare, spesa netta {2}"), name, r.Vehicles, r.NetCost), 13, + r.Affordable ? Palette.Text : Palette.Danger); + text.SizeFlagsHorizontal = SizeFlags.ExpandFill; + text.AutowrapMode = TextServer.AutowrapMode.WordSmart; + row.AddChild(text); + int train = r.Train; + var button = new Button { Text = T("Rinnova") }; + button.Pressed += () => _session.Command(new ScheduleServiceCommand(new TrainId(train), report.RenewalIntervention), Result); + row.AddChild(button); + _fleet.AddChild(row); + } } // ------------------------------------------------------------------ registro officina diff --git a/client/RailEnterprise.Client/scripts/Panels/TrainsPanel.cs b/client/RailEnterprise.Client/scripts/Panels/TrainsPanel.cs index cbf8293..c3569a2 100644 --- a/client/RailEnterprise.Client/scripts/Panels/TrainsPanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/TrainsPanel.cs @@ -11,8 +11,11 @@ using static RailEnterprise.Client.App.Localization; namespace RailEnterprise.Client.Panels; /// -/// Treni: acquisto dei veicoli in un deposito, composizione, assegnazione alle linee, rientro. -/// Ogni azione è un comando; la lista si aggiorna con i delta del server. +/// Treni: acquisto dei veicoli in un deposito, composizione, assegnazione alle linee, rientro, vendita +/// dei veicoli liberi e rinnovo dei treni con veicoli superati. Ogni azione è un comando; la lista si +/// aggiorna con i delta del server. Catalogo, obsolescenza, successori e valori di rivendita vengono dal +/// quadro della flotta (FleetReport, ADR 0020), chiesto all'apertura, a ogni nuovo giorno e dopo i comandi: +/// il pannello non calcola nulla. /// public partial class TrainsPanel : VBoxContainer { @@ -20,10 +23,12 @@ public partial class TrainsPanel : VBoxContainer private readonly OptionButton _depot = new(); private readonly OptionButton _vehicle = new(); private readonly SpinBox _count = new() { MinValue = 1, MaxValue = 12, Value = 1 }; + private readonly Label _modelInfo = UiTheme.Text("", 13, Palette.TextSecondary); private readonly ItemList _inDepot = new() { SelectMode = ItemList.SelectModeEnum.Multi, CustomMinimumSize = new Vector2(0, 120) }; private readonly LineEdit _name = new() { PlaceholderText = T("Nome del treno") }; private readonly ItemList _trains = new() { CustomMinimumSize = new Vector2(0, 140) }; private readonly OptionButton _line = new(); + private readonly Label _renewInfo = UiTheme.Text("", 13, Palette.TextSecondary); private readonly Label _status = UiTheme.Text("", 13, Palette.TextSecondary); private readonly List _depotIds = []; private readonly List _catalog = []; @@ -31,6 +36,9 @@ public partial class TrainsPanel : VBoxContainer private readonly List _trainIds = []; private readonly List _lineIds = []; private int _version = -1; + private FleetReport? _fleetShown; + private long _requestedDay = long.MinValue; + private double _sinceRequest = double.MaxValue; public event Action? TrainSelected; @@ -46,6 +54,8 @@ public partial class TrainsPanel : VBoxContainer buy.AddChild(_vehicle); buy.AddChild(_count); AddChild(buy); + _modelInfo.AutowrapMode = TextServer.AutowrapMode.WordSmart; + AddChild(_modelInfo); var buyButton = UiTheme.Primary(T("Compra veicoli")); buyButton.Pressed += Buy; AddChild(buyButton); @@ -57,6 +67,9 @@ public partial class TrainsPanel : VBoxContainer var composeButton = new Button { Text = T("Componi") }; composeButton.Pressed += Compose; compose.AddChild(composeButton); + var sellButton = new Button { Text = T("Vendi") }; + sellButton.Pressed += Sell; + compose.AddChild(sellButton); AddChild(compose); AddChild(PanelKit.Separator()); AddChild(UiTheme.Text(T("Treni della compagnia"), 14, bold: true)); @@ -71,15 +84,38 @@ public partial class TrainsPanel : VBoxContainer var home = new Button { Text = T("Manda al deposito") }; home.Pressed += SendHome; AddChild(home); + var renew = new Button { Text = T("Rinnova i veicoli superati") }; + renew.Pressed += Renew; + AddChild(renew); + _renewInfo.AutowrapMode = TextServer.AutowrapMode.WordSmart; + AddChild(_renewInfo); _status.AutowrapMode = TextServer.AutowrapMode.WordSmart; AddChild(_status); _depot.ItemSelected += _ => Refresh(force: true); - _trains.ItemSelected += i => TrainSelected?.Invoke(_trainIds[(int)i]); + _vehicle.ItemSelected += _ => ShowModel(); + _trains.ItemSelected += i => + { + TrainSelected?.Invoke(_trainIds[(int)i]); + ShowRenewal(); + }; } public override void _Process(double delta) { - if (_session.World.EntityVersion != _version) Refresh(force: false); + var w = _session.World; + _sinceRequest += delta; + // quadro della flotta: all'apertura e a ogni nuovo giorno; di nuovo dopo 5 s se non arriva + long today = Fmt.Today(w); + if (today != _requestedDay || (w.Fleet is null && _sinceRequest > 5)) RequestFleet(today); + bool fleetChanged = !ReferenceEquals(w.Fleet, _fleetShown); + if (w.EntityVersion != _version || fleetChanged) Refresh(force: fleetChanged); + } + + private void RequestFleet(long day) + { + _requestedDay = day; + _sinceRequest = 0; + _session.Send(new RequestDetail { Kind = DetailKind.Fleet, Target = 0 }); } private int Company => _session.World.Summary?.CompanyId ?? 0; @@ -87,7 +123,9 @@ public partial class TrainsPanel : VBoxContainer private void Refresh(bool force) { var w = _session.World; + var fleet = w.Fleet; _version = w.EntityVersion; + _fleetShown = fleet; int selectedDepot = _depot.Selected >= 0 && _depot.Selected < _depotIds.Count ? _depotIds[_depot.Selected] : -1; _depotIds.Clear(); _depot.Clear(); @@ -101,16 +139,33 @@ public partial class TrainsPanel : VBoxContainer if (_catalog.Count == 0 || force) { - int keep = _vehicle.Selected; + string? keep = _vehicle.Selected >= 0 && _vehicle.Selected < _catalog.Count ? _catalog[_vehicle.Selected].Id : null; _catalog.Clear(); _vehicle.Clear(); - foreach (var def in w.Data.Vehicles.Where(v => v.EraFrom <= w.Year && (v.EraTo is null || v.EraTo >= w.Year))) + if (fleet is not null) { - _catalog.Add(def); - _vehicle.AddItem($"{def.NameIt} — {new Money(def.Price)}"); + // catalogo del server: solo i modelli in produzione, i superati segnati con il successore + foreach (var m in fleet.Models) + { + if (Def(m.Type) is not { } def) continue; + _catalog.Add(def); + string mark = m.Superseded ? $" · {T("superato")}" + (m.Successor.Length > 0 ? $" → {Def(m.Successor)?.NameIt ?? m.Successor}" : "") : ""; + _vehicle.AddItem($"{def.NameIt} — {new Money(def.Price)}{mark}"); + } } - _vehicle.Selected = keep >= 0 && keep < _catalog.Count ? keep : 0; + else + { + // in attesa del quadro del server: i modelli dell'anno, senza segni + foreach (var def in w.Data.Vehicles.Where(v => v.EraFrom <= w.Year && (v.EraTo is null || v.EraTo >= w.Year))) + { + _catalog.Add(def); + _vehicle.AddItem($"{def.NameIt} — {new Money(def.Price)}"); + } + } + int index = keep is null ? -1 : _catalog.FindIndex(d => d.Id == keep); + _vehicle.Selected = index >= 0 ? index : _catalog.Count > 0 ? 0 : -1; } + ShowModel(); int depot = _depot.Selected >= 0 ? _depotIds[_depot.Selected] : -1; _vehicleIds.Clear(); @@ -118,18 +173,24 @@ public partial class TrainsPanel : VBoxContainer foreach (var v in w.Vehicles.Values.Where(v => v.Owner == Company && v.Depot == depot && v.Train < 0).OrderBy(v => v.Id)) { _vehicleIds.Add(v.Id); - var def = w.Data.Vehicles.FirstOrDefault(d => d.Id == v.Type); - _inDepot.AddItem($"{def?.NameIt ?? v.Type} #{v.Id}"); + var info = fleet?.Vehicles.FirstOrDefault(x => x.Vehicle == v.Id); + string extra = info is null + ? "" + : (info.Superseded ? $" · {T("superato")}" : "") + " · " + string.Format(T("rivendita {0}"), info.Resale); + _inDepot.AddItem($"{Def(v.Type)?.NameIt ?? v.Type} #{v.Id}{extra}"); + if (info is { Superseded: true }) _inDepot.SetItemCustomFgColor(_inDepot.ItemCount - 1, Palette.Amber); } - var selectedTrain = _trains.GetSelectedItems() is { Length: > 0 } sel ? _trainIds[sel[0]] : -1; + var selectedTrain = SelectedTrain; _trainIds.Clear(); _trains.Clear(); foreach (var t in w.Trains.Values.Where(t => t.Owner == Company).OrderBy(t => t.Id)) { _trainIds.Add(t.Id); string line = t.Line >= 0 && w.Lines.TryGetValue(t.Line, out var l) ? l.Name : T("senza linea"); - _trains.AddItem($"{t.Name} · {StateName((TrainState)t.State)} · {line}"); + bool renew = fleet?.Trains.Any(r => r.Train == t.Id) == true; + _trains.AddItem($"{t.Name} · {StateName((TrainState)t.State)} · {line}{(renew ? " · " + T("da rinnovare") : "")}"); + if (renew) _trains.SetItemCustomFgColor(_trains.ItemCount - 1, Palette.Amber); } int ti = _trainIds.IndexOf(selectedTrain); if (ti >= 0) _trains.Select(ti); @@ -146,6 +207,40 @@ public partial class TrainsPanel : VBoxContainer } int li = _lineIds.IndexOf(selectedLine); _line.Selected = li >= 0 ? li : Math.Min(1, _lineIds.Count - 1); + ShowRenewal(); + } + + private VehicleDef? Def(string id) => _session.World.Data.Vehicles.FirstOrDefault(v => v.Id == id); + + /// Modello scelto nel catalogo: superato o no, successore con prestazioni e prezzo, ultimo anno di produzione. + private void ShowModel() + { + var fleet = _session.World.Fleet; + if (fleet is null || _vehicle.Selected < 0 || _vehicle.Selected >= _catalog.Count) { _modelInfo.Text = ""; return; } + var model = fleet.Models.FirstOrDefault(m => m.Type == _catalog[_vehicle.Selected].Id); + if (model is null) { _modelInfo.Text = ""; return; } + var parts = new List(); + if (model.Superseded) + { + var next = Def(model.Successor); + parts.Add(next is null + ? string.Format(T("Superato dal {0}."), model.SupersededYear) + : string.Format(T("Superato dal {0}: successore {1} ({2} kW, {3} km/h, {4})."), + model.SupersededYear, next.NameIt, next.PowerKw, next.MaxSpeedKmh, new Money(next.Price))); + } + if (model.LastYear > 0) parts.Add(string.Format(T("In produzione fino al {0}."), model.LastYear)); + _modelInfo.Text = string.Join(" ", parts); + } + + /// Rinnovo del treno scelto: veicoli superati e spesa netta calcolati dal server. + private void ShowRenewal() + { + int train = SelectedTrain; + var renewal = train >= 0 ? _session.World.Fleet?.Trains.FirstOrDefault(r => r.Train == train) : null; + _renewInfo.Text = renewal is null + ? "" + : string.Format(T("Rinnovo: {0} veicoli superati, spesa netta {1} dopo le rivendite."), renewal.Vehicles, renewal.NetCost) + + (renewal.Affordable ? "" : " " + T("Cassa insufficiente.")); } public static string StateName(TrainState s) => s switch @@ -160,7 +255,12 @@ public partial class TrainsPanel : VBoxContainer _ => s.ToString(), }; - private void Result(CommandResultMessage r) => _status.Text = r.Message; + private void Result(CommandResultMessage r) + { + _status.Text = r.Message; + // acquisti, vendite e rinnovi cambiano il quadro della flotta + RequestFleet(Fmt.Today(_session.World)); + } private void Buy() { @@ -177,7 +277,14 @@ public partial class TrainsPanel : VBoxContainer _session.Command(new ComposeTrainCommand(new DepotId(_depotIds[_depot.Selected]), selected, name), Result); } - private int SelectedTrain => _trains.GetSelectedItems() is { Length: > 0 } sel ? _trainIds[sel[0]] : -1; + private void Sell() + { + var selected = _inDepot.GetSelectedItems().OrderBy(i => i).Select(i => _vehicleIds[i]).ToList(); + if (selected.Count == 0) { _status.Text = T("Seleziona i veicoli da vendere"); return; } + foreach (int id in selected) _session.Command(new SellVehicleCommand(new VehicleId(id)), Result); + } + + private int SelectedTrain => _trains.GetSelectedItems() is { Length: > 0 } sel && sel[0] < _trainIds.Count ? _trainIds[sel[0]] : -1; private void Assign() { @@ -192,4 +299,13 @@ public partial class TrainsPanel : VBoxContainer if (train < 0 || _depot.Selected < 0) { _status.Text = T("Seleziona un treno e un deposito"); return; } _session.Command(new SendToDepotCommand(new TrainId(train), new DepotId(_depotIds[_depot.Selected])), Result); } + + private void Renew() + { + int train = SelectedTrain; + if (train < 0) { _status.Text = T("Seleziona un treno"); return; } + string intervention = _session.World.Fleet?.RenewalIntervention ?? ""; + if (intervention.Length == 0) { _status.Text = T("Quadro della flotta in arrivo dal server…"); return; } + _session.Command(new ScheduleServiceCommand(new TrainId(train), intervention), Result); + } } diff --git a/data/ai.json b/data/ai.json index d34d431..3cb9d40 100644 --- a/data/ai.json +++ b/data/ai.json @@ -57,6 +57,12 @@ "industryMaxCashShare": 0.25, "industryMinMargin": 0.1 }, + "renewal": { + "minSupersededYears": 3, + "minAgeShareOfLife": 0.5, + "cashReserveMultiple": 2.0, + "maxTrainsPerMonth": 1 + }, "personalities": [ { "id": "expansive", "name_it": "Espansiva", "roiThreshold": 0.08, "loanShareOfCredit": 0.8, "targetsPlayer": false, "buysShares": false, "maintenancePolicy": "standard" }, { "id": "prudent", "name_it": "Prudente", "roiThreshold": 0.15, "loanShareOfCredit": 0.3, "targetsPlayer": false, "buysShares": false, "maintenancePolicy": "standard" }, diff --git a/data/maintenance.json b/data/maintenance.json index 32a3238..2c75e95 100644 --- a/data/maintenance.json +++ b/data/maintenance.json @@ -55,7 +55,8 @@ { "id": "overhaul", "name_it": "Revisione generale", "days": 20, "costShare": 0.12, "spareParts": 5, "effect": "overhaul" }, { "id": "repair_minor", "name_it": "Riparazione dopo guasto lieve", "days": 2, "costShare": 0.03, "spareParts": 1, "effect": "repair", "restoreTo": 80 }, { "id": "repair_major", "name_it": "Riparazione dopo guasto grave", "days": 7, "costShare": 0.08, "spareParts": 3, "effect": "repair", "restoreTo": 90 }, - { "id": "repair_catastrophic", "name_it": "Ricostruzione dopo deragliamento", "days": 30, "costShare": 0.3, "spareParts": 8, "effect": "replace" } + { "id": "repair_catastrophic", "name_it": "Ricostruzione dopo deragliamento", "days": 30, "costShare": 0.3, "spareParts": 8, "effect": "replace" }, + { "id": "renewal", "name_it": "Rinnovo dei veicoli superati", "days": 4, "costShare": 0.005, "spareParts": 0, "effect": "renew" } ], "inspection": { "brakesTo": 100, "othersPlus": 10, "hazardFactor": 0.5, "hazardDays": 30 }, "service": { "plus": 40 }, diff --git a/data/schema/ai.schema.json b/data/schema/ai.schema.json index 9456435..9888e27 100644 --- a/data/schema/ai.schema.json +++ b/data/schema/ai.schema.json @@ -91,6 +91,34 @@ }, "minItems": 1 }, + "renewal": { + "type": "object", + "properties": { + "minSupersededYears": { + "type": "number", + "minimum": 0 + }, + "minAgeShareOfLife": { + "type": "number", + "minimum": 0 + }, + "cashReserveMultiple": { + "type": "number", + "minimum": 0 + }, + "maxTrainsPerMonth": { + "type": "integer", + "minimum": 0 + } + }, + "required": [ + "minSupersededYears", + "minAgeShareOfLife", + "cashReserveMultiple", + "maxTrainsPerMonth" + ], + "additionalProperties": false + }, "market": { "type": "object", "additionalProperties": { @@ -108,7 +136,8 @@ "personalities", "companyNames", "colors", - "market" + "market", + "renewal" ], "additionalProperties": false } diff --git a/data/schema/maintenance.schema.json b/data/schema/maintenance.schema.json index ce88a48..882fffb 100644 --- a/data/schema/maintenance.schema.json +++ b/data/schema/maintenance.schema.json @@ -160,7 +160,8 @@ "service", "overhaul", "repair", - "replace" + "replace", + "renew" ] }, "restoreTo": { diff --git a/data/schema/vehicles.schema.json b/data/schema/vehicles.schema.json index dc02d15..d700c2b 100644 --- a/data/schema/vehicles.schema.json +++ b/data/schema/vehicles.schema.json @@ -10,6 +10,32 @@ "type": "integer", "minimum": 1 }, + "obsolescence": { + "type": "object", + "properties": { + "immediateValueLoss": { + "type": "number", + "minimum": 0, + "maximum": 0.9 + }, + "depreciationSpeed": { + "type": "number", + "minimum": 1, + "maximum": 10 + }, + "maintenanceCostFactor": { + "type": "number", + "minimum": 1, + "maximum": 10 + } + }, + "required": [ + "immediateValueLoss", + "depreciationSpeed", + "maintenanceCostFactor" + ], + "additionalProperties": false + }, "vehicles": { "type": "array", "items": { @@ -45,6 +71,10 @@ "minimum": 1800, "maximum": 2300 }, + "successor": { + "type": "string", + "pattern": "^[a-z][a-z0-9_]*$" + }, "powerKw": { "type": "number", "minimum": 0 @@ -152,6 +182,7 @@ }, "required": [ "version", + "obsolescence", "vehicles" ], "additionalProperties": false diff --git a/data/vehicles.json b/data/vehicles.json index 5d2cdca..8a53f80 100644 --- a/data/vehicles.json +++ b/data/vehicles.json @@ -1,17 +1,18 @@ { "$schema": "schema/vehicles.schema.json", "version": 1, + "obsolescence": { "immediateValueLoss": 0.15, "depreciationSpeed": 2.0, "maintenanceCostFactor": 1.5 }, "vehicles": [ { "id": "loco_steam_1850", "kind": "locomotive", "name_it": "Ardita 2-6-0", "name_en": "Ardita 2-6-0", - "eraFrom": 1850, "eraTo": 1905, "powerKw": 300, "tractiveEffortKn": 70, "maxSpeedKmh": 60, "massT": 38, "lengthM": 16, + "eraFrom": 1850, "eraTo": 1905, "successor": "loco_steam_1878", "powerKw": 300, "tractiveEffortKn": 70, "maxSpeedKmh": 60, "massT": 38, "lengthM": 16, "price": 1800000, "runningCostPerYear": 240000, "lifeYears": 25, "traction": "steam", "components": { "engine": 1.0, "wheelsets": 0.8, "brakes": 1.0, "electrics": 0.6 } }, { "id": "loco_steam_1878", "kind": "locomotive", "name_it": "Vittoria 2-8-0", "name_en": "Vittoria 2-8-0", - "eraFrom": 1878, "eraTo": 1935, "powerKw": 650, "tractiveEffortKn": 110, "maxSpeedKmh": 70, "massT": 62, "lengthM": 18, + "eraFrom": 1878, "eraTo": 1935, "successor": "loco_steam_1902", "powerKw": 650, "tractiveEffortKn": 110, "maxSpeedKmh": 70, "massT": 62, "lengthM": 18, "price": 3200000, "runningCostPerYear": 380000, "lifeYears": 30, "traction": "steam", "components": { "engine": 1.0, "wheelsets": 0.9, "brakes": 1.0, "electrics": 0.6 } }, { "id": "loco_steam_1902", "kind": "locomotive", "name_it": "Freccia 4-6-2", "name_en": "Freccia 4-6-2", - "eraFrom": 1902, "eraTo": 1945, "powerKw": 1150, "tractiveEffortKn": 95, "maxSpeedKmh": 110, "massT": 88, "lengthM": 21, + "eraFrom": 1902, "eraTo": 1945, "successor": "loco_diesel_1925", "powerKw": 1150, "tractiveEffortKn": 95, "maxSpeedKmh": 110, "massT": 88, "lengthM": 21, "price": 5600000, "runningCostPerYear": 560000, "lifeYears": 30, "traction": "steam", "components": { "engine": 1.1, "wheelsets": 1.0, "brakes": 1.0, "electrics": 0.6 } }, { "id": "loco_diesel_1925", "kind": "locomotive", "name_it": "Aquila D1", "name_en": "Aquila D1", @@ -19,7 +20,7 @@ "price": 7500000, "runningCostPerYear": 420000, "lifeYears": 30, "traction": "diesel", "components": { "engine": 0.9, "wheelsets": 0.8, "brakes": 0.9, "electrics": 0.9 } }, { "id": "loco_electric_1950", "kind": "locomotive", "name_it": "Saetta E50", "name_en": "Saetta E50", - "eraFrom": 1950, "eraTo": 2010, "powerKw": 3200, "tractiveEffortKn": 260, "maxSpeedKmh": 160, "massT": 84, "lengthM": 18, + "eraFrom": 1950, "eraTo": 2010, "successor": "loco_highspeed_1990", "powerKw": 3200, "tractiveEffortKn": 260, "maxSpeedKmh": 160, "massT": 84, "lengthM": 18, "price": 14000000, "runningCostPerYear": 520000, "lifeYears": 35, "traction": "electric", "components": { "engine": 0.7, "wheelsets": 0.9, "brakes": 0.9, "electrics": 1.2 } }, { "id": "loco_highspeed_1990", "kind": "locomotive", "name_it": "Lampo AV", "name_en": "Lampo HS", @@ -43,7 +44,7 @@ "capacity": 16, "wagonType": "box", "goods": [ "food", "goods", "tools", "spare_parts", "livestock", "grain" ], "components": { "axles": 1.0, "brakes": 1.0, "body": 1.0 } }, { "id": "coach_worker", "kind": "coach", "name_it": "Carrozza operai", "name_en": "Workers' coach", - "eraFrom": 1850, "maxSpeedKmh": 100, "massT": 18, "lengthM": 14, "price": 220000, "runningCostPerYear": 20000, "lifeYears": 40, + "eraFrom": 1850, "successor": "coach_modern", "maxSpeedKmh": 100, "massT": 18, "lengthM": 14, "price": 220000, "runningCostPerYear": 20000, "lifeYears": 40, "paxCapacity": 60, "class": "worker", "components": { "axles": 1.0, "brakes": 1.0, "body": 1.0 } }, { "id": "coach_staff", "kind": "coach", "name_it": "Carrozza tecnici", "name_en": "Staff coach", diff --git a/docs/ARCHITECTURE.md b/docs/ARCHITECTURE.md index ac549e8..c2699c1 100644 --- a/docs/ARCHITECTURE.md +++ b/docs/ARCHITECTURE.md @@ -40,7 +40,7 @@ Regole: ``` Clock → Commands → Construction → Trains → Signals → Stations → Maintenance (treni) → Demand (giornaliero) → Commuting → Industries → IndustryMaintenance → Towns → Market -→ Finance → StockMarket → AiAgents (mensile) → Events → Contracts → Hash (giornaliero) +→ Finance → StockMarket → AiAgents (mensile) → Events → Eras (annuale) → Contracts → Hash (giornaliero) ``` Sistemi implementati (F1–F5), nella loro posizione: @@ -64,6 +64,7 @@ Sistemi implementati (F1–F5), nella loro posizione: | `StockMarketSystem` | giorno/mese/anno | prezzi e sentiment, valore delle partecipazioni, offerte pubbliche (adesioni, esito), controllo e utili delle controllate, amministrazione controllata del giocatore, fallimenti e aste, storico annuale, nuovi concorrenti (ADR 0012) | | `AiSystem` | giorno/mese | agenti delle compagnie IA: progetti, stalli, offerte; una volta al mese (giorno diverso per IA) finanza, treni aggiuntivi, borsa, industrie, linee dei ricambi e nuovi progetti, tutto con i comandi (ADR 0013) | | `EventSystem` | giorno | eventi del mondo (F6, ADR 0017): chiude quelli scaduti, estrae i nuovi dal catalogo `events.json` con il flusso «events» e la frequenza della difficoltà, notizie d'inizio e di fine (posto di «Events») | +| `EraSystem` | anno | novità tecnologiche (F6, ADR 0020): il 1° gennaio, dai dati, la notizia dell'era che inizia, di trazioni, veicoli, ponti, gallerie, binari, segnali, elettrificazione, merci e industrie introdotti, dei modelli superati e di quelli fuori produzione (`EventKind.Technology`), annotata nella Cronaca; senza stato | | `HashSystem` | giorno | hash dello stato dinamico | - Ogni sistema implementa `ISimSystem.Step(WorldContext ctx)`; i sistemi giornalieri o mensili controllano `ctx.IsNewDay` / `ctx.IsNewMonth` e ritornano subito negli altri tick: nei 239 tick su 240 lavora solo `TrainSystem`. @@ -92,7 +93,7 @@ Requisito: stesso seme + stessi comandi agli stessi tick ⇒ stesso hash di stat ## 6. Economia e contabilità -- Entità in `RailEnterprise.Core.Economy`: `Town`, `Industry`, `Hub`, `ResourceSite`, `Company` (con `Loan`), `CommuteContract`, `Market`, `Tariffs`; `MarketOutlook` (F6, ADR 0015) è l'analisi in sola lettura per il pannello «Mercato globale»: storico mensile, previsione dalla componente mondiale, destinazioni di vendita, hub, evento in corso, avanzamento verso il commercio. `ClimbOutlook` (F6, ADR 0018) è l'analisi in sola lettura per «La tua scalata»: livelli con gli sblocchi dai dati (`Tiers.NewUnlocks`), requisiti del prossimo livello con l'avanzamento (media delle tre frazioni, usata anche dal Mercato globale), stato patrimoniale per voce che somma al patrimonio netto del motore, conto economico, prestiti, storico del patrimonio dalla Cronaca. `FinanceOutlook` (F6, ADR 0019) è l'analisi in sola lettura per il pannello «Finanze»: conto economico per voce (mese in corso, mesi chiusi, anno in corso, anni chiusi) che somma all'utile operativo del motore, spiegazione del rating (misure, componenti, soglie, cosa serve per salire), prestiti con rata e scadenza, fido, giorni di cassa negativa sul limite della difficoltà. +- Entità in `RailEnterprise.Core.Economy`: `Town`, `Industry`, `Hub`, `ResourceSite`, `Company` (con `Loan`), `CommuteContract`, `Market`, `Tariffs`; `MarketOutlook` (F6, ADR 0015) è l'analisi in sola lettura per il pannello «Mercato globale»: storico mensile, previsione dalla componente mondiale, destinazioni di vendita, hub, evento in corso, avanzamento verso il commercio. `ClimbOutlook` (F6, ADR 0018) è l'analisi in sola lettura per «La tua scalata»: livelli con gli sblocchi dai dati (`Tiers.NewUnlocks`), requisiti del prossimo livello con l'avanzamento (media delle tre frazioni, usata anche dal Mercato globale), stato patrimoniale per voce che somma al patrimonio netto del motore, conto economico, prestiti, storico del patrimonio dalla Cronaca. `FinanceOutlook` (F6, ADR 0019) è l'analisi in sola lettura per il pannello «Finanze»: conto economico per voce (mese in corso, mesi chiusi, anno in corso, anni chiusi) che somma all'utile operativo del motore, spiegazione del rating (misure, componenti, soglie, cosa serve per salire), prestiti con rata e scadenza, fido, giorni di cassa negativa sul limite della difficoltà. `FleetOutlook` (F6, ADR 0020) è il quadro in sola lettura del rinnovo della flotta: era in corso e prossima, veicoli con età, superato, successore consigliato, valore di libro, rivendita e fattore di manutenzione, catalogo dei modelli in produzione, treni da rinnovare con la spesa netta. Produzione, obsolescenza e valore dei veicoli vengono da `Simulation.Systems.Obsolescence` (senza stato, dai dati, dal calendario e dal giorno d'acquisto): è l'unica fonte del valore per il patrimonio (`FinanceSystem.BookValues`), `SellVehicle`, il rinnovo in officina (intervento «renewal», effetto `renew`) e i costi di manutenzione dei modelli superati. - Ogni movimento di denaro passa dal registro (`MoneyLedger.Transfer`) tra conti: compagnie, industrie e il conto `Esterno` (famiglie, clienti delle tariffe, mercato mondiale). La somma di tutti i saldi è sempre zero: è l'invariante «denaro» dei test. Le voci del conto economico delle compagnie (`LedgerEntry`) si accumulano per mese e per anno; `LedgerEntries` ne fissa l'ordine e le sezioni (ricavi, costi, investimenti e finanziamenti) e `Company.OperatingProfit` è la somma di ricavi e costi (ADR 0019). Un trasferimento può usare voci diverse per chi paga e chi incassa (dividendi pagati e incassati). - Ogni unità di merce sta in un magazzino tracciato (industrie, città, magazzini delle compagnie nelle stazioni, pacchetti in stazione e a bordo dei treni) e `GoodsCounters` registra prodotto, consumato, deperito, importato, esportato: giacenza = prodotto + importato − consumato − deperito − esportato. È l'invariante «merci». - Compravendita in proprio (F6, ADR 0016): `TradingCommandHandlers` esegue `BuyGoods`, `SellGoods` e `ShipGoods` con il prezzo locale marginale di `Systems/TradingMath` (unità per unità, controparti ordinate per prezzo). La merce comprata sta in `Station.Stock`; quella spedita viaggia in pacchetti con `Packet.Owned`, senza tariffa né consumatore, ed entra nel magazzino della stazione d'arrivo. Gli scambi con le industrie passano dal registro sulla voce «Commercio», quelli con gli hub contano come importazione ed esportazione; `StationSystem` addebita ogni mese la giacenza dei magazzini. diff --git a/docs/PROTOCOL.md b/docs/PROTOCOL.md index c067a32..19607f8 100644 --- a/docs/PROTOCOL.md +++ b/docs/PROTOCOL.md @@ -77,7 +77,7 @@ costMultiplier: f64 }` | 7 | Save | `name: string` | | 8 | Load | `saveId: string` | | 9 | NewGame | `seed: u64`, `sizeKm: i32`, `startYear: i32` (0 = predefinito), `difficultyPreset: string`, `overrides: [(key: string, value: f64)]`, `endlessFlags: u32` | -| 10 | RequestDetail | `kind: u8` (1 cartella di manutenzione di un treno, 2 registro officina di un deposito, 3 registro degli impieghi; dalla F5: 4 scheda di una compagnia, 5 scheda di un'industria, 6 Cronaca; dalla F6: 7 quadro del mercato globale, 8 quadro della scalata, 9 quadro delle finanze), `target: i32` (id del treno, del deposito, della compagnia o dell'industria; ignorato per 3, 6, 7, 8 e 9). Aggiunto in F4 | +| 10 | RequestDetail | `kind: u8` (1 cartella di manutenzione di un treno, 2 registro officina di un deposito, 3 registro degli impieghi; dalla F5: 4 scheda di una compagnia, 5 scheda di un'industria, 6 Cronaca; dalla F6: 7 quadro del mercato globale, 8 quadro della scalata, 9 quadro delle finanze, 10 quadro del rinnovo della flotta), `target: i32` (id del treno, del deposito, della compagnia o dell'industria; ignorato per 3, 6, 7, 8, 9 e 10). Aggiunto in F4 | ### Comandi (`Command.type`, payload in ordine) @@ -99,7 +99,7 @@ costMultiplier: f64 }` | 14 | SendToDepot | `train: i32`, `depot: i32` | | 15 | SetReserve | `train: i32`, `reserve: bool` | | 16 | SetMaintenancePolicy | `scope: u8` (0 compagnia, 1 linea, 2 treno), `target: i32`, `policy: string` | -| 17 | ScheduleService | `train: i32`, `intervention: string` | +| 17 | ScheduleService | `train: i32`, `intervention: string` (id di `maintenance.json`; dalla F6 anche «renewal», il rinnovo dei veicoli superati: in officina si vendono e si sostituiscono con il successore consigliato, ADR 0020) | | 18 | OrderParts | `depot: i32`, `quantity: i32`; blocco 1 (F5): `industry: i32` (ricambi ordinati per un'industria posseduta, oltre la scorta della politica) | | 19 | TakeLoan | `amount: Money` | | 20 | RepayLoan | `loan: i32`, `amount: Money` | @@ -162,6 +162,7 @@ loro fase i comandi 35–38 rispondono `NotImplemented`. Il server imposta l'emi | 133 | SaveList | `saves: [SaveInfo]` | | 134 | ClimbReport | `day: i64, company: i32, foundedDay: i64, initialCapital: Money, tier: u8, nextTier: u8 (0 all'ultimo livello), tiers: [TierInfo]`; requisiti del prossimo livello: `netWorth, netWorthRequired: Money, netWorthFraction: f32, netWorthMet: bool, towns, townsRequired, townPopulation: i32, townsFraction: f32, townsMet: bool, rating, ratingRequired: string, ratingFraction: f32, ratingMet: bool, progress: f32` (media delle tre frazioni); stato patrimoniale: `assets: [AmountInfo]` (kind 0 binari e opere, 1 stazioni e depositi, 2 veicoli, 3 industrie possedute, 4 merce propria), `portfolio, cash (positiva), totalAssets, loans: Money, loansRate: f32 (medio), overdraft (scoperto), totalLiabilities, balanceNetWorth: Money` (= totalAssets − totalLiabilities = patrimonio netto del motore); conto economico: `incomeYear: i32, incomePartial: bool, income: [AmountInfo]` (kind 0 tariffe e noli, 1 altri ricavi, 2 costi operativi, 3 manutenzione, 4 interessi; con segno), `profit: Money`; prestiti: `loanList: [LoanInfo], maxLoan, loanAvailable: Money, newLoanRate: f32, loansAllowed: bool`; `history: [NetWorthPointInfo]` (fondazione, fine di ogni anno, oggi) (su richiesta, F6; ADR 0018) | | 135 | FinanceReport | `day: i64, company: i32, cash, netWorth, loans, overdraft: Money`; conto economico: `lines: [FinanceLineInfo]` (voci in ordine di presentazione), `columns: [IncomeColumnInfo]` (mese in corso, mesi chiusi dal più recente, anno in corso, anni chiusi dal più recente); rating: `rating: string, ratingInitial: bool, ratingMonths, revenueMonths: u8, marginNeutral: bool (margine 0 finché la finestra non è piena e ha meno di minRevenueMonths mesi con ricavi), minRevenueMonths: u8, margin, leverage: f32, leverageUnbounded: bool, marginWeight, leverageWeight, marginComponent, leverageComponent, score: f32, thresholds: [RatingThresholdInfo], nextRating: string ("" ad AAA), nextThreshold: f32, nextAlreadyMet: bool (il punteggio basta già: rating scoreRating al prossimo calcolo mensile, obiettivi a zero), scoreRating: string, marginNeeded: f32, marginReachable: bool, leverageMax: f32 (sempre finita), leverageReachable: bool, debtToRepay: Money, repayAffordable: bool (il rimborso non supera la cassa né il residuo dei prestiti; lo scoperto non si rimborsa)`; prestiti: `loanList: [FinanceLoanInfo], maxLoan, loanAvailable: Money, newLoanRate, baseRate, spread: f32, loanTermMonths: i32, loanStep: Money, loansAllowed: bool`; bancarotta: `negativeCashDays, bankruptcyDays: i32, bankrupt, receivership: bool` (su richiesta, F6; ADR 0019) | +| 136 | FleetReport | `day: i64, company, year: i32, era, nextEra: string ("" all'ultima), nextEraYear: i32 (0 all'ultima), renewalIntervention: string (id per `ScheduleService`), bookValueTotal: Money (coincide con la voce «veicoli» dello stato patrimoniale), vehicles: [FleetVehicleInfo] (veicoli non venduti della compagnia, per id), models: [VehicleModelInfo] (solo i modelli in produzione nell'anno, nell'ordine di vehicles.json), trains: [RenewalTrainInfo] (treni con veicoli da rinnovare)` (su richiesta, F6; ADR 0020) | Record (ognuno chiude con `flags`): @@ -182,7 +183,7 @@ Record (ognuno chiude con `flags`): 3 guasto lieve, 4 fermo in linea, 5 rimorchiato), `reserve: bool`, `policy: u8` (255 = ereditata), `nextIntervention: string`, `nextDueDays: i32`, `maintenanceDepot: i32` - `EdgeInfo { id, owner, a, b, trackClass: u8, doubleTrack, electrified, state: u8, condition: f32, structureCondition: f32, progress: f32, samples: [(s, x, y, h, ground: f64, kind: u8, speedLimitKmh: f64)], signals: [f64] }` -- `EventInfo { day: i64, kind: u8, severity: u8, text, entity: u8, entityIndex: i32, company: i32 }`; `kind` 10 = evento del mondo (inizio e fine, F6) +- `EventInfo { day: i64, kind: u8, severity: u8, text, entity: u8, entityIndex: i32, company: i32 }`; `kind` 10 = evento del mondo (inizio e fine, F6), 11 = novità tecnologiche dell'anno (era che inizia, modelli introdotti, superati e fuori produzione; F6, ADR 0020) - `WorldEventInfo { id: i32, type: string (id di events.json), entity: u8 (1 città, 2 industria, 7 deposito), entityIndex: i32, good: i32 (−1 se nessuno), startDay: i64 (dopo `day` per un evento estratto oggi, che inizia domani), endDay: i64 (primo giorno senza l'evento: il server lo toglie quel mattino), severity: u8, effects: [f32] }`: `effects` sono i moltiplicatori nell'ordine degli effetti del tipo nel catalogo (ADR 0017) - `EmploymentRow { industry, jobsWorkers, jobsStaff, workersPresent: f32, staffPresent: f32, reason, sources: [EmploymentSource { town, homeStation, line, category: u8, headcount, coverage: f32 }] }`; blocco 1: `kind: u8` (0 industria, 1 deposito: `industry` è allora l'id del deposito), `workersReason: u8`, `staffReason: u8` @@ -203,6 +204,7 @@ Record (ognuno chiude con `flags`): - `LedgerEntry` (voce del registro, u8): 0 FreightRevenue (noli merci), 1 PassengerRevenue (biglietti), 2 Construction (costruzioni), 3 VehiclePurchase (acquisto di treni), 4 VehicleSale (vendita di treni), 5 RunningCosts (esercizio dei treni), 6 TrackMaintenance (manutenzione dei binari), 7 FleetMaintenance (manutenzione dei treni), 8 Wages (stipendi), 9 Interest (interessi), 10 LoanTaken (prestiti ricevuti), 11 LoanRepaid (prestiti rimborsati), 12 Trading (commercio in proprio), 13 IndustryPurchase (acquisto di industrie), 14 Dividends (dividendi pagati), 15 Shares (azioni), 16 Contracts (contratti), 17 Penalties (penali), 18 Other (altro), 19 Industries (industrie possedute), 20 Subsidiaries (controllate), 21 StationUpkeep (stazioni e depositi), 22 Storage (magazzini), 23 Duties (dazi), 24 DividendsReceived (dividendi incassati). Sezione: ricavi 0, 1, 12, 16, 19, 20, 24; costi 5–9, 17, 21–23; investimenti e finanziamenti gli altri (ADR 0019) - `FinanceLineInfo { kind: u8 (LedgerEntry), section: u8 (0 ricavi, 1 costi, 2 investimenti e finanziamenti) }`, `IncomeColumnInfo { kind: u8 (0 mese in corso, 1 mese chiuso, 2 anno in corso, 3 anno chiuso), year: i32, month: u8 (1–12, 0 per gli anni), values: [AmountInfo] (solo le voci diverse da zero, kind = LedgerEntry, con segno), profit: Money (utile operativo del motore), cashFlow: Money }`, `RatingThresholdInfo { rating: string, minScore, loanRate: f32 }`, `FinanceLoanInfo { loan: i32, principal, remaining: Money, annualRate: f32 (fisso), monthsLeft: i32, payment, nextInterest: Money, maturityDay: i64 }` - `HubMarketInfo { hub, kind: u8 (0 porto, 1 valico), monthlyCapacity, duty: f32, usedThisMonth, line: i32 (−1 non collegato) }` +- `FleetVehicleInfo { vehicle: i32, type: string, train, depot: i32 (−1 se nessuno), ageYears: f32, lifeYears: i32, condition: f32 (media dei componenti, 0–1), inProduction, superseded: bool, supersededYear: i32 (0 senza successore), successor: string (consigliato, "" se non superato o senza successore in produzione), bookValue, resale: Money, maintenanceFactor: f32 }`, `VehicleModelInfo { type: string, superseded: bool, supersededYear: i32, successor: string, lastYear: i32 (ultimo anno di produzione, 0 se non previsto) }`, `RenewalTrainInfo { train, vehicles: i32, netCost: Money (successori − rivendite + lavoro, può essere negativa), affordable: bool }` - `WarehouseInfo { station, capacity, incoming: i32 (merce propria in viaggio verso la stazione), goods: [WarehouseGoodInfo] }` (stazioni vive della compagnia) - `WarehouseGoodInfo { good, units: i32 (in magazzino), buyPrice: f64 (centesimi, prossima unità; −1 nessun venditore), buyUnits: i32, sellPrice: f64 (−1 nessun compratore), sellUnits: i32 }` (beni in magazzino o scambiabili nel bacino) @@ -225,7 +227,7 @@ Record (ognuno chiude con `flags`): `CompanyCard` (qualunque compagnia), `IndustryCard` (qualunque industria aperta) e `Chronicle`; la Cronaca arriva da sola, una volta per sessione, quando la partita del giocatore finisce. Dalla F6 `MarketReport` (quadro del mercato globale per la compagnia della sessione), che il pannello chiede - all'apertura e a ogni nuovo giorno; il server non lo manda da solo. Così anche `ClimbReport` (quadro della scalata), che il pannello chiede all'apertura, a ogni nuovo giorno e dopo un prestito, e la barra superiore una volta al mese, e `FinanceReport` (quadro delle finanze), che il pannello «Finanze» chiede all'apertura, a ogni nuovo giorno e dopo un prestito o un rimborso. + all'apertura e a ogni nuovo giorno; il server non lo manda da solo. Così anche `ClimbReport` (quadro della scalata), che il pannello chiede all'apertura, a ogni nuovo giorno e dopo un prestito, e la barra superiore una volta al mese, e `FinanceReport` (quadro delle finanze), che il pannello «Finanze» chiede all'apertura, a ogni nuovo giorno e dopo un prestito o un rimborso, e `FleetReport` (quadro del rinnovo della flotta), che i pannelli Treni e Officine chiedono all'apertura, a ogni nuovo giorno e dopo i loro comandi. - Backpressure: i moti si scartano oltre 256 KB in coda; oltre 64 MB di messaggi affidabili la sessione si chiude (il client può riprenderla). - Obiettivo di banda in regime: < 100 KB/s per client. diff --git a/docs/STATE.md b/docs/STATE.md index 4b2f368..76ce084 100644 --- a/docs/STATE.md +++ b/docs/STATE.md @@ -141,11 +141,23 @@ Aggiornato alla fine di ogni fase (guida, sezione 18). - client: pannello «Finanze» a tutto schermo (`FinancePanel`): conto economico con «Mesi» e «Anni», rating con misure e «per salire…», soglie e tassi, prestiti con rata, interessi, scadenza, «Rimborsa» ed «Estingui», richiesta con fido e tasso, barra dei giorni di cassa negativa solo con lo scoperto; frasi intere con segnaposto in `strings.csv`; schermata `18_finanze` nel pilota automatico (non provata qui: manca l'editor); - IA invariate: usano gli stessi comandi di prestito; accettazione F5 (un'IA al livello 3 in 15 anni) e F4 (35 / 20 guasti senza la linea, 75 / 2 con la linea) invariate; - test (`Economy/FinanceTests.cs`, 19, più il quadro via WebSocket in `ServerTests` e il round-trip di `FinanceReport`): tasso per rating e fisso, fido dal livello e rifiuti, interessi e quota capitale sul registro, rimborso parziale e totale, rating dalle due misure e leva infinita, spiegazione che porta al gradino sopra e rimborso possibile con la cassa, punteggio che basta già (senza infiniti), margine neutro ai primi incassi, finestra di 12 mesi, conto economico che somma all'utile, stipendi dei depositi, dazi, magazzini, dividendi incassati nell'utile, avvisi e bancarotta ai giorni di ogni preset (lento), rientro e oscillazioni senza notizie, quota dei trasporti senza dividendi, salvataggio versione 7 e migrazione dalla 6, determinismo con gli invarianti, proiezione. 194 test (175 senza i lenti). -- Restano della F6: ere e obsolescenza, pannello 07, tooltip «perché», tutorial, audio, bilanciamento con i bot. +- **Ere e obsolescenza dei veicoli (issue #41, ADR 0020)**: + - analisi delle lacune nell'ADR: ere, sblocchi per anno, rifiuto d'acquisto fuori produzione, valore di libro per età e `SellVehicle` c'erano già; mancavano notizie d'era e Cronaca, successori e modelli superati, una sola fonte del valore, costi di manutenzione dei superati, un modo di sostituire i veicoli di un treno, il quadro della flotta, la vendita nel client e l'aggiornamento dei modelli dei progetti delle IA; + - `vehicles.json`: campo `successor` (stessa categoria, introdotto dopo, validato) e blocco `obsolescence` (perdita immediata 15 %, ammortamento 2 volte più rapido, manutenzione × 1,5 per i superati); catena vapore 1850 → 1878 → 1902 → diesel 1925, elettrica 1950 → alta velocità 1990, carrozza operai → moderna; + - `Obsolescence` (senza stato): in produzione, superato dal 1° gennaio dell'anno del successore, successore consigliato, curva del valore, valore di libro (patrimonio) e rivendita (× condizione) da una sola fonte, fattore della manutenzione in `Fleet.CostOf`; + - rinnovo con l'intervento «renewal» di `maintenance.json` (effetto `renew`) prenotato con `ScheduleService`: in officina i veicoli superati si vendono e il successore entra nella stessa posizione; nessun comando nuovo; rifiuto senza veicoli superati o con la spesa netta oltre la cassa; + - `EraSystem`: il 1° gennaio la notizia (`EventKind.Technology` = 11) dell'era che inizia e delle novità dell'anno lette dai dati (trazioni, veicoli, ponti, gallerie, binari, segnali, elettrificazione, merci, industrie, superati, fuori produzione), annotata nella Cronaca; una volta sola anche attraverso un salvataggio; + - salvataggio invariato (corpo versione 7): nessuno stato nuovo, «renewal» in coda agli interventi; + - IA: i modelli dei progetti fuori produzione passano al successore o al migliore dell'anno; ogni mese al massimo un treno in linea con veicoli superati da 3 anni o a metà vita va al rinnovo se resta in cassa il doppio della riserva (`ai.json`, `renewal`); + - protocollo: `DetailKind.Fleet` (10) e `FleetReport` (136); server: quadro su richiesta; `ClientWorld.Fleet`; + - client: Treni con il catalogo dal server (fuori produzione nascosti, superati segnati con il successore, prestazioni e prezzo del successore), rivendita e «superato» sui veicoli liberi, «Vendi», treni «da rinnovare» e «Rinnova i veicoli superati» con la spesa netta; Officine con la riga di obsolescenza nella cartella, il pulsante del rinnovo e la sezione «Rinnovo della flotta»; testi in `strings.csv` (non provato in Godot: manca l'editor); + - accettazione F4 (35 / 20 guasti senza la linea, 75 / 2 con la linea) e F5 invariate; + - test (`Economy/ErasTests.cs`, 11, più il round-trip di `FleetReport`): sblocchi per anno, validazione dei successori, notizia d'era una volta anche attraverso un salvataggio, fuori produzione non acquistabile, curva del valore e rivendita, manutenzione dei superati, valore di libro uguale al patrimonio, rinnovo in officina con gli invarianti, determinismo e salvataggio con un rinnovo in corso, quadro e round-trip, un'IA che rinnova (lento). 205 test (185 senza i lenti). +- Restano della F6: pannello 07, tooltip «perché», tutorial, audio, bilanciamento con i bot. ## Prossimo passo -- F6: ere e obsolescenza, pannello 07, tooltip «perché», tutorial, audio, bilanciamento con i bot su `simulate`. +- F6: pannello 07, tooltip «perché», tutorial, audio, bilanciamento con i bot su `simulate`. ## Limiti noti diff --git a/docs/adr/0020-ere-e-obsolescenza.md b/docs/adr/0020-ere-e-obsolescenza.md new file mode 100644 index 0000000..6f08c61 --- /dev/null +++ b/docs/adr/0020-ere-e-obsolescenza.md @@ -0,0 +1,139 @@ +# ADR 0020 — Ere e obsolescenza dei veicoli (F6) + +Stato: accettato (F6, issue #41). + +## Contesto + +La guida (§13) chiede che la tecnologia avanzi per ere: ponti, gallerie, binari, segnali, trazioni e +veicoli si sbloccano con l'anno, i modelli vecchi escono di produzione e quelli superati perdono valore +e costano di più da mantenere, così che rinnovare la flotta diventi una scelta. Le ere continue e la +ricerca (§13.2) sono della F7: il modello di questa fase deve permetterle senza riscritture. Prima di +scrivere codice si è confrontato il motore con la guida. + +### Analisi delle lacune + +C'era già, e resta com'era: + +- ere con l'anno d'inizio in `eras.json`; `TrackPlanner` vi legge tipi di ponte, limiti delle gallerie, + classi di binario ed elettrificazione; i segnali hanno l'anno; merci e industrie hanno l'era; +- `BuyVehicle` rifiuta i modelli non ancora introdotti o fuori produzione (`EraFrom` / `EraTo` di + `vehicles.json`, rifiuto `EraLocked`); `Estimators` fa scegliere alle IA solo modelli disponibili; + il catalogo del client filtrava i modelli dell'anno dai dati; +- valore di libro dei veicoli in `FinanceSystem.BookValues` (ADR 0018): prezzo × max(minimo, 1 − età / vita); +- `SellVehicle` (9) per i veicoli liberi in deposito, con un valore di rivendita calcolato a parte (stessa + formula × condizione media); +- costo di manutenzione che cresce oltre la vita utile (`ageFactor` di `maintenance.json`). + +Mancava: + +1. qualsiasi notizia del passaggio d'era o delle novità dell'anno, e quindi nulla nella Cronaca; +2. il legame tra un modello e il suo successore: nessun modello era «superato», il valore scendeva con la + sola età e la manutenzione non cambiava con l'obsolescenza; +3. una fonte unica del valore: patrimonio e rivendita avevano due formule; +4. un modo di sostituire i veicoli di un treno: non c'è un comando che scompone un treno e `SellVehicle` + rifiuta i veicoli composti, quindi un treno superato si poteva solo tenere; +5. un quadro della flotta per il client (età, superato, successore, valori); +6. il pulsante di vendita nel client; +7. per le IA: i modelli dei progetti restavano quelli scelti all'apertura e, fuori produzione, ogni + `BuyVehicle` del progetto sarebbe stato rifiutato. + +## Decisione + +1. **Obsolescenza senza stato.** Tutto discende dai dati, dal calendario e dal giorno d'acquisto del + veicolo (`Vehicle.BoughtDay`): `Obsolescence` (Core, statica) dice se un modello è in produzione, + se è superato, da quale anno, qual è il successore consigliato, il residuo del valore, il valore di + libro, la rivendita e il moltiplicatore della manutenzione. Nessun campo nuovo nel mondo. + - In produzione: `eraFrom` ≤ anno ≤ `eraTo` (estremo compreso, come già in `BuyVehicle`). + - Successore: nuovo campo `successor` di `vehicles.json`. Il validatore pretende un modello esistente, + della stessa categoria (tipo, tipo di carro, classe dei passeggeri), introdotto dopo e che non chieda + l'elettrificazione se il modello d'origine non la chiede. Catena attuale: vapore 1850 → 1878 → 1902 → + diesel 1925; elettrica 1950 → alta velocità 1990; carrozza operai → carrozza moderna (1950). + - Superato: dal 1° gennaio dell'anno d'introduzione del successore. + - Successore consigliato: il più recente della catena già introdotto e ancora in produzione (la catena + si percorre anche oltre un modello uscito di produzione). +2. **Curva del valore.** Con età e anni da superato in anni di calendario, vita utile del modello e il + minimo `finance.bookValueFloor` (0,1): + - modello non superato: r = max(minimo, 1 − età / vita), come prima; + - superato: r = max(minimo, (1 − `immediateValueLoss`) × (1 − (età + (`depreciationSpeed` − 1) × anni da + superato) / vita)), cioè un gradino del 15 % all'arrivo del successore e poi un ammortamento due + volte più rapido. Gli anni da superato partono dall'acquisto se il veicolo è stato comprato dopo. + + Parametri nel nuovo blocco `obsolescence` di `vehicles.json` (con schema e intervalli validati). + Esempio: una vaporiera del 1850 (vita 25 anni) comprata nel 1850 vale nel 1877 il minimo del 10 %; + comprata nel 1870 vale nel 1878 il 68 % (1 − 8/25) un giorno prima e il 57,8 % il 1° gennaio. +3. **Una sola fonte del valore.** Valore di libro = prezzo × r (centesimi, troncato) in + `FinanceSystem.BookValues`, quindi nel patrimonio netto; rivendita = prezzo × r × condizione media dei + componenti in `SellVehicle` e nel rinnovo; il quadro della flotta legge le stesse funzioni e il suo + totale coincide con la voce «veicoli» dello stato patrimoniale calcolata lo stesso giorno. +4. **Manutenzione dei superati.** `Fleet.CostOf` pesa il prezzo di ogni veicolo superato per + `maintenanceCostFactor` (1,5): un intervento costa di più quanto più la composizione è superata. Il + fattore tocca solo il costo in denaro, non la durata né i ricambi né l'usura. L'accettazione F4 + (Valdoria, 1850, nessun modello superato nei tre anni) resta identica. +5. **Rinnovo con un intervento dei dati, non con un comando nuovo.** In `maintenance.json` l'intervento + «renewal» (effetto nuovo `renew`, 4 giorni, lavoro pari allo 0,5 % dei prezzi di listino pesati dei veicoli del + treno per il fattore della politica, nessun ricambio) si prenota con + il comando esistente `ScheduleService` (17). In officina, al completamento, ogni veicolo superato del + treno con un successore in produzione si vende al valore di rivendita (voce «vendita di treni») e nella + stessa posizione della composizione entra un veicolo nuovo del successore consigliato (voce «acquisto + di treni», componenti nuovi); il treno ricalcola prestazioni e grafo della linea e torna in servizio. + Il comando si rifiuta senza veicoli da rinnovare («nessun veicolo superato da rinnovare») e con una + spesa netta (successori − rivendite + lavoro) maggiore della cassa. I veicoli liberi si vendono con + `SellVehicle`, com'era. Così il rinnovo eredita prenotazione, coda, stalli, personale e notizie + dell'officina (ADR 0009), il client non ha un comando in più e il protocollo dei comandi non cambia. + Il validatore pretende esattamente un intervento con effetto `renew`. +6. **Notizie d'era e novità (`EraSystem`).** Nel sistema `Eras`, dopo gli eventi del mondo e prima + dell'hash, il 1° gennaio di ogni anno (non il giorno della fondazione) una notizia + (`EventKind.Technology` = 11, opportunità, per tutte le compagnie) dice l'era che inizia e le novità + lette dai dati: trazioni, veicoli introdotti («locomotiva …» per le locomotive), tipi di ponte con la + campata, limiti delle gallerie, classi di binario, segnali, elettrificazione, merci e industrie; poi i + modelli che diventano superati con il successore e quelli usciti di produzione. Nessun elenco è scritto + a mano. La Cronaca del giocatore annota «inizia l'Era …» o «novità del …». Il sistema non ha stato: la + notizia nasce nel tick del cambio d'anno e il mondo si salva tra due tick, quindi esce una volta sola + anche attraverso un salvataggio. +7. **Niente versione 8 del salvataggio.** Non c'è stato nuovo: superato, valori e notizie si ricavano da + dati, calendario e `BoughtDay`, che già si salva. L'intervento «renewal» è in coda all'elenco, quindi + gli indici degli interventi salvati (lavori in officina, storico) restano validi. Il corpo resta alla + versione 7 e l'hash non cambia per i mondi senza modelli superati. +8. **Quadro della flotta.** `FleetOutlook` (Core, sola lettura): era in corso e prossima, veicoli della + compagnia (età, vita, condizione, in produzione, superato e da quando, successore consigliato, valore + di libro, rivendita, fattore di manutenzione), catalogo dei soli modelli in produzione con il segno dei + superati e l'ultimo anno di produzione, treni da rinnovare con la spesa netta e se la cassa basta. + Protocollo: `DetailKind.Fleet` (10) e `FleetReport` (136) su richiesta, `ClientWorld.Fleet`. +9. **Client.** Nessun calcolo: il pannello Treni prende il catalogo dal quadro (nasconde i fuori + produzione, segna i superati con il successore e, per il modello scelto, prestazioni e prezzo del + successore e l'ultimo anno di produzione), mostra «superato · rivendita X» sui veicoli liberi, ha + «Vendi» (`SellVehicle`) e «Rinnova i veicoli superati» con la spesa netta, e segna i treni «da + rinnovare»; il pannello Officine aggiunge alla cartella la riga di obsolescenza di ogni veicolo, il + pulsante del rinnovo, e la sezione «Rinnovo della flotta» (era, prossima era, valore della flotta, + veicoli superati con successore, valori e manutenzione, treni da rinnovare con «Rinnova»). Il quadro si + chiede all'apertura, a ogni nuovo giorno e dopo i comandi. Testi in `strings.csv`. +10. **IA.** Due regole deterministiche: + - all'acquisto per un progetto, un modello uscito di produzione si sostituisce con il successore + consigliato o, se non c'è, con il migliore dell'anno (`Estimators`); + - ogni mese, dopo la crescita delle linee, al massimo `renewal.maxTrainsPerMonth` (1) treni in linea, + sani e non in officina, in ordine di id, si mandano al rinnovo se almeno un veicolo è superato da + `minSupersededYears` (3) anni o ha `minAgeShareOfLife` (50 %) della vita, e se dopo la spesa netta + resta in cassa `cashReserveMultiple` (2) volte la riserva dell'agente. Parametri nel blocco + `renewal` di `ai.json`. +11. **F7.** Le ere continue e la ricerca aggiungeranno modelli e successori ai dati o anticiperanno + `eraFrom` per compagnia: `Obsolescence` ed `EraSystem` leggono solo dati e anno, quindi basterà + passare loro l'anno «tecnologico» della compagnia al posto di quello del calendario. + +## Conseguenze + +- Il patrimonio netto scende di più per chi tiene modelli superati; la scalata e il rating lo vedono. +- Rinnovare costa il prezzo dei successori meno la rivendita: un treno vecchio vale poco, quindi il + rinnovo è una spesa vera, che il pannello mostra prima della prenotazione. +- Ogni 1° gennaio con novità c'è una notizia in più; gli anni senza novità non ne hanno. +- Accettazione F4 invariata (35 / 20 guasti senza la linea, 75 / 2 con la linea): nel 1850–1853 nessun + modello è superato. Accettazione F5 invariata. + +## Limiti + +- Il rinnovo sostituisce solo i veicoli con un successore in produzione; un modello senza successore + (diesel, carri merci) invecchia con la sola età. +- La rivendita non dipende dal mercato dell'usato (domanda, numero di veicoli in vendita). +- La manutenzione dei superati costa di più ma non si guasta più spesso: il fattore tocca il prezzo, non + l'usura. +- Le IA rinnovano solo treni in linea e non vendono i veicoli liberi in deposito. +- Il successore è unico per modello: niente rami (per esempio vapore → diesel o elettrica). diff --git a/src/RailEnterprise.Core/Data/AiDefs.cs b/src/RailEnterprise.Core/Data/AiDefs.cs index 0e7764b..8ca6959 100644 --- a/src/RailEnterprise.Core/Data/AiDefs.cs +++ b/src/RailEnterprise.Core/Data/AiDefs.cs @@ -10,6 +10,8 @@ public sealed class AiFile public required int Version { get; init; } public required AiPlanningParams Planning { get; init; } public required AiMarketParams Market { get; init; } + /// Rinnovo dei treni con veicoli superati (F6, ADR 0020). + public required AiRenewalParams Renewal { get; init; } public required List Personalities { get; init; } public required List CompanyNames { get; init; } public required List Colors { get; init; } @@ -77,6 +79,21 @@ public sealed class AiPlanningParams public required int FailedMemory { get; init; } } +/// +/// Rinnovo della flotta delle IA (ADR 0020): ogni mese al più treni in +/// servizio con un veicolo superato vanno in officina per il rinnovo, se il veicolo è superato da almeno +/// anni o ha già consumato della vita +/// utile, e se dopo la spesa netta (successori − rivendite) la cassa resta sopra +/// volte la riserva dell'IA. +/// +public sealed class AiRenewalParams +{ + public required double MinSupersededYears { get; init; } + public required double MinAgeShareOfLife { get; init; } + public required double CashReserveMultiple { get; init; } + public required int MaxTrainsPerMonth { get; init; } +} + /// Comportamento in borsa delle IA (12.1–12.2). public sealed class AiMarketParams { diff --git a/src/RailEnterprise.Core/Data/DataValidator.cs b/src/RailEnterprise.Core/Data/DataValidator.cs index 7ad1af0..4f75176 100644 --- a/src/RailEnterprise.Core/Data/DataValidator.cs +++ b/src/RailEnterprise.Core/Data/DataValidator.cs @@ -97,6 +97,23 @@ public static class DataValidator break; } } + // successori (ADR 0020): stessa categoria, introdotti dopo, senza richiedere la linea elettrificata in più + var vehicleById = new Dictionary(StringComparer.Ordinal); + foreach (var v in d.Vehicles) vehicleById.TryAdd(v.Id, v); + bool Electric(VehicleDef v) => v.Traction is { } tr && d.Eras.Tractions.Any(x => x.Id == tr && x.NeedsElectrification); + foreach (var v in d.Vehicles) + { + if (v.Successor is not { } sid) continue; + if (!vehicleById.TryGetValue(sid, out var next)) + { + Err("vehicles.json", $"{v.Id}: successore sconosciuto «{sid}»"); + continue; + } + if (next.Kind != v.Kind || next.WagonType != v.WagonType || next.Class != v.Class) + Err("vehicles.json", $"{v.Id}: il successore «{sid}» non è della stessa categoria"); + if (next.EraFrom <= v.EraFrom) Err("vehicles.json", $"{v.Id}: il successore «{sid}» deve essere introdotto dopo"); + if (Electric(next) && !Electric(v)) Err("vehicles.json", $"{v.Id}: il successore «{sid}» richiede la linea elettrificata"); + } foreach (var g in d.Goods) { bool carried = d.Vehicles.Any(v => v.Kind == VehicleKind.Wagon && v.WagonType == g.Wagon && (v.Goods?.Contains(g.Id) ?? false)); @@ -249,6 +266,8 @@ public static class DataValidator { if (i.Effect == InterventionEffect.Repair && i.RestoreTo is null) Err("maintenance.json", $"{i.Id}: una riparazione richiede restoreTo"); } + if (m.Interventions.Count(i => i.Effect == InterventionEffect.Renew) != 1) + Err("maintenance.json", "serve esattamente un intervento con effetto «renew» (rinnovo dei veicoli superati)"); RequireKeys("maintenance.json", "depots.stallsBySize", m.Depots.StallsBySize.Keys, SizeKeys, errors); // --- IA, contratti, regioni diff --git a/src/RailEnterprise.Core/Data/Enums.cs b/src/RailEnterprise.Core/Data/Enums.cs index 4612e11..44a1fcc 100644 --- a/src/RailEnterprise.Core/Data/Enums.cs +++ b/src/RailEnterprise.Core/Data/Enums.cs @@ -28,7 +28,8 @@ public enum IronmanRule { No, Optional, Yes } public enum DepletionRate { Slow, Normal, Fast } -public enum InterventionEffect { Inspection, Service, Overhaul, Repair, Replace } +/// Effetto di un intervento; Renew sostituisce i veicoli superati con il successore consigliato (ADR 0020). +public enum InterventionEffect { Inspection, Service, Overhaul, Repair, Replace, Renew } public enum MaintenancePolicy { Economy, Standard, Thorough } diff --git a/src/RailEnterprise.Core/Data/GameData.cs b/src/RailEnterprise.Core/Data/GameData.cs index 4b5b96a..d16f60b 100644 --- a/src/RailEnterprise.Core/Data/GameData.cs +++ b/src/RailEnterprise.Core/Data/GameData.cs @@ -23,6 +23,8 @@ public sealed class GameData public required IReadOnlyList Goods { get; init; } public required IReadOnlyList Industries { get; init; } public required IReadOnlyList Vehicles { get; init; } + /// Obsolescenza dei modelli superati (vehicles.json, ADR 0020). + public required ObsolescenceParams Obsolescence { get; init; } public required ErasFile Eras { get; init; } public required TiersFile Tiers { get; init; } public required BalanceFile Balance { get; init; } @@ -114,6 +116,7 @@ public sealed class GameData Goods = goods!.Goods, Industries = industries!.Industries, Vehicles = vehicles!.Vehicles, + Obsolescence = vehicles.Obsolescence, Eras = eras!, Tiers = tiers!, Balance = balance!, @@ -197,6 +200,7 @@ public sealed class GameData _vehicleIndex[def.Id] = i; def.GoodIndices = def.Goods?.Select(g => _goodIndex[g]).ToArray() ?? []; } + foreach (var def in Vehicles) def.SuccessorDef = def.Successor is { } succ ? Vehicles[_vehicleIndex[succ]] : null; for (int i = 0; i < Eras.TrackClasses.Count; i++) Eras.TrackClasses[i].Index = i; for (int i = 0; i < Events.Events.Count; i++) { diff --git a/src/RailEnterprise.Core/Data/VehicleDefs.cs b/src/RailEnterprise.Core/Data/VehicleDefs.cs index 40422d1..aaca6ca 100644 --- a/src/RailEnterprise.Core/Data/VehicleDefs.cs +++ b/src/RailEnterprise.Core/Data/VehicleDefs.cs @@ -7,9 +7,24 @@ public sealed class VehiclesFile { [JsonPropertyName("$schema")] public string? Schema { get; init; } public required int Version { get; init; } + /// Parametri dell'obsolescenza dei modelli superati (F6, ADR 0020). + public required ObsolescenceParams Obsolescence { get; init; } public required List Vehicles { get; init; } } +/// +/// Obsolescenza di un modello superato da un successore (ADR 0020): dal 1° gennaio dell'anno in cui il +/// successore entra in produzione il valore perde subito e poi si +/// ammortizza volte più in fretta; gli interventi di manutenzione +/// costano volte tanto. +/// +public sealed class ObsolescenceParams +{ + public required double ImmediateValueLoss { get; init; } + public required double DepreciationSpeed { get; init; } + public required double MaintenanceCostFactor { get; init; } +} + /// Modello di veicolo: locomotiva, carro merci o carrozza. public sealed class VehicleDef { @@ -17,8 +32,15 @@ public sealed class VehicleDef public required VehicleKind Kind { get; init; } [JsonPropertyName("name_it")] public required string NameIt { get; init; } [JsonPropertyName("name_en")] public required string NameEn { get; init; } + /// Anno di introduzione: da quest'anno il modello si può comprare. public required int EraFrom { get; init; } + /// Ultimo anno di produzione (assente: sempre in produzione); dall'anno dopo non si compra più. public int? EraTo { get; init; } + /// + /// Modello che lo sostituisce (stessa categoria, introdotto dopo): dall'anno di introduzione del + /// successore questo modello è «superato» (ADR 0020). + /// + public string? Successor { get; init; } public double PowerKw { get; init; } public double TractiveEffortKn { get; init; } public required double MaxSpeedKmh { get; init; } @@ -39,6 +61,8 @@ public sealed class VehicleDef public PaxClass? Class { get; init; } [JsonIgnore] public int Index { get; internal set; } + /// Successore risolto (null se il modello non ne ha). + [JsonIgnore] public VehicleDef? SuccessorDef { get; internal set; } /// Indici dei beni trasportabili (carri). [JsonIgnore] public int[] GoodIndices { get; internal set; } = []; } diff --git a/src/RailEnterprise.Core/Economy/FleetOutlook.cs b/src/RailEnterprise.Core/Economy/FleetOutlook.cs new file mode 100644 index 0000000..f69a234 --- /dev/null +++ b/src/RailEnterprise.Core/Economy/FleetOutlook.cs @@ -0,0 +1,88 @@ +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Systems; + +namespace RailEnterprise.Core.Economy; + +/// +/// Stato di un veicolo per il rinnovo della flotta: età, condizione media, superato o no, successore +/// consigliato, valore di libro e di rivendita, moltiplicatore dei costi di manutenzione. +/// +public sealed record FleetVehicleLine( + VehicleId Id, VehicleDef Def, TrainId Train, DepotId Depot, double AgeYears, double Condition, + bool InProduction, bool Superseded, int? SupersededYear, VehicleDef? Successor, + Money BookValue, Money ResaleValue, double MaintenanceFactor); + +/// Modello in produzione nell'anno, come lo mostra il catalogo d'acquisto: superato o no e successore consigliato. +public sealed record VehicleModelLine(VehicleDef Def, bool Superseded, int? SupersededYear, VehicleDef? Successor, int? LastYear); + +/// Treno con veicoli da rinnovare: quanti, spesa netta del rinnovo (successori − rivendite + lavoro) e se la cassa basta. +public sealed record RenewalTrainLine(TrainId Train, int Vehicles, Money NetCost, bool Affordable); + +/// +/// Quadro del rinnovo della flotta (F6, ADR 0020), in sola lettura: era in corso e prossima, veicoli +/// della compagnia con età, obsolescenza, successore e valori, catalogo dei modelli in produzione e +/// treni da rinnovare. Tutto viene da : lo stesso valore del patrimonio e +/// della rivendita. Il client lo mostra com'è. +/// +public sealed class FleetOutlook +{ + public required long Day { get; init; } + public required int Year { get; init; } + public required CompanyId Company { get; init; } + public required EraDef Era { get; init; } + public required EraDef? NextEra { get; init; } + /// Veicoli non venduti della compagnia, in ordine di id. + public required List Vehicles { get; init; } + /// Modelli in produzione nell'anno, nell'ordine di vehicles.json (i fuori produzione non ci sono). + public required List Models { get; init; } + /// Treni della compagnia con almeno un veicolo da rinnovare, in ordine di id. + public required List Trains { get; init; } + /// Somma dei valori di libro: coincide con la voce «veicoli» dello stato patrimoniale calcolata oggi. + public Money BookValueTotal => new(Vehicles.Sum(v => v.BookValue.Cents)); + + public static FleetOutlook Build(World w, CompanyId company) + { + var d = w.Data; + int year = w.Clock.Year; + double daysPerYear = w.Calendar.DaysPerYear; + var vehicles = new List(); + foreach (var v in w.Vehicles) + { + if (v.Sold || v.Owner != company) continue; + bool superseded = Obsolescence.IsSuperseded(v.Def, year); + vehicles.Add(new FleetVehicleLine( + v.Id, v.Def, v.Train, v.Depot, (w.Clock.Day - v.BoughtDay) / daysPerYear, Obsolescence.AverageCondition(v), + Obsolescence.InProduction(v.Def, year), superseded, Obsolescence.SupersededYear(v.Def), + superseded ? Obsolescence.Recommended(v.Def, year) : null, + new Money(Obsolescence.BookValueCents(w, v)), Obsolescence.ResaleValue(w, v), + Obsolescence.MaintenanceCostFactor(d, v.Def, year))); + } + var models = new List(); + foreach (var def in d.Vehicles) + { + if (!Obsolescence.InProduction(def, year)) continue; + bool superseded = Obsolescence.IsSuperseded(def, year); + models.Add(new VehicleModelLine(def, superseded, Obsolescence.SupersededYear(def), + superseded ? Obsolescence.Recommended(def, year) : null, def.EraTo)); + } + var trains = new List(); + var c = company.IsValid && company.Value < w.Companies.Count ? w.Companies[company.Value] : null; + int renew = d.Maintenance.Interventions.FindIndex(i => i.Effect == InterventionEffect.Renew); + foreach (var t in w.Trains) + { + if (t.Removed || t.Owner != company) continue; + var plan = Obsolescence.RenewalPlan(w, t); + if (plan.Count == 0) continue; + var net = Obsolescence.NetCost(plan) + Fleet.CostOf(w, t, d.Maintenance.Interventions[renew], Fleet.PolicyOf(w, t)); + trains.Add(new RenewalTrainLine(t.Id, plan.Count, net, c is not null && (!net.IsPositive || c.Cash >= net))); + } + return new FleetOutlook + { + Day = w.Clock.Day, Year = year, Company = company, + Era = EraSystem.CurrentEra(d, year), NextEra = EraSystem.NextEra(d, year), + Vehicles = vehicles, Models = models, Trains = trains, + }; + } +} diff --git a/src/RailEnterprise.Core/Simulation/Ai/AiAgent.cs b/src/RailEnterprise.Core/Simulation/Ai/AiAgent.cs index d5e53d7..21f6984 100644 --- a/src/RailEnterprise.Core/Simulation/Ai/AiAgent.cs +++ b/src/RailEnterprise.Core/Simulation/Ai/AiAgent.cs @@ -192,6 +192,7 @@ internal sealed class AiAgent /// Compra locomotiva e carri nel deposito del progetto, compone il treno e lo assegna alla linea. private bool BuyTrain(AiProject project) { + UpdateModels(project); var loco = _w.Data.Vehicle(project.Loco); var car = _w.Data.Vehicle(project.Car); long price = Estimators.TrainPrice(loco, car, project.CarsPerTrain); @@ -211,6 +212,25 @@ internal sealed class AiAgent return true; } + /// + /// Modelli fuori produzione (ADR 0020): la linea passa al successore consigliato o, se la catena non + /// ne offre, al modello che l'IA sceglierebbe oggi per un progetto nuovo. Così i treni aggiuntivi non + /// chiedono veicoli che non si possono più comprare. + /// + private void UpdateModels(AiProject project) + { + int year = _ctx.Year; + var loco = _w.Data.Vehicle(project.Loco); + if (!Obsolescence.InProduction(loco, year) && (Obsolescence.Recommended(loco, year) ?? Estimators.BestLocomotive(_w, year)) is { } newLoco) + project.Loco = newLoco.Id; + var car = _w.Data.Vehicle(project.Car); + if (Obsolescence.InProduction(car, year)) return; + var newCar = Obsolescence.Recommended(car, year) ?? (car.Kind == VehicleKind.Coach + ? Estimators.CoachFor(_w, car.Class ?? PaxClass.Worker, year) + : project.Good >= 0 ? Estimators.WagonFor(_w, project.Good, year) : null); + if (newCar is not null) project.Car = newCar.Id; + } + // ================================================================== mensile public void Monthly() @@ -240,6 +260,7 @@ internal sealed class AiAgent } Finance(); GrowLines(); + RenewFleet(); StockMarket(); BuyIndustries(); if (!EnsurePartsSupply()) NewProject(); @@ -401,6 +422,47 @@ internal sealed class AiAgent } } + // ================================================================== rinnovo della flotta (ADR 0020) + + /// + /// Manda in officina per il rinnovo (intervento «renew», lo stesso comando ScheduleService del + /// giocatore) al più renewal.maxTrainsPerMonth treni in servizio, in ordine di id, che hanno un + /// veicolo superato da almeno renewal.minSupersededYears anni o con almeno renewal.minAgeShareOfLife + /// della vita utile, se dopo la spesa netta (successori − rivendite) la cassa resta sopra + /// renewal.cashReserveMultiple volte la riserva. + /// + private void RenewFleet() + { + var r = _w.Data.Ai.Renewal; + if (r.MaxTrainsPerMonth <= 0) return; + var interventions = _w.Data.Maintenance.Interventions; + string renewal = interventions[interventions.FindIndex(i => i.Effect == InterventionEffect.Renew)].Id; + double daysPerYear = _w.Calendar.DaysPerYear; + int scheduled = 0; + foreach (var t in _w.Trains) + { + if (scheduled >= r.MaxTrainsPerMonth) break; + if (t.Removed || t.Owner != _c.Id || !t.Line.IsValid || t.Reserve || t.InWorkshop || t.MaintenanceDepot.IsValid + || t.Failure != FailureKind.None || t.State == TrainState.Broken) continue; + var plan = Obsolescence.RenewalPlan(_w, t); + if (plan.Count == 0) continue; + bool due = false; + foreach (var item in plan) + { + double age = (_ctx.Day - item.Old.BoughtDay) / daysPerYear; + if (Obsolescence.YearsSuperseded(_w, item.Old) >= r.MinSupersededYears || age >= r.MinAgeShareOfLife * item.Old.Def.LifeYears) + { + due = true; + break; + } + } + if (!due) continue; + long net = Obsolescence.NetCost(plan).Cents; + if (_c.Cash.Cents - net < (long)(Reserve() * r.CashReserveMultiple)) continue; + if (Do(new ScheduleServiceCommand(t.Id, renewal)).Ok) scheduled++; + } + } + // ================================================================== borsa (12.2) private void StockMarket() diff --git a/src/RailEnterprise.Core/Simulation/Ai/AiState.cs b/src/RailEnterprise.Core/Simulation/Ai/AiState.cs index a09a03e..a38dd9e 100644 --- a/src/RailEnterprise.Core/Simulation/Ai/AiState.cs +++ b/src/RailEnterprise.Core/Simulation/Ai/AiState.cs @@ -30,8 +30,9 @@ public sealed class AiProject public long CapitalCents { get; init; } public long RevenuePerYearCents { get; init; } public int TrainsPlanned { get; set; } - public required string Loco { get; init; } - public required string Car { get; init; } + /// Modelli dei treni della linea; se escono di produzione si passa al successore (ADR 0020). + public required string Loco { get; set; } + public required string Car { get; set; } public int CarsPerTrain { get; init; } /// Giorno prima del quale non si aggiungono treni (dopo uno stallo risolto). public long GrowAfterDay { get; set; } diff --git a/src/RailEnterprise.Core/Simulation/GameEvents.cs b/src/RailEnterprise.Core/Simulation/GameEvents.cs index c1863f2..ef2a9da 100644 --- a/src/RailEnterprise.Core/Simulation/GameEvents.cs +++ b/src/RailEnterprise.Core/Simulation/GameEvents.cs @@ -20,6 +20,8 @@ public enum EventKind : byte Company = 9, /// Evento del mondo (events.json, ADR 0017): inizio e fine. World = 10, + /// Passaggio d'era e novità tecnologiche dell'anno (ADR 0020). + Technology = 11, } /// Riferimento facoltativo all'entità coinvolta. diff --git a/src/RailEnterprise.Core/Simulation/MaintenanceCommandHandlers.cs b/src/RailEnterprise.Core/Simulation/MaintenanceCommandHandlers.cs index 15262ff..cf7017f 100644 --- a/src/RailEnterprise.Core/Simulation/MaintenanceCommandHandlers.cs +++ b/src/RailEnterprise.Core/Simulation/MaintenanceCommandHandlers.cs @@ -74,13 +74,21 @@ public static class MaintenanceCommandHandlers if (!TryTrain(w, c.Train, company, out var train)) return reply(CommandError.NotFound, "Treno inesistente"); var m = w.Data.Maintenance; int idx = m.InterventionIndex(c.Intervention); - if (idx < 0 || m.Interventions[idx].Effect is not (InterventionEffect.Inspection or InterventionEffect.Service or InterventionEffect.Overhaul)) - return reply(CommandError.InvalidArgument, "Intervento: inspection, service o overhaul"); + if (idx < 0 || m.Interventions[idx].Effect is not (InterventionEffect.Inspection or InterventionEffect.Service or InterventionEffect.Overhaul or InterventionEffect.Renew)) + return reply(CommandError.InvalidArgument, $"Intervento: inspection, service, overhaul o {m.Interventions.First(i => i.Effect == InterventionEffect.Renew).Id}"); if (train.Vehicles.Count == 0) return reply(CommandError.NotAllowed, "Treno senza veicoli"); if (train.InWorkshop) return reply(CommandError.NotAllowed, $"{train.Name} è già in officina"); if (train.State == TrainState.Broken) return reply(CommandError.NotAllowed, $"{train.Name} attende il soccorso"); if (train.Failure != FailureKind.None) return reply(CommandError.NotAllowed, $"{train.Name} ha un guasto: prima la riparazione"); var def = m.Interventions[idx]; + if (def.Effect == InterventionEffect.Renew) + { + // rinnovo (ADR 0020): serve almeno un veicolo superato con un successore in produzione e la cassa per la spesa netta + var plan = Obsolescence.RenewalPlan(w, train); + if (plan.Count == 0) return reply(CommandError.NotAllowed, $"{train.Name}: nessun veicolo superato da rinnovare"); + var net = Obsolescence.NetCost(plan) + Fleet.CostOf(w, train, def, Fleet.PolicyOf(w, train)); + if (net.IsPositive && company.Cash < net) return reply(CommandError.InsufficientFunds, $"Il rinnovo di {train.Name} costa {net} al netto delle rivendite: cassa insufficiente"); + } int parts = Fleet.PartsFor(w, train, def); FleetMaintenanceSystem.CancelBooking(train); if (!FleetMaintenanceSystem.Book(ctx, train, idx, parts, requireParts: true)) diff --git a/src/RailEnterprise.Core/Simulation/RailCommandHandlers.cs b/src/RailEnterprise.Core/Simulation/RailCommandHandlers.cs index d5c0606..20b5ab8 100644 --- a/src/RailEnterprise.Core/Simulation/RailCommandHandlers.cs +++ b/src/RailEnterprise.Core/Simulation/RailCommandHandlers.cs @@ -408,14 +408,11 @@ public static class RailCommandHandlers return reply(CommandError.None, $"Venduto per {value}"); } - /// Valore di rivendita: prezzo × (1 − età/vita, minimo 10 %) × condizione media. - public static Money ResaleValue(World w, Vehicle v) - { - double ageYears = (w.Clock.Day - v.BoughtDay) / (double)w.Calendar.DaysPerYear; - double residual = Math.Max(w.Data.Balance.Finance.BookValueFloor, 1 - ageYears / v.Def.LifeYears); - double condition = v.Components.Length == 0 ? 1 : v.Components.Average() / 100; - return new Money(v.Def.Price) * (residual * condition); - } + /// + /// Valore di rivendita: prezzo × residuo (1 − età/vita, minimo 10 %, più rapido per i modelli + /// superati) × condizione media; la curva è in (ADR 0020). + /// + public static Money ResaleValue(World w, Vehicle v) => Obsolescence.ResaleValue(w, v); public static CommandResult ComposeTrain(World w, Company company, ComposeTrainCommand c, Reply reply) { diff --git a/src/RailEnterprise.Core/Simulation/SystemPipeline.cs b/src/RailEnterprise.Core/Simulation/SystemPipeline.cs index 89be274..ab2a752 100644 --- a/src/RailEnterprise.Core/Simulation/SystemPipeline.cs +++ b/src/RailEnterprise.Core/Simulation/SystemPipeline.cs @@ -9,7 +9,7 @@ namespace RailEnterprise.Core.Simulation; /// inseriscono nella loro posizione quando vengono implementati: /// Clock → Commands → Construction → Trains → Signals → Stations (+ trasporto locale) /// → Maintenance → Demand → Commuting → Industries → IndustryMaintenance → Towns → Market -/// → Finance → StockMarket → AiAgents → Events → Contracts → Hash. +/// → Finance → StockMarket → AiAgents → Events → Eras (F6, ADR 0020) → Contracts → Hash. /// public sealed class SystemPipeline(IReadOnlyList systems) { @@ -43,6 +43,7 @@ public sealed class SystemPipeline(IReadOnlyList systems) new StockMarketSystem(), new AiSystem(), new EventSystem(), + new EraSystem(), new HashSystem(), ]); diff --git a/src/RailEnterprise.Core/Simulation/Systems/EraSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/EraSystem.cs new file mode 100644 index 0000000..9c024bc --- /dev/null +++ b/src/RailEnterprise.Core/Simulation/Systems/EraSystem.cs @@ -0,0 +1,150 @@ +using System.Globalization; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; + +namespace RailEnterprise.Core.Simulation.Systems; + +/// Tipo di novità tecnologica di un anno (ADR 0020). +public enum TechKind : byte +{ + Traction = 0, + Vehicle = 1, + BridgeType = 2, + TunnelLimit = 3, + TrackClass = 4, + Signal = 5, + Electrification = 6, + Good = 7, + Industry = 8, +} + +/// Novità che un anno sblocca: tipo, id nei dati (vuoto per gallerie ed elettrificazione) e testo italiano. +public readonly record struct TechUnlock(TechKind Kind, string Id, string TextIt); + +/// +/// Passaggi d'era e novità tecnologiche (F6, ADR 0020). Il 1° gennaio di ogni anno (non il giorno della +/// fondazione) annuncia, se ce ne sono, le novità di quell'anno lette dai dati: inizio di un'era +/// (eras.json), trazioni, veicoli introdotti, tipi di ponte, limiti delle gallerie, classi di binario, +/// segnali, elettrificazione, merci e industrie; poi i modelli che escono di produzione e quelli che +/// diventano superati. Nessun elenco è scritto a mano. La notizia () +/// va a tutte le compagnie e la Cronaca del giocatore la registra come fatto saliente. +/// +/// Il sistema non ha stato: la notizia nasce nel tick del cambio d'anno, che un salvataggio non ripete +/// (il mondo si salva tra un tick e l'altro), quindi esce una volta sola anche passando da un +/// salvataggio. Le ere continue della F7 aggiungeranno modelli ai dati: questo sistema li annuncerà +/// senza cambiare. +/// +public sealed class EraSystem : ISimSystem +{ + public string Name => "Eras"; + + public void Step(WorldContext ctx) + { + if (!ctx.IsNewYear || ctx.Day == 0) return; + Announce(ctx.World, ctx.Year); + } + + /// Emette la notizia delle novità dell'anno (se ce ne sono) e la annota nella Cronaca del giocatore. + public static GameEvent? Announce(World w, int year) + { + string? text = NewsText(w.Data, year); + if (text is null) return null; + var era = EraStarting(w.Data, year); + var e = new GameEvent(w.Clock.Day, EventKind.Technology, EventSeverity.Opportunity, text, Company: CompanyId.None); + w.Events.Add(e); + if (w.Companies.Count > 0) + Corporate.Milestone(w, w.Player, era is not null ? $"inizia l'{era.NameIt}" : $"novità del {year}: {Join(Unlocks(w.Data, year).Select(u => u.TextIt))}"); + return e; + } + + /// Era in corso nell'anno: l'ultima iniziata (la prima se l'anno la precede). + public static EraDef CurrentEra(GameData d, int year) + { + var eras = d.Eras.Eras; + var current = eras[0]; + foreach (var e in eras) + { + if (e.From <= year) current = e; + } + return current; + } + + /// Prossima era dopo l'anno (null all'ultima). + public static EraDef? NextEra(GameData d, int year) => d.Eras.Eras.FirstOrDefault(e => e.From > year); + + /// Era che inizia esattamente nell'anno (null se nessuna). + public static EraDef? EraStarting(GameData d, int year) => d.Eras.Eras.FirstOrDefault(e => e.From == year); + + /// Novità introdotte nell'anno, nell'ordine dei file dati. + public static List Unlocks(GameData d, int year) + { + var list = new List(); + var eras = d.Eras; + foreach (var t in eras.Tractions) + { + if (t.From == year) list.Add(new TechUnlock(TechKind.Traction, t.Id.ToString().ToLowerInvariant(), $"trazione {t.NameIt.ToLowerInvariant()}")); + } + foreach (var v in d.Vehicles) + { + if (v.EraFrom == year) list.Add(new TechUnlock(TechKind.Vehicle, v.Id, v.Kind == VehicleKind.Locomotive ? $"locomotiva {v.NameIt}" : v.NameIt.ToLowerInvariant())); + } + foreach (var b in eras.BridgeTypes) + { + if (b.From == year) list.Add(new TechUnlock(TechKind.BridgeType, b.Id, $"ponti in {b.NameIt.ToLowerInvariant()} con campate fino a {Number(b.MaxSpanM)} m")); + } + foreach (var t in eras.TunnelLimits) + { + if (t.From == year) list.Add(new TechUnlock(TechKind.TunnelLimit, "", $"gallerie fino a {Number(t.MaxLengthM / 1000)} km")); + } + foreach (var c in eras.TrackClasses) + { + if (c.From == year) list.Add(new TechUnlock(TechKind.TrackClass, c.Id, $"binario {c.NameIt}")); + } + foreach (var s in eras.Signals) + { + if (s.From == year) list.Add(new TechUnlock(TechKind.Signal, s.Id, s.NameIt.ToLowerInvariant())); + } + if (eras.ElectrificationFrom == year) list.Add(new TechUnlock(TechKind.Electrification, "", "elettrificazione delle linee")); + foreach (var g in d.Goods) + { + if (g.Era == year) list.Add(new TechUnlock(TechKind.Good, g.Id, $"merce {g.NameIt.ToLowerInvariant()}")); + } + foreach (var i in d.Industries) + { + if (i.Era == year) list.Add(new TechUnlock(TechKind.Industry, i.Id, $"industria {i.NameIt.ToLowerInvariant()}")); + } + return list; + } + + /// Modelli fuori produzione dall'anno (ultimo anno di produzione l'anno prima). + public static List Retired(GameData d, int year) => d.Vehicles.Where(v => v.EraTo == year - 1).ToList(); + + /// Modelli che nell'anno diventano superati (il successore è introdotto quell'anno). + public static List NewlySuperseded(GameData d, int year) => d.Vehicles.Where(v => v.SuccessorDef?.EraFrom == year).ToList(); + + /// Testo della notizia dell'anno, o null se l'anno non porta nulla di nuovo. + public static string? NewsText(GameData d, int year) + { + var era = EraStarting(d, year); + var unlocks = Unlocks(d, year); + var retired = Retired(d, year); + var superseded = NewlySuperseded(d, year); + if (era is null && unlocks.Count == 0 && retired.Count == 0 && superseded.Count == 0) return null; + var parts = new List(); + if (unlocks.Count > 0) parts.Add($"sblocca {Join(unlocks.Select(u => u.TextIt))}"); + if (superseded.Count > 0) + parts.Add($"{(superseded.Count == 1 ? "modello superato" : "modelli superati")}: {Join(superseded.Select(v => $"{v.NameIt} (successore {v.SuccessorDef!.NameIt})"))}"); + if (retired.Count > 0) parts.Add($"fuori produzione: {Join(retired.Select(v => v.NameIt))}"); + string head = era is not null ? $"Inizia l'{era.NameIt} ({year})" : $"Novità del {year}"; + return parts.Count == 0 ? head : $"{head}: {string.Join("; ", parts)}"; + } + + private static string Join(IEnumerable items) + { + var list = items.ToList(); + return list.Count <= 1 ? string.Concat(list) : $"{string.Join(", ", list.Take(list.Count - 1))} e {list[^1]}"; + } + + private static string Number(double value) => + value.ToString("0.#", CultureInfo.InvariantCulture).Replace('.', ','); +} diff --git a/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs index dfc7ef0..02c06e7 100644 --- a/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/FinanceSystem.cs @@ -221,8 +221,8 @@ public sealed class FinanceSystem : ISimSystem foreach (var v in w.Vehicles) { if (v.Sold) continue; - double age = (today - v.BoughtDay) / daysPerYear; - values[v.Owner.Value][vehicles] += (long)(v.Def.Price * Math.Max(fb.BookValueFloor, 1 - age / v.Def.LifeYears)); + // stessa curva della rivendita, con l'obsolescenza dei modelli superati (ADR 0020) + values[v.Owner.Value][vehicles] += Obsolescence.BookValueCents(w, v); } foreach (var ind in w.Industries) { diff --git a/src/RailEnterprise.Core/Simulation/Systems/Fleet.cs b/src/RailEnterprise.Core/Simulation/Systems/Fleet.cs index dbb58ac..955a0b9 100644 --- a/src/RailEnterprise.Core/Simulation/Systems/Fleet.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/Fleet.cs @@ -173,27 +173,39 @@ public static class Fleet public static int PartsFor(World w, Train t, InterventionDef def) => def.Effect == InterventionEffect.Repair ? def.SpareParts : def.SpareParts * t.Vehicles.Count; - /// Costo dell'intervento: quota del prezzo dei veicoli interessati × fattore di costo della politica. + /// + /// Costo dell'intervento: quota del prezzo dei veicoli interessati × fattore di costo della politica; + /// il prezzo di un modello superato conta maintenanceCostFactor volte (ricambi fuori catalogo, ADR 0020). + /// public static Money CostOf(World w, Train t, InterventionDef def, PolicyDef policy) { - long price = 0; + double price = 0; + int year = w.Clock.Year; if (def.Effect == InterventionEffect.Repair) { - if (t.FailedVehicle.IsValid) price = w.Vehicles[t.FailedVehicle.Value].Def.Price; + if (t.FailedVehicle.IsValid) price = WeightedPrice(w.Data, w.Vehicles[t.FailedVehicle.Value].Def, year); } else { - foreach (var id in t.Vehicles) price += w.Vehicles[id.Value].Def.Price; + foreach (var id in t.Vehicles) price += WeightedPrice(w.Data, w.Vehicles[id.Value].Def, year); } return Money.FromCentsRounded(price * def.CostShare * policy.CostFactor); } + private static double WeightedPrice(GameData d, VehicleDef def, int year) => def.Price * Obsolescence.MaintenanceCostFactor(d, def, year); + /// Applica gli effetti dell'intervento ai veicoli del treno (10.2), scalati dalla politica. public static void Apply(World w, Train t, InterventionDef def, PolicyDef policy) { var m = w.Data.Maintenance; long today = w.Clock.Day; double ef = policy.EffectFactor; + if (def.Effect == InterventionEffect.Renew) + { + // rinnovo: i veicoli superati si vendono e al loro posto entrano i successori nuovi (ADR 0020) + Obsolescence.Renew(w, t); + return; + } foreach (var id in t.Vehicles) { var v = w.Vehicles[id.Value]; diff --git a/src/RailEnterprise.Core/Simulation/Systems/FleetMaintenanceSystem.cs b/src/RailEnterprise.Core/Simulation/Systems/FleetMaintenanceSystem.cs index bd8458e..7333e20 100644 --- a/src/RailEnterprise.Core/Simulation/Systems/FleetMaintenanceSystem.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/FleetMaintenanceSystem.cs @@ -527,6 +527,7 @@ public sealed class FleetMaintenanceSystem : ISimSystem var w = ctx.World; var m = w.Data.Maintenance; var def = m.Interventions[job.Intervention]; + int renewed = def.Effect == InterventionEffect.Renew ? Obsolescence.RenewalPlan(w, t).Count : 0; Fleet.Apply(w, t, def, Fleet.PolicyOf(w, t)); bool repair = def.Effect is InterventionEffect.Repair or InterventionEffect.Replace; if (def.Effect != InterventionEffect.Inspection) @@ -549,6 +550,12 @@ public sealed class FleetMaintenanceSystem : ISimSystem w.Events.Add(new GameEvent(ctx.Day, EventKind.Maintenance, EventSeverity.Info, $"{t.Name}: {def.NameIt.ToLowerInvariant()} completata a {d.Name}", EntityKind.Train, t.Id.Value, t.Owner)); } + else if (def.Effect == InterventionEffect.Renew) + { + string what = renewed == 1 ? "1 veicolo sostituito" : $"{renewed} veicoli sostituiti"; + w.Events.Add(new GameEvent(ctx.Day, EventKind.Maintenance, EventSeverity.Info, + $"{t.Name}: rinnovo completato a {d.Name}, {what}", EntityKind.Train, t.Id.Value, t.Owner)); + } } // ------------------------------------------------------------------ riserve diff --git a/src/RailEnterprise.Core/Simulation/Systems/Obsolescence.cs b/src/RailEnterprise.Core/Simulation/Systems/Obsolescence.cs new file mode 100644 index 0000000..de9a806 --- /dev/null +++ b/src/RailEnterprise.Core/Simulation/Systems/Obsolescence.cs @@ -0,0 +1,157 @@ +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Time; + +namespace RailEnterprise.Core.Simulation.Systems; + +/// Veicolo superato da rinnovare: il successore consigliato, il suo prezzo e la rivendita del vecchio. +public readonly record struct RenewalItem(Vehicle Old, VehicleDef Successor, Money Price, Money Resale); + +/// +/// Produzione, obsolescenza e valore dei veicoli (F6, ADR 0020), senza stato: tutto discende dai dati +/// (anno di introduzione, ultimo anno di produzione, successore di vehicles.json), dal calendario e dal +/// giorno d'acquisto del veicolo. È l'unica fonte del valore di un veicolo: il valore di libro del +/// patrimonio (), la rivendita di SellVehicle, il rinnovo e +/// i quadri del client leggono le stesse funzioni. +/// +/// Curva del valore (residuo r, frazione del prezzo, con il minimo finance.bookValueFloor): +/// - modello non superato: r = 1 − età / vita; +/// - superato (dal 1° gennaio dell'anno d'introduzione del successore, o dall'acquisto se è successivo): +/// r = (1 − perdita) × (1 − (età + (velocità − 1) × anni da superato) / vita), cioè un gradino di +/// immediateValueLoss e poi un ammortamento depreciationSpeed volte più rapido. +/// Valore di libro = prezzo × r; rivendita = prezzo × r × condizione media dei componenti. +/// +public static class Obsolescence +{ + /// Vero se il modello si può comprare nell'anno: introdotto e non ancora fuori produzione. + public static bool InProduction(VehicleDef def, int year) => def.EraFrom <= year && (def.EraTo is not { } to || year <= to); + + /// Vero se il successore del modello è già stato introdotto nell'anno. + public static bool IsSuperseded(VehicleDef def, int year) => def.SuccessorDef is { } s && s.EraFrom <= year; + + /// Anno da cui il modello è superato (null se non ha successore). + public static int? SupersededYear(VehicleDef def) => def.SuccessorDef?.EraFrom; + + /// + /// Successore consigliato nell'anno: il più recente della catena dei successori già introdotto e + /// ancora in produzione (null se il modello non è superato o nessun successore si può comprare). + /// + public static VehicleDef? Recommended(VehicleDef def, int year) + { + VehicleDef? best = null; + for (var s = def.SuccessorDef; s is not null && s.EraFrom <= year; s = s.SuccessorDef) + { + if (InProduction(s, year)) best = s; + } + return best; + } + + /// Primo giorno in cui il modello è superato (long.MaxValue se non ha successore). + public static long SupersededDay(Calendar calendar, VehicleDef def) => + def.SuccessorDef is { } s ? (long)(s.EraFrom - calendar.StartYear) * calendar.DaysPerYear : long.MaxValue; + + /// Anni da quando il veicolo è superato (dal giorno d'acquisto se è successivo); 0 se non lo è. + public static double YearsSuperseded(World w, Vehicle v) + { + long since = SupersededDay(w.Calendar, v.Def); + long today = w.Clock.Day; + if (today < since) return 0; + return (today - Math.Max(v.BoughtDay, since)) / (double)w.Calendar.DaysPerYear; + } + + /// Residuo del valore del veicolo oggi (frazione del prezzo di listino). + public static double Residual(World w, Vehicle v) => Residual(w.Data, w.Calendar, v.Def, v.BoughtDay, w.Clock.Day); + + /// Residuo del valore di un veicolo del modello comprato in , al giorno . + public static double Residual(GameData d, Calendar calendar, VehicleDef def, long boughtDay, long today) + { + double daysPerYear = calendar.DaysPerYear; + double floor = d.Balance.Finance.BookValueFloor; + double age = (today - boughtDay) / daysPerYear; + long since = SupersededDay(calendar, def); + if (today < since) return Math.Max(floor, 1 - age / def.LifeYears); + var o = d.Obsolescence; + double years = (today - Math.Max(boughtDay, since)) / daysPerYear; + double effectiveAge = age + (o.DepreciationSpeed - 1) * years; + return Math.Max(floor, (1 - o.ImmediateValueLoss) * (1 - effectiveAge / def.LifeYears)); + } + + /// Valore di libro del veicolo in centesimi: prezzo × residuo (voce «veicoli» del patrimonio). + public static long BookValueCents(World w, Vehicle v) => (long)(v.Def.Price * Residual(w, v)); + + /// Condizione media dei componenti come frazione (1 se il veicolo non ne ha). + public static double AverageCondition(Vehicle v) => v.Components.Length == 0 ? 1 : v.Components.Average() / 100; + + /// Valore di rivendita (mercato dell'usato): prezzo × residuo × condizione media. + public static Money ResaleValue(World w, Vehicle v) => new Money(v.Def.Price) * (Residual(w, v) * AverageCondition(v)); + + /// Moltiplicatore dei costi di manutenzione del modello nell'anno: maintenanceCostFactor se superato, altrimenti 1. + public static double MaintenanceCostFactor(GameData d, VehicleDef def, int year) => + IsSuperseded(def, year) ? d.Obsolescence.MaintenanceCostFactor : 1; + + /// + /// Veicoli del treno da rinnovare oggi, in ordine di composizione: quelli superati con un successore + /// consigliato in produzione, con il prezzo del successore e la rivendita del vecchio. + /// + public static List RenewalPlan(World w, Train t) + { + var list = new List(); + int year = w.Clock.Year; + foreach (var id in t.Vehicles) + { + var v = w.Vehicles[id.Value]; + if (!IsSuperseded(v.Def, year) || Recommended(v.Def, year) is not { } next) continue; + list.Add(new RenewalItem(v, next, new Money(next.Price), ResaleValue(w, v))); + } + return list; + } + + /// Spesa netta di un rinnovo: prezzi dei successori meno le rivendite (può essere negativa). + public static Money NetCost(List plan) + { + long cents = 0; + foreach (var item in plan) cents += item.Price.Cents - item.Resale.Cents; + return new Money(cents); + } + + /// + /// Rinnovo in officina (intervento con effetto «renew»): ogni veicolo superato del treno si vende al + /// valore di rivendita (voce «vendita di treni») e al suo posto, nella stessa posizione della + /// composizione, entra un veicolo nuovo del successore consigliato (voce «acquisto di treni»). I + /// veicoli venduti restano nell'elenco con Sold, come quelli di SellVehicle. + /// Restituisce quanti veicoli sono stati sostituiti. + /// + public static int Renew(World w, Train t) + { + var plan = RenewalPlan(w, t); + if (plan.Count == 0) return 0; + var owner = Account.Of(t.Owner); + foreach (var item in plan) + { + var old = item.Old; + int index = t.Vehicles.IndexOf(old.Id); + var fresh = new Vehicle + { + Id = new VehicleId(w.Vehicles.Count), + Def = item.Successor, + Owner = old.Owner, + BoughtDay = w.Clock.Day, + Train = t.Id, + }; + Fleet.InitVehicle(w.Data, fresh, w.Clock.Day); + w.Vehicles.Add(fresh); + old.Sold = true; + old.Train = TrainId.None; + old.Depot = DepotId.None; + t.Vehicles[index] = fresh.Id; + if (item.Resale.IsPositive) w.Money.Transfer(Account.External, owner, item.Resale, LedgerEntry.VehicleSale); + w.Money.Transfer(owner, Account.External, item.Price, LedgerEntry.VehiclePurchase); + } + w.NextIds.Vehicle = w.Vehicles.Count; + RailCommandHandlers.RecomputeTrain(w, t); + w.LineGraphs.Touch(); + return plan.Count; + } +} diff --git a/src/RailEnterprise.Protocol/Client/ClientWorld.cs b/src/RailEnterprise.Protocol/Client/ClientWorld.cs index 2ffa47f..8d9ede0 100644 --- a/src/RailEnterprise.Protocol/Client/ClientWorld.cs +++ b/src/RailEnterprise.Protocol/Client/ClientWorld.cs @@ -56,6 +56,9 @@ public sealed class ClientWorld(GameData data) /// Quadro delle finanze (F6), su richiesta: lo usa il pannello «Finanze». public FinanceReport? Finance { get; private set; } + /// Quadro del rinnovo della flotta (F6, ADR 0020), su richiesta: lo usano i pannelli Treni e Officine. + public FleetReport? Fleet { get; private set; } + /// Contatore dei listini ricevuti (per aggiornare il pannello della borsa). public int TapeVersion { get; private set; } @@ -148,6 +151,10 @@ public sealed class ClientWorld(GameData data) Finance = m; DetailVersion++; return true; + case FleetReport m: + Fleet = m; + DetailVersion++; + return true; case MaintenanceAlert m: Alerts.Insert(0, m); if (Alerts.Count > AlertCapacity) Alerts.RemoveAt(Alerts.Count - 1); @@ -170,6 +177,7 @@ public sealed class ClientWorld(GameData data) Market = null; Climb = null; Finance = null; + Fleet = null; Alerts.Clear(); Summary = m.Summary; SessionId = m.SessionId; diff --git a/src/RailEnterprise.Protocol/Message.cs b/src/RailEnterprise.Protocol/Message.cs index 49ca71d..c961a59 100644 --- a/src/RailEnterprise.Protocol/Message.cs +++ b/src/RailEnterprise.Protocol/Message.cs @@ -47,6 +47,8 @@ public enum MessageId : ushort ClimbReport = 134, /// Quadro delle finanze: conto economico per voce, rating spiegato, prestiti, bancarotta (F6). FinanceReport = 135, + /// Quadro del rinnovo della flotta: ere, veicoli superati, successori, valori (F6). + FleetReport = 136, } /// Messaggio del protocollo: si serializza a mano, campo per campo. diff --git a/src/RailEnterprise.Protocol/Messages/ClientMessages.cs b/src/RailEnterprise.Protocol/Messages/ClientMessages.cs index f030345..c013070 100644 --- a/src/RailEnterprise.Protocol/Messages/ClientMessages.cs +++ b/src/RailEnterprise.Protocol/Messages/ClientMessages.cs @@ -243,6 +243,8 @@ public enum DetailKind : byte Climb = 8, /// Quadro delle finanze (risposta FinanceReport, F6; Id ignorato). Finance = 9, + /// Quadro del rinnovo della flotta (risposta FleetReport, F6, ADR 0020; Id ignorato). + Fleet = 10, } /// Chiede al server un dettaglio che non viaggia con le entità (aggiunto in F4). diff --git a/src/RailEnterprise.Protocol/Messages/FleetMessages.cs b/src/RailEnterprise.Protocol/Messages/FleetMessages.cs new file mode 100644 index 0000000..fcd44e3 --- /dev/null +++ b/src/RailEnterprise.Protocol/Messages/FleetMessages.cs @@ -0,0 +1,157 @@ +using RailEnterprise.Core.Common; + +namespace RailEnterprise.Protocol.Messages; + +// Messaggi della fase F6: ere e obsolescenza dei veicoli (ADR 0020). Il quadro del rinnovo della flotta +// arriva su richiesta (RequestDetail con DetailKind.Fleet) ed è calcolato dal server con FleetOutlook: il +// client lo mostra com'è, senza calcolare età, valori, successori o modelli in produzione. + +/// +/// Veicolo della compagnia per il rinnovo: modello, treno o deposito, età e vita utile, condizione media +/// (0–1), produzione, obsolescenza (anno da cui è superato, 0 se non ha successore), successore consigliato +/// ("" se non superato o senza successore in produzione), valore di libro e di rivendita, moltiplicatore dei +/// costi di manutenzione. +/// +public sealed class FleetVehicleInfo +{ + public int Vehicle { get; init; } + public string Type { get; init; } = ""; + public int Train { get; init; } = -1; + public int Depot { get; init; } = -1; + public float AgeYears { get; init; } + public int LifeYears { get; init; } + public float Condition { get; init; } + public bool InProduction { get; init; } + public bool Superseded { get; init; } + public int SupersededYear { get; init; } + public string Successor { get; init; } = ""; + public Money BookValue { get; init; } + public Money Resale { get; init; } + public float MaintenanceFactor { get; init; } + + public void Write(ref SpanWriter w) + { + w.I32(Vehicle); w.String(Type); w.I32(Train); w.I32(Depot); w.F32(AgeYears); w.I32(LifeYears); w.F32(Condition); + w.Bool(InProduction); w.Bool(Superseded); w.I32(SupersededYear); w.String(Successor); + w.Money(BookValue); w.Money(Resale); w.F32(MaintenanceFactor); + w.Flags(0); + } + + public static FleetVehicleInfo Read(ref SpanReader r) + { + var m = new FleetVehicleInfo + { + Vehicle = r.I32(), Type = r.String(), Train = r.I32(), Depot = r.I32(), AgeYears = r.F32(), LifeYears = r.I32(), Condition = r.F32(), + InProduction = r.Bool(), Superseded = r.Bool(), SupersededYear = r.I32(), Successor = r.String(), + BookValue = r.Money(), Resale = r.Money(), MaintenanceFactor = r.F32(), + }; + r.Flags(); + return m; + } +} + +/// +/// Modello in produzione per il catalogo d'acquisto: superato o no, anno da cui lo è (0 se non ha +/// successore), successore consigliato, ultimo anno di produzione (0 se non previsto). +/// +public sealed class VehicleModelInfo +{ + public string Type { get; init; } = ""; + public bool Superseded { get; init; } + public int SupersededYear { get; init; } + public string Successor { get; init; } = ""; + public int LastYear { get; init; } + + public void Write(ref SpanWriter w) + { + w.String(Type); w.Bool(Superseded); w.I32(SupersededYear); w.String(Successor); w.I32(LastYear); + w.Flags(0); + } + + public static VehicleModelInfo Read(ref SpanReader r) + { + var m = new VehicleModelInfo { Type = r.String(), Superseded = r.Bool(), SupersededYear = r.I32(), Successor = r.String(), LastYear = r.I32() }; + r.Flags(); + return m; + } +} + +/// Treno con veicoli superati da rinnovare: quanti, spesa netta (successori − rivendite + lavoro) e se la cassa basta. +public sealed class RenewalTrainInfo +{ + public int Train { get; init; } + public int Vehicles { get; init; } + public Money NetCost { get; init; } + public bool Affordable { get; init; } + + public void Write(ref SpanWriter w) + { + w.I32(Train); w.I32(Vehicles); w.Money(NetCost); w.Bool(Affordable); + w.Flags(0); + } + + public static RenewalTrainInfo Read(ref SpanReader r) + { + var m = new RenewalTrainInfo { Train = r.I32(), Vehicles = r.I32(), NetCost = r.Money(), Affordable = r.Bool() }; + r.Flags(); + return m; + } +} + +/// +/// Quadro del rinnovo della flotta della compagnia della sessione (F6, ADR 0020): era in corso e prossima +/// (con l'anno; "" e 0 all'ultima), veicoli con età, obsolescenza, successore e valori, catalogo dei +/// modelli in produzione, treni da rinnovare con l'intervento «renewal». +/// +public sealed class FleetReport : IMessage +{ + public MessageId Id => MessageId.FleetReport; + public long Day { get; init; } + public int Company { get; init; } + public int Year { get; init; } + public string Era { get; init; } = ""; + public string NextEra { get; init; } = ""; + public int NextEraYear { get; init; } + /// Id dell'intervento di rinnovo in maintenance.json (per ScheduleService). + public string RenewalIntervention { get; init; } = ""; + public Money BookValueTotal { get; init; } + public List Vehicles { get; init; } = []; + public List Models { get; init; } = []; + public List Trains { get; init; } = []; + + public void Write(ref SpanWriter w) + { + w.I64(Day); w.I32(Company); w.I32(Year); w.String(Era); w.String(NextEra); w.I32(NextEraYear); w.String(RenewalIntervention); + w.Money(BookValueTotal); + w.Count(Vehicles.Count); + foreach (var v in Vehicles) v.Write(ref w); + w.Count(Models.Count); + foreach (var m in Models) m.Write(ref w); + w.Count(Trains.Count); + foreach (var t in Trains) t.Write(ref w); + w.Flags(0); + } + + public static FleetReport Read(ref SpanReader r) + { + long day = r.I64(); + int company = r.I32(), year = r.I32(); + string era = r.String(), next = r.String(); + int nextYear = r.I32(); + string renewal = r.String(); + var book = r.Money(); + var vehicles = new List(); + for (int n = r.Count(), i = 0; i < n; i++) vehicles.Add(FleetVehicleInfo.Read(ref r)); + var models = new List(); + for (int n = r.Count(), i = 0; i < n; i++) models.Add(VehicleModelInfo.Read(ref r)); + var trains = new List(); + for (int n = r.Count(), i = 0; i < n; i++) trains.Add(RenewalTrainInfo.Read(ref r)); + var m = new FleetReport + { + Day = day, Company = company, Year = year, Era = era, NextEra = next, NextEraYear = nextYear, RenewalIntervention = renewal, + BookValueTotal = book, Vehicles = vehicles, Models = models, Trains = trains, + }; + r.Flags(); + return m; + } +} diff --git a/src/RailEnterprise.Protocol/Messages/MessageCodec.cs b/src/RailEnterprise.Protocol/Messages/MessageCodec.cs index 72ddbea..f1b805c 100644 --- a/src/RailEnterprise.Protocol/Messages/MessageCodec.cs +++ b/src/RailEnterprise.Protocol/Messages/MessageCodec.cs @@ -34,6 +34,7 @@ public static class MessageCodec MessageId.MarketReport => MarketReport.Read(ref r), MessageId.ClimbReport => ClimbReport.Read(ref r), MessageId.FinanceReport => FinanceReport.Read(ref r), + MessageId.FleetReport => FleetReport.Read(ref r), MessageId.MarketTape => MarketTape.Read(ref r), MessageId.CommandResult => CommandResultMessage.Read(ref r), MessageId.Notification => Notification.Read(ref r), diff --git a/src/RailEnterprise.Server/GameHost.cs b/src/RailEnterprise.Server/GameHost.cs index db976a1..70c19a6 100644 --- a/src/RailEnterprise.Server/GameHost.cs +++ b/src/RailEnterprise.Server/GameHost.cs @@ -667,6 +667,9 @@ public sealed class GameHost : IDisposable case DetailKind.Finance: if (s.Company.IsValid && s.Company.Value < w.Companies.Count) s.Send(Projection.Finance(w, s.Company)); break; + case DetailKind.Fleet: + if (s.Company.IsValid && s.Company.Value < w.Companies.Count) s.Send(Projection.FleetRenewal(w, s.Company)); + break; } } diff --git a/src/RailEnterprise.Server/Projection.cs b/src/RailEnterprise.Server/Projection.cs index ecf8a20..dcc83c0 100644 --- a/src/RailEnterprise.Server/Projection.cs +++ b/src/RailEnterprise.Server/Projection.cs @@ -625,6 +625,32 @@ public static class Projection }; } + /// Quadro del rinnovo della flotta per la compagnia della sessione (FleetOutlook, ADR 0020). + public static FleetReport FleetRenewal(World w, CompanyId company) + { + var report = FleetOutlook.Build(w, company); + var interventions = w.Data.Maintenance.Interventions; + return new FleetReport + { + Day = report.Day, Company = report.Company.Value, Year = report.Year, Era = report.Era.Id, + NextEra = report.NextEra?.Id ?? "", NextEraYear = report.NextEra?.From ?? 0, + RenewalIntervention = interventions.First(i => i.Effect == InterventionEffect.Renew).Id, + BookValueTotal = report.BookValueTotal, + Vehicles = report.Vehicles.Select(v => new FleetVehicleInfo + { + Vehicle = v.Id.Value, Type = v.Def.Id, Train = v.Train.Value, Depot = v.Depot.Value, AgeYears = (float)v.AgeYears, + LifeYears = v.Def.LifeYears, Condition = (float)v.Condition, InProduction = v.InProduction, Superseded = v.Superseded, + SupersededYear = v.SupersededYear ?? 0, Successor = v.Successor?.Id ?? "", BookValue = v.BookValue, Resale = v.ResaleValue, + MaintenanceFactor = (float)v.MaintenanceFactor, + }).ToList(), + Models = report.Models.Select(m => new VehicleModelInfo + { + Type = m.Def.Id, Superseded = m.Superseded, SupersededYear = m.SupersededYear ?? 0, Successor = m.Successor?.Id ?? "", LastYear = m.LastYear ?? 0, + }).ToList(), + Trains = report.Trains.Select(t => new RenewalTrainInfo { Train = t.Train.Value, Vehicles = t.Vehicles, NetCost = t.NetCost, Affordable = t.Affordable }).ToList(), + }; + } + /// Evento del mondo in corso → record del protocollo (ADR 0017). public static WorldEventInfo WorldEvent(ActiveWorldEvent e) => new() { diff --git a/tests/RailEnterprise.Tests/Economy/ErasTests.cs b/tests/RailEnterprise.Tests/Economy/ErasTests.cs new file mode 100644 index 0000000..86aab43 --- /dev/null +++ b/tests/RailEnterprise.Tests/Economy/ErasTests.cs @@ -0,0 +1,360 @@ +using System.Text.Json.Nodes; +using RailEnterprise.Core.Commands; +using RailEnterprise.Core.Common; +using RailEnterprise.Core.Data; +using RailEnterprise.Core.Economy; +using RailEnterprise.Core.Persistence; +using RailEnterprise.Core.Rail; +using RailEnterprise.Core.Simulation; +using RailEnterprise.Core.Simulation.Ai; +using RailEnterprise.Core.Simulation.Scenarios; +using RailEnterprise.Core.Simulation.Systems; +using RailEnterprise.Protocol; +using RailEnterprise.Protocol.Messages; +using RailEnterprise.Server; +using RailEnterprise.Tests.Harness; +using RailEnterprise.Tests.Rail; +using RailEnterprise.Tests.Scenarios; + +namespace RailEnterprise.Tests.Economy; + +/// Ere, novità tecnologiche, obsolescenza e rinnovo della flotta (F6, ADR 0020). +public static class ErasTests +{ + private static readonly Vec2 DepotPos = RailFixture.K(2.6, 4.4); + + /// Valdoria che comincia nell'anno indicato, con un deposito e l'id del deposito. + private static (RailFixture F, int Depot) ValdoriaIn(int year, GameData? data = null) + { + var json = JsonNode.Parse(File.ReadAllText(ScenarioHelper.PathOf("valdoria")))!; + json["startYear"] = year; + var s = ScenarioLoader.Load(data ?? TestData.Data, json.ToJsonString()); + var f = new RailFixture(s.World, s); + int depot = f.Ok(new BuildDepotCommand(DepotPos, "small", "Deposito di prova")); + return (f, depot); + } + + private static int CountTechnology(IEnumerable events) => events.Count(e => e.Kind == EventKind.Technology); + + private static void AssertInvariants(World w, string when) + { + Assert.Equal(0L, w.MoneyBalanceSum(), $"denaro {when}"); + for (int g = 0; g < w.Data.GoodCount; g++) + Assert.Equal(w.Goods.ExpectedStock(g), w.TotalStock(g), $"merce {w.Data.Goods[g].Id} {when}"); + } + + [Test(Description = "Sblocchi per anno letti dai dati: era in corso, novità, fuori produzione, superati e testo della notizia")] + public static void UnlocksFollowTheYear() + { + var d = TestData.Data; + Assert.Equal("steam", EraSystem.CurrentEra(d, 1924).Id); + Assert.Equal("diesel", EraSystem.CurrentEra(d, 1925).Id); + Assert.Equal("electric", EraSystem.NextEra(d, 1925)!.Id); + Assert.True(EraSystem.NextEra(d, 1990) is null, "dopo l'ultima era non ce n'è un'altra"); + + var u1878 = EraSystem.Unlocks(d, 1878); + Assert.True(u1878.Any(u => u.Kind == TechKind.Vehicle && u.Id == "loco_steam_1878"), "1878: Vittoria 2-8-0"); + Assert.Equal("loco_steam_1850", EraSystem.NewlySuperseded(d, 1878).Single().Id); + var u1925 = EraSystem.Unlocks(d, 1925); + Assert.True(u1925.Any(u => u.Kind == TechKind.Traction && u.Id == "diesel"), "1925: trazione diesel"); + Assert.True(u1925.Any(u => u.Kind == TechKind.Vehicle && u.Id == "loco_diesel_1925"), "1925: Aquila D1"); + var u1950 = EraSystem.Unlocks(d, 1950); + Assert.True(u1950.Any(u => u.Kind == TechKind.Electrification), "1950: elettrificazione"); + Assert.True(u1950.Any(u => u.Kind == TechKind.BridgeType && u.Id == "concrete"), "1950: ponti in cemento armato"); + Assert.True(u1950.Any(u => u.Kind == TechKind.TunnelLimit), "1950: gallerie più lunghe"); + Assert.Equal("loco_steam_1850", EraSystem.Retired(d, 1906).Single().Id); + + string text = EraSystem.NewsText(d, 1925)!; + Assert.True(text.StartsWith("Inizia l'Era diesel (1925)", StringComparison.Ordinal), text); + Assert.True(text.Contains("Aquila D1", StringComparison.Ordinal) && text.Contains("Freccia 4-6-2 (successore Aquila D1)", StringComparison.Ordinal), text); + Assert.True(EraSystem.NewsText(d, 1878)!.StartsWith("Novità del 1878", StringComparison.Ordinal)); + Assert.True(EraSystem.NewsText(d, 1906)!.Contains("fuori produzione: Ardita 2-6-0", StringComparison.Ordinal)); + Assert.True(EraSystem.NewsText(d, 1851) is null, "un anno senza novità non dà notizie"); + + // nessun elenco scritto a mano: un modello aggiunto ai dati entra nella notizia del suo anno + var files = MemoryDataSource.Snapshot(TestData.Source); + var vehicles = JsonNode.Parse(files["vehicles.json"])!; + var copy = JsonNode.Parse(vehicles["vehicles"]![0]!.ToJsonString())!; + copy["id"] = "loco_steam_1851"; + copy["name_it"] = "Prova 1851"; + copy["eraFrom"] = 1851; + copy.AsObject().Remove("successor"); + vehicles["vehicles"]!.AsArray().Add(copy); + files["vehicles.json"] = vehicles.ToJsonString(); + var altered = GameData.Load(new MemoryDataSource(files)); + Assert.True(EraSystem.NewsText(altered, 1851)!.Contains("locomotiva Prova 1851", StringComparison.Ordinal)); + } + + [Test(Description = "Il validatore rifiuta successori sconosciuti, di un'altra categoria o introdotti prima")] + public static void SuccessorValidation() + { + static string? Error(Action change) + { + var files = MemoryDataSource.Snapshot(TestData.Source); + var vehicles = JsonNode.Parse(files["vehicles.json"])!; + change(vehicles["vehicles"]!); + files["vehicles.json"] = vehicles.ToJsonString(); + try + { + GameData.Load(new MemoryDataSource(files)); + return null; + } + catch (DataValidationException ex) + { + return ex.Message; + } + } + JsonNode Find(JsonNode list, string id) => list.AsArray().First(v => (string)v!["id"]! == id)!; + Assert.True(Error(l => Find(l, "loco_steam_1850")["successor"] = "loco_inesistente") is { } e1 && e1.Contains("sconosciuto", StringComparison.Ordinal)); + Assert.True(Error(l => Find(l, "loco_steam_1850")["successor"] = "wagon_hopper") is { } e2 && e2.Contains("categoria", StringComparison.Ordinal)); + Assert.True(Error(l => Find(l, "loco_steam_1878")["successor"] = "loco_steam_1850") is { } e3 && e3.Contains("dopo", StringComparison.Ordinal)); + Assert.True(Error(l => Find(l, "loco_diesel_1925")["successor"] = "loco_electric_1950") is { } e4 && e4.Contains("elettrificata", StringComparison.Ordinal)); + } + + [Test(Description = "La notizia del passaggio d'anno esce una volta sola, anche salvando prima o dopo, e la Cronaca la registra")] + public static void EraNewsOnceAcrossSaves() + { + var (f, _) = ValdoriaIn(1877); + var w = f.W; + int dpy = w.Calendar.DaysPerYear; + w.RunTicks((long)dpy * w.Calendar.TicksPerDay - 1 - w.Clock.Tick); + Assert.Equal(1877, w.Clock.Year); + Assert.Equal(0, CountTechnology(w.Events.Drain()), "nessuna notizia nel 1877"); + var before = SaveFile.Load(TestData.Data, SaveFile.Save(w, "test")); + w.RunDays(2); + before.RunDays(2); + var news = w.Events.Drain().Where(e => e.Kind == EventKind.Technology).ToList(); + Assert.Equal(1, news.Count, "una notizia nel tick del 1° gennaio"); + Assert.Equal(1, CountTechnology(before.Events.Drain()), "anche dal salvataggio fatto il 31 dicembre"); + Assert.True(news[0].Text.Contains("Vittoria 2-8-0", StringComparison.Ordinal), news[0].Text); + Assert.False(news[0].Company.IsValid, "la notizia è per tutte le compagnie"); + Assert.Equal(StateHasher.Compute(w), StateHasher.Compute(before), "stesso stato passando dal salvataggio"); + + var after = SaveFile.Load(TestData.Data, SaveFile.Save(w, "test")); + after.RunDays(60); + Assert.Equal(0, CountTechnology(after.Events.Drain()), "dopo il caricamento la notizia non si ripete"); + Assert.Equal(1, after.Player.Milestones.Count(m => m.Text.StartsWith("novità del 1878", StringComparison.Ordinal)), "fatto saliente nella Cronaca"); + Assert.True(ChronicleReport.Build(after).Highlights.Any(h => h.Contains("Vittoria 2-8-0", StringComparison.Ordinal)), "nella Cronaca"); + } + + [Test(Description = "Un modello fuori produzione non si compra né compare nel catalogo; i superati sono segnati con il successore")] + public static void OutOfProductionIsNotBuyable() + { + var (f, depot) = ValdoriaIn(1906); + var r = f.Do(new BuyVehicleCommand("loco_steam_1850", new DepotId(depot), 1)); + Assert.Equal(CommandError.EraLocked, r.Error, r.Message); + Assert.True(f.Do(new BuyVehicleCommand("loco_steam_1878", new DepotId(depot), 1)).Ok, "il modello del 1878 è ancora in produzione"); + var report = FleetOutlook.Build(f.W, f.Me); + Assert.False(report.Models.Any(m => m.Def.Id == "loco_steam_1850"), "il catalogo nasconde i fuori produzione"); + var m1878 = report.Models.Single(m => m.Def.Id == "loco_steam_1878"); + Assert.True(m1878.Superseded, "superato dalla Freccia del 1902"); + Assert.Equal("loco_steam_1902", m1878.Successor!.Id); + Assert.False(report.Models.Single(m => m.Def.Id == "wagon_hopper").Superseded, "un carro senza successore non è superato"); + Assert.Equal("loco_steam_1902", Obsolescence.Recommended(f.W.Data.Vehicle("loco_steam_1850"), 1906)!.Id, + "il successore consigliato salta i modelli fuori produzione della catena"); + } + + [Test(Description = "Curva del valore: gradino all'arrivo del successore, poi ammortamento più rapido; rivendita = libro × condizione")] + public static void ValueCurveOfSupersededModels() + { + var d = TestData.Data; + var (f, depot) = ValdoriaIn(1876); + var w = f.W; + var cal = w.Calendar; + var o = d.Obsolescence; + double floor = d.Balance.Finance.BookValueFloor; + var loco = d.Vehicle("loco_steam_1850"); + var wagon = d.Vehicle("wagon_hopper"); + long obsolete = Obsolescence.SupersededDay(cal, loco); + Assert.Equal((long)(1878 - 1876) * cal.DaysPerYear, obsolete); + + double before = Obsolescence.Residual(d, cal, loco, 0, obsolete - 1); + double at = Obsolescence.Residual(d, cal, loco, 0, obsolete); + Assert.Approx(1 - (obsolete - 1) / (double)cal.DaysPerYear / loco.LifeYears, before, 1e-12, "prima: lineare sulla vita"); + Assert.Approx((1 - o.ImmediateValueLoss) * (1 - 2.0 / loco.LifeYears), at, 1e-12, "gradino di immediateValueLoss"); + double oneYear = Obsolescence.Residual(d, cal, loco, 0, obsolete + cal.DaysPerYear); + Assert.Approx((1 - o.ImmediateValueLoss) * (1 - (3 + (o.DepreciationSpeed - 1)) / loco.LifeYears), oneYear, 1e-12, "ammortamento più rapido"); + // pendenza da superato = depreciationSpeed volte quella normale (scalata dal gradino) + double normalSlope = 1.0 / loco.LifeYears; + Assert.Approx((1 - o.ImmediateValueLoss) * o.DepreciationSpeed * normalSlope, at - oneYear, 1e-12); + // un carro senza successore segue la curva di sempre + Assert.Approx(1 - 3.0 / wagon.LifeYears, Obsolescence.Residual(d, cal, wagon, 0, obsolete + cal.DaysPerYear), 1e-12); + // monotona e mai sotto il minimo, anche per un veicolo comprato dopo l'arrivo del successore + foreach (long bought in new[] { 0L, obsolete + 100 }) + { + double last = double.MaxValue; + for (long day = bought; day < bought + 40L * cal.DaysPerYear; day += 7) + { + double r = Obsolescence.Residual(d, cal, loco, bought, day); + Assert.True(r <= last + 1e-12 && r >= floor - 1e-12, $"residuo {r} al giorno {day}"); + last = r; + } + } + Assert.Approx(1 - o.ImmediateValueLoss, Obsolescence.Residual(d, cal, loco, obsolete + 100, obsolete + 100), 1e-12, "nuovo ma già superato"); + + // valore di libro, rivendita e SellVehicle sullo stesso residuo + int id = f.Do(new BuyVehicleCommand("loco_steam_1850", new DepotId(depot), 1)).Created[0]; + w.RunDays((int)(obsolete - w.Clock.Day) + 30); + var v = w.Vehicles[id]; + v.Components[0] = 50; + double residual = Obsolescence.Residual(w, v); + Assert.Equal((long)(loco.Price * residual), Obsolescence.BookValueCents(w, v)); + var resale = Obsolescence.ResaleValue(w, v); + Assert.Equal(new Money(loco.Price) * (residual * Obsolescence.AverageCondition(v)), resale); + var cash = w.Player.Cash; + Assert.True(f.Do(new SellVehicleCommand(new VehicleId(id))).Ok); + Assert.Equal(cash + resale, w.Player.Cash, "SellVehicle incassa la rivendita"); + AssertInvariants(w, "dopo la vendita"); + } + + [Test(Description = "La manutenzione di un modello superato costa maintenanceCostFactor volte; gli altri veicoli non cambiano")] + public static void SupersededMaintenanceCostsMore() + { + Money ServiceCost(int year) + { + var (f, depot) = ValdoriaIn(year); + int train = f.Train(depot, "Prova", ("loco_steam_1850", 1), ("wagon_hopper", 3)); + var w = f.W; + var t = w.Trains[train]; + var def = w.Data.Maintenance.Interventions[w.Data.Maintenance.InterventionIndex("service")]; + return Fleet.CostOf(w, t, def, Fleet.PolicyOf(w, t)); + } + var d = TestData.Data; + var service = d.Maintenance.Interventions[d.Maintenance.InterventionIndex("service")]; + long loco = d.Vehicle("loco_steam_1850").Price, wagon = d.Vehicle("wagon_hopper").Price; + Assert.Equal(Money.FromCentsRounded((loco + 3.0 * wagon) * service.CostShare), ServiceCost(1877), "prima del successore"); + Assert.Equal(Money.FromCentsRounded((loco * d.Obsolescence.MaintenanceCostFactor + 3.0 * wagon) * service.CostShare), ServiceCost(1878), + "superato: solo la locomotiva costa di più"); + } + + [Test(Description = "Valore di libro dei veicoli: una sola fonte per patrimonio, quadro della flotta e stato patrimoniale")] + public static void BookValueMatchesNetWorth() + { + var (f, depot) = ValdoriaIn(1877); + var w = f.W; + f.Train(depot, "Prova", ("loco_steam_1850", 2), ("coach_worker", 2)); + w.RunDays(w.Calendar.DaysPerYear + w.Calendar.DaysPerMonth - (int)(w.Clock.Day % w.Calendar.DaysPerMonth)); + Assert.Equal(1878, w.Clock.Year); + Assert.Equal(0L, w.Clock.Day % w.Calendar.DaysPerMonth, "inizio del mese: valori appena aggiornati"); + long expected = w.Vehicles.Where(v => !v.Sold && v.Owner == f.Me).Sum(v => Obsolescence.BookValueCents(w, v)); + Assert.Equal(expected, FinanceSystem.BookValues(w)[f.Me.Value][(int)AssetCategory.Vehicles], "FinanceSystem.BookValues"); + Assert.Equal(expected, w.Player.BookValues[(int)AssetCategory.Vehicles], "voce salvata dal mese"); + Assert.Equal(new Money(expected), FleetOutlook.Build(w, f.Me).BookValueTotal, "quadro della flotta"); + var balance = ClimbOutlook.Balance(w.Player); + Assert.Equal(new Money(expected), balance.Assets.Single(a => a.Category == AssetCategory.Vehicles).Value, "stato patrimoniale"); + Assert.Equal(w.Player.NetWorth, w.Player.Cash + w.Player.AssetBookValue + w.Player.PortfolioValue - w.Player.Debt); + } + + [Test(Description = "Rinnovo in officina: i veicoli superati si vendono e i successori prendono il loro posto, con denaro e merci in equilibrio")] + public static void RenewalReplacesSupersededVehicles() + { + var (f, depot) = ValdoriaIn(1878); + var w = f.W; + int fresh = f.Train(depot, "Nuovo", ("loco_steam_1878", 1), ("wagon_hopper", 2)); + var refused = f.Do(new ScheduleServiceCommand(new TrainId(fresh), "renewal")); + Assert.Equal(CommandError.NotAllowed, refused.Error, "niente da rinnovare"); + + int train = f.Train(depot, "Vecchio", ("loco_steam_1850", 1), ("wagon_hopper", 2)); + var t = w.Trains[train]; + var oldLoco = t.Vehicles[0]; + var wagons = t.Vehicles.Skip(1).ToList(); + var plan = Obsolescence.RenewalPlan(w, t); + Assert.Equal(1, plan.Count, "solo la locomotiva è superata"); + Assert.Equal("loco_steam_1878", plan[0].Successor.Id); + var renewal = w.Data.Maintenance.Interventions[w.Data.Maintenance.InterventionIndex("renewal")]; + var outlook = FleetOutlook.Build(w, f.Me).Trains.Single(x => x.Train.Value == train); + Assert.Equal(Obsolescence.NetCost(plan) + Fleet.CostOf(w, t, renewal, Fleet.PolicyOf(w, t)), outlook.NetCost); + + var cash = w.Player.Cash; + Assert.True(f.Do(new ScheduleServiceCommand(new TrainId(train), "renewal")).Ok); + Assert.True(t.InWorkshop, "il treno è già nel deposito: entra subito in officina"); + Assert.True(f.RunUntil(() => !t.InWorkshop, 30), "rinnovo completato"); + Assert.True(w.Vehicles[oldLoco.Value].Sold, "la vecchia locomotiva è venduta"); + var loco = w.Vehicles[t.Vehicles[0].Value]; + Assert.Equal("loco_steam_1878", loco.Def.Id); + Assert.Equal(t.Id, loco.Train); + Assert.SequenceEqual(wagons, t.Vehicles.Skip(1), "i carri restano al loro posto"); + Assert.Approx(loco.Def.PowerKw, t.PowerKw, 1e-9, "caratteristiche del treno ricalcolate"); + Assert.True(w.Player.Cash < cash, "il rinnovo costa"); + Assert.Equal(0, Obsolescence.RenewalPlan(w, t).Count, "niente più da rinnovare"); + Assert.True(t.History.Any(h => h.Intervention == w.Data.Maintenance.InterventionIndex("renewal")), "nello storico della manutenzione"); + AssertInvariants(w, "dopo il rinnovo"); + } + + [Test(Description = "Rinnovo deterministico e salvataggio a metà officina: stesso hash e stesso esito, senza nuovo stato (corpo versione 7)")] + public static void RenewalIsDeterministicAcrossSaves() + { + Assert.Equal(7, WorldSerializer.BodyVersion, "ere e obsolescenza non aggiungono stato al salvataggio"); + (World W, int Train) Start() + { + var (f, depot) = ValdoriaIn(1878); + int train = f.Train(depot, "Vecchio", ("loco_steam_1850", 1), ("coach_worker", 2)); + Assert.True(f.Do(new ScheduleServiceCommand(new TrainId(train), "renewal")).Ok); + f.W.RunDays(1); + return (f.W, train); + } + var (a, train) = Start(); + var (b, _) = Start(); + var loaded = SaveFile.Load(TestData.Data, SaveFile.Save(b, "test")); + Assert.True(loaded.Trains[train].InWorkshop, "salvato a metà officina"); + a.RunDays(40); + loaded.RunDays(40); + Assert.Equal(StateHasher.Compute(a), StateHasher.Compute(loaded)); + Assert.Equal("loco_steam_1878", loaded.Vehicles[loaded.Trains[train].Vehicles[0].Value].Def.Id); + Assert.Equal(0L, loaded.MoneyBalanceSum()); + } + + [Test(Description = "Il quadro della flotta si proietta nel protocollo e sopravvive al round-trip")] + public static void FleetReportRoundTrip() + { + var (f, depot) = ValdoriaIn(1878); + var w = f.W; + int train = f.Train(depot, "Vecchio", ("loco_steam_1850", 1), ("wagon_hopper", 1)); + ulong hash = StateHasher.Compute(w); + var report = Projection.FleetRenewal(w, f.Me); + Assert.Equal(hash, StateHasher.Compute(w), "il quadro non cambia il mondo"); + var decoded = (FleetReport)Frame.Decode(Frame.Encode(report)); + Assert.Equal("steam", decoded.Era); + Assert.Equal("diesel", decoded.NextEra); + Assert.Equal(1925, decoded.NextEraYear); + Assert.Equal("renewal", decoded.RenewalIntervention); + Assert.Equal(2, decoded.Vehicles.Count); + var loco = decoded.Vehicles.Single(v => v.Type == "loco_steam_1850"); + Assert.True(loco.Superseded && loco.InProduction); + Assert.Equal(1878, loco.SupersededYear); + Assert.Equal("loco_steam_1878", loco.Successor); + Assert.Equal(train, loco.Train); + Assert.Approx(w.Data.Obsolescence.MaintenanceCostFactor, loco.MaintenanceFactor, 1e-6); + var v = w.Vehicles[loco.Vehicle]; + Assert.Equal(Obsolescence.ResaleValue(w, v), loco.Resale); + Assert.Equal(new Money(Obsolescence.BookValueCents(w, v)), loco.BookValue); + Assert.Equal(decoded.Vehicles.Sum(x => x.BookValue.Cents), decoded.BookValueTotal.Cents); + Assert.Equal(train, decoded.Trains.Single().Train); + Assert.True(decoded.Models.Single(m => m.Type == "loco_steam_1850").Superseded); + Assert.False(decoded.Models.Any(m => m.Type == "loco_diesel_1925"), "non ancora introdotto"); + } + + [Test(Slow = true, Description = "Le IA rinnovano i treni con locomotive superate, senza comandi rifiutati oltre il 5 %")] + public static void AiRenewsSupersededTrains() + { + var files = MemoryDataSource.Snapshot(TestData.Source); + var ai = JsonNode.Parse(files["ai.json"])!; + ai["renewal"]!["minSupersededYears"] = 0; + files["ai.json"] = ai.ToJsonString(); + var data = GameData.Load(new MemoryDataSource(files)); + var w = WorldFactory.Create(data, new NewGameSettings { Seed = 42, SizeKm = 64, StartYear = 1875 }); + // fino al 1878: le IA costruiscono le prime linee con l'Ardita del 1850 + w.RunTicks((long)3 * w.Calendar.DaysPerYear * w.Calendar.TicksPerDay - w.Clock.Tick); + Assert.Equal(1878, w.Clock.Year); + var oldTrains = w.Trains + .Where(t => !t.Removed && !w.Company(t.Owner).IsPlayer && t.Vehicles.Any(id => w.Vehicles[id.Value].Def.Id == "loco_steam_1850")) + .Select(t => t.Id).ToList(); + Assert.True(oldTrains.Count > 0, "le IA hanno treni con l'Ardita"); + w.RunYears(2); + int renewed = oldTrains.Count(id => w.Trains[id.Value].Vehicles.Any(v => w.Vehicles[v.Value].Def.Id == "loco_steam_1878")); + Assert.True(renewed > 0, $"almeno un treno rinnovato su {oldTrains.Count}"); + foreach (var s in w.AiStates) + Assert.True(s.RejectedShare <= w.Data.Ai.Planning.MaxRejectedShare, $"{w.Company(s.Company).Name}: {s.Rejected} rifiutati su {s.Issued}"); + Assert.Equal(0L, w.MoneyBalanceSum()); + } +} diff --git a/tests/RailEnterprise.Tests/Protocol/ProtocolTests.cs b/tests/RailEnterprise.Tests/Protocol/ProtocolTests.cs index 5b89bc1..e23e458 100644 --- a/tests/RailEnterprise.Tests/Protocol/ProtocolTests.cs +++ b/tests/RailEnterprise.Tests/Protocol/ProtocolTests.cs @@ -188,6 +188,22 @@ public static class ProtocolTests MaxLoan = new Money(100_000_000), LoanAvailable = new Money(88_000_000), NewLoanRate = 0.061f, LoansAllowed = false, History = [new NetWorthPointInfo { Day = 0, Value = new Money(25_000_000) }, new NetWorthPointInfo { Day = 2600, Value = new Money(39_144_993) }], }; + yield return new FleetReport + { + Day = 10_100, Company = 0, Year = 1878, Era = "steam", NextEra = "diesel", NextEraYear = 1925, RenewalIntervention = "renewal", + BookValueTotal = new Money(1_234_567), + Vehicles = + [ + new FleetVehicleInfo { Vehicle = 3, Type = "loco_steam_1850", Train = 1, Depot = -1, AgeYears = 26.5f, LifeYears = 25, Condition = 0.8f, + InProduction = true, Superseded = true, SupersededYear = 1878, Successor = "loco_steam_1878", BookValue = new Money(180_000), + Resale = new Money(144_000), MaintenanceFactor = 1.5f }, + new FleetVehicleInfo { Vehicle = 4, Type = "wagon_hopper", Train = -1, Depot = 2, AgeYears = 1f, LifeYears = 40, Condition = 1f, + InProduction = true, BookValue = new Money(117_000), Resale = new Money(117_000), MaintenanceFactor = 1f }, + ], + Models = [new VehicleModelInfo { Type = "loco_steam_1850", Superseded = true, SupersededYear = 1878, Successor = "loco_steam_1878", LastYear = 1905 }, + new VehicleModelInfo { Type = "wagon_hopper" }], + Trains = [new RenewalTrainInfo { Train = 1, Vehicles = 1, NetCost = new Money(3_056_000), Affordable = true }], + }; yield return new FinanceReport { Day = 2610, Company = 0, Cash = new Money(-120_000), NetWorth = new Money(39_000_000), Loans = new Money(12_000_000), Overdraft = new Money(120_000), From 45462bf9ecc879c24106ff2163f7c31a8b701467 Mon Sep 17 00:00:00 2001 From: Alberto Balbo Date: Sun, 8 Nov 2026 14:04:28 +0100 Subject: [PATCH 3/7] F6: scheda industria e schermata di connessione definitive MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit La scheda dell'industria e la schermata di connessione si allineano alle immagini di riferimento 07 e 09. I dati che mancavano li calcola il Core con una funzione pura, e viaggiano in blocchi compatibili del protocollo. Il formato dei salvataggi non cambia (ADR 0021). - IndustryOutlook calcola la scheda in sola lettura: - fattori dell'efficienza e quello che la limita; - ingressi e uscite al mese, con giorni di scorta o di magazzino; - fornitori e clienti con prezzo, distanza e linea che li collega; - forza lavoro dai contratti dei pendolari; - punteggio di crescita del trimestre con le soglie; - prezzo medio, utile annuo, stazioni che la servono, sblocco dell'acquisto. IndustryMath.GrowthScore è ora l'unica formula del punteggio e la usa anche IndustrySystem: gli hash non cambiano. Nuovi parametri in balance.json, industry.outlook. - Protocollo: - IndustryCard: blocco 1 IndustrySheetInfo; - Welcome: blocco 1 ServerInfo (versione, sistema, Docker, tempo di attività, passo del ciclo, client collegati); - ClientWorld conserva lo stato del server e l'elenco dei salvataggi. - Client: - IndustryPanel a tutto schermo, con tre schede, il grafo della catena, impianti e crescita, e i comandi del proprietario; - ConnectScreen sostituisce MenuScreen: server locale o in rete, stato del server, partite salvate, «Connetti e riprendi» e «Nuova partita sul server» su una sessione di prova; - testi in strings.csv; - pilota automatico: schermate 19_scheda_industria e 20_connessione. - Test: - IndustryOutlookTests; - scheda e stato del server via WebSocket; - campioni del protocollo con i blocchi nuovi. 200 test, 181 senza i lenti. Refs #42. Co-Authored-By: Claude Opus 5.5 --- .../assets/i18n/strings.csv | 105 +++ .../scripts/App/AutoPilot.cs | 23 + client/RailEnterprise.Client/scripts/Main.cs | 59 +- .../scripts/Panels/IndustryPanel.cs | 625 +++++++++++++----- .../scripts/Panels/IndustryWidgets.cs | 185 ++++++ .../scripts/Screens/ConnectScreen.cs | 611 +++++++++++++++-- .../scripts/Screens/GameScreen.cs | 29 +- .../scripts/Screens/MenuScreen.cs | 56 -- .../scripts/Screens/MenuScreen.cs.uid | 1 - data/balance.json | 3 +- docs/ARCHITECTURE.md | 6 +- docs/PROTOCOL.md | 16 +- docs/STATE.md | 37 +- .../0021-scheda-industria-e-connessione.md | 103 +++ src/RailEnterprise.Core/Data/BalanceDefs.cs | 11 + src/RailEnterprise.Core/Data/DataValidator.cs | 2 + .../Economy/IndustryOutlook.cs | 515 +++++++++++++++ .../Simulation/Systems/IndustryMath.cs | 17 + .../Simulation/Systems/IndustrySystem.cs | 5 +- .../Client/ClientWorld.cs | 11 + .../Messages/CorporateMessages.cs | 16 +- .../Messages/IndustryMessages.cs | 269 ++++++++ .../Messages/ServerMessages.cs | 15 +- src/RailEnterprise.Server/GameHost.cs | 17 +- src/RailEnterprise.Server/Projection.cs | 43 +- .../Economy/IndustryOutlookTests.cs | 279 ++++++++ .../Protocol/ProtocolTests.cs | 31 + .../Server/ServerTests.cs | 49 ++ 28 files changed, 2810 insertions(+), 329 deletions(-) create mode 100644 client/RailEnterprise.Client/scripts/Panels/IndustryWidgets.cs delete mode 100644 client/RailEnterprise.Client/scripts/Screens/MenuScreen.cs delete mode 100644 client/RailEnterprise.Client/scripts/Screens/MenuScreen.cs.uid create mode 100644 docs/adr/0021-scheda-industria-e-connessione.md create mode 100644 src/RailEnterprise.Core/Economy/IndustryOutlook.cs create mode 100644 src/RailEnterprise.Protocol/Messages/IndustryMessages.cs create mode 100644 tests/RailEnterprise.Tests/Economy/IndustryOutlookTests.cs diff --git a/client/RailEnterprise.Client/assets/i18n/strings.csv b/client/RailEnterprise.Client/assets/i18n/strings.csv index dd4319d..c910eb2 100644 --- a/client/RailEnterprise.Client/assets/i18n/strings.csv +++ b/client/RailEnterprise.Client/assets/i18n/strings.csv @@ -1,9 +1,13 @@ keys,it,en +a piena capacità,,at full capacity Abitanti,,Population Accetta,,Accept Acquista,,Buy Aderisci con le tue azioni,,Tender your shares +adesso,,just now Aggiorna,,Refresh +al giorno,,per day +al lavoro ora,,at work now Alto,,High Ambra,,Amber Amministrazione controllata,,Receivership @@ -20,23 +24,29 @@ Assegna,,Assign Asta degli attivi,,Asset auction Attendi il pieno alla prima fermata (max 2 giorni),,Wait for full load at the first stop (max 2 days) Attiva,,Active +Attivo da,,Up for +automatico,,automatic Avvio del server locale…,,Starting the local server… Azioni proprie (non votano),,Treasury shares (no vote) Base,,Base Base d'asta,,Reserve price +bastano per,,enough for Binari,,Track Binari di stazione,,Platforms Blu,,Blue Budget di manutenzione,,Maintenance budget C'è già un'offerta in corso su questa compagnia: la trovi nell'elenco a sinistra.,,There is already a bid on this company: see the list on the left. Cantiere,,Construction +Capacità ridotta da un evento,,Capacity reduced by an event Capitalizz.,,Market cap Capitalizzazione,,Market cap +Caricamento di,,Loading Carico,,Load Cartella di manutenzione,,Maintenance record Cartella in arrivo dal server…,,Record on its way from the server… Cassa,,Cash Cassa dell'industria,,Industry cash +Catena produttiva,,Production chain Cavaliere bianco,,White knight Celeste,,Light blue "Chi offre di più alla chiusura compra treni, binari, stazioni e industrie della compagnia fallita.",,"The highest bidder at closing buys the bankrupt company's trains, track, stations and industries." @@ -334,11 +344,21 @@ capacità mancante da,,capacity short for carica,,load cavaliere bianco,,white knight città senza servizi per il personale,,towns without services for staff +Client collegati,,Connected clients +Collegato a,,Connected to +Collo di bottiglia,,Bottleneck +Condizione degli impianti,,Plant condition +Connetti a un server,,Connect to a server +Connetti e riprendi,,Connect and resume consumo,,use controlla la compagnia,,controls the company controllata da,,controlled by copertura,,coverage +Copertura degli ingressi,,Input coverage +Crea una linea verso questa industria,,Build a line to this industry +Creazione della nuova partita sul server…,,Creating the new game on the server… da,,from +dati compatibili,,compatible data degli utili come dividendo e non puoi chiedere prestiti.,,of profits as dividends and cannot take new loans. dei ricavi,,of revenue del capitale,,of the capital @@ -346,28 +366,44 @@ del capitale per ordine.,,of the capital per order. della cassa (il titolo sale); cavaliere bianco: un'alleata compra il flottante al prezzo dell'offerta più il,,of cash (the share price rises); white knight: an ally buys the free float at the bid price plus delle azioni entro il,,of the shares by di,,of +Disponibile al livello,,Available at level dividendo straordinario,,extra dividend +Dove gira il motore di gioco?,,Where does the game engine run? durata,,duration +e altre,,and e il,,and e personale sufficiente,,and enough staff +Fai un'offerta di acquisto,,Make a purchase offer fallita,,bankrupt "fallita, attivi all'asta",,"bankrupt, assets at auction" +Fattore di redditività,,Profitability factor ferma,,stopped ferma fino al,,stopped until fermo in linea,,stranded on the line fermo in salita,,stalled on grade +Forza lavoro,,Workforce g,,d +Giacimento residuo,,Remaining reserve +Gioca in locale,,Play locally giorni,,days giorni di fermo,,days of shutdown +giorni di produzione,,days of production giorni e liquida le minoranze al prezzo di mercato.,,days and buys out the minorities at market price. giorni e offre un premio tra il,,days and offers a premium between +giorni fa,,days ago giorno,,day gli impianti rendono pieno; sotto calano fino a,,plants run at full output; below they drop to guasto,,broken down guasto lieve,,minor failure hub mercato mondiale,,world market hub +i lavoratori,,workers il fondatore ha,,the founder holds +"Il mondo vive sempre in un server: sul tuo computer, avviato insieme al gioco, oppure in rete, dove la partita continua anche a gioco chiuso.",,"The world always lives in a server: on your computer, started together with the game, or on the network, where the game goes on even when the client is closed." +il personale qualificato,,skilled staff +Il server ha chiuso la connessione,,The server closed the connection +Il server non ha risposto,,The server did not respond impegnato,,committed +Impianti e crescita,,Plant and growth in arrivo,,arriving in attesa,,waiting in attesa di via libera,,waiting for clearance @@ -378,19 +414,33 @@ in officina,,in the workshop in scorta,,in stock in servizio,,in service in stazione,,at station +inattiva,,inactive incasso stimato,,estimated proceeds intervento prenotato,,intervention booked +L'industria è tua: gli utili entrano nel conto economico della compagnia.,,The industry is yours: its profits go into the company's income statement. la fusione è possibile dopo,,the merger is possible after la tua compagnia,,your company large,Grande,Large +Latenza,,Latency lavoratori,,workers lavori,,jobs le città raggiungibili non hanno lavoratori liberi,,reachable towns have no free workers +limitata da un evento,,limited by an event +limitata dagli impianti,,limited by the plant +limitata dai lavoratori,,limited by workers +limitata dal giacimento,,limited by the reserve +limitata dal personale,,limited by staff +limitata dalla redditività,,limited by profitability +limitata dalle materie prime,,limited by raw materials linea,,line livello,,level +Livello massimo raggiunto,,Maximum level reached +locale,,local macchinari,,machinery macchinari per il prossimo lavoro,,machinery for the next job macchinari per livello,,machinery per level +Mancano,,Missing +Mappa,,Map medium,Medio,Medium mesi,,months mila km,,thousand km @@ -498,22 +548,56 @@ in 30 giorni,,in 30 days lug,,Jul mag,,May mar,,Mar +Materie prime in ingresso,,Incoming raw materials mese,,month mesi e previsione a,,months and forecast for +minuti fa,,minutes ago +Moltiplicatore di resa,,Output multiplier "nei magazzini delle industrie e nelle stazioni, divise per la domanda mensile della mappa",,"in industry storage and at stations, divided by the map's monthly demand" +Nessun cliente nella regione,,No customer in the region +Nessun posto per i lavoratori,,No jobs for workers +Nessun posto per il personale,,No jobs for staff +Nessun vettore la serve: il livello resta fermo finché una linea non la collega.,,No carrier serves it: the level stays put until a line connects it. +Nessuna produzione,,No production +nessuna stazione la serve,,no station serves it nessuna tua stazione servita da una linea con treni ha questa destinazione nel bacino,,none of your stations served by a line with trains has this destination in its catchment +non collegata,,not connected non collegato,,not connected +Non collegato,,Not connected nov,,Nov +Nuova partita sul server,,New game on the server oggi,,today +ore fa,,hours ago ott,,Oct +Partita in corso,,Current game +perde un livello,,it loses a level +Personale qualificato,,Skilled staff +persone: portale in treno dalle città vicine.,,people: bring them by train from nearby towns. +presenti,,present prev.,,fcst. prezzo mondiale in calo,,world price falling prezzo mondiale in rialzo,,world price rising +Produzione,,Production +proprietari privati,,private owners +provenienze,,more origins +Punteggio di crescita,,Growth score quota mondiale dagli hub,,world share through the hubs +recupero,,recovery rispetto al ciclo per circa,,compared with the cycle for about +Scegli un'industria nell'elenco in alto.,,Choose an industry from the list above. +Scheda dell'industria,,Industry sheet +scorta,,stock serve,,needs +Server locale spento: scegli «Gioca in locale» per avviarlo,,Local server off: choose «Play locally» to start it +"Server su questo computer, avviato e chiuso con il gioco. Le partite restano qui.",,"Server on this computer, started and stopped with the game. Games stay here." +servita dalla stazione,,served by station servita dalla tua linea,,served by your line set,,Sep +Sistema,,System +sopra,,above +sotto,,below +spedito,,shipped +tick al secondo,,ticks per second unità/mese,,units/month è più alto del,,is higher by è più basso del,,is lower by @@ -561,6 +645,8 @@ Scalate ai concorrenti,,Takeovers of rivals Concessioni,,Concessions fondata nel,,founded in con,,with +magazzino,,storage +Partite salvate sul server,,Games saved on the server verso,,towards raggiunta nel,,reached in raggiunta,,reached @@ -576,14 +662,20 @@ Patrimonio netto di,,Net worth of città oltre,,towns over collegata su,,connected out of collegate su,,connected out of +merci su linea,,goods on a line +Prezzo medio realizzato,,Average realised price Rating creditizio,,Credit rating attuale,,current Binari e opere,,Track and structures Stazioni e depositi,,Stations and depots Materiale rotabile,,Rolling stock Industrie possedute,,Owned industries +magazzino pieno,,storage full Merce propria,,Own goods +Nessun fornitore nella regione,,No supplier in the region +"Non consuma materie prime: estrae, coltiva o raccoglie da sé.",,"It consumes no raw materials: it mines, farms or gathers on its own." Partecipazioni,,Shareholdings +"Server dedicato in rete, per esempio in Docker su un NAS. Più giocatori, partita sempre accesa.",,"Dedicated server on the network, for example in Docker on a NAS. Several players, the game is always on." Totale attivo,,Total assets Prestiti al,,Loans at Prestiti,,Loans @@ -611,6 +703,9 @@ Bancarotta dichiarata,,Bankruptcy declared La compagnia non ha riportato la cassa sopra zero entro il limite della difficoltà.,,The company did not bring its cash back above zero within the difficulty limit. in corso,,in progress finora,,so far +utile,,profit +Utile annuo stimato,,Estimated annual profit +Valore stimato,,Estimated value Voce,,Item Utile operativo,,Operating profit Flusso di cassa,,Cash flow @@ -633,6 +728,8 @@ Magazzini,,Storage Penali,,Penalties Costruzioni,,Construction Acquisto di treni,,Train purchases +ultimo trimestre,,last quarter +usura,,wear Vendita di treni,,Train sales Prestiti ricevuti,,Loans received Prestiti rimborsati,,Loans repaid @@ -660,6 +757,8 @@ Residuo,,Outstanding fisso,,fixed Rata mensile,,Monthly payment interessi,,interest +pieno tra,,full in +Ricorda questo server,,Remember this server scadenza,,maturity Estingui,,Pay off La cassa è tornata positiva,,Cash is back above zero @@ -670,6 +769,8 @@ Cassa negativa da {0}: bancarotta tra {1},,Cash negative for {0}: bankruptcy in neutro,,neutral "Il margine conta da quando ci sono almeno {0} mesi chiusi con ricavi (ora {1}): fino ad allora vale 0, così i primi incassi non fanno crollare il rating.",,"The margin counts once there are at least {0} closed months with revenue (now {1}): until then it is 0, so the first takings do not sink the rating." "Il punteggio {0} vale già {1}: il rating si aggiorna al prossimo calcolo mensile, a inizio mese.",,"The score {0} is already worth {1}: the rating is updated at the next monthly calculation, at the start of the month." +Simulazione,,Simulation +trimestri sale,,quarters it rises un margine di almeno {0},,a margin of at least {0} una leva non oltre {0},,leverage no higher than {0} una leva non oltre {0} (rimborsando {1}),,leverage no higher than {0} (by repaying {1}) @@ -677,3 +778,7 @@ una leva non oltre {0} (rimborsando {1}),,leverage no higher than {0} (by repayi Per il gradino {0} serve un punteggio di {1}: {2}.,,To reach {0} you need a score of {1}: {2}. In bancarotta non si possono chiedere prestiti,,Loans cannot be requested while bankrupt Fido disponibile {0} su {1}. Tasso di un nuovo prestito: {2} fisso (base {3} + rating {4} {5}) per {6} anni.,,Available credit {0} of {1}. Rate of a new loan: {2} fixed (base {3} + rating {4} {5}) for {6} years. +Verifica connessione,,Test connection +Versione,,Version +Versione del gioco,,Game version +viaggio medio,,average trip diff --git a/client/RailEnterprise.Client/scripts/App/AutoPilot.cs b/client/RailEnterprise.Client/scripts/App/AutoPilot.cs index 7394a92..412f6a6 100644 --- a/client/RailEnterprise.Client/scripts/App/AutoPilot.cs +++ b/client/RailEnterprise.Client/scripts/App/AutoPilot.cs @@ -254,5 +254,28 @@ public partial class AutoPilot : Node _game.OpenChronicle(); await Until(() => _game.ChronicleVisible, "cronaca", 30); await Shot("15_cronaca", 30); + _game.CloseChronicle(); + + // F6, scheda dell'industria (immagine 07): un'industria di trasformazione vicino alla linea, + // con catena produttiva, forza lavoro e crescita + var processing = World.Industries.Values + .Where(i => !i.Closed && i.Level > 0 && World.Data.Industries.FirstOrDefault(d => d.Id == i.Type)?.Recipe.Inputs.Count > 0) + .OrderBy(i => MapScale.V(i.Position).DistanceTo(anchor)).ThenBy(i => i.Id).FirstOrDefault() ?? industry; + _game.OpenIndustry(processing.Id); + await Until(() => World.IndustryCards.TryGetValue(processing.Id, out var c) && c.Sheet is not null, "scheda completa dell'industria", 30); + _game.ScrollPanel(0); + await Shot("19_scheda_industria", 40); + + // F6, schermata di connessione (immagine 09) sopra la partita: sessione di prova sul server + // locale con il suo stato e l'elenco dei salvataggi (uno appena fatto) + Session.Send(new Save { Name = "Collaudo" }); + var launcher = Session.LocalServer ?? throw new InvalidOperationException("collaudo senza server locale"); + var connect = new ConnectScreen(World.Data, remember: false); + _game.AddChild(connect); + await Frame(); + await connect.ProbeRemote(new Uri($"ws://127.0.0.1:{launcher.Port}/ws"), launcher.Token); + await Until(() => connect.Loaded, "stato del server e salvataggi", 30); + await Shot("20_connessione", 30); + connect.QueueFree(); } } diff --git a/client/RailEnterprise.Client/scripts/Main.cs b/client/RailEnterprise.Client/scripts/Main.cs index 2c2d1aa..5360af3 100644 --- a/client/RailEnterprise.Client/scripts/Main.cs +++ b/client/RailEnterprise.Client/scripts/Main.cs @@ -8,7 +8,7 @@ using static RailEnterprise.Client.App.Localization; namespace RailEnterprise.Client; /// -/// Nodo radice: tema e traduzioni, dati del gioco, passaggio tra menu, collegamento e partita; +/// 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. /// public partial class Main : Node @@ -56,12 +56,20 @@ public partial class Main : Node AddChild(screen); } + /// Schermata iniziale e di connessione (immagine 09): server locale o in rete, stato, salvataggi. private void ShowMenu(string status = "") { - var menu = new MenuScreen(); - menu.LocalGame += StartLocal; - menu.ConnectToServer += ShowConnect; - menu.LanguageChanged += code => + 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; + } + var screen = new ConnectScreen(_data); + screen.PlayRequested += ShowGame; + screen.LanguageChanged += code => { var cfg = new ConfigFile(); cfg.Load(SettingsPath); @@ -70,32 +78,11 @@ public partial class Main : Node TranslationServer.SetLocale(code); ShowMenu(); }; - Swap(menu); - if (status.Length > 0) menu.SetStatus(status); - } - - private void ShowConnect() - { - var screen = new ConnectScreen(); - screen.Back += () => ShowMenu(); - screen.ConnectRequested += async (uri, token, label) => - { - if (_data is null) return; - screen.SetStatus(T("Collegamento in corso…"), busy: true); - try - { - using var cts = new CancellationTokenSource(TimeSpan.FromSeconds(10)); - var session = await GameSession.ConnectAsync(_data, uri, token, label, cts.Token); - ShowGame(session); - } - catch (Exception e) - { - screen.SetStatus($"{T("Collegamento non riuscito")}: {e.Message}", busy: false); - } - }; Swap(screen); + if (status.Length > 0) screen.SetStatus(status, error: true); } + /// Collaudo: server locale da zero e subito in partita, senza la schermata di connessione. private async void StartLocal() { if (_data is null) return; @@ -105,13 +92,11 @@ public partial class Main : Node ShowMenu(T("Server locale non trovato: compila src/RailEnterprise.Server o imposta RE_SERVER_PATH.")); return; } - if (_screen is MenuScreen menu) menu.SetStatus(T("Avvio del server locale…")); var launcher = new LocalServerLauncher(); try { - string dataDir = ProjectSettings.GlobalizePath(_autopilot is null ? "user://server" : "user://autopilot-server"); - // il collaudo parte sempre da una partita nuova - if (_autopilot is not null && Directory.Exists(dataDir)) Directory.Delete(dataDir, true); + string dataDir = ProjectSettings.GlobalizePath("user://autopilot-server"); + 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; @@ -141,10 +126,10 @@ public partial class Main : Node public override void _Notification(int what) { - if (what == NotificationWMCloseRequest && _session is not null) - { - _session.DisposeAsync().AsTask().Wait(TimeSpan.FromSeconds(3)); - _session = null; - } + 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)); } } diff --git a/client/RailEnterprise.Client/scripts/Panels/IndustryPanel.cs b/client/RailEnterprise.Client/scripts/Panels/IndustryPanel.cs index e0b4914..1aa43b0 100644 --- a/client/RailEnterprise.Client/scripts/Panels/IndustryPanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/IndustryPanel.cs @@ -11,20 +11,35 @@ using static RailEnterprise.Client.App.Localization; namespace RailEnterprise.Client.Panels; /// -/// Industrie (sezione 11): elenco delle industrie della regione e pannello del proprietario -/// dell'industria scelta: condizione degli impianti con il moltiplicatore di efficienza, budget di -/// manutenzione, scorta di ricambi e macchinari, storico dei fermi, «Fermo programmato», -/// «Ammoderna», «Ordina ricambi»; per le industrie dei privati il prezzo chiesto e «Acquista». -/// La scheda del proprietario arriva su richiesta dal server (IndustryCard). +/// Scheda dell'industria a tutto schermo (immagine di riferimento 07, sezione 11): in alto nome, +/// livello, proprietà, stazione che la serve, valore stimato e l'anello dell'efficienza con il +/// fattore che la limita; sotto tre schede (materie prime in ingresso, forza lavoro, produzione), il +/// grafo della catena produttiva con fornitori, città dei pendolari e clienti, e la scheda «Impianti +/// e crescita» con condizione, punteggio trimestrale e soglie, comandi del proprietario e storico dei +/// fermi. Tutti i numeri arrivano dal server nella scheda (IndustryCard, blocco 1: ADR 0021); il +/// pannello li chiede una volta al secondo e li mostra com'è. /// public partial class IndustryPanel : VBoxContainer { private readonly GameSession _session; - private readonly ItemList _list = new() { CustomMinimumSize = new Vector2(0, 150) }; + private readonly OptionButton _chooser = new() { CustomMinimumSize = new Vector2(320, 44), FitToLongestItem = false }; private readonly List _ids = []; - private readonly VBoxContainer _header = PanelKit.Column(8); + private readonly Label _title = UiTheme.TitleLabel("", 44); + private readonly Label _subtitle = UiTheme.Text("", 15, Palette.TextSecondary); + private readonly Label _ownerLine = UiTheme.Text("", 14, Palette.TextSecondary); + private readonly Label _valuation = UiTheme.Text("", 26, Palette.AmberLight, bold: true); + private readonly EfficiencyRing _ring = new(); + private readonly Label _limit = UiTheme.Text("", 13, Palette.TextSecondary); + private readonly VBoxContainer _notices = PanelKit.Column(6); + private readonly ScrollContainer _scroll = new() { HorizontalScrollMode = ScrollContainer.ScrollMode.Disabled, SizeFlagsVertical = SizeFlags.ExpandFill }; + private readonly VBoxContainer _inputs = PanelKit.Column(8); + private readonly VBoxContainer _workforce = PanelKit.Column(8); + private readonly VBoxContainer _production = PanelKit.Column(8); + private readonly ChainGraph _graph = new(); + private readonly VBoxContainer _chainFooter = PanelKit.Column(8); + private readonly VBoxContainer _plants = PanelKit.Column(8); private readonly VBoxContainer _controls = PanelKit.Column(8); - private readonly VBoxContainer _details = PanelKit.Column(6); + private readonly VBoxContainer _history = PanelKit.Column(4); private readonly Label _status = UiTheme.Text("", 13, Palette.TextSecondary); private readonly List