348 lines
19 KiB
C
348 lines
19 KiB
C
class ERR_MortarSupplyStatus
|
|
{
|
|
SCR_AIGroup Group;
|
|
IEntity Gun;
|
|
vector Position;
|
|
float ObservedAt;
|
|
int MessageId;
|
|
int Shells;
|
|
}
|
|
class ERR_MortarLogisticsRules
|
|
{
|
|
static bool Fresh(float observedAt, float now) { return observedAt >= 0 && now >= observedAt && now - observedAt <= 180000; }
|
|
static bool Need(int shells) { return shells >= 0 && shells <= 6; }
|
|
static bool NewRequest(int message, int consumed, bool fresh) { return fresh && message > 0 && message > consumed; }
|
|
static bool Near(float distance) { return distance >= 0 && distance <= 12; }
|
|
static bool ActiveTrip(bool server, bool stopped, int trip, int current, bool fresh, bool ownershipValid) { return server && !stopped && trip > 0 && trip == current && fresh && ownershipValid; }
|
|
}
|
|
// One finite western-cache courier, owned and ticked exclusively by HQ.
|
|
class ERR_MortarLogistics
|
|
{
|
|
protected ERR_HQ m_HQ;
|
|
protected ERR_GameMode m_Mode;
|
|
protected ERR_SiteRuntime m_Site;
|
|
protected IEntity m_Cache;
|
|
protected SCR_AIGroup m_Group;
|
|
protected ERR_MortarBattery m_Battery;
|
|
protected IEntity m_OriginalGun;
|
|
protected SCR_AIGroup m_OriginalBatteryGroup;
|
|
protected ref array<IEntity> m_BatteryMembers = {};
|
|
protected ref array<IEntity> m_OriginalMembers = {};
|
|
protected ref array<IEntity> m_Stock = {};
|
|
protected ref array<IEntity> m_Cargo = {};
|
|
protected ref array<IEntity> m_AttemptedPickup = {};
|
|
protected ref array<IEntity> m_AttemptedUnload = {};
|
|
protected ref array<ref ERR_MortarInitialItem> m_Initial = {};
|
|
protected ref ERR_MortarSupplyStatus m_Report;
|
|
protected ref ERR_HQRoute m_Order;
|
|
protected ref ERR_MortarCourierTransfer m_Move;
|
|
protected IEntity m_Courier;
|
|
protected AIWaypoint m_Waypoint;
|
|
protected AIWaypoint m_HoldWaypoint;
|
|
protected float m_InitialDeadline;
|
|
protected float m_NextReport;
|
|
protected float m_LastDeliveryAt = -1;
|
|
protected int m_ConsumedMessage;
|
|
protected int m_Trip;
|
|
protected int m_State; // 0 initial, 1 idle, 2 downlink, 3 pickup, 4 travel, 5 unload
|
|
protected int m_Delivered;
|
|
protected int m_CompletedTrips;
|
|
protected bool m_Started;
|
|
protected bool m_Stopped;
|
|
protected string m_Reason;
|
|
static const int INITIAL_SHELLS = 12;
|
|
static const int TRIP_SHELLS = 6;
|
|
void ERR_MortarLogistics(ERR_HQ hq, ERR_GameMode mode) { m_HQ = hq; m_Mode = mode; }
|
|
int State() { return m_State; }
|
|
int Trip() { return m_Trip; }
|
|
int Delivered() { return m_Delivered; }
|
|
int CompletedTrips() { return m_CompletedTrips; }
|
|
IEntity Cache() { return m_Cache; }
|
|
SCR_AIGroup Group() { return m_Group; }
|
|
IEntity Courier() { return m_Courier; }
|
|
ERR_MortarBattery Battery() { return m_Battery; }
|
|
ERR_MortarSupplyStatus Report() { return m_Report; }
|
|
bool Stopped() { return m_Stopped; }
|
|
void InitialStock(out array<IEntity> items) { items.Copy(m_Stock); }
|
|
protected void Audit(string kind, string reason)
|
|
{
|
|
int message; if (m_Report) message = m_Report.MessageId;
|
|
m_Reason = reason;
|
|
m_HQ.Journal().Write("COURIER " + kind, string.Format("trip=%1 state=%2 delivered=%3; %4", m_Trip, m_State, m_Delivered, reason), message);
|
|
}
|
|
protected InventoryStorageManagerComponent Inventory(IEntity entity)
|
|
{
|
|
if (!entity) return null;
|
|
return InventoryStorageManagerComponent.Cast(entity.FindComponent(InventoryStorageManagerComponent));
|
|
}
|
|
protected bool Contains(IEntity owner, IEntity shell)
|
|
{
|
|
InventoryStorageManagerComponent inventory = Inventory(owner);
|
|
if (!inventory || !shell) return false;
|
|
array<IEntity> items = {}; ERR_Inventory.Items(inventory, items); return items.Contains(shell);
|
|
}
|
|
protected void Shells(IEntity owner, out array<IEntity> shells)
|
|
{
|
|
shells.Clear(); InventoryStorageManagerComponent inventory = Inventory(owner); if (!inventory) return;
|
|
array<IEntity> items = {}; ERR_Inventory.Items(inventory, items);
|
|
foreach (IEntity item : items)
|
|
if (item && item.GetPrefabData() && item.GetPrefabData().GetPrefabName() == ERR_MortarBattery.SHELL) shells.Insert(item);
|
|
}
|
|
bool Prepare()
|
|
{
|
|
if (!Replication.IsServer() || m_Started || m_Stopped) return false;
|
|
m_Started = true;
|
|
ERR_ScenarioComponent scenario = ERR_ScenarioComponent.Cast(m_Mode.FindComponent(ERR_ScenarioComponent));
|
|
if (!scenario || !scenario.Sites()) return false;
|
|
m_Site = scenario.Sites().Find("everon-supply-2");
|
|
if (!m_Site || !m_Site.Group || !m_Site.PatrolCycle || !scenario.Sites().Owns(m_Site.Container)) return false;
|
|
m_Cache = m_Site.Container; m_Group = m_Site.Group;
|
|
array<ref ERR_MortarBattery> batteries = {}; m_HQ.Mortars().Batteries(batteries);
|
|
if (batteries.Count() != 1) return false;
|
|
m_Battery = batteries[0]; m_OriginalGun = m_Battery.Gun; m_OriginalBatteryGroup = m_Battery.Group;
|
|
InventoryStorageManagerComponent inventory = Inventory(m_Cache);
|
|
if (!inventory || !inventory.CanInsertResource(ERR_MortarBattery.SHELL, EStoragePurpose.PURPOSE_DEPOSIT)) return false;
|
|
array<IEntity> existing = {}; Shells(m_Cache, existing); if (!existing.IsEmpty()) return false;
|
|
array<AIAgent> agents = {}; m_Group.GetAgents(agents);
|
|
foreach (AIAgent agent : agents)
|
|
{
|
|
if (!agent || !ERR_Actors.CanFight(agent.GetControlledEntity())) return false;
|
|
m_OriginalMembers.Insert(agent.GetControlledEntity());
|
|
}
|
|
if (m_OriginalMembers.Count() != m_Site.InitialGuardCount) return false;
|
|
m_InitialDeadline = GetGame().GetWorld().GetWorldTime() + 15000;
|
|
// SiteService owns this existing cache and its contents through rollback/world teardown.
|
|
// This bounded startup allocation is never reopened, including partial failure/theft.
|
|
for (int i = 0; i < INITIAL_SHELLS; i++)
|
|
{
|
|
IEntity shell = ERR_Actors.Spawn(ERR_MortarBattery.SHELL, m_Cache.GetOrigin());
|
|
if (!shell) return false;
|
|
// Keep the exact created identity; counts cannot prove an external item was
|
|
// not substituted while an asynchronous insertion was pending.
|
|
m_Mode.Own(shell); m_Stock.Insert(shell);
|
|
ERR_MortarInitialItem operation = new ERR_MortarInitialItem(); m_Initial.Insert(operation);
|
|
if (!inventory.TryInsertItem(shell, EStoragePurpose.PURPOSE_DEPOSIT, operation)) { operation.Rejected(); return false; }
|
|
}
|
|
return true;
|
|
}
|
|
protected bool OriginalGroup()
|
|
{
|
|
if (!m_Site || m_Site.Group != m_Group || m_Site.Container != m_Cache || !m_Group || !m_Cache || m_Group.GetPlayerCount(true) > 0 || m_Group.GetFaction() != m_Mode.EnemyFaction()) return false;
|
|
array<AIAgent> agents = {}; m_Group.GetAgents(agents); bool living;
|
|
foreach (AIAgent agent : agents)
|
|
{
|
|
if (!agent || !agent.GetControlledEntity()) continue;
|
|
IEntity actor = agent.GetControlledEntity();
|
|
if (!m_OriginalMembers.Contains(actor) || ERR_Actors.Player(actor) || ERR_Actors.Group(actor) != m_Group || SCR_FactionManager.SGetFaction(actor) != m_Mode.EnemyFaction()) return false;
|
|
if (ERR_Actors.CanFight(actor)) living = true;
|
|
}
|
|
return living;
|
|
}
|
|
protected bool BindBatteryMembers()
|
|
{
|
|
if (!m_Battery || !m_Battery.StartupActivated || m_Battery.Group != m_OriginalBatteryGroup || m_Battery.Gun != m_OriginalGun) return false;
|
|
if (!m_BatteryMembers.IsEmpty()) return true;
|
|
array<AIAgent> agents = {}; m_Battery.Group.GetAgents(agents);
|
|
foreach (AIAgent agent : agents)
|
|
if (agent && agent.GetControlledEntity() && !m_BatteryMembers.Contains(agent.GetControlledEntity())) m_BatteryMembers.Insert(agent.GetControlledEntity());
|
|
return !m_BatteryMembers.IsEmpty();
|
|
}
|
|
bool TargetAvailable()
|
|
{
|
|
if (!m_Battery || m_Battery.Gun != m_OriginalGun || m_Battery.Group != m_OriginalBatteryGroup || !m_OriginalGun || !m_Battery.StartupActivated || m_Battery.Stopped() || !m_Battery.Operational() || m_HQ.Mortars().FindGun(m_OriginalGun) != m_Battery || m_BatteryMembers.IsEmpty()) return false;
|
|
if (SCR_FactionManager.SGetFaction(m_OriginalGun) != m_Mode.EnemyFaction()) return false;
|
|
SCR_AIVehicleUsageComponent usage = SCR_AIVehicleUsageComponent.Cast(m_OriginalGun.FindComponent(SCR_AIVehicleUsageComponent));
|
|
if (!usage || !usage.GetTurretCompartmentSlot()) return false;
|
|
IEntity occupant = usage.GetTurretCompartmentSlot().GetOccupant();
|
|
if (!occupant) return true;
|
|
return m_BatteryMembers.Contains(occupant) && ERR_Actors.CanFight(occupant) && !ERR_Actors.Player(occupant) && ERR_Actors.Group(occupant) == m_OriginalBatteryGroup && SCR_FactionManager.SGetFaction(occupant) == m_Mode.EnemyFaction();
|
|
}
|
|
bool CanSample(ERR_MortarBattery battery) { return battery == m_Battery && TargetAvailable(); }
|
|
protected bool Bearer(IEntity actor)
|
|
{
|
|
return actor && m_OriginalMembers.Contains(actor) && ERR_Actors.Group(actor) == m_Group && ERR_Actors.CanFight(actor) && !ERR_Actors.Player(actor) && !CompartmentAccessComponent.GetVehicleIn(actor) && SCR_FactionManager.SGetFaction(actor) == m_Mode.EnemyFaction() && ERR_HQRadio.Capability(actor) != 2;
|
|
}
|
|
bool AcceptsStatus(ERR_MortarSupplyStatus report, float now)
|
|
{
|
|
return !m_Stopped && m_State == 1 && report && m_Battery && report.Group == m_Battery.Group && report.Gun == m_Battery.Gun && ERR_MortarLogisticsRules.Need(report.Shells) && ERR_MortarLogisticsRules.NewRequest(report.MessageId, m_ConsumedMessage, ERR_MortarLogisticsRules.Fresh(report.ObservedAt, now));
|
|
}
|
|
void Receive(ERR_MortarSupplyStatus report, float now)
|
|
{
|
|
if (!AcceptsStatus(report, now)) return;
|
|
m_Report = report;
|
|
Audit("RECEIVED", "immutable low-ammunition status delivered by native physical radio route");
|
|
}
|
|
protected bool Authorized(float now)
|
|
{
|
|
if (!m_Mode || !m_Mode.Active() || !m_Report || !m_Battery) return false;
|
|
return ERR_MortarLogisticsRules.ActiveTrip(Replication.IsServer(), m_Stopped, m_Trip, m_HQ.LogisticsToken(m_Group), ERR_MortarLogisticsRules.Fresh(m_Report.ObservedAt, now), OriginalGroup()) && TargetAvailable() && m_Report.Gun == m_Battery.Gun && m_Report.Group == m_Battery.Group && vector.Distance(m_Report.Position, m_Battery.Gun.GetOrigin()) <= 5;
|
|
}
|
|
bool TransferAllowed(int trip, IEntity shell, IEntity from, IEntity to, float now)
|
|
{
|
|
if (trip != m_Trip || !Authorized(now) || !shell || !m_Stock.Contains(shell) || !Bearer(m_Courier)) return false;
|
|
if (m_State == 3) return from == m_Cache && to == m_Courier && ERR_MortarLogisticsRules.Near(vector.Distance(from.GetOrigin(), to.GetOrigin()));
|
|
if (m_State != 5 || from != m_Courier || !m_Cargo.Contains(shell) || !ERR_Actors.CanFight(to) || ERR_Actors.Player(to) || to == m_Battery.RadioOperator || !m_BatteryMembers.Contains(to) || ERR_Actors.Group(to) != m_Battery.Group || SCR_FactionManager.SGetFaction(to) != m_Mode.EnemyFaction()) return false;
|
|
return !CompartmentAccessComponent.GetVehicleIn(to) && ERR_MortarLogisticsRules.Near(vector.Distance(from.GetOrigin(), to.GetOrigin()));
|
|
}
|
|
protected void ClearWaypoint()
|
|
{
|
|
if (m_Waypoint) { if (m_Group) m_Group.RemoveWaypoint(m_Waypoint); ERR_Actors.DeleteSpawned(m_Waypoint); }
|
|
m_Waypoint = null;
|
|
if (m_HoldWaypoint) { if (m_Group) m_Group.RemoveWaypoint(m_HoldWaypoint); ERR_Actors.DeleteSpawned(m_HoldWaypoint); }
|
|
m_HoldWaypoint = null;
|
|
}
|
|
protected bool MoveTo(vector position)
|
|
{
|
|
ClearWaypoint();
|
|
m_Waypoint = AIWaypoint.Cast(ERR_Actors.Spawn(ERR_Resources.MoveWaypoint(), ERR_Actors.Ground(position)));
|
|
if (!m_Waypoint) return false;
|
|
// A completed Move alone would let the original patrol resume during the
|
|
// asynchronous item operation. This owned, non-completing native Defend
|
|
// keeps that queue below us until release; its original entries are untouched.
|
|
m_HoldWaypoint = AIWaypoint.Cast(ERR_Actors.Spawn(ERR_Resources.DefendWaypoint(), ERR_Actors.Ground(position)));
|
|
if (!m_HoldWaypoint) { ClearWaypoint(); return false; }
|
|
m_HoldWaypoint.SetCompletionRadius(8);
|
|
m_Group.AddWaypointAt(m_HoldWaypoint, 0); m_Group.AddWaypointAt(m_Waypoint, 0); m_Group.ActivateAI(); return true;
|
|
}
|
|
protected void Finish(string reason)
|
|
{
|
|
Audit("END", reason);
|
|
if (m_Move) m_Move.Invalidate();
|
|
ClearWaypoint(); m_HQ.ReleaseLogistics(m_Group, m_Trip);
|
|
m_Order = null; m_Report = null; m_Courier = null; m_Cargo.Clear(); m_State = 1;
|
|
// Native requests cannot be canceled. A pending move remains held until its
|
|
// physical outcome resolves; callbacks cannot authorize a later trip.
|
|
m_NextReport = GetGame().GetWorld().GetWorldTime() + 60000;
|
|
}
|
|
protected bool BeginMove(IEntity shell, IEntity from, IEntity to, float now)
|
|
{
|
|
InventoryStorageManagerComponent destination = Inventory(to);
|
|
BaseInventoryStorageComponent storage; if (destination) storage = destination.FindStorageForItem(shell, EStoragePurpose.PURPOSE_DEPOSIT);
|
|
if (!storage) return false;
|
|
m_Move = new ERR_MortarCourierTransfer(this, m_Trip, shell, from, to, storage, now);
|
|
return m_Move.Begin(now);
|
|
}
|
|
protected bool PollMove(float now)
|
|
{
|
|
if (!m_Move) return true;
|
|
int result = m_Move.Poll(now);
|
|
if (result == 0) return false;
|
|
if (result < 0) { Finish("native item operation rejected, expired or lost authority; physical items retained"); return false; }
|
|
IEntity shell = m_Move.Shell(); m_Move = null;
|
|
if (m_State == 3) { m_Cargo.Insert(shell); Audit("PICKUP", "exact depot shell confirmed in original bearer inventory"); }
|
|
else if (m_State == 5) { m_Cargo.RemoveItem(shell); m_Delivered++; m_LastDeliveryAt = now; Audit("DELIVERED", "exact original shell confirmed in living mortar crew inventory"); }
|
|
return true;
|
|
}
|
|
protected void Pickup(float now)
|
|
{
|
|
if (!m_Courier)
|
|
{
|
|
foreach (IEntity candidate : m_OriginalMembers)
|
|
if (Bearer(candidate) && Inventory(candidate) && Inventory(candidate).CanInsertResource(ERR_MortarBattery.SHELL, EStoragePurpose.PURPOSE_DEPOSIT) && ERR_MortarLogisticsRules.Near(vector.Distance(candidate.GetOrigin(), m_Cache.GetOrigin()))) { m_Courier = candidate; break; }
|
|
if (!m_Courier) return;
|
|
}
|
|
if (!Bearer(m_Courier)) { Finish("original bearer lost or captured"); return; }
|
|
if (!PollMove(now)) return;
|
|
if (m_Cargo.Count() < TRIP_SHELLS)
|
|
{
|
|
foreach (IEntity shell : m_Stock)
|
|
{
|
|
if (!shell || !Contains(m_Cache, shell) || m_AttemptedPickup.Contains(shell)) continue;
|
|
InventoryStorageManagerComponent destination = Inventory(m_Courier);
|
|
if (!destination || !destination.FindStorageForItem(shell, EStoragePurpose.PURPOSE_DEPOSIT)) break;
|
|
m_AttemptedPickup.Insert(shell);
|
|
if (!BeginMove(shell, m_Cache, m_Courier, now)) Finish("native pickup rejected; no second request for that shell");
|
|
return;
|
|
}
|
|
}
|
|
if (m_Cargo.IsEmpty()) { Finish("finite cache empty or bearer native storage full"); return; }
|
|
m_State = 4;
|
|
if (!MoveTo(m_Report.Position)) { Finish("native delivery waypoint unavailable"); return; }
|
|
Audit("OUTBOUND", "original patrol walking with verified finite cargo to reported battery position");
|
|
}
|
|
protected void Unload(float now)
|
|
{
|
|
if (!PollMove(now)) return;
|
|
if (m_Cargo.IsEmpty()) { m_CompletedTrips++; Finish("finite delivery complete; original patrol restored"); return; }
|
|
array<AIAgent> agents = {}; m_Battery.Group.GetAgents(agents);
|
|
foreach (IEntity shell : m_Cargo)
|
|
{
|
|
if (!shell || !Contains(m_Courier, shell)) { Finish("carried shell lost or stolen; no replacement"); return; }
|
|
if (m_AttemptedUnload.Contains(shell)) { Finish("previous unload unresolved or failed; no retry"); return; }
|
|
foreach (AIAgent agent : agents)
|
|
{
|
|
if (!agent) continue;
|
|
IEntity recipient = agent.GetControlledEntity();
|
|
if (!TransferAllowed(m_Trip, shell, m_Courier, recipient, now)) continue;
|
|
InventoryStorageManagerComponent destination = Inventory(recipient);
|
|
if (!destination || !destination.FindStorageForItem(shell, EStoragePurpose.PURPOSE_DEPOSIT)) continue;
|
|
m_AttemptedUnload.Insert(shell);
|
|
if (!BeginMove(shell, m_Courier, recipient, now)) Finish("native recipient move rejected; cargo remains physical");
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
void Tick(float now)
|
|
{
|
|
if (m_Stopped || !m_Started || !Replication.IsServer() || !m_Mode.Active()) return;
|
|
if (m_State == 0)
|
|
{
|
|
bool failed; foreach (ERR_MortarInitialItem operation : m_Initial) { if (!operation.Finished) { if (now < m_InitialDeadline) return; failed = true; } else if (!operation.Succeeded) failed = true; }
|
|
if (!OriginalGroup()) failed = true;
|
|
array<IEntity> shells = {}; Shells(m_Cache, shells);
|
|
if (shells.Count() != INITIAL_SHELLS) { if (now < m_InitialDeadline && !failed) return; failed = true; }
|
|
foreach (IEntity originalShell : m_Stock) if (!originalShell || !shells.Contains(originalShell)) failed = true;
|
|
if (m_Stock.Count() != INITIAL_SHELLS) failed = true;
|
|
if (failed) { Audit("STARTUP FAILED", "one-time native stock allocation incomplete; no refill"); Stop(); return; }
|
|
m_State = 1; Audit("READY", "12 distinct original HE shells physically confirmed in existing western cache");
|
|
}
|
|
if (m_State == 1)
|
|
{
|
|
if (m_Move) { m_Move.Poll(now); if (m_Move.Unresolved()) return; m_Move = null; }
|
|
if (!OriginalGroup() || !BindBatteryMembers() || !TargetAvailable()) return;
|
|
bool available; foreach (IEntity stocked : m_Stock) if (Contains(m_Cache, stocked) && !m_AttemptedPickup.Contains(stocked)) available = true;
|
|
if (!available) return;
|
|
if (now >= m_NextReport && ERR_MortarLogisticsRules.Need(m_Battery.CountShells())) { if (m_HQ.QueueSupplyStatus(m_Battery, now)) m_NextReport = now + 60000; }
|
|
if (!m_Report || !ERR_MortarLogisticsRules.NewRequest(m_Report.MessageId, m_ConsumedMessage, ERR_MortarLogisticsRules.Fresh(m_Report.ObservedAt, now))) return;
|
|
int nextTrip = m_Trip + 1;
|
|
if (!m_HQ.ReserveLogistics(m_Group, nextTrip)) return;
|
|
m_Trip = nextTrip; m_ConsumedMessage = m_Report.MessageId;
|
|
m_Order = m_HQ.Downlink(m_Group, "MORTAR SUPPLY", "collect finite western-cache HE; walk to reported battery", m_Report.MessageId);
|
|
m_State = 2;
|
|
if (!m_Order) { Finish("no native courier downlink"); return; }
|
|
Audit("QUEUED", "original patrol reserved pending physical radio command delivery");
|
|
}
|
|
if (!Authorized(now)) { Finish("supply report expired or original ownership/gun/group changed"); return; }
|
|
if (m_Courier && !Bearer(m_Courier)) { Finish("original bearer unavailable; surviving cargo retained"); return; }
|
|
if (m_State == 2)
|
|
{
|
|
int delivered = m_Order.Advance(now, m_HQ.Journal());
|
|
if (delivered == 0) return;
|
|
if (delivered < 0) { Finish("courier command interrupted"); return; }
|
|
m_Order = null; m_State = 3;
|
|
if (!MoveTo(m_Cache.GetOrigin())) { Finish("native pickup waypoint unavailable"); return; }
|
|
Audit("DISPATCH", "same original patrol receives delivered order and walks to finite cache");
|
|
}
|
|
if (m_State == 3) { Pickup(now); return; }
|
|
if (m_State == 4)
|
|
{
|
|
if (!ERR_MortarLogisticsRules.Near(vector.Distance(m_Courier.GetOrigin(), m_Report.Position))) return;
|
|
m_State = 5; Audit("ARRIVED", "physical bearer reached reported gun area; exact recipient checks still required");
|
|
}
|
|
if (m_State == 5) Unload(now);
|
|
}
|
|
void Stop()
|
|
{
|
|
if (m_Stopped) return;
|
|
m_Stopped = true;
|
|
if (m_Move) m_Move.Invalidate();
|
|
ClearWaypoint(); m_HQ.ReleaseLogistics(m_Group, m_Trip); m_Order = null; m_Report = null;
|
|
}
|
|
#ifdef WORKBENCH
|
|
ERR_HQRoute ProbeOrder() { return m_Order; }
|
|
int ProbeSourceMessage() { return m_ConsumedMessage; }
|
|
float ProbeLastDelivery() { return m_LastDeliveryAt; }
|
|
#endif
|
|
string Status() { return string.Format("courier state=%1 finite initial=%2 delivered=%3 stopped=%4 (%5)", m_State, m_Stock.Count(), m_Delivered, m_Stopped, m_Reason); }
|
|
}
|