diff --git a/Assets/Scripts/ServerShared/Scenarios/LockOn.cs b/Assets/Scripts/ServerShared/Scenarios/LockOn.cs new file mode 100644 index 000000000..0aab7dabe --- /dev/null +++ b/Assets/Scripts/ServerShared/Scenarios/LockOn.cs @@ -0,0 +1,43 @@ +using static CultMath.math; +using static ItemRotation; + +public sealed class LockOn : Scenario +{ + public override string Name => "Lock On"; + public override string Brief => "A hostile closes from out of sight, finds you and locks. Verify: no warning at first; once it locks, one " + + "indicator appears toward it and tightens as the lock grows; break line of sight or range and it vanishes; " + + "your own ping shows no incoming paint on its side, only the lock does."; + public override uint Seed => 113; + public override bool Ambient => false; + + // The hostile starts far beyond the player's sight and the hostile's own, 4000 m ahead facing the player. Stepping the + // arena headlessly, it closes to about 3000 m, sees the player after some eight seconds, and locks two ticks later; + // at Duel's 900 m (and at 600 m) it sees and locks within a second. + public static readonly CultMath.float2 HostileAt = float2(0, 4000); + + public override Galaxy Generate(GalaxyStage stage) => stage.Prelude(DemoTerminus.Cast); + + public override void Stage(ScenarioStage stage) + { + var fighter = stage.Fit("Longinus", + ("Cockpit 2x2", int2(2, 6), None), + ("Large Drive", int2(1, 0), Reversed), + ("Large Drive", int2(3, 0), Reversed), + ("Talaria", int2(2, 14), CounterClockwise), + ("Talaria", int2(3, 14), Clockwise), + ("Core Power", int2(2, 4), None), + ("GT 3K", int2(0, 5), None), + ("GT 3K", int2(5, 5), None), + ("FastBlast+-", int2(1, 8), None), + ("FastBlast+-", int2(4, 8), None), + ("Iapyx", int2(2, 2), CounterClockwise), + ("Iapyx", int2(3, 2), Clockwise), + ("not if i see you first", int2(3, 10), None), + ("PotaT+-", int2(1, 5), None), + ("Fire Control Array", int2(1, 6), Clockwise), + ("Store-All Plus", int2(2, 8), None)); + + stage.Player(fighter, float2(0, 0), facing: float2(0, 1)); + stage.Place(fighter, HostileAt, facing: float2(0, -1), stance: ScenarioStance.Hostile, piloted: true); + } +} diff --git a/Assets/Scripts/ServerShared/Scenarios/LockOn.cs.meta b/Assets/Scripts/ServerShared/Scenarios/LockOn.cs.meta new file mode 100644 index 000000000..1512201c0 --- /dev/null +++ b/Assets/Scripts/ServerShared/Scenarios/LockOn.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 3f0b6d2a9c7e4a1b8d5e2c6f7a9b0c14 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/ServerShared/Scenarios/Scenarios.cs b/Assets/Scripts/ServerShared/Scenarios/Scenarios.cs index a201fc6b9..752b33e28 100644 --- a/Assets/Scripts/ServerShared/Scenarios/Scenarios.cs +++ b/Assets/Scripts/ServerShared/Scenarios/Scenarios.cs @@ -9,6 +9,6 @@ public static class Scenarios public static readonly Scenario[] Tests = { - new DjinniShakedown(), new StarvedReactor(), new Arcs(), new Duel(), new LauncherAngles(), new WeaponFeel(), new FusedRounds(), new RefusedRounds(), new AiFusedDiscipline(), new LongHaul(), new Pursuit(), new Crossing(), new Belt() + new DjinniShakedown(), new StarvedReactor(), new Arcs(), new Duel(), new LauncherAngles(), new WeaponFeel(), new FusedRounds(), new RefusedRounds(), new AiFusedDiscipline(), new LongHaul(), new Pursuit(), new Crossing(), new Belt(), new LockOn() }; } diff --git a/tests/Aetheria.Shared.Tests/LockOnScenarioTests.cs b/tests/Aetheria.Shared.Tests/LockOnScenarioTests.cs new file mode 100644 index 000000000..3af2fef45 --- /dev/null +++ b/tests/Aetheria.Shared.Tests/LockOnScenarioTests.cs @@ -0,0 +1,43 @@ +using System.Linq; +using Xunit; +using static CultMath.math; + +// The arena the operator flies to check the incoming-lock warning (map: Scenarios for operator checks, SC5 and SC14). The +// test launches the scenario the way New Game does and steps what it staged. +public sealed partial class RunStartTests +{ + // Lock On: the hostile starts piloted, beyond its sight of the player, and the player has no incoming paint. Stepped at + // .1 s, it closes, finds the player and locks: a Track paint reaches the player bearing toward the hostile, and not at + // once, because the hostile had to find the player first. The tick is the lock's, at seed 113 it is 83 (8.4 s). + [Fact] + public void LockOnSituation() + { + var (_, arena, staged, failures) = Launch(new LockOn(), Inputs(() => GalaxySeed)); + Assert.True(failures.Count == 0, string.Join("; ", failures)); + var player = staged.Player; + var hostile = Assert.Single(staged.Entities); + Assert.True(player.IsHostileTo(hostile) && hostile.IsHostileTo(player), "the hostile is hostile both ways"); + Assert.Equal(1, AgentsOf(arena, hostile)); + + arena.Update(0f); + Assert.DoesNotContain(hostile, player.VisibleEnemies); + Assert.DoesNotContain(player.IncomingPaints, paint => paint.Mode == PaintMode.Track); + Assert.DoesNotContain(player, hostile.VisibleEnemies); // it starts without a track of the player + + var lockedAt = -1; + var bearingDot = 0f; + for (var tick = 0; tick < 600 && lockedAt < 0; tick++) + { + arena.Update(.1f); + foreach (var paint in player.IncomingPaints.Where(paint => paint.Mode == PaintMode.Track)) + { + lockedAt = tick; + bearingDot = dot(normalize(paint.Bearing), normalize(hostile.Position.xz - player.Position.xz)); + } + } + Assert.True(lockedAt >= 0, "the hostile never locked the player within 600 ticks of .1 s"); + Assert.True(bearingDot >= cos(radians(5f)), "the warning points at the hostile"); + // Not at the staging: the hostile had to close and find the player first (a hostile staged inside sight locks within 10 ticks). + Assert.InRange(lockedAt, 40, 200); + } +}