Add platformer locomotion slice

tests/SideScrollerGame.Sim.Tests/SimulationSerializationTests.cs

@@ -1,6 +1,7 @@
 using System.Collections.Immutable;
 using SideScrollerGame.Sim.Definitions;
 using SideScrollerGame.Sim.Input;
+using SideScrollerGame.Sim.Math;
 
 namespace SideScrollerGame.Sim.Tests;
 
@@ -9,11 +10,11 @@ public sealed class SimulationSerializationTests
     [Fact]
     public void SaveStateLoadState_PreservesStateAndNextStepHash()
     {
-        var definition = SimulationTestFactory.CreateGameDefinition(triggers: ImmutableArray.Create(new TriggerDefinition("checkpoint_a", new(new(11, 21), new(12, 22)), "TriggerActivated")));
+        var definition = SimulationTestFactory.CreateGameDefinition(new(new(0, 0), new(50, 20)), triggers: ImmutableArray.Create(new TriggerDefinition("checkpoint_a", new(new(11, 17), new(12, 18)), "TriggerActivated")), players: ImmutableArray.Create(new PlayerDefinition(new(1), new(10, 20), 10, true, FixPoint16.One, FixPoint16.One, new(3), 1, 1)));
         var config = SimulationTestFactory.CreateConfig();
 
         Simulation original = new(definition, config, 17);
-        original.Step(SimulationTestFactory.CreateTick(1, new MoveAxisChanged(new(1), 1, 1)));
+        original.Step(SimulationTestFactory.CreateTick(1, new MoveAxisChanged(new(1), 1, 1), new ButtonChanged(new(1), InputButton.Jump, true)));
 
         var bytes = original.SaveState();
         var loaded = Simulation.LoadState(bytes, definition, config);
@@ -22,8 +23,10 @@ public sealed class SimulationSerializationTests
         Assert.Equal(original.CurrentSnapshot.StateHash, loaded.CurrentSnapshot.StateHash);
         Assert.Equal(original.CurrentState.GetRequiredPlayer(new(1)).Health, loaded.CurrentState.GetRequiredPlayer(new(1)).Health);
         Assert.Equal(original.CurrentState.ActivatedTriggerIds, loaded.CurrentState.ActivatedTriggerIds);
+        Assert.Equal(original.CurrentState.GetRequiredPlayer(new(1)).VerticalVelocity, loaded.CurrentState.GetRequiredPlayer(new(1)).VerticalVelocity);
+        Assert.Equal(original.CurrentState.GetRequiredPlayer(new(1)).IsGrounded, loaded.CurrentState.GetRequiredPlayer(new(1)).IsGrounded);
 
-        var nextBatch = SimulationTestFactory.CreateTick(2, new ButtonChanged(new(1), InputButton.FirePrimary, true));
+        var nextBatch = SimulationTestFactory.CreateTick(2, new MoveAxisChanged(new(1), 0, 0), new ButtonChanged(new(1), InputButton.FirePrimary, true));
         var originalHash = original.Step(nextBatch).StateHash;
         var loadedHash = loaded.Step(nextBatch).StateHash;
 

tests/SideScrollerGame.Sim.Tests/SimulationStateTests.cs

@@ -1,5 +1,6 @@
 using System.Collections.Immutable;
 using SideScrollerGame.Sim.Input;
+using SideScrollerGame.Sim.Math;
 using SideScrollerGame.Sim.Runtime;
 
 namespace SideScrollerGame.Sim.Tests;
@@ -9,25 +10,31 @@ public sealed class SimulationStateTests
     [Fact]
     public void PlayerState_CloneAndButtonReleasePreserveIndependentState()
     {
-        PlayerState player = new(new(1), new(3, 4), 1, 2, 5, 6, 7, 0, 9);
+        PlayerState player = new(new(1), new(3, 4), 1, 2, 5, 6, 7, 0, 9, FixPoint16.One, true, 3, 4);
         player.SetButton(InputButton.Dash, true);
         player.ApplyDamage(4);
+        player.BufferJump(6);
 
         var clone = player.Clone();
         player.SetButton(InputButton.Dash, false);
         player.SetPosition(new(8, 9));
+        player.SetVerticalVelocity(new(5));
 
         Assert.NotEqual(player.ButtonMask, clone.ButtonMask);
         Assert.Equal(7, clone.SelectedWeaponSlot);
         Assert.Equal(3, clone.Position.m_X.ToIntRound());
         Assert.Equal(4, clone.Position.m_Y.ToIntRound());
         Assert.Equal(5, clone.Health);
+        Assert.Equal(1, clone.VerticalVelocity.ToIntRound());
+        Assert.True(clone.IsGrounded);
+        Assert.Equal(3, clone.LastGroundedTick);
+        Assert.Equal(6, clone.BufferedJumpTick);
     }
 
     [Fact]
     public void SimulationState_CloneCreatesDeepCopy()
     {
-        SimulationState original = new(4, 9, 123UL, 456UL, ImmutableArray.Create(new PlayerState(new(1), new(1, 2), 3, 4, 5, 6, 7, 8, 9)), ImmutableHashSet<string>.Empty.Add("checkpoint_a"));
+        SimulationState original = new(4, 9, 123UL, 456UL, ImmutableArray.Create(new PlayerState(new(1), new(1, 2), 3, 4, 5, 6, 7, 8, 9, new(2), true, 4, -1)), ImmutableHashSet<string>.Empty.Add("checkpoint_a"));
         var clone = original.Clone();
 
         original.GetRequiredPlayer(new(1)).SetMoveAxis(9, 9);
@@ -38,6 +45,7 @@ public sealed class SimulationStateTests
         Assert.Equal((ulong)123, clone.RandomState);
         Assert.Equal((ulong)456, clone.LastRandomValue);
         Assert.Equal(3, clone.GetRequiredPlayer(new(1)).MoveAxisX);
+        Assert.Equal(2, clone.GetRequiredPlayer(new(1)).VerticalVelocity.ToIntRound());
         Assert.DoesNotContain("checkpoint_b", clone.ActivatedTriggerIds);
     }
 
@@ -66,4 +74,18 @@ public sealed class SimulationStateTests
         Assert.True(state.ActivateTrigger("checkpoint_a"));
         Assert.False(state.ActivateTrigger("checkpoint_a"));
     }
+
+    [Fact]
+    public void PlayerState_BufferedJumpExpiresOutsideWindow()
+    {
+        PlayerState player = new(new(1), new(0, 0), 0, 0, 0, 0, 0, 0, 10, FixPoint16.Zero, false, -1, -1);
+        player.BufferJump(3);
+
+        Assert.True(player.HasBufferedJump(4, 1));
+        Assert.False(player.HasBufferedJump(5, 1));
+
+        player.ConsumeBufferedJump();
+
+        Assert.False(player.HasBufferedJump(5, 5));
+    }
 }

tests/SideScrollerGame.Sim.Tests/SimulationStepTests.cs

@@ -1,6 +1,8 @@
 using System.Collections.Immutable;
+using System.Text;
 using SideScrollerGame.Sim.Definitions;
 using SideScrollerGame.Sim.Input;
+using SideScrollerGame.Sim.Math;
 
 namespace SideScrollerGame.Sim.Tests;
 
@@ -8,6 +10,13 @@ public sealed class SimulationStepTests
 {
     private sealed record UnsupportedAction : SimulationAction;
 
+    private static byte[] CreateStatePayload(int playerId, int positionX, int positionY, bool isGrounded, int lastGroundedTick = -1)
+    {
+        return Encoding.UTF8.GetBytes($$"""
+                                        {"Version":{{SimulationDefaults.StateFormatVersion}},"Tick":0,"Seed":7,"RandomState":7,"LastRandomValue":0,"Players":[{"PlayerId":{{playerId}},"PositionX":{{positionX * 65536}},"PositionY":{{positionY * 65536}},"MoveAxisX":0,"MoveAxisY":0,"AimAxisX":0,"AimAxisY":0,"SelectedWeaponSlot":0,"ButtonMask":0,"Health":10,"VerticalVelocity":0,"IsGrounded":{{isGrounded.ToString().ToLowerInvariant()}},"LastGroundedTick":{{lastGroundedTick}},"BufferedJumpTick":-1}],"ActivatedTriggerIds":[]}
+                                        """);
+    }
+
     [Fact]
     public void Step_AdvancesTickSnapshotsAndMovement()
     {
@@ -125,7 +134,7 @@ public sealed class SimulationStepTests
     [Fact]
     public void Constructor_RejectsDuplicatePlayers()
     {
-        GameDefinition definition = new(new(new(new(0, 0), new(100, 100)), ImmutableArray<HazardDefinition>.Empty, ImmutableArray<TriggerDefinition>.Empty), ImmutableArray.Create(new(new(1), new(0, 0), 10), new PlayerDefinition(new(1), new(2, 3), 10)));
+        GameDefinition definition = new(new(new(new(0, 0), new(100, 100)), ImmutableArray<HazardDefinition>.Empty, ImmutableArray<TriggerDefinition>.Empty, ImmutableArray<SolidPlatformDefinition>.Empty), ImmutableArray.Create(new(new(1), new(0, 0), 10), new PlayerDefinition(new(1), new(2, 3), 10)));
 
         var exception = Assert.Throws<InvalidOperationException>(() => new Simulation(definition, SimulationTestFactory.CreateConfig(), 11));
 
@@ -135,7 +144,7 @@ public sealed class SimulationStepTests
     [Fact]
     public void Constructor_RejectsSpawnOutsideBounds()
     {
-        GameDefinition definition = new(new(new(new(0, 0), new(5, 5)), ImmutableArray<HazardDefinition>.Empty, ImmutableArray<TriggerDefinition>.Empty), ImmutableArray.Create(new PlayerDefinition(new(1), new(10, 20), 10)));
+        GameDefinition definition = new(new(new(new(0, 0), new(5, 5)), ImmutableArray<HazardDefinition>.Empty, ImmutableArray<TriggerDefinition>.Empty, ImmutableArray<SolidPlatformDefinition>.Empty), ImmutableArray.Create(new PlayerDefinition(new(1), new(10, 20), 10)));
 
         var exception = Assert.Throws<InvalidOperationException>(() => new Simulation(definition, SimulationTestFactory.CreateConfig(), 11));
 
@@ -145,7 +154,7 @@ public sealed class SimulationStepTests
     [Fact]
     public void Constructor_RejectsNonPositiveHealth()
     {
-        GameDefinition definition = new(new(new(new(0, 0), new(100, 100)), ImmutableArray<HazardDefinition>.Empty, ImmutableArray<TriggerDefinition>.Empty), ImmutableArray.Create(new PlayerDefinition(new(1), new(1, 1), 0)));
+        GameDefinition definition = new(new(new(new(0, 0), new(100, 100)), ImmutableArray<HazardDefinition>.Empty, ImmutableArray<TriggerDefinition>.Empty, ImmutableArray<SolidPlatformDefinition>.Empty), ImmutableArray.Create(new PlayerDefinition(new(1), new(1, 1), 0)));
 
         var exception = Assert.Throws<InvalidOperationException>(() => new Simulation(definition, SimulationTestFactory.CreateConfig(), 11));
 
@@ -180,4 +189,229 @@ public sealed class SimulationStepTests
 
         Assert.Equal("gameDefinition", exception.ParamName);
     }
+
+    [Fact]
+    public void Step_PlatformerJumpUsesBufferedInputAndProducesVerticalVelocity()
+    {
+        var definition = SimulationTestFactory.CreateGameDefinition(new(new(0, 0), new(50, 20)), players: ImmutableArray.Create(SimulationTestFactory.CreatePlatformerPlayerDefinition(new(1), 10, 20)));
+        Simulation simulation = new(definition, SimulationTestFactory.CreateConfig(), 7);
+
+        var result = simulation.Step(SimulationTestFactory.CreateTick(1, new MoveAxisChanged(new(1), 1, 1), new ButtonChanged(new(1), InputButton.Jump, true)));
+
+        var player = simulation.CurrentState.GetRequiredPlayer(new(1));
+        Assert.False(player.IsGrounded);
+        Assert.Equal(12, player.Position.m_X.ToIntRound());
+        Assert.Equal(18, player.Position.m_Y.ToIntRound());
+        Assert.Equal(-2, player.VerticalVelocity.ToIntRound());
+        Assert.Contains(result.Events, static e => e.Kind == "PlayerJumped");
+        Assert.DoesNotContain(result.Events, static e => e.Kind == "PlayerClamped");
+    }
+
+    [Fact]
+    public void Step_PlatformerUsesCoyoteTimeAfterLeavingPlatform()
+    {
+        var platforms = ImmutableArray.Create(new SolidPlatformDefinition("ledge", new(new(10, 20), new(12, 22))));
+        var definition = SimulationTestFactory.CreateGameDefinition(new(new(0, 0), new(50, 40)), platforms: platforms, players: ImmutableArray.Create(SimulationTestFactory.CreatePlatformerPlayerDefinition(new(1), 10, 20)));
+        Simulation simulation = new(definition, SimulationTestFactory.CreateConfig(), 7);
+
+        var first = simulation.Step(SimulationTestFactory.CreateTick(1, new MoveAxisChanged(new(1), 2, 0)));
+        var second = simulation.Step(SimulationTestFactory.CreateTick(2, new MoveAxisChanged(new(1), 0, 0), new ButtonChanged(new(1), InputButton.Jump, true)));
+
+        var player = simulation.CurrentState.GetRequiredPlayer(new(1));
+        Assert.DoesNotContain(first.Events, static e => e.Kind == "PlayerJumped");
+        Assert.Contains(second.Events, static e => e.Kind == "PlayerJumped");
+        Assert.False(player.IsGrounded);
+        Assert.Equal(14, player.Position.m_X.ToIntRound());
+        Assert.Equal(18, player.Position.m_Y.ToIntRound());
+    }
+
+    [Fact]
+    public void Step_PlatformerConsumesJumpBufferOnLanding()
+    {
+        var definition = SimulationTestFactory.CreateGameDefinition(new(new(0, 0), new(50, 20)), players: ImmutableArray.Create(new PlayerDefinition(new(1), new(10, 18), 10, true, FixPoint16.One, new(2), new(3), 0, 1)));
+        Simulation simulation = new(definition, SimulationTestFactory.CreateConfig(), 7);
+
+        var result = simulation.Step(SimulationTestFactory.CreateTick(1, new ButtonChanged(new(1), InputButton.Jump, true)));
+
+        var player = simulation.CurrentState.GetRequiredPlayer(new(1));
+        Assert.False(player.IsGrounded);
+        Assert.Equal(17, player.Position.m_Y.ToIntRound());
+        Assert.Equal(-3, player.VerticalVelocity.ToIntRound());
+        Assert.Contains(result.Events, static e => e.Kind == "PlayerLanded");
+        Assert.Contains(result.Events, static e => e.Kind == "PlayerJumped");
+    }
+
+    [Fact]
+    public void Step_PlatformerClampsHorizontalMovementAtWorldEdge()
+    {
+        var definition = SimulationTestFactory.CreateGameDefinition(new(new(0, 0), new(11, 20)), players: ImmutableArray.Create(SimulationTestFactory.CreatePlatformerPlayerDefinition(new(1), 10, 20)));
+        Simulation simulation = new(definition, SimulationTestFactory.CreateConfig(), 7);
+
+        var result = simulation.Step(SimulationTestFactory.CreateTick(1, new MoveAxisChanged(new(1), 1, 0)));
+
+        Assert.Equal(11, simulation.CurrentState.GetRequiredPlayer(new(1)).Position.m_X.ToIntRound());
+        Assert.Contains(result.Events, static e => e.Kind == "PlayerClamped");
+    }
+
+    [Fact]
+    public void Step_PlatformerClampsJumpAtWorldCeiling()
+    {
+        var definition = SimulationTestFactory.CreateGameDefinition(new(new(0, 0), new(20, 2)), players: ImmutableArray.Create(new PlayerDefinition(new(1), new(10, 2), 10, true, FixPoint16.Zero, FixPoint16.Zero, new(4), 0, 1)));
+        Simulation simulation = new(definition, SimulationTestFactory.CreateConfig(), 7);
+
+        var result = simulation.Step(SimulationTestFactory.CreateTick(1, new ButtonChanged(new(1), InputButton.Jump, true)));
+
+        var player = simulation.CurrentState.GetRequiredPlayer(new(1));
+        Assert.Equal(0, player.Position.m_Y.ToIntRound());
+        Assert.Equal(0, player.VerticalVelocity.ToIntRound());
+        Assert.Contains(result.Events, static e => e.Kind == "PlayerClamped");
+    }
+
+    [Fact]
+    public void Step_PlatformerLandsOnHighestCrossedPlatform()
+    {
+        var platforms = ImmutableArray.Create(new("lower", new(new(8, 20), new(12, 22))), new SolidPlatformDefinition("upper", new(new(8, 15), new(12, 17))));
+        var definition = SimulationTestFactory.CreateGameDefinition(new(new(0, 0), new(50, 40)), platforms: platforms, players: ImmutableArray.Create(new PlayerDefinition(new(1), new(10, 10), 10, true, FixPoint16.Zero, new(12), new(3), 1, 1)));
+        Simulation simulation = new(definition, SimulationTestFactory.CreateConfig(), 7);
+
+        var result = simulation.Step(SimulationTestFactory.CreateTick(1));
+
+        var player = simulation.CurrentState.GetRequiredPlayer(new(1));
+        Assert.Equal(15, player.Position.m_Y.ToIntRound());
+        Assert.True(player.IsGrounded);
+        Assert.Contains(result.Events, static e => e.Kind == "PlayerLanded");
+    }
+
+    [Fact]
+    public void Step_PlatformerIgnoresPlatformWhenStillAboveTop()
+    {
+        var platforms = ImmutableArray.Create(new SolidPlatformDefinition("ledge", new(new(8, 15), new(12, 17))));
+        var definition = SimulationTestFactory.CreateGameDefinition(new(new(0, 0), new(50, 40)), platforms: platforms, players: ImmutableArray.Create(new PlayerDefinition(new(1), new(10, 10), 10, true, FixPoint16.Zero, FixPoint16.Zero, new(3), 1, 1)));
+        Simulation simulation = new(definition, SimulationTestFactory.CreateConfig(), 7);
+
+        simulation.Step(SimulationTestFactory.CreateTick(1));
+
+        Assert.Equal(10, simulation.CurrentState.GetRequiredPlayer(new(1)).Position.m_Y.ToIntRound());
+    }
+
+    [Fact]
+    public void Step_PlatformerIgnoresPlatformWhenAlreadyBelowTop()
+    {
+        var platforms = ImmutableArray.Create(new SolidPlatformDefinition("ledge", new(new(8, 15), new(12, 17))));
+        var definition = SimulationTestFactory.CreateGameDefinition(new(new(0, 0), new(50, 40)), platforms: platforms, players: ImmutableArray.Create(new PlayerDefinition(new(1), new(10, 20), 10, true, FixPoint16.Zero, FixPoint16.Zero, new(3), 1, 1)));
+        Simulation simulation = new(definition, SimulationTestFactory.CreateConfig(), 7);
+
+        simulation.Step(SimulationTestFactory.CreateTick(1));
+
+        Assert.Equal(20, simulation.CurrentState.GetRequiredPlayer(new(1)).Position.m_Y.ToIntRound());
+    }
+
+    [Fact]
+    public void Step_PlatformerIgnoresPlatformWhenFallingOutsideRightEdge()
+    {
+        var platforms = ImmutableArray.Create(new SolidPlatformDefinition("ledge", new(new(8, 15), new(12, 17))));
+        var definition = SimulationTestFactory.CreateGameDefinition(new(new(0, 0), new(50, 40)), platforms: platforms, players: ImmutableArray.Create(new PlayerDefinition(new(1), new(14, 10), 10, true, FixPoint16.Zero, new(12), new(3), 1, 1)));
+        Simulation simulation = new(definition, SimulationTestFactory.CreateConfig(), 7);
+
+        simulation.Step(SimulationTestFactory.CreateTick(1));
+
+        Assert.Equal(22, simulation.CurrentState.GetRequiredPlayer(new(1)).Position.m_Y.ToIntRound());
+    }
+
+    [Fact]
+    public void Step_PlatformerIgnoresPlatformWhenFallingOutsideLeftEdge()
+    {
+        var platforms = ImmutableArray.Create(new SolidPlatformDefinition("ledge", new(new(8, 15), new(12, 17))));
+        var definition = SimulationTestFactory.CreateGameDefinition(new(new(0, 0), new(50, 40)), platforms: platforms, players: ImmutableArray.Create(new PlayerDefinition(new(1), new(6, 10), 10, true, FixPoint16.Zero, new(12), new(3), 1, 1)));
+        Simulation simulation = new(definition, SimulationTestFactory.CreateConfig(), 7);
+
+        simulation.Step(SimulationTestFactory.CreateTick(1));
+
+        Assert.Equal(22, simulation.CurrentState.GetRequiredPlayer(new(1)).Position.m_Y.ToIntRound());
+    }
+
+    [Fact]
+    public void Step_LoadedPlatformerStateCanRegainGroundedFlagFromSupport()
+    {
+        var definition = SimulationTestFactory.CreateGameDefinition(new(new(0, 0), new(20, 20)), players: ImmutableArray.Create(SimulationTestFactory.CreatePlatformerPlayerDefinition(new(1), 10, 20)));
+        var simulation = Simulation.LoadState(CreateStatePayload(1, 10, 20, false), definition, SimulationTestFactory.CreateConfig());
+
+        simulation.Step(SimulationTestFactory.CreateTick(1));
+
+        Assert.True(simulation.CurrentState.GetRequiredPlayer(new(1)).IsGrounded);
+    }
+
+    [Fact]
+    public void Step_LoadedStateBelowFloorClampsBackIntoSupport()
+    {
+        var definition = SimulationTestFactory.CreateGameDefinition(new(new(0, 0), new(20, 20)), players: ImmutableArray.Create(SimulationTestFactory.CreatePlatformerPlayerDefinition(new(1), 10, 20)));
+        var simulation = Simulation.LoadState(CreateStatePayload(1, 10, 25, false), definition, SimulationTestFactory.CreateConfig());
+
+        simulation.Step(SimulationTestFactory.CreateTick(1));
+
+        var player = simulation.CurrentState.GetRequiredPlayer(new(1));
+        Assert.Equal(20, player.Position.m_Y.ToIntRound());
+        Assert.False(player.IsGrounded);
+    }
+
+    [Fact]
+    public void Step_LoadedStateRejectsPlayersMissingFromDefinition()
+    {
+        var definition = SimulationTestFactory.CreateGameDefinition(players: ImmutableArray.Create(SimulationTestFactory.CreatePlatformerPlayerDefinition(new(1), 10, 20)));
+        var simulation = Simulation.LoadState(CreateStatePayload(99, 10, 20, true, 0), definition, SimulationTestFactory.CreateConfig());
+
+        var exception = Assert.Throws<InvalidOperationException>(() => simulation.Step(SimulationTestFactory.CreateTick(1)));
+
+        Assert.Contains("Unknown player id 99", exception.Message);
+    }
+
+    [Fact]
+    public void Constructor_RejectsNegativeJumpBufferTicks()
+    {
+        GameDefinition definition = new(new(new(new(0, 0), new(100, 100)), ImmutableArray<HazardDefinition>.Empty, ImmutableArray<TriggerDefinition>.Empty, ImmutableArray<SolidPlatformDefinition>.Empty), ImmutableArray.Create(new PlayerDefinition(new(1), new(1, 1), 10, true, FixPoint16.One, FixPoint16.One, new(3), 1, -1)));
+
+        var exception = Assert.Throws<InvalidOperationException>(() => new Simulation(definition, SimulationTestFactory.CreateConfig(), 11));
+
+        Assert.Contains("jump buffer ticks", exception.Message);
+    }
+
+    [Fact]
+    public void Constructor_RejectsNegativeMoveSpeed()
+    {
+        GameDefinition definition = new(new(new(new(0, 0), new(100, 100)), ImmutableArray<HazardDefinition>.Empty, ImmutableArray<TriggerDefinition>.Empty, ImmutableArray<SolidPlatformDefinition>.Empty), ImmutableArray.Create(new PlayerDefinition(new(1), new(1, 1), 10, true, -FixPoint16.One, FixPoint16.One, new(3), 1, 1)));
+
+        var exception = Assert.Throws<InvalidOperationException>(() => new Simulation(definition, SimulationTestFactory.CreateConfig(), 11));
+
+        Assert.Contains("move speed", exception.Message);
+    }
+
+    [Fact]
+    public void Constructor_RejectsNegativeGravity()
+    {
+        GameDefinition definition = new(new(new(new(0, 0), new(100, 100)), ImmutableArray<HazardDefinition>.Empty, ImmutableArray<TriggerDefinition>.Empty, ImmutableArray<SolidPlatformDefinition>.Empty), ImmutableArray.Create(new PlayerDefinition(new(1), new(1, 1), 10, true, FixPoint16.One, -FixPoint16.One, new(3), 1, 1)));
+
+        var exception = Assert.Throws<InvalidOperationException>(() => new Simulation(definition, SimulationTestFactory.CreateConfig(), 11));
+
+        Assert.Contains("gravity", exception.Message);
+    }
+
+    [Fact]
+    public void Constructor_RejectsNegativeJumpVelocity()
+    {
+        GameDefinition definition = new(new(new(new(0, 0), new(100, 100)), ImmutableArray<HazardDefinition>.Empty, ImmutableArray<TriggerDefinition>.Empty, ImmutableArray<SolidPlatformDefinition>.Empty), ImmutableArray.Create(new PlayerDefinition(new(1), new(1, 1), 10, true, FixPoint16.One, FixPoint16.One, -FixPoint16.One, 1, 1)));
+
+        var exception = Assert.Throws<InvalidOperationException>(() => new Simulation(definition, SimulationTestFactory.CreateConfig(), 11));
+
+        Assert.Contains("jump velocity", exception.Message);
+    }
+
+    [Fact]
+    public void Constructor_RejectsNegativeCoyoteTicks()
+    {
+        GameDefinition definition = new(new(new(new(0, 0), new(100, 100)), ImmutableArray<HazardDefinition>.Empty, ImmutableArray<TriggerDefinition>.Empty, ImmutableArray<SolidPlatformDefinition>.Empty), ImmutableArray.Create(new PlayerDefinition(new(1), new(1, 1), 10, true, FixPoint16.One, FixPoint16.One, new(3), -1, 1)));
+
+        var exception = Assert.Throws<InvalidOperationException>(() => new Simulation(definition, SimulationTestFactory.CreateConfig(), 11));
+
+        Assert.Contains("coyote ticks", exception.Message);
+    }
 }

tests/SideScrollerGame.Sim.Tests/SimulationTestFactory.cs

@@ -1,15 +1,21 @@
 using System.Collections.Immutable;
 using SideScrollerGame.Sim.Definitions;
 using SideScrollerGame.Sim.Input;
+using SideScrollerGame.Sim.Math;
 using SideScrollerGame.Sim.Verification;
 
 namespace SideScrollerGame.Sim.Tests;
 
 internal static class SimulationTestFactory
 {
-    public static GameDefinition CreateGameDefinition(AxisAlignedBounds? worldBounds = null, ImmutableArray<HazardDefinition> hazards = default, ImmutableArray<TriggerDefinition> triggers = default)
+    public static GameDefinition CreateGameDefinition(AxisAlignedBounds? worldBounds = null, ImmutableArray<HazardDefinition> hazards = default, ImmutableArray<TriggerDefinition> triggers = default, ImmutableArray<SolidPlatformDefinition> platforms = default, ImmutableArray<PlayerDefinition> players = default)
     {
-        return new(new(worldBounds ?? new(new(0, 0), new(100, 100)), hazards, triggers), ImmutableArray.Create(new PlayerDefinition(new(1), new(10, 20), 10)));
+        return new(new(worldBounds ?? new(new(0, 0), new(100, 100)), hazards, triggers, platforms), players.IsDefault ? ImmutableArray.Create(new PlayerDefinition(new(1), new(10, 20), 10)) : players);
+    }
+
+    public static PlayerDefinition CreatePlatformerPlayerDefinition(PlayerId playerId, int spawnX, int spawnY)
+    {
+        return new(playerId, new(spawnX, spawnY), 10, true, new(2), FixPoint16.One, new(3), 1, 1);
     }
 
     public static SimulationConfig CreateConfig(VerificationMode verificationMode = VerificationMode.None)