From d06a2faea90825a60552dc66d2ba1540b1c43c64 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Wed, 14 Oct 2026 02:01:45 +0200 Subject: [PATCH 1/2] aetheria-release map: inspection-scanner refresh at b836af48 (r3), shared sites with sensor-catalog Co-Authored-By: Claude Opus 5.5 --- docs/aetheria-release-map.md | 121 +++++++++++++++++++++++++++++++++-- 1 file changed, 117 insertions(+), 4 deletions(-) diff --git a/docs/aetheria-release-map.md b/docs/aetheria-release-map.md index 9f61b90a2..fb4bb7aae 100644 --- a/docs/aetheria-release-map.md +++ b/docs/aetheria-release-map.md @@ -8417,16 +8417,16 @@ Aimed across 8 test files; FireControlCut12Tests pins ResolveAimPoint's cell ave |---|---|---|---| | Signature channel (`SignatureChannel`: Thermal, Reflection, DrivePlume, LaunchFlash, Emission) | A closed enum, the five channels of ruling visibility-per-capability-reveal. Saved only as `VisibilityData.Channel` (catalog, by value; append-only, a value is never reused). | Fixed set; a new channel is a code change and a ruling. | The ruling. Code names each writer's channel; the catalog names a Visibility gear's. | | Light signature (`Signature {Channel, Strength, Item}` in `Entity.VisibilitySources`) | (emitting entity, source object). The source is the writing behaviour, or the entity for hull radiation; the key is a reference, so injective. `Item` is derived from the behaviour's `Item` (null for hull radiation and consumable effects). Channel Emission is never a light signature (after cut emissions-heard). | Written each tick its source acts (thermal, radiator, reflector, visibility gear continuously; weapon fire and plume when they act). Decayed by VisibilityDecay in the owner's Update and removed below 0.1. Runtime only, never saved. | One writer per entry: its source, through `Entity.SetSignature`. Entity.Update the only decayer. Forbidden: another entity, any presenter, a direct dictionary write. `Visibility` (the sum) stays the track input. | -| Active emission (`ActiveEmission {Item, HearRange, Mode}` in `Entity.ActiveEmissions`) | (emitting entity, emitting item, tick). No persistent id. | Posted to the emitter's inbox each tick it emits (a ping wavefront in flight: Search; a lock paint inside LockAngle: Track); published in the zone's pre-phase with paints; lives exactly one tick. Never saved. | Sensor.Execute (search) and LockWeapon.Execute (track) through `Entity.Emit`; Entity publishes. HearRange = the emitter's range / its InterceptFactor, fixed at the emit. | -| Paint warning (`PaintWarning {Bearing, EmitterClass, Mode, Strength}` in `Entity.IncomingPaints`; was LockWarning / IncomingLocks) | (painted entity, tick, painter beam). No id. | One tick after its last paint (unchanged from lock-warning). Search paints carry Strength 0. | LockWeapon.Execute (Track) and a ping wavefront crossing (Search, Sensor.Execute) call ReceivePaint; Entity publishes. Painted targets are always warned (sensor-stat-set 4). | +| Active emission (`ActiveEmission {Item, HearRange, Claimed}` in the emitter's private `_emissions`) | (emitting entity, emitting item, tick). No persistent id. | Written by `Entity.Emit` during the emitter's Update each tick it emits (a ping wavefront in flight, a lock paint inside LockAngle, a held scan after inspection-scanner); read only by other entities' Sense in the same tick; cleared by the emitter's next PublishInbox and by Deactivate. No mode. Never saved. | Sensor.Execute, LockWeapon.Execute and (inspection-scanner) Scanner.Execute through `Entity.Emit`, which stamps `Claimed = ClaimOf(item)`. HearRange = the emitter's range / its InterceptFactor, fixed at the emit. (Body at b836af48: IS3.) | +| Paint warning (`PaintWarning {Bearing, EmitterClass, Mode, Strength}` in `Entity.IncomingPaints`; was LockWarning / IncomingLocks) | (painted entity, tick, painter beam). No id. | One tick after its last paint (unchanged from lock-warning). Search paints carry Strength 0; Scan paints (inspection-scanner) carry the scan's progress. | LockWeapon.Execute (Track), a ping wavefront crossing (Search, Sensor.Execute) and a held scan (Scan, Scanner.Execute) call ReceivePaint; Entity publishes, and PublishInbox records the painter's item as an Emission reveal. Painted targets are always warned (sensor-stat-set 4, scan-is-an-act). | | Track (`EntityInfoGathered[subject]`) | (observer, subject entity). | Seeded 0 on zone entry, revised each tick by each active sensor (passive gain, decay), plus one monostatic gain on the tick its own ping crosses the subject and one bistatic gain per published ping return (R2); removed when the subject leaves; cleared on Deactivate. Runtime only. | Sensor.Execute only, reading the observer's own receivers and its own published returns. Forbidden: shared-track writes (ruling shared-track-bearing-only), presenters, other ships, any read of another ship's Sensor state. | | Ping sweep (`Sensor._reached`, per pinging sensor) | (pinging sensor, ping). The set of subjects the wavefront has reached this ping, in the beam or not. | Cleared at Ping(); a subject joins on the first sweeping tick it lies inside the radius, and that is its one crossing (credited and painted only if inside the beam then); nothing joins after the ping's last step; emptied when the sensor is idle. Runtime only. | The pinging Sensor.Execute alone decides "this ping crossed this subject, once". Forbidden: another sensor or ship reading its radii; an interval sample standing in for it. | | Ping return (`PingReturn {Subject, IlluminatedRange, IlluminatedObscuration, MaxRange}` in the ally's `PingReturns`) | (receiving entity, pinging sensor, subject, tick). No id. | Posted by the pinger to each ally's inbox on the crossing tick; published in the zone pre-phase with paints (`PublishInbox`); lives exactly one tick. Never saved. | The pinger posts (it owns the illuminated leg and its own range); the receiving Sensor credits from its own Sensitivity, PingBoost, distance and sight line (it owns the receive leg). Forbidden: the pinger writing the ally's track; the ally reading the pinger. | -| Reveal (`Reveal {Item, Channel, Bearing, Time}` in the observer's reveal book, keyed (subject, item)) | (observer, subject entity, revealed item), by reference. Channel is null for a reveal by inspection (cut inspection-scanner). | Created on the first act the observer's instruments receive, or for every live item when the observer's scanner completes a scan; Channel, Bearing and Time refreshed by each later act; ended for an item when the observer perceives its destruction, and for all of a subject's items when the observer perceives the subject's death or departure (acts received through the observer's own Sense step, never a subscription to the subject); a subject leaving the zone does not by itself empty any book: its entries stay unrefreshed and are pruned once the freshest is older than BearingMemory; Contact never reads the subject's live equipment or Durability, and only the aiming read (IsRevealed, IsLocated) filters on the live item (Durability < .01 or off the subject) (Defaulted ruling reveal-ends-on-perception); RecordReveal and its one removal counterpart are the book's only writers and its one membership gate; cleared on Deactivate. Not decayed: memory of the sitting. Never saved. | `Entity.Sense` (once per Entity.Update) for light acts and heard emissions; `ReceivePaint` for paints; `Entity.RecordInspection` (called by the observer's own Scanner) for scans. Forbidden: Sensor's track loop, presenters, another ship, shared tracks. | +| Reveal (`Reveal {Item, Channel, Bearing, Time}` in the observer's reveal book, keyed (subject, item)) | (observer, subject entity, revealed item), by reference. Channel is null for a reveal by inspection (cut inspection-scanner). | Created on the first act the observer's instruments receive, or for every fitted, non-destroyed, non-hull item when the observer's scanner completes a scan (Channel null, Claimed the subject's `ClaimOf(item)`, as any act records the claim it carries: aetheria-ew one-judge; a scan creates and refreshes entries and ends none); Channel, Bearing and Time refreshed by each later act; ended for an item when the observer perceives its destruction, and for all of a subject's items when the observer perceives the subject's death or departure (acts received through the observer's own Sense step, never a subscription to the subject); a subject leaving the zone does not by itself empty any book: its entries stay unrefreshed and are pruned once the freshest is older than BearingMemory; Contact never reads the subject's live equipment or Durability, and only the aiming read (IsRevealed, IsLocated) filters on the live item (Durability < .01 or off the subject) (Defaulted ruling reveal-ends-on-perception); RecordReveal and its one removal counterpart are the book's only writers and its one membership gate; cleared on Deactivate. Not decayed: memory of the sitting. Never saved. | `Entity.Sense` (once per Entity.Update) for light acts and heard emissions; `ReceivePaint` for paints; `Entity.RecordInspection` (called by the observer's own Scanner) for scans. Forbidden: Sensor's track loop, presenters, another ship, shared tracks. | | Hull layout knowledge (derived by `Entity.LayoutOf(subject)`) | (observer, subject hull class). The class is the subject's HullData; the layout is its Hardpoints (type, position, shape). | Derived on read: the subject's HullData.Hardpoints while ContactOf(subject).Identified, else empty. Stored nowhere; never says what is fitted. | `Entity.LayoutOf` is the one derivation (ruling quiet-gear-identifiable-hull-layout-known). Readers: IsLocated, the target schematic, the player's cycle. | | Contact (`Contact`, derived by `Entity.ContactOf(subject)`) | (observer, subject). | Derived on read from track, reveals, the zone clock and `BearingMemory`; stored nowhere. Flags: Detected (tracked, or a reveal younger than BearingMemory), Tracked (track > TargetDetectionInfoThreshold, which is VisibleEntities), Classified (detected and any reveal), Identified (track >= TargetGearInfoThreshold, name kept, now the identify threshold). Bearing: the true bearing while tracked, else the freshest reveal's. | `Entity.ContactOf` is the one derivation. HUD and AI read it; VisibleEntities stays the tracked set. | | Located item (`FireControl.IsLocated(observer, item)`) and aim point | (observer, subject item). | Derived on every read: revealed, or on a hardpoint of a layout the observer holds. The aim point is the item's own cells when revealed, else its hardpoint's cells; the choice is frozen into the shot with Aimed. | FireControl (R10). TrySelectTargetItem and ResolvedTargetItem gate on IsLocated; anything that reads an item's stats or class (AI weapon choice, schematic weapon rows) gates on IsRevealed. | -| Scan (`Scanner` behaviour; progress per (scanner, target)) | (scanning item, the ship's Target). | Progress builds while the Target is tracked and within Range, at 1/ScanTime per second; falls at the same rate otherwise; reset on target change; at 1 the scan completes (RecordInspection) and progress restarts. Runtime only. | The Scanner behaviour; RecordInspection in Entity.cs writes the reveals. While scanning: a Scan paint (Strength = progress) on the target and an Emit(Item, Range / InterceptFactor, Scan) (question scanner-reveals-its-user, recommended). | +| Scan (`Scanner` behaviour; progress per (scanner, target)) | (scanning item, the ship's Target entity). | Progress builds in Execute while the item is Active and its Target is tracked (VisibleEntities) and within Range (TargetRange), at 1/ScanTime per second; falls at the same rate in the behaviour's always-run Update on any tick it was not held (out of range, untracked, no target, or the item inactive: ruling scan-held-beam); reset on a target change; at 1 the scan completes (RecordInspection) and progress restarts. Runtime only. No hostility gate (a scan reads no true faction: classify-from-belief). | The Scanner behaviour owns progress; RecordInspection in Entity.cs writes the reveals through RecordReveal's gate. While held: a Scan paint (Strength = progress) on the target and Emit(Item, Range / InterceptFactor) (ruling scan-is-an-act). | | Sensor stats (SensorData Sensitivity key 3 = detection power, BeamWidth key 12, InterceptFactor key 13; LockWeaponData.InterceptFactor key 26; ListenerData.Multiple key 1; ScannerData Range 1, ScanTime 2, InterceptFactor 3) | Fields of a catalog design; brand flavour through product role quality. | Authored by AetherDb (cut sensor-catalog); resolved per item through StatResolver. PingVisibility (key 7) is retired, never reused. | The catalog. Readers: Sensor (BeamWidth, InterceptFactor), LockWeapon (InterceptFactor), Entity.HearingMultiple (ListenerData). | No empty cell. Two decisions are defaults, not rulings: reveals never decay within a sitting (a ship @@ -9481,3 +9481,116 @@ No weapon's falloff was ever authored: 26 weapons carry one copied template, and Not for range: the deletion removes the only weapon use. Of the other BezierCurve uses, one is live in the sim (sensor bearing gain, on 2 records with the default template), one is null on every record (consumable effectiveness), and the launcher curves are `float4[]` Unity keyframes used only in presentation. A piecewise-linear keyframe type would be the same data with straight segments. Its real gains over BezierCurve are small: `HullRange` becomes exact (the extremes sit at the keys), and the mutable `_cachedIndices` search cache goes from shared sim data. That does not earn a new type or a CultMath change now: CultMath's `lerp` and `unlerp` already are the segment math, and CultMath holds no keyed or serialized curve. Decide it when the sensor line is mapped. R-heat's four scalars stay: they are the controls the operator asked for ("Same shape, more intuitive controls"). + +# Inspection-scanner refresh at b836af48 + +Imagination imagination-aeth-inspection-scanner, session self-2026-10-14-ag, 2026-10-14. Pinned to Aetheria +origin/master b836af48 (contact-hud, emissions-heard, reveals-replace-tiers, scenarios-lock-on, aetheria-ew +ew-hide-launch and ew-claims-in-the-book, loot-3 merged). Refreshes cut_spec inspection-scanner (r2 -> r3) only; +bearing-markers, layout-aim and scanner-catalog stay lines in the cut sequence. Paths under +Assets/Scripts/ServerShared unless noted. Source reads at b836af48. + +## Body facts + +IS1. r2's anchors at b836af48 (context-pack): PaintMode moved to Sensing.cs:42-46 (comment 39-41); Reveal is +Sensing.cs:104-120 (comment 99-103) and gained `Claimed` (ew-claims-in-the-book); RecordReveal is Entity.cs:944-950 +(comment 937-943) and takes `(subject, item, channel, claimed)`. `Reveal.Channel` is still a non-null +`SignatureChannel`. The only `new Reveal(` is Entity.cs:949. + +IS2. No production code reads `Reveal.Channel`: its readers are tests only (ContactRevealTests 321, 410, 413, 437, +1000; EmissionTests 62, 103, 111; LaunchSuppressorTests 61), each `Assert.Equal(SignatureChannel.X, reveal.Channel)`, +which infers `T = SignatureChannel?` once Channel is nullable and so needs no edit. + +IS3. Claims (aetheria-ew ew-claims-in-the-book): `Entity.ClaimOf(item)` (Entity.cs:117-118) is the item's data +unless claimed otherwise; `Claim` is the one write port, tests only until ew-masquerade (109-127). Every act stamps +it: SetSignature (106), Emit (921-925: `ActiveEmission(item, hearRange, ClaimOf(item))`, two arguments, no mode), +ReceivePaint (931-935: `PaintWarning(bearing, emitter.ClaimOf(item), mode, strength)`). PublishInbox (897-911) +records each painter's item as an Emission reveal with the paint's EmitterClass. Classifying readers read +`Reveal.Claimed` (RevealedWeapons 985-987, SchematicRows 1000-1003); ContactOf derives Profile from +`subject.ClaimedHull` at Identified (1011-1030). + +IS4. The hull is an equipped item: `EquippedHull` is added to `Equipment` (Entity.cs:1217-1218), and Claim refuses a +hull class on any other item and any other class on the hull (123-124). A scan that walks Equipment must skip +`subject.EquippedHull` explicitly. + +IS5. Behaviour execution (EquippedItem.Update, Entity.cs:2299-2320): Execute runs per behaviour group only while +`Active.Value` (Enabled && Online, 2126-2127); every `IAlwaysUpdatedBehavior.Update` runs after it on every tick, +active or not. A behaviour whose Execute alone decays progress therefore freezes while its item is inactive. +`TargetRange` is computed in Entity.Update (1704-1706) before the equipment updates. + +IS6. Aim gate: `FireControl.IsRevealed(observer, item)` is book AND live (FireControl.cs:160-161); +`TrySelectTargetItem` and `ResolvedTargetItem` read it (Entity.cs:410-432). A scan reveal therefore makes quiet gear +selectable with no change to aim. `IsLocated` does not exist at b836af48 (layout-aim is unmapped). + +IS7. BehaviorData union ends at `Union(49, LaunchSuppressorData)` (Behaviors/Behaviors.cs:193). Sensor-catalog's +branch (eureka/aetheria-release-sensor-catalog-r2, head 068adf0d) takes 50 for ListenerData at the same place. +ResourceScanner (Union 28, Behaviors/ResourceScanner.cs) is a parked mining behaviour with its own data keys; the +new `ScannerData` is a separate type. + +IS8. Paint readers: the incoming-lock indicator takes the strongest Track paint (Gameplay/ActionGameManager.cs: +1478-1491), so a Scan paint never shows as a lock; the combat flag is `VisibleEnemies.Count > 0 || +IncomingPaints.Count > 0` (1270), so a ship being scanned enters the combat state, as it does when pinged. + +IS9. Negative-check baselines: `Emit(` in Assets/Scripts/ServerShared appears in Entity.cs, Sensor.cs and +LockWeapon.cs (Editor/ShipModPreview.cs is a particle Emit); `ReceivePaint(` in Entity.cs, Sensor.cs and +LockWeapon.cs; `RecordReveal(` and `EndReveals(` only in Entity.cs. + +IS10. Test fixture: ContactRevealTests is a partial class (EmissionTests, ClaimTests are partials); its constructor +writes the fixture catalog (37-110), `Tool(name, behavior)` (236-241) makes a Tool gear, and `Add(position, mounts, +tools)` (250-271) places tools by TryFindSpace on the five-by-five "Rack" hull. + +## Shared sites with sensor-catalog (branch head 068adf0d) + +Read as `git diff b836af48...068adf0d` (merge-base e99cfbed); line numbers below are b836af48's. + +- Behaviors/Behaviors.cs union list: both insert after `Union(49, ...)` (193). Sensor-catalog takes 50; this cut + takes 51 whichever merges first. A textual conflict only: keep both lines. +- tests/Aetheria.Shared.Tests/ContactRevealTests.cs constructor: sensor-catalog inserts 18 lines after the Roar + upsert (61) and edits `Make` (243-246). This cut inserts its scanner designs after `Locker("Hushed")` (98), a + different hunk. +- Entity.cs: sensor-catalog rewrites HearingMultiple (716-718 at b836af48), which this cut does not edit; every hunk of this cut + in Entity.cs (SetSignature is untouched; RecordReveal 937-950) lies below it and shifts by +15 if sensor-catalog + merges first. Semantics shared: a third party hears the scanner at HearRange times its HearingMultiple, which a + listener raises above 1. This cut's hearing test uses a sensor-only observer, so it holds under either order. +- No other shared file (sensor-catalog's Listener.cs, AetherDb, CatalogRoleTests, ListenerTests, EvasionTermTests + and the catalog blob are untouched here). + +Order: either; neither waits on the other. Running beside each other costs the two one-line merges above. + +## Rationale + +- A scan records the claim, not the truth. Every act stamps the class its ship claims (IS3), and the aetheria-ew + target's one-judge invariant puts every see-through in one function (illumination-burns-through names paints + among what burns through). A scan that recorded `item.Data` would be a second see-through path outside the judge, + and would read the true item's data to classify (classify-from-belief). RecordInspection therefore records + `subject.ClaimOf(item)`. While no production code writes a claim (IS3) this equals the truth, so ruling + quiet-gear-identifiable-hull-layout-known is met today; whether a Scan paint burns through a lie is cut + ew-burn-through's, which reads paints already. +- Aim under a hull lie stays ew-masquerade's. Ruling ew-aim-under-hull-lie-ruled closes gear aim while a hull lie is + believed. That gate will sit on the aim read (IsRevealed), which governs scan reveals and act reveals alike, so + this cut adds nothing for it. +- No hostility gate. LockWeapon requires `IsHostileTo` (LockWeapon.cs:98), which reads the true faction. A scanner + inspects whatever its ship targets, and its gate reads only the track and range (ruling + ew-hostility-from-belief-ruled moves allegiance to belief). +- Decay in one place. r2 decayed in Execute, which freezes while the item is inactive (IS5), so a powered-down + scanner held its progress: a broken beam that does not decay, against ruling scan-held-beam. r3 decays in the + behaviour's IAlwaysUpdatedBehavior.Update on any tick Execute did not hold the scan, the one decay site for every + way a scan breaks. +- Channel stays `SignatureChannel?` (null = inspection), r2's design. A new SignatureChannel member would be a new + channel, which the model page reserves for a ruling (row Signature channel), and nothing in production reads the + channel (IS2). +- The AI test is dropped. The Scanner reads only its ship's Target, so an AI ship scans through the same path by + construction (ruling same-ship-same-inputs); a negative check that Scanner.cs reads no Agents or input type + carries the claim instead of an agent fixture. +- Size: 65/80 Hands calls, as r2; one pass. + +## Cut order (amends 'Visibility refresh at efee2a2a') + +emissions-heard, reveals-replace-tiers, contact-hud and ew-claims-in-the-book (all merged) -> inspection-scanner r3 +(runs now, beside sensor-catalog r2); inspection-scanner + sensor-catalog + bearing-markers -> scanner-catalog +(unchanged line). bearing-markers and layout-aim are unchanged lines, mapped when they are about to run. + +## Admitted (imagination-aeth-inspection-scanner, 2026-10-14) + +- mind-commit-6e261b55...: cut-inspection-scanner.r3 (base b836af48), resolution cut_spec.cut-inspection-scanner.r2.n1 + (Superseded). context-pack on r3: all six anchors SAME. No question raised. From cefbb3dca7047f14ffb5db8c4ca01ebdd17ee998 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Wed, 14 Oct 2026 02:07:41 +0200 Subject: [PATCH 2/2] aetheria-release map: damage falloff at fire time (cut-damage-falloff r2) Co-Authored-By: Claude Opus 5.5 --- docs/aetheria-release-map.md | 55 ++++++++++++++++++++++++++++++++++-- 1 file changed, 53 insertions(+), 2 deletions(-) diff --git a/docs/aetheria-release-map.md b/docs/aetheria-release-map.md index fb4bb7aae..2ea520ad4 100644 --- a/docs/aetheria-release-map.md +++ b/docs/aetheria-release-map.md @@ -54,7 +54,7 @@ Cuts without a `cut_spec`, withdrawn 2026-10-12 under map-only-what-runs: a spec - matrix-mines: Weapon matrix, Mine row: Mine Rack, Heavy Mine Layer and Minefield Projector beside the Mine Launcher, with warhead and. Waits on: roles-backfill (refresh needed; ruling catalog-breadth-now (superseded catalog-breadth-after-visibility 2026-10-13): runs now, refresh against master first). - product-lines-gear: Gear product lines: the twenty-two second-maker products of follow-up gear-product-lines, with role quality from maker. Waits on: generic-design-names, roles-backfill (blocked on generic-design-names; ruling catalog-breadth-now (superseded catalog-breadth-after-visibility 2026-10-13): runs now, refresh against master first). - product-lines-weapons: Weapon product lines (r2): r1's nineteen products plus a second maker for the Mine Launcher, authored after. Waits on: generic-design-names, lot-product, roles-backfill (blocked on generic-design-names; ruling catalog-breadth-now (superseded catalog-breadth-after-visibility 2026-10-13): runs now, refresh against master first). -- boost-gear-combat: Stat boosters, combat, tiered by size: a modest 1x1 and a strong 2x2 each for Damage and Range on every gun through. Waits on: boost-gear-systems (blocked on boost-gear-systems; ruling catalog-breadth-now (superseded catalog-breadth-after-visibility 2026-10-13): runs now, refresh against master first). +- boost-gear-combat: Stat boosters, combat, tiered by size: a modest 1x1 and a strong 2x2 each for Damage and Range on every gun through. Waits on: boost-gear-systems (blocked on boost-gear-systems; ruling catalog-breadth-now (superseded catalog-breadth-after-visibility 2026-10-13): runs now, refresh against master first). After damage-falloff: a Range Extender multiplies Range only, so it lengthens the falloff ramp and leaves EffectiveRange where it was; the cut decides whether it also targets EffectiveRange (section "Damage falloff at fire time", DF8). - boost-gear-systems: Stat boosters, systems, tiered by size: a modest 1x1 and a strong 2x2 each for Thrust, Signal, Emissivity and Reactor. Waits on: nothing in the mind (refresh needed; ruling catalog-breadth-now (superseded catalog-breadth-after-visibility 2026-10-13): runs now, refresh against master first). - ships-player: S3, agent side: a player built by AetheriaBuild composes and preloads mod ships with Aetheria materials only, radiators. Waits on: ships-mounts, ships-hull-material, player-build (blocked on ships-hull-material). - ships-addon-gizmos: Blender Ship Mounts tool (r6): gizmos select and drag mounts snapped to cells in Ship Root's frame; arc fans from the. Waits on: ships-addon-mesh-mounts (blocked on ships-addon-mesh-mounts). @@ -73,7 +73,6 @@ Cuts without a `cut_spec`, withdrawn 2026-10-12 under map-only-what-runs: a spec - radiator-geonodes: a Geometry Nodes setup molds radiator panels over a region marked on the model under the radiator hardpoint's name, in the live hull stack. Waits on: Ruling: radiator-panels-molded-by-geonodes. HELD for the operator walkthrough on Starfire (ruling hardpoint-work-held-for-walkthrough). Schematic and model are separate spaces linked only by mount name (ruling schematic-and-model-are-separate-spaces). - floating-greeble-library: operator seed pieces, model-written parametric families, placements as hull-local data (never a GN scatter on the live mesh), merged into the ship mesh at export, kept out of socket clearance. Waits on: operator seed set. Research: GameCult.Geometry.Csg docs/research/greebles-prior-art.md (4877300). -- damage-curve-delete: delete WeaponData.DamageCurve (MessagePack key 7 tombstoned, never reused), the three Weapon RangeDamagePerSecond curve reads and the claims cut's rated copies, which become DamagePerSecond inside [MinRange, Range] and 0 outside; PropertiesPanel's "Damage Range" chart becomes the range numbers; catalog re-saved by AetherDb so the stored schema matches; fixtures that build a DamageCurve lose it. Waits on: the operator's answer on range falloff (section "Weapon damage over range"), and ew-claims-in-the-book merged (it rewrites the same formulas). Rulings: range-ramps-not-curve. - sensor-bearing-shape: SensorData.SensitivityCurve (gain over bearing angle / PI, read in the sim by Sensor.cs:229,262 and bounded by HullRange at :271) becomes authored scalars or is replaced by the beam width ruling sensor-stat-set already names. Waits on: the sensor-catalog chain; decide with it, not before. - consumable-effectiveness: ConsumableItemData.Effectiveness (a BezierCurve over progress through duration, read by Entity.cs:1921 ConsumableProgressFactor) is null on both shipped consumables, so any stat that declares a ConsumableProgress term throws; delete it or give it a validated shape. Waits on: nothing in the mind. ## Body facts @@ -9594,3 +9593,55 @@ emissions-heard, reveals-replace-tiers, contact-hud and ew-claims-in-the-book (a - mind-commit-6e261b55...: cut-inspection-scanner.r3 (base b836af48), resolution cut_spec.cut-inspection-scanner.r2.n1 (Superseded). context-pack on r3: all six anchors SAME. No question raised. + +## Damage falloff at fire time (imagination-aeth-damage-falloff, 2026-10-14) + +Operator ruling damage-curve-fate-ruled (make-falloff-real): "Simplify weapon range to minimum, effective and maximum, one lerp." The BezierCurve DamageCurve goes; hits, the AI and the panel read one function. Probes ran at origin/master b836af48 (worktree `C:\aeth-wt\map-damage-falloff`). + +### Body facts + +**DF1. The census at 1746e8bd still holds at b836af48.** `git log 1746e8bd..b836af48 -- GameData/Aetheria.cc` lists only launch-suppressor's two applies, which add gear, not weapons. Re-probed on Yggdrasil (scratch console over `AetheriaStores.Open`, job `imagination-aeth-damage-falloff/probe1.log`, 2026-10-14): 27 weapon designs carry a DamageCurve, 26 the copied default `(0,1,0,0) (1,0,-1.77,-1.77)`, Mine Launcher flat `(0,1) (1,1)`. By behaviour: Instant 2, Auto 13, Charged 5, Constant 1 (21 guns and beams, three of them the Smoke Refused rounds at Range 20); Guided 3 and Launcher 2 (5 missiles); MineLayer 1. No gear in the catalog carries a StatModifier on any Range stat. + +**DF2. Range stats as authored.** MinRange is 0..0 on 25 weapons (terms `Heat:1`, inert at 0); LRMM72 500..500 and GT 3K 500..50 (follow-up gt3k-minrange-inverted). Range is quality-ranged on every weapon but the three Smoke Refused (20..20): for example Autocannon 800..1200 `[Heat:1, Quality:barrel:2]`, CShot RainbowLite 1000..3000 `[Heat:.5, Durability:.25, Quality:focusing array:2]`, Mine Launcher 1600..2400 `[Quality:dispenser:2]`. Each Range reads one declared role, so a stat with Range's terms copied reads the same role, and CB-R1 (`CatalogRoleTests.ShippedCatalogRolesAreLive`) holds. + +**DF3. Where the curve is read at b836af48** (aetheria-ew ew-claims-in-the-book has merged, so the rated copies are live): +- `WeaponData.DamageCurve` key 7 (`Weapon.cs:40-41`). The highest key in the WeaponData hierarchy is 34 (`LockWeapon.cs`); 35 and 36 are free. +- Three shared formulas: `InstantWeaponData.RangeDamagePerSecond` (`InstantWeapon.cs:39-40`), `ConstantWeaponData` (`ConstantWeapon.cs:28-29`), `ChargedWeaponData` (`ChargedWeapon.cs:59-61`), each `curve.Evaluate(saturate(unlerp(minRange, range, at)))`. Each has a rated caller (`:42-43`, `:31-32`, `:63-65`) and a live caller (`:73-76`, `:57-60`, `:91-95`). +- AI: `Combat.cs:48` (claimed design, rated), `:73` (own groups, live), `:157` (SampleDps, live). +- Panel: `PropertiesPanel.cs:423-427` draws the curve through `CurveField.Show(string, BezierCurve, ...)` (`CurveField.cs:39-73`); that is CurveField's only caller, and its `showMax` path is unused. +- Tools: AetherDb `smoke-rounds` copies it (`Program.cs:1741`), `mine-launcher` authors a flat one (`:1831`). +- Tests: 30 fixture lines in 21 files set a curve, all flat but `ContactRevealTests.cs:170`, which sets `ClaimTests`' falling `Falloff()` (`ClaimTests.cs:22`) through `ContactRevealTests.Spanned` (`:165-175`); `FireControlTests.ClaimedDesign` takes a curve (`:289-299`) and `TheAIRanksClaimsAtTheTargetsDistance` passes a falling one (`:361-364`); `RunStartTests.EverySoldWeaponHasADamageCurve` (`:463-473`) requires one on every sold weapon. +- Not readers: `BezierCurve` itself stays (SensorData.SensitivityCurve, `Sensor.cs`); the Unity weapon presenters read `Range` only. + +**DF4. Who decides range today.** One gate, `FireControl.Designated` (`FireControl.cs:270-276`): planar range, inclusive `[MinRange, Range]`, read by PFire, Solve, the agents' trigger and Combat's group test (`Combat.cs:65`). `LockWeapon.CanFire` (`LockWeapon.cs:62`) keeps its own strict `(MinRange, Range)` test. The AI's distance is 3D (`Combat.cs:35`, `length(toTarget)`) while the gate is planar (FireControl R7). SampleDps (`Combat.cs:136-168`) samples only between the shortest and longest weapon **Range**, so a ship whose guns share one Range samples one point, its maximum: with falloff to zero there, that ship's optimum stays at its initial 0 and it closes to point blank. + +**DF5. Where damage is decided at fire time.** `FireControl.Fire` freezes `Damage = damageOverride ?? weapon.Damage` into the PendingShot (`FireControl.cs:725`); a beam passes `Damage * interval` as the override (`ConstantWeapon.cs:188`), and a charged gun's Damage is already lerped by charge. Every resolution path reads the frozen `shot.Damage`. `Solve` already computes the distance the payload is delivered at: `BurstReach = length((burstPosition - origin).xz)` (`:654`), where `burstPosition` is the engaged target for a direct round, the armed burst point for a fused one (bomb fishing at Range included), and the origin (0) for an untargeted direct round. Its comments (`:587`, `:2040-2041`) say it is read for Burst only. Mines are laid by `Lay` (`:787`) with no range from the shooter. + +**DF6. The AI's range bias.** `Settings.AgentRangeExponent` defaults to .25 (`Settings.cs:255`); SampleDps multiplies dps by `range^.25`. For a gun flat to E and ramping linearly to 0 at M, `d/dr ln(dps) = .25/r - 1/(M - r)` just past E is negative whenever E > M/5, so the optimum is E itself: the AI holds at its effective range. + +**DF7. Prior art for the unruled numbers** (short search, 2026-10-14; community sources, not publisher documentation). MechWarrior Online: damage falls linearly from a weapon's optimal range to zero at its maximum, about 2x optimal for energy weapons and 3x for autocannons; LRMs instead ramp up below their minimum range ([MWO forum](https://mwomercs.com/forums/topic/155906-ac2-range-change-was-great-now-do-it-for-all-the-autocannons/), [MWO wiki, C-LRM 10](https://mwo.fandom.com/wiki/C-LRM_10)). Elite Dangerous: lasers fall off linearly from about 500 m to zero at their 3 km maximum; cannons and missiles do not fall off ([Steam discussion](https://steamcommunity.com/app/359320/discussions/0/2653115771069188807)). Shooters with a damage floor (Battlefield, Destiny) have no hard range gate to meet. Both games with a min/effective/max triple end at zero, and both exempt missiles. + +**DF8. Range boosters.** A StatModifier targets one stat by reference (`StatModifier.cs:229`). The boost-gear-combat line's Range Extender (section "Catalog breadth", design tables) targets `WeaponData.Range`; after this cut it lengthens the ramp and leaves EffectiveRange. No shipped gear modifies a range today (DF1), so nothing changes now. + +### The design + +One function, `WeaponData.RangeFactor(min, effective, max, damageAtMax, at)`: 0 outside the gate's inclusive `[min, max]`; with `e = clamp(effective, min, max)`, 1 on `[min, e]`, then `lerp(1, damageAtMax, unlerp(e, max, at))` up to `max`; 1 everywhere inside the gate when `e >= max`. EffectiveRange is a PerformanceStat (key 35) defaulting to +infinity, as Tracking does (key 33), so an unauthored weapon is flat and every fixture keeps its damage. `DamageAtMaxRange` is a plain float (key 36, default 0): quality does not vary it, so it needs no role. Callers: +- the hit: `Fire` multiplies the frozen Damage by the factor at `solution.BurstReach`; +- the AI: the three DPS formulas take the factor in place of the curve (live through `Weapon.RangeFactor`, rated through `WeaponData.RatedRangeFactor` over each stat's Max); Combat reads planar range and samples from the shortest MinRange; +- the panel: CurveField plots any `Func`, and the panel passes the factor over `[min, max]`. + +Missiles and mines get no EffectiveRange (flat): DF7's games exempt missiles, and a mine's damage happens where the mine is, not at a range from its layer. + +### Model page rows + +| Kind | Identity | Lifecycle | Authority | +|---|---|---|---| +| Weapon range shape (`WeaponData` MinRange key 5, Range key 6, EffectiveRange key 35, DamageAtMaxRange key 36; DamageCurve key 7 retired, never reused) | Fields of a catalog weapon design; ranges resolved per item through StatResolver. | Authored by AetherDb `range-falloff` (cut damage-falloff); an unauthored EffectiveRange means no falloff. | The catalog. One reader, `WeaponData.RangeFactor`: FireControl.Fire (the hit), the DPS formulas (Combat's choices) and PropertiesPanel (the chart). | + +### Rationale + +- BurstReach, not FireRange: FireRange is the target's distance or 0, so a fused round fished to Range would land at full damage. BurstReach is where the payload is delivered for every outcome, and Solve already computes it. +- EffectiveRange is a stat, not a fraction of Range: the ruling names three authored ranges. A copied stat moves with quality, heat and wear as Range does (DF2); only a booster on Range alone moves one without the other (DF8). +- +infinity as the unauthored value: it is Tracking's precedent, it keeps every fixture's damage, and "no falloff" becomes a value the function already handles rather than a flag. +- Size: one Hands pass (about 110 calls, cap 150), with a declared stop point before the catalog apply. +- The two numbers the operator has not ruled (the end multiplier and how effective ranges are authored) are authored data with defaults from DF7, so they do not block Hands; a different answer is a rerun of `range-falloff` with other arguments.