- 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
632 lines
35 KiB
C#
632 lines
35 KiB
C#
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;
|
||
}
|
||
}
|