F6: livelli e scalata, correzioni della revisione
CI / Build e test (pull_request) Successful in 1m32s
CI / Immagine Docker (pull_request) Successful in 35s

La revisione del pannello «La tua scalata» ha trovato numeri che promettevano
più di quanto il motore concede e qualche incoerenza con l'immagine 08.

- Avanzamento: il client mostra le percentuali per difetto (Fmt.Progress),
  così il 100 % compare solo a requisito o livello raggiunto; prima 0,996
  si leggeva «100%» senza promozione. Il tetto del motore resta 0,999.
- Rating: la frazione è 1 − gradini mancanti / ratingProgressSteps (2,5 in
  tiers.json, con schema e validatore). Lo stato dell'immagine 08 torna al
  58 % (rating al 60 %); misurato dalla D dava l'86 % per un solo gradino.
- Concessioni: non compaiono più tra gli sblocchi né nella notizia finché il
  comando non esiste (F7); il rifiuto dice che non sono ancora disponibili.
- Validatore: gli sblocchi non possono diminuire salendo di livello (fido e
  funzioni), come presumono notizie, rifiuti e pannello.
- Industrie possedute inattive (livello 0): a libro valgono solo la cassa.
- Migrazione 1-5: il giorno del livello ricostruito dallo storico è quello
  della fotografia (primo giorno dell'anno dopo), tra fondazione e oggi.
- Storico del patrimonio: un punto per anno di calendario (oggi sostituisce
  il primo giorno dell'anno in corso); i livelli si segnano sull'anno della
  promozione, anche sull'ultimo punto.
- Barra superiore: richiede di nuovo il quadro se uno stato completo lo ha
  azzerato.
- ADR 0018 aggiornato; ADR 0015 §12 segnato come sostituito.
- Test nuovi per avanzamento, storico, migrazione, concessioni, industria
  inattiva e validatore (174 test verdi).

Refs #38.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Alby96andClaude Opus 5.5 committed 2026-11-08 12:31:10 +01:00
1 parent d473e21708
commit 2e5215c570
18 files changed
+275 -49

No files matched your search

@@ -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;
/// <summary>Clic sul livello: apre «La tua scalata».</summary>
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»")}";
@@ -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,
@@ -26,6 +26,12 @@ public static class Fmt
/// <summary>Quota (0–1) in percentuale («12,4%»).</summary>
public static string Pct(double fraction, int decimals = 1) => Number(fraction * 100, decimals) + "%";
/// <summary>
/// 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).
/// </summary>
public static string Progress(double fraction) => Number(Math.Floor(Math.Clamp(fraction, 0, 1) * 100 + 1e-9), 0) + "%";
/// <summary>Variazione con il segno («+1,2%», «−0,8%»).</summary>
public static string Change(double fraction) => (fraction > 0 ? "+" : "") + Pct(fraction);
@@ -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)))
{
@@ -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);
+5
View File
@@ -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
+1
View File
@@ -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" },
+2 -1
View File
@@ -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
+24 -11
View File
@@ -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
@@ -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<CreditRating>())) 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);
@@ -8,6 +8,11 @@ public sealed class TiersFile
[JsonPropertyName("$schema")] public string? Schema { get; init; }
public required int Version { get; init; }
public required List<CreditRating> RatingScale { get; init; }
/// <summary>
/// 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.
/// </summary>
public required double RatingProgressSteps { get; init; }
public required List<TierDef> Tiers { get; init; }
}
@@ -173,7 +173,8 @@ public static class ClimbOutlook
/// <summary>
/// Requisiti di un livello per la compagnia, con gli stessi confronti di <see cref="Simulation.Systems.Tiers.Meets"/>.
/// 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 / <see cref="TiersFile.RatingProgressSteps"/> (limitata tra 0 e 1).
/// L'avanzamento è la loro media, sotto 1 finché un requisito manca (<see cref="ProgressCap"/>).
/// </summary>
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
};
}
/// <summary>
/// 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 <see cref="Simulation.Systems.Tiers.Meets"/>): il client mostra le percentuali per difetto,
/// quindi sotto il tetto legge al massimo «99%».
/// </summary>
public const double ProgressCap = 0.999;
/// <summary>
/// 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 %).
/// </summary>
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);
}
/// <summary>Stato patrimoniale dalle voci del motore: somma esattamente al patrimonio netto.</summary>
public static BalanceSheet Balance(Company c)
{
@@ -257,16 +274,18 @@ public static class ClimbOutlook
/// <summary>
/// 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.
/// </summary>
public static List<NetWorthPoint> History(World w, Company c)
{
var points = new List<NetWorthPoint> { 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));
@@ -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).
/// </summary>
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;
}
@@ -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"),
};
}
@@ -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));
}
/// <summary>Valore degli impianti nel prezzo d'acquisto: costo d'ammodernamento × livello × quota, secondo le condizioni.</summary>
public static double PlantValue(World w, Industry ind)
/// <summary>Valore degli impianti: costo d'ammodernamento × livello × quota, secondo le condizioni.</summary>
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);
}
/// <summary>
/// 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.
/// </summary>
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));
}
@@ -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;
}
/// <summary>
/// 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.
/// </summary>
public static bool ConcessionsAvailable => false;
/// <summary>
/// Rifiuto delle concessioni finché non sono implementate: prima del livello che le sblocca
/// (TierLocked) dice anche quale livello servirà.
/// </summary>
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}»";
}
/// <summary>Fido massimo della compagnia a un livello: fido iniziale × fattore del livello.</summary>
public static Money LoanLimit(Company c, TierDef def) => c.BaseCredit * def.Unlocks.MaxLoanFactor;
@@ -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<string> LoadErrors(Action<Dictionary<string, string>> mutate)
{
var files = MemoryDataSource.Snapshot(TestData.Source);
@@ -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]);
}
}