From 0e89dd16731b84a157bc071169bf65ddc00adfe6 Mon Sep 17 00:00:00 2001 From: Meta Vens Date: Fri, 9 Oct 2026 20:19:22 +0200 Subject: [PATCH] FireControl.RoundAt: the one statement of where a fired round is at a sim time PendingShot freezes the weapon's Velocity as Speed at Fire; RoundAt(shot, time) reads the frozen origin, direction, speed and fire time, clamped to the FireRange point. Step, Commit and Apply do not call it. BallisticFlightTests pin the line against the shooter position, aim and authored velocity. Builds: yes. Presenters still fly their own rounds at this commit. Co-Authored-By: Claude Opus 5.5 --- Assets/Scripts/ServerShared/FireControl.cs | 13 ++ .../BallisticFlightTests.cs | 127 ++++++++++++++++++ 2 files changed, 140 insertions(+) create mode 100644 tests/Aetheria.Shared.Tests/BallisticFlightTests.cs diff --git a/Assets/Scripts/ServerShared/FireControl.cs b/Assets/Scripts/ServerShared/FireControl.cs index 138776ce9..097c3cc79 100644 --- a/Assets/Scripts/ServerShared/FireControl.cs +++ b/Assets/Scripts/ServerShared/FireControl.cs @@ -514,6 +514,16 @@ public static class FireControl return shot.Target == null ? 1f : PDeviation(deviation, shot.Tracking); } + // Where a ballistic round is at a sim time: the one statement of the round's line, from its frozen origin along its + // frozen direction at its frozen speed, held at the FireRange point once it has flown that far. Pure: it reads the + // shot alone, and the simulation's own arithmetic (Step, Commit, Apply) does not call it. Presenters draw rounds here. + public static float2 RoundAt(in PendingShot shot, float time) + { + if (shot.Speed <= .01f) return shot.FireOrigin.xz; + var flown = clamp(time - shot.FireTime, 0f, shot.FireRange / shot.Speed); + return shot.FireOrigin.xz + shot.TravelDirection * (shot.Speed * flown); + } + // How far a target can and does move off the line of fire in the solution window: the term DeviationProbability // and HitProbability both add. Behaviour (its observed unpredictability across the line of sight) realises the // evasion and capability (its envelope's reach) caps it, so a coasting ship evades nothing whatever it could do @@ -755,6 +765,7 @@ public static class FireControl Spread = weapon.Spread, FireRange = fireRange, FireTime = now, + Speed = weapon.Velocity, FireOrigin = origin, FireTargetPosition = targetPosition, FireTargetVelocity = targetVelocity, @@ -1999,6 +2010,8 @@ public struct PendingShot public float3 FireTargetPosition; public float3 FireTargetVelocity; public float FireTime; + // The weapon's Velocity at Fire: frozen with the rest, so RoundAt states the same line whatever happens to the stat later. + public float Speed; public float CommitTime; public float ArrivalTime; diff --git a/tests/Aetheria.Shared.Tests/BallisticFlightTests.cs b/tests/Aetheria.Shared.Tests/BallisticFlightTests.cs new file mode 100644 index 000000000..cd3582d70 --- /dev/null +++ b/tests/Aetheria.Shared.Tests/BallisticFlightTests.cs @@ -0,0 +1,127 @@ +/* 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 System.Linq; +using Xunit; +using static CultMath.math; +using float2 = CultMath.float2; +using float3 = CultMath.float3; + +// Ballistic flight: FireControl.RoundAt is the one statement of where a fired round is at a sim time, from the +// PendingShot's frozen origin, direction, speed and fire time. Unity draws rounds there and integrates nothing, so +// these tests pin the line itself against first principles (the shooter's position, the aim, the authored velocity) +// rather than against the code that computes it. Shares the Cut 12.4 engagement fixture. +public sealed partial class FireControlCut124Tests +{ + private const float BallisticSpeed = 20f; + + // A no-lock proximity round: flies the aim line (2,1) to max range, bursting there. + private Engagement FireBurstRound(out float3 origin) + { + var e = Build(TestSettings(), SolidShape(5, 4), velocity: BallisticSpeed, fuse: WeaponFuse.Proximity, blastRadius: 4f, + damage: 100f, weaponRange: NoLockRange); + Aim(e, float2(2, 1)); + e.Shooter.SetTarget(TargetRef.None); + origin = e.Shooter.Position; + FireControl.Fire(e.Weapon, e.WeaponItem, e.Shooter); + return e; + } + + [Fact] + public void RoundAtIsTheFiredLine() + { + // Burst round: leaves the shooter, is where its own speed puts it a second in, and ends on the burst point. + var e = FireBurstRound(out var origin); + var burst = SafeAssert.OnlyShot(e.Zone); + var aim = normalize(float2(2, 1)); + + var start = FireControl.RoundAt(burst, burst.FireTime); + Assert.Equal(origin.x, start.x, 3); + Assert.Equal(origin.z, start.y, 3); + + var second = FireControl.RoundAt(burst, burst.FireTime + 1f); + Assert.Equal(origin.x + aim.x * BallisticSpeed, second.x, 3); + Assert.Equal(origin.z + aim.y * BallisticSpeed, second.y, 3); + + var arrival = FireControl.RoundAt(burst, burst.ArrivalTime); + Assert.Equal(burst.BurstPosition.x, arrival.x, 3); + Assert.Equal(burst.BurstPosition.z, arrival.y, 3); + + // Past the range it is held at the FireRange point, however late it is asked. + var held = FireControl.RoundAt(burst, burst.FireTime + NoLockRange / BallisticSpeed + 50f); + Assert.Equal(origin.x + aim.x * NoLockRange, held.x, 3); + Assert.Equal(origin.z + aim.y * NoLockRange, held.y, 3); + // Before it was fired it is still at the origin, not behind it. + var before = FireControl.RoundAt(burst, burst.FireTime - 5f); + Assert.Equal(origin.x, before.x, 3); + Assert.Equal(origin.z, before.y, 3); + + // Direct round at a stationary target 100 ahead (+z): arrives on the target, and holds at the range point. + var d = Build(TestSettings(), SolidShape(5, 4), velocity: BallisticSpeed, weaponRange: 1000f); + var dOrigin = d.Shooter.Position; + FireControl.Fire(d.Weapon, d.WeaponItem, d.Shooter); + var direct = SafeAssert.OnlyShot(d.Zone); + var hit = FireControl.RoundAt(direct, direct.ArrivalTime); + Assert.Equal(d.Target.Position.x, hit.x, 2); + Assert.Equal(d.Target.Position.z, hit.y, 2); + Assert.Equal(dOrigin.z + 100f / 2f, FireControl.RoundAt(direct, direct.FireTime + 2.5f).y, 2); + var heldDirect = FireControl.RoundAt(direct, direct.FireTime + direct.FireRange / BallisticSpeed + 99f); + Assert.Equal(dOrigin.z + direct.FireRange, heldDirect.y, 2); + } + + // A round with no speed (the weapon authors Velocity 0, or effectively 0) does not fly: it is at its origin at any + // time, and is not stretched along its line by a vanishing speed over the range it would need forever to cover. + [Fact] + public void ARoundWithNoSpeedStaysAtItsOrigin() + { + var e = Build(TestSettings(), SolidShape(5, 4), velocity: .005f, weaponRange: 1000f); + var origin = e.Shooter.Position; + FireControl.Fire(e.Weapon, e.WeaponItem, e.Shooter); + var shot = SafeAssert.OnlyShot(e.Zone); + + var late = FireControl.RoundAt(shot, shot.FireTime + 5000f); + Assert.Equal(origin.x, late.x, 3); + Assert.Equal(origin.z, late.y, 3); + } + + [Fact] + public void SpeedIsFrozenAtFire() + { + var e = FireBurstRound(out var origin); + var shot = SafeAssert.OnlyShot(e.Zone); + Assert.Equal(BallisticSpeed, shot.Speed, 4); + + // The stat changes after the round left, and the weapon re-reads it. + ((InstantWeaponData) e.Weapon.WeaponData).Velocity = Constant(BallisticSpeed * 5f); + e.Weapon.Execute(0f); + Assert.Equal(BallisticSpeed * 5f, e.Weapon.Velocity, 4); + + var after = SafeAssert.OnlyShot(e.Zone); + Assert.Equal(BallisticSpeed, after.Speed, 4); + var aim = normalize(float2(2, 1)); + var at = FireControl.RoundAt(after, after.FireTime + 1f); + Assert.Equal(origin.x + aim.x * BallisticSpeed, at.x, 3); + Assert.Equal(origin.z + aim.y * BallisticSpeed, at.y, 3); + } + + [Fact] + public void RoundAtIsPure() + { + var e = FireBurstRound(out _); + var shot = SafeAssert.OnlyShot(e.Zone); + var time = e.Zone.Time; + var entities = e.Zone.Entities.ToList(); + var positions = entities.Select(x => x.Position).ToList(); + var velocities = entities.Select(x => x.Velocity).ToList(); + + for (var i = 0; i < 25; i++) + FireControl.RoundAt(shot, shot.FireTime + i * .37f); + + Assert.Equal(time, e.Zone.Time); + Assert.True(e.Zone.PendingShots.Count == 1 && e.Zone.PendingShots[0].Equals(shot), "the pending shot changed"); + Assert.True(e.Zone.Entities.SequenceEqual(entities), "the zone's entities changed"); + Assert.True(entities.Select(x => x.Position).SequenceEqual(positions), "an entity moved"); + Assert.True(entities.Select(x => x.Velocity).SequenceEqual(velocities), "an entity's velocity changed"); + } +}