diff --git a/client/RailEnterprise.Client/scripts/Hud/TopBar.cs b/client/RailEnterprise.Client/scripts/Hud/TopBar.cs index 9b7b2bd..62d915c 100644 --- a/client/RailEnterprise.Client/scripts/Hud/TopBar.cs +++ b/client/RailEnterprise.Client/scripts/Hud/TopBar.cs @@ -15,6 +15,7 @@ public partial class TopBar : PanelContainer private readonly PanelContainer _tier = UiTheme.Badge(""); private readonly Label _climb = UiTheme.Text("", 12, Palette.TextSecondary); private long _climbRequestedMonth = long.MinValue; + private double _sinceClimbRequest = double.MaxValue; /// Clic sul livello: apre «La tua scalata». public event Action? ClimbRequested; @@ -105,17 +106,20 @@ public partial class TopBar : PanelContainer _company.Text = me?.Name ?? w.Summary.CompanyName; int tier = Math.Clamp(me?.Tier ?? 1, 1, w.Data.Tiers.Tiers.Count); ((Label)_tier.GetChild(0)).Text = $"{tier} · {Fmt.Tier(w, tier)}"; - // il quadro della scalata si chiede una volta al mese di gioco (il pannello lo chiede ogni giorno) + // il quadro della scalata si chiede una volta al mese di gioco (il pannello lo chiede ogni giorno), e + // di nuovo dopo 5 s se manca: uno stato completo (ripresa della sessione, nuova partita) lo azzera + _sinceClimbRequest += delta; long month = w.Calendar is { } cal ? Fmt.Today(w) / cal.DaysPerMonth : 0; - if (month != _climbRequestedMonth && _session!.IsOpen) + if ((month != _climbRequestedMonth || (w.Climb is null && _sinceClimbRequest > 5)) && _session!.IsOpen) { _climbRequestedMonth = month; + _sinceClimbRequest = 0; _session.Send(new RequestDetail { Kind = DetailKind.Climb, Target = 0 }); } var climb = w.Climb; bool top = tier >= w.Data.Tiers.Tiers.Count; _climb.Text = top ? T("livello più alto") - : climb is not null && climb.Tier == tier ? $"{Fmt.Pct(climb.Progress, 0)} {T("verso")} {Fmt.Tier(w, tier + 1)}" + : climb is not null && climb.Tier == tier ? $"{Fmt.Progress(climb.Progress)} {T("verso")} {Fmt.Tier(w, tier + 1)}" : $"{T("prossimo")}: {Fmt.Tier(w, tier + 1)}"; if (_tierBox is not null) _tierBox.TooltipText = $"{T("Livello")} {tier} {T("di")} {w.Data.Tiers.Tiers.Count}. {T("Clic per aprire «La tua scalata»")}"; diff --git a/client/RailEnterprise.Client/scripts/Panels/ClimbPanel.cs b/client/RailEnterprise.Client/scripts/Panels/ClimbPanel.cs index 64baa61..37c49c8 100644 --- a/client/RailEnterprise.Client/scripts/Panels/ClimbPanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/ClimbPanel.cs @@ -195,7 +195,7 @@ public partial class ClimbPanel : VBoxContainer { var next = report.Tiers.FirstOrDefault(t => t.Level == report.NextTier); _track.Set(report.Tiers.Count, report.Tier, report.NextTier > 0 ? report.Progress : 1, - next is null ? "" : $"{Fmt.Pct(report.Progress, 0)} {T("verso")} {TierName(next)}"); + next is null ? "" : $"{Fmt.Progress(report.Progress)} {T("verso")} {TierName(next)}"); foreach (var c in _stations.GetChildren()) c.QueueFree(); foreach (var t in report.Tiers) { @@ -207,7 +207,7 @@ public partial class ClimbPanel : VBoxContainer col.AddChild(name); string status = t.Level == 1 ? $"{T("dal")} {YearOf(w, t.ReachedDay)}" : t.Reached ? (t.ReachedDay >= 0 ? $"{T("raggiunta nel")} {YearOf(w, t.ReachedDay)}" : T("raggiunta")) - : isNext ? $"{T("avanzamento")} {Fmt.Pct(report.Progress, 0)}" + : isNext ? $"{T("avanzamento")} {Fmt.Progress(report.Progress)}" : $"{T("patrimonio")} {Short(t.NetWorthRequired)}"; var statusLabel = UiTheme.Text(status, 14, current ? Palette.AmberLight : Palette.Text, bold: true); statusLabel.HorizontalAlignment = HorizontalAlignment.Center; @@ -229,11 +229,14 @@ public partial class ClimbPanel : VBoxContainer var values = report.History.Select(p => (double)p.Value.Cents).ToList(); var labels = report.History.Select(p => YearOf(w, p.Day).ToString()).ToList(); _chart.Show(values, labels, v => new Money((long)v).ToString("short"), SeriesChart.Style.Line, Palette.Amber, T("Lo storico cresce anno dopo anno")); - // i livelli raggiunti si segnano sul primo punto dal giorno della promozione + // i livelli raggiunti si segnano sul punto dell'anno della promozione (un punto per anno di + // calendario, l'ultimo è oggi); in mancanza sul primo punto dopo la promozione var markers = new List<(int Index, string Label)>(); foreach (var t in report.Tiers.Where(t => t.Level > 1 && t.Reached && t.ReachedDay >= 0)) { - int index = report.History.FindIndex(p => p.Day >= t.ReachedDay); + int year = YearOf(w, t.ReachedDay); + int index = report.History.FindIndex(p => YearOf(w, p.Day) == year); + if (index < 0) index = report.History.FindIndex(p => p.Day >= t.ReachedDay); if (index >= 0) markers.Add((index, TierName(t))); } _chart.SetMarkers(markers); @@ -258,7 +261,7 @@ public partial class ClimbPanel : VBoxContainer } _nextTitle.Text = $"{T("Per diventare")} {TierName(next)}"; _requirements.AddChild(Requirement($"{T("Patrimonio netto di")} {Short(report.NetWorthRequired)}", report.NetWorthFraction, report.NetWorthMet, - $"{Short(report.NetWorth)}, {Fmt.Pct(report.NetWorthFraction, 0)}")); + $"{Short(report.NetWorth)}, {Fmt.Progress(report.NetWorthFraction)}")); _requirements.AddChild(Requirement($"{report.TownsRequired} {T("città oltre")} {Fmt.Number(report.TownPopulation, 0)} {T("abitanti")}", report.TownsFraction, report.TownsMet, $"{report.Towns} {(report.Towns == 1 ? T("collegata su") : T("collegate su"))} {report.TownsRequired}")); _requirements.AddChild(Requirement($"{T("Rating creditizio")} {report.RatingRequired}", report.RatingFraction, report.RatingMet, diff --git a/client/RailEnterprise.Client/scripts/Panels/Fmt.cs b/client/RailEnterprise.Client/scripts/Panels/Fmt.cs index 86ec593..126d5d0 100644 --- a/client/RailEnterprise.Client/scripts/Panels/Fmt.cs +++ b/client/RailEnterprise.Client/scripts/Panels/Fmt.cs @@ -26,6 +26,12 @@ public static class Fmt /// Quota (0–1) in percentuale («12,4%»). public static string Pct(double fraction, int decimals = 1) => Number(fraction * 100, decimals) + "%"; + /// + /// Avanzamento (0–1) in percentuale intera per difetto («99%»): il 100 % compare solo quando la + /// frazione è piena, cioè con il requisito o il livello davvero raggiunto (ADR 0018). + /// + public static string Progress(double fraction) => Number(Math.Floor(Math.Clamp(fraction, 0, 1) * 100 + 1e-9), 0) + "%"; + /// Variazione con il segno («+1,2%», «−0,8%»). public static string Change(double fraction) => (fraction > 0 ? "+" : "") + Pct(fraction); diff --git a/client/RailEnterprise.Client/scripts/Panels/MarketPanel.cs b/client/RailEnterprise.Client/scripts/Panels/MarketPanel.cs index 1558e63..2c7fe34 100644 --- a/client/RailEnterprise.Client/scripts/Panels/MarketPanel.cs +++ b/client/RailEnterprise.Client/scripts/Panels/MarketPanel.cs @@ -523,7 +523,7 @@ public partial class MarketPanel : VBoxContainer } col.AddChild(Wrapped($"{T("Compra merci all'origine e rivendile dove il prezzo è più alto. Si sblocca al livello")} {tier}.", 13, Palette.Text)); col.AddChild(Bar(report.TradingProgress, Palette.Amber)); - col.AddChild(UiTheme.Text($"{T("Avanzamento verso")} {tier}: {Fmt.Pct(report.TradingProgress, 0)}", 12, Palette.TextSecondary)); + col.AddChild(UiTheme.Text($"{T("Avanzamento verso")} {tier}: {Fmt.Progress(report.TradingProgress)}", 12, Palette.TextSecondary)); // merce già in magazzino (per esempio ereditata da una fusione): si vende e si spedisce anche senza lo sblocco if (report.Warehouses.Any(h => h.Incoming > 0 || h.Goods.Any(g => g.Units > 0))) { diff --git a/client/RailEnterprise.Client/scripts/Panels/SeriesChart.cs b/client/RailEnterprise.Client/scripts/Panels/SeriesChart.cs index 133288d..60598eb 100644 --- a/client/RailEnterprise.Client/scripts/Panels/SeriesChart.cs +++ b/client/RailEnterprise.Client/scripts/Panels/SeriesChart.cs @@ -132,13 +132,15 @@ public partial class SeriesChart : Control if (f > 0) DrawForecast(area, points[^1], step, Y, font, fontSize); foreach (var (index, label) in _markers) { - if (index < 0 || index >= n - 1) continue; // l'ultimo punto ha già il suo valore + if (index < 0 || index >= n) continue; var p = points[index]; + bool atEnd = index == n - 1; DrawCircle(p, 5, Palette.AmberLight); DrawArc(p, 5, 0, MathF.Tau, 16, Palette.AppBackground, 1.5f, true); var dims = font.GetStringSize(label, HorizontalAlignment.Left, -1, 12); - float mx = Math.Clamp(p.X - dims.X / 2, area.Position.X, Size.X - dims.X - 4); - float my = p.Y - 12 < area.Position.Y + 10 ? p.Y + 20 : p.Y - 12; + // sull'ultimo punto (che ha sopra il suo valore) l'etichetta va a sinistra, alla sua altezza + float mx = atEnd ? Math.Max(area.Position.X, p.X - dims.X - 10) : Math.Clamp(p.X - dims.X / 2, area.Position.X, Size.X - dims.X - 4); + float my = atEnd ? p.Y + 16 : p.Y - 12 < area.Position.Y + 10 ? p.Y + 20 : p.Y - 12; DrawString(font, new Vector2(mx, my), label, HorizontalAlignment.Left, -1, 12, Palette.AmberLight); } DrawCircle(points[^1], 4, Palette.AmberLight); diff --git a/data/schema/tiers.schema.json b/data/schema/tiers.schema.json index 717abad..2d3a7f4 100644 --- a/data/schema/tiers.schema.json +++ b/data/schema/tiers.schema.json @@ -31,6 +31,10 @@ "maxItems": 10, "uniqueItems": true }, + "ratingProgressSteps": { + "type": "number", + "exclusiveMinimum": 0 + }, "tiers": { "type": "array", "items": { @@ -152,6 +156,7 @@ "required": [ "version", "ratingScale", + "ratingProgressSteps", "tiers" ], "additionalProperties": false diff --git a/data/tiers.json b/data/tiers.json index ed05b56..b304678 100644 --- a/data/tiers.json +++ b/data/tiers.json @@ -2,6 +2,7 @@ "$schema": "schema/tiers.schema.json", "version": 1, "ratingScale": [ "AAA", "AA", "A", "BBB", "BB", "B", "CCC", "CC", "C", "D" ], + "ratingProgressSteps": 2.5, "tiers": [ { "level": 1, "name_it": "Compagnia locale", "name_en": "Local company", "requirements": { "netWorth": 0, "connectedTownsOver": { "count": 0, "population": 0 }, "creditRating": "D" }, diff --git a/docs/adr/0015-mercato-globale.md b/docs/adr/0015-mercato-globale.md index 4fe2814..d5bf368 100644 --- a/docs/adr/0015-mercato-globale.md +++ b/docs/adr/0015-mercato-globale.md @@ -69,7 +69,8 @@ né come migrare i salvataggi con lo storico di un anno. (oggi il 2, «Compagnia regionale»). Se la compagnia ce l'ha è «sbloccata»; altrimenti l'avanzamento è il minimo tra le frazioni dei requisiti numerici (patrimonio netto / richiesto, città collegate / richieste, entrambe limitate a 1); il rating è soddisfatto o no e si mostra a parte, perché non ha - una frazione sensata. + una frazione sensata. *Sostituito dall'ADR 0018 §2: l'avanzamento è la media delle tre frazioni + (patrimonio, città, rating), la stessa del pannello «La tua scalata».* ## Conseguenze diff --git a/docs/adr/0018-scalata-e-livelli.md b/docs/adr/0018-scalata-e-livelli.md index 3ecc4dc..95c600a 100644 --- a/docs/adr/0018-scalata-e-livelli.md +++ b/docs/adr/0018-scalata-e-livelli.md @@ -22,15 +22,23 @@ né come valutare le industrie possedute, che finora non entravano nel patrimoni 2. **Requisiti e avanzamento.** Per il prossimo livello: patrimonio netto, città collegate sopra la popolazione (lo stesso `Tiers.ConnectedTowns`) e rating, con valore attuale, soglia, soddisfatto o no (gli stessi confronti di `Tiers.Meets`) e frazione: patrimonio/soglia e città/città richieste limitate - a 1; per il rating i gradini risaliti dalla D rispetto a quelli richiesti - ((D − attuale)/(D − richiesto), 1 se soddisfatto). **L'avanzamento complessivo è la media delle tre - frazioni** (l'immagine 08: 65 % di patrimonio e 1 città su 2 danno circa il 58 %); vale 1 solo con - tutti e tre i requisiti soddisfatti. Il quadro del Mercato globale usa la stessa funzione: l'ADR 0015 - §12 (minimo dei requisiti numerici) è sostituito, così i due pannelli mostrano lo stesso numero. + a 1; per il rating 1 − gradini mancanti / `ratingProgressSteps` di `tiers.json` (2,5), limitata tra 0 + e 1 (1 se soddisfatto: un gradino sotto vale il 60 %, tre o più lo 0 %). **L'avanzamento complessivo è + la media delle tre frazioni**: con lo stato dell'immagine 08 (65 % di patrimonio, 1 città su 2, BBB + verso A) le frazioni sono 0,65, 0,5 e 0,6 e l'avanzamento il 58 %, come nell'immagine. Misurare il + rating dalla D (prima scelta) dava l'86 % per un solo gradino mancante e il 67 % complessivo, e gonfiava + l'avanzamento fin dall'inizio. L'avanzamento vale 1 solo con tutti e tre i requisiti soddisfatti + (altrimenti al massimo 0,999), e il client mostra queste percentuali per difetto, quindi il 100 % + compare solo a requisito o livello raggiunto. Il quadro del Mercato globale usa la stessa funzione: + l'ADR 0015 §12 (minimo dei requisiti numerici) è sostituito, così i due pannelli mostrano lo stesso numero. 3. **Sblocchi dai dati.** `Tiers.NewUnlocks` elenca ciò che un livello aggiunge al precedente, nell'ordine di `UnlockKind`: fido massimo (fido iniziale × `maxLoanFactor`, se cresce), squadre di cantiere (se crescono), compravendita in proprio, acquisto di industrie, quotazione, scalate ostili, concessioni (le funzioni che passano da `false` a `true`); il livello 1 elenca la dotazione di partenza (fido e squadre). + Le concessioni non si annunciano finché il comando non esiste (F7, `Tiers.ConcessionsAvailable`): il + gioco non promette uno sblocco che non funziona. Il validatore pretende che gli sblocchi non diminuiscano + salendo di livello (`maxLoanFactor` non decrescente, le funzioni non tornano `false`), come presumono + notizie, rifiuti e pannello (ADR 0011: gli sblocchi restano acquisiti). Le squadre per livello stanno in due file (`construction.json`, usato dal cantiere, e `tiers.json`): il validatore ora pretende che coincidano. Nessun testo di regola è scritto a mano: il Core ha solo le etichette italiane degli sblocchi, il client le sue chiavi di traduzione. @@ -39,8 +47,8 @@ né come valutare le industrie possedute, che finora non entravano nel patrimoni cantiere, compravendita in proprio» (il fido è quello della compagnia). Il livello non scende (ADR 0011): nessuna notizia di retrocessione. 5. **Rifiuti con il livello.** I comandi bloccati dal livello dicono quale livello serve e come si chiama, dai dati (`Tiers.LockedText`): compravendita in proprio, acquisto di industrie, quotazione, scalate - ostili e concessioni (che prima del livello si rifiutano per il livello e dopo restano «non ancora - disponibili» fino alla F7). Il fido insufficiente dice quanto resta su quanto e quale livello alza il + ostili e concessioni (che fino alla F7 sono «non ancora disponibili»: prima del livello il rifiuto è per + il livello e dice che si sbloccheranno lì, dopo resta «non ancora disponibili»). Il fido insufficiente dice quanto resta su quanto e quale livello alza il fido e a quanto. 6. **Stato patrimoniale per voce, una sola fonte.** `FinanceSystem.BookValues` calcola il valore contabile per compagnia e per voce (`AssetCategory`: binari e opere, stazioni e depositi, veicoli, industrie @@ -52,7 +60,9 @@ né come valutare le industrie possedute, che finora non entravano nel patrimoni 7. **Industrie possedute nel patrimonio.** Finora comprare un'industria toglieva il prezzo dalla cassa senza aggiungere nulla agli attivi. Ora entrano al valore contabile `IndustryMath.BookValue`: la parte del prezzo d'acquisto (ADR 0011 §5) senza l'avviamento, cioè impianti (`PlantValue`: costo - d'ammodernamento × livello × quota, secondo le condizioni) più la cassa dell'impresa. Comprare costa + d'ammodernamento × livello × quota, secondo le condizioni) più la cassa dell'impresa. Gli impianti + contano al livello attuale: un'industria inattiva (livello 0), che non si può vendere, vale solo la sua + cassa (il prezzo d'acquisto conta invece almeno un livello, come prima). Comprare costa quindi al patrimonio solo l'avviamento (il multiplo degli utili), e il rating e il prezzo dell'azione vedono gli impianti. Il prezzo di vendita (`Valuation`) non cambia. 8. **Salvataggio versione 6.** Le voci non si possono ricostruire al caricamento (dipendono dal giorno del @@ -63,11 +73,14 @@ né come valutare le industrie possedute, che finora non entravano nel patrimoni in proporzione alle voci calcolate al giorno del caricamento (resto dell'arrotondamento sulla voce più grande, tutto sui binari se non c'è nulla da ripartire), quindi il patrimonio netto non cambia fino al ricalcolo del mese; i giorni dei livelli si ricostruiscono dai fatti salienti («diventa «nome»») o, in - mancanza, dal primo anno dello storico con quel livello. + mancanza, dalla prima fotografia dello storico con quel livello: quella dell'anno Y si scatta il primo + giorno di Y+1, dopo la chiusura del mese che può aver promosso la compagnia, quindi si usa quel giorno + (tra la fondazione e oggi). 9. **Storico del patrimonio.** Nessuno stato nuovo: si riusa lo storico annuale della Cronaca (`Company.History`, fotografia di fine anno al primo giorno dell'anno dopo), preceduto dal capitale - iniziale della difficoltà alla fondazione e seguito dal valore di oggi. I livelli raggiunti si segnano - sul primo punto dal giorno della promozione. + iniziale della difficoltà alla fondazione e seguito dal valore di oggi, che prende il posto della + fotografia del primo giorno dell'anno in corso: un punto per anno di calendario, etichettato con il suo + anno. I livelli raggiunti si segnano sul punto dell'anno della promozione, anche sull'ultimo (oggi). 10. **Conto economico.** L'ultimo anno chiuso (o l'anno in corso fino a oggi, per una compagnia fondata quest'anno), con le voci del registro raggruppate in tariffe e noli, altri ricavi (commercio, contratti, industrie, controllate), costi operativi (esercizio, salari, penali), manutenzione (binari e flotta) e diff --git a/src/RailEnterprise.Core/Data/DataValidator.cs b/src/RailEnterprise.Core/Data/DataValidator.cs index 2a7418a..ed9c6a9 100644 --- a/src/RailEnterprise.Core/Data/DataValidator.cs +++ b/src/RailEnterprise.Core/Data/DataValidator.cs @@ -136,6 +136,22 @@ public static class DataValidator if (!levels.SequenceEqual(Enumerable.Range(1, levels.Count))) Err("tiers.json", "i livelli devono essere 1, 2, 3, 4, 5 in ordine"); Increasing("tiers.json", "requirements.netWorth", d.Tiers.Tiers.Select(t => (double)t.Requirements.NetWorth), errors, strictFromSecond: true); if (!d.Tiers.RatingScale.SequenceEqual(Enum.GetValues())) Err("tiers.json", "ratingScale deve elencare i rating da AAA a D"); + if (!(d.Tiers.RatingProgressSteps > 0)) Err("tiers.json", "ratingProgressSteps deve essere positivo"); + // gli sblocchi restano acquisiti salendo (ADR 0011): notizie, rifiuti e pannello lo presumono (ADR 0018) + var unlocks = d.Tiers.Tiers.Select(t => t.Unlocks).ToList(); + for (int i = 1; i < unlocks.Count; i++) + { + var (prev, cur) = (unlocks[i - 1], unlocks[i]); + if (cur.MaxLoanFactor < prev.MaxLoanFactor) Err("tiers.json", $"unlocks.maxLoanFactor non può scendere dal livello {i} al livello {i + 1}"); + foreach (var (name, had, has) in new[] + { + ("trading", prev.Trading, cur.Trading), ("buyIndustry", prev.BuyIndustry, cur.BuyIndustry), ("ipo", prev.Ipo, cur.Ipo), + ("hostileTakeover", prev.HostileTakeover, cur.HostileTakeover), ("concessions", prev.Concessions, cur.Concessions), + }) + { + if (had && !has) Err("tiers.json", $"unlocks.{name} non può tornare falso dal livello {i} al livello {i + 1}"); + } + } // --- difficoltà Unique("difficulty.json", d.Difficulty.Presets.Select(p => p.Id), errors); diff --git a/src/RailEnterprise.Core/Data/TiersDefs.cs b/src/RailEnterprise.Core/Data/TiersDefs.cs index a8f9ab9..4c49091 100644 --- a/src/RailEnterprise.Core/Data/TiersDefs.cs +++ b/src/RailEnterprise.Core/Data/TiersDefs.cs @@ -8,6 +8,11 @@ public sealed class TiersFile [JsonPropertyName("$schema")] public string? Schema { get; init; } public required int Version { get; init; } public required List RatingScale { get; init; } + /// + /// Gradini di rating sotto quello richiesto a cui l'avanzamento del requisito vale zero (ADR 0018): + /// la frazione è 1 − gradini mancanti / questo valore, limitata tra 0 e 1. + /// + public required double RatingProgressSteps { get; init; } public required List Tiers { get; init; } } diff --git a/src/RailEnterprise.Core/Economy/ClimbOutlook.cs b/src/RailEnterprise.Core/Economy/ClimbOutlook.cs index 11cb10e..daad38d 100644 --- a/src/RailEnterprise.Core/Economy/ClimbOutlook.cs +++ b/src/RailEnterprise.Core/Economy/ClimbOutlook.cs @@ -173,7 +173,8 @@ public static class ClimbOutlook /// /// Requisiti di un livello per la compagnia, con gli stessi confronti di . /// Frazioni: patrimonio / soglia e città / città richieste (limitate a 1; 1 se la soglia è zero); per il - /// rating i gradini risaliti dalla D rispetto a quelli richiesti. L'avanzamento è la loro media. + /// rating 1 − gradini mancanti / (limitata tra 0 e 1). + /// L'avanzamento è la loro media, sotto 1 finché un requisito manca (). /// public static RequirementProgress Requirements(World w, Company c, TierDef tier) { @@ -181,13 +182,10 @@ public static class ClimbOutlook int towns = Simulation.Systems.Tiers.ConnectedTowns(w, c.Id, req.ConnectedTownsOver.Population); double worth = req.NetWorth <= 0 ? 1 : DMath.Clamp((double)c.NetWorth.Cents / req.NetWorth, 0, 1); double townsFraction = req.ConnectedTownsOver.Count <= 0 ? 1 : DMath.Clamp((double)towns / req.ConnectedTownsOver.Count, 0, 1); - int worst = w.Data.Tiers.RatingScale.Count - 1; - int steps = worst - (int)req.CreditRating; - double rating = c.Rating <= req.CreditRating || steps <= 0 ? 1 : DMath.Clamp((double)(worst - (int)c.Rating) / steps, 0, 1); + double rating = RatingFraction(w, c.Rating, req.CreditRating); bool worthMet = c.NetWorth.Cents >= req.NetWorth, townsMet = towns >= req.ConnectedTownsOver.Count, ratingMet = c.Rating <= req.CreditRating; - // una frazione arrotondata a 1 non basta: l'avanzamento è 1 solo con tutti i requisiti soddisfatti double progress = (worth + townsFraction + rating) / 3; - if (!(worthMet && townsMet && ratingMet)) progress = Math.Min(progress, 0.999); + if (!(worthMet && townsMet && ratingMet)) progress = Math.Min(progress, ProgressCap); return new RequirementProgress { Level = tier.Level, @@ -199,6 +197,25 @@ public static class ClimbOutlook }; } + /// + /// Tetto dell'avanzamento finché un requisito manca: una frazione arrotondata a 1 non basta, il pieno + /// arriva solo con tutti i requisiti soddisfatti. Non è un parametro di gioco (non cambia la promozione, + /// che segue ): il client mostra le percentuali per difetto, + /// quindi sotto il tetto legge al massimo «99%». + /// + public const double ProgressCap = 0.999; + + /// + /// Frazione del requisito di rating: 1 se soddisfatto, altrimenti 1 − gradini mancanti / + /// ratingProgressSteps di tiers.json, limitata tra 0 e 1 (immagine 08: un gradino sotto vale il 60 %). + /// + public static double RatingFraction(World w, CreditRating current, CreditRating required) + { + if (current <= required) return 1; + int missing = (int)current - (int)required; + return DMath.Clamp(1 - missing / w.Data.Tiers.RatingProgressSteps, 0, 1); + } + /// Stato patrimoniale dalle voci del motore: somma esattamente al patrimonio netto. public static BalanceSheet Balance(Company c) { @@ -257,16 +274,18 @@ public static class ClimbOutlook /// /// Patrimonio netto nel tempo: il capitale iniziale alla fondazione, la fotografia di fine anno - /// dello storico (al primo giorno dell'anno dopo) e il valore di oggi. + /// dello storico (al primo giorno dell'anno dopo) e il valore di oggi. La fotografia del primo giorno + /// dell'anno in corso lascia il posto a oggi: un punto per anno di calendario, come l'immagine 08. /// public static List History(World w, Company c) { var points = new List { new(c.FoundedDay, new Money(w.Difficulty.InitialCapital)) }; long today = w.Clock.Day; + long yearStart = (long)(w.Clock.Year - w.Calendar.StartYear) * w.Calendar.DaysPerYear; foreach (var y in c.History) { long day = (long)(y.Year + 1 - w.Calendar.StartYear) * w.Calendar.DaysPerYear; - if (day <= points[^1].Day || day >= today) continue; + if (day <= points[^1].Day || day >= yearStart) continue; points.Add(new NetWorthPoint(day, new Money(y.NetWorthCents))); } if (today > points[^1].Day) points.Add(new NetWorthPoint(today, c.NetWorth)); diff --git a/src/RailEnterprise.Core/Persistence/BalanceSheetSerializer.cs b/src/RailEnterprise.Core/Persistence/BalanceSheetSerializer.cs index f3671cf..2231914 100644 --- a/src/RailEnterprise.Core/Persistence/BalanceSheetSerializer.cs +++ b/src/RailEnterprise.Core/Persistence/BalanceSheetSerializer.cs @@ -38,7 +38,7 @@ public static class BalanceSheetSerializer /// proporzione alla scomposizione calcolata al giorno del caricamento, con il resto dell'arrotondamento /// sulla voce più grande; il totale, e quindi il patrimonio netto, non cambia fino al ricalcolo del /// mese. I giorni dei livelli si ricostruiscono dai fatti salienti («diventa «nome»») e, in mancanza, - /// dallo storico annuale (primo giorno dell'anno in cui il livello compare). + /// dallo storico annuale (giorno della prima fotografia con il livello, tra fondazione e oggi). /// public static void Migrate(World w) { @@ -80,8 +80,11 @@ public static class BalanceSheetSerializer long day = c.Milestones.FirstOrDefault(m => m.Text == text, new CompanyMilestone(-1, "")).Day; if (day < 0) { + // la fotografia dell'anno Y si scatta il primo giorno di Y+1, dopo la chiusura del mese che + // può aver promosso la compagnia: il livello è certo solo da quel giorno (come ClimbOutlook.History) int year = c.History.FirstOrDefault(y => y.Tier >= level, new CompanyYear(int.MinValue, 0, 0, 0, 0, 0, 0, 0, 0)).Year; - if (year != int.MinValue) day = Math.Max(0, (long)(year - w.Calendar.StartYear) * w.Calendar.DaysPerYear); + if (year != int.MinValue) + day = Math.Clamp((long)(year + 1 - w.Calendar.StartYear) * w.Calendar.DaysPerYear, Math.Max(0, c.FoundedDay), Math.Max(c.FoundedDay, w.Clock.Day)); } c.TierReachedDay[level - 1] = day; } diff --git a/src/RailEnterprise.Core/Simulation/CommandProcessor.cs b/src/RailEnterprise.Core/Simulation/CommandProcessor.cs index b0fd806..3506188 100644 --- a/src/RailEnterprise.Core/Simulation/CommandProcessor.cs +++ b/src/RailEnterprise.Core/Simulation/CommandProcessor.cs @@ -62,9 +62,14 @@ public static class CommandProcessor BuyGoodsCommand c => TradingCommandHandlers.Buy(w, company, c, Reply), SellGoodsCommand c => TradingCommandHandlers.Sell(w, company, c, Reply), ShipGoodsCommand c => TradingCommandHandlers.Ship(w, company, c, ctx, Reply), - // le concessioni (F7) si rifiutano prima per il livello, poi perché non ancora disponibili + // le concessioni (F7) si rifiutano prima per il livello, poi perché non ancora disponibili; il testo + // non promette che il livello basti BuyConcessionCommand when !Tiers.Unlocks(w, company).Concessions => - Result(CommandError.TierLocked, Tiers.LockedText(w, "Le concessioni", u => u.Concessions, plural: true)), + Result(CommandError.TierLocked, Tiers.ConcessionsAvailable + ? Tiers.LockedText(w, "Le concessioni", u => u.Concessions, plural: true) + : Tiers.ConcessionsUnavailableText(w)), + BuyConcessionCommand when !Tiers.ConcessionsAvailable => + Result(CommandError.NotImplemented, "Le concessioni non sono ancora disponibili"), _ => Result(CommandError.NotImplemented, $"Comando {command.Type} non ancora disponibile"), }; } diff --git a/src/RailEnterprise.Core/Simulation/Systems/IndustryMath.cs b/src/RailEnterprise.Core/Simulation/Systems/IndustryMath.cs index 5f12d85..8859d23 100644 --- a/src/RailEnterprise.Core/Simulation/Systems/IndustryMath.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/IndustryMath.cs @@ -93,20 +93,21 @@ public static class IndustryMath { var p = w.Data.Balance.IndustryMaintenance.Purchase; double earnings = Math.Max(0, AnnualProfit(w, ind)) * p.EarningsMultiple; - return Common.Money.FromCentsRounded(PlantValue(w, ind) + earnings + Math.Max(0, ind.Cash.Cents)); + return Common.Money.FromCentsRounded(PlantValue(w, ind, Math.Max(1, ind.Level)) + earnings + Math.Max(0, ind.Cash.Cents)); } - /// Valore degli impianti nel prezzo d'acquisto: costo d'ammodernamento × livello × quota, secondo le condizioni. - public static double PlantValue(World w, Industry ind) + /// Valore degli impianti: costo d'ammodernamento × livello × quota, secondo le condizioni. + public static double PlantValue(World w, Industry ind, int level) { var p = w.Data.Balance.IndustryMaintenance.Purchase; - return ind.Def.UpgradeCost * Math.Max(1, ind.Level) * p.AssetShare * (1 - p.ConditionWeight + p.ConditionWeight * ind.Condition / 100); + return ind.Def.UpgradeCost * level * p.AssetShare * (1 - p.ConditionWeight + p.ConditionWeight * ind.Condition / 100); } /// /// Valore contabile di un'industria per il proprietario (ADR 0018): il prezzo d'acquisto senza - /// l'avviamento (multiplo degli utili), cioè impianti più cassa dell'impresa. + /// l'avviamento (multiplo degli utili), cioè impianti più cassa dell'impresa. Gli impianti contano + /// al livello attuale: un'industria inattiva (livello 0), che non si può vendere, vale solo la sua cassa. /// public static Common.Money BookValue(World w, Industry ind) => - Common.Money.FromCentsRounded(PlantValue(w, ind) + Math.Max(0, ind.Cash.Cents)); + Common.Money.FromCentsRounded(PlantValue(w, ind, ind.Level) + Math.Max(0, ind.Cash.Cents)); } diff --git a/src/RailEnterprise.Core/Simulation/Systems/Tiers.cs b/src/RailEnterprise.Core/Simulation/Systems/Tiers.cs index 3f943c5..919ff40 100644 --- a/src/RailEnterprise.Core/Simulation/Systems/Tiers.cs +++ b/src/RailEnterprise.Core/Simulation/Systems/Tiers.cs @@ -79,10 +79,28 @@ public static class Tiers if (u.BuyIndustry && p?.BuyIndustry != true) list.Add(new TierUnlock(UnlockKind.BuyIndustry, 0)); if (u.Ipo && p?.Ipo != true) list.Add(new TierUnlock(UnlockKind.Ipo, 0)); if (u.HostileTakeover && p?.HostileTakeover != true) list.Add(new TierUnlock(UnlockKind.HostileTakeover, 0)); - if (u.Concessions && p?.Concessions != true) list.Add(new TierUnlock(UnlockKind.Concessions, 0)); + // le concessioni non si annunciano finché il comando non esiste (F7): il livello le sblocca, ma non funzionerebbero + if (ConcessionsAvailable && u.Concessions && p?.Concessions != true) list.Add(new TierUnlock(UnlockKind.Concessions, 0)); return list; } + /// + /// Vero quando le concessioni (BuyConcession) saranno implementate: fino alla F7 il comando risponde + /// «non ancora disponibili», quindi non compaiono tra gli sblocchi né nelle notizie. + /// + public static bool ConcessionsAvailable => false; + + /// + /// Rifiuto delle concessioni finché non sono implementate: prima del livello che le sblocca + /// (TierLocked) dice anche quale livello servirà. + /// + public static string ConcessionsUnavailableText(World w) + { + const string text = "Le concessioni non sono ancora disponibili"; + var tier = FirstUnlocking(w, u => u.Concessions); + return tier is null ? text : $"{text}: si sbloccheranno al livello {tier.Level}, «{tier.NameIt}»"; + } + /// Fido massimo della compagnia a un livello: fido iniziale × fattore del livello. public static Money LoanLimit(Company c, TierDef def) => c.BaseCredit * def.Unlocks.MaxLoanFactor; diff --git a/tests/RailEnterprise.Tests/Data/DataTests.cs b/tests/RailEnterprise.Tests/Data/DataTests.cs index f10b527..56ffdf1 100644 --- a/tests/RailEnterprise.Tests/Data/DataTests.cs +++ b/tests/RailEnterprise.Tests/Data/DataTests.cs @@ -130,6 +130,20 @@ public static class DataTests Assert.True(errors.Any(e => e.Contains("failure.*Share", StringComparison.Ordinal))); } + [Test(Description = "Gli sblocchi non diminuiscono salendo di livello: fido e funzioni restano acquisiti (ADR 0011, 0018)")] + public static void SemanticRejectsShrinkingUnlocks() + { + var errors = LoadErrors(files => + { + var root = JsonNode.Parse(files["tiers.json"])!; + root["tiers"]![4]!["unlocks"]!["ipo"] = false; + root["tiers"]![2]!["unlocks"]!["maxLoanFactor"] = 1.0; + files["tiers.json"] = root.ToJsonString(); + }); + Assert.True(errors.Any(e => e.Contains("unlocks.ipo", StringComparison.Ordinal)), string.Join("; ", errors)); + Assert.True(errors.Any(e => e.Contains("unlocks.maxLoanFactor", StringComparison.Ordinal)), string.Join("; ", errors)); + } + private static IReadOnlyList LoadErrors(Action> mutate) { var files = MemoryDataSource.Snapshot(TestData.Source); diff --git a/tests/RailEnterprise.Tests/Economy/ClimbTests.cs b/tests/RailEnterprise.Tests/Economy/ClimbTests.cs index 2e1f4fc..dd43778 100644 --- a/tests/RailEnterprise.Tests/Economy/ClimbTests.cs +++ b/tests/RailEnterprise.Tests/Economy/ClimbTests.cs @@ -73,7 +73,8 @@ public static class ClimbTests Assert.Equal(Tiers.Meets(w, c, tier.Requirements), req.AllMet, $"livello {tier.Level}"); Assert.Equal(Tiers.ConnectedTowns(w, c.Id, tier.Requirements.ConnectedTownsOver.Population), req.Towns); Assert.Equal(c.NetWorth, req.NetWorth); - Assert.Approx((req.NetWorthFraction + req.TownsFraction + req.RatingFraction) / 3, req.Progress, 1e-12); + double average = (req.NetWorthFraction + req.TownsFraction + req.RatingFraction) / 3; + Assert.Approx(req.AllMet ? average : Math.Min(average, ClimbOutlook.ProgressCap), req.Progress, 1e-12); Assert.InRange(req.Progress, 0, 1); Assert.Equal(req.AllMet, req.Progress >= 1, "avanzamento pieno solo con tutti i requisiti"); double worth = tier.Requirements.NetWorth <= 0 ? 1 : Math.Clamp((double)c.NetWorth.Cents / tier.Requirements.NetWorth, 0, 1); @@ -83,11 +84,14 @@ public static class ClimbTests Assert.Equal(tiers[c.Tier].Level, next.Level); Assert.True(report.Tiers.Skip(c.Tier).All(t => t.ReachedDay == -1), "livelli non raggiunti senza giorno"); - // rating: gradini risaliti dalla D rispetto a quelli richiesti + // rating: 1 − gradini mancanti / ratingProgressSteps (2,5 nei dati) var bbb = tiers.First(t => t.Requirements.CreditRating == CreditRating.BBB); var saved = c.Rating; - c.Rating = CreditRating.B; // indice 5, D = 9, BBB = 3: (9 − 5) / (9 − 3) - Assert.Approx(4.0 / 6, ClimbOutlook.Requirements(w, c, bbb).RatingFraction, 1e-12); + double steps = w.Data.Tiers.RatingProgressSteps; + c.Rating = CreditRating.BB; // un gradino sotto BBB + Assert.Approx(1 - 1 / steps, ClimbOutlook.Requirements(w, c, bbb).RatingFraction, 1e-12); + c.Rating = CreditRating.D; // troppo lontano: zero + Assert.Equal(0.0, ClimbOutlook.Requirements(w, c, bbb).RatingFraction); c.Rating = CreditRating.AA; Assert.Equal(1.0, ClimbOutlook.Requirements(w, c, bbb).RatingFraction); Assert.True(ClimbOutlook.Requirements(w, c, bbb).RatingMet); @@ -123,7 +127,9 @@ public static class ClimbTests var prev = level > 1 ? tiers[level - 2].Unlocks : null; foreach (var (kind, has) in features) { - bool expected = has(u) && (prev is null || !has(prev)); + // le concessioni non si annunciano finché il comando non esiste (F7) + bool available = kind != UnlockKind.Concessions || Tiers.ConcessionsAvailable; + bool expected = available && has(u) && (prev is null || !has(prev)); Assert.Equal(expected, unlocks.Any(x => x.Kind == kind), $"livello {level}, {kind}"); } bool loanUp = prev is null || u.MaxLoanFactor > prev.MaxLoanFactor; @@ -134,7 +140,7 @@ public static class ClimbTests // le funzioni dell'ultimo livello compaiono ciascuna una volta sola var all = Enumerable.Range(1, tiers.Count).SelectMany(l => Tiers.NewUnlocks(w, c, l)).Where(x => x.Kind >= UnlockKind.Trading).ToList(); Assert.Equal(all.Count, all.Select(x => x.Kind).Distinct().Count()); - Assert.Equal(features.Count(x => x.Has(tiers[^1].Unlocks)), all.Count); + Assert.Equal(features.Count(x => x.Has(tiers[^1].Unlocks) && (x.Kind != UnlockKind.Concessions || Tiers.ConcessionsAvailable)), all.Count); Assert.Equal("compravendita in proprio", Tiers.UnlockLabel(new TierUnlock(UnlockKind.Trading, 0))); } @@ -192,6 +198,13 @@ public static class ClimbTests Assert.Equal(w.Clock.Year, income.Year); Assert.True(income.Partial, "primo anno: anno in corso"); Assert.Equal(Company.OperatingProfit(c.YearEntries), income.Profit.Cents); + + // un'industria posseduta inattiva (livello 0) non si vende: a libro vale solo la sua cassa + int level = mine.Level; + mine.Level = 0; + Assert.Equal(Money.Max(Money.Zero, mine.Cash), IndustryMath.BookValue(w, mine), "impianti a livello 0"); + mine.Level = level; + Assert.True(IndustryMath.BookValue(w, mine) > Money.Max(Money.Zero, mine.Cash), "impianti al livello attuale"); } [Test(Description = "Al passaggio di livello la notizia elenca gli sblocchi ottenuti; il giorno resta annotato")] @@ -251,6 +264,19 @@ public static class ClimbTests Assert.Equal(CommandError.TierLocked, goods.Error); Assert.True(goods.Message.Contains(Named(u => u.Trading)), goods.Message); + // concessioni (F7): prima del livello il rifiuto dice che non ci sono ancora e dove si sbloccheranno, + // dopo restano «non ancora disponibili»; nessuna notizia o pannello le annuncia + var concession = Do(w, new BuyConcessionCommand(new RegionId(0))); + Assert.Equal(CommandError.TierLocked, concession.Error); + Assert.True(concession.Message.Contains("non sono ancora disponibili") && concession.Message.Contains(Named(u => u.Concessions)), concession.Message); + int saved = w.Player.Tier; + w.Player.Tier = tiers.First(t => t.Unlocks.Concessions).Level; + var later = Do(w, new BuyConcessionCommand(new RegionId(0))); + Assert.Equal(CommandError.NotImplemented, later.Error); + Assert.True(later.Message.Contains("non sono ancora disponibili"), later.Message); + Assert.False(Tiers.PromotionText(w, w.Player, w.Player.Tier).Contains("concessioni"), "la notizia non promette le concessioni"); + w.Player.Tier = saved; + // fido: quanto resta e quale livello lo alza var max = FinanceSystem.MaxLoan(w, w.Player); var loan = Do(w, new TakeLoanCommand(max + Money.FromLire(1))); @@ -332,4 +358,88 @@ public static class ClimbTests Assert.Equal(w.Player.NetWorth, decoded.History[^1].Value); Assert.Equal(new Money(w.Difficulty.InitialCapital), decoded.History[0].Value); } + + [Test(Description = "L'avanzamento resta sotto il pieno (e sotto il 100 % per difetto) finché un requisito manca; il rating dell'immagine 08")] + public static void ProgressIsFullOnlyWhenAllRequirementsAreMet() + { + var data = EasyTierTwo(); + var w = WorldFactory.Create(data, new NewGameSettings + { + Seed = 1804, SizeKm = 64, DifficultyId = "imprenditore", + DifficultyOverride = DifficultyOverrides.Apply(data.DifficultyPreset("imprenditore"), new[] { ("aiCompetitors", 0.0) }), + }); + var c = w.Player; + var tier = data.Tiers.Tiers[1]; + // soglia del patrimonio a 1000 volte il patrimonio attuale, poi il 99,7 % della soglia + var req = new TierRequirements + { + NetWorth = Math.Max(1_000_000, c.NetWorth.Cents) * 1000, + ConnectedTownsOver = tier.Requirements.ConnectedTownsOver, + CreditRating = tier.Requirements.CreditRating, + }; + var def = new TierDef { Level = tier.Level, NameIt = tier.NameIt, NameEn = tier.NameEn, Requirements = req, Unlocks = tier.Unlocks }; + void SetNetWorth(long cents) + { + long delta = cents - c.NetWorth.Cents; + if (delta > 0) w.Money.Transfer(Account.External, Account.Of(c.Id), new Money(delta), LedgerEntry.Other); + else if (delta < 0) w.Money.Transfer(Account.Of(c.Id), Account.External, new Money(-delta), LedgerEntry.Other); + Assert.Equal(cents, c.NetWorth.Cents); + } + SetNetWorth(req.NetWorth * 997 / 1000); + var near = ClimbOutlook.Requirements(w, c, def); + Assert.True(near.TownsMet && near.RatingMet && !near.NetWorthMet, "manca solo il patrimonio"); + Assert.False(Tiers.Meets(w, c, req)); + Assert.True(near.Progress < 1 && near.Progress <= ClimbOutlook.ProgressCap, $"avanzamento {near.Progress}"); + Assert.Equal(99.0, Math.Floor(near.Progress * 100), "per difetto si legge 99 %"); + Assert.Equal(99.0, Math.Floor(near.NetWorthFraction * 100), "patrimonio al 99 %"); + + SetNetWorth(req.NetWorth); + var met = ClimbOutlook.Requirements(w, c, def); + Assert.True(met.AllMet && Tiers.Meets(w, c, req)); + Assert.Equal(1.0, met.Progress); + + // immagine 08: 65 % del patrimonio, 1 città su 2, BBB verso A danno il 58 % + double rating = ClimbOutlook.RatingFraction(w, CreditRating.BBB, CreditRating.A); + Assert.Approx(0.6, rating, 1e-12); + Assert.Equal(58.0, Math.Floor((0.65 + 0.5 + rating) / 3 * 100)); + Assert.Equal(1.0, ClimbOutlook.RatingFraction(w, CreditRating.A, CreditRating.A)); + } + + [Test(Description = "Lo storico del patrimonio ha un punto per anno di calendario: oggi sostituisce la fotografia del primo giorno dell'anno")] + public static void HistoryHasOnePointPerCalendarYear() + { + var w = TestWorlds.NoAi(1805); + var c = w.Player; + int dpy = w.Calendar.DaysPerYear, start = w.Calendar.StartYear; + Assert.Equal(0L, c.FoundedDay); + w.Clock.Restore((3L * dpy + 100) * w.Calendar.TicksPerDay); + for (int y = 0; y < 3; y++) c.History.Add(new CompanyYear(start + y, 1_000 * (y + 1), 0, 0, 0, 1, 0, 0, 0)); + var points = ClimbOutlook.History(w, c); + Assert.True(points.Select(p => p.Day).SequenceEqual(new[] { 0L, dpy, 2L * dpy, w.Clock.Day }), string.Join(",", points.Select(p => p.Day))); + var years = points.Select(p => w.Calendar.DateOfDay(p.Day).Year).ToList(); + Assert.Equal(years.Count, years.Distinct().Count(), "anni distinti"); + Assert.Equal(new Money(2_000), points[2].Value, "fine anno dal secondo anno dello storico"); + Assert.Equal(c.NetWorth, points[^1].Value); + } + + [Test(Description = "Migrazione senza fatto saliente: il giorno del livello è quello della prima fotografia annuale che lo mostra (primo giorno dell'anno dopo)")] + public static void MigratedTierDayComesFromTheSnapshotDay() + { + var w = TestWorlds.NoAi(1806); + var c = w.Player; + int dpy = w.Calendar.DaysPerYear, start = w.Calendar.StartYear; + w.Clock.Restore((3L * dpy + 100) * w.Calendar.TicksPerDay); + c.Tier = 3; + c.History.Add(new CompanyYear(start, 0, 0, 0, 0, 1, 0, 0, 0)); + c.History.Add(new CompanyYear(start + 1, 0, 0, 0, 0, 2, 0, 0, 0)); + c.History.Add(new CompanyYear(start + 2, 0, 0, 0, 0, 3, 0, 0, 0)); + Assert.False(c.Milestones.Any(m => m.Text.StartsWith("diventa", StringComparison.Ordinal)), "nessun fatto saliente dei livelli"); + var v5 = new SaveWriter(1 << 20); + WorldSerializer.Write(w, v5, 5); + var mc = WorldSerializer.Read(TestData.Data, new SaveReader(v5.WrittenSpan.ToArray())).Player; + // livello 2 nella fotografia del secondo anno, scattata il primo giorno del terzo + Assert.Equal(2L * dpy, mc.TierReachedDay[1]); + Assert.Equal(3L * dpy, mc.TierReachedDay[2]); + Assert.Equal(-1L, mc.TierReachedDay[3]); + } }