Добавить production-каталог опасностей

2026-08-19 05:30:56 +03:00
parent cc7f487cf7
commit dc2ebcbf8c
33 changed files with 1160 additions and 37 deletions
@@ -0,0 +1,64 @@
+package com.projectsacrifice.game;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+import static org.junit.Assert.assertTrue;
+
+import android.os.SystemClock;
+import android.view.MotionEvent;
+
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+import java.util.List;
+
+@RunWith(AndroidJUnit4.class)
+public final class LevelPaginationTest {
+    @Test
+    public void nextAndPreviousControlsExposeEveryAuthoredLevel() {
+        try (ActivityScenario<MainActivity> activity = ActivityScenario.launch(MainActivity.class)) {
+            activity.onActivity(current -> {
+                GameView view = current.gameViewForAutomation();
+                view.setLanguageForAutomation(GameLanguage.EN);
+                assertEquals(0, view.levelPageIndexForAutomation());
+                assertEquals(2, view.levelPageCountForAutomation());
+                assertTrue(view.visibleLocalizedTextForAutomation().contains("The Volunteer"));
+                assertFalse(view.visibleLocalizedTextForAutomation().contains("Steam Charge"));
+            });
+
+            tap(activity, 1_730f, 965f);
+
+            activity.onActivity(current -> {
+                GameView view = current.gameViewForAutomation();
+                List<String> visible = view.visibleLocalizedTextForAutomation();
+                assertEquals(1, view.levelPageIndexForAutomation());
+                assertTrue(visible.contains("Steam Charge"));
+                assertFalse(visible.contains("The Volunteer"));
+                assertTrue(visible.contains("Page 2 of 2"));
+            });
+
+            tap(activity, 190f, 965f);
+            activity.onActivity(current ->
+                    assertEquals(0, current.gameViewForAutomation().levelPageIndexForAutomation()));
+        }
+    }
+
+    private static void tap(ActivityScenario<MainActivity> activity, float canvasX, float canvasY) {
+        activity.onActivity(current -> {
+            GameView view = current.gameViewForAutomation();
+            float scale = Math.min(view.getWidth() / 1_920f, view.getHeight() / 1_080f);
+            float x = (view.getWidth() - 1_920f * scale) * 0.5f + canvasX * scale;
+            float y = (view.getHeight() - 1_080f * scale) * 0.5f + canvasY * scale;
+            long now = SystemClock.uptimeMillis();
+            MotionEvent down = MotionEvent.obtain(now, now, MotionEvent.ACTION_DOWN, x, y, 0);
+            view.dispatchTouchEvent(down);
+            down.recycle();
+            MotionEvent up = MotionEvent.obtain(now, now, MotionEvent.ACTION_UP, x, y, 0);
+            view.dispatchTouchEvent(up);
+            up.recycle();
+        });
+    }
+}
@@ -0,0 +1,94 @@
+package com.projectsacrifice.game;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertTrue;
+
+import android.app.Instrumentation;
+
+import androidx.test.core.app.ActivityScenario;
+import androidx.test.ext.junit.runners.AndroidJUnit4;
+import androidx.test.platform.app.InstrumentationRegistry;
+
+import org.junit.Test;
+import org.junit.runner.RunWith;
+
+@RunWith(AndroidJUnit4.class)
+public final class ProductionHazardPlaythroughTest {
+    private static final int CONSECUTIVE_RUNS = 3;
+
+    @Test public void crusherLevelCompletesThreeTimes() {
+        prove(ProductionHazardScenarios.levelEleven(), 35_000L, false);
+    }
+
+    @Test public void fireLevelCompletesThreeTimes() {
+        prove(ProductionHazardScenarios.levelTwelve(), 35_000L, false);
+    }
+
+    @Test public void projectileLevelCompletesThreeTimes() {
+        prove(ProductionHazardScenarios.levelThirteen(), 40_000L, false);
+    }
+
+    @Test public void explosionDeliversBodyAndOpensGateThreeTimes() {
+        prove(ProductionHazardScenarios.levelFourteen(), 45_000L, true);
+    }
+
+    private static void prove(LevelPlaytestBot.Scenario scenario, long budget,
+                              boolean requiresDoor) {
+        try (ActivityScenario<MainActivity> activity = ActivityScenario.launch(MainActivity.class)) {
+            AndroidDriver driver = AndroidDriver.from(activity);
+            for (int run = 1; run <= CONSECUTIVE_RUNS; run++) {
+                LevelPlaytestBot.Result result = new LevelPlaytestBot().run(driver, scenario, budget);
+                assertTrue("run=" + run + "; " + result.diagnostic(), result.completed());
+                assertEquals("run=" + run + "; teaching route uses exactly one volunteer",
+                        1, result.deaths());
+                assertEquals("run=" + run + "; sacrificed body remains in the level",
+                        1, result.corpseCount());
+                if (requiresDoor) {
+                    assertTrue("run=" + run + "; blast-delivered body must open the gate",
+                            result.doorOpened());
+                }
+            }
+        }
+    }
+
+    private static final class AndroidDriver implements LevelPlaytestBot.Driver {
+        private final Instrumentation instrumentation;
+        private final GameView gameView;
+
+        private AndroidDriver(Instrumentation instrumentation, GameView gameView) {
+            this.instrumentation = instrumentation;
+            this.gameView = gameView;
+        }
+
+        static AndroidDriver from(ActivityScenario<MainActivity> activity) {
+            GameView[] view = new GameView[1];
+            activity.onActivity(current -> view[0] = current.gameViewForAutomation());
+            return new AndroidDriver(InstrumentationRegistry.getInstrumentation(), view[0]);
+        }
+
+        @Override public void startLevel(int oneBasedLevelNumber) {
+            instrumentation.runOnMainSync(
+                    () -> gameView.startLevelForAutomation(oneBasedLevelNumber));
+        }
+
+        @Override public void setInput(boolean moveLeft, boolean moveRight, boolean jump) {
+            instrumentation.runOnMainSync(
+                    () -> gameView.setAutomationInput(moveLeft, moveRight, jump));
+        }
+
+        @Override public GameView.AutomationSnapshot snapshot() {
+            GameView.AutomationSnapshot[] snapshot = new GameView.AutomationSnapshot[1];
+            instrumentation.runOnMainSync(() -> snapshot[0] = gameView.automationSnapshot());
+            return snapshot[0];
+        }
+
+        @Override public void waitForNextDecision(long millis) {
+            try {
+                Thread.sleep(Math.max(32L, millis));
+            } catch (InterruptedException interrupted) {
+                Thread.currentThread().interrupt();
+                throw new AssertionError("Production-hazard bot interrupted", interrupted);
+            }
+        }
+    }
+}
@@ -0,0 +1,143 @@
+package com.projectsacrifice.game;
+
+/** Intended routes for the first four data-driven production hazards. */
+final class ProductionHazardScenarios {
+    private ProductionHazardScenarios() {}
+
+    static LevelPlaytestBot.Scenario levelEleven() {
+        return LevelPlaytestBot.Scenario.builder(11, "Level 11 - crusher rhythm")
+                .step("Sacrifice one volunteer to the press", 4_000L,
+                        LevelPlaytestBot.Input.right(),
+                        snapshot -> snapshot.deaths() == 1 && snapshot.corpseCount() == 1)
+                .step("Wait for respawn", 3_000L, LevelPlaytestBot.Input.none(),
+                        snapshot -> snapshot.playerAlive() && snapshot.playerX() < 250f)
+                .step("Approach the retained body", 2_000L, LevelPlaytestBot.Input.right(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                LevelPlaytestBot.groundedAliveAtOrBeyond(520f)))
+                .step("Observe the press close for a fresh cycle", 4_000L,
+                        LevelPlaytestBot.Input.none(),
+                        GameView.AutomationSnapshot::firstHazardActive)
+                .step("Observe the press resting", 4_000L, LevelPlaytestBot.Input.none(),
+                        snapshot -> !snapshot.firstHazardActive())
+                .step("Jump through the resting press", 2_500L,
+                        LevelPlaytestBot.Input.rightJump(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                snapshot -> snapshot.playerAlive()
+                                        && snapshot.playerX() >= 900f))
+                .step("Reach the relic", 6_000L, LevelPlaytestBot.Input.right(),
+                        GameView.AutomationSnapshot::completed)
+                .build();
+    }
+
+    static LevelPlaytestBot.Scenario levelTwelve() {
+        return LevelPlaytestBot.Scenario.builder(12, "Level 12 - blue fire")
+                .step("Sacrifice one volunteer to the flame", 4_000L,
+                        LevelPlaytestBot.Input.right(),
+                        snapshot -> snapshot.deaths() == 1 && snapshot.corpseCount() == 1)
+                .step("Wait for respawn", 3_000L, LevelPlaytestBot.Input.none(),
+                        snapshot -> snapshot.playerAlive() && snapshot.playerX() < 250f)
+                .step("Approach the blue flame", 2_000L, LevelPlaytestBot.Input.right(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                LevelPlaytestBot.groundedAliveAtOrBeyond(535f)))
+                .step("Take off before the flame", 1_000L,
+                        LevelPlaytestBot.Input.rightJump(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                snapshot -> snapshot.playerAlive()
+                                        && !snapshot.playerOnGround()
+                                        && snapshot.playerY() <= 700f))
+                .step("Clear the flame", 2_000L, LevelPlaytestBot.Input.right(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                snapshot -> snapshot.playerAlive()
+                                        && snapshot.playerX() >= 850f))
+                .step("Reach the relic", 6_000L, LevelPlaytestBot.Input.right(),
+                        GameView.AutomationSnapshot::completed)
+                .build();
+    }
+
+    static LevelPlaytestBot.Scenario levelThirteen() {
+        return LevelPlaytestBot.Scenario.builder(13, "Level 13 - clockwork projectile")
+                .step("Read the bolt by sacrificing once", 5_000L,
+                        LevelPlaytestBot.Input.right(),
+                        snapshot -> snapshot.deaths() == 1 && snapshot.corpseCount() == 1)
+                .step("Wait for respawn", 3_000L, LevelPlaytestBot.Input.none(),
+                        snapshot -> snapshot.playerAlive() && snapshot.playerX() < 250f)
+                .step("Approach the firing line", 2_000L, LevelPlaytestBot.Input.right(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                LevelPlaytestBot.groundedAliveAtOrBeyond(600f)))
+                .step("Wait for the jump window", 4_000L, LevelPlaytestBot.Input.none(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                snapshot -> snapshot.firstHazardX() >= 850f
+                                        && snapshot.firstHazardX() <= 930f))
+                .step("Jump through the bolt line", 1_500L,
+                        LevelPlaytestBot.Input.rightJump(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                snapshot -> snapshot.playerAlive()
+                                        && snapshot.playerY() <= 690f))
+                .step("Clear the firing line", 2_500L, LevelPlaytestBot.Input.right(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                snapshot -> snapshot.playerAlive()
+                                        && snapshot.playerX() >= 1_050f))
+                .step("Wait for the returning bolt", 4_000L, LevelPlaytestBot.Input.none(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                snapshot -> snapshot.firstHazardX() >= 1_350f
+                                        && snapshot.firstHazardX() <= 1_450f))
+                .step("Jump through the returning bolt", 1_500L,
+                        LevelPlaytestBot.Input.rightJump(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                snapshot -> snapshot.playerAlive()
+                                        && snapshot.playerY() <= 690f))
+                .step("Clear the second firing line", 2_000L,
+                        LevelPlaytestBot.Input.right(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                snapshot -> snapshot.playerAlive()
+                                        && snapshot.playerX() >= 1_600f))
+                .step("Reach the relic", 4_000L, LevelPlaytestBot.Input.right(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                GameView.AutomationSnapshot::completed))
+                .build();
+    }
+
+    static LevelPlaytestBot.Scenario levelFourteen() {
+        return LevelPlaytestBot.Scenario.builder(14, "Level 14 - explosion delivery")
+                .step("Give one volunteer to the blast", 4_000L,
+                        LevelPlaytestBot.Input.right(),
+                        snapshot -> snapshot.deaths() == 1 && snapshot.corpseCount() == 1)
+                .step("Observe the delivered body open the gate", 5_000L,
+                        LevelPlaytestBot.Input.none(),
+                        GameView.AutomationSnapshot::allDoorsOpen)
+                .step("Wait for respawn", 3_000L, LevelPlaytestBot.Input.none(),
+                        snapshot -> snapshot.playerAlive() && snapshot.playerX() < 250f)
+                .step("Approach the steam charge", 2_000L, LevelPlaytestBot.Input.right(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                LevelPlaytestBot.groundedAliveAtOrBeyond(390f)))
+                .step("Observe the charge rebuild", 4_000L,
+                        LevelPlaytestBot.Input.none(),
+                        GameView.AutomationSnapshot::firstHazardActive)
+                .step("Observe the safe blast rest", 4_000L,
+                        LevelPlaytestBot.Input.none(),
+                        snapshot -> !snapshot.firstHazardActive())
+                .step("Take off before the blast", 1_000L,
+                        LevelPlaytestBot.Input.rightJump(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                snapshot -> snapshot.playerAlive()
+                                        && !snapshot.playerOnGround()
+                                        && snapshot.playerY() <= 690f))
+                .step("Clear the blast", 2_000L, LevelPlaytestBot.Input.right(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                snapshot -> snapshot.playerAlive()
+                                        && snapshot.playerX() >= 820f))
+                .step("Approach the delivered body", 1_000L,
+                        LevelPlaytestBot.Input.right(),
+                        snapshot -> snapshot.playerAlive() && snapshot.playerX() >= 880f)
+                .step("Jump over the delivered body", 2_000L,
+                        LevelPlaytestBot.Input.rightJump(),
+                        LevelPlaytestBot.whileDeathsAtMost(1,
+                                snapshot -> snapshot.playerAlive()
+                                        && snapshot.playerX() >= 1_200f))
+                .step("Pass the opened gate", 4_000L, LevelPlaytestBot.Input.right(),
+                        snapshot -> snapshot.playerAlive() && snapshot.playerX() >= 1_550f)
+                .step("Reach the relic", 5_000L, LevelPlaytestBot.Input.right(),
+                        GameView.AutomationSnapshot::completed)
+                .build();
+    }
+}