F6: eventi del mondo, correzioni della revisione
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:
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
|
||||
|
@@ -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;
|
||||
}
|
||||
|
||||
@@ -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
@@ -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
@@ -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
|
||||
|
||||
@@ -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
|
||||
{
|
||||
|
||||
@@ -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}");
|
||||
|
||||
Reference in new issue
Block a user