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"); + } +}