341 lines
13 KiB
C
341 lines
13 KiB
C
// Owned and ticked by HQ. Initial assets are authored once; losses are never replaced.
|
|
class ERR_MortarSystem
|
|
{
|
|
protected ERR_HQ m_HQ;
|
|
protected ref array<ref ERR_MortarBattery> m_Batteries = {};
|
|
protected ref ERR_SettlementSafety m_Settlements = new ERR_SettlementSafety();
|
|
protected bool m_Prepared;
|
|
protected bool m_Stopped;
|
|
protected float m_NextDecision;
|
|
protected float m_NextRefreshDecision;
|
|
string SafetyReason;
|
|
string SettlementReason;
|
|
|
|
void ERR_MortarSystem(ERR_HQ hq) { m_HQ = hq; }
|
|
static ERR_MortarSystem Get()
|
|
{
|
|
ERR_HQ hq = ERR_HQ.Get();
|
|
if (!hq || !Replication.IsServer()) return null;
|
|
return hq.Mortars();
|
|
}
|
|
static bool NearPlayer(vector position)
|
|
{
|
|
array<IEntity> players = {};
|
|
ERR_Actors.Players(players);
|
|
foreach (IEntity player : players)
|
|
if (vector.DistanceXZ(player.GetOrigin(), position) <= 1200) return true;
|
|
return false;
|
|
}
|
|
bool Prepare()
|
|
{
|
|
if (!Replication.IsServer() || m_Prepared || m_Stopped) return false;
|
|
m_Prepared = true;
|
|
vector position = ERR_Actors.Ground("6000 0 7000");
|
|
if (position[1] < 1) return false;
|
|
IEntity gun = ERR_Actors.Spawn(ERR_MortarBattery.GUN, position);
|
|
SCR_AIGroup group = SCR_AIGroup.Cast(ERR_Actors.Spawn(MortarGroup(), ERR_Actors.Ground(position + "0 0 4")));
|
|
if (!gun || !group)
|
|
{
|
|
ERR_Actors.DeleteSpawned(gun);
|
|
ERR_MortarReadiness.RetireGroup(group);
|
|
ERR_Actors.DeleteSpawned(group);
|
|
return false;
|
|
}
|
|
if (group.GetFaction() != ERR_GameMode.Get().EnemyFaction())
|
|
{
|
|
ERR_Actors.DeleteSpawned(gun);
|
|
ERR_MortarReadiness.RetireGroup(group);
|
|
ERR_Actors.DeleteSpawned(group);
|
|
return false;
|
|
}
|
|
FactionAffiliationComponent affiliation = FactionAffiliationComponent.Cast(gun.FindComponent(FactionAffiliationComponent));
|
|
if (affiliation) affiliation.SetAffiliatedFaction(ERR_GameMode.Get().EnemyFaction());
|
|
ERR_MortarBattery battery = new ERR_MortarBattery();
|
|
battery.Bind(1, group, gun, GetGame().GetWorld().GetWorldTime());
|
|
m_Batteries.Insert(battery);
|
|
ERR_GameMode mode = ERR_GameMode.Get();
|
|
mode.Own(gun);
|
|
mode.RegisterGroup(group);
|
|
m_HQ.ReserveGroup(group);
|
|
battery.Audit("DEPLOY", "authored gun and four-person crew; finite ammunition initialization pending");
|
|
return true;
|
|
}
|
|
static ResourceName MortarGroup() { return "{B84C05941C4C81B8}Prefabs/ERR/MortarCrew.et"; }
|
|
void Batteries(out array<ref ERR_MortarBattery> batteries)
|
|
{
|
|
batteries.Clear();
|
|
foreach (ERR_MortarBattery battery : m_Batteries) batteries.Insert(battery);
|
|
}
|
|
ERR_MortarBattery FindGun(IEntity gun)
|
|
{
|
|
foreach (ERR_MortarBattery battery : m_Batteries)
|
|
if (gun && battery.Gun == gun) return battery;
|
|
return null;
|
|
}
|
|
ERR_MortarBattery FindGroup(SCR_AIGroup group)
|
|
{
|
|
foreach (ERR_MortarBattery battery : m_Batteries)
|
|
if (group && battery.Group == group) return battery;
|
|
return null;
|
|
}
|
|
ERR_HQReport Latest(ERR_MortarBattery battery, float now)
|
|
{
|
|
// Only the coordinates actually delivered to this battery are available.
|
|
// A newer HQ contact cannot update a gun's knowledge without another downlink.
|
|
if (!battery || !ERR_MortarPrediction.Fresh(battery.Report, now)) return null;
|
|
return battery.Report;
|
|
}
|
|
string ContactFailure(ERR_MortarBattery battery)
|
|
{
|
|
if (!battery.Report) return "no delivered target report";
|
|
return "delivered target report expired or invalid";
|
|
}
|
|
// Classify only after SupplyState has observed any accepted inventory move.
|
|
// Report expiry must not be mislabeled as physical ammunition depletion.
|
|
string SupplyFailure(ERR_MortarBattery battery, float now)
|
|
{
|
|
if (!Latest(battery, now)) return ContactFailure(battery);
|
|
return "next native load lacks confirmed physical gunner ammunition";
|
|
}
|
|
bool OutsideSettlements(vector impact)
|
|
{
|
|
bool clear = m_Settlements.OutsideSettlements(impact);
|
|
SettlementReason = m_Settlements.SettlementReason;
|
|
return clear;
|
|
}
|
|
bool Safe(ERR_MortarBattery battery, vector impact, float flight)
|
|
{
|
|
SafetyReason = "clear";
|
|
if (!battery.Operational()) { SafetyReason = battery.OperationalReason(); return false; }
|
|
if (!OutsideSettlements(impact)) { SafetyReason = SettlementReason; return false; }
|
|
if (SCR_TerrainHelper.GetTerrainY(impact) < 0) { SafetyReason = "impact below Everon sea level"; return false; }
|
|
Faction faction = battery.Group.GetFaction();
|
|
if (!faction) { SafetyReason = "battery faction missing"; return false; }
|
|
array<IEntity> friendlies = {};
|
|
m_HQ.PhysicalForces(friendlies);
|
|
foreach (IEntity entity : friendlies)
|
|
{
|
|
Faction friendly = SCR_FactionManager.SGetFaction(entity);
|
|
if (!friendly || faction.IsFactionEnemy(friendly) || !ERR_Actors.Alive(entity)) continue;
|
|
vector velocity;
|
|
IEntity moving = CompartmentAccessComponent.GetVehicleIn(entity);
|
|
if (!moving) moving = entity;
|
|
if (moving.GetPhysics()) velocity = moving.GetPhysics().GetVelocity();
|
|
if (ERR_MortarPrediction.ThreatensFriendly(impact, entity.GetOrigin(), velocity, flight))
|
|
{
|
|
SafetyReason = "friendly physical force can enter the impact area";
|
|
return false;
|
|
}
|
|
}
|
|
return true;
|
|
}
|
|
bool Withhold(ERR_MortarBattery battery, string reason, string detail = "")
|
|
{
|
|
battery.LastFailure = reason + "; " + detail;
|
|
battery.Trace("WITHHELD", reason, detail);
|
|
// Finish the activity from the next HQ tick, never from inside its own node.
|
|
battery.Rejected = true;
|
|
return false;
|
|
}
|
|
bool AllowShot(ERR_MortarBattery battery)
|
|
{
|
|
float now = GetGame().GetWorld().GetWorldTime();
|
|
if (m_Stopped || !ERR_HQ.MissionActive()) return Withhold(battery, "mission inactive or HQ stopped");
|
|
if (!battery.Operational()) return Withhold(battery, battery.OperationalReason());
|
|
if (battery.RefreshRejected) return Withhold(battery, "target update failed; order awaiting cancellation");
|
|
if (!battery.CommandOpen || battery.OrderShots >= ERR_MortarSalvo.ROUNDS) return Withhold(battery, "salvo complete or order closed");
|
|
if (battery.Released) return Withhold(battery, "waiting for committed projectile");
|
|
if (battery.AimedShot != battery.OrderShots || battery.AimedAt < 0 || now < battery.AimedAt) return Withhold(battery, "fresh aim solution required");
|
|
ERR_HQReport report = Latest(battery, now);
|
|
if (!report) return Withhold(battery, ContactFailure(battery));
|
|
if (!battery.AimSolution || !battery.AimSolution.Matches(battery, report)) return Withhold(battery, "aim command does not match delivered order");
|
|
if (battery.AimValidatedAt < battery.AimedAt || now < battery.AimValidatedAt) return Withhold(battery, "aim validation timestamp invalid");
|
|
if (now - battery.AimValidatedAt > 10000)
|
|
{
|
|
if (!battery.AimSolver) return Withhold(battery, "original native aim solver no longer available");
|
|
if (!battery.AimSolver.ERR_RevalidateAim(battery, this, report, now)) return false;
|
|
}
|
|
vector updated;
|
|
if (!ERR_MortarPrediction.Predict(report, now, battery.FlightTime, updated)) return Withhold(battery, ERR_MortarPrediction.FailureReason);
|
|
updated += battery.AimOffset;
|
|
if (vector.DistanceXZ(updated, battery.Impact) > 60) return Withhold(battery, "predicted target left aimed impact area");
|
|
if (!OutsideSettlements(updated)) return Withhold(battery, SettlementReason);
|
|
if (!Safe(battery, battery.Impact, battery.FlightTime)) return Withhold(battery, SafetyReason);
|
|
return true;
|
|
}
|
|
protected void AdvanceOrder(ERR_MortarBattery battery, float now)
|
|
{
|
|
if (battery.RadioOrder)
|
|
{
|
|
int deliveredState = battery.RadioOrder.Advance(now, m_HQ.Journal());
|
|
if (deliveredState == 0) return;
|
|
ERR_HQReport delivered = battery.PendingRadioReport;
|
|
battery.RadioOrder = null;
|
|
battery.PendingRadioReport = null;
|
|
if (deliveredState < 0 || !ERR_MortarPrediction.Fresh(delivered, now) || !battery.Operational() || battery.Activity || !battery.CommandOpen)
|
|
{
|
|
battery.Cancel("radio delivery, report freshness or battery availability failed");
|
|
battery.NextOrder = now + 10000;
|
|
return;
|
|
}
|
|
battery.PendingSupplyReport = delivered;
|
|
}
|
|
if (!battery.PendingSupplyReport) return;
|
|
if (!battery.CommandOpen || !ERR_MortarPrediction.Fresh(battery.PendingSupplyReport, now) || !battery.Operational() || battery.Activity)
|
|
{
|
|
battery.Cancel("delivered order expired or became unavailable while awaiting physical ammunition");
|
|
battery.NextOrder = now + 10000;
|
|
return;
|
|
}
|
|
ERR_MortarSupplyState supply = battery.SupplyState(now);
|
|
if (supply == ERR_MortarSupplyState.PENDING) return;
|
|
if (supply == ERR_MortarSupplyState.FAILED)
|
|
{
|
|
battery.Cancel("physical gunner ammunition unavailable or transfer failed");
|
|
battery.NextOrder = now + 10000;
|
|
return;
|
|
}
|
|
ERR_HQReport ready = battery.PendingSupplyReport;
|
|
battery.PendingSupplyReport = null;
|
|
battery.Order(ready, now);
|
|
}
|
|
|
|
protected void AdvanceRefresh(ERR_MortarBattery battery, float now)
|
|
{
|
|
ERR_MortarRefresh update = battery.Refresh;
|
|
if (!update) return;
|
|
// A stale transaction must not cancel or modify a later order.
|
|
if (update.OrderId != battery.OrderId || !battery.CommandOpen)
|
|
{
|
|
battery.Refresh = null;
|
|
return;
|
|
}
|
|
if (!update.Owns(battery) || !battery.Operational() || !battery.Activity || !ERR_MortarRefreshRules.Newer(battery.Report, update.Report, now))
|
|
{
|
|
battery.RejectRefresh("target update ownership, observation freshness or activity changed");
|
|
return;
|
|
}
|
|
if (update.Route)
|
|
{
|
|
int state = update.Route.Advance(now, m_HQ.Journal());
|
|
if (state == 0) return;
|
|
if (state < 0)
|
|
{
|
|
battery.RejectRefresh("new target observation failed physical HQ radio delivery");
|
|
return;
|
|
}
|
|
update.Route = null;
|
|
}
|
|
// The original committed shell owns its report, geometry and airspace until
|
|
// native OnWeaponFired confirms it. A delivered update cannot relabel it.
|
|
if (battery.Released) return;
|
|
if (battery.AimSolution)
|
|
{
|
|
if (!battery.AimSolver || !battery.AimSolver.ERR_AdoptReport(battery, this, update.Report, now))
|
|
{
|
|
battery.RejectRefresh("delivered update cannot preserve the original native aim command");
|
|
return;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
// No barrel command exists for the next shell yet. Its normal native aim
|
|
// node must solve this report; receiving it is not an aim authorization.
|
|
battery.Report = update.Report;
|
|
}
|
|
battery.Audit("UPDATE RECEIVED", string.Format("same order; update radio=M%1 accepted observation=M%2 observed=%3; shots=%4 original aim time=%5", update.RadioId, update.Report.MessageId, update.Report.ObservedAt, battery.OrderShots, battery.AimedAt));
|
|
battery.Refresh = null;
|
|
}
|
|
|
|
protected void QueueRefreshes(float now)
|
|
{
|
|
if (now < m_NextRefreshDecision) return;
|
|
m_NextRefreshDecision = now + 5000;
|
|
array<ref ERR_HQReport> reports = {};
|
|
m_HQ.SupportContacts(reports, now);
|
|
foreach (ERR_MortarBattery battery : m_Batteries)
|
|
{
|
|
ERR_HQReport newest;
|
|
foreach (ERR_HQReport report : reports)
|
|
{
|
|
if (!battery.CanRefresh(report, now)) continue;
|
|
if (!newest || report.ObservedAt > newest.ObservedAt) newest = report;
|
|
}
|
|
if (!newest) continue;
|
|
ERR_HQRoute route = m_HQ.Downlink(battery.Group, "MORTAR UPDATE", newest.Description(now), newest.MessageId);
|
|
if (!route)
|
|
{
|
|
battery.RejectRefresh("HQ has a newer observation but no physical downlink to the active battery");
|
|
continue;
|
|
}
|
|
battery.BeginRefresh(newest, route, now);
|
|
}
|
|
}
|
|
|
|
void Tick(float now)
|
|
{
|
|
if (m_Stopped || !Replication.IsServer()) return;
|
|
foreach (ERR_MortarBattery battery : m_Batteries)
|
|
{
|
|
if ((battery.Rejected || battery.RefreshRejected) && !battery.Released)
|
|
{
|
|
battery.Cancel("native aim or firing authorization rejected");
|
|
battery.NextOrder = now + 10000;
|
|
}
|
|
battery.Rejected = false;
|
|
battery.Update(now);
|
|
AdvanceOrder(battery, now);
|
|
AdvanceRefresh(battery, now);
|
|
}
|
|
QueueRefreshes(now);
|
|
if (now < m_NextDecision) return;
|
|
m_NextDecision = now + 10000;
|
|
array<ref ERR_HQReport> reports = {};
|
|
m_HQ.SupportContacts(reports, now);
|
|
ERR_MortarBattery selected;
|
|
ERR_HQReport target;
|
|
float distance = float.MAX;
|
|
foreach (ERR_MortarBattery battery : m_Batteries)
|
|
{
|
|
if (!battery.StartupActivated || !battery.Operational() || battery.Activity || battery.RadioOrder || battery.PendingSupplyReport || battery.SupplyPending() || now < battery.NextOrder || battery.CountShells() == 0) continue;
|
|
foreach (ERR_HQReport report : reports)
|
|
{
|
|
if (!battery.CanRequest(report, now)) continue;
|
|
float candidate = vector.DistanceXZ(battery.Position, report.Position);
|
|
if (candidate < 350 || candidate > 4000 || candidate >= distance || !OutsideSettlements(report.Position)) continue;
|
|
selected = battery;
|
|
target = report;
|
|
distance = candidate;
|
|
}
|
|
}
|
|
if (!selected || !target) return;
|
|
ERR_HQRoute route = m_HQ.Downlink(selected.Group, "MORTAR ORDER", target.Description(now), target.MessageId);
|
|
if (!route) return;
|
|
if (!selected.BeginRequest(target, now)) return;
|
|
selected.RadioId = route.MessageId;
|
|
selected.RadioOrder = route;
|
|
selected.PendingRadioReport = target.Snapshot();
|
|
m_NextDecision = now + 20000;
|
|
}
|
|
void AppendGuns(array<IEntity> entities)
|
|
{
|
|
foreach (ERR_MortarBattery battery : m_Batteries)
|
|
if (battery.Gun && !entities.Contains(battery.Gun)) entities.Insert(battery.Gun);
|
|
}
|
|
string Status()
|
|
{
|
|
int ready, shells;
|
|
foreach (ERR_MortarBattery battery : m_Batteries)
|
|
{
|
|
if (battery.StartupActivated && battery.Operational()) ready++;
|
|
shells += battery.CountShells();
|
|
}
|
|
return string.Format("mortars %1/%2; HE shells %3", ready, m_Batteries.Count(), shells);
|
|
}
|
|
void Stop()
|
|
{
|
|
m_Stopped = true;
|
|
foreach (ERR_MortarBattery battery : m_Batteries) battery.Stop();
|
|
}
|
|
}
|