786 lines
34 KiB
C#
786 lines
34 KiB
C#
using static SpaceGame.Api.Shared.Runtime.SimulationRuntimeSupport;
|
|
using static SpaceGame.Api.Shared.Runtime.ShipBehaviorKinds;
|
|
using static SpaceGame.Api.Stations.Simulation.InfrastructureSimulationService;
|
|
|
|
namespace SpaceGame.Api.Ships.AI;
|
|
|
|
public sealed partial class ShipAiService
|
|
{
|
|
private static ShipOrderRuntime? GetTopOrder(ShipRuntime ship) =>
|
|
ship.OrderQueue
|
|
.Where(order => order.Status is OrderStatus.Queued or OrderStatus.Active)
|
|
.OrderByDescending(GetOrderSourcePriority)
|
|
.ThenByDescending(order => order.Priority)
|
|
.ThenBy(order => order.CreatedAtUtc)
|
|
.FirstOrDefault();
|
|
|
|
private static int GetOrderSourcePriority(ShipOrderRuntime order) => order.SourceKind switch
|
|
{
|
|
ShipOrderSourceKind.Player => 300,
|
|
ShipOrderSourceKind.Commander => 200,
|
|
ShipOrderSourceKind.Behavior => 100,
|
|
_ => 0,
|
|
};
|
|
|
|
private void SyncBehaviorOrders(SimulationWorld world, ShipRuntime ship)
|
|
{
|
|
var desiredOrder = BuildManagedBehaviorOrder(world, ship);
|
|
ship.OrderQueue.RemoveAll(order =>
|
|
order.SourceKind == ShipOrderSourceKind.Behavior
|
|
&& (desiredOrder is null || !string.Equals(order.Id, desiredOrder.Id, StringComparison.Ordinal)));
|
|
|
|
if (desiredOrder is null)
|
|
{
|
|
return;
|
|
}
|
|
|
|
var existing = ship.OrderQueue.FirstOrDefault(order => string.Equals(order.Id, desiredOrder.Id, StringComparison.Ordinal));
|
|
if (existing is null)
|
|
{
|
|
ship.OrderQueue.Add(desiredOrder);
|
|
return;
|
|
}
|
|
|
|
if (ManagedOrdersEqual(existing, desiredOrder))
|
|
{
|
|
return;
|
|
}
|
|
|
|
ship.OrderQueue.Remove(existing);
|
|
ship.OrderQueue.Add(desiredOrder);
|
|
}
|
|
|
|
private ShipOrderRuntime? BuildManagedBehaviorOrder(SimulationWorld world, ShipRuntime ship)
|
|
{
|
|
var assignment = ResolveAssignment(world, ship);
|
|
var behaviorKind = assignment?.BehaviorKind ?? ship.DefaultBehavior.Kind;
|
|
var systemId = assignment?.TargetSystemId ?? ship.DefaultBehavior.AreaSystemId ?? ship.SystemId;
|
|
|
|
if (string.Equals(behaviorKind, HoldPosition, StringComparison.Ordinal))
|
|
{
|
|
return new ShipOrderRuntime
|
|
{
|
|
Id = $"behavior-{ship.Id}-hold-position",
|
|
Kind = ShipOrderKinds.HoldPosition,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = "Hold position",
|
|
TargetSystemId = systemId,
|
|
TargetPosition = ship.DefaultBehavior.TargetPosition ?? ship.Position,
|
|
WaitSeconds = MathF.Max(2f, ship.DefaultBehavior.WaitSeconds),
|
|
Radius = ship.DefaultBehavior.Radius,
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, DockAndWait, StringComparison.Ordinal))
|
|
{
|
|
var station = ResolveStation(world, assignment?.TargetEntityId ?? ship.DefaultBehavior.TargetEntityId ?? ship.DefaultBehavior.HomeStationId);
|
|
if (station is null)
|
|
{
|
|
ship.LastAccessFailureReason = "station-missing";
|
|
return null;
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return new ShipOrderRuntime
|
|
{
|
|
Id = $"behavior-{ship.Id}-dock-and-wait",
|
|
Kind = ShipOrderKinds.DockAndWait,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = $"Dock and wait at {station.Label}",
|
|
TargetEntityId = station.Id,
|
|
TargetSystemId = station.SystemId,
|
|
DestinationStationId = station.Id,
|
|
WaitSeconds = MathF.Max(2f, ship.DefaultBehavior.WaitSeconds),
|
|
Radius = ship.DefaultBehavior.Radius,
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, FlyAndWait, StringComparison.Ordinal))
|
|
{
|
|
ship.LastAccessFailureReason = null;
|
|
return new ShipOrderRuntime
|
|
{
|
|
Id = $"behavior-{ship.Id}-fly-and-wait",
|
|
Kind = ShipOrderKinds.FlyAndWait,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = "Fly and wait",
|
|
TargetSystemId = systemId,
|
|
TargetPosition = ship.DefaultBehavior.TargetPosition ?? ship.Position,
|
|
WaitSeconds = MathF.Max(2f, ship.DefaultBehavior.WaitSeconds),
|
|
Radius = ship.DefaultBehavior.Radius,
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, FollowShip, StringComparison.Ordinal))
|
|
{
|
|
var targetShip = world.Ships.FirstOrDefault(candidate =>
|
|
candidate.Id == (assignment?.TargetEntityId ?? ship.DefaultBehavior.TargetEntityId)
|
|
&& candidate.Health > 0f);
|
|
if (targetShip is null)
|
|
{
|
|
ship.LastAccessFailureReason = "target-ship-missing";
|
|
return null;
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return new ShipOrderRuntime
|
|
{
|
|
Id = $"behavior-{ship.Id}-follow-ship",
|
|
Kind = ShipOrderKinds.FollowShip,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = $"Follow {targetShip.Definition.Name}",
|
|
TargetEntityId = targetShip.Id,
|
|
TargetSystemId = targetShip.SystemId,
|
|
WaitSeconds = MathF.Max(2f, ship.DefaultBehavior.WaitSeconds),
|
|
Radius = MathF.Max(16f, ship.DefaultBehavior.Radius),
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, FlyToObject, StringComparison.Ordinal))
|
|
{
|
|
var targetEntityId = assignment?.TargetEntityId ?? ship.DefaultBehavior.TargetEntityId;
|
|
var target = ResolveObjectTarget(world, targetEntityId);
|
|
if (target is null)
|
|
{
|
|
ship.LastAccessFailureReason = "target-missing";
|
|
return null;
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return new ShipOrderRuntime
|
|
{
|
|
Id = $"behavior-{ship.Id}-fly-to-object",
|
|
Kind = ShipOrderKinds.FlyToObject,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = "Fly to object",
|
|
TargetEntityId = targetEntityId,
|
|
TargetSystemId = target.Value.SystemId,
|
|
TargetPosition = target.Value.Position,
|
|
WaitSeconds = MathF.Max(1f, ship.DefaultBehavior.WaitSeconds),
|
|
Radius = MathF.Max(8f, ship.DefaultBehavior.Radius),
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, Patrol, StringComparison.Ordinal))
|
|
{
|
|
return BuildManagedPatrolOrder(world, ship, assignment, behaviorKind);
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, AttackTarget, StringComparison.Ordinal))
|
|
{
|
|
var targetEntityId = assignment?.TargetEntityId ?? ship.DefaultBehavior.TargetEntityId;
|
|
if (string.IsNullOrWhiteSpace(targetEntityId))
|
|
{
|
|
return BuildManagedPatrolOrder(world, ship, assignment, behaviorKind);
|
|
}
|
|
|
|
var target = ResolveObjectTarget(world, targetEntityId);
|
|
ship.LastAccessFailureReason = target is null ? "target-missing" : null;
|
|
return new ShipOrderRuntime
|
|
{
|
|
Id = $"behavior-{ship.Id}-attack-target",
|
|
Kind = ShipOrderKinds.AttackTarget,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = "Attack target",
|
|
TargetEntityId = targetEntityId,
|
|
TargetSystemId = target?.SystemId ?? assignment?.TargetSystemId ?? ship.DefaultBehavior.AreaSystemId ?? ship.SystemId,
|
|
TargetPosition = target?.Position ?? ship.Position,
|
|
WaitSeconds = 0f,
|
|
Radius = 26f,
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, ConstructStation, StringComparison.Ordinal))
|
|
{
|
|
var site = world.ConstructionSites.FirstOrDefault(candidate => candidate.Id == (assignment?.TargetEntityId ?? ship.DefaultBehavior.PreferredConstructionSiteId))
|
|
?? world.ConstructionSites
|
|
.Where(candidate => candidate.FactionId == ship.FactionId && candidate.State is ConstructionSiteStateKinds.Active or ConstructionSiteStateKinds.Planned)
|
|
.OrderBy(candidate => candidate.Id, StringComparer.Ordinal)
|
|
.FirstOrDefault();
|
|
if (site is null)
|
|
{
|
|
ship.LastAccessFailureReason = "no-construction-site";
|
|
return null;
|
|
}
|
|
|
|
if (ResolveSupportStation(world, ship, site) is null)
|
|
{
|
|
ship.LastAccessFailureReason = "support-station-missing";
|
|
return null;
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return new ShipOrderRuntime
|
|
{
|
|
Id = $"behavior-{ship.Id}-construct-station",
|
|
Kind = ShipOrderKinds.BuildAtSite,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = $"Build {site.BlueprintId}",
|
|
TargetEntityId = site.Id,
|
|
TargetSystemId = site.SystemId,
|
|
ConstructionSiteId = site.Id,
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, AdvancedAutoMine, StringComparison.Ordinal)
|
|
|| string.Equals(behaviorKind, ExpertAutoMine, StringComparison.Ordinal))
|
|
{
|
|
var homeStation = ResolveStation(world, assignment?.HomeStationId ?? ship.DefaultBehavior.HomeStationId);
|
|
if (homeStation is null)
|
|
{
|
|
ship.LastAccessFailureReason = "no-home-station";
|
|
return null;
|
|
}
|
|
|
|
var opportunity = SelectMiningOpportunity(world, ship, homeStation, assignment, behaviorKind);
|
|
if (opportunity is null)
|
|
{
|
|
ship.LastAccessFailureReason = "no-mineable-node";
|
|
return null;
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return new ShipOrderRuntime
|
|
{
|
|
Id = $"behavior-{ship.Id}-{behaviorKind}-mine-and-deliver",
|
|
Kind = ShipOrderKinds.MineAndDeliverRun,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = opportunity.Summary,
|
|
TargetEntityId = opportunity.Node.Id,
|
|
TargetSystemId = opportunity.Node.SystemId,
|
|
DestinationStationId = opportunity.DropOffStation.Id,
|
|
ItemId = opportunity.Node.ItemId,
|
|
AnchorId = opportunity.Node.AnchorId,
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, ProtectPosition, StringComparison.Ordinal))
|
|
{
|
|
var targetSystemId = assignment?.TargetSystemId ?? ship.DefaultBehavior.AreaSystemId ?? ship.SystemId;
|
|
var targetPosition = ship.DefaultBehavior.TargetPosition ?? assignment?.TargetPosition ?? ship.Position;
|
|
var threat = SelectThreatTarget(world, ship, targetSystemId, targetPosition, MathF.Max(90f, ship.DefaultBehavior.Radius));
|
|
if (threat is not null)
|
|
{
|
|
ship.LastAccessFailureReason = null;
|
|
return CreateManagedAttackOrder(ship, behaviorKind, "Protect position", threat.EntityId, threat.SystemId, threat.Position);
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return CreateManagedFlyAndWaitOrder(
|
|
ship,
|
|
behaviorKind,
|
|
"Protect position",
|
|
targetSystemId,
|
|
targetPosition,
|
|
MathF.Max(2f, ship.DefaultBehavior.WaitSeconds),
|
|
MathF.Max(6f, ship.DefaultBehavior.Radius));
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, ProtectShip, StringComparison.Ordinal))
|
|
{
|
|
var guardTarget = world.Ships.FirstOrDefault(candidate =>
|
|
candidate.Id == (assignment?.TargetEntityId ?? ship.DefaultBehavior.TargetEntityId)
|
|
&& candidate.Health > 0f);
|
|
if (guardTarget is null)
|
|
{
|
|
return BuildManagedPatrolOrder(world, ship, assignment, Patrol);
|
|
}
|
|
|
|
var threat = SelectThreatTarget(
|
|
world,
|
|
ship,
|
|
guardTarget.SystemId,
|
|
guardTarget.Position,
|
|
MathF.Max(90f, ship.DefaultBehavior.Radius),
|
|
excludeEntityId: guardTarget.Id);
|
|
if (threat is not null)
|
|
{
|
|
ship.LastAccessFailureReason = null;
|
|
return CreateManagedAttackOrder(ship, behaviorKind, $"Protect {guardTarget.Definition.Name}", threat.EntityId, threat.SystemId, threat.Position);
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return CreateManagedFollowShipOrder(
|
|
ship,
|
|
behaviorKind,
|
|
$"Escort {guardTarget.Definition.Name}",
|
|
guardTarget,
|
|
MathF.Max(18f, ship.DefaultBehavior.Radius * 0.5f),
|
|
MathF.Max(2f, ship.DefaultBehavior.WaitSeconds));
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, ProtectStation, StringComparison.Ordinal))
|
|
{
|
|
var station = ResolveStation(world, assignment?.TargetEntityId ?? ship.DefaultBehavior.TargetEntityId ?? assignment?.HomeStationId ?? ship.DefaultBehavior.HomeStationId);
|
|
if (station is null)
|
|
{
|
|
return BuildManagedPatrolOrder(world, ship, assignment, Patrol);
|
|
}
|
|
|
|
var threat = SelectThreatTarget(world, ship, station.SystemId, station.Position, MathF.Max(station.Radius + 80f, ship.DefaultBehavior.Radius));
|
|
if (threat is not null)
|
|
{
|
|
ship.LastAccessFailureReason = null;
|
|
return CreateManagedAttackOrder(ship, behaviorKind, $"Protect {station.Label}", threat.EntityId, threat.SystemId, threat.Position);
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return CreateManagedFlyAndWaitOrder(
|
|
ship,
|
|
behaviorKind,
|
|
$"Guard {station.Label}",
|
|
station.SystemId,
|
|
GetFormationPosition(station.Position, ship.Id, MathF.Max(station.Radius + 18f, ship.DefaultBehavior.Radius)),
|
|
MathF.Max(2f, ship.DefaultBehavior.WaitSeconds),
|
|
MathF.Max(6f, ship.DefaultBehavior.Radius));
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, Police, StringComparison.Ordinal))
|
|
{
|
|
var homeStation = ResolveStation(world, assignment?.HomeStationId ?? ship.DefaultBehavior.HomeStationId);
|
|
var policeSystemId = assignment?.TargetSystemId ?? ship.DefaultBehavior.AreaSystemId ?? homeStation?.SystemId ?? ship.SystemId;
|
|
var areaPosition = homeStation?.Position ?? ship.DefaultBehavior.TargetPosition ?? ship.Position;
|
|
var contact = SelectPoliceContact(world, ship, policeSystemId, areaPosition, MathF.Max(80f, ship.DefaultBehavior.Radius));
|
|
if (contact is null)
|
|
{
|
|
return BuildManagedPatrolOrder(world, ship, assignment, Patrol);
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return contact.Engage
|
|
? CreateManagedAttackOrder(ship, behaviorKind, "Police engage", contact.EntityId, contact.SystemId, contact.Position)
|
|
: CreateManagedFollowTargetOrder(ship, behaviorKind, "Police inspect", contact.EntityId, contact.SystemId, contact.Position, MathF.Max(14f, ship.DefaultBehavior.Radius * 0.5f), MathF.Max(2f, ship.DefaultBehavior.WaitSeconds));
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, LocalAutoTrade, StringComparison.Ordinal)
|
|
|| string.Equals(behaviorKind, AdvancedAutoTrade, StringComparison.Ordinal)
|
|
|| string.Equals(behaviorKind, FillShortages, StringComparison.Ordinal)
|
|
|| string.Equals(behaviorKind, FindBuildTasks, StringComparison.Ordinal)
|
|
|| string.Equals(behaviorKind, RevisitKnownStations, StringComparison.Ordinal))
|
|
{
|
|
var homeStation = ResolveStation(world, assignment?.HomeStationId ?? ship.DefaultBehavior.HomeStationId);
|
|
var route = SelectTradeRoute(world, ship, homeStation, behaviorKind, ship.DefaultBehavior.KnownStationsOnly);
|
|
if (route is not null)
|
|
{
|
|
ship.LastAccessFailureReason = null;
|
|
return CreateManagedTradeRouteOrder(ship, behaviorKind, route);
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, RevisitKnownStations, StringComparison.Ordinal)
|
|
&& SelectKnownStationVisit(world, ship, homeStation) is { } visitStation)
|
|
{
|
|
ship.LastAccessFailureReason = null;
|
|
return CreateManagedDockAndWaitOrder(ship, behaviorKind, visitStation, MathF.Max(2f, ship.DefaultBehavior.WaitSeconds), $"Revisit {visitStation.Label}");
|
|
}
|
|
|
|
ship.LastAccessFailureReason = "no-trade-route";
|
|
return null;
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, SupplyFleet, StringComparison.Ordinal))
|
|
{
|
|
var homeStation = ResolveStation(world, assignment?.HomeStationId ?? ship.DefaultBehavior.HomeStationId);
|
|
var plan = SelectFleetSupplyPlan(world, ship, homeStation);
|
|
if (plan is null)
|
|
{
|
|
ship.LastAccessFailureReason = "no-fleet-to-supply";
|
|
return null;
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return new ShipOrderRuntime
|
|
{
|
|
Id = $"behavior-{ship.Id}-supply-fleet",
|
|
Kind = ShipOrderKinds.SupplyFleetRun,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = plan.Summary,
|
|
TargetEntityId = plan.TargetShip.Id,
|
|
TargetSystemId = plan.TargetShip.SystemId,
|
|
SourceStationId = plan.SourceStation.Id,
|
|
ItemId = plan.ItemId,
|
|
Radius = plan.Radius,
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, AutoSalvage, StringComparison.Ordinal))
|
|
{
|
|
var homeStation = ResolveStation(world, assignment?.HomeStationId ?? ship.DefaultBehavior.HomeStationId);
|
|
if (homeStation is null)
|
|
{
|
|
ship.LastAccessFailureReason = "no-home-station";
|
|
return null;
|
|
}
|
|
|
|
var salvage = SelectSalvageOpportunity(world, ship, homeStation);
|
|
if (salvage is null)
|
|
{
|
|
ship.LastAccessFailureReason = "no-salvage-target";
|
|
return null;
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return new ShipOrderRuntime
|
|
{
|
|
Id = $"behavior-{ship.Id}-auto-salvage",
|
|
Kind = ShipOrderKinds.SalvageRun,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = salvage.Summary,
|
|
TargetEntityId = salvage.Wreck.Id,
|
|
TargetSystemId = salvage.Wreck.SystemId,
|
|
TargetPosition = salvage.Wreck.Position,
|
|
SourceStationId = homeStation.Id,
|
|
ItemId = salvage.Wreck.ItemId,
|
|
Radius = MathF.Max(8f, ship.DefaultBehavior.Radius * 0.25f),
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
}
|
|
|
|
if (string.Equals(behaviorKind, RepeatOrders, StringComparison.Ordinal))
|
|
{
|
|
if (ship.DefaultBehavior.RepeatOrders.Count == 0)
|
|
{
|
|
ship.LastAccessFailureReason = "no-repeat-orders";
|
|
return null;
|
|
}
|
|
|
|
var template = ship.DefaultBehavior.RepeatOrders[ship.DefaultBehavior.RepeatIndex % ship.DefaultBehavior.RepeatOrders.Count];
|
|
ship.LastAccessFailureReason = null;
|
|
return new ShipOrderRuntime
|
|
{
|
|
Id = $"behavior-{ship.Id}-repeat-{ship.DefaultBehavior.RepeatIndex}",
|
|
Kind = template.Kind,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = template.Label,
|
|
TargetEntityId = template.TargetEntityId,
|
|
TargetSystemId = template.TargetSystemId,
|
|
TargetPosition = template.TargetPosition,
|
|
SourceStationId = template.SourceStationId,
|
|
DestinationStationId = template.DestinationStationId,
|
|
ItemId = template.ItemId,
|
|
AnchorId = template.AnchorId,
|
|
ConstructionSiteId = template.ConstructionSiteId,
|
|
ModuleId = template.ModuleId,
|
|
WaitSeconds = template.WaitSeconds,
|
|
Radius = template.Radius,
|
|
MaxSystemRange = template.MaxSystemRange ?? ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = template.KnownStationsOnly,
|
|
};
|
|
}
|
|
|
|
if (!string.Equals(behaviorKind, LocalAutoMine, StringComparison.Ordinal))
|
|
{
|
|
return null;
|
|
}
|
|
|
|
var itemId = assignment?.ItemId ?? ship.DefaultBehavior.ItemId;
|
|
if (string.IsNullOrWhiteSpace(itemId))
|
|
{
|
|
ship.LastAccessFailureReason = "missing-item";
|
|
return null;
|
|
}
|
|
|
|
if (GetShipCargoAmount(ship) >= ship.Definition.GetTotalCargoCapacity() - 0.01f)
|
|
{
|
|
var buyer = SelectLocalAutoMineBuyer(world, ship, systemId, itemId);
|
|
if (buyer is null)
|
|
{
|
|
ship.LastAccessFailureReason = "no-suitable-buyer";
|
|
return null;
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return new ShipOrderRuntime
|
|
{
|
|
Id = $"behavior-{ship.Id}-local-auto-mine-sell",
|
|
Kind = ShipOrderKinds.SellMinedCargo,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = $"Sell {itemId} in {systemId}",
|
|
TargetEntityId = buyer.Id,
|
|
TargetSystemId = buyer.SystemId,
|
|
DestinationStationId = buyer.Id,
|
|
ItemId = itemId,
|
|
WaitSeconds = 0f,
|
|
Radius = 0f,
|
|
MaxSystemRange = 0,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
}
|
|
|
|
var node = SelectLocalMiningNode(world, ship, systemId, itemId, ship.DefaultBehavior.PreferredAnchorId);
|
|
if (node is null)
|
|
{
|
|
ship.LastAccessFailureReason = "no-mineable-node";
|
|
return null;
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return new ShipOrderRuntime
|
|
{
|
|
Id = $"behavior-{ship.Id}-local-auto-mine-mine",
|
|
Kind = ShipOrderKinds.MineLocal,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = $"Mine {itemId} in {systemId}",
|
|
TargetEntityId = node.Id,
|
|
TargetSystemId = node.SystemId,
|
|
AnchorId = node.AnchorId,
|
|
ItemId = node.ItemId,
|
|
WaitSeconds = 0f,
|
|
Radius = 0f,
|
|
MaxSystemRange = 0,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
}
|
|
|
|
private static bool ManagedOrdersEqual(ShipOrderRuntime left, ShipOrderRuntime right) =>
|
|
string.Equals(left.Id, right.Id, StringComparison.Ordinal)
|
|
&& string.Equals(left.Kind, right.Kind, StringComparison.Ordinal)
|
|
&& left.SourceKind == right.SourceKind
|
|
&& string.Equals(left.SourceId, right.SourceId, StringComparison.Ordinal)
|
|
&& left.Priority == right.Priority
|
|
&& left.InterruptCurrentPlan == right.InterruptCurrentPlan
|
|
&& string.Equals(left.Label, right.Label, StringComparison.Ordinal)
|
|
&& string.Equals(left.TargetEntityId, right.TargetEntityId, StringComparison.Ordinal)
|
|
&& string.Equals(left.TargetSystemId, right.TargetSystemId, StringComparison.Ordinal)
|
|
&& left.TargetPosition == right.TargetPosition
|
|
&& string.Equals(left.DestinationStationId, right.DestinationStationId, StringComparison.Ordinal)
|
|
&& string.Equals(left.ItemId, right.ItemId, StringComparison.Ordinal)
|
|
&& string.Equals(left.AnchorId, right.AnchorId, StringComparison.Ordinal)
|
|
&& left.WaitSeconds.Equals(right.WaitSeconds)
|
|
&& left.Radius.Equals(right.Radius)
|
|
&& left.MaxSystemRange == right.MaxSystemRange
|
|
&& left.KnownStationsOnly == right.KnownStationsOnly;
|
|
|
|
private ShipOrderRuntime BuildManagedPatrolOrder(SimulationWorld world, ShipRuntime ship, CommanderAssignmentRuntime? assignment, string sourceKind)
|
|
{
|
|
var patrolSystemId = assignment?.TargetSystemId ?? ship.DefaultBehavior.AreaSystemId ?? ship.SystemId;
|
|
var protectPosition = ship.DefaultBehavior.TargetPosition ?? assignment?.TargetPosition ?? ship.Position;
|
|
var patrolThreat = SelectThreatTarget(world, ship, patrolSystemId, protectPosition, MathF.Max(60f, ship.DefaultBehavior.Radius));
|
|
if (patrolThreat is not null)
|
|
{
|
|
ship.LastAccessFailureReason = null;
|
|
return CreateManagedAttackOrder(ship, sourceKind, "Patrol intercept", patrolThreat.EntityId, patrolThreat.SystemId, patrolThreat.Position, orderIdSuffix: "patrol-attack");
|
|
}
|
|
|
|
Vector3 targetPosition;
|
|
string targetSystemId;
|
|
if (ship.DefaultBehavior.PatrolPoints.Count > 0)
|
|
{
|
|
var index = ship.DefaultBehavior.PatrolIndex % ship.DefaultBehavior.PatrolPoints.Count;
|
|
targetPosition = ship.DefaultBehavior.PatrolPoints[index];
|
|
ship.DefaultBehavior.PatrolIndex = (index + 1) % ship.DefaultBehavior.PatrolPoints.Count;
|
|
targetSystemId = ship.DefaultBehavior.AreaSystemId ?? ship.SystemId;
|
|
}
|
|
else if (ResolveStation(world, ship.DefaultBehavior.HomeStationId ?? assignment?.HomeStationId) is { } homeStation)
|
|
{
|
|
var patrolRadius = homeStation.Radius + 90f;
|
|
targetPosition = new Vector3(homeStation.Position.X + patrolRadius, homeStation.Position.Y, homeStation.Position.Z);
|
|
targetSystemId = homeStation.SystemId;
|
|
}
|
|
else
|
|
{
|
|
targetPosition = ship.Position;
|
|
targetSystemId = ship.SystemId;
|
|
}
|
|
|
|
ship.LastAccessFailureReason = null;
|
|
return CreateManagedFlyAndWaitOrder(ship, sourceKind, "Patrol waypoint", targetSystemId, targetPosition, MathF.Max(2f, ship.DefaultBehavior.WaitSeconds), MathF.Max(6f, ship.DefaultBehavior.Radius), orderIdSuffix: "patrol-fly-and-wait");
|
|
}
|
|
|
|
private static ShipOrderRuntime CreateManagedAttackOrder(
|
|
ShipRuntime ship,
|
|
string behaviorKind,
|
|
string label,
|
|
string targetEntityId,
|
|
string targetSystemId,
|
|
Vector3 targetPosition,
|
|
string? orderIdSuffix = null) =>
|
|
new()
|
|
{
|
|
Id = $"behavior-{ship.Id}-{orderIdSuffix ?? behaviorKind}",
|
|
Kind = ShipOrderKinds.AttackTarget,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = label,
|
|
TargetEntityId = targetEntityId,
|
|
TargetSystemId = targetSystemId,
|
|
TargetPosition = targetPosition,
|
|
WaitSeconds = 0f,
|
|
Radius = 26f,
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
|
|
private static ShipOrderRuntime CreateManagedTradeRouteOrder(ShipRuntime ship, string behaviorKind, TradeRoutePlan route) =>
|
|
new()
|
|
{
|
|
Id = $"behavior-{ship.Id}-{behaviorKind}-trade-route",
|
|
Kind = ShipOrderKinds.TradeRoute,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = route.Summary,
|
|
SourceStationId = route.SourceStation.Id,
|
|
DestinationStationId = route.DestinationStation.Id,
|
|
ItemId = route.ItemId,
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
|
|
private static ShipOrderRuntime CreateManagedDockAndWaitOrder(ShipRuntime ship, string behaviorKind, StationRuntime station, float waitSeconds, string label) =>
|
|
new()
|
|
{
|
|
Id = $"behavior-{ship.Id}-{behaviorKind}-dock-and-wait",
|
|
Kind = ShipOrderKinds.DockAndWait,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = label,
|
|
TargetEntityId = station.Id,
|
|
TargetSystemId = station.SystemId,
|
|
DestinationStationId = station.Id,
|
|
WaitSeconds = waitSeconds,
|
|
Radius = ship.DefaultBehavior.Radius,
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
|
|
private static ShipOrderRuntime CreateManagedFlyAndWaitOrder(
|
|
ShipRuntime ship,
|
|
string behaviorKind,
|
|
string label,
|
|
string targetSystemId,
|
|
Vector3 targetPosition,
|
|
float waitSeconds,
|
|
float radius,
|
|
string? orderIdSuffix = null) =>
|
|
new()
|
|
{
|
|
Id = $"behavior-{ship.Id}-{orderIdSuffix ?? behaviorKind}",
|
|
Kind = ShipOrderKinds.FlyAndWait,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = label,
|
|
TargetSystemId = targetSystemId,
|
|
TargetPosition = targetPosition,
|
|
WaitSeconds = waitSeconds,
|
|
Radius = radius,
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
|
|
private static ShipOrderRuntime CreateManagedFollowShipOrder(
|
|
ShipRuntime ship,
|
|
string behaviorKind,
|
|
string label,
|
|
ShipRuntime targetShip,
|
|
float radius,
|
|
float waitSeconds) =>
|
|
new()
|
|
{
|
|
Id = $"behavior-{ship.Id}-{behaviorKind}",
|
|
Kind = ShipOrderKinds.FollowShip,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = label,
|
|
TargetEntityId = targetShip.Id,
|
|
TargetSystemId = targetShip.SystemId,
|
|
WaitSeconds = waitSeconds,
|
|
Radius = radius,
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
|
|
private static ShipOrderRuntime CreateManagedFollowTargetOrder(
|
|
ShipRuntime ship,
|
|
string behaviorKind,
|
|
string label,
|
|
string targetEntityId,
|
|
string targetSystemId,
|
|
Vector3 targetPosition,
|
|
float radius,
|
|
float waitSeconds) =>
|
|
new()
|
|
{
|
|
Id = $"behavior-{ship.Id}-{behaviorKind}",
|
|
Kind = ShipOrderKinds.FollowShip,
|
|
SourceKind = ShipOrderSourceKind.Behavior,
|
|
SourceId = behaviorKind,
|
|
Priority = 0,
|
|
InterruptCurrentPlan = false,
|
|
Label = label,
|
|
TargetEntityId = targetEntityId,
|
|
TargetSystemId = targetSystemId,
|
|
TargetPosition = targetPosition,
|
|
WaitSeconds = waitSeconds,
|
|
Radius = radius,
|
|
MaxSystemRange = ship.DefaultBehavior.MaxSystemRange,
|
|
KnownStationsOnly = ship.DefaultBehavior.KnownStationsOnly,
|
|
};
|
|
}
|