F6: livelli e scalata, correzioni della revisione
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:
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);
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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" },
|
||||
|
||||
@@ -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
|
||||
|
||||
|
||||
@@ -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]);
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user