F6: eventi del mondo, correzioni della revisione
CI / Build e test (pull_request) Successful in 1m23s
CI / Immagine Docker (pull_request) Successful in 30s

Allinea i giorni degli eventi a quelli annunciati, toglie le sovrapposizioni
di zona e impedisce che l'IA trasformi un effetto temporaneo in un
investimento permanente.

- Un evento è in vigore nei giorni [inizio, fine) per tutti: le
  interrogazioni di WorldEventState contano solo gli eventi in vigore nel
  giorno dell'orologio, l'usura conta il maltempo del giorno del traffico.
  Il maltempo non rallenta più i treni il giorno dell'estrazione e agisce
  per intero l'ultimo giorno; l'evento esce dall'elenco il mattino del
  primo giorno libero, con la notizia di fine. {until} è l'ultimo giorno.
- Niente zone sovrapposte tra due maltempi o tra due eventi sulla domanda
  dello stesso bene (né due boom né boom e crollo insieme): nessuna città
  e nessun arco ricevono due volte lo stesso effetto.
- IA: stime dei candidati sulla domanda senza eventi, sui posti scoperti
  senza le assenze di epidemie e scioperi (PresentWithoutEvents) e
  sull'efficienza senza il moltiplicatore di capacità (ADR 0017 §9).
- Client: conto alla rovescia dalla durata a 1 e «da domani» per gli
  eventi estratti oggi; avviso anche nelle città della zona e nel Registro
  officina del deposito in sciopero; dal resoconto il notiziario prende
  solo le notizie di fine, le altre arrivano già come Notification.

ADR 0017, STATE, ARCHITECTURE e PROTOCOL aggiornati; 2 test nuovi e
3 adattati alla nuova finestra.

Refs #33.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Alby96andClaude Opus 5.5 committed 2026-11-07 17:23:42 +01:00
1 parent 1f8da87e51
commit 5a4a156d52
14 files changed
+309 -54

No files matched your search

@@ -548,3 +548,5 @@ Velocità dei treni,,Train speed
Usura dei binari,,Track wear
entro,,within
fino al,,until
da domani,,from tomorrow
dal,,from
1 keys it en
548 Usura dei binari Track wear
549 entro within
550 fino al until
551 da domani from tomorrow
552 dal from
@@ -279,6 +279,8 @@ public partial class MaintenancePanel : VBoxContainer
stats.AddChild(PanelKit.Stat(T("Ricambi"), PanelKit.Value($"{d.SpareParts}")));
_workshop.AddChild(stats);
if (d.WaitingParts) _workshop.AddChild(UiTheme.Notice(T("Ricambi esauriti: gli interventi aspettano. Porta i ricambi in treno da una fabbrica di macchinari o da un porto.")));
// sciopero del personale del deposito (ADR 0017)
WorldEventText.AddNotices(w, _workshop, WorldEventText.Depot, _depot);
if (reg is not null)
{
if (reg.WorkRate < 0.999f)
@@ -71,12 +71,25 @@ public static class WorldEventText
return def?.RadiusKm is { } km ? $"{T("entro")} {Fmt.Number(km, 0)} km {T("da")} {target}" : target;
}
/// <summary>
/// Scadenza: ultimo giorno dell'evento (EndDay − 1) e giorni che restano, oggi compreso. Il server
/// toglie l'evento il mattino di EndDay, quindi il conto va dalla durata estratta a 1. Un evento
/// estratto oggi inizia domani: si dice da quando, con la sua durata.
/// </summary>
public static string Until(ClientWorld w, WorldEventInfo e)
{
long left = Math.Max(0, e.EndDay - Fmt.Today(w));
return $"{T("fino al")} {Fmt.Date(w, e.EndDay - 1)} ({left} {(left == 1 ? T("giorno") : T("giorni"))})";
long today = Fmt.Today(w);
string until = $"{T("fino al")} {Fmt.Date(w, e.EndDay - 1)}";
if (e.StartDay > today)
{
string from = e.StartDay == today + 1 ? T("da domani") : $"{T("dal")} {Fmt.Date(w, e.StartDay)}";
return $"{from} {until} ({Days(e.EndDay - e.StartDay)})";
}
return $"{until} ({Days(Math.Max(1, e.EndDay - today))})";
}
private static string Days(long n) => $"{n} {(n == 1 ? T("giorno") : T("giorni"))}";
/// <summary>Colore della gravità: opportunità in verde, avvisi in ambra, critici in rosso.</summary>
public static Color Color(WorldEventInfo e) => e.Severity switch
{
@@ -98,9 +111,21 @@ public static class WorldEventText
return col;
}
/// <summary>Eventi che riguardano un'entità: bersaglio diretto oppure città centro della zona.</summary>
/// <summary>
/// Eventi che riguardano un'entità: bersaglio diretto oppure, per una città, zona (maltempo,
/// domanda di un bene) che la contiene. Come sul server, una città è nella zona se dista dalla città
/// centro al più il raggio del catalogo.
/// </summary>
public static IEnumerable<WorldEventInfo> For(ClientWorld w, byte entity, int index) =>
(w.LastDigest?.WorldEvents ?? []).Where(e => e.Entity == entity && e.EntityIndex == index);
(w.LastDigest?.WorldEvents ?? []).Where(e => (e.Entity == entity && e.EntityIndex == index) || (entity == TownEntity && InZone(w, e, index)));
private static bool InZone(ClientWorld w, WorldEventInfo e, int town)
{
if (e.Entity != TownEntity || Def(w, e)?.RadiusKm is not { } km) return false;
if (!w.Towns.TryGetValue(town, out var t) || !w.Towns.TryGetValue(e.EntityIndex, out var center)) return false;
double r = km * 1000;
return (t.Position - center.Position).LengthSquared <= r * r;
}
/// <summary>Avvisi «Evento in corso» per la scheda dell'entità.</summary>
public static void AddNotices(ClientWorld w, Control into, byte entity, int index)
@@ -309,8 +309,9 @@ public partial class GameScreen : Node
_session.Send(new RequestDetail { Kind = DetailKind.Employment, Target = 0 });
break;
case DailyDigest d:
// gli eventi del mondo (inizio e fine) vanno sempre nel notiziario
foreach (var e in d.Events.Where(e => e.Severity >= 2 || e.Kind == WorldEventKind)) _ticker.Add(e);
// le notizie non informative arrivano già una per una come Notification (GameHost); dal
// resoconto si aggiungono solo le fini degli eventi del mondo, informative (ADR 0017 §7)
foreach (var e in d.Events.Where(e => e.Kind == WorldEventKind && e.Severity == 0)) _ticker.Add(e);
_worldEvents.Update(_session.World);
break;
}
+1 -1
View File
@@ -96,7 +96,7 @@ Requisito: stesso seme + stessi comandi agli stessi tick ⇒ stesso hash di stat
- Ogni movimento di denaro passa dal registro (`MoneyLedger.Transfer`) tra conti: compagnie, industrie e il conto `Esterno` (famiglie, clienti delle tariffe, mercato mondiale). La somma di tutti i saldi è sempre zero: è l'invariante «denaro» dei test. Le voci del conto economico delle compagnie (`LedgerEntry`) si accumulano per mese e per anno.
- Ogni unità di merce sta in un magazzino tracciato (industrie, città, magazzini delle compagnie nelle stazioni, pacchetti in stazione e a bordo dei treni) e `GoodsCounters` registra prodotto, consumato, deperito, importato, esportato: giacenza = prodotto + importato − consumato − deperito − esportato. È l'invariante «merci».
- Compravendita in proprio (F6, ADR 0016): `TradingCommandHandlers` esegue `BuyGoods`, `SellGoods` e `ShipGoods` con il prezzo locale marginale di `Systems/TradingMath` (unità per unità, controparti ordinate per prezzo). La merce comprata sta in `Station.Stock`; quella spedita viaggia in pacchetti con `Packet.Owned`, senza tariffa né consumatore, ed entra nel magazzino della stazione d'arrivo. Gli scambi con le industrie passano dal registro sulla voce «Commercio», quelli con gli hub contano come importazione ed esportazione; `StationSystem` addebita ogni mese la giacenza dei magazzini.
- Eventi del mondo (F6, ADR 0017): `World.WorldEvents` (`WorldEventState`) è l'unica sorgente dei loro effetti. I sistemi chiedono un moltiplicatore per entità (1 senza eventi): `IndustryCapacity` in `IndustrySystem` e nella domanda di input di `DemandSystem`, `TownDemand` in `DemandSystem.TownDemand`, `Attendance` nelle presenze dei pendolari di `EmploymentSystem`, `EdgeSpeed` in `TrainSystem` ed `EdgeWear` nell'usura del binario di `ConstructionSystem`. Nessuno stato di base viene modificato: a evento finito il moltiplicatore torna 1.
- Eventi del mondo (F6, ADR 0017): `World.WorldEvents` (`WorldEventState`) è l'unica sorgente dei loro effetti. I sistemi chiedono un moltiplicatore per entità (1 senza eventi): `IndustryCapacity` in `IndustrySystem` e nella domanda di input di `DemandSystem`, `TownDemand` in `DemandSystem.TownDemand`, `Attendance` nelle presenze dei pendolari di `EmploymentSystem`, `EdgeSpeed` in `TrainSystem` ed `EdgeWear` nell'usura del binario di `ConstructionSystem` (traffico del giorno prima). Contano solo gli eventi in vigore nel giorno dell'orologio, [inizio, fine). Nessuno stato di base viene modificato: a evento finito il moltiplicatore torna 1. Le stime dei candidati delle IA leggono i valori senza eventi.
- Interpretazioni delle formule della guida: ADR 0004.
## 7. Salvataggi
+1 -1
View File
@@ -181,7 +181,7 @@ Record (ognuno chiude con `flags`):
`nextDueDays: i32`, `maintenanceDepot: i32`
- `EdgeInfo { id, owner, a, b, trackClass: u8, doubleTrack, electrified, state: u8, condition: f32, structureCondition: f32, progress: f32, samples: [(s, x, y, h, ground: f64, kind: u8, speedLimitKmh: f64)], signals: [f64] }`
- `EventInfo { day: i64, kind: u8, severity: u8, text, entity: u8, entityIndex: i32, company: i32 }`; `kind` 10 = evento del mondo (inizio e fine, F6)
- `WorldEventInfo { id: i32, type: string (id di events.json), entity: u8 (1 città, 2 industria, 7 deposito), entityIndex: i32, good: i32 (−1 se nessuno), startDay: i64, endDay: i64 (primo giorno senza l'evento), severity: u8, effects: [f32] }`: `effects` sono i moltiplicatori nell'ordine degli effetti del tipo nel catalogo (ADR 0017)
- `WorldEventInfo { id: i32, type: string (id di events.json), entity: u8 (1 città, 2 industria, 7 deposito), entityIndex: i32, good: i32 (−1 se nessuno), startDay: i64 (dopo `day` per un evento estratto oggi, che inizia domani), endDay: i64 (primo giorno senza l'evento: il server lo toglie quel mattino), severity: u8, effects: [f32] }`: `effects` sono i moltiplicatori nell'ordine degli effetti del tipo nel catalogo (ADR 0017)
- `EmploymentRow { industry, jobsWorkers, jobsStaff, workersPresent: f32, staffPresent: f32, reason, sources: [EmploymentSource { town, homeStation, line, category: u8, headcount, coverage: f32 }] }`;
blocco 1: `kind: u8` (0 industria, 1 deposito: `industry` è allora l'id del deposito), `workersReason: u8`, `staffReason: u8`
(0 nessuno, 1 nessuna stazione, 2 nessuna città entro il tempo massimo, 3 nessun lavoratore libero, 4 città senza servizi
+4 -3
View File
@@ -115,10 +115,11 @@ Aggiornato alla fine di ogni fase (guida, sezione 18).
- effetti come moltiplicatori letti da un'unica sorgente (`World.WorldEvents`): capacità delle industrie (produzione e domanda di input), consumi delle città, presenze dei pendolari, velocità dei treni e usura del binario; a evento finito tutto torna come prima;
- `EventSystem` tra le IA e l'hash, flusso pseudo-casuale dedicato «events», bersaglio in ordine di id, notizie d'inizio e di fine in italiano (`EventKind.World` = 10); `EventSystem.Force` per test e scenari;
- salvataggio: corpo versione 5 (`EventSerializer`) con gli eventi attivi nell'hash e la frequenza nelle impostazioni; le versioni 1–4 si caricano senza eventi e con la frequenza del preset;
- protocollo: blocco 1 di `DailyDigest` con gli eventi in corso (`WorldEventInfo`), blocco 2 di `MarketReport` con quelli sulla domanda di un bene; client: riquadro «Eventi in corso» sopra la minimappa, avvisi nelle schede di industria e città, «evento in corso» nel Mercato globale, notizie degli eventi sempre nel notiziario, testi in `strings.csv` (corretta anche una chiave con la virgola non tra virgolette);
- protocollo: blocco 1 di `DailyDigest` con gli eventi in corso (`WorldEventInfo`), blocco 2 di `MarketReport` con quelli sulla domanda di un bene; client: riquadro «Eventi in corso» sopra la minimappa, avvisi nelle schede di industria e città e nel Registro officina, «evento in corso» nel Mercato globale, notizie degli eventi sempre nel notiziario, testi in `strings.csv` (corretta anche una chiave con la virgola non tra virgolette);
- scenari: campo facoltativo `eventFrequencyMultiplier`; `valdoria.json` lo mette a 0, così l'accettazione F2 e F4 resta invariata (35 / 20 guasti senza la linea, 75 / 2 con la linea). Con gli eventi a frequenza «Imprenditore» la rete senza linea si fermava a 41 con 10 guasti e il criterio «sotto 40 entro 3 anni» non valeva più (ADR 0017 §8);
- le IA non reagiscono agli eventi: ne subiscono gli effetti attraverso i sistemi;
- test (`Simulation/EventTests.cs`, 17): catalogo e validazione, effetti di ogni tipo e loro fine, solo la zona per domanda e maltempo, treni rallentati, officina senza personale, durata, niente doppioni, frequenza 0, stesso seme stessi eventi, salvataggio con eventi attivi, migrazione dalla versione 4, un anno di eventi frequenti con gli invarianti (lento), eventi nel `DailyDigest` e nel `MarketReport`. 160 test (142 senza i lenti).
- le IA non reagiscono agli eventi: ne subiscono gli effetti attraverso i sistemi, ma stimano i candidati sui valori senza eventi (domanda delle città, posti scoperti, efficienza delle industrie di trasformazione; ADR 0017 §9);
- correzioni della revisione: un evento è in vigore nei giorni [inizio, fine) per tutti (sistemi giornalieri, treni a ogni tick, usura del traffico del giorno prima) ed esce dall'elenco il mattino del primo giorno libero con la notizia di fine; nessuna sovrapposizione di zone tra due maltempi o tra due eventi sulla domanda dello stesso bene; `{until}` è l'ultimo giorno; client: conto alla rovescia dalla durata a 1 e «da domani» per gli eventi estratti oggi, avviso anche nelle città della zona e nel Registro officina del deposito, notiziario senza doppioni (dal resoconto solo le notizie di fine, le altre arrivano come `Notification`);
- test (`Simulation/EventTests.cs`, 19): catalogo e validazione, effetti di ogni tipo e loro fine, solo la zona per domanda e maltempo, treni rallentati, officina senza personale, durata, niente doppioni né zone sovrapposte, giorni del maltempo per treni, usura e resoconto con il conto alla rovescia, presenti senza eventi per l'IA, frequenza 0, stesso seme stessi eventi, salvataggio con eventi attivi, migrazione dalla versione 4, un anno di eventi frequenti con gli invarianti (lento), eventi nel `DailyDigest` e nel `MarketReport`. 162 test (144 senza i lenti).
- Restano della F6: finanza completa, livelli e sblocchi nell'interfaccia, ere e obsolescenza, pannelli 07–08, tooltip «perché», tutorial, audio, bilanciamento con i bot.
## Prossimo passo
+32 -11
View File
@@ -66,12 +66,20 @@ finito tutto torna come prima) e deterministici.
flusso dedicato `World.Stream("events")` (derivato con `Rng.Fork`, salvato con gli altri); se il
tetto non è raggiunto, i candidati in ordine di id (industrie aperte di livello > 0, depositi vivi,
città sopra la popolazione minima; per `townGood` le coppie città–bene con domanda nell'anno) senza
quelli che hanno già un evento dello stesso tipo, poi bersaglio, durata e intensità dallo stesso
flusso. Stessi tipi diversi sullo stesso bersaglio si sommano (prodotto dei moltiplicatori).
quelli che hanno già un evento dello stesso tipo e, per le zone, quelli la cui zona si
sovrappone a quella di un evento con lo stesso bersaglio di zona (due maltempi; due eventi sulla
domanda dello stesso bene, quindi né due boom né boom e crollo insieme): i centri devono distare
più della somma dei raggi, così nessuna città e nessun arco ricevono due volte lo stesso effetto.
Poi bersaglio, durata e intensità dallo stesso flusso. Tipi diversi sullo stesso bersaglio si
sommano (prodotto dei moltiplicatori), per esempio epidemia e sciopero sulle presenze.
Posizione e date: girando dopo i sistemi giornalieri, un evento estratto il giorno S inizia il
giorno S + 1 e agisce sui sistemi giornalieri nei giorni [inizio, fine), cioè esattamente per la
durata estratta; si chiude la sera del suo ultimo giorno con la notizia di fine. I treni, che si
muovono a ogni tick, sentono il maltempo dal tick successivo all'estrazione. Inizio e fine danno un
giorno S + 1 ed è in vigore nei giorni [inizio, fine), cioè esattamente per la durata estratta.
L'evento resta nell'elenco dall'estrazione al mattino del primo giorno libero (fine), quando
esce con la notizia di fine; le interrogazioni di `WorldEventState` contano solo gli eventi in
vigore nel giorno dell'orologio, così valgono gli stessi giorni per i sistemi giornalieri, per i
treni che si muovono a ogni tick (niente rallentamento il giorno dell'estrazione, rallentamento
per intero l'ultimo giorno) e per l'usura, che `ConstructionSystem` applica al mattino al traffico
del giorno prima e che quindi conta il maltempo in vigore ieri. Inizio e fine danno un
`GameEvent` di tipo nuovo `EventKind.World` (10), in italiano, con l'entità coinvolta, per
notiziario e Cronaca. `EventSystem.Force` fa iniziare un evento scelto (test, scenari, strumenti),
senza numeri casuali.
@@ -83,13 +91,20 @@ finito tutto torna come prima) e deterministici.
prima della F6 riceve gli eventi da quel momento. Un tipo o un bene tolti dai dati fanno finire
l'evento al caricamento.
7. **Protocollo e client.** `DailyDigest` (120) porta nel blocco 1 l'elenco compatto degli eventi in
corso (`WorldEventInfo`: id, tipo, entità, bene, giorni, gravità e valori dei moltiplicatori);
corso (`WorldEventInfo`: id, tipo, entità, bene, giorni, gravità e valori dei moltiplicatori),
compresi quelli estratti oggi che iniziano domani;
`MarketReport` (129) porta nel blocco 2 quelli sulla domanda di un bene, che il pannello «Mercato
globale» mostra come «evento in corso» insieme allo shock mondiale (`MarketOutlook.GoodEvents`).
Il client mostra il riquadro «Eventi in corso» sopra la minimappa (fino a quattro righe, i più
vicini alla fine), l'avviso dell'evento nelle schede di industria e città coinvolte e manda sempre
al notiziario le notizie `EventKind.World`, anche le opportunità. Testi con `T()` e chiavi in
`strings.csv`; i nomi dei tipi vengono dal catalogo nella lingua dell'interfaccia.
vicini alla fine) con l'ultimo giorno (fine − 1) e i giorni che restano, oggi compreso (dalla
durata a 1), oppure «da domani» per quelli non ancora iniziati. Mostra l'avviso dell'evento nelle
schede dell'industria, della città (bersaglio diretto o città entro il raggio del catalogo dalla
città centro di una zona, come sul server) e nel Registro officina del deposito in sciopero. Le
notizie non informative arrivano già una per una come `Notification`; dal `DailyDigest` il
notiziario aggiunge solo quelle informative di `EventKind.World` (le notizie di fine), così
nessuna compare due volte. Il segnaposto `{until}` è l'ultimo giorno dell'evento, come nel
client. Testi con `T()` e chiavi in `strings.csv`; i nomi dei tipi vengono dal catalogo nella
lingua dell'interfaccia.
8. **Accettazione con gli eventi disattivati.** Lo scenario di riferimento `valdoria.json` mette
`eventFrequencyMultiplier` a 0 (nuovo campo facoltativo degli scenari, che sostituisce quello della
difficoltà): l'accettazione F2 e F4 e tutti i test sulla rete di Valdoria misurano il sistema che
@@ -99,8 +114,14 @@ finito tutto torna come prima) e deterministici.
guida «sotto 40 entro 3 anni» non sarebbe più vero; con la linea resta 75 con 2 guasti. I numeri
dell'accettazione F4 con gli eventi disattivati restano 35 / 20 guasti senza la linea e 75 / 2 con
la linea. I mondi generati (`WorldFactory`) hanno gli eventi della difficoltà scelta.
9. **IA.** Le compagnie IA non reagiscono agli eventi: ne subiscono gli effetti attraverso i sistemi
(le stime di domanda leggono `TownDemand`).
9. **IA.** Le compagnie IA non reagiscono agli eventi: ne subiscono gli effetti attraverso i sistemi,
ma non progettano linee su valori temporanei, che renderebbero permanente un effetto di pochi
giorni. Nelle stime dei candidati usano la domanda delle città senza eventi
(`DemandSystem.TownDemand(…, events: false)`), i posti scoperti contati sui presenti senza le
assenze di epidemie e scioperi (`EmploymentSystem.PresentWithoutEvents`) e, per le industrie di
trasformazione, l'efficienza divisa per il moltiplicatore di capacità (un impianto fermo per un
incidente si rivaluta a evento finito, senza essere scartato). Gli effetti indiretti passati per le
medie mobili (coperture a 30 giorni) restano, come per ogni altro cambiamento del mondo.
## Conseguenze
@@ -646,8 +646,16 @@ internal sealed class AiAgent
if (who == _c.Id) continue;
if (who.IsValid && !(_p.TargetsPlayer && who == _w.Player.Id)) continue;
// produzione attesa: le primarie lavorano un po' meglio quando sono servite; le industrie di
// trasformazione producono solo quanto i loro input consentono (efficienza attuale)
double eff = prod.Def.Kind == IndustryKind.Primary ? _plan.AssumedEfficiency : Math.Min(prod.Efficiency, _plan.AssumedEfficiency);
// trasformazione producono solo quanto i loro input consentono (efficienza attuale, senza
// il moltiplicatore temporaneo di incidenti e boom: ADR 0017 §9)
double eff = _plan.AssumedEfficiency;
if (prod.Def.Kind != IndustryKind.Primary)
{
double capacity = _w.WorldEvents.IndustryCapacity(prod.Id);
// impianto fermo per un incidente: non si giudica oggi, se ne riparla a evento finito
if (capacity <= 0) break;
eff = Math.Min(prod.Efficiency / capacity, eff);
}
double supply = (double)prod.Def.Capacity(prod.Level) * outputs[o].PerCycle / outputs[0].PerCycle * months * eff;
if (supply <= 0) continue;
foreach (var cons in _w.Industries)
@@ -688,7 +696,8 @@ internal sealed class AiAgent
}
foreach (var town in _w.Towns)
{
double perDay = DemandSystem.TownDemand(_w, town, good, _ctx.Year);
// domanda di base: una fiera o un boom di qualche settimana non vale un anno (ADR 0017 §9)
double perDay = DemandSystem.TownDemand(_w, town, good, _ctx.Year, events: false);
if (perDay <= 0) continue;
double km = _w.TownEdgeDistanceKm(town, prod.Position);
if (km < minKm || km > maxKm) continue;
@@ -715,7 +724,11 @@ internal sealed class AiAgent
if (ind.Closed || ind.Level <= 0 || servedBy[ind.Id.Value] != _c.Id) continue;
for (int cls = 0; cls < 2; cls++)
{
double uncovered = cls == 0 ? ind.JobsWorkers - ind.WorkersPresent : ind.JobsStaff - ind.StaffPresent;
// posti scoperti senza le assenze di epidemie e scioperi: un vuoto di pochi giorni non
// giustifica una linea nuova (ADR 0017 §9)
double uncovered = cls == 0
? ind.JobsWorkers - EmploymentSystem.PresentWithoutEvents(_w, ind, PaxClass.Worker)
: ind.JobsStaff - EmploymentSystem.PresentWithoutEvents(_w, ind, PaxClass.Staff);
if (uncovered < _plan.MinCommuters) continue;
var paxClass = cls == 0 ? PaxClass.Worker : PaxClass.Staff;
foreach (var town in _w.Towns)
@@ -422,6 +422,28 @@ public sealed class EmploymentSystem : ISimSystem
public static int OpenJobs(int jobs, double share, int contracted) =>
Math.Max(0, (int)Math.Ceiling(jobs - OnSite(jobs, share) - contracted - 1e-9));
/// <summary>
/// Lavoratori (o personale) che sarebbero presenti oggi senza gli eventi del mondo: lo stesso conto
/// di <c>UpdatePresence</c> senza le presenze ridotte da epidemie e scioperi. Serve alle stime che
/// portano a investimenti duraturi (IA, ADR 0017 §9), che non devono leggere un vuoto temporaneo
/// come posti scoperti. Senza eventi sulle presenze è il valore del giorno.
/// </summary>
public static double PresentWithoutEvents(World w, Industry ind, PaxClass cls)
{
bool staff = cls == PaxClass.Staff;
if (!w.WorldEvents.AnyWith(EventEffectKind.Attendance)) return staff ? ind.StaffPresent : ind.WorkersPresent;
var ib = w.Data.Balance.Industry;
int jobs = staff ? ind.JobsStaff : ind.JobsWorkers;
double present = OnSite(jobs, staff ? ib.OnSiteStaffShare : ib.OnSiteWorkerShare);
var me = WorkplaceRef.Of(ind.Id);
foreach (var c in w.Commutes)
{
if (c.Workplace != me || (c.Category == PaxClass.Staff) != staff) continue;
present += c.Walking ? c.Headcount : c.Headcount * Math.Min(1.0, c.Coverage);
}
return Math.Min(present, jobs);
}
private static void UpdatePresence(WorldContext ctx)
{
var w = ctx.World;
@@ -8,13 +8,14 @@ namespace RailEnterprise.Core.Simulation.Systems;
/// Eventi del mondo (F6, ADR 0017): ogni giorno chiude quelli scaduti, poi per ogni tipo del
/// catalogo (events.json, in ordine) estrae con il flusso dedicato «events» se ne nasce uno, con
/// probabilità chancePerYear × difficoltà / giorni dell'anno, e sceglie il bersaglio tra i candidati
/// in ordine di id. Nessun doppione dello stesso tipo sullo stesso bersaglio; al massimo maxActive
/// eventi insieme. Inizio e fine danno una notizia (<see cref="EventKind.World"/>). Gli effetti sono
/// moltiplicatori letti dai sistemi tramite <see cref="WorldEventState"/>.
/// in ordine di id. Nessun doppione dello stesso tipo sullo stesso bersaglio, né zone sovrapposte di
/// due maltempi o di due eventi sulla domanda dello stesso bene; al massimo maxActive eventi insieme.
/// Inizio e fine danno una notizia (<see cref="EventKind.World"/>). Gli effetti sono moltiplicatori
/// letti dai sistemi tramite <see cref="WorldEventState"/>.
/// Gira dopo le IA e prima dell'hash, quindi dopo i sistemi giornalieri del giorno: un evento estratto
/// oggi inizia domani (StartDay) e agisce sui sistemi giornalieri nei giorni [StartDay, EndDay), cioè
/// esattamente per la durata estratta; si chiude a fine giornata del suo ultimo giorno (EndDay − 1),
/// con la notizia di fine. I treni, che si muovono a ogni tick, lo sentono dal tick successivo.
/// oggi inizia domani (StartDay) ed è in vigore nei giorni [StartDay, EndDay), cioè esattamente per la
/// durata estratta, per i sistemi giornalieri come per i treni a ogni tick e per l'usura del loro
/// traffico; esce dall'elenco il mattino di EndDay, con la notizia di fine.
/// </summary>
public sealed class EventSystem : ISimSystem
{
@@ -55,8 +56,9 @@ public sealed class EventSystem : ISimSystem
{
var e = state.Active[i];
bool alive = TargetAlive(w, e.TargetKind, e.Target);
// domani è fuori dall'intervallo [StartDay, EndDay): oggi era l'ultimo giorno
if (day + 1 < e.EndDay && alive)
// oggi è il primo giorno senza l'evento: i sistemi giornalieri e l'usura del traffico di
// ieri (ConstructionSystem) lo hanno già letto per l'ultima volta
if (day < e.EndDay && alive)
{
i++;
continue;
@@ -69,9 +71,10 @@ public sealed class EventSystem : ISimSystem
/// <summary>
/// Fa iniziare subito un evento sul bersaglio indicato (test, scenari e strumenti; in partita li
/// estrae il sistema). Restituisce null se il bersaglio non è ammesso dal tipo, se un evento dello
/// stesso tipo è già in corso lì o se la durata non è positiva. Non usa numeri casuali e non
/// controlla maxActive né l'anno minimo. Chiamato tra un giorno e l'altro (fuori dalla pipeline),
/// l'evento agisce già sul giorno che sta per cominciare; a giornata iniziata, da domani.
/// stesso tipo è già in corso lì (o, per le zone, su una zona sovrapposta) o se la durata non è
/// positiva. Non usa numeri casuali e non controlla maxActive né l'anno minimo. Chiamato tra un
/// giorno e l'altro (fuori dalla pipeline), l'evento agisce già sul giorno che sta per cominciare;
/// a giornata iniziata, da domani.
/// </summary>
public static ActiveWorldEvent? Force(World w, string typeId, int target, int good = -1, int? durationDays = null, double intensity = 1.0)
{
@@ -154,10 +157,18 @@ public sealed class EventSystem : ISimSystem
}
break;
case EventTarget.Town:
foreach (var t in w.Towns)
{
if (t.Population < def.MinPopulation || state.IsActive(def, EntityKind.Town, t.Id.Value)) continue;
into.Add((EntityKind.Town, t.Id.Value, -1));
}
break;
case EventTarget.Area:
foreach (var t in w.Towns)
{
if (t.Population < def.MinPopulation || state.IsActive(def, EntityKind.Town, t.Id.Value)) continue;
// due maltempi sullo stesso arco si moltiplicherebbero: zone separate
if (Overlaps(state, def, t.Position, -1)) continue;
into.Add((EntityKind.Town, t.Id.Value, -1));
}
break;
@@ -170,6 +181,8 @@ public sealed class EventSystem : ISimSystem
{
// solo i beni che la città consuma quest'anno (era e fine del consumo)
if (DemandSystem.TownDemand(w, t, g, year, events: false) <= 0) continue;
// né due boom né boom e crollo dello stesso bene sulle stesse città
if (Overlaps(state, def, t.Position, g)) continue;
into.Add((EntityKind.Town, t.Id.Value, g));
}
}
@@ -177,19 +190,36 @@ public sealed class EventSystem : ISimSystem
}
}
/// <summary>
/// Vero se la zona centrata in <paramref name="center"/> si sovrappone a quella di un evento in
/// elenco con lo stesso bersaglio di zona (maltempo; per la domanda, lo stesso bene): le due zone
/// possono avere una città o un arco in comune quando i centri distano al più la somma dei raggi.
/// </summary>
private static bool Overlaps(WorldEventState state, WorldEventDef def, Vec2 center, int good)
{
if (def.RadiusKm is not { } km) return false;
foreach (var e in state.Active)
{
if (e.Def.Target != def.Target || e.Good != good || e.Def.RadiusKm is not { } other) continue;
double reach = (km + other) * 1000;
if ((e.Center - center).LengthSquared <= reach * reach) return true;
}
return false;
}
private static void Announce(World w, ActiveWorldEvent e, string template, NewsSeverity severity)
{
string text = Format(w, e, template);
w.Events.Add(new GameEvent(w.Clock.Day, EventKind.World, (EventSeverity)(byte)severity, text, e.TargetKind, e.Target));
}
/// <summary>Testo della notizia con i segnaposti {target}, {good}, {pct}, {days}, {until}.</summary>
/// <summary>Testo della notizia con i segnaposti {target}, {good}, {pct}, {days}, {until} (ultimo giorno dell'evento).</summary>
public static string Format(World w, ActiveWorldEvent e, string template) => template
.Replace("{target}", TargetName(w, e.TargetKind, e.Target), StringComparison.Ordinal)
.Replace("{good}", e.Good >= 0 ? w.Data.Goods[e.Good].NameIt.ToLowerInvariant() : "", StringComparison.Ordinal)
.Replace("{pct}", $"{Math.Round(e.Primary * 100):0}%", StringComparison.Ordinal)
.Replace("{days}", e.DurationDays.ToString(System.Globalization.CultureInfo.InvariantCulture), StringComparison.Ordinal)
.Replace("{until}", w.Calendar.DateOfDay(e.EndDay).ToString(), StringComparison.Ordinal);
.Replace("{until}", w.Calendar.DateOfDay(e.EndDay - 1).ToString(), StringComparison.Ordinal);
public static string TargetName(World w, EntityKind kind, int target) => kind switch
{
+2 -1
View File
@@ -24,6 +24,7 @@ public sealed class World
Settings = settings;
Calendar = new Calendar(data.Balance.Time, settings.StartYear);
Clock = new GameClock(Calendar);
WorldEvents = new WorldEventState(Clock);
Rng = new Rng(settings.Seed);
Terrain = terrain;
Sampler = new TerrainSampler(terrain);
@@ -96,7 +97,7 @@ public sealed class World
public EventLog Events { get; } = new();
/// <summary>Eventi del mondo in corso con i loro effetti temporanei (ADR 0017).</summary>
public WorldEventState WorldEvents { get; } = new();
public WorldEventState WorldEvents { get; }
/// <summary>Avvisi di manutenzione del giorno (non salvati): il server li inoltra come MaintenanceAlert.</summary>
public List<FleetAlert> Alerts { get; } = [];
@@ -2,6 +2,7 @@ using RailEnterprise.Core.Common;
using RailEnterprise.Core.Data;
using RailEnterprise.Core.Economy;
using RailEnterprise.Core.Rail;
using RailEnterprise.Core.Time;
namespace RailEnterprise.Core.Simulation;
@@ -31,6 +32,9 @@ public sealed class ActiveWorldEvent
public int DurationDays => (int)(EndDay - StartDay);
/// <summary>Vero se l'evento è in vigore nel giorno indicato: [StartDay, EndDay).</summary>
public bool InForce(long day) => StartDay <= day && day < EndDay;
/// <summary>Moltiplicatore dell'effetto indicato (1 se il tipo non ce l'ha).</summary>
public double Effect(EventEffectKind kind)
{
@@ -59,13 +63,18 @@ public sealed class ActiveWorldEvent
/// <summary>
/// Eventi del mondo in corso: unica sorgente dei moltiplicatori temporanei letti dai sistemi. Ogni
/// interrogazione restituisce il prodotto degli effetti attivi sull'entità (1 senza eventi), così a
/// evento scaduto tutto torna come prima. L'elenco è in ordine d'inizio (id crescente).
/// evento scaduto tutto torna come prima. L'elenco è in ordine d'inizio (id crescente) e contiene
/// gli eventi dall'estrazione fino al mattino del primo giorno libero: le interrogazioni contano solo
/// quelli in vigore nel giorno dell'orologio (<see cref="ActiveWorldEvent.InForce"/>), così un evento
/// estratto oggi agisce da domani anche sui treni e l'ultimo giorno agisce per intero (ADR 0017 §5).
/// </summary>
public sealed class WorldEventState
public sealed class WorldEventState(GameClock clock)
{
private readonly List<ActiveWorldEvent> _active = [];
private int _areaEvents;
private long Today => clock.Day;
public IReadOnlyList<ActiveWorldEvent> Active => _active;
/// <summary>Prossimo id libero (mai riutilizzato).</summary>
@@ -108,7 +117,17 @@ public sealed class WorldEventState
return false;
}
/// <summary>Eventi che riguardano un'entità (bersaglio diretto o città centro di una zona).</summary>
/// <summary>Vero se un evento in elenco (anche non ancora iniziato) ha l'effetto indicato.</summary>
public bool AnyWith(EventEffectKind kind)
{
foreach (var e in _active)
{
if (e.Has(kind)) return true;
}
return false;
}
/// <summary>Eventi il cui bersaglio diretto è l'entità (anche non ancora iniziati).</summary>
public IEnumerable<ActiveWorldEvent> For(EntityKind kind, int index)
{
foreach (var e in _active)
@@ -121,9 +140,10 @@ public sealed class WorldEventState
public double IndustryCapacity(IndustryId industry)
{
double f = 1.0;
long day = Today;
foreach (var e in _active)
{
if (e.TargetKind == EntityKind.Industry && e.Target == industry.Value) f *= e.Effect(EventEffectKind.IndustryCapacity);
if (e.TargetKind == EntityKind.Industry && e.Target == industry.Value && e.InForce(day)) f *= e.Effect(EventEffectKind.IndustryCapacity);
}
return f;
}
@@ -133,8 +153,10 @@ public sealed class WorldEventState
{
if (_active.Count == 0) return 1.0;
double f = 1.0;
long day = Today;
foreach (var e in _active)
{
if (!e.InForce(day)) continue;
switch (e.Def.Target)
{
case EventTarget.Town when e.Target == town.Id.Value:
@@ -156,8 +178,10 @@ public sealed class WorldEventState
{
if (_active.Count == 0) return 1.0;
double f = 1.0;
long day = Today;
foreach (var e in _active)
{
if (!e.InForce(day)) continue;
bool hit = e.Def.Target switch
{
EventTarget.Town => e.Target == town.Value,
@@ -169,20 +193,23 @@ public sealed class WorldEventState
return f;
}
/// <summary>Velocità dei treni sull'arco (TrainSystem): aree di maltempo che contengono il suo punto medio.</summary>
public double EdgeSpeed(TrackEdge edge) => _areaEvents == 0 ? 1.0 : AreaEffect(edge, EventEffectKind.TrainSpeed);
/// <summary>Velocità dei treni sull'arco (TrainSystem, a ogni tick): aree di maltempo in vigore oggi che contengono il suo punto medio.</summary>
public double EdgeSpeed(TrackEdge edge) => _areaEvents == 0 ? 1.0 : AreaEffect(edge, EventEffectKind.TrainSpeed, Today);
/// <summary>Usura del binario dovuta al traffico sull'arco (ConstructionSystem).</summary>
public double EdgeWear(TrackEdge edge) => _areaEvents == 0 ? 1.0 : AreaEffect(edge, EventEffectKind.TrackWear);
/// <summary>
/// Usura del binario dovuta al traffico sull'arco (ConstructionSystem): il sistema la applica al
/// mattino al traffico del giorno prima, quindi conta il maltempo in vigore ieri.
/// </summary>
public double EdgeWear(TrackEdge edge) => _areaEvents == 0 ? 1.0 : AreaEffect(edge, EventEffectKind.TrackWear, Today - 1);
private double AreaEffect(TrackEdge edge, EventEffectKind kind)
private double AreaEffect(TrackEdge edge, EventEffectKind kind, long day)
{
int mid = edge.X.Length / 2;
var p = new Vec2(edge.X[mid], edge.Y[mid]);
double f = 1.0;
foreach (var e in _active)
{
if (e.Def.Target == EventTarget.Area && e.InZone(p)) f *= e.Effect(kind);
if (e.Def.Target == EventTarget.Area && e.InForce(day) && e.InZone(p)) f *= e.Effect(kind);
}
return f;
}
@@ -213,6 +213,14 @@ public static class EventTests
a.RunDays(1);
b.RunDays(1);
CheckAttendance(a, b, town, 0.2, "sciopero");
// le stime dell'IA (ADR 0017 §9) contano i presenti senza lo sciopero: come nel gemello
foreach (var ind in a.Industries)
{
var twin = b.Industries[ind.Id.Value];
Assert.Approx(twin.WorkersPresent, EmploymentSystem.PresentWithoutEvents(a, ind, PaxClass.Worker), 1e-9, $"presenti senza eventi a {ind.Name}");
Assert.Approx(twin.StaffPresent, EmploymentSystem.PresentWithoutEvents(a, ind, PaxClass.Staff), 1e-9, $"personale senza eventi a {ind.Name}");
Assert.Equal(twin.WorkersPresent, EmploymentSystem.PresentWithoutEvents(b, twin, PaxClass.Worker), "senza eventi è il valore del giorno");
}
var sb = b.Towns[town.Id.Value];
Assert.SequenceEqual(sb.DemandToday, town.DemandToday, "lo sciopero non cambia i consumi");
a.RunDays(3);
@@ -271,10 +279,15 @@ public static class EventTests
Assert.Approx(4.0, wear, 1e-12);
Assert.False(ev.InZone(new Vec2(1e7, 1e7)), "lontano dall'area");
// il maltempo è in vigore da oggi: l'usura del traffico di oggi si applica domattina, moltiplicata;
// stessa usura del traffico nei due mondi: con il maltempo l'arco perde «wear» volte di più
a.RunDays(1);
b.RunDays(1);
var edges = a.Network.Edges.Where(e => e.State == EdgeState.Active).ToList();
var before = new Dictionary<int, (double A, double B)>();
foreach (var e in edges)
{
before[e.Id.Value] = (e.Condition, b.Network.Edges[e.Id.Value].Condition);
e.WearToday = 2000;
b.Network.Edges[e.Id.Value].WearToday = 2000;
}
@@ -286,7 +299,7 @@ public static class EventTests
double factor = a.WorldEvents.EdgeWear(e);
Assert.True(factor == 1.0 || Math.Abs(factor - wear) < 1e-12, "fattore dell'arco");
Assert.Approx(factor == 1.0 ? 1.0 : speed, a.WorldEvents.EdgeSpeed(e), 1e-12, "velocità dell'arco");
double dropA = 100 - e.Condition, dropB = 100 - b.Network.Edges[e.Id.Value].Condition;
double dropA = before[e.Id.Value].A - e.Condition, dropB = before[e.Id.Value].B - b.Network.Edges[e.Id.Value].Condition;
Assert.True(dropB > 0, "il traffico consuma il binario");
Assert.Approx(dropB * factor, dropA, 1e-9, $"usura dell'arco {e.Id.Value}");
if (factor > 1) affected++;
@@ -378,16 +391,17 @@ public static class EventTests
Assert.Equal(EventSeverity.Warning, news.Severity);
Assert.Equal(EntityKind.Industry, news.Entity);
Assert.True(news.Text.Contains(mine.Name, StringComparison.Ordinal) && news.Text.Contains("10 giorni", StringComparison.Ordinal) && news.Text.Contains("0%", StringComparison.Ordinal), news.Text);
Assert.Equal(w.Calendar.DateOfDay(ev.EndDay - 1).ToString(), EventSystem.Format(w, ev, "{until}"), "{until} è l'ultimo giorno dell'evento");
int stoppedDays = 0;
for (int d = 0; d < 12; d++)
{
w.RunDays(1);
if (mine.Efficiency == 0) stoppedDays++;
Assert.Equal(d < 9, w.WorldEvents.Active.Contains(ev), $"giorno {d}: evento in corso");
Assert.Equal(d < 10, w.WorldEvents.Active.Contains(ev), $"giorno {d}: evento in elenco");
}
Assert.Equal(10, stoppedDays, "dieci giorni di produzione nulla");
var end = WorldNews(w).Last();
Assert.Equal(start + 9, end.Day, "la notizia di fine arriva la sera dell'ultimo giorno");
Assert.Equal(start + 10, end.Day, "la notizia di fine arriva il mattino del primo giorno libero");
Assert.True(end.Text.Contains("riprende", StringComparison.Ordinal), end.Text);
Assert.Equal(2, WorldNews(w).Count);
}
@@ -409,6 +423,90 @@ public static class EventTests
Assert.Approx(0.5 * 1.5, w.WorldEvents.IndustryCapacity(mine.Id), 1e-12, "incidente e boom insieme: la capacità è il prodotto dei due");
}
[Test(Description = "Zone: niente due maltempi né due eventi sulla domanda dello stesso bene su zone sovrapposte; zone lontane o beni diversi sono ammessi")]
public static void OverlappingZonesAreRefused()
{
var w = Generated(31, 0);
w.RunDays(1);
var boom = w.Data.EventType("good_demand_boom")!;
double r = boom.RadiusKm!.Value * 1000;
// due città abbastanza vicine da condividere la zona e un bene consumato da entrambe
var (x, y, good) = (from p in w.Towns
from q in w.Towns
where p.Id.Value < q.Id.Value && (p.Position - q.Position).LengthSquared <= 4 * r * r
from g in boom.GoodIndices
where DemandSystem.TownDemand(w, p, g, w.Clock.Year) > 0 && DemandSystem.TownDemand(w, q, g, w.Clock.Year) > 0
select (p, q, g)).First();
var first = EventSystem.Force(w, "good_demand_boom", x.Id.Value, good, durationDays: 30)!;
Assert.True(EventSystem.Force(w, "good_demand_boom", y.Id.Value, good, durationDays: 30) is null, "boom dello stesso bene su una zona sovrapposta");
Assert.True(EventSystem.Force(w, "good_demand_slump", y.Id.Value, good, durationDays: 30) is null, "boom e crollo dello stesso bene insieme");
int other = boom.GoodIndices.FirstOrDefault(g => g != good && DemandSystem.TownDemand(w, y, g, w.Clock.Year) > 0, -1);
if (other >= 0) Assert.NotNull(EventSystem.Force(w, "good_demand_boom", y.Id.Value, other, durationDays: 30), "un altro bene è ammesso");
foreach (var t in w.Towns)
{
double expected = (t.Position - x.Position).LengthSquared <= r * r ? first.Primary : 1.0;
Assert.Approx(expected, w.WorldEvents.TownDemand(t, good), 1e-12, $"un solo moltiplicatore a {t.Name}");
}
var storm = w.Data.EventType("storm")!;
double rs = storm.RadiusKm!.Value * 1000;
var near = w.Towns.First(t => t.Id != x.Id && (t.Position - x.Position).LengthSquared <= 4 * rs * rs);
var far = w.Towns.FirstOrDefault(t => (t.Position - x.Position).LengthSquared > 4 * rs * rs);
Assert.NotNull(EventSystem.Force(w, "storm", x.Id.Value, durationDays: 5));
Assert.True(EventSystem.Force(w, "storm", near.Id.Value, durationDays: 5) is null, "due maltempi su zone sovrapposte");
if (far is not null) Assert.NotNull(EventSystem.Force(w, "storm", far.Id.Value, durationDays: 5), "maltempo lontano ammesso");
}
/// <summary>Porta il mondo al primo tick del giorno dopo, già eseguito (come quando il server manda il resoconto).</summary>
private static void NextDayAfterFirstTick(World w)
{
do w.RunTicks(1);
while (w.Clock.TickOfDay != 0);
w.RunTicks(1);
}
[Test(Description = "Maltempo estratto a giornata iniziata: treni, usura e resoconto al client seguono i giorni annunciati, con il conto alla rovescia da n a 1")]
public static void StormWindowMatchesTheAnnouncedDays()
{
var f = Valdoria();
f.BuildFreightNetwork();
var w = f.W;
w.RunDays(1);
w.RunTicks(1); // giorno D, dopo i sistemi giornalieri: l'evento inizia domani
long draw = w.Clock.Day;
var town = TownNamed(w, "Valdoria");
var ev = EventSystem.Force(w, "storm", town.Id.Value, durationDays: 3, intensity: 1.0)!;
Assert.Equal(draw + 1, ev.StartDay);
var edge = w.Network.Edges.First(e => e.State == EdgeState.Active && ev.InZone(new Vec2(e.X[e.X.Length / 2], e.Y[e.Y.Length / 2])));
double speed = ev.Effect(EventEffectKind.TrainSpeed), wear = ev.Effect(EventEffectKind.TrackWear);
Assert.Equal(1.0, w.WorldEvents.EdgeSpeed(edge), "il giorno dell'estrazione i treni non rallentano");
WorldEventInfo Listed() => RailEnterprise.Server.Projection.Digest(w, w.Player, [], false, 1, 0).WorldEvents.Single();
Assert.True(Listed().StartDay > w.Clock.Day, "il resoconto del giorno dell'estrazione lo mostra in partenza");
int Ends() => WorldNews(w).Count(n => n.Text.Contains("sereno", StringComparison.Ordinal));
for (int k = 0; k < 3; k++)
{
NextDayAfterFirstTick(w);
Assert.Equal(speed, w.WorldEvents.EdgeSpeed(edge), $"giorno {k + 1}: treni rallentati");
// l'usura applicata oggi è del traffico di ieri: moltiplicata dal secondo giorno
Assert.Equal(k == 0 ? 1.0 : wear, w.WorldEvents.EdgeWear(edge), $"giorno {k + 1}: usura");
Assert.Equal(3L - k, Listed().EndDay - w.Clock.Day, $"giorno {k + 1}: giorni che restano");
Assert.Equal(0, Ends(), "nessuna notizia di fine prima del tempo");
}
// primo giorno libero, prima del suo primo tick: l'usura dell'ultimo giorno di maltempo è ancora moltiplicata
do w.RunTicks(1);
while (w.Clock.TickOfDay != 0);
Assert.Equal(ev.EndDay, w.Clock.Day);
Assert.Equal(wear, w.WorldEvents.EdgeWear(edge), "usura del traffico dell'ultimo giorno");
Assert.Equal(1.0, w.WorldEvents.EdgeSpeed(edge), "il primo giorno libero i treni vanno normali");
w.RunTicks(1);
Assert.Equal(0, RailEnterprise.Server.Projection.Digest(w, w.Player, [], false, 1, 0).WorldEvents.Count, "fuori dal resoconto");
var end = WorldNews(w).Last();
Assert.Equal(ev.EndDay, end.Day, "la notizia di fine il primo giorno libero");
Assert.Equal(1, Ends(), end.Text);
AssertInvariants(w, "maltempo");
}
[Test(Description = "Con la frequenza a zero (scenari di accettazione) non nasce nessun evento; la difficoltà scala la frequenza")]
public static void FrequencyZeroMeansNoEvents()
{
@@ -511,11 +609,23 @@ public static class EventTests
Assert.True(active.Count <= w.Data.Events.MaxActive, $"giorno {d}: {active.Count} eventi");
var keys = active.Select(e => (e.Def.Id, e.TargetKind, e.Target)).ToList();
Assert.Equal(keys.Count, keys.Distinct().Count(), $"giorno {d}: doppioni");
for (int i = 0; i < active.Count; i++)
{
for (int j = i + 1; j < active.Count; j++)
{
var (x, y) = (active[i], active[j]);
if (x.Def.Target != y.Def.Target || x.Good != y.Good || x.Def.RadiusKm is not { } rx || y.Def.RadiusKm is not { } ry) continue;
double reach = (rx + ry) * 1000;
Assert.True((x.Center - y.Center).LengthSquared > reach * reach, $"giorno {d}: zone sovrapposte di {x.Def.Id} e {y.Def.Id}");
}
}
// giorno appena giocato: Clock.Day − 1; quelli estratti ieri iniziano oggi
long last = w.Clock.Day - 1;
foreach (var e in active)
{
types.Add(e.Def.Id);
Assert.True(e.DurationDays >= e.Def.DurationDays[0] && e.DurationDays <= e.Def.DurationDays[1], $"{e.Def.Id}: durata");
Assert.True(e.StartDay <= w.Clock.Day && w.Clock.Day < e.EndDay, $"{e.Def.Id}: in corso oggi");
Assert.True(e.InForce(last) || e.StartDay == last + 1, $"{e.Def.Id}: in vigore ieri o in partenza oggi");
Assert.InRange(e.Intensity, 0, 1, "intensità");
}
if (d % 30 == 29) AssertInvariants(w, $"giorno {d}");