From 70dc0cf1b9f1060dcd67ad82521f7ee278470d1b Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 17 Jul 2026 09:23:29 +0100 Subject: [PATCH] Seed generated agents with orbit patrols --- Aetheria.State.Daemon.Smoke/Program.cs | 27 +++++++++++-- .../AetheriaDaemonTutorialRunWriter.cs | 4 ++ ...AetheriaDaemonTutorialWorldMaterializer.cs | 30 +++++++++++++- Aetheria.State.Daemon/Program.cs | 16 ++++++++ .../AetheriaRuntimeStateDocuments.cs | 21 ++++++++++ .../Runtime/AetheriaRuntimeAgentTasks.cs | 40 +++++++++++++------ ...AetheriaRuntimeDaemonGameSurfaceBuilder.cs | 1 + .../AetheriaRuntimeDaemonOperations.cs | 6 +++ docs/aetheria-perfect-machine-map.md | 9 ++++- docs/original-game-migration-matrix.md | 2 +- docs/renderless-aetheria-architecture.md | 3 ++ 11 files changed, 140 insertions(+), 19 deletions(-) diff --git a/Aetheria.State.Daemon.Smoke/Program.cs b/Aetheria.State.Daemon.Smoke/Program.cs index 2065c6b3c..467ca8592 100644 --- a/Aetheria.State.Daemon.Smoke/Program.cs +++ b/Aetheria.State.Daemon.Smoke/Program.cs @@ -59,6 +59,11 @@ else if (args.Contains("--orbits", StringComparer.Ordinal)) checks.RunOrbits(); Console.WriteLine("Daemon dynamic-orbit smoke passed."); } +else if (args.Contains("--patrol", StringComparer.Ordinal)) +{ + checks.RunPatrol(); + Console.WriteLine("Daemon generated-agent patrol smoke passed."); +} else { checks.Run(); @@ -98,6 +103,7 @@ internal sealed class AetheriaDaemonYmirSmokeChecks public void RunTutorialMaterialization() => RunCheck(TutorialPopulationPreservesFossilEntityMechanics); public void RunTutorialRun() => RunCheck(TutorialRunPersistsCanonicalWorldTruth); public void RunOrbits() => RunCheck(GeneratedOrbitsAdvanceOrbitalWorldTruth); + public void RunPatrol() => RunCheck(AgentPatrolsHistoricalOrbitCircuitThroughMovementCommands); private static void TutorialRunPersistsCanonicalWorldTruth() { @@ -117,6 +123,9 @@ internal sealed class AetheriaDaemonYmirSmokeChecks Require(run != null && run.IsTutorial && run.ZoneKeys.Length == 64 && run.EntranceZoneIndex == run.CurrentZoneIndex && run.ExitZoneIndex == -1, "persisted New Game truth must be the complete authored tutorial graph, not the Terminus witness fixture"); + Require(run!.AgentTasks.Length > 0 && run.AgentTasks.All(task => + task.TaskType == "patrol" && task.Status == "assigned" && task.TargetOrbitKeys.Length == 4), + "persisted tutorial agents must retain their assigned four-orbit fossil patrols"); Require(settings != null && settings.ActiveRunKey == written.RunKey && !settings.TutorialPassed, "tutorial persistence must select the new run without falsely awarding completion"); Require(run!.CurrentEntityKey == written.CurrentEntityKey, @@ -164,6 +173,18 @@ internal sealed class AetheriaDaemonYmirSmokeChecks .Where(entity => entity.Kind == "ship" && entity.AgentTaskCapabilities.Contains("attack", StringComparer.Ordinal)) .All(entity => entity.Position.X != 0 || entity.Position.Z != 0), "generated non-player ships must retain the fossil activation rule that distributes zero-pose ships through the zone"); + Require(first.Zones.Values.All(zone => + { + var orbitKeys = zone.Orbits.Select(orbit => orbit.OrbitKey).ToHashSet(StringComparer.Ordinal); + var agents = zone.Entities.Where(entity => + entity.Kind == "ship" && entity.AgentTaskCapabilities.Contains("attack", StringComparer.Ordinal)).ToArray(); + return zone.AgentTasks.Length == agents.Length && + zone.AgentTasks.All(task => task.TaskType == "patrol" && + task.Status == "assigned" && task.TargetOrbitKeys.Length == 4 && + task.TargetOrbitKeys.Distinct(StringComparer.Ordinal).Count() == 4 && + task.TargetOrbitKeys.All(orbitKeys.Contains)) && + agents.All(entity => zone.AgentTasks.Any(task => task.TaskId == entity.AssignedAgentTaskId)); + }), "every generated NPC must begin with one assigned four-orbit patrol owned by daemon task state"); Require(first.Zones.Values.SelectMany(zone => zone.Entities) .Where(entity => !string.IsNullOrWhiteSpace(entity.OrbitKey)) .All(entity => entity.Position.X != 0 || entity.Position.Z != 0), @@ -5103,7 +5124,7 @@ internal sealed class AetheriaDaemonYmirSmokeChecks private static void AgentPatrolsHistoricalOrbitCircuitThroughMovementCommands() { var agent = Entity(0, 0, "workers"); - agent.AgentTaskCapabilities = [AetheriaRuntimeAgentTaskTypes.Defend]; + agent.AgentTaskCapabilities = [AetheriaRuntimeAgentTaskTypes.Patrol]; var catalog = EquipThrusterBank([agent]); var run = new AetheriaRuntimeRunCheckpointCommit { @@ -5140,11 +5161,11 @@ internal sealed class AetheriaDaemonYmirSmokeChecks { TaskId = "patrol-orbits", CorporationKey = "workers", - TaskType = AetheriaRuntimeAgentTaskTypes.Defend, + TaskType = AetheriaRuntimeAgentTaskTypes.Patrol, Priority = 10, ZoneIndex = 0, CompletionRadius = 5, - TargetBodyKeys = ["body:east", "body:west"] + TargetOrbitKeys = ["orbit:east", "orbit:west"] }; var sawWestLeg = false; var sawReturnToEast = false; diff --git a/Aetheria.State.Daemon/AetheriaDaemonTutorialRunWriter.cs b/Aetheria.State.Daemon/AetheriaDaemonTutorialRunWriter.cs index 8ca1c0dbc..d4a746e74 100644 --- a/Aetheria.State.Daemon/AetheriaDaemonTutorialRunWriter.cs +++ b/Aetheria.State.Daemon/AetheriaDaemonTutorialRunWriter.cs @@ -88,6 +88,10 @@ public static class AetheriaDaemonTutorialRunWriter CurrentEntityKey = playerEntityKey, LifecyclePhase = AetheriaRuntimeRunLifecycle.Active, TerminalFrameId = -1, + AgentTasks = materialized.Zones.Values + .OrderBy(zone => zone.Topology.ZoneIndex) + .SelectMany(zone => zone.AgentTasks) + .ToArray(), UpdatedAtUtc = now }).ConfigureAwait(false); diff --git a/Aetheria.State.Daemon/AetheriaDaemonTutorialWorldMaterializer.cs b/Aetheria.State.Daemon/AetheriaDaemonTutorialWorldMaterializer.cs index face963af..d38b31cd7 100644 --- a/Aetheria.State.Daemon/AetheriaDaemonTutorialWorldMaterializer.cs +++ b/Aetheria.State.Daemon/AetheriaDaemonTutorialWorldMaterializer.cs @@ -8,6 +8,7 @@ public sealed record AetheriaDaemonMaterializedTutorialZone( int FactionPresence, AetheriaOrbitSnapshot[] Orbits, AetheriaEntitySnapshot[] Entities, + AetheriaAgentTaskState[] AgentTasks, int PlayerEntityIndex); public sealed record AetheriaDaemonMaterializedTutorialWorld( @@ -56,6 +57,7 @@ public static class AetheriaDaemonTutorialWorldMaterializer var stationCount = (int)(random.NextFloat() * (factionPresence + 1)); var orbits = celestial.Orbits.ToList(); var entities = new List(); + var agentTasks = new List(); var generators = new Dictionary(StringComparer.Ordinal); AetheriaDaemonLoadoutGenerator Generator(string factionKey) @@ -142,7 +144,32 @@ public static class AetheriaDaemonTutorialWorldMaterializer Generator(nearest.CorporationKey).Build("ship", nearest.CorporationKey), spawnRandom.NextFloat((float)-halfRadius, (float)halfRadius), spawnRandom.NextFloat((float)-halfRadius, (float)halfRadius)); - enemy.AgentTaskCapabilities = ["attack", "defend", "explore"]; + var entityIndex = entities.Count; + var taskId = $"tutorial.zone.{topology.ZoneIndex}.entity.{entityIndex}.patrol"; + enemy.AgentTaskCapabilities = + [ + AetheriaRuntimeAgentTaskTypes.Attack, + AetheriaRuntimeAgentTaskTypes.Defend, + AetheriaRuntimeAgentTaskTypes.Explore, + AetheriaRuntimeAgentTaskTypes.Patrol + ]; + enemy.AssignedAgentTaskId = taskId; + agentTasks.Add(new AetheriaAgentTaskState + { + TaskId = taskId, + CorporationKey = nearest.CorporationKey, + TaskType = AetheriaRuntimeAgentTaskTypes.Patrol, + Priority = 0, + ZoneIndex = topology.ZoneIndex, + Status = AetheriaRuntimeAgentTaskStatuses.Assigned, + AssignedEntityIndex = entityIndex, + CompletionRadius = 10, + TargetOrbitKeys = orbits + .OrderBy(_ => spawnRandom.NextFloat()) + .Take(4) + .Select(orbit => orbit.OrbitKey) + .ToArray() + }); entities.Add(enemy); } @@ -175,6 +202,7 @@ public static class AetheriaDaemonTutorialWorldMaterializer factionPresence, orbits.ToArray(), entities.ToArray(), + agentTasks.ToArray(), localPlayerIndex)); } diff --git a/Aetheria.State.Daemon/Program.cs b/Aetheria.State.Daemon/Program.cs index 279010e3a..38ce8582a 100644 --- a/Aetheria.State.Daemon/Program.cs +++ b/Aetheria.State.Daemon/Program.cs @@ -2637,6 +2637,21 @@ static async Task ReadRuntimeRunCheckpointA : run.LifecyclePhase, TerminalReason = run.TerminalReason ?? "", TerminalFrameId = run.TerminalFrameId, + AgentTasks = (run.AgentTasks ?? Array.Empty()) + .Select(task => new AetheriaRuntimeAgentTaskCommit + { + TaskId = task.TaskId ?? "", + CorporationKey = task.CorporationKey ?? "", + TaskType = task.TaskType ?? "", + Priority = task.Priority, + ZoneIndex = task.ZoneIndex, + Status = task.Status ?? AetheriaRuntimeAgentTaskStatuses.Queued, + AssignedEntityIndex = task.AssignedEntityIndex, + CompletionRadius = task.CompletionRadius, + TargetOrbitKeys = (task.TargetOrbitKeys ?? Array.Empty()).ToArray(), + CircuitIndex = task.CircuitIndex + }) + .ToArray(), Credits = 1000000 }; } @@ -2702,6 +2717,7 @@ static AetheriaRuntimeEntitySnapshotCommit ToRuntimeEntity( EntityId = entityKey ?? "", HomeEntityId = entity.HomeEntityKey ?? "", AgentTaskCapabilities = (entity.AgentTaskCapabilities ?? Array.Empty()).ToArray(), + AssignedAgentTaskId = entity.AssignedAgentTaskId ?? "", EntityIndex = entityIndex, Name = entity.Name ?? "", Kind = entity.Kind ?? "", diff --git a/Aetheria.State/Documents/AetheriaRuntimeStateDocuments.cs b/Aetheria.State/Documents/AetheriaRuntimeStateDocuments.cs index 03660f43f..04453459a 100644 --- a/Aetheria.State/Documents/AetheriaRuntimeStateDocuments.cs +++ b/Aetheria.State/Documents/AetheriaRuntimeStateDocuments.cs @@ -250,6 +250,24 @@ public sealed class AetheriaRunState [Key(15)] public long TerminalFrameId { get; set; } = -1; + + [Key(16)] + public AetheriaAgentTaskState[] AgentTasks { get; set; } = []; +} + +[MessagePackObject] +public sealed class AetheriaAgentTaskState +{ + [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; } = "queued"; + [Key(6)] public int AssignedEntityIndex { get; set; } = -1; + [Key(7)] public double CompletionRadius { get; set; } = 10; + [Key(8)] public string[] TargetOrbitKeys { get; set; } = []; + [Key(9)] public int CircuitIndex { get; set; } } [CultDocument("aetheria.zone_state", "aetheria.zone_state.v1")] @@ -645,6 +663,9 @@ public sealed class AetheriaEntitySnapshot [Key(37)] public double SecurityRadius { get; set; } + + [Key(38)] + public string AssignedAgentTaskId { get; set; } = ""; } [MessagePackObject] diff --git a/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeAgentTasks.cs b/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeAgentTasks.cs index 2a730cc1b..2f61f436d 100644 --- a/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeAgentTasks.cs +++ b/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeAgentTasks.cs @@ -14,11 +14,12 @@ namespace GameCult.Aetheria.State.Verse 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 All = - new[] { Mine, Haul, Tow, Defend, Attack, Explore }; + new[] { Mine, Haul, Tow, Defend, Patrol, Attack, Explore }; } public static class AetheriaRuntimeAgentTaskStatuses @@ -57,6 +58,7 @@ namespace GameCult.Aetheria.State.Verse [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 TargetOrbitKeys { get; set; } = Array.Empty(); } [MessagePackObject] @@ -78,6 +80,7 @@ namespace GameCult.Aetheria.State.Verse [Key(13)] public IReadOnlyList TargetBodyKeys { get; set; } = Array.Empty(); [Key(14)] public string OrbitParentKey { get; set; } = ""; [Key(15)] public double OrbitDistance { get; set; } + [Key(16)] public IReadOnlyList TargetOrbitKeys { get; set; } = Array.Empty(); } public static class AetheriaRuntimeAgentScheduler @@ -296,7 +299,8 @@ namespace GameCult.Aetheria.State.Verse commands.AddRange(PlanSurvey(run, zone!, task, agent, frameId, catalog, simulationTimeSeconds)); continue; } - if (string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Defend, StringComparison.Ordinal)) + if (string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Defend, StringComparison.Ordinal) || + string.Equals(task.TaskType, AetheriaRuntimeAgentTaskTypes.Patrol, StringComparison.Ordinal)) { commands.AddRange(PlanPatrol(zone!, task, agent, frameId)); continue; @@ -1075,34 +1079,46 @@ namespace GameCult.Aetheria.State.Verse AetheriaRuntimeEntitySnapshotCommit agent, long frameId) { - var circuit = (task.TargetBodyKeys ?? Array.Empty()) + var circuit = (task.TargetOrbitKeys ?? Array.Empty()) .Where(key => !string.IsNullOrWhiteSpace(key)) .ToArray(); if (circuit.Length == 0) + { + var bodyOrbits = (zone.Bodies ?? Array.Empty()) + .Where(body => body != null && !string.IsNullOrWhiteSpace(body.BodyKey)) + .ToDictionary(body => body.BodyKey, body => body.OrbitKey ?? "", StringComparer.Ordinal); + circuit = (task.TargetBodyKeys ?? Array.Empty()) + .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(); } task.CircuitIndex = ((task.CircuitIndex % circuit.Length) + circuit.Length) % circuit.Length; - var body = AetheriaRuntimeDaemonRenderQueries.QueryBodyPoses(zone) - .FirstOrDefault(candidate => string.Equals(candidate.BodyKey, circuit[task.CircuitIndex], StringComparison.Ordinal)); - if (string.IsNullOrWhiteSpace(body.BodyKey)) + var positions = AetheriaRuntimeOrbitQueries.BuildPositions(zone); + if (!positions.TryGetValue(circuit[task.CircuitIndex], out var destination)) { Fail(task, agent); return Array.Empty(); } - var dx = body.CenterX - agent.PositionX; - var dz = body.CenterZ - agent.PositionZ; + 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; - var next = AetheriaRuntimeDaemonRenderQueries.QueryBodyPoses(zone) - .First(candidate => string.Equals(candidate.BodyKey, circuit[task.CircuitIndex], StringComparison.Ordinal)); - dx = next.CenterX - agent.PositionX; - dz = next.CenterZ - agent.PositionZ; + if (!positions.TryGetValue(circuit[task.CircuitIndex], out var next)) + { + Fail(task, agent); + return Array.Empty(); + } + dx = next.x - agent.PositionX; + dz = next.z - agent.PositionZ; } return new[] { Movement(task, agent, frameId, dx, dz, 1) }; } diff --git a/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonGameSurfaceBuilder.cs b/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonGameSurfaceBuilder.cs index 5c7cab46d..413381a88 100644 --- a/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonGameSurfaceBuilder.cs +++ b/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonGameSurfaceBuilder.cs @@ -393,6 +393,7 @@ namespace GameCult.Aetheria.State.Verse ("deliveredQuantity", task.DeliveredQuantity.ToString(CultureInfo.InvariantCulture)), ("phase", task.Phase), ("targetBodyKeys", string.Join(",", task.TargetBodyKeys ?? Array.Empty())), + ("targetOrbitKeys", string.Join(",", task.TargetOrbitKeys ?? Array.Empty())), ("circuitIndex", task.CircuitIndex.ToString(CultureInfo.InvariantCulture)), ("orbitParentKey", task.OrbitParentKey), ("orbitDistance", task.OrbitDistance.ToString("0.###", CultureInfo.InvariantCulture)), diff --git a/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonOperations.cs b/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonOperations.cs index 671fa4be9..48e27f134 100644 --- a/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonOperations.cs +++ b/Packages/org.gamecult.aetheria.state/Runtime/AetheriaRuntimeDaemonOperations.cs @@ -314,6 +314,11 @@ namespace GameCult.Aetheria.State.Verse { return false; } + if (string.Equals(taskType, AetheriaRuntimeAgentTaskTypes.Patrol, StringComparison.Ordinal) && + !(request.TargetOrbitKeys ?? Array.Empty()).Any(key => !string.IsNullOrWhiteSpace(key))) + { + return false; + } if (string.Equals(taskType, AetheriaRuntimeAgentTaskTypes.Tow, StringComparison.Ordinal) && (request.TargetEntityIndex < 0 || string.IsNullOrWhiteSpace(request.OrbitParentKey) || request.OrbitDistance <= 0)) return false; @@ -343,6 +348,7 @@ namespace GameCult.Aetheria.State.Verse ? "pickup" : "", TargetBodyKeys = request.TargetBodyKeys ?? Array.Empty(), + TargetOrbitKeys = request.TargetOrbitKeys ?? Array.Empty(), OrbitParentKey = request.OrbitParentKey ?? "", OrbitDistance = request.OrbitDistance, Status = AetheriaRuntimeAgentTaskStatuses.Queued diff --git a/docs/aetheria-perfect-machine-map.md b/docs/aetheria-perfect-machine-map.md index 77c6c5225..ede67c31f 100644 --- a/docs/aetheria-perfect-machine-map.md +++ b/docs/aetheria-perfect-machine-map.md @@ -1145,6 +1145,10 @@ the Terminus proof arena cannot award completion. - Outputs: 64 canonical zone documents, stable entity records, loadout generation receipts, one controlled entrance ship, tutorial discovery state, and an Aetheria-mode game session. +- Agent work: each generated NPC ship receives one assigned `patrol` task with + the fossil four-orbit shuffled circuit. Orbit circuits are typed separately + from mining/survey body targets and survive bootstrap into the runtime + checkpoint; Unity no longer creates `Minion` patrol state on activation. - Physical placement: the daemon resolves orbital entities from the canonical orbit graph before persistence and deterministically distributes generated non-player ships through the fossil half-zone volume. The controlled starter @@ -1166,8 +1170,9 @@ the Terminus proof arena cannot award completion. - Verification layer: focused smokes prove deterministic population, resolved orbital references and poses, distributed non-player spawns, fixed-step orbit phase/pose/velocity through Ymir, station/turret/agent - presence, loadout provenance, all 64 persisted zones, canonical starter - identity, discovery, and adjacency. + presence, assigned four-orbit patrol persistence and movement, loadout + provenance, all 64 persisted zones, canonical starter identity, discovery, + and adjacency. ### Daemon Generated Zone Body Ownership diff --git a/docs/original-game-migration-matrix.md b/docs/original-game-migration-matrix.md index ccb9d9721..fa5bfec58 100644 --- a/docs/original-game-migration-matrix.md +++ b/docs/original-game-migration-matrix.md @@ -45,7 +45,7 @@ validation proves contract shape, not wiring, exclusivity, lowering, or parity. | Starbridge | original/shared architecture intent | one daemon session | pilot + commander surfaces | Unity + Electron | commander task board and autonomous explore execution wired; Electron Eve lowering and split-target proof missing | commander orders plus four pilots and autonomous workers | | Behavior engine | `ServerShared/Behaviors` composition | daemon | executable action/status projection | action bar and feedback | tick reconciles equipped catalog payloads into persistent behavior state; `Switch`, one-shot `Trigger`, normalized `Cooldown`, adjustable high/low-pass `Thermotoggle`, `EnergyDraw`, equipment `Heat`, atomic `ItemUsage`, and thermal `Wear` execute in authored group order and stop downstream effects on refusal; each row records whether the chain reached it. `Thruster`, rare `AetherDrive`, and `Radiator` now pause their groups at the specialized owner, report the exact fossil success result, and resume common tails at most once, so idle or unfunded actuators cannot consume wear; radiator emission remains its independent always-update path. Cooldown projects generic progress and thermostat target is daemon-commanded state seeded from authored data. Equipped and timed-consumable `StatModifier` sources persist daemon-owned lifecycle state and every runtime stat reader applies the fossil `base × multiplier product + constant sum` rule through one query; legacy `Data` kind references and required-behavior filters are honored | remaining specialized return-value composition and canonical consumable-content proof | | Sensors/visibility | installed sensor sensitivity and angular curve, `Visibility`, `Reflector`, decaying signature sources, stellar light, ping state, and observer information thresholds | daemon | accumulated contacts, named visibility sources, and ping events | indicators/maps and provider environment lowering | every operational installed Sensor executes the fossil visibility/sensitivity/angle/distance information equation and decay; visibility is thresholded by the provider setting. Actor-scoped ping owns energy, cooldown, expansion radius, reconnect-stable crossed-target state, one-time information boost, and transient signature. Operational `Visibility` equipment publishes evaluated constant signature; committed weapons publish authored signature including charged-shot multiplication; transient weapon and ping sources decay by the fossil exponential rule. Reflectors multiply evaluated cross-section by the exponent-8 stellar `PowerPulse` after thermal settlement. Gameplay light and environment projection share resolved authored orbit/body centers and provider-owned sun radius inputs. Contact refresh no longer invents perfect information or overwrites emitted visibility; docked craft consume one daemon-derived union of craft and dock-parent contacts through both Eve rows and SoA bodies, with sensor-source provenance | active consumable visibility/reflector effects, complete source cardinality, classification timelines, and canonical catalog station-array data | -| AI/tasks | corporation task scheduler plus agent state machines and installed orbital `TurretController` | daemon | commander task board, corporation survey ledger, controller aim/state, and shared semantic controls | Eve commander/pilot clients | point exploration, loadout-driven attack, haul, mining/offload, resource surveying, physical station towing, persistent orbit patrol, route-aware assignment, and autonomous return home are wired through shared commands. Ship combat samples the fossil DPS/range policy, selects live weapon groups, leads projectiles, strafes relative to target attitude, and gates fire on catalog placement rotation. Chain-admitted orbital controllers independently acquire the first visible hostile ship, publish predictive look direction, and trigger only exact aligned in-range weapon behaviors through the shared combat lifecycle; the canonical preceding `EnergyDraw` now blocks acquisition, aim, and fire when power is unavailable, and non-player identity grants no implicit group-zero fire. Cross-zone task and home routes survive the full daemon-owned wormhole timeline; attack admission rejects missing/friendly targets and unavailable weapon groups before durable queueing. Cancel, complete, fail, stale-assignment repair, and duplicate-carrier repair share one scheduler-owned release primitive that zeros persisted helm input, clears the scheduler target, releases towing parentage, and prevents a terminal task from emitting another command. Real CultCache close/reopen proofs now cover both ordinary mid-travel and the first `entering` phase of a two-edge route; fresh Ymir owners resume without duplicate tasks, entities, or transition events, and Eve commander observes terminal status | multi-client command transfer and model-local barrel-direction metadata | +| AI/tasks | corporation task scheduler plus agent state machines and installed orbital `TurretController` | daemon | commander task board, corporation survey ledger, controller aim/state, and shared semantic controls | Eve commander/pilot clients | point exploration, loadout-driven attack, haul, mining/offload, resource surveying, physical station towing, persistent orbit patrol, route-aware assignment, and autonomous return home are wired through shared commands. `patrol` is a first-class task with orbit targets distinct from survey/mining body targets; every generated tutorial NPC persists its assigned fossil four-orbit shuffled circuit before the first tick. Ship combat samples the fossil DPS/range policy, selects live weapon groups, leads projectiles, strafes relative to target attitude, and gates fire on catalog placement rotation. Chain-admitted orbital controllers independently acquire the first visible hostile ship, publish predictive look direction, and trigger only exact aligned in-range weapon behaviors through the shared combat lifecycle; the canonical preceding `EnergyDraw` now blocks acquisition, aim, and fire when power is unavailable, and non-player identity grants no implicit group-zero fire. Cross-zone task and home routes survive the full daemon-owned wormhole timeline; attack admission rejects missing/friendly targets and unavailable weapon groups before durable queueing. Cancel, complete, fail, stale-assignment repair, and duplicate-carrier repair share one scheduler-owned release primitive that zeros persisted helm input, clears the scheduler target, releases towing parentage, and prevents a terminal task from emitting another command. Real CultCache close/reopen proofs now cover both ordinary mid-travel and the first `entering` phase of a two-edge route; fresh Ymir owners resume without duplicate tasks, entities, or transition events, and Eve commander observes terminal status | multi-client command transfer and model-local barrel-direction metadata | | Consumables | cargo-backed timed behavior containers | daemon | dynamic actions, active effects, and lifecycle facts | action bar/schematic | daemon atomically resolves typed metadata and concrete cargo, preserves consumed-instance quality, enforces authored stacking, evaluates effectiveness/quality, and executes ordered `EnergyDraw`, fossil-compatible no-op `Heat`, `ItemUsage`, and stateful `Cooldown` payloads after energy tick initialization; every effect and payload state has stable authored identity; cooldowns update before the ordered chain, require state strictly below zero, reset to one on success, and continue aging behind earlier failures; false and unsupported payloads stop later execution with a typed fact; timers retain the fossil's exact-zero final tick; Unity reconciles presentation by effect identity and cannot restore active behavior state by list index | catalog revision pinning, stat modifiers, remaining behavior families, and reconnect presentation proof | ## Ownership Invariants diff --git a/docs/renderless-aetheria-architecture.md b/docs/renderless-aetheria-architecture.md index ec3b199e4..b22e7876c 100644 --- a/docs/renderless-aetheria-architecture.md +++ b/docs/renderless-aetheria-architecture.md @@ -156,6 +156,9 @@ Generated non-player ships are distributed through the fossil half-zone volume. Generated orbits carry the authored distance-derived period; each fixed daemon step advances canonical phase and projects orbital entity pose and velocity before Ymir. Body queries and Eve lower the same orbit graph. +Each generated NPC also enters with a daemon-owned assigned patrol task over +four shuffled orbit identities, matching the fossil activation behavior without +letting the Unity client create agent state. New Game now submits its advertised Eve operation, waits for a newly published daemon sector map, and selects the persisted 64-zone tutorial while