Добавить первую волну мира Physics

app/src/androidTest/java/com/projectsacrifice/game/LevelPaginationTest.java

@@ -24,7 +24,7 @@ public final class LevelPaginationTest {
                 GameView view = current.gameViewForAutomation();
                 view.setLanguageForAutomation(GameLanguage.EN);
                 assertEquals(0, view.levelPageIndexForAutomation());
-                assertEquals(3, view.levelPageCountForAutomation());
+                assertEquals(4, view.levelPageCountForAutomation());
                 assertTrue(view.visibleLocalizedTextForAutomation().contains("The Volunteer"));
                 assertFalse(view.visibleLocalizedTextForAutomation().contains("Steam Charge"));
             });
@@ -43,7 +43,7 @@ public final class LevelPaginationTest {
                 assertTrue(visible.contains("Covered Path"));
                 assertFalse(visible.contains("Held Open"));
                 assertFalse(visible.contains("The Volunteer"));
-                assertTrue(visible.contains("Page 2 of 3"));
+                assertTrue(visible.contains("Page 2 of 4"));
             });
 
             tap(activity, 1_730f, 965f);
@@ -62,9 +62,25 @@ public final class LevelPaginationTest {
                 assertTrue(visible.contains("Minimum Cost"));
                 assertTrue(visible.contains("Foundation Relay"));
                 assertFalse(visible.contains("Covered Path"));
-                assertTrue(visible.contains("Page 3 of 3"));
+                assertTrue(visible.contains("Page 3 of 4"));
             });
 
+            tap(activity, 1_730f, 965f);
+            activity.onActivity(current -> {
+                GameView view = current.gameViewForAutomation();
+                List<String> visible = view.visibleLocalizedTextForAutomation();
+                assertEquals(3, view.levelPageIndexForAutomation());
+                assertTrue(visible.contains("Weight Class"));
+                assertTrue(visible.contains("Stack Order"));
+                assertTrue(visible.contains("Launch Window"));
+                assertTrue(visible.contains("Press Cycle"));
+                assertFalse(visible.contains("Foundation Relay"));
+                assertTrue(visible.contains("Page 4 of 4"));
+            });
+
+            tap(activity, 190f, 965f);
+            activity.onActivity(current ->
+                    assertEquals(2, current.gameViewForAutomation().levelPageIndexForAutomation()));
             tap(activity, 190f, 965f);
             activity.onActivity(current ->
                     assertEquals(1, current.gameViewForAutomation().levelPageIndexForAutomation()));

app/src/androidTest/java/com/projectsacrifice/game/PhysicsWaveOnePlaythroughTest.java

@@ -0,0 +1,111 @@
+package com.projectsacrifice.game;
+
+import static org.junit.Assert.assertEquals;
+import static org.junit.Assert.assertFalse;
+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 PhysicsWaveOnePlaythroughTest {
+    @Test public void weightClassOpensFromObjectMassThreeTimes() {
+        try (ActivityScenario<MainActivity> activity = ActivityScenario.launch(MainActivity.class)) {
+            Driver driver = Driver.from(activity);
+            for (int run = 1; run <= 3; run++) {
+                assertAccepted(run, new LevelPlaytestBot().run(
+                        driver, PhysicsWaveOneScenarios.levelThirtyOne(), 55_000L),
+                        driver, 0, 0);
+            }
+            driver.restart();
+            GameView.AutomationSnapshot restarted = driver.snapshot();
+            assertEquals(31, restarted.levelNumber());
+            assertEquals(650f, restarted.firstPhysicalObjectX(), 0f);
+            assertEquals(780f, restarted.firstPhysicalObjectY(), 0f);
+            assertEquals(0, restarted.deaths());
+            assertEquals(0, restarted.corpseCount());
+            assertFalse(restarted.allDoorsOpen());
+            assertFalse(restarted.collectibleFound());
+            assertFalse(restarted.inputActive());
+        }
+    }
+
+    @Test public void stackOrderClimbsSupportedObjectsThreeTimes() {
+        runThree(PhysicsWaveOneScenarios.levelThirtyTwo(), 0, 0);
+    }
+
+    @Test public void launchWindowUsesOneSawVolunteerAndLiftThreeTimes() {
+        runThree(PhysicsWaveOneScenarios.levelThirtyThree(), 1, 1);
+    }
+
+    @Test public void pressCycleLeavesOneCrushedBodyThreeTimes() {
+        runThree(PhysicsWaveOneScenarios.levelThirtyFour(), 1, 1);
+    }
+
+    private static void runThree(LevelPlaytestBot.Scenario scenario,
+                                 int expectedDeaths, int expectedCorpses) {
+        try (ActivityScenario<MainActivity> activity = ActivityScenario.launch(MainActivity.class)) {
+            Driver driver = Driver.from(activity);
+            for (int run = 1; run <= 3; run++) {
+                LevelPlaytestBot.Result result = new LevelPlaytestBot().run(driver, scenario, 55_000L);
+                assertAccepted(run, result, driver, expectedDeaths, expectedCorpses);
+            }
+        }
+    }
+
+    private static void assertAccepted(int run, LevelPlaytestBot.Result result, Driver driver,
+                                       int expectedDeaths, int expectedCorpses) {
+        assertTrue("run=" + run + "; " + result.diagnostic(), result.completed());
+        assertEquals("run=" + run, expectedDeaths, result.deaths());
+        assertEquals("run=" + run, expectedCorpses, result.corpseCount());
+        assertTrue("run=" + run + "; collectible", driver.snapshot().collectibleFound());
+    }
+
+    private static final class Driver implements LevelPlaytestBot.Driver {
+        private final Instrumentation instrumentation;
+        private final GameView view;
+
+        private Driver(Instrumentation instrumentation, GameView view) {
+            this.instrumentation = instrumentation;
+            this.view = view;
+        }
+
+        static Driver from(ActivityScenario<MainActivity> activity) {
+            GameView[] target = new GameView[1];
+            activity.onActivity(current -> target[0] = current.gameViewForAutomation());
+            return new Driver(InstrumentationRegistry.getInstrumentation(), target[0]);
+        }
+
+        @Override public void startLevel(int oneBasedLevelNumber) {
+            instrumentation.runOnMainSync(() -> {
+                view.enableDeterministicAutomationClock();
+                view.startLevelForAutomation(oneBasedLevelNumber);
+            });
+        }
+
+        @Override public void setInput(boolean left, boolean right, boolean jump) {
+            instrumentation.runOnMainSync(() -> view.setAutomationInput(left, right, jump));
+        }
+
+        @Override public GameView.AutomationSnapshot snapshot() {
+            GameView.AutomationSnapshot[] value = new GameView.AutomationSnapshot[1];
+            instrumentation.runOnMainSync(() -> value[0] = view.automationSnapshot());
+            return value[0];
+        }
+
+        @Override public void waitForNextDecision(long millis) {
+            instrumentation.runOnMainSync(() ->
+                    view.advanceDeterministicAutomation(Math.max(16L, millis)));
+        }
+
+        void restart() {
+            instrumentation.runOnMainSync(view::restartLevelForAutomation);
+        }
+    }
+}