diff --git a/Assets/Scripts/ServerShared/ScenarioStage.cs b/Assets/Scripts/ServerShared/ScenarioStage.cs index 8f532e03f..159504292 100644 --- a/Assets/Scripts/ServerShared/ScenarioStage.cs +++ b/Assets/Scripts/ServerShared/ScenarioStage.cs @@ -105,12 +105,15 @@ public sealed class ScenarioStage } // Anything else in the arena. A stance holds both ways between it and the player. A piloted ship gets the zone's - // pilot; an unpiloted entity has none and goes nowhere on its own. A turret hull stays where it is put. - public Entity Place(ScenarioFit fit, float2 at, float2 facing = default, ScenarioStance stance = ScenarioStance.Neutral, bool piloted = false) + // pilot; an unpiloted entity has none and goes nowhere on its own unless it is placed moving: velocity is the planar + // velocity it starts with, and the sim carries it from there. A turret hull stays where it is put. + public Entity Place(ScenarioFit fit, float2 at, float2 facing = default, ScenarioStance stance = ScenarioStance.Neutral, bool piloted = false, + float2 velocity = default) { var where = $"entity {_placements++}"; var entity = Build(fit, where, at, facing); if (entity == null) return null; + entity.Velocity = velocity; if (piloted && !(entity is Ship)) _failures.Add($"{where}: {entity.Name} is not a ship hull, so it cannot be piloted"); _placed.Add(new Placement { Entity = entity, Stance = stance, Piloted = piloted }); return entity; diff --git a/Assets/Scripts/ServerShared/Scenarios/Crossing.cs b/Assets/Scripts/ServerShared/Scenarios/Crossing.cs new file mode 100644 index 000000000..60ede6afb --- /dev/null +++ b/Assets/Scripts/ServerShared/Scenarios/Crossing.cs @@ -0,0 +1,46 @@ +using static CultMath.math; +using static ItemRotation; + +public sealed class Crossing : Scenario +{ + public override string Name => "Crossing"; + public override string Brief => "plight at the starboard gun and a FastBlast+- at the port gun, a fast Djinni crossing close ahead and an " + + "unpiloted one waiting at range. The Djinni starts to port moving across the bow; the arena's gravity bends its run. Make the pass coasting: give no throttle until the Djinni has crossed the bow, then fly freely (thrusting from the start carries you past it). Verify: as the Djinni crosses close, FastBlast lands some and plight " + + "almost none; against the Djinni at range both land. Fly it again without the Fire Control Array: " + + "with it the small gun lands more."; + public override uint Seed => 112; + public override bool Ambient => false; + + // Where the Djinni sit: the player is at the origin facing +z. The crosser starts ahead and to port, facing across + // the bow and already moving at the Djinni's 50 m/s cap, so its run sweeps across the bow within seconds (the arena + // pulls the player to port, which brings the two together). The waiting Djinni sits inside plight's arc at 80% of + // its Range. + public static readonly CultMath.float2 CrosserAt = float2(-150, 200), CrosserFacing = float2(1, 0), CrosserVelocity = float2(50, 0); + public const float PlightRange = 1216f; // plight's Range in metres, 1216.4 as the fit stands settled at rest + public static readonly CultMath.float2 Waiting = float2(0, PlightRange * .8f); + + 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), + ("plight", 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), + ("Fire Control Array", int2(1, 6), Clockwise)); + + stage.Player(fighter, float2(0, 0), facing: float2(0, 1)); + stage.Place(stage.Generated("Djinni"), CrosserAt, facing: CrosserFacing, stance: ScenarioStance.Hostile, piloted: true, velocity: CrosserVelocity); + stage.Place(stage.Bare("Djinni"), Waiting); + } +} diff --git a/Assets/Scripts/ServerShared/Scenarios/Crossing.cs.meta b/Assets/Scripts/ServerShared/Scenarios/Crossing.cs.meta new file mode 100644 index 000000000..2787758ab --- /dev/null +++ b/Assets/Scripts/ServerShared/Scenarios/Crossing.cs.meta @@ -0,0 +1,11 @@ +fileFormatVersion: 2 +guid: 0cc3edfb4b0e4ea485cce71354f41748 +MonoImporter: + externalObjects: {} + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Assets/Scripts/ServerShared/Scenarios/DjinniShakedown.cs b/Assets/Scripts/ServerShared/Scenarios/DjinniShakedown.cs index 720fa2d08..7cbec5630 100644 --- a/Assets/Scripts/ServerShared/Scenarios/DjinniShakedown.cs +++ b/Assets/Scripts/ServerShared/Scenarios/DjinniShakedown.cs @@ -3,13 +3,22 @@ using float2 = CultMath.float2; public sealed class DjinniShakedown : Scenario { public override string Name => "Djinni Shakedown"; - public override string Brief => "A fitted Djinni in empty space. Verify: its thrusters move and turn it; with the hull " + - "offline and thrusters firing, its speed does not run away."; + public override string Brief => "A fitted Djinni in empty space, facing +z, with a bare hull dead ahead and one abeam. Verify: its thrusters " + + "move and turn it; with the hull offline and thrusters firing, its speed does not run away. Its " + + "articulated ballistic barrel points at the hull ahead when it bears, and rests at the arc edge while you " + + "aim at the hull abeam."; public override uint Seed => 101; public override bool Ambient => false; + // Where the targets sit: the ballistic mount faces +z, so Ahead is inside its arc and Abeam outside it. + public static readonly float2 Ahead = new float2(0, 400), Abeam = new float2(400, 0); + public override Galaxy Generate(GalaxyStage stage) => stage.Prelude(); - public override void Stage(ScenarioStage stage) => + public override void Stage(ScenarioStage stage) + { stage.Player(stage.Generated("Djinni"), float2.zero); + stage.Place(stage.Bare("Longinus"), Ahead); + stage.Place(stage.Bare("Longinus"), Abeam); + } } diff --git a/Assets/Scripts/ServerShared/Scenarios/Scenarios.cs b/Assets/Scripts/ServerShared/Scenarios/Scenarios.cs index 288f8373d..38cbfea88 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 LongHaul(), new Pursuit() + new DjinniShakedown(), new StarvedReactor(), new Arcs(), new Duel(), new LauncherAngles(), new LongHaul(), new Pursuit(), new Crossing() }; } diff --git a/tests/Aetheria.Shared.Tests/CrossingScenarioTests.cs b/tests/Aetheria.Shared.Tests/CrossingScenarioTests.cs new file mode 100644 index 000000000..1ac80e455 --- /dev/null +++ b/tests/Aetheria.Shared.Tests/CrossingScenarioTests.cs @@ -0,0 +1,138 @@ +using System.Linq; +using Xunit; +using static CultMath.math; +using float2 = CultMath.float2; +using float3 = CultMath.float3; + +// The arenas the operator flies to check the evasion term and the articulated barrel (map: Scenarios for operator +// checks). Each test launches the scenario the way New Game does and reads what it staged, so a script that stops +// staging what its brief claims fails here. +public sealed partial class RunStartTests +{ + // Crossing: the demo's cast; plight and FastBlast+- fitted in separate weapon groups with the Fire Control Array + // aboard; a piloted hostile Djinni that crosses the bow inside 400 m; and an unpiloted neutral one inside plight's + // arc, short of its Range and beyond three quarters of it. + [Fact] + public void CrossingConditions() + { + var (galaxy, arena, staged, failures) = Launch(new Crossing(), Inputs(() => GalaxySeed)); + Assert.True(failures.Count == 0, string.Join("; ", failures)); + Assert.Equal(DemoTerminus.Cast.ZoneCount, galaxy.Zones.Length); + Assert.Equal(4, galaxy.HomeZones.Count); + + var player = staged.Player; + var plight = player.Equipment.Single(item => item.Data.Name == "plight"); + var small = player.Equipment.Single(item => item.Data.Name == "FastBlast+-"); + Assert.Contains(player.Equipment, item => item.Data.Name == "Fire Control Array"); + var groupOf = new System.Func(item => System.Array.FindIndex(player.WeaponGroups, group => group.items.Contains(item))); + Assert.True(groupOf(plight) >= 0 && groupOf(small) >= 0, "both guns are in a weapon group"); + Assert.NotEqual(groupOf(plight), groupOf(small)); + + Assert.Equal(2, staged.Entities.Count); + var crosser = staged.Entities[0]; + var waiting = staged.Entities[1]; + Assert.IsType(crosser); + Assert.IsType(waiting); + Assert.Equal(("Djinni", "Djinni"), (_items.GetData(crosser.Hull).Name, _items.GetData(waiting.Hull).Name)); + Assert.Contains(crosser.Equipment, item => item.Behaviors.OfType().Any()); + + Assert.True(player.IsHostileTo(crosser) && crosser.IsHostileTo(player), "the crosser is hostile both ways"); + Assert.Equal(1, AgentsOf(arena, crosser)); + var toCrosser = crosser.Position - player.Position; + Assert.True(length(toCrosser) < 400f, "the crosser starts inside 400 m"); + Assert.True(toCrosser.z > 0, "the crosser starts ahead"); + Assert.True(abs(dot(crosser.Direction, player.Direction)) <= sin(radians(30f)) + 1e-4f, + "the crosser faces within 30 degrees of perpendicular to the player's bow"); + // It is placed moving: toward the bow line at most of the Djinni's 50 m/s cap, so its run is its own and not only the + // arena's pull on the player. + var crosserVelocity = ((Ship) crosser).Velocity; + Assert.True(crosserVelocity.x * toCrosser.x < 0, "the crosser starts moving toward the bow line"); + Assert.True(abs(crosserVelocity.x) >= 40f, "the crosser's speed toward the bow line is most of the Djinni's speed cap"); + Assert.True(length(crosserVelocity) >= 40f, "the crosser starts at most of the Djinni's speed cap"); + + Assert.False(player.IsHostileTo(waiting) || waiting.IsHostileTo(player), "the waiting Djinni is neutral"); + Assert.Equal(0, AgentsOf(arena, waiting)); + var toWaiting = waiting.Position - player.Position; + EvSettle(player); // a weapon's Range is read once the ship's stats have settled; the geometry above is as staged + var range = plight.Behaviors.OfType().Single().Range; + Assert.True(FireControl.InArc(plight, toWaiting), "the waiting Djinni is inside plight's arc"); + Assert.True(length(toWaiting) <= range, "the waiting Djinni is inside plight's Range"); + Assert.True(length(toWaiting) > .75f * range, "the waiting Djinni is beyond three quarters of plight's Range"); + + // The crossing is what the sim does with that staging, read in the player's frame: the arena's gravity and the + // crosser's pilot act from the first tick, so the t=0 facing proves nothing. Within CrossingSeconds the crosser's + // bearing sweeps from port to starboard while it is ahead and inside CrossingMetres, and both guns bear on it. + // The pass is made by a coasting player: the loop gives no input, and the Brief tells the operator to fly it that way. + Assert.Equal(float2.zero, player.MovementDirection); + var swept = false; + var crossedAt = 0f; + var crossedMetres = 0f; + for (var tick = 0; tick < 60 * CrossingSeconds && !swept; tick++) + { + var before = crosser.Position - player.Position; + arena.Update(1f / 60f); + var after = crosser.Position - player.Position; + if (before.x < 0 && after.x >= 0) + { + swept = true; + crossedAt = (tick + 1) / 60f; + crossedMetres = length(after); + Assert.True(after.z > 0, "the crosser passes the bow line ahead of the player, not astern"); + Assert.True(length(after) < CrossingMetres, "the crosser passes inside the stated distance"); + Assert.True(FireControl.InArc(small, after), "FastBlast+- bears on the crosser as it crosses"); + Assert.True(dot(FireControl.MountDirection(small), float3(player.Direction.x, 0, player.Direction.y)) > 0, "FastBlast+- mounts forward"); + } + } + Assert.True(swept, $"the crosser's bearing never swept across the bow within {CrossingSeconds} s"); + // At seed 112 with no input the pass is at 3.6 s and 45 m; a seed or staging change that loses it moves these. + Assert.InRange(crossedAt, 3.0f, 4.2f); + Assert.InRange(crossedMetres, 30f, 60f); + } + + // Place with no velocity leaves the entity at rest: the unpiloted waiting Djinni and both Shakedown targets start with + // zero velocity, so their stated places are where they are. + [Fact] + public void PlacedWithoutVelocityStartsAtRest() + { + var (_, _, crossing, crossingFailures) = Launch(new Crossing(), Inputs(() => GalaxySeed)); + Assert.True(crossingFailures.Count == 0, string.Join("; ", crossingFailures)); + Assert.Equal(float2.zero, crossing.Entities[1].Velocity); + var (_, _, shakedown, shakedownFailures) = Launch(new DjinniShakedown(), Inputs(() => GalaxySeed)); + Assert.True(shakedownFailures.Count == 0, string.Join("; ", shakedownFailures)); + Assert.All(shakedown.Entities, entity => Assert.Equal(float2.zero, entity.Velocity)); + } + + private const int CrossingSeconds = 6; + private const float CrossingMetres = 150f; + + // Djinni Shakedown: the generated Djinni carries a gun on a Ballistic hardpoint (not a launcher); that mount bears on + // Ahead and not on Abeam, and both targets are neutral. + [Fact] + public void DjinniShakedownTargets() + { + var (_, _, staged, failures) = Launch(new DjinniShakedown(), Inputs(() => GalaxySeed)); + Assert.True(failures.Count == 0, string.Join("; ", failures)); + var player = staged.Player; + var barrels = player.Equipment.Where(item => item.Hardpoint?.Type == HardpointType.Ballistic + && item.Behaviors.OfType().Any(weapon => !(weapon.WeaponData is LauncherData))).ToList(); + Assert.NotEmpty(barrels); + + Assert.Equal(2, staged.Entities.Count); + var ahead = staged.Entities[0]; + var abeam = staged.Entities[1]; + var facing = player.Direction; + var perpendicular = new float2(facing.y, -facing.x); + Assert.Equal(400f, length(ahead.Position.xz), .01f); + Assert.Equal(400f, length(abeam.Position.xz), .01f); + Assert.Equal(1f, dot(normalize(ahead.Position.xz), facing), .001f); + Assert.Equal(1f, abs(dot(normalize(abeam.Position.xz), perpendicular)), .001f); + Assert.Equal(("Longinus", "Longinus"), (_items.GetData(ahead.Hull).Name, _items.GetData(abeam.Hull).Name)); + foreach (var barrel in barrels) + { + Assert.True(FireControl.InArc(barrel, ahead.Position - player.Position), $"{barrel.Data.Name} cannot bear on Ahead"); + Assert.False(FireControl.InArc(barrel, abeam.Position - player.Position), $"{barrel.Data.Name} bears on Abeam"); + } + Assert.False(player.IsHostileTo(ahead) || ahead.IsHostileTo(player) || player.IsHostileTo(abeam) || abeam.IsHostileTo(player), + "both targets are neutral"); + } +}