1304 lines
69 KiB
C#
1304 lines
69 KiB
C#
using MessagePack;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
|
|
#nullable enable
|
|
|
|
namespace GameCult.Aetheria.State.Verse
|
|
{
|
|
public static class AetheriaRuntimeAgentTaskTypes
|
|
{
|
|
public const string Mine = "mine";
|
|
public const string Haul = "haul";
|
|
public const string Tow = "tow";
|
|
public const string Defend = "defend";
|
|
public const string Patrol = "patrol";
|
|
public const string Attack = "attack";
|
|
public const string Explore = "explore";
|
|
|
|
public static readonly IReadOnlyList<string> All =
|
|
new[] { Mine, Haul, Tow, Defend, Patrol, Attack, Explore };
|
|
}
|
|
|
|
public static class AetheriaRuntimeAgentTaskStatuses
|
|
{
|
|
public const string Queued = "queued";
|
|
public const string Assigned = "assigned";
|
|
public const string Completed = "completed";
|
|
public const string Cancelled = "cancelled";
|
|
public const string Failed = "failed";
|
|
}
|
|
|
|
[MessagePackObject]
|
|
public sealed class AetheriaRuntimeAgentTaskCommit
|
|
{
|
|
[Key(0)] public string TaskId { get; set; } = "";
|
|
[Key(1)] public string CorporationKey { get; set; } = "";
|
|
[Key(2)] public string TaskType { get; set; } = "";
|
|
[Key(3)] public int Priority { get; set; }
|
|
[Key(4)] public int ZoneIndex { get; set; } = -1;
|
|
[Key(5)] public string Status { get; set; } = AetheriaRuntimeAgentTaskStatuses.Queued;
|
|
[Key(6)] public int AssignedEntityIndex { get; set; } = -1;
|
|
[Key(7)] public int TargetEntityIndex { get; set; } = -1;
|
|
[Key(8)] public double TargetPositionX { get; set; }
|
|
[Key(9)] public double TargetPositionZ { get; set; }
|
|
[Key(10)] public double CompletionRadius { get; set; } = 10;
|
|
[Key(11)] public int WeaponGroup { get; set; }
|
|
[Key(12)] public long AssignedFrameId { get; set; } = -1;
|
|
[Key(13)] public long CompletedFrameId { get; set; } = -1;
|
|
[Key(14)] public int OriginEntityIndex { get; set; } = -1;
|
|
[Key(15)] public string ItemKey { get; set; } = "";
|
|
[Key(16)] public int RequestedQuantity { get; set; }
|
|
[Key(17)] public int DeliveredQuantity { get; set; }
|
|
[Key(18)] public int PendingQuantity { get; set; }
|
|
[Key(19)] public string Phase { get; set; } = "";
|
|
[Key(20)] public IReadOnlyList<string> TargetBodyKeys { get; set; } = Array.Empty<string>();
|
|
[Key(21)] public int CircuitIndex { get; set; }
|
|
[Key(22)] public string OrbitParentKey { get; set; } = "";
|
|
[Key(23)] public double OrbitDistance { get; set; }
|
|
[Key(24)] public IReadOnlyList<string> TargetOrbitKeys { get; set; } = Array.Empty<string>();
|
|
}
|
|
|
|
[MessagePackObject]
|
|
public sealed class AetheriaRuntimeAgentTaskCommand
|
|
{
|
|
[Key(0)] public string TaskId { get; set; } = "";
|
|
[Key(1)] public string CorporationKey { get; set; } = "";
|
|
[Key(2)] public string TaskType { get; set; } = "";
|
|
[Key(3)] public int Priority { get; set; }
|
|
[Key(4)] public int ZoneIndex { get; set; } = -1;
|
|
[Key(5)] public int TargetEntityIndex { get; set; } = -1;
|
|
[Key(6)] public double TargetPositionX { get; set; }
|
|
[Key(7)] public double TargetPositionZ { get; set; }
|
|
[Key(8)] public double CompletionRadius { get; set; } = 10;
|
|
[Key(9)] public int WeaponGroup { get; set; }
|
|
[Key(10)] public int OriginEntityIndex { get; set; } = -1;
|
|
[Key(11)] public string ItemKey { get; set; } = "";
|
|
[Key(12)] public int Quantity { get; set; }
|
|
[Key(13)] public IReadOnlyList<string> TargetBodyKeys { get; set; } = Array.Empty<string>();
|
|
[Key(14)] public string OrbitParentKey { get; set; } = "";
|
|
[Key(15)] public double OrbitDistance { get; set; }
|
|
[Key(16)] public IReadOnlyList<string> TargetOrbitKeys { get; set; } = Array.Empty<string>();
|
|
}
|
|
|
|
public static class AetheriaRuntimeAgentScheduler
|
|
{
|
|
public const string RuntimeId = "aetheria.daemon.agent-scheduler";
|
|
|
|
public static IReadOnlyList<AetheriaRuntimeDaemonCommandDocument> AssignAndPlan(
|
|
AetheriaRuntimeRunCheckpointCommit run,
|
|
long frameId,
|
|
AetheriaRuntimeCatalogSnapshot? catalog = null,
|
|
double simulationTimeSeconds = 0,
|
|
AetheriaRuntimeDaemonSimulationSettings? simulationSettings = null)
|
|
{
|
|
if (run == null)
|
|
return Array.Empty<AetheriaRuntimeDaemonCommandDocument>();
|
|
|
|
ReleaseInvalidAssignments(run);
|
|
AssignQueuedTasks(run, frameId);
|
|
var commands = PlanAssignedTasks(
|
|
run,
|
|
frameId,
|
|
catalog,
|
|
simulationTimeSeconds,
|
|
simulationSettings ?? AetheriaRuntimeDaemonSimulationSettings.AetheriaDefault).ToList();
|
|
commands.AddRange(PlanIdleReturns(run, frameId));
|
|
return commands;
|
|
}
|
|
|
|
public static void Reconcile(
|
|
AetheriaRuntimeRunCheckpointCommit run,
|
|
long frameId,
|
|
IReadOnlyCollection<string> appliedCommandIds,
|
|
IReadOnlyCollection<string> rejectedCommandIds)
|
|
{
|
|
var applied = new HashSet<string>(appliedCommandIds ?? Array.Empty<string>(), StringComparer.Ordinal);
|
|
var rejected = new HashSet<string>(rejectedCommandIds ?? Array.Empty<string>(), StringComparer.Ordinal);
|
|
foreach (var task in (run?.AgentTasks ?? Array.Empty<AetheriaRuntimeAgentTaskCommit>())
|
|
.Where(task => task != null && string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Haul, StringComparison.Ordinal)))
|
|
{
|
|
var pickupId = CommandId(task, frameId, "pickup");
|
|
var deliveryId = CommandId(task, frameId, "delivery");
|
|
if (applied.Contains(pickupId))
|
|
{
|
|
task.Phase = "delivery";
|
|
continue;
|
|
}
|
|
if (applied.Contains(deliveryId))
|
|
{
|
|
task.DeliveredQuantity += task.PendingQuantity;
|
|
task.PendingQuantity = 0;
|
|
task.Phase = task.DeliveredQuantity >= task.RequestedQuantity ? "complete" : "pickup";
|
|
if (string.Equals(task.Phase, "complete", StringComparison.Ordinal))
|
|
{
|
|
var agent = FindEntity(run, task.ZoneIndex, task.AssignedEntityIndex);
|
|
if (agent != null)
|
|
Complete(task, agent, frameId);
|
|
}
|
|
continue;
|
|
}
|
|
if (rejected.Contains(pickupId) || rejected.Contains(deliveryId))
|
|
task.PendingQuantity = 0;
|
|
}
|
|
foreach (var task in (run?.AgentTasks ?? Array.Empty<AetheriaRuntimeAgentTaskCommit>())
|
|
.Where(task => task != null && string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Mine, StringComparison.Ordinal)))
|
|
{
|
|
if (!rejected.Contains(CommandId(task, frameId, "offload")))
|
|
continue;
|
|
var agent = FindEntity(run, task.ZoneIndex, task.AssignedEntityIndex);
|
|
if (agent != null)
|
|
Complete(task, agent, frameId);
|
|
}
|
|
foreach (var task in (run?.AgentTasks ?? Array.Empty<AetheriaRuntimeAgentTaskCommit>())
|
|
.Where(task => task != null && string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Tow, StringComparison.Ordinal)))
|
|
{
|
|
var detach = CommandId(task, frameId, "detach");
|
|
var agent = FindEntity(run, task.ZoneIndex, task.AssignedEntityIndex);
|
|
if (agent == null) continue;
|
|
if (applied.Contains(detach)) Complete(task, agent, frameId);
|
|
else if (rejected.Contains(detach)) Fail(task, agent);
|
|
}
|
|
}
|
|
|
|
internal static void ReleaseControls(
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
AetheriaRuntimeAgentTaskCommit? task)
|
|
{
|
|
if (agent == null)
|
|
return;
|
|
|
|
agent.AssignedAgentTaskId = "";
|
|
agent.HelmStrafe = 0;
|
|
agent.HelmForward = 0;
|
|
agent.TargetEntityIndex = -1;
|
|
if (task != null &&
|
|
string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Tow, StringComparison.Ordinal) &&
|
|
task.TargetEntityIndex >= 0)
|
|
{
|
|
agent.ChildEntityIndices = (agent.ChildEntityIndices ?? Array.Empty<int>())
|
|
.Where(index => index != task.TargetEntityIndex)
|
|
.ToArray();
|
|
}
|
|
}
|
|
|
|
private static void AssignQueuedTasks(AetheriaRuntimeRunCheckpointCommit run, long frameId)
|
|
{
|
|
var tasks = (run.AgentTasks ?? Array.Empty<AetheriaRuntimeAgentTaskCommit>()).Where(task => task != null).ToArray();
|
|
var entities = (run.Zones ?? Array.Empty<AetheriaRuntimeZoneSnapshotCommit>())
|
|
.Where(zone => zone != null)
|
|
.SelectMany(zone => (zone.Entities ?? Array.Empty<AetheriaRuntimeEntitySnapshotCommit>())
|
|
.Where(entity => entity != null)
|
|
.Select(entity => (zone.ZoneIndex, Entity: entity)))
|
|
.ToArray();
|
|
|
|
foreach (var corporation in tasks
|
|
.Where(task => string.Equals(task.Status, AetheriaRuntimeAgentTaskStatuses.Queued, StringComparison.Ordinal))
|
|
.GroupBy(task => task.CorporationKey ?? "", StringComparer.Ordinal))
|
|
foreach (var taskType in corporation.GroupBy(task => task.TaskType ?? "", StringComparer.Ordinal))
|
|
{
|
|
var available = entities
|
|
.Where(pair => pair.Entity.IsActive && string.IsNullOrWhiteSpace(pair.Entity.AssignedAgentTaskId))
|
|
.Where(pair => !IsCurrentEntity(run, pair.ZoneIndex, pair.Entity.EntityIndex))
|
|
.Where(pair => string.Equals(pair.Entity.FactionKey ?? "", corporation.Key, StringComparison.Ordinal))
|
|
.Where(pair => (pair.Entity.AgentTaskCapabilities ?? Array.Empty<string>()).Contains(taskType.Key, StringComparer.Ordinal))
|
|
.OrderBy(pair => pair.ZoneIndex)
|
|
.ThenBy(pair => pair.Entity.EntityIndex)
|
|
.ToList();
|
|
foreach (var task in taskType.OrderByDescending(task => task.Priority).ThenBy(task => task.TaskId, StringComparer.Ordinal))
|
|
{
|
|
var assignment = available
|
|
.Select(agent => (Agent: agent, Route: FindZoneRoute(run, agent.ZoneIndex, task.ZoneIndex)))
|
|
.Where(candidate => candidate.Route.Count > 0)
|
|
.OrderBy(candidate => candidate.Route.Count)
|
|
.ThenBy(candidate => candidate.Agent.Entity.EntityIndex)
|
|
.FirstOrDefault();
|
|
if (assignment.Route == null || assignment.Route.Count == 0)
|
|
continue;
|
|
available.Remove(assignment.Agent);
|
|
task.Status = AetheriaRuntimeAgentTaskStatuses.Assigned;
|
|
task.AssignedEntityIndex = assignment.Agent.Entity.EntityIndex;
|
|
task.AssignedFrameId = frameId;
|
|
assignment.Agent.Entity.AssignedAgentTaskId = task.TaskId;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static IReadOnlyList<AetheriaRuntimeDaemonCommandDocument> PlanAssignedTasks(
|
|
AetheriaRuntimeRunCheckpointCommit run,
|
|
long frameId,
|
|
AetheriaRuntimeCatalogSnapshot? catalog,
|
|
double simulationTimeSeconds,
|
|
AetheriaRuntimeDaemonSimulationSettings simulationSettings)
|
|
{
|
|
var commands = new List<AetheriaRuntimeDaemonCommandDocument>();
|
|
foreach (var task in (run.AgentTasks ?? Array.Empty<AetheriaRuntimeAgentTaskCommit>())
|
|
.Where(task => task != null && string.Equals(task.Status, AetheriaRuntimeAgentTaskStatuses.Assigned, StringComparison.Ordinal)))
|
|
{
|
|
var assignment = FindAssignedEntity(run, task);
|
|
if (assignment.Entity == null || assignment.Zone == null || !assignment.Entity.IsActive)
|
|
continue;
|
|
if (IsCurrentEntity(run, assignment.Zone.ZoneIndex, assignment.Entity.EntityIndex))
|
|
continue;
|
|
task.AssignedEntityIndex = assignment.Entity.EntityIndex;
|
|
if (assignment.Zone.ZoneIndex != task.ZoneIndex)
|
|
{
|
|
var route = FindZoneRoute(run, assignment.Zone.ZoneIndex, task.ZoneIndex);
|
|
if (route.Count < 2)
|
|
continue;
|
|
var settings = AetheriaRuntimeDaemonRenderSettings.AetheriaDefault;
|
|
var exit = AetheriaRuntimeDaemonRenderQueries.QueryWormholeExits(
|
|
run,
|
|
assignment.Zone,
|
|
AetheriaRuntimeDaemonRenderQueries.ResolveZoneRenderRadius(
|
|
assignment.Zone, AetheriaRuntimeDaemonRenderQueries.DefaultZoneRenderRadius),
|
|
settings.WormholeDistanceRatio)
|
|
.First(candidate => candidate.TargetZoneIndex == route[1]);
|
|
var travelDx = exit.PositionX - assignment.Entity.PositionX;
|
|
var travelDz = exit.PositionZ - assignment.Entity.PositionZ;
|
|
var travelDistance = Math.Sqrt(travelDx * travelDx + travelDz * travelDz);
|
|
if (travelDistance > AetheriaRuntimeDaemonOperationContext.DefaultWormholeExitRadius * 0.8)
|
|
{
|
|
commands.Add(MovementFromZone(task, assignment.Zone.ZoneIndex, assignment.Entity, frameId, travelDx, travelDz));
|
|
}
|
|
else
|
|
{
|
|
var travel = AetheriaRuntimeDaemonCommandDocument.Create(
|
|
AetheriaRuntimeDaemonCommandKinds.EnterWormhole,
|
|
RuntimeId,
|
|
"daemon-agent-scheduler",
|
|
frameId,
|
|
$"zone.{assignment.Zone.ZoneIndex}.entity.{assignment.Entity.EntityIndex}");
|
|
travel.CommandId = CommandId(task, frameId, "travel");
|
|
travel.TargetZoneIndex = route[1];
|
|
commands.Add(travel);
|
|
}
|
|
continue;
|
|
}
|
|
var zone = (run.Zones ?? Array.Empty<AetheriaRuntimeZoneSnapshotCommit>())
|
|
.FirstOrDefault(candidate => candidate != null && candidate.ZoneIndex == task.ZoneIndex);
|
|
var agent = assignment.Entity;
|
|
if (agent == null || !agent.IsActive)
|
|
continue;
|
|
|
|
if (string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Haul, StringComparison.Ordinal))
|
|
{
|
|
commands.AddRange(PlanHaul(run, zone!, task, agent, frameId));
|
|
continue;
|
|
}
|
|
if (string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Mine, StringComparison.Ordinal))
|
|
{
|
|
commands.AddRange(PlanMining(zone!, task, agent, frameId, catalog, simulationTimeSeconds));
|
|
continue;
|
|
}
|
|
if (string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Explore, StringComparison.Ordinal) &&
|
|
(task.TargetBodyKeys ?? Array.Empty<string>()).Any(key => !string.IsNullOrWhiteSpace(key)))
|
|
{
|
|
commands.AddRange(PlanSurvey(run, zone!, task, agent, frameId, catalog, simulationTimeSeconds));
|
|
continue;
|
|
}
|
|
if (string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Defend, StringComparison.Ordinal) ||
|
|
string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Patrol, StringComparison.Ordinal))
|
|
{
|
|
var hostile = FirstVisibleHostileShip(zone!, agent);
|
|
if (hostile != null && ResolveAgentWeapons(agent, catalog).Count > 0)
|
|
{
|
|
var combatDx = hostile.PositionX - agent.PositionX;
|
|
var combatDz = hostile.PositionZ - agent.PositionZ;
|
|
commands.AddRange(PlanAttack(
|
|
run, task, agent, hostile, frameId, combatDx, combatDz,
|
|
Math.Sqrt(combatDx * combatDx + combatDz * combatDz), catalog, simulationSettings));
|
|
continue;
|
|
}
|
|
commands.AddRange(PlanPatrol(zone!, task, agent, frameId));
|
|
continue;
|
|
}
|
|
if (string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Tow, StringComparison.Ordinal))
|
|
{
|
|
commands.AddRange(PlanTow(run, zone!, task, agent, frameId));
|
|
continue;
|
|
}
|
|
|
|
var target = task.TargetEntityIndex < 0
|
|
? null
|
|
: zone!.Entities.FirstOrDefault(entity => entity != null && entity.EntityIndex == task.TargetEntityIndex);
|
|
if (string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Attack, StringComparison.Ordinal) &&
|
|
(target == null || !target.IsActive))
|
|
{
|
|
Complete(task, agent, frameId);
|
|
commands.Add(Movement(task, agent, frameId, 0, 0, 0));
|
|
continue;
|
|
}
|
|
var targetX = target?.PositionX ?? task.TargetPositionX;
|
|
var targetZ = target?.PositionZ ?? task.TargetPositionZ;
|
|
var dx = targetX - agent.PositionX;
|
|
var dz = targetZ - agent.PositionZ;
|
|
var distance = Math.Sqrt(dx * dx + dz * dz);
|
|
if (string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Attack, StringComparison.Ordinal) && target != null)
|
|
{
|
|
commands.AddRange(PlanAttack(
|
|
run, task, agent, target, frameId, dx, dz, distance, catalog, simulationSettings));
|
|
continue;
|
|
}
|
|
if (distance <= Math.Max(0.01, task.CompletionRadius) &&
|
|
!string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Attack, StringComparison.Ordinal))
|
|
{
|
|
Complete(task, agent, frameId);
|
|
commands.Add(Movement(task, agent, frameId, 0, 0, 0));
|
|
continue;
|
|
}
|
|
|
|
var magnitude = distance <= 0.0001 ? 0 : 1;
|
|
commands.Add(Movement(task, agent, frameId, dx, dz, magnitude));
|
|
}
|
|
return commands;
|
|
}
|
|
|
|
private static IReadOnlyList<AetheriaRuntimeDaemonCommandDocument> PlanAttack(
|
|
AetheriaRuntimeRunCheckpointCommit run,
|
|
AetheriaRuntimeAgentTaskCommit task,
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
AetheriaRuntimeEntitySnapshotCommit target,
|
|
long frameId,
|
|
double dx,
|
|
double dz,
|
|
double distance,
|
|
AetheriaRuntimeCatalogSnapshot? catalog,
|
|
AetheriaRuntimeDaemonSimulationSettings settings)
|
|
{
|
|
var weapons = ResolveAgentWeapons(agent, catalog);
|
|
if (weapons.Count == 0)
|
|
{
|
|
Fail(task, agent);
|
|
return Array.Empty<AetheriaRuntimeDaemonCommandDocument>();
|
|
}
|
|
|
|
var optimum = SampleOptimumRange(run, task, agent, weapons, settings);
|
|
var toTarget = Normalize(dx, dz, 0, 1);
|
|
var targetForward = Normalize(target.DirectionX, target.DirectionY, 0, 1);
|
|
var targetRight = new Vector2(targetForward.Y, -targetForward.X);
|
|
var targetPortAlignment = Dot(targetRight, toTarget);
|
|
var targetForeAlignment = Dot(new Vector2(-targetForward.X, -targetForward.Y), toTarget);
|
|
var optimumRangeDelta = Math.Abs(optimum - distance);
|
|
var forwardness = Clamp01(optimumRangeDelta / settings.AgentMaxForwardDistance) * settings.AgentForwardLerp;
|
|
if (targetForeAlignment > 0)
|
|
forwardness = Lerp(forwardness, 1, targetPortAlignment * targetPortAlignment);
|
|
var lateral = RotateQuarter(toTarget, targetPortAlignment > 0 ? 3 : 1);
|
|
var radial = distance > optimum ? toTarget : new Vector2(-toTarget.X, -toTarget.Y);
|
|
var movementDirection = Normalize(
|
|
Lerp(lateral.X, radial.X, forwardness),
|
|
Lerp(lateral.Y, radial.Y, forwardness),
|
|
lateral.X,
|
|
lateral.Y);
|
|
task.Phase = distance > optimum ? "closing-range" : distance < optimum ? "opening-range" : "orbiting";
|
|
|
|
var selected = SelectHighestDpsGroup(weapons, distance);
|
|
if (selected >= 0)
|
|
task.WeaponGroup = selected;
|
|
var aim = selected >= 0
|
|
? InterceptDirection(agent, target, weapons.First(value => value.GroupIndex == selected))
|
|
: toTarget;
|
|
var commands = new List<AetheriaRuntimeDaemonCommandDocument>
|
|
{
|
|
Movement(task, agent, frameId, movementDirection.X, movementDirection.Y, 1),
|
|
Command(task, agent, frameId, AetheriaRuntimeDaemonCommandKinds.SetLookDirection, "look", command =>
|
|
{
|
|
command.DirectionX = aim.X;
|
|
command.PositionZ = aim.Y;
|
|
}),
|
|
Command(task, agent, frameId, AetheriaRuntimeDaemonCommandKinds.SetTarget, "target", command =>
|
|
command.TargetEntityKey = EntityKey(run, task.ZoneIndex, target.EntityIndex))
|
|
};
|
|
var fireGroups = weapons
|
|
.Where(value => value.Locking && distance > value.MinRange && distance < value.Range)
|
|
.Select(value => value.GroupIndex)
|
|
.Distinct()
|
|
.ToList();
|
|
if (selected >= 0 && HardpointFaces(agent, weapons.First(value => value.GroupIndex == selected), aim))
|
|
fireGroups.Add(selected);
|
|
foreach (var group in fireGroups.Distinct().OrderBy(value => value))
|
|
commands.Add(Command(task, agent, frameId, AetheriaRuntimeDaemonCommandKinds.FireWeaponGroup,
|
|
$"fire-{group}", command => command.WeaponGroup = group));
|
|
return commands;
|
|
}
|
|
|
|
private static IReadOnlyList<AgentWeapon> ResolveAgentWeapons(
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
AetheriaRuntimeCatalogSnapshot? catalog)
|
|
{
|
|
if (catalog == null)
|
|
return Array.Empty<AgentWeapon>();
|
|
var groups = agent.WeaponGroups ?? Array.Empty<IReadOnlyList<int>>();
|
|
return AetheriaRuntimeEquippedBehaviorQueries.FindOperational(agent, catalog, "Weapon")
|
|
.Where(value =>
|
|
AetheriaRuntimeBehaviorMetadataCatalog.IsKindOrDescendant(value.Payload.Kind, AetheriaRuntimeBehaviorKinds.InstantWeapon) ||
|
|
AetheriaRuntimeBehaviorMetadataCatalog.IsKindOrDescendant(value.Payload.Kind, "ConstantWeapon"))
|
|
.Select(value =>
|
|
{
|
|
var group = Enumerable.Range(0, groups.Count)
|
|
.Where(index => (groups[index] ?? Array.Empty<int>()).Contains(value.EquipmentIndex))
|
|
.DefaultIfEmpty(-1)
|
|
.First();
|
|
return new AgentWeapon(
|
|
agent,
|
|
value,
|
|
group,
|
|
Math.Max(0, value.EvaluateStat(5)),
|
|
Math.Max(0, value.EvaluateStat(6)),
|
|
Math.Max(0, value.EvaluateStat(16)),
|
|
Math.Max(0.000001, value.EvaluateStat(19)),
|
|
AetheriaRuntimeBehaviorMetadataCatalog.IsKindOrDescendant(value.Payload.Kind, "ConstantWeapon"),
|
|
AetheriaRuntimeBehaviorMetadataCatalog.IsKindOrDescendant(value.Payload.Kind, "LockWeapon"),
|
|
AetheriaRuntimeBehaviorMetadataCatalog.IsKindOrDescendant(value.Payload.Kind, AetheriaRuntimeBehaviorKinds.ChargedWeapon));
|
|
})
|
|
.Where(value => value.GroupIndex >= 0 && value.Range > value.MinRange)
|
|
.ToArray();
|
|
}
|
|
|
|
private static double SampleOptimumRange(
|
|
AetheriaRuntimeRunCheckpointCommit run,
|
|
AetheriaRuntimeAgentTaskCommit task,
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
IReadOnlyList<AgentWeapon> weapons,
|
|
AetheriaRuntimeDaemonSimulationSettings settings)
|
|
{
|
|
if (weapons.Count == 0)
|
|
return 0;
|
|
// Preserve the fossil CombatState interval: both ends come from authored maximum ranges.
|
|
var minimum = weapons.Min(value => value.Range);
|
|
var maximum = weapons.Max(value => value.Range);
|
|
var span = Math.Max(0, maximum - minimum);
|
|
var count = Math.Max(1, settings.AgentDpsSampleCount);
|
|
var step = span / count;
|
|
var offset = StableUnit(run.GenerationSeed, task.TaskId, agent.EntityId) * step;
|
|
var optimum = minimum;
|
|
var optimumScore = 0.0;
|
|
for (var index = 0; index < count; index++)
|
|
{
|
|
var range = offset + minimum + span * index / count;
|
|
var score = weapons.Sum(value => RangeDamagePerSecond(value, range));
|
|
score *= Math.Pow(Math.Max(0, range), settings.AgentRangeExponent);
|
|
if (score <= optimumScore)
|
|
continue;
|
|
optimumScore = score;
|
|
optimum = range;
|
|
}
|
|
return optimum;
|
|
}
|
|
|
|
private static int SelectHighestDpsGroup(
|
|
IReadOnlyList<AgentWeapon> weapons,
|
|
double range)
|
|
{
|
|
return weapons
|
|
.Where(value => !value.Locking && WeaponReady(value))
|
|
.Where(value => range > value.MinRange && range < value.Range)
|
|
.GroupBy(value => value.GroupIndex)
|
|
.Select(group => (Group: group.Key, Dps: group.Sum(value => RangeDamagePerSecond(value, range))))
|
|
.Where(value => value.Dps > 0.1)
|
|
.OrderByDescending(value => value.Dps)
|
|
.ThenBy(value => value.Group)
|
|
.Select(value => value.Group)
|
|
.DefaultIfEmpty(-1)
|
|
.First();
|
|
}
|
|
|
|
private static bool WeaponReady(AgentWeapon weapon)
|
|
{
|
|
if (weapon.Constant)
|
|
return true;
|
|
var state = FindWeaponState(weapon);
|
|
return state == null || (!state.CoolingDown && !state.Reloading);
|
|
}
|
|
|
|
private static AetheriaRuntimeWeaponStateCommit? FindWeaponState(AgentWeapon weapon) =>
|
|
(weapon.Owner.WeaponStates ?? Array.Empty<AetheriaRuntimeWeaponStateCommit>())
|
|
.FirstOrDefault(value => value != null &&
|
|
value.OwnerKind == AetheriaRuntimeBehaviorStateProjector.EquipmentOwnerKind &&
|
|
value.OwnerIndex == weapon.Behavior.EquipmentIndex &&
|
|
value.BehaviorIndex == weapon.Behavior.BehaviorIndex);
|
|
|
|
private static double RangeDamagePerSecond(AgentWeapon weapon, double range)
|
|
{
|
|
if (range <= weapon.MinRange || range >= weapon.Range)
|
|
return 0;
|
|
var normalized = Clamp01((range - weapon.MinRange) / Math.Max(0.000001, weapon.Range - weapon.MinRange));
|
|
var damageField = (weapon.Behavior.Payload.Fields ?? Array.Empty<AetheriaRuntimeBehaviorField>())
|
|
.FirstOrDefault(value => value != null && value.Key == 2)?.Value;
|
|
var thermal = weapon.Owner.EquipmentStates?.FirstOrDefault(value =>
|
|
value != null && value.EquipmentIndex == weapon.Behavior.EquipmentIndex)?.ThermalPerformance ?? 1;
|
|
var damage = AetheriaRuntimeDaemonItemStatQueries.EvaluatePerformanceStat(
|
|
damageField,
|
|
AetheriaRuntimeDaemonItemStatQueries.ConditionsFor(
|
|
weapon.Behavior.Item,
|
|
heat: thermal,
|
|
charge: WeaponCharge(weapon),
|
|
range: normalized));
|
|
damage *= SampleDamageCurve(weapon.Behavior.Payload, normalized);
|
|
if (weapon.Constant)
|
|
return damage;
|
|
if (!weapon.Charged)
|
|
return damage / weapon.Cooldown;
|
|
var charge = WeaponCharge(weapon);
|
|
var multiplier = PositiveNumber(weapon.Behavior.Payload, 27, 1);
|
|
var chargeTime = Math.Max(0.000001, weapon.Behavior.EvaluateStat(21));
|
|
return damage * Lerp(1, multiplier, charge) * multiplier / (weapon.Cooldown + chargeTime);
|
|
}
|
|
|
|
private static double WeaponCharge(AgentWeapon weapon)
|
|
{
|
|
if (!weapon.Charged)
|
|
return 1;
|
|
return Clamp01(FindWeaponState(weapon)?.Charge ?? 0);
|
|
}
|
|
|
|
private static double PositiveNumber(AetheriaRuntimeBehaviorPayload payload, int key, double fallback)
|
|
{
|
|
var value = (payload.Fields ?? Array.Empty<AetheriaRuntimeBehaviorField>())
|
|
.FirstOrDefault(field => field != null && field.Key == key)?.Value?.NumberValue ?? fallback;
|
|
return value > 0 ? value : fallback;
|
|
}
|
|
|
|
private static double SampleDamageCurve(AetheriaRuntimeBehaviorPayload payload, double normalizedRange)
|
|
{
|
|
var value = (payload.Fields ?? Array.Empty<AetheriaRuntimeBehaviorField>())
|
|
.FirstOrDefault(field => field != null && field.Key == 7)?.Value;
|
|
var keys = value?.Children != null && value.Children.Count > 0 && value.Children[0].Children.Count > 0
|
|
? value.Children[0].Children
|
|
: value?.Children ?? Array.Empty<AetheriaRuntimeBehaviorValue>();
|
|
var curve = keys
|
|
.Where(key => key?.Children != null && key.Children.Count >= 4)
|
|
.Select(key => new AetheriaRuntimeCurveKey(
|
|
key.Children[0].NumberValue,
|
|
key.Children[1].NumberValue,
|
|
key.Children[2].NumberValue,
|
|
key.Children[3].NumberValue))
|
|
.ToArray();
|
|
return curve.Length == 0 ? 1 : AetheriaRuntimeDaemonItemStatQueries.SampleCurve(curve, normalizedRange);
|
|
}
|
|
|
|
private static Vector2 InterceptDirection(
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
AetheriaRuntimeEntitySnapshotCommit target,
|
|
AgentWeapon weapon)
|
|
{
|
|
if (weapon.Velocity <= 1)
|
|
return Normalize(target.PositionX - agent.PositionX, target.PositionZ - agent.PositionZ, 0, 1);
|
|
var relative = new CultMath.float3(
|
|
(float)(target.PositionX - agent.PositionX),
|
|
0,
|
|
(float)(target.PositionZ - agent.PositionZ));
|
|
var velocity = new CultMath.float3((float)target.VelocityX, 0, (float)target.VelocityY);
|
|
var time = CultMath.math.first_order_intercept_time((float)weapon.Velocity, relative, velocity);
|
|
return Normalize(relative.x + velocity.x * time, relative.z + velocity.z * time, relative.x, relative.z);
|
|
}
|
|
|
|
private static bool HardpointFaces(
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
AgentWeapon weapon,
|
|
Vector2 aim)
|
|
{
|
|
var forward = Normalize(agent.DirectionX, agent.DirectionY, 0, 1);
|
|
var hardpoint = RotateQuarter(
|
|
forward,
|
|
AetheriaRuntimeEquipmentRotation.QuarterTurns(weapon.Behavior.Slot?.Rotation));
|
|
return Dot(hardpoint, aim) > 0.99;
|
|
}
|
|
|
|
private static Vector2 RotateQuarter(Vector2 value, int rotation)
|
|
{
|
|
var rotated = AetheriaRuntimeEquipmentRotation.RotateQuarter(value.X, value.Y, rotation);
|
|
return new Vector2(rotated.X, rotated.Y);
|
|
}
|
|
|
|
private static double StableUnit(uint seed, string taskId, string entityId)
|
|
{
|
|
var hash = seed == 0 ? 2166136261u : seed;
|
|
foreach (var character in (taskId ?? "") + "\n" + (entityId ?? ""))
|
|
{
|
|
hash ^= character;
|
|
hash *= 16777619u;
|
|
}
|
|
return hash / ((double)uint.MaxValue + 1);
|
|
}
|
|
|
|
private static double Dot(Vector2 left, Vector2 right) => left.X * right.X + left.Y * right.Y;
|
|
private static double Lerp(double from, double to, double value) => from + (to - from) * Clamp01(value);
|
|
private static double Clamp01(double value) => value < 0 ? 0 : value > 1 ? 1 : value;
|
|
private static Vector2 Normalize(double x, double y, double fallbackX, double fallbackY)
|
|
{
|
|
var length = Math.Sqrt(x * x + y * y);
|
|
if (length <= 0.000001)
|
|
{
|
|
var fallbackLength = Math.Sqrt(fallbackX * fallbackX + fallbackY * fallbackY);
|
|
return fallbackLength <= 0.000001
|
|
? new Vector2(0, 1)
|
|
: new Vector2(fallbackX / fallbackLength, fallbackY / fallbackLength);
|
|
}
|
|
return new Vector2(x / length, y / length);
|
|
}
|
|
|
|
private readonly struct Vector2
|
|
{
|
|
public Vector2(double x, double y) { X = x; Y = y; }
|
|
public double X { get; }
|
|
public double Y { get; }
|
|
}
|
|
|
|
private sealed class AgentWeapon
|
|
{
|
|
public AgentWeapon(
|
|
AetheriaRuntimeEntitySnapshotCommit owner,
|
|
AetheriaRuntimeEquippedBehavior behavior,
|
|
int groupIndex,
|
|
double minRange,
|
|
double range,
|
|
double velocity,
|
|
double cooldown,
|
|
bool constant,
|
|
bool locking,
|
|
bool charged)
|
|
{
|
|
Owner = owner;
|
|
Behavior = behavior;
|
|
GroupIndex = groupIndex;
|
|
MinRange = minRange;
|
|
Range = range;
|
|
Velocity = velocity;
|
|
Cooldown = cooldown;
|
|
Constant = constant;
|
|
Locking = locking;
|
|
Charged = charged;
|
|
}
|
|
|
|
public AetheriaRuntimeEquippedBehavior Behavior { get; }
|
|
public AetheriaRuntimeEntitySnapshotCommit Owner { get; }
|
|
public int GroupIndex { get; }
|
|
public double MinRange { get; }
|
|
public double Range { get; }
|
|
public double Velocity { get; }
|
|
public double Cooldown { get; }
|
|
public bool Constant { get; }
|
|
public bool Locking { get; }
|
|
public bool Charged { get; }
|
|
}
|
|
|
|
private static IReadOnlyList<AetheriaRuntimeDaemonCommandDocument> PlanIdleReturns(
|
|
AetheriaRuntimeRunCheckpointCommit run,
|
|
long frameId)
|
|
{
|
|
var commands = new List<AetheriaRuntimeDaemonCommandDocument>();
|
|
var locations = (run.Zones ?? Array.Empty<AetheriaRuntimeZoneSnapshotCommit>())
|
|
.Where(zone => zone != null)
|
|
.SelectMany(zone => (zone.Entities ?? Array.Empty<AetheriaRuntimeEntitySnapshotCommit>())
|
|
.Where(entity => entity != null)
|
|
.Select(entity => (Zone: zone, Entity: entity)))
|
|
.ToArray();
|
|
var byId = locations
|
|
.Where(value => !string.IsNullOrWhiteSpace(value.Entity.EntityId))
|
|
.ToDictionary(value => value.Entity.EntityId, StringComparer.Ordinal);
|
|
foreach (var worker in locations
|
|
.Where(value => value.Entity.IsActive)
|
|
.Where(value => !IsCurrentEntity(run, value.Zone.ZoneIndex, value.Entity.EntityIndex))
|
|
.Where(value => (value.Entity.AgentTaskCapabilities ?? Array.Empty<string>()).Count > 0)
|
|
.Where(value => string.IsNullOrWhiteSpace(value.Entity.AssignedAgentTaskId))
|
|
.Where(value => !string.IsNullOrWhiteSpace(value.Entity.HomeEntityId)))
|
|
{
|
|
if (!byId.TryGetValue(worker.Entity.HomeEntityId, out var home) || !home.Entity.IsActive)
|
|
continue;
|
|
if (worker.Zone.ZoneIndex != home.Zone.ZoneIndex)
|
|
{
|
|
var route = FindZoneRoute(run, worker.Zone.ZoneIndex, home.Zone.ZoneIndex);
|
|
if (route.Count < 2)
|
|
continue;
|
|
var settings = AetheriaRuntimeDaemonRenderSettings.AetheriaDefault;
|
|
var exit = AetheriaRuntimeDaemonRenderQueries.QueryWormholeExits(
|
|
run,
|
|
worker.Zone,
|
|
AetheriaRuntimeDaemonRenderQueries.ResolveZoneRenderRadius(
|
|
worker.Zone, AetheriaRuntimeDaemonRenderQueries.DefaultZoneRenderRadius),
|
|
settings.WormholeDistanceRatio)
|
|
.First(candidate => candidate.TargetZoneIndex == route[1]);
|
|
var dx = exit.PositionX - worker.Entity.PositionX;
|
|
var dz = exit.PositionZ - worker.Entity.PositionZ;
|
|
if (Math.Sqrt(dx * dx + dz * dz) > AetheriaRuntimeDaemonOperationContext.DefaultWormholeExitRadius * 0.8)
|
|
commands.Add(IdleMovement(worker.Zone.ZoneIndex, worker.Entity, frameId, dx, dz, "home-approach-wormhole"));
|
|
else
|
|
commands.Add(IdleCommand(worker.Zone.ZoneIndex, worker.Entity, frameId,
|
|
AetheriaRuntimeDaemonCommandKinds.EnterWormhole, "home-travel", command => command.TargetZoneIndex = route[1]));
|
|
continue;
|
|
}
|
|
if ((home.Entity.DockingBayAssignments ?? Array.Empty<int>()).Contains(worker.Entity.EntityIndex))
|
|
continue;
|
|
var homeDx = home.Entity.PositionX - worker.Entity.PositionX;
|
|
var homeDz = home.Entity.PositionZ - worker.Entity.PositionZ;
|
|
var dockingCommandDistance =
|
|
AetheriaRuntimeDaemonOperationContext.DefaultDockingDistance;
|
|
if (Math.Sqrt(homeDx * homeDx + homeDz * homeDz) > dockingCommandDistance)
|
|
commands.Add(IdleMovement(worker.Zone.ZoneIndex, worker.Entity, frameId, homeDx, homeDz, "home-approach"));
|
|
else
|
|
commands.Add(IdleCommand(worker.Zone.ZoneIndex, worker.Entity, frameId,
|
|
AetheriaRuntimeDaemonCommandKinds.Dock, "home-dock",
|
|
command => command.TargetEntityKey = EntityKey(run, home.Zone.ZoneIndex, home.Entity.EntityIndex)));
|
|
}
|
|
return commands;
|
|
}
|
|
|
|
private static bool IsCurrentEntity(AetheriaRuntimeRunCheckpointCommit run, int zoneIndex, int entityIndex) =>
|
|
AetheriaRuntimeRunCheckpointCommit.TryParseEntityKey(run.CurrentEntityKey, out var currentZoneIndex, out var currentEntityIndex) &&
|
|
currentZoneIndex == zoneIndex && currentEntityIndex == entityIndex;
|
|
|
|
private static AetheriaRuntimeDaemonCommandDocument IdleMovement(
|
|
int zoneIndex,
|
|
AetheriaRuntimeEntitySnapshotCommit entity,
|
|
long frameId,
|
|
double dx,
|
|
double dz,
|
|
string phase)
|
|
{
|
|
var length = Math.Sqrt(dx * dx + dz * dz);
|
|
return IdleCommand(zoneIndex, entity, frameId, AetheriaRuntimeDaemonCommandKinds.SetMoveVector, phase, command =>
|
|
{
|
|
// Fossil MoveToState asks Agent.Accelerate for a target velocity; it does not
|
|
// blindly thrust toward the target position. Preserve that delta-v owner so
|
|
// an agent can brake through a close interaction radius instead of orbiting it.
|
|
const double defaultAgentTopSpeed = 100;
|
|
var desiredVelocityX = length <= 0.0001 ? 0 : dx / length * defaultAgentTopSpeed;
|
|
var desiredVelocityZ = length <= 0.0001 ? 0 : dz / length * defaultAgentTopSpeed;
|
|
var deltaVelocityX = desiredVelocityX - entity.VelocityX;
|
|
var deltaVelocityZ = desiredVelocityZ - entity.VelocityY;
|
|
var deltaVelocityLength = Math.Sqrt(
|
|
deltaVelocityX * deltaVelocityX + deltaVelocityZ * deltaVelocityZ);
|
|
SetLocalHelmAxes(
|
|
command,
|
|
entity,
|
|
deltaVelocityX,
|
|
deltaVelocityZ,
|
|
deltaVelocityLength <= 1 ? 0 : 1);
|
|
});
|
|
}
|
|
|
|
private static AetheriaRuntimeDaemonCommandDocument IdleCommand(
|
|
int zoneIndex,
|
|
AetheriaRuntimeEntitySnapshotCommit entity,
|
|
long frameId,
|
|
AetheriaRuntimeDaemonCommandKinds kind,
|
|
string phase,
|
|
Action<AetheriaRuntimeDaemonCommandDocument> configure)
|
|
{
|
|
var command = AetheriaRuntimeDaemonCommandDocument.Create(
|
|
kind, RuntimeId, "daemon-agent-scheduler", frameId, $"zone.{zoneIndex}.entity.{entity.EntityIndex}");
|
|
command.CommandId = string.Join(":", RuntimeId, entity.EntityId, frameId.ToString(CultureInfo.InvariantCulture), phase);
|
|
configure(command);
|
|
return command;
|
|
}
|
|
|
|
private static (AetheriaRuntimeZoneSnapshotCommit? Zone, AetheriaRuntimeEntitySnapshotCommit? Entity) FindAssignedEntity(
|
|
AetheriaRuntimeRunCheckpointCommit run,
|
|
AetheriaRuntimeAgentTaskCommit task)
|
|
{
|
|
foreach (var zone in run.Zones ?? Array.Empty<AetheriaRuntimeZoneSnapshotCommit>())
|
|
foreach (var entity in zone?.Entities ?? Array.Empty<AetheriaRuntimeEntitySnapshotCommit>())
|
|
if (entity != null && string.Equals(entity.AssignedAgentTaskId, task.TaskId, StringComparison.Ordinal))
|
|
return (zone, entity);
|
|
return (null, null);
|
|
}
|
|
|
|
private static IReadOnlyList<int> FindZoneRoute(AetheriaRuntimeRunCheckpointCommit run, int source, int target)
|
|
{
|
|
if (source == target)
|
|
return new[] { source };
|
|
var zones = (run.Zones ?? Array.Empty<AetheriaRuntimeZoneSnapshotCommit>())
|
|
.Where(zone => zone != null)
|
|
.ToDictionary(zone => zone.ZoneIndex);
|
|
if (!zones.ContainsKey(source) || !zones.ContainsKey(target))
|
|
return Array.Empty<int>();
|
|
var previous = new Dictionary<int, int> { [source] = source };
|
|
var queue = new Queue<int>();
|
|
queue.Enqueue(source);
|
|
while (queue.Count > 0)
|
|
{
|
|
var current = queue.Dequeue();
|
|
foreach (var adjacent in zones[current].AdjacentZoneIndices ?? Array.Empty<int>())
|
|
{
|
|
if (!zones.ContainsKey(adjacent) || previous.ContainsKey(adjacent))
|
|
continue;
|
|
previous[adjacent] = current;
|
|
if (adjacent == target)
|
|
{
|
|
var route = new List<int> { target };
|
|
for (var cursor = target; cursor != source; cursor = previous[cursor])
|
|
route.Add(previous[cursor]);
|
|
route.Reverse();
|
|
return route;
|
|
}
|
|
queue.Enqueue(adjacent);
|
|
}
|
|
}
|
|
return Array.Empty<int>();
|
|
}
|
|
|
|
private static IReadOnlyList<AetheriaRuntimeDaemonCommandDocument> PlanMining(
|
|
AetheriaRuntimeZoneSnapshotCommit zone,
|
|
AetheriaRuntimeAgentTaskCommit task,
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
long frameId,
|
|
AetheriaRuntimeCatalogSnapshot? catalog,
|
|
double simulationTimeSeconds)
|
|
{
|
|
var home = zone.Entities.FirstOrDefault(entity => entity != null && entity.EntityIndex == task.OriginEntityIndex);
|
|
if (string.Equals(task.Phase, "offload", StringComparison.Ordinal) ||
|
|
AetheriaRuntimeCargoCapacityQueries.Available(agent, catalog) < 1)
|
|
{
|
|
if (home == null)
|
|
{
|
|
Fail(task, agent);
|
|
return Array.Empty<AetheriaRuntimeDaemonCommandDocument>();
|
|
}
|
|
task.Phase = "offload";
|
|
var homeDx = home.PositionX - agent.PositionX;
|
|
var homeDz = home.PositionZ - agent.PositionZ;
|
|
if (Math.Max(0, Math.Sqrt(homeDx * homeDx + homeDz * homeDz) - InteractionRadius(agent) - InteractionRadius(home)) > Math.Max(0.01, task.CompletionRadius))
|
|
return new[] { Movement(task, agent, frameId, homeDx, homeDz, 1) };
|
|
|
|
var commodity = (agent.CargoContents ?? Array.Empty<AetheriaRuntimeCargoBayLoadoutCommit>())
|
|
.SelectMany((bay, bayIndex) => (bay?.Items ?? Array.Empty<AetheriaRuntimeLoadoutItemSlotCommit>())
|
|
.Where(slot => slot?.Item != null && !string.IsNullOrWhiteSpace(catalog?.FindItem(slot.Item.ItemKey)?.SimpleCommodityCategory))
|
|
.Select(slot => (BayIndex: bayIndex, Slot: slot)))
|
|
.FirstOrDefault();
|
|
if (commodity.Slot == null)
|
|
{
|
|
task.Phase = "mining";
|
|
return new[] { Movement(task, agent, frameId, 0, 0, 0) };
|
|
}
|
|
var quantity = Math.Min(commodity.Slot.Item.Quantity,
|
|
AetheriaRuntimeCargoCapacityQueries.UnitsThatFit(home, catalog, commodity.Slot.Item.ItemKey));
|
|
if (quantity <= 0)
|
|
{
|
|
Complete(task, agent, frameId);
|
|
return new[] { Movement(task, agent, frameId, 0, 0, 0) };
|
|
}
|
|
return new[]
|
|
{
|
|
Movement(task, agent, frameId, 0, 0, 0),
|
|
Command(task, agent, frameId, AetheriaRuntimeDaemonCommandKinds.TransferCargoItem, "offload", command =>
|
|
{
|
|
command.TextValue = commodity.Slot.Item.ItemKey;
|
|
command.ScalarValue = quantity;
|
|
command.TargetEntityKey = $"zone.{task.ZoneIndex}.entity.{home.EntityIndex}";
|
|
command.CargoTransfer = new AetheriaRuntimeCargoTransferCommand
|
|
{
|
|
OriginEntityKey = $"zone.{task.ZoneIndex}.entity.{agent.EntityIndex}",
|
|
OriginCargoIndex = commodity.BayIndex,
|
|
DestinationEntityKey = $"zone.{task.ZoneIndex}.entity.{home.EntityIndex}",
|
|
DestinationCargoIndex = 0,
|
|
SourceX = commodity.Slot.X,
|
|
SourceY = commodity.Slot.Y,
|
|
Quantity = quantity
|
|
};
|
|
})
|
|
};
|
|
}
|
|
var tool = AetheriaRuntimeEquippedBehaviorQueries.FindOperational(agent, catalog, "MiningTool").FirstOrDefault();
|
|
var bodyKey = (task.TargetBodyKeys ?? Array.Empty<string>()).FirstOrDefault() ?? "";
|
|
var body = (zone.Bodies ?? Array.Empty<AetheriaRuntimeBodySnapshotCommit>())
|
|
.FirstOrDefault(candidate => candidate != null && string.Equals(candidate.BodyKey, bodyKey, StringComparison.Ordinal));
|
|
if (tool == null || body == null)
|
|
{
|
|
Fail(task, agent);
|
|
return Array.Empty<AetheriaRuntimeDaemonCommandDocument>();
|
|
}
|
|
|
|
var asteroid = AetheriaRuntimeDaemonRenderQueries.QueryAsteroidInstancePoses(zone, bodyKey, simulationTimeSeconds)
|
|
.Where(pose => pose.AsteroidIndex >= 0 && pose.AsteroidIndex < body.Asteroids.Count && body.Asteroids[pose.AsteroidIndex].RespawnTimer <= 0)
|
|
.OrderBy(pose => Math.Pow(pose.PositionX - agent.PositionX, 2) + Math.Pow(pose.PositionZ - agent.PositionZ, 2))
|
|
.FirstOrDefault();
|
|
if (asteroid.BodyKey == null)
|
|
return new[] { Movement(task, agent, frameId, 0, 0, 0) };
|
|
|
|
var dx = asteroid.PositionX - agent.PositionX;
|
|
var dz = asteroid.PositionZ - agent.PositionZ;
|
|
var distance = Math.Sqrt(dx * dx + dz * dz);
|
|
var range = Math.Max(0.01, tool.EvaluateStat(4));
|
|
if (distance > range)
|
|
return new[] { Movement(task, agent, frameId, dx, dz, 1) };
|
|
|
|
task.Phase = "mining";
|
|
return new[]
|
|
{
|
|
Movement(task, agent, frameId, 0, 0, 0),
|
|
Command(task, agent, frameId, AetheriaRuntimeDaemonCommandKinds.SetBehaviorActive, "mine", command =>
|
|
{
|
|
command.EquipmentIndex = tool.EquipmentIndex;
|
|
command.BehaviorIndex = tool.BehaviorIndex;
|
|
command.ScalarValue = 1;
|
|
command.TextValue = bodyKey;
|
|
command.PositionX = asteroid.AsteroidIndex;
|
|
})
|
|
};
|
|
}
|
|
|
|
private static IReadOnlyList<AetheriaRuntimeDaemonCommandDocument> PlanSurvey(
|
|
AetheriaRuntimeRunCheckpointCommit run,
|
|
AetheriaRuntimeZoneSnapshotCommit zone,
|
|
AetheriaRuntimeAgentTaskCommit task,
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
long frameId,
|
|
AetheriaRuntimeCatalogSnapshot? catalog,
|
|
double simulationTimeSeconds)
|
|
{
|
|
var scanner = AetheriaRuntimeEquippedBehaviorQueries.FindOperational(agent, catalog, "ResourceScanner").FirstOrDefault();
|
|
if (scanner == null) { Fail(task, agent); return Array.Empty<AetheriaRuntimeDaemonCommandDocument>(); }
|
|
var minimumDensity = scanner.EvaluateStat(2);
|
|
var surveyed = new HashSet<string>((run.CorporationSurveys ?? Array.Empty<AetheriaRuntimeCorporationSurveyCommit>())
|
|
.Where(value => string.Equals(value.CorporationKey, task.CorporationKey, StringComparison.Ordinal) && value.DensityFloor + 0.5 >= minimumDensity)
|
|
.Select(value => value.BodyKey), StringComparer.Ordinal);
|
|
var targets = (task.TargetBodyKeys ?? Array.Empty<string>()).Where(key => !surveyed.Contains(key)).ToArray();
|
|
if (targets.Length == 0) { Complete(task, agent, frameId); return new[] { Movement(task, agent, frameId, 0, 0, 0) }; }
|
|
|
|
var candidates = targets.SelectMany(key =>
|
|
{
|
|
var body = (zone.Bodies ?? Array.Empty<AetheriaRuntimeBodySnapshotCommit>()).FirstOrDefault(value => value != null && string.Equals(value.BodyKey, key, StringComparison.Ordinal));
|
|
if (body == null) return Array.Empty<(string Key, int Asteroid, double X, double Z)>();
|
|
if (string.Equals(body.Kind, "asteroid_belt", StringComparison.OrdinalIgnoreCase))
|
|
return AetheriaRuntimeDaemonRenderQueries.QueryAsteroidInstancePoses(zone, key, simulationTimeSeconds)
|
|
.Select(pose => (Key: key, Asteroid: pose.AsteroidIndex, X: pose.PositionX, Z: pose.PositionZ)).ToArray();
|
|
var pose = AetheriaRuntimeDaemonRenderQueries.QueryBodyPoses(zone).FirstOrDefault(value => string.Equals(value.BodyKey, key, StringComparison.Ordinal));
|
|
return string.IsNullOrWhiteSpace(pose.BodyKey)
|
|
? Array.Empty<(string Key, int Asteroid, double X, double Z)>()
|
|
: new[] { (Key: key, Asteroid: -1, X: pose.CenterX, Z: pose.CenterZ) };
|
|
}).OrderBy(value => Math.Pow(value.X - agent.PositionX, 2) + Math.Pow(value.Z - agent.PositionZ, 2)).FirstOrDefault();
|
|
if (string.IsNullOrWhiteSpace(candidates.Key)) { Fail(task, agent); return Array.Empty<AetheriaRuntimeDaemonCommandDocument>(); }
|
|
var dx = candidates.X - agent.PositionX; var dz = candidates.Z - agent.PositionZ;
|
|
if (Math.Sqrt(dx * dx + dz * dz) >= Math.Max(0.01, scanner.EvaluateStat(1)))
|
|
return new[] { Movement(task, agent, frameId, dx, dz, 1) };
|
|
task.Phase = "scanning";
|
|
return new[]
|
|
{
|
|
Movement(task, agent, frameId, 0, 0, 0),
|
|
Command(task, agent, frameId, AetheriaRuntimeDaemonCommandKinds.SetBehaviorActive, "scan", command =>
|
|
{
|
|
command.EquipmentIndex = scanner.EquipmentIndex; command.BehaviorIndex = scanner.BehaviorIndex;
|
|
command.ScalarValue = 1; command.TextValue = candidates.Key; command.PositionX = candidates.Asteroid;
|
|
})
|
|
};
|
|
}
|
|
|
|
private static IReadOnlyList<AetheriaRuntimeDaemonCommandDocument> PlanHaul(
|
|
AetheriaRuntimeRunCheckpointCommit run,
|
|
AetheriaRuntimeZoneSnapshotCommit zone,
|
|
AetheriaRuntimeAgentTaskCommit task,
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
long frameId)
|
|
{
|
|
var pickup = !string.Equals(task.Phase, "delivery", StringComparison.Ordinal);
|
|
var endpointIndex = pickup ? task.OriginEntityIndex : task.TargetEntityIndex;
|
|
var endpoint = zone.Entities.FirstOrDefault(entity => entity != null && entity.EntityIndex == endpointIndex);
|
|
if (endpoint == null)
|
|
{
|
|
Fail(task, agent);
|
|
return Array.Empty<AetheriaRuntimeDaemonCommandDocument>();
|
|
}
|
|
|
|
var dx = endpoint.PositionX - agent.PositionX;
|
|
var dz = endpoint.PositionZ - agent.PositionZ;
|
|
var distance = Math.Max(0, Math.Sqrt(dx * dx + dz * dz) - InteractionRadius(agent) - InteractionRadius(endpoint));
|
|
if (distance > Math.Max(0.01, task.CompletionRadius))
|
|
return new[] { Movement(task, agent, frameId, dx, dz, 1) };
|
|
|
|
var source = pickup ? endpoint : agent;
|
|
var destination = pickup ? agent : endpoint;
|
|
var sourceSlot = (source.CargoContents ?? Array.Empty<AetheriaRuntimeCargoBayLoadoutCommit>())
|
|
.SelectMany((bay, bayIndex) => (bay?.Items ?? Array.Empty<AetheriaRuntimeLoadoutItemSlotCommit>())
|
|
.Where(slot => string.Equals(slot?.Item?.ItemKey, task.ItemKey, StringComparison.Ordinal))
|
|
.Select(slot => (BayIndex: bayIndex, Slot: slot)))
|
|
.FirstOrDefault();
|
|
if (sourceSlot.Slot == null)
|
|
{
|
|
Fail(task, agent);
|
|
return Array.Empty<AetheriaRuntimeDaemonCommandDocument>();
|
|
}
|
|
|
|
var remaining = task.RequestedQuantity - task.DeliveredQuantity;
|
|
var quantity = Math.Min(remaining, Math.Max(1, sourceSlot.Slot.Item.Quantity));
|
|
task.PendingQuantity = quantity;
|
|
var transfer = Command(task, agent, frameId, AetheriaRuntimeDaemonCommandKinds.TransferCargoItem,
|
|
pickup ? "pickup" : "delivery", command =>
|
|
{
|
|
command.TextValue = task.ItemKey;
|
|
command.ScalarValue = quantity;
|
|
command.TargetEntityKey = EntityKey(run, task.ZoneIndex, destination.EntityIndex);
|
|
command.CargoTransfer = new AetheriaRuntimeCargoTransferCommand
|
|
{
|
|
OriginEntityKey = EntityKey(run, task.ZoneIndex, source.EntityIndex),
|
|
OriginCargoIndex = sourceSlot.BayIndex,
|
|
DestinationEntityKey = EntityKey(run, task.ZoneIndex, destination.EntityIndex),
|
|
DestinationCargoIndex = 0,
|
|
SourceX = sourceSlot.Slot.X,
|
|
SourceY = sourceSlot.Slot.Y,
|
|
Quantity = quantity
|
|
};
|
|
});
|
|
return new[]
|
|
{
|
|
Movement(task, agent, frameId, 0, 0, 0),
|
|
transfer
|
|
};
|
|
}
|
|
|
|
private static IReadOnlyList<AetheriaRuntimeDaemonCommandDocument> PlanTow(
|
|
AetheriaRuntimeRunCheckpointCommit run,
|
|
AetheriaRuntimeZoneSnapshotCommit zone,
|
|
AetheriaRuntimeAgentTaskCommit task,
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
long frameId)
|
|
{
|
|
var station = zone.Entities.FirstOrDefault(value => value != null && value.EntityIndex == task.TargetEntityIndex);
|
|
var parentBody = (zone.Bodies ?? Array.Empty<AetheriaRuntimeBodySnapshotCommit>())
|
|
.FirstOrDefault(value => value != null && string.Equals(value.BodyKey, task.OrbitParentKey, StringComparison.Ordinal));
|
|
var parent = AetheriaRuntimeDaemonRenderQueries.QueryBodyPoses(zone)
|
|
.FirstOrDefault(value => string.Equals(value.BodyKey, task.OrbitParentKey, StringComparison.Ordinal));
|
|
if (station == null || parentBody == null || string.IsNullOrWhiteSpace(parent.BodyKey) || string.IsNullOrWhiteSpace(parentBody.OrbitKey)) { Fail(task, agent); return Array.Empty<AetheriaRuntimeDaemonCommandDocument>(); }
|
|
var attached = (agent.ChildEntityIndices ?? Array.Empty<int>()).Contains(station.EntityIndex);
|
|
if (!attached)
|
|
{
|
|
var dx = station.PositionX - agent.PositionX; var dz = station.PositionZ - agent.PositionZ;
|
|
if (Math.Sqrt(dx * dx + dz * dz) > Math.Max(0.01, task.CompletionRadius))
|
|
return new[] { Movement(task, agent, frameId, dx, dz, 1) };
|
|
task.Phase = "pickup";
|
|
return new[] { Movement(task, agent, frameId, 0, 0, 0), Command(task, agent, frameId, AetheriaRuntimeDaemonCommandKinds.TowToStation, "attach", command => { command.TargetEntityKey = EntityKey(run, task.ZoneIndex, station.EntityIndex); command.TextValue = "attach"; }) };
|
|
}
|
|
task.Phase = "delivery";
|
|
var radialX = agent.PositionX - parent.CenterX; var radialZ = agent.PositionZ - parent.CenterZ;
|
|
var length = Math.Sqrt(radialX * radialX + radialZ * radialZ);
|
|
if (length < 0.001) { radialX = 1; radialZ = 0; length = 1; }
|
|
var destinationX = parent.CenterX + radialX / length * task.OrbitDistance;
|
|
var destinationZ = parent.CenterZ + radialZ / length * task.OrbitDistance;
|
|
var dxDelivery = destinationX - agent.PositionX; var dzDelivery = destinationZ - agent.PositionZ;
|
|
if (Math.Sqrt(dxDelivery * dxDelivery + dzDelivery * dzDelivery) > Math.Max(0.01, task.CompletionRadius))
|
|
return new[] { Movement(task, agent, frameId, dxDelivery, dzDelivery, 1) };
|
|
task.Phase = "detach";
|
|
return new[] { Movement(task, agent, frameId, 0, 0, 0), Command(task, agent, frameId, AetheriaRuntimeDaemonCommandKinds.TowToStation, "detach", command => { command.TargetEntityKey = EntityKey(run, task.ZoneIndex, station.EntityIndex); command.TextValue = "detach"; command.SubjectKey = parentBody.OrbitKey; command.ScalarValue = task.OrbitDistance; command.PositionX = destinationX; command.PositionZ = destinationZ; }) };
|
|
}
|
|
|
|
private static IReadOnlyList<AetheriaRuntimeDaemonCommandDocument> PlanPatrol(
|
|
AetheriaRuntimeZoneSnapshotCommit zone,
|
|
AetheriaRuntimeAgentTaskCommit task,
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
long frameId)
|
|
{
|
|
var circuit = (task.TargetOrbitKeys ?? Array.Empty<string>())
|
|
.Where(key => !string.IsNullOrWhiteSpace(key))
|
|
.ToArray();
|
|
if (circuit.Length == 0)
|
|
{
|
|
var bodyOrbits = (zone.Bodies ?? Array.Empty<AetheriaRuntimeBodySnapshotCommit>())
|
|
.Where(body => body != null && !string.IsNullOrWhiteSpace(body.BodyKey))
|
|
.ToDictionary(body => body.BodyKey, body => body.OrbitKey ?? "", StringComparer.Ordinal);
|
|
circuit = (task.TargetBodyKeys ?? Array.Empty<string>())
|
|
.Select(key => bodyOrbits.TryGetValue(key, out var orbitKey) ? orbitKey : "")
|
|
.Where(key => !string.IsNullOrWhiteSpace(key))
|
|
.ToArray();
|
|
}
|
|
if (circuit.Length == 0)
|
|
{
|
|
Fail(task, agent);
|
|
return Array.Empty<AetheriaRuntimeDaemonCommandDocument>();
|
|
}
|
|
|
|
task.CircuitIndex = ((task.CircuitIndex % circuit.Length) + circuit.Length) % circuit.Length;
|
|
var positions = AetheriaRuntimeOrbitQueries.BuildPositions(zone);
|
|
if (!positions.TryGetValue(circuit[task.CircuitIndex], out var destination))
|
|
{
|
|
Fail(task, agent);
|
|
return Array.Empty<AetheriaRuntimeDaemonCommandDocument>();
|
|
}
|
|
|
|
var dx = destination.x - agent.PositionX;
|
|
var dz = destination.z - agent.PositionZ;
|
|
var distance = Math.Sqrt(dx * dx + dz * dz);
|
|
if (distance <= Math.Max(0.01, task.CompletionRadius))
|
|
{
|
|
task.CircuitIndex = (task.CircuitIndex + 1) % circuit.Length;
|
|
if (!positions.TryGetValue(circuit[task.CircuitIndex], out var next))
|
|
{
|
|
Fail(task, agent);
|
|
return Array.Empty<AetheriaRuntimeDaemonCommandDocument>();
|
|
}
|
|
dx = next.x - agent.PositionX;
|
|
dz = next.z - agent.PositionZ;
|
|
}
|
|
return new[] { Movement(task, agent, frameId, dx, dz, 1) };
|
|
}
|
|
|
|
private static AetheriaRuntimeEntitySnapshotCommit? FirstVisibleHostileShip(
|
|
AetheriaRuntimeZoneSnapshotCommit zone,
|
|
AetheriaRuntimeEntitySnapshotCommit agent)
|
|
{
|
|
var hostileIndices = (agent.Contacts ?? Array.Empty<AetheriaRuntimeEntityContactCommit>())
|
|
.Where(contact => contact != null && contact.Visible && contact.Hostile)
|
|
.Select(contact => contact.TargetEntityIndex)
|
|
.ToArray();
|
|
foreach (var index in hostileIndices)
|
|
{
|
|
var target = (zone.Entities ?? Array.Empty<AetheriaRuntimeEntitySnapshotCommit>())
|
|
.FirstOrDefault(entity => entity != null && entity.EntityIndex == index &&
|
|
entity.IsActive && string.Equals(entity.Kind, "ship", StringComparison.OrdinalIgnoreCase));
|
|
if (target != null)
|
|
return target;
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private static AetheriaRuntimeDaemonCommandDocument Movement(
|
|
AetheriaRuntimeAgentTaskCommit task,
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
long frameId,
|
|
double dx,
|
|
double dz,
|
|
double magnitude)
|
|
{
|
|
return Command(task, agent, frameId, AetheriaRuntimeDaemonCommandKinds.SetMoveVector, "move", command =>
|
|
{
|
|
SetLocalHelmAxes(command, agent, dx, dz, magnitude);
|
|
});
|
|
}
|
|
|
|
private static AetheriaRuntimeDaemonCommandDocument MovementFromZone(
|
|
AetheriaRuntimeAgentTaskCommit task,
|
|
int zoneIndex,
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
long frameId,
|
|
double dx,
|
|
double dz)
|
|
{
|
|
var command = AetheriaRuntimeDaemonCommandDocument.Create(
|
|
AetheriaRuntimeDaemonCommandKinds.SetMoveVector,
|
|
RuntimeId,
|
|
"daemon-agent-scheduler",
|
|
frameId,
|
|
$"zone.{zoneIndex}.entity.{agent.EntityIndex}");
|
|
command.CommandId = CommandId(task, frameId, "travel-approach");
|
|
var length = Math.Sqrt(dx * dx + dz * dz);
|
|
SetLocalHelmAxes(command, agent, dx, dz, length <= 0.0001 ? 0 : 1);
|
|
return command;
|
|
}
|
|
|
|
private static void SetLocalHelmAxes(
|
|
AetheriaRuntimeDaemonCommandDocument command,
|
|
AetheriaRuntimeEntitySnapshotCommit entity,
|
|
double worldX,
|
|
double worldZ,
|
|
double magnitude)
|
|
{
|
|
var desiredLength = Math.Sqrt(worldX * worldX + worldZ * worldZ);
|
|
if (desiredLength <= 0.0001 || magnitude <= 0)
|
|
{
|
|
command.DirectionX = 0;
|
|
command.DirectionY = 0;
|
|
command.ScalarValue = 0;
|
|
return;
|
|
}
|
|
|
|
var forwardLength = Math.Sqrt(
|
|
entity.DirectionX * entity.DirectionX + entity.DirectionY * entity.DirectionY);
|
|
var forwardX = forwardLength <= 0.0001 ? 0 : entity.DirectionX / forwardLength;
|
|
var forwardZ = forwardLength <= 0.0001 ? 1 : entity.DirectionY / forwardLength;
|
|
var desiredX = worldX / desiredLength;
|
|
var desiredZ = worldZ / desiredLength;
|
|
var rightX = forwardZ;
|
|
var rightZ = -forwardX;
|
|
command.DirectionX = desiredX * rightX + desiredZ * rightZ;
|
|
command.DirectionY = desiredX * forwardX + desiredZ * forwardZ;
|
|
command.ScalarValue = Math.Min(1, magnitude);
|
|
}
|
|
|
|
private static double InteractionRadius(AetheriaRuntimeEntitySnapshotCommit entity) =>
|
|
string.Equals(entity.Kind, "station", StringComparison.OrdinalIgnoreCase) ? 48 : 20;
|
|
|
|
private static AetheriaRuntimeDaemonCommandDocument Command(
|
|
AetheriaRuntimeAgentTaskCommit task,
|
|
AetheriaRuntimeEntitySnapshotCommit agent,
|
|
long frameId,
|
|
AetheriaRuntimeDaemonCommandKinds kind,
|
|
string phase,
|
|
Action<AetheriaRuntimeDaemonCommandDocument> configure)
|
|
{
|
|
var actor = $"zone.{task.ZoneIndex}.entity.{agent.EntityIndex}";
|
|
var command = AetheriaRuntimeDaemonCommandDocument.Create(kind, RuntimeId, "daemon-agent-scheduler", frameId, actor);
|
|
command.CommandId = CommandId(task, frameId, phase);
|
|
configure(command);
|
|
return command;
|
|
}
|
|
|
|
private static void Complete(AetheriaRuntimeAgentTaskCommit task, AetheriaRuntimeEntitySnapshotCommit agent, long frameId)
|
|
{
|
|
task.Status = AetheriaRuntimeAgentTaskStatuses.Completed;
|
|
task.CompletedFrameId = frameId;
|
|
ReleaseControls(agent, task);
|
|
}
|
|
|
|
private static void Fail(AetheriaRuntimeAgentTaskCommit task, AetheriaRuntimeEntitySnapshotCommit agent)
|
|
{
|
|
task.Status = AetheriaRuntimeAgentTaskStatuses.Failed;
|
|
task.PendingQuantity = 0;
|
|
ReleaseControls(agent, task);
|
|
}
|
|
|
|
private static string CommandId(AetheriaRuntimeAgentTaskCommit task, long frameId, string phase) =>
|
|
string.Join(":", RuntimeId, task.TaskId, frameId.ToString(CultureInfo.InvariantCulture), phase);
|
|
|
|
private static AetheriaRuntimeEntitySnapshotCommit? FindEntity(
|
|
AetheriaRuntimeRunCheckpointCommit run,
|
|
int zoneIndex,
|
|
int entityIndex) =>
|
|
(run.Zones ?? Array.Empty<AetheriaRuntimeZoneSnapshotCommit>())
|
|
.FirstOrDefault(zone => zone != null && zone.ZoneIndex == zoneIndex)
|
|
?.Entities?.FirstOrDefault(entity => entity != null && entity.EntityIndex == entityIndex);
|
|
|
|
private static void ReleaseInvalidAssignments(AetheriaRuntimeRunCheckpointCommit run)
|
|
{
|
|
var tasks = (run.AgentTasks ?? Array.Empty<AetheriaRuntimeAgentTaskCommit>())
|
|
.Where(task => task != null)
|
|
.ToArray();
|
|
var entities = (run.Zones ?? Array.Empty<AetheriaRuntimeZoneSnapshotCommit>())
|
|
.Where(zone => zone != null)
|
|
.SelectMany(zone => zone.Entities ?? Array.Empty<AetheriaRuntimeEntitySnapshotCommit>())
|
|
.Where(entity => entity != null)
|
|
.ToArray();
|
|
var activeTaskIds = tasks
|
|
.Where(task => task != null && string.Equals(task.Status, AetheriaRuntimeAgentTaskStatuses.Assigned, StringComparison.Ordinal))
|
|
.Select(task => task.TaskId)
|
|
.ToHashSet(StringComparer.Ordinal);
|
|
foreach (var entity in entities)
|
|
{
|
|
if (!string.IsNullOrWhiteSpace(entity.AssignedAgentTaskId) &&
|
|
(!entity.IsActive || !activeTaskIds.Contains(entity.AssignedAgentTaskId)))
|
|
ReleaseControls(entity, tasks.FirstOrDefault(task =>
|
|
string.Equals(task.TaskId, entity.AssignedAgentTaskId, StringComparison.Ordinal)));
|
|
}
|
|
foreach (var task in tasks.Where(task => string.Equals(task.Status, AetheriaRuntimeAgentTaskStatuses.Assigned, StringComparison.Ordinal)))
|
|
{
|
|
var carriers = entities
|
|
.Where(entity => entity.IsActive && string.Equals(entity.AssignedAgentTaskId, task.TaskId, StringComparison.Ordinal))
|
|
.OrderBy(entity => entity.EntityIndex)
|
|
.ToArray();
|
|
if (carriers.Length == 0)
|
|
{
|
|
task.Status = AetheriaRuntimeAgentTaskStatuses.Queued;
|
|
task.AssignedEntityIndex = -1;
|
|
task.AssignedFrameId = -1;
|
|
continue;
|
|
}
|
|
task.AssignedEntityIndex = carriers[0].EntityIndex;
|
|
foreach (var duplicate in carriers.Skip(1))
|
|
ReleaseControls(duplicate, task);
|
|
}
|
|
}
|
|
|
|
private static string EntityKey(AetheriaRuntimeRunCheckpointCommit run, int zoneIndex, int entityIndex) =>
|
|
AetheriaRuntimeRunCheckpointCommit.EntityRecordKey(run.RunId, zoneIndex, entityIndex);
|
|
}
|
|
}
|