CollectCircles 9 - Autonomous mode

// Key used to persist the selected game mode in SharedPreferences.
private static final String AUTONOMOUS_MODE_KEY = "autonomous_mode";

// Cached mode used by the current screen.
private boolean autonomousMode;

autonomousMode = preferences.getBoolean(AUTONOMOUS_MODE_KEY, false);

/**
 * Returns the game mode currently selected by the player.
 */
public boolean isAutonomousMode() {
    return autonomousMode;
}

/**
 * Updates the selected mode and saves it for the next app launch.
 */
public void setAutonomousMode(boolean autonomousMode) {
    this.autonomousMode = autonomousMode;
    preferences.edit()
            .putBoolean(AUTONOMOUS_MODE_KEY, autonomousMode)
            .apply();
}

/**
 * Adds non-overlapping circles until the requested amount is reached.
 */
private void createCircles(int requestedCount, float boardWidth,
                           float boardHeight, int circleColor) {
    float circleRadius = target.getRadius() / 2f;

    while (circles.size() < requestedCount) {
        // Keep the existing loop body unchanged.
    }
}

/**
 * Updates circle spawning in Auto mode using elapsed time and the board limit.
 *
 * @param elapsedSeconds The time elapsed since the previous update, in seconds
 * @param boardWidth The width of the game board in pixels
 * @param boardHeight The height of the game board in pixels
 * @param circleColor The color of the new circles
 */
public void update(double elapsedSeconds, float boardWidth,
                   float boardHeight, int circleColor) {
    if (!autonomous) {
        return;
    }

    spawnProgress += elapsedSeconds * AUTONOMOUS_SPAWN_RATE;
    while (spawnProgress >= 1.0 && circles.size() < MAX_CIRCLE_COUNT) {
        createCircles(circles.size() + 1, boardWidth, boardHeight, circleColor);
        spawnProgress -= 1.0;
    }

    if (circles.size() == MAX_CIRCLE_COUNT) {
        spawnProgress = Math.min(spawnProgress, 1.0);
    }
}

/**
 * Returns the number of circles currently on the board.
 */
int getCircleCount() {
    return circles.size();
}

import android.os.SystemClock;

// True while the Auto frame callback should keep scheduling itself.
private boolean autonomousRunning;
// Timestamp of the previous frame, used to measure real elapsed time.
private long previousFrameMillis;

// Repeats once per display frame while Auto mode is running.
private final Runnable autonomousFrame = new Runnable() {
    /**
     * Advances the model by one frame and requests the next drawing pass.
     */
    @Override
    public void run() {
        if (!autonomousRunning || game == null) {
            return;
        }

        long nowMillis = SystemClock.elapsedRealtime();
        double elapsedSeconds = (nowMillis - previousFrameMillis) / 1000.0;
        previousFrameMillis = nowMillis;

        game.update(elapsedSeconds, getWidth(), getHeight(), color(R.color.circle_green));
        invalidate();
        postOnAnimation(this);
    }
};

/**
 * Builds either game mode with the same board measurements and colors.
 */
private Game createGame(float targetRadius, boolean autonomous) {
    return new Game(
            getWidth(),
            getHeight(),
            targetRadius,
            color(R.color.target_red),
            color(R.color.target_cross),
            dp(2f),
            color(R.color.circle_green),
            autonomous
    );
}

/**
 * Creates a fresh Auto game and starts its frame loop.
 */
public void startAutonomousGame() {
    if (getWidth() == 0 || getHeight() == 0) {
        return;
    }

    float targetRadius = calculateTargetRadius();
    game = createGame(targetRadius, true);
    resumeAutonomousGame();
    invalidate();
}

/**
 * Resumes frame updates without replacing the current game.
 */
public void resumeAutonomousGame() {
    if (game == null || autonomousRunning) {
        return;
    }
    autonomousRunning = true;
    previousFrameMillis = SystemClock.elapsedRealtime();
    postOnAnimation(autonomousFrame);
}

/**
 * Pauses frame updates while preserving the current game.
 */
public void pauseAutonomousGame() {
    stopAutonomousFrames();
}

/**
 * Stops all updates and removes the current game from the board.
 */
public void clearGame() {
    stopAutonomousFrames();
    game = null;
    invalidate();
}

/**
 * Cancels the scheduled callback so only one Auto loop can exist.
 */
private void stopAutonomousFrames() {
    autonomousRunning = false;
    removeCallbacks(autonomousFrame);
}

/**
 * Calculates the target size shared by timed and Auto games.
 */
private float calculateTargetRadius() {
    return Math.min(
            dp(TARGET_RADIUS_DP),
            Math.min(getWidth(), getHeight()) / 5f
    );
}

// Restore the saved switch position before attaching its listener.
binding.autonomousSwitch.setChecked(gameProgress.isAutonomousMode());
// Build the screen that matches the restored mode.
showSelectedGameMode();

// Persist mode changes and immediately rebuild the game screen.
binding.autonomousSwitch.setOnCheckedChangeListener((button, enabled) -> {
    gameProgress.setAutonomousMode(enabled);
    showSelectedGameMode();
});

/**
 * Stops the previous mode and configures the selected game mode.
 */
private void showSelectedGameMode() {
    // Removes every queued execution of this exact Runnable from the View's message queue.
    // This stops future timer updates but does not delete or disable timerUpdate,
    // so the same Runnable can be started again later with timerUpdate.run().
    binding.elapsedTimeText.removeCallbacks(timerUpdate);
    gameRunning = false;

    if (gameProgress.isAutonomousMode()) {
        binding.startButton.setEnabled(false);
        binding.elapsedTimeText.setText(R.string.autonomous_time);
        // Wait until GameBoardView has valid width and height measurements.
        binding.gameBoard.post(() -> {
            if (gameProgress.isAutonomousMode()) {
                binding.gameBoard.startAutonomousGame();
            }
        });
    } else {
        binding.startButton.setEnabled(true);
        binding.elapsedTimeText.setText(R.string.elapsed_time_initial);
        binding.gameBoard.clearGame();
    }
}

/**
 * Stops both update loops while the Activity is not visible.
 */
@Override
protected void onStop() {
    binding.elapsedTimeText.removeCallbacks(timerUpdate);
    binding.gameBoard.pauseAutonomousGame();
    super.onStop();
}

import static org.junit.Assert.assertEquals;

/**
 * Verifies the Auto spawn rate and the maximum on-screen circle count.
 */
@Test
public void autonomousGameSpawnsSlowlyAndStopsAtTheScreenCap() {
    Game game = new Game(1000, 1000, 100,
            0, 0, 1, 0, true);

    assertEquals(3, game.getCircleCount());

    game.update(5.1, 1000, 1000, 0);
    assertEquals(4, game.getCircleCount());

    game.update(1000, 1000, 1000, 0);
    assertEquals(Game.MAX_CIRCLE_COUNT, game.getCircleCount());
}

/**
 * Verifies that elapsed time does not add circles to a timed game.
 */
@Test
public void timedGameDoesNotSpawnMoreCircles() {
    Game game = new Game(1000, 1000, 100,
            0, 0, 1, 0, false);

    game.update(1000, 1000, 1000, 0);

    assertEquals(5, game.getCircleCount());
}