Initialize Project Sacrifice backlog and source baseline

app/src/test/java/com/projectsacrifice/game/GameMathTest.java

@@ -0,0 +1,32 @@
+package com.projectsacrifice.game;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+public final class GameMathTest {
+    @Test
+    public void intersectionTreatsTouchingEdgesAsNonOverlap() {
+        assertFalse(GameMath.intersects(0, 0, 10, 10, 10, 0, 10, 10));
+        assertTrue(GameMath.intersects(0, 0, 10, 10, 9.9f, 0, 10, 10));
+    }
+
+    @Test
+    public void pingPongIsDeterministicAndBounded() {
+        assertEquals(0f, GameMath.pingPong(0f, 4f), 0.0001f);
+        assertEquals(1f, GameMath.pingPong(2f, 4f), 0.0001f);
+        assertEquals(0f, GameMath.pingPong(4f, 4f), 0.0001f);
+        for (int i = 0; i < 100; i++) {
+            float value = GameMath.pingPong(i * 0.13f, 3.7f);
+            assertTrue(value >= 0f && value <= 1f);
+        }
+    }
+
+    @Test
+    public void timeFormattingIsStable() {
+        assertEquals("00:00", GameMath.formatTime(999));
+        assertEquals("01:05", GameMath.formatTime(65_000));
+    }
+}

app/src/test/java/com/projectsacrifice/game/LevelCatalogTest.java

@@ -0,0 +1,105 @@
+package com.projectsacrifice.game;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import org.junit.Test;
+
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+public final class LevelCatalogTest {
+    @Test
+    public void verticalSliceContainsTenSequentialLevels() {
+        List<LevelDefinition> levels = LevelCatalog.all();
+        assertEquals(10, levels.size());
+        Set<String> titles = new HashSet<>();
+        for (int i = 0; i < levels.size(); i++) {
+            LevelDefinition level = levels.get(i);
+            assertEquals(i + 1, level.number);
+            assertTrue(titles.add(level.title));
+            assertFalse(level.hint.trim().isEmpty());
+        }
+    }
+
+    @Test
+    public void everyLevelHasValidSpawnGoalAndGeometry() {
+        for (LevelDefinition level : LevelCatalog.all()) {
+            assertTrue(level.worldWidth >= 1920f);
+            assertTrue(level.spawnX >= 0f && level.spawnX < level.worldWidth);
+            assertTrue(level.spawnY >= 0f && level.spawnY < 1080f);
+            assertTrue(level.goal.x >= 0f && level.goal.right() <= level.worldWidth);
+            assertTrue(level.goal.y >= 0f && level.goal.bottom() <= 1080f);
+            assertFalse(level.platforms.isEmpty());
+            assertTrue(level.targetDeaths >= 0);
+            assertTrue(level.targetSeconds > 0);
+        }
+    }
+
+    @Test
+    public void requestedMechanicsAreRepresentedInProgression() {
+        boolean spikes = false;
+        boolean saw = false;
+        boolean freezer = false;
+        boolean electricity = false;
+        boolean moving = false;
+        boolean pressure = false;
+        boolean toggle = false;
+        boolean timed = false;
+        boolean multiSignalDoor = false;
+
+        for (LevelDefinition level : LevelCatalog.all()) {
+            spikes |= level.containsMechanic(LevelDefinition.HazardType.SPIKES);
+            saw |= level.containsMechanic(LevelDefinition.HazardType.SAW);
+            freezer |= level.containsMechanic(LevelDefinition.HazardType.FREEZER);
+            electricity |= level.containsMechanic(LevelDefinition.HazardType.ELECTRIC);
+            moving |= level.hasMovingPlatform();
+            pressure |= level.containsMechanic(LevelDefinition.SwitchType.PRESSURE);
+            toggle |= level.containsMechanic(LevelDefinition.SwitchType.TOGGLE);
+            timed |= level.containsMechanic(LevelDefinition.SwitchType.TIMED);
+            for (LevelDefinition.Door door : level.doors) multiSignalDoor |= door.requiredSignals.size() > 1;
+        }
+
+        assertTrue(spikes);
+        assertTrue(saw);
+        assertTrue(freezer);
+        assertTrue(electricity);
+        assertTrue(moving);
+        assertTrue(pressure);
+        assertTrue(toggle);
+        assertTrue(timed);
+        assertTrue(multiSignalDoor);
+    }
+
+    @Test
+    public void masteryLevelCombinesAtLeastFourCoreMechanics() {
+        LevelDefinition finale = LevelCatalog.get(9);
+        int count = finale.hazards.size() + finale.switches.size();
+        assertTrue(finale.hasMovingPlatform());
+        assertTrue(count >= 5);
+        assertFalse(finale.doors.isEmpty());
+    }
+
+    @Test
+    public void everyDoorAndControlledPlatformHasADeclaredSignalSource() {
+        for (LevelDefinition level : LevelCatalog.all()) {
+            Set<String> sources = new HashSet<>();
+            for (LevelDefinition.Switch item : level.switches) sources.add(item.signalId);
+            for (LevelDefinition.Hazard hazard : level.hazards) {
+                if (hazard.relayId != null) sources.add(hazard.relayId);
+            }
+            for (LevelDefinition.Door door : level.doors) {
+                for (String required : door.requiredSignals) {
+                    assertTrue("Level " + level.number + " has missing signal " + required, sources.contains(required));
+                }
+            }
+            for (LevelDefinition.Platform platform : level.platforms) {
+                if (platform.controlId != null) {
+                    assertTrue("Level " + level.number + " has missing signal " + platform.controlId, sources.contains(platform.controlId));
+                }
+            }
+        }
+    }
+}