Files
Rail_Enterprise/src/ViaFerrea.Core/Simulation/RailCommandHandlers.cs
T
Claude b6c326b79c F4: manutenzione della flotta, officine, ricambi via treno e pendolarismo completo nel motore
- FleetMaintenanceSystem: usura per componente in km di servizio, rischio e guasti
  (lieve, grave con soccorso, deragliamento), pianificatore predittivo con scelta del
  deposito, officine con stalli, ricambi e personale, riserve, avvisi.
- Depositi come posti di lavoro; motivi dei posti scoperti; convenzioni di pendolarismo.
- Ricambi consegnati alle officine nel bacino e importati dagli hub.
- Inversione di marcia in stazione come sosta tecnica e transito in stazione che libera
  l'arco d'arrivo (eliminano due stalli della circolazione).
- Salvataggio versione 2 con migrazione dalla versione 1; test di 14.5 e accettazione F4.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_0191R7vXgtbAvSV4V8tj8uzL
2026-10-02 01:39:38 +00:00

632 lines
35 KiB
C#
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
using ViaFerrea.Core.Commands;
using ViaFerrea.Core.Common;
using ViaFerrea.Core.Data;
using ViaFerrea.Core.Economy;
using ViaFerrea.Core.Map;
using ViaFerrea.Core.Rail;
using ViaFerrea.Core.Simulation.Systems;
namespace ViaFerrea.Core.Simulation;
/// <summary>Esecuzione dei comandi ferroviari. Ogni gestore valida tutto prima di modificare il mondo.</summary>
public static class RailCommandHandlers
{
public delegate CommandResult Reply(CommandError error, string message, params int[] created);
/// <summary>Moltiplicatore dei costi di costruzione di una compagnia (difficoltà e sconto IA).</summary>
public static double CostMultiplier(World w, Company company) =>
w.Difficulty.ConstructionCostMultiplier * (company.IsPlayer ? 1.0 : 1.0 - w.Difficulty.AiCostDiscount);
/// <summary>Ingressi dell'anteprima ricavati dal mondo autorevole.</summary>
public static TrackPreviewInputs PreviewInputs(World w, Company company) => new()
{
Data = w.Data,
Sampler = w.Sampler,
Network = w.Network,
Year = w.Clock.Year,
CostMultiplier = CostMultiplier(w, company),
NearestTownEdgeKm = p => w.Towns.Count == 0 ? double.MaxValue : w.Towns.Min(t => w.TownEdgeDistanceKm(t, p)),
};
/// <summary>Contesto del pianificatore per una compagnia (difficoltà e sconto IA inclusi).</summary>
public static TrackPlanContext PlanContext(World w, Company company, ITrackObstacles? obstacles = null) =>
TrackPreview.Context(PreviewInputs(w, company), obstacles);
/// <summary>Prepara il piano di un binario come farebbe il comando (stesso codice dell'anteprima del client).</summary>
public static (TrackPlan Plan, AttachPoint Start, AttachPoint End) PreparePlan(World w, Company company, BuildTrackCommand c) =>
TrackPreview.Prepare(PreviewInputs(w, company), company.Id, c);
public static CommandResult BuildTrack(World w, Company company, BuildTrackCommand c, Reply reply)
{
if (c.Polyline.Count < 2) return reply(CommandError.InvalidArgument, "Servono almeno due punti");
var (plan, start, end) = PreparePlan(w, company, c);
if (!plan.Valid) return reply(CommandError.InvalidTrack, plan.Errors[0].Message);
if (c.ExpectedCostCents != 0 && c.ExpectedCostCents != plan.TotalCost.Cents)
return reply(CommandError.PreviewMismatch, $"Il costo calcolato dal server ({plan.TotalCost}) differisce dall'anteprima");
if (start.Node.IsValid && start.Node == end.Node) return reply(CommandError.InvalidTrack, "Le estremità coincidono");
foreach (var a in new[] { start, end })
{
if (a.SplitEdge.IsValid && !RailNetwork.IsFree(w.Network.Edges[a.SplitEdge.Value]))
return reply(CommandError.Blocked, "Il binario da raccordare è occupato da un treno");
}
if (company.Cash < plan.TotalCost) return reply(CommandError.InsufficientFunds, $"Servono {plan.TotalCost}, in cassa {company.Cash}");
var net = w.Network;
NodeId Resolve(AttachPoint a)
{
if (a.Node.IsValid) return a.Node;
if (a.SplitEdge.IsValid)
{
// ricerca di nuovo: un'altra divisione può aver spostato i campioni
var again = net.FindAttach(a.Position, company.Id, 1.0, 0);
if (again.Node.IsValid) return again.Node;
var edge = net.Edges[again.SplitEdge.IsValid ? again.SplitEdge.Value : a.SplitEdge.Value];
return net.SplitEdge(edge, again.SplitEdge.IsValid ? again.SplitIndex : a.SplitIndex).Id;
}
return net.AddNode(a.Position, w.Sampler.HeightAt(a.Position), company.Id).Id;
}
var na = Resolve(start);
var nb = Resolve(end);
int classIndex = w.Data.Eras.TrackClasses.First(t => t.Id == c.TrackClass).Index;
var edgeObj = net.AddEdge(na, nb, company.Id, plan, classIndex, w.Clock.Day);
var project = new ConstructionProject
{
Id = net.NextProject++,
Owner = company.Id,
Kind = ProjectKind.NewTrack,
Edges = [edgeObj.Id],
TotalDays = Math.Max(1, plan.Days),
QueuedDay = w.Clock.Day,
Works = plan.Works.ToList(),
};
edgeObj.Project = project.Id;
net.Projects.Add(project);
w.Money.Transfer(Account.Of(company.Id), Account.External, plan.TotalCost, LedgerEntry.Construction);
return reply(CommandError.None, $"Cantiere aperto: {plan.LengthM / 1000:F1} km, {plan.TotalCost}, {plan.Days} giorni",
edgeObj.Id.Value, na.Value, nb.Value, project.Id);
}
public static CommandResult BuildStation(World w, Company company, BuildStationCommand c, Reply reply)
{
var sp = w.Data.Construction.Stations;
if (c.Platforms < 1 || c.Platforms > sp.MaxPlatforms) return reply(CommandError.InvalidArgument, $"Binari di stazione tra 1 e {sp.MaxPlatforms}");
if (!InsideMap(w, c.Position)) return reply(CommandError.InvalidArgument, "Fuori dalla mappa");
var type = w.Sampler.TypeAt(c.Position);
if (type is CellType.Water or CellType.Sea or CellType.Town or CellType.Industry)
return reply(CommandError.NotAllowed, "La stazione deve stare su terreno libero, fuori da città e industrie");
if (w.Network.Stations.Any(s => w.Network.IsAlive(s) && Vec2.Distance(s.Position, c.Position) < sp.AreaRadiusM * 2)
|| w.Network.Depots.Any(d => w.Network.IsAlive(d) && Vec2.Distance(d.Position, c.Position) < sp.AreaRadiusM * 2))
return reply(CommandError.NotAllowed, "Troppo vicino a un'altra stazione o deposito");
var attach = w.Network.FindAttach(c.Position, company.Id, sp.SnapM, 0);
if (attach.Node.IsValid)
{
var n = w.Network.Nodes[attach.Node.Value];
if (n.Station.IsValid || n.Depot.IsValid) return reply(CommandError.NotAllowed, "Il nodo ha già una stazione o un deposito");
}
if (attach.SplitEdge.IsValid && !RailNetwork.IsFree(w.Network.Edges[attach.SplitEdge.Value]))
return reply(CommandError.Blocked, "Il binario è occupato da un treno");
var cost = new Money(w.Data.Construction.Costs.StationBase + w.Data.Construction.Costs.StationPerPlatform * c.Platforms)
* CostMultiplier(w, company);
if (company.Cash < cost) return reply(CommandError.InsufficientFunds, $"Servono {cost}");
var node = attach.Node.IsValid ? w.Network.Nodes[attach.Node.Value]
: attach.SplitEdge.IsValid ? w.Network.SplitEdge(w.Network.Edges[attach.SplitEdge.Value], attach.SplitIndex)
: w.Network.AddNode(c.Position, w.Sampler.HeightAt(c.Position), company.Id);
string name = c.Name ?? DefaultName(w, node.Position, "Stazione");
var station = new Station
{
Id = new StationId(w.Network.Stations.Count),
Owner = company.Id,
Name = name,
Node = node.Id,
Position = node.Position,
Platforms = c.Platforms,
PlatformTrain = Enumerable.Repeat(-1, c.Platforms).ToArray(),
BuiltDay = w.Clock.Day,
BuildCostCents = cost.Cents,
Incoming = new int[w.Data.GoodCount],
};
node.Station = station.Id;
w.Network.Stations.Add(station);
w.NextIds.Station = w.Network.Stations.Count;
UpdateCatchment(w, station);
w.Network.Touch();
w.Money.Transfer(Account.Of(company.Id), Account.External, cost, LedgerEntry.Construction);
return reply(CommandError.None, $"Stazione {name} costruita ({c.Platforms} binari)", station.Id.Value, node.Id.Value);
}
public static CommandResult BuildDepot(World w, Company company, BuildDepotCommand c, Reply reply)
{
var costs = w.Data.Construction.Costs;
var sp = w.Data.Construction.Stations;
if (!costs.DepotBySize.TryGetValue(c.Size, out long baseCost)) return reply(CommandError.InvalidArgument, "Dimensione del deposito: small, medium o large");
if (!InsideMap(w, c.Position)) return reply(CommandError.InvalidArgument, "Fuori dalla mappa");
var type = w.Sampler.TypeAt(c.Position);
if (type is CellType.Water or CellType.Sea or CellType.Town or CellType.Industry)
return reply(CommandError.NotAllowed, "Il deposito deve stare su terreno libero");
if (w.Network.Stations.Any(s => w.Network.IsAlive(s) && Vec2.Distance(s.Position, c.Position) < sp.AreaRadiusM * 2)
|| w.Network.Depots.Any(d => w.Network.IsAlive(d) && Vec2.Distance(d.Position, c.Position) < sp.AreaRadiusM * 2))
return reply(CommandError.NotAllowed, "Troppo vicino a un'altra stazione o deposito");
var attach = w.Network.FindAttach(c.Position, company.Id, sp.SnapM, 0);
if (attach.Node.IsValid && (w.Network.Nodes[attach.Node.Value].Station.IsValid || w.Network.Nodes[attach.Node.Value].Depot.IsValid))
return reply(CommandError.NotAllowed, "Il nodo ha già una stazione o un deposito");
if (attach.SplitEdge.IsValid && !RailNetwork.IsFree(w.Network.Edges[attach.SplitEdge.Value]))
return reply(CommandError.Blocked, "Il binario è occupato da un treno");
var cost = new Money(baseCost) * CostMultiplier(w, company);
if (company.Cash < cost) return reply(CommandError.InsufficientFunds, $"Servono {cost}");
var node = attach.Node.IsValid ? w.Network.Nodes[attach.Node.Value]
: attach.SplitEdge.IsValid ? w.Network.SplitEdge(w.Network.Edges[attach.SplitEdge.Value], attach.SplitIndex)
: w.Network.AddNode(c.Position, w.Sampler.HeightAt(c.Position), company.Id);
string name = c.Name ?? DefaultName(w, node.Position, "Deposito");
var depot = new Depot
{
Id = new DepotId(w.Network.Depots.Count),
Owner = company.Id,
Name = name,
Node = node.Id,
Position = node.Position,
Size = c.Size,
BuiltDay = w.Clock.Day,
BuildCostCents = cost.Cents,
SpareParts = w.Data.Maintenance.Depots.InitialSpareParts,
PartsTarget = w.Data.Maintenance.Depots.TargetSpareParts,
};
InitDepot(w.Data, depot);
// la scorta iniziale è compresa nel prezzo del deposito
w.Goods.Imported[w.Data.SparePartsGood] += depot.SpareParts;
node.Depot = depot.Id;
w.Network.Depots.Add(depot);
w.NextIds.Depot = w.Network.Depots.Count;
foreach (var st in w.Network.Stations)
{
if (st.Owner == company.Id && w.Network.IsAlive(st) && Vec2.Distance(st.Position, depot.Position) <= sp.CatchmentKm * 1000)
UpdateCatchment(w, st);
}
w.Network.Touch();
w.Money.Transfer(Account.Of(company.Id), Account.External, cost, LedgerEntry.Construction);
return reply(CommandError.None, $"{name} costruito", depot.Id.Value, node.Id.Value);
}
/// <summary>Stalli e posti di lavoro del deposito secondo la dimensione (maintenance.json).</summary>
public static void InitDepot(GameData data, Depot depot)
{
var dp = data.Maintenance.Depots;
depot.Stalls = dp.StallsBySize.GetValueOrDefault(depot.Size, 0);
depot.JobsStaff = depot.Stalls * dp.StaffPerStall;
depot.JobsWorkers = depot.Stalls * dp.JobsWorkersPerStall;
}
public static CommandResult PlaceSignal(World w, Company company, PlaceSignalCommand c, Reply reply)
{
if (!TryEdge(w, c.Edge, company, out var edge)) return reply(CommandError.NotFound, "Binario inesistente");
if (edge.State != EdgeState.Active) return reply(CommandError.NotAllowed, "Binario non in esercizio");
if (c.PositionM < 50 || c.PositionM > edge.Length - 50) return reply(CommandError.InvalidArgument, "Il segnale deve stare ad almeno 50 m dalle estremità");
if (edge.Signals.Any(s => Math.Abs(s - c.PositionM) < 100)) return reply(CommandError.InvalidArgument, "Troppo vicino a un altro segnale");
if (!RailNetwork.IsFree(edge)) return reply(CommandError.Blocked, "Binario occupato: riprova quando è libero");
var type = w.Data.Eras.Signals.Where(s => s.From <= w.Clock.Year).OrderByDescending(s => s.From).FirstOrDefault();
if (type is null) return reply(CommandError.EraLocked, "Nessun segnale disponibile");
var cost = new Money(type.Price);
if (company.Cash < cost) return reply(CommandError.InsufficientFunds, $"Servono {cost}");
int i = 0;
while (i < edge.Signals.Count && edge.Signals[i] < c.PositionM) i++;
edge.Signals.Insert(i, c.PositionM);
edge.ResetBlocks();
w.Network.Touch();
w.Money.Transfer(Account.Of(company.Id), Account.External, cost, LedgerEntry.Construction);
return reply(CommandError.None, $"{type.NameIt} posato");
}
public static CommandResult Demolish(World w, Company company, DemolishCommand c, Reply reply)
{
var net = w.Network;
double refundShare = w.Data.Construction.Costs.DemolitionRefund;
switch (c.Target)
{
case DemolishTarget.Edge:
{
if (!TryEdge(w, new EdgeId(c.Id), company, out var edge)) return reply(CommandError.NotFound, "Binario inesistente");
if (edge.State == EdgeState.Demolished) return reply(CommandError.NotFound, "Già demolito");
if (!RailNetwork.IsFree(edge)) return reply(CommandError.Blocked, "Binario occupato da un treno");
if (edge.Project >= 0 && !net.Projects[edge.Project].Done) net.Projects[edge.Project].Done = true;
edge.State = EdgeState.Demolished;
net.Nodes[edge.A.Value].Edges.Remove(edge.Id);
net.Nodes[edge.B.Value].Edges.Remove(edge.Id);
net.Touch();
var refund = new Money(edge.BuildCostCents) * refundShare;
w.Money.Transfer(Account.External, Account.Of(company.Id), refund, LedgerEntry.Construction);
return reply(CommandError.None, $"Binario demolito, recuperati {refund}");
}
case DemolishTarget.Signal:
{
if (!TryEdge(w, new EdgeId(c.Id), company, out var edge)) return reply(CommandError.NotFound, "Binario inesistente");
if (!RailNetwork.IsFree(edge)) return reply(CommandError.Blocked, "Binario occupato da un treno");
edge.Signals.Clear();
edge.ResetBlocks();
net.Touch();
return reply(CommandError.None, "Segnali rimossi");
}
case DemolishTarget.Station:
{
if (c.Id < 0 || c.Id >= net.Stations.Count || net.Stations[c.Id].Owner != company.Id) return reply(CommandError.NotFound, "Stazione inesistente");
var st = net.Stations[c.Id];
var node = net.Nodes[st.Node.Value];
if (node.Station != st.Id) return reply(CommandError.NotFound, "Stazione già demolita");
if (st.PlatformTrain.Any(t => t >= 0)) return reply(CommandError.Blocked, "Ci sono treni in stazione");
if (w.Lines.Any(l => !l.Removed && l.Stops.Any(s => s.Station == st.Id))) return reply(CommandError.NotAllowed, "La stazione è fermata di una linea");
if (st.Waiting.Any(p => p.Kind == PacketKind.Freight))
{
foreach (var p in st.Waiting.Where(p => p.Kind == PacketKind.Freight)) w.Goods.Decayed[p.Good] += p.Units;
}
st.Waiting.Clear();
node.Station = StationId.None;
st.Industries.Clear();
st.Towns.Clear();
st.Hubs.Clear();
st.Depots.Clear();
net.Touch();
var refund = new Money(st.BuildCostCents) * refundShare;
w.Money.Transfer(Account.External, Account.Of(company.Id), refund, LedgerEntry.Construction);
return reply(CommandError.None, $"Stazione demolita, recuperati {refund}");
}
default:
{
if (c.Id < 0 || c.Id >= net.Depots.Count || net.Depots[c.Id].Owner != company.Id) return reply(CommandError.NotFound, "Deposito inesistente");
var depot = net.Depots[c.Id];
var node = net.Nodes[depot.Node.Value];
if (node.Depot != depot.Id) return reply(CommandError.NotFound, "Deposito già demolito");
if (w.Vehicles.Any(v => !v.Sold && v.Depot == depot.Id) || w.Trains.Any(t => !t.Removed && t.AtNode == depot.Node))
return reply(CommandError.Blocked, "Ci sono veicoli nel deposito");
if (depot.Jobs.Count > 0) return reply(CommandError.Blocked, "L'officina ha lavori in corso");
node.Depot = DepotId.None;
// prenotazioni verso l'officina demolita: il pianificatore ne sceglierà un'altra
foreach (var t in w.Trains)
{
if (!t.Removed && t.MaintenanceDepot == depot.Id && !t.InWorkshop) FleetMaintenanceSystem.CancelBooking(t);
if (!t.Removed && t.GoingToDepot == depot.Id) t.GoingToDepot = DepotId.None;
}
foreach (var st in net.Stations) st.Depots.Remove(depot.Id);
net.Touch();
var refund = new Money(depot.BuildCostCents) * refundShare;
w.Money.Transfer(Account.External, Account.Of(company.Id), refund, LedgerEntry.Construction);
return reply(CommandError.None, $"Deposito demolito, recuperati {refund}");
}
}
}
public static CommandResult RenewTrack(World w, Company company, RenewTrackCommand c, Reply reply)
{
if (!TryEdge(w, c.Edge, company, out var edge)) return reply(CommandError.NotFound, "Binario inesistente");
if (edge.State != EdgeState.Active) return reply(CommandError.NotAllowed, "Binario non in esercizio");
if (!RailNetwork.IsFree(edge)) return reply(CommandError.Blocked, "Binario occupato da un treno");
var tw = w.Data.Construction.TrackWear;
var cost = new Money(edge.BuildCostCents) * tw.RenewalCostShare;
if (company.Cash < cost) return reply(CommandError.InsufficientFunds, $"Servono {cost}");
double days = Math.Max(1, Math.Ceiling(edge.Length / 1000 * tw.RenewalDaysPerKm));
StartProject(w, company, edge, ProjectKind.Renewal, days);
w.Money.Transfer(Account.Of(company.Id), Account.External, cost, LedgerEntry.TrackMaintenance);
return reply(CommandError.None, $"Rinnovo avviato: {days:F0} giorni di chiusura, {cost}");
}
public static CommandResult UpgradeTrack(World w, Company company, UpgradeTrackCommand c, Reply reply)
{
if (!TryEdge(w, c.Edge, company, out var edge)) return reply(CommandError.NotFound, "Binario inesistente");
if (edge.State != EdgeState.Active) return reply(CommandError.NotAllowed, "Binario non in esercizio");
if (!RailNetwork.IsFree(edge)) return reply(CommandError.Blocked, "Binario occupato da un treno");
var cls = w.Data.Eras.TrackClasses.FirstOrDefault(t => t.Id == c.TrackClass);
if (cls is null) return reply(CommandError.InvalidArgument, "Classe sconosciuta");
if (cls.From > w.Clock.Year) return reply(CommandError.EraLocked, $"{cls.NameIt} disponibile dal {cls.From}");
if (c.Electrified && w.Data.Eras.ElectrificationFrom > w.Clock.Year) return reply(CommandError.EraLocked, "Elettrificazione non ancora disponibile");
var costs = w.Data.Construction.Costs;
var speedClasses = w.Data.Construction.SpeedClasses;
double oldMult = speedClasses.First(s => s.TrackClass == w.Data.Eras.TrackClasses[edge.TrackClass].Id).CostMultiplier;
double newMult = speedClasses.First(s => s.TrackClass == cls.Id).CostMultiplier;
// il raggio delle curve esistenti deve bastare alla nuova classe
double minRadius = speedClasses.First(s => s.TrackClass == cls.Id).MinRadiusM;
double baseCost = edge.Length * costs.BasePerMeter * w.Difficulty.ConstructionCostMultiplier;
double extra = Math.Max(0, newMult - oldMult) * baseCost
+ (c.DoubleTrack && !edge.DoubleTrack ? (costs.DoubleTrackMultiplier - 1) * baseCost * newMult : 0)
+ (c.Electrified && !edge.Electrified ? costs.ElectrificationExtra * baseCost * newMult : 0);
if (extra <= 0 && cls.Index == edge.TrackClass) return reply(CommandError.InvalidArgument, "Nessuna modifica");
var cost = Money.FromCentsRounded(extra);
if (company.Cash < cost) return reply(CommandError.InsufficientFunds, $"Servono {cost}");
double days = Math.Max(1, Math.Ceiling(edge.Length / w.Data.Construction.Crews.MetersPerDay["natural"]));
StartProject(w, company, edge, ProjectKind.Upgrade, days, cls.Index, c.DoubleTrack || edge.DoubleTrack, c.Electrified || edge.Electrified);
w.Money.Transfer(Account.Of(company.Id), Account.External, cost, LedgerEntry.Construction);
_ = minRadius;
return reply(CommandError.None, $"Ammodernamento avviato: {days:F0} giorni, {cost}");
}
private static void StartProject(World w, Company company, TrackEdge edge, ProjectKind kind, double days,
int upgradeClass = -1, bool upgradeDouble = false, bool upgradeElectrified = false)
{
var net = w.Network;
var project = new ConstructionProject
{
Id = net.NextProject++,
Owner = company.Id,
Kind = kind,
Edges = [edge.Id],
TotalDays = days,
QueuedDay = w.Clock.Day,
UpgradeClass = upgradeClass,
UpgradeDouble = upgradeDouble,
UpgradeElectrified = upgradeElectrified,
};
edge.Project = project.Id;
edge.State = EdgeState.Closed;
net.Projects.Add(project);
net.Touch();
}
public static CommandResult BuyVehicle(World w, Company company, BuyVehicleCommand c, Reply reply)
{
if (!w.Data.TryVehicle(c.VehicleType, out var def) || def is null) return reply(CommandError.NotFound, "Veicolo sconosciuto");
if (c.Count < 1 || c.Count > 50) return reply(CommandError.InvalidArgument, "Quantità tra 1 e 50");
int year = w.Clock.Year;
if (def.EraFrom > year || (def.EraTo is { } to && year > to)) return reply(CommandError.EraLocked, $"{def.NameIt} non è in produzione nel {year}");
if (!c.Depot.IsValid || c.Depot.Value >= w.Network.Depots.Count || w.Network.Depots[c.Depot.Value].Owner != company.Id)
return reply(CommandError.NotFound, "Deposito inesistente");
if (w.Network.Nodes[w.Network.Depots[c.Depot.Value].Node.Value].Depot != c.Depot) return reply(CommandError.NotFound, "Deposito demolito");
var cost = new Money(def.Price) * c.Count;
if (company.Cash < cost) return reply(CommandError.InsufficientFunds, $"Servono {cost}");
var created = new int[c.Count];
for (int i = 0; i < c.Count; i++)
{
var v = new Vehicle
{
Id = new VehicleId(w.Vehicles.Count),
Def = def,
Owner = company.Id,
BoughtDay = w.Clock.Day,
Depot = c.Depot,
};
Fleet.InitVehicle(w.Data, v, w.Clock.Day);
w.Vehicles.Add(v);
created[i] = v.Id.Value;
}
w.NextIds.Vehicle = w.Vehicles.Count;
w.Money.Transfer(Account.Of(company.Id), Account.External, cost, LedgerEntry.VehiclePurchase);
return reply(CommandError.None, $"Acquistati {c.Count} × {def.NameIt}", created);
}
public static CommandResult SellVehicle(World w, Company company, SellVehicleCommand c, Reply reply)
{
if (!c.Vehicle.IsValid || c.Vehicle.Value >= w.Vehicles.Count) return reply(CommandError.NotFound, "Veicolo inesistente");
var v = w.Vehicles[c.Vehicle.Value];
if (v.Owner != company.Id || v.Sold) return reply(CommandError.NotFound, "Veicolo inesistente");
if (v.Train.IsValid) return reply(CommandError.NotAllowed, "Il veicolo fa parte di un treno: scomponilo prima");
var value = ResaleValue(w, v);
v.Sold = true;
v.Depot = DepotId.None;
w.Money.Transfer(Account.External, Account.Of(company.Id), value, LedgerEntry.VehicleSale);
return reply(CommandError.None, $"Venduto per {value}");
}
/// <summary>Valore di rivendita: prezzo × (1 − età/vita, minimo 10 %) × condizione media.</summary>
public static Money ResaleValue(World w, Vehicle v)
{
double ageYears = (w.Clock.Day - v.BoughtDay) / (double)w.Calendar.DaysPerYear;
double residual = Math.Max(w.Data.Balance.Finance.BookValueFloor, 1 - ageYears / v.Def.LifeYears);
double condition = v.Components.Length == 0 ? 1 : v.Components.Average() / 100;
return new Money(v.Def.Price) * (residual * condition);
}
public static CommandResult ComposeTrain(World w, Company company, ComposeTrainCommand c, Reply reply)
{
var ops = w.Data.Construction.Operations;
if (c.Vehicles.Count == 0 || c.Vehicles.Count > ops.MaxVehiclesPerTrain) return reply(CommandError.InvalidArgument, $"Da 1 a {ops.MaxVehiclesPerTrain} veicoli");
if (!c.Depot.IsValid || c.Depot.Value >= w.Network.Depots.Count || w.Network.Depots[c.Depot.Value].Owner != company.Id)
return reply(CommandError.NotFound, "Deposito inesistente");
if (c.Vehicles.Distinct().Count() != c.Vehicles.Count) return reply(CommandError.InvalidArgument, "Veicoli ripetuti");
foreach (var id in c.Vehicles)
{
if (!id.IsValid || id.Value >= w.Vehicles.Count) return reply(CommandError.NotFound, "Veicolo inesistente");
var v = w.Vehicles[id.Value];
if (v.Owner != company.Id || v.Sold) return reply(CommandError.NotFound, "Veicolo inesistente");
if (v.Train.IsValid || v.Depot != c.Depot) return reply(CommandError.NotAllowed, $"{v.Def.NameIt} non è libero in questo deposito");
}
if (!c.Vehicles.Any(id => w.Vehicles[id.Value].Def.Kind == VehicleKind.Locomotive))
return reply(CommandError.InvalidArgument, "Serve almeno una locomotiva");
var depot = w.Network.Depots[c.Depot.Value];
var train = new Train
{
Id = new TrainId(w.Trains.Count),
Owner = company.Id,
Name = c.Name ?? $"Treno {w.Trains.Count(t => t.Owner == company.Id) + 1}",
HomeDepot = c.Depot,
AtNode = depot.Node,
};
foreach (var id in c.Vehicles)
{
train.Vehicles.Add(id);
var v = w.Vehicles[id.Value];
v.Train = train.Id;
v.Depot = DepotId.None;
}
RecomputeTrain(w, train);
w.Trains.Add(train);
w.NextIds.Train = w.Trains.Count;
w.LineGraphs.Touch();
return reply(CommandError.None, $"{train.Name} composto: {train.LengthM:F0} m, {train.EmptyMassT:F0} t, {train.MaxSpeedKmh:F0} km/h", train.Id.Value);
}
/// <summary>Ricalcola le caratteristiche fisiche del treno dalla composizione.</summary>
public static void RecomputeTrain(World w, Train t)
{
var cx = w.Data.Construction.Physics.CxByKind;
double mass = 0, locoMass = 0, power = 0, te = 0, length = 0, drag = 0, vmax = double.MaxValue, capacity = 0;
bool electric = false;
int locos = 0;
foreach (var id in t.Vehicles)
{
var d = w.Vehicles[id.Value].Def;
mass += d.MassT;
length += d.LengthM;
vmax = Math.Min(vmax, d.MaxSpeedKmh);
drag += cx[d.Kind.ToString().ToLowerInvariant()];
capacity += (d.Capacity ?? 0) + (d.PaxCapacity ?? 0) * w.Data.Construction.Physics.PassengerMassT;
if (d.Kind != VehicleKind.Locomotive) continue;
locos++;
locoMass += d.MassT;
power += d.PowerKw;
te += d.TractiveEffortKn;
if (d.Traction is { } tr && w.Data.Eras.Tractions.First(x => x.Id == tr).NeedsElectrification) electric = true;
}
t.EmptyMassT = mass;
t.LocoMassT = locoMass;
t.PowerKw = power;
t.TractiveKn = te;
t.LengthM = length;
t.Cx = drag;
t.MaxSpeedKmh = vmax == double.MaxValue ? 0 : vmax;
t.NeedsElectrification = electric;
t.Locomotives = locos;
t.CapacityT = capacity;
}
public static CommandResult CreateLine(World w, Company company, CreateLineCommand c, Reply reply)
{
var error = ValidateStops(w, company, c.Stops);
if (error is not null) return reply(CommandError.InvalidArgument, error);
var line = new Line
{
Id = new LineId(w.Lines.Count),
Owner = company.Id,
Name = string.IsNullOrWhiteSpace(c.Name) ? $"Linea {w.Lines.Count(l => l.Owner == company.Id) + 1}" : c.Name,
Color = c.Color,
};
line.Stops.AddRange(c.Stops);
w.Lines.Add(line);
w.NextIds.Line = w.Lines.Count;
w.LineGraphs.Touch();
return reply(CommandError.None, $"{line.Name} creata con {line.Stops.Count} fermate", line.Id.Value);
}
public static CommandResult EditLine(World w, Company company, EditLineCommand c, Reply reply)
{
if (!c.Line.IsValid || c.Line.Value >= w.Lines.Count || w.Lines[c.Line.Value].Owner != company.Id || w.Lines[c.Line.Value].Removed)
return reply(CommandError.NotFound, "Linea inesistente");
var error = ValidateStops(w, company, c.Stops);
if (error is not null) return reply(CommandError.InvalidArgument, error);
var line = w.Lines[c.Line.Value];
line.Stops.Clear();
line.Stops.AddRange(c.Stops);
if (c.Name is not null) line.Name = c.Name;
foreach (var t in w.Trains.Where(t => t.Line == line.Id && t.StopIndex >= line.Stops.Count)) t.StopIndex = 0;
w.LineGraphs.Touch();
return reply(CommandError.None, $"{line.Name} aggiornata");
}
private static string? ValidateStops(World w, Company company, IReadOnlyList<LineStop> stops)
{
if (stops.Count < 2) return "Una linea ha almeno due fermate";
foreach (var s in stops)
{
if (!s.Station.IsValid || s.Station.Value >= w.Network.Stations.Count) return "Stazione inesistente";
var st = w.Network.Stations[s.Station.Value];
if (st.Owner != company.Id || w.Network.Nodes[st.Node.Value].Station != st.Id) return "Stazione inesistente";
if (s.MaxWaitDays < 0 || s.MaxWaitDays > 60) return "Attesa massima tra 0 e 60 giorni";
}
return null;
}
public static CommandResult AssignTrain(World w, Company company, AssignTrainCommand c, Reply reply)
{
if (!TryTrain(w, c.Train, company, out var train)) return reply(CommandError.NotFound, "Treno inesistente");
if (c.Line.IsValid && (c.Line.Value >= w.Lines.Count || w.Lines[c.Line.Value].Owner != company.Id || w.Lines[c.Line.Value].Removed))
return reply(CommandError.NotFound, "Linea inesistente");
// un'assegnazione esplicita chiude la copertura di una riserva
if (train.Covering.IsValid)
{
var covered = w.Trains[train.Covering.Value];
if (covered.CoveredBy == train.Id) covered.CoveredBy = TrainId.None;
train.Covering = TrainId.None;
}
if (c.Line.IsValid) train.Reserve = false;
train.Line = c.Line;
train.StopIndex = 0;
if (!train.MaintenanceDepot.IsValid || train.GoingToDepot != train.MaintenanceDepot) train.GoingToDepot = DepotId.None;
if (train.State == TrainState.NoRoute) train.State = TrainState.Waiting;
w.LineGraphs.Touch();
return reply(CommandError.None, c.Line.IsValid ? $"{train.Name} assegnato a {w.Lines[c.Line.Value].Name}" : $"{train.Name} tolto dal servizio");
}
public static CommandResult SendToDepot(World w, Company company, SendToDepotCommand c, Reply reply)
{
if (!TryTrain(w, c.Train, company, out var train)) return reply(CommandError.NotFound, "Treno inesistente");
if (!c.Depot.IsValid || c.Depot.Value >= w.Network.Depots.Count || w.Network.Depots[c.Depot.Value].Owner != company.Id)
return reply(CommandError.NotFound, "Deposito inesistente");
if (train.InWorkshop) return reply(CommandError.NotAllowed, $"{train.Name} è in officina");
if (train.State == TrainState.Broken) return reply(CommandError.NotAllowed, $"{train.Name} attende il soccorso");
// il rientro voluto dal giocatore sostituisce l'intervento prenotato (il pianificatore lo riproporrà)
FleetMaintenanceSystem.CancelBooking(train);
if (train.Covering.IsValid)
{
var covered = w.Trains[train.Covering.Value];
if (covered.CoveredBy == train.Id) covered.CoveredBy = TrainId.None;
train.Covering = TrainId.None;
}
train.GoingToDepot = c.Depot;
train.Line = LineId.None;
if (train.State == TrainState.NoRoute) train.State = TrainState.Waiting;
w.LineGraphs.Touch();
return reply(CommandError.None, $"{train.Name} diretto al deposito");
}
/// <summary>Ricalcola il bacino di una stazione (industrie, città, hub entro il raggio).</summary>
public static void UpdateCatchment(World w, Station s)
{
double km = w.Data.Construction.Stations.CatchmentKm;
s.Industries.Clear();
s.Towns.Clear();
s.Hubs.Clear();
s.Depots.Clear();
if (w.Network.Nodes[s.Node.Value].Station != s.Id) return;
foreach (var i in w.Industries)
{
if (!i.Closed && Vec2.Distance(i.Position, s.Position) <= km * 1000) s.Industries.Add(i.Id);
}
foreach (var t in w.Towns)
{
if (w.TownEdgeDistanceKm(t, s.Position) <= km) s.Towns.Add(t.Id);
}
foreach (var h in w.Hubs)
{
if (Vec2.Distance(h.Position, s.Position) <= km * 1000) s.Hubs.Add(h.Id);
}
foreach (var d in w.Network.Depots)
{
if (d.Owner == s.Owner && w.Network.IsAlive(d) && Vec2.Distance(d.Position, s.Position) <= km * 1000) s.Depots.Add(d.Id);
}
}
private static string DefaultName(World w, Vec2 p, string kind)
{
if (w.Towns.Count == 0) return kind;
var town = w.Towns.MinBy(t => w.TownEdgeDistanceKm(t, p))!;
string name = $"{kind} di {town.Name}";
int n = 2;
while (w.Network.Stations.Any(s => s.Name == name) || w.Network.Depots.Any(d => d.Name == name)) name = $"{kind} di {town.Name} {n++}";
return name;
}
private static bool InsideMap(World w, Vec2 p) => p.X >= 0 && p.Y >= 0 && p.X < w.Terrain.WidthM && p.Y < w.Terrain.HeightM;
private static bool TryEdge(World w, EdgeId id, Company company, out TrackEdge edge)
{
edge = null!;
if (!id.IsValid || id.Value >= w.Network.Edges.Count) return false;
edge = w.Network.Edges[id.Value];
return edge.Owner == company.Id;
}
private static bool TryTrain(World w, TrainId id, Company company, out Train train)
{
train = null!;
if (!id.IsValid || id.Value >= w.Trains.Count) return false;
train = w.Trains[id.Value];
return train.Owner == company.Id && !train.Removed;
}
}