Add targeting subsystem, reveal rule and selection slot (fire control Cut 2)

TargetingSystem is required interior Tool gear: Accuracy/Resolution/
Precision/Tracking are PerformanceStats reached through the usual
Evaluate path, so lot quality, wear, heat and PowerSupply all apply
(a starved system rolls worse, never switches off). FireControl.Accuracy/
Resolution/Precision fall back to GameplaySettings.UnaidedAccuracy (new,
authored low per Q4) whenever an entity has no targeting system or its
own is destroyed/disabled.

FireControl.IsRevealed derives R5's reveal rule from EntityInfoGathered:
non-hull equipment ranks hardpoint-mounted first, then by size, and
reveals between TargetArmorInfoThreshold and TargetGearInfoThreshold --
the first code to read either setting. Entity.TargetItem/
TrySelectTargetItem/ResolvedTargetItem give both the player and AI one
shared, revoke-on-decay aim-point slot with a single writer.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
This commit is contained in:
Meta Vens 2026-09-19 13:02:05 +02:00
commit c4a57a8df0
6 changed files with 191 additions and 2 deletions

View file

@ -183,6 +183,9 @@ public interface IPowerConsumer
Union(36, typeof(ConstantWeaponData)),
Union(37, typeof(ChargedWeaponData)),
Union(38, typeof(AutoWeaponData)),
// Cut 2 (docs/fire-control-cut.md): 39 is the next free index against this list, not the 39 the
// superseded draft quoted -- checked directly here rather than trusted from that document.
Union(39, typeof(TargetingSystemData)),
JsonObject(MemberSerialization.OptIn)]
public abstract class BehaviorData
{

View file

@ -0,0 +1,77 @@
/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
using MessagePack;
using Newtonsoft.Json;
// Cut 2 (docs/fire-control-cut.md): the required interior Tool gear that makes aimed fire possible at all
// (R2, Q4). An entity with no working targeting system is not merely worse -- FireControl falls back to
// GameplaySettings.UnaidedAccuracy and a Precision of 0, which is authored to make unaided fire a last
// resort (Q4: "really, really bad"). This behaviour carries no power machinery of its own: EnergyDraw and
// Heat, authored alongside it on the same item, already cover that, and it adds nothing new.
[Inspectable, MessagePackObject, JsonObject(MemberSerialization.OptIn), RuntimeInspectable]
public class TargetingSystemData : BehaviorData
{
// The ceiling on hit probability (Cut 3's roll multiplies against this; nothing here computes a
// probability). A stat, not a constant, so lot quality, wear, heat and PowerSupply all reach it through
// EquippedItem.Evaluate -- a starved targeting system rolls worse rather than switching off (the
// brownout ruling, docs/stats-and-power-cut.md, applied here).
[Inspectable, JsonProperty("accuracy"), Key(1), RuntimeInspectable]
public PerformanceStat Accuracy = new PerformanceStat();
// The info level (see Entity.EntityInfoGathered) at which sensor state stops limiting hits. Below the
// system's own resolution, an otherwise-earned hit still degrades on account of thin sensor data;
// consumed by Cut 3's roll.
[Inspectable, JsonProperty("resolution"), Key(2), RuntimeInspectable]
public PerformanceStat Resolution = new PerformanceStat();
// The chance a hit lands on the item actually aimed at (Entity.TargetItem) rather than a random cell.
// Consumed by Cut 3's roll.
[Inspectable, JsonProperty("precision"), Key(3), RuntimeInspectable]
public PerformanceStat Precision = new PerformanceStat();
// How much target-side deviation from the predicted intercept this system forgives before a shot goes
// wide. Consumed by Cut 3's roll; unused until then.
[Inspectable, JsonProperty("tracking"), Key(4), RuntimeInspectable]
public PerformanceStat Tracking = new PerformanceStat();
public override Behavior CreateInstance(EquippedItem item)
{
return new TargetingSystem(this, item);
}
public override Behavior CreateInstance(ConsumableItemEffect item)
{
return new TargetingSystem(this, item);
}
}
public class TargetingSystem : Behavior
{
private readonly TargetingSystemData _data;
public float Accuracy { get; private set; }
public float Resolution { get; private set; }
public float Precision { get; private set; }
public float Tracking { get; private set; }
public TargetingSystem(TargetingSystemData data, EquippedItem item) : base(data, item)
{
_data = data;
}
public TargetingSystem(TargetingSystemData data, ConsumableItemEffect item) : base(data, item)
{
_data = data;
}
public override bool Execute(float dt)
{
Accuracy = Evaluate(_data.Accuracy);
Resolution = Evaluate(_data.Resolution);
Precision = Evaluate(_data.Precision);
Tracking = Evaluate(_data.Tracking);
return true;
}
}

View file

@ -0,0 +1,3 @@
fileFormatVersion: 2
guid: e72dd6e15fead417f201fdc92c1fd259
timeCreated: 1758283200

View file

@ -45,6 +45,13 @@ public abstract class Entity
public List<Entity> Children = new List<Entity>();
public ReactiveProperty<Entity> Target = new ReactiveProperty<Entity>((Entity)null);
// Cut 2 (docs/fire-control-cut.md): the stored aim-point slot. Written only by TrySelectTargetItem
// below, and nulled whenever Target changes (subscribed in Activate). Do not read this field directly
// outside Entity -- read ResolvedTargetItem, which re-validates on every call, so decay (or the item
// leaving the target) drops the aim point the moment it is no longer earned, with no loop that has to
// notice and clear it.
public ReactiveProperty<EquippedItem> TargetItem = new ReactiveProperty<EquippedItem>((EquippedItem)null);
public float3 LookDirection;
public string Name;
@ -273,11 +280,42 @@ public abstract class Entity
foreach(var subscription in _watchedEntitySubscriptions[disappearingEntity.Value]) subscription.Dispose();
_watchedEntitySubscriptions.Remove(disappearingEntity.Value);
}));
// Cut 2 (docs/fire-control-cut.md): a Target change nulls the aim point. Fires immediately on
// subscribe with whatever Target already holds, which is harmless -- TargetItem starts null anyway.
_subscriptions.Add(Target.Subscribe(_ => TargetItem.Value = null));
if(WeaponGroups.All(wg=>!wg.items.Any()))
GenerateWeaponGroups();
}
// Cut 2 (docs/fire-control-cut.md): the only writer of TargetItem. Accepts null (clearing the aim
// point) or an item belonging to the current Target that FireControl.IsRevealed resolves true for this
// entity as observer. Returns whether the write took effect; a rejected non-null selection leaves
// TargetItem unchanged.
public bool TrySelectTargetItem(EquippedItem item)
{
if (item == null)
{
TargetItem.Value = null;
return true;
}
if (Target.Value == null || item.Entity != Target.Value || !FireControl.IsRevealed(this, item))
return false;
TargetItem.Value = item;
return true;
}
// The read path for TargetItem (see the field's own comment): null once the aimed item is no longer
// revealed to this entity, or no longer belongs to the current Target, even though nothing wrote
// TargetItem.Value at the moment that became true. Re-checked on every call; never cached.
public EquippedItem ResolvedTargetItem =>
TargetItem.Value != null && Target.Value == TargetItem.Value.Entity && FireControl.IsRevealed(this, TargetItem.Value)
? TargetItem.Value
: null;
// Another entity's stance toward THIS one, as far as this entity can perceive it: unknown (null)
// until this entity detects them, mirroring the existing detection model (VisibleEntities, driven
// by EntityInfoGathered crossing TargetDetectionInfoThreshold). Detected but not yet hostility-rated

View file

@ -2,13 +2,16 @@
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at https://mozilla.org/MPL/2.0/. */
using System.Linq;
using CultMath;
using static CultMath.math;
// Cut 1 (docs/fire-control-cut.md): geometry only. Whether a weapon bears on a point is decided here and
// Cut 1 (docs/fire-control-cut.md): geometry -- whether a weapon bears on a point is decided here and
// nowhere else -- no prefab, transform, ArticulationPoint or renderer may influence it (R6, R7). Mount
// direction and arc are both derived per read from catalog data and the item's authored rotation; neither
// is ever stored on the entity.
// Cut 2 adds the reveal rule (R5) and the resolved targeting-system stats an entity fires with, both
// likewise derived on every read and never cached.
public static class FireControl
{
// The planar unit vector a hardpoint's weapon points along, derived solely from the item's authored
@ -40,4 +43,61 @@ public static class FireControl
var planarTarget = normalize(float3(toTarget.x, 0, toTarget.z));
return dot(MountDirection(weapon), planarTarget) >= cos(radians(arc / 2f));
}
// Cut 2, R5: whether `observer` has resolved `item` (which must belong to some entity in the zone) well
// enough to aim at it. Derived fresh from EntityInfoGathered on every call -- nothing caches a reveal
// result, so decay drops it the moment info falls back below tier, with no clearing loop anywhere.
//
// Ranking: the target's own non-hull equipment, hardpoint-mounted gear first (the big obvious things),
// then by size descending, ties broken by equipment order (OrderByDescending is a stable sort, so this
// needs no explicit tie-break key). Item i of N reveals once info crosses
// lerp(TargetArmorInfoThreshold, TargetGearInfoThreshold, i / max(1, N - 1)) -- the first item to reveal
// does so at the armor tier, the last at the gear tier.
public static bool IsRevealed(Entity observer, EquippedItem item)
{
var target = item.Entity;
var ranked = target.Equipment
.Where(e => e.Data.HardpointType != HardpointType.Hull)
.OrderByDescending(e => e.Data.HardpointType != HardpointType.Tool)
.ThenByDescending(e => e.Data.Shape.Coordinates.Length)
.ToList();
var index = ranked.IndexOf(item);
if (index < 0) return false; // the hull itself, or an item that is no longer on this target
var settings = observer.ItemManager.GameplaySettings;
var info = observer.EntityInfoGathered.TryGetValue(target, out var gathered) ? gathered : 0f;
var tier = lerp(settings.TargetArmorInfoThreshold, settings.TargetGearInfoThreshold,
(float) index / max(1, ranked.Count - 1));
return info >= tier;
}
// Cut 2, Q4: the stats an entity actually fires with. A working targeting system (equipped, online --
// not destroyed, not shut down) supplies its own resolved stats; anything else falls back to the
// authored unaided figures, which make aiming without one a last resort rather than an alternative.
// Cut 3's roll is the only planned reader.
public static float Accuracy(Entity entity)
{
var system = entity.GetBehavior<TargetingSystem>();
return system != null && system.Item.Active.Value
? system.Accuracy
: entity.ItemManager.GameplaySettings.UnaidedAccuracy;
}
public static float Resolution(Entity entity)
{
var system = entity.GetBehavior<TargetingSystem>();
return system != null && system.Item.Active.Value ? system.Resolution : 1f;
}
public static float Precision(Entity entity)
{
var system = entity.GetBehavior<TargetingSystem>();
return system != null && system.Item.Active.Value ? system.Precision : 0f;
}
public static float Tracking(Entity entity)
{
var system = entity.GetBehavior<TargetingSystem>();
return system != null && system.Item.Active.Value ? system.Tracking : 0f;
}
}

View file

@ -213,6 +213,14 @@ public class GameplaySettings
public float TargetGearInfoThreshold;
public float ConvergenceMinimumDistance;
public float FiringArc = 120;
// Cut 2 (docs/fire-control-cut.md, Q4): what an entity with no working targeting system fires with --
// the ceiling FireControl.Accuracy falls back to (Resolution 1, Precision 0 alongside it). Authored low
// on purpose ("really, really bad," operator 2026-09-19): .05 against the two catalog designs' own
// Accuracy ranges (the authoring spec this cut produces proposes .45-.6 for the 1-cell design and
// .65-.85 for the 2-cell one) leaves unaided fire capable of hitting something close, slow and
// unaware, and little else. One authored setting, easy to find and turn -- the operator rules the real
// figure in play.
public float UnaidedAccuracy = .05f;
public float AgentRangeExponent = .25f;
public float AgentForwardLerp = .5f;
public float AgentMaxForwardDistance = 50;