CollectCircles 13 - התקדמות בזמן שהיישום סגור

package com.example.collectcircles;

public final class ProductionRates {

    private static final double BASE_SPAWN_RATE = 0.20;
    private static final double SPAWN_RATE_PER_PUSHER =
            Pusher.CIRCLES_PER_SECOND * 1.10;

    /** Prevents creating objects from this utility class. */
    private ProductionRates() {
    }

    /**
     * Calculates how many circles the game can create per second.
     *
     * @param pusherCount number of owned Pushers
     * @return circle spawn rate per second
     */
    public static double spawnRate(int pusherCount) {
        int safeCount = Math.max(0, pusherCount);
        return Math.max(BASE_SPAWN_RATE, safeCount * SPAWN_RATE_PER_PUSHER);
    }

    /**
     * Calculates how many circles all Pushers can collect per second.
     *
     * @param pusherCount number of owned Pushers
     * @return combined Pusher collection rate per second
     */
    public static double pusherRate(int pusherCount) {
        return Math.max(0, pusherCount) * Pusher.CIRCLES_PER_SECOND;
    }

    /**
     * Returns the slower of the spawn and collection rates.
     *
     * @param pusherCount number of owned Pushers
     * @return effective offline collection rate per second
     */
    public static double offlineRate(int pusherCount) {
        return Math.min(spawnRate(pusherCount), pusherRate(pusherCount));
    }
}

package com.example.collectcircles;

public final class OfflineProgressCalculator {

    /** Prevents creating objects from this utility class. */
    private OfflineProgressCalculator() {
    }

    /**
     * Calculates whole circles and the remaining fraction for an offline period.
     *
     * @param elapsedMillis elapsed wall-clock time, in milliseconds
     * @param pusherCount number of owned Pushers
     * @param previousFraction unfinished progress from the previous calculation
     * @return calculated whole circles and the fraction to keep
     */
    public static Result calculate(long elapsedMillis, int pusherCount,
                                   double previousFraction) {
        long safeElapsedMillis = Math.max(0, elapsedMillis);
        double safeFraction = Math.max(0, Math.min(previousFraction, 0.999999));
        double produced = safeFraction
                + safeElapsedMillis / 1000.0
                * ProductionRates.offlineRate(pusherCount);

        if (produced >= Long.MAX_VALUE) {
            return new Result(Long.MAX_VALUE, 0);
        }

        long wholeCircles = (long) Math.floor(produced);
        return new Result(wholeCircles, produced - wholeCircles);
    }

    public static final class Result {
        private final long wholeCircles;
        private final double fraction;

        /**
         * Creates an immutable calculation result.
         *
         * @param wholeCircles number of complete circles produced
         * @param fraction unfinished part of the next circle
         */
        private Result(long wholeCircles, double fraction) {
            this.wholeCircles = wholeCircles;
            this.fraction = fraction;
        }

        /** @return number of complete circles produced */
        public long getWholeCircles() {
            return wholeCircles;
        }

        /** @return unfinished part of the next circle */
        public double getFraction() {
            return fraction;
        }
    }
}

private static final String LAST_PROGRESS_UPDATE_KEY = "last_progress_update";
private static final String FRACTIONAL_PROGRESS_KEY = "fractional_progress";

private long lastProgressUpdateMillis;
private double fractionalProgress;

lastProgressUpdateMillis = preferences.getLong(
        LAST_PROGRESS_UPDATE_KEY,
        System.currentTimeMillis()
);
fractionalProgress = Double.longBitsToDouble(
        preferences.getLong(
                FRACTIONAL_PROGRESS_KEY,
                Double.doubleToRawLongBits(0)
        )
);

/**
 * Applies progress earned since the last saved wall-clock timestamp.
 *
 * @param nowMillis current wall-clock time, in milliseconds
 * @return number of whole circles added to the progress totals
 */
public long settleOfflineProgress(long nowMillis) {
    long elapsedMillis = Math.max(0, nowMillis - lastProgressUpdateMillis);
    lastProgressUpdateMillis = nowMillis;

    long collectedCircles = 0;
    if (autonomousMode && pusherCount > 0) {
        OfflineProgressCalculator.Result result =
                OfflineProgressCalculator.calculate(
                        elapsedMillis,
                        pusherCount,
                        fractionalProgress
                );
        collectedCircles = result.getWholeCircles();
        fractionalProgress = result.getFraction();
        circlesBalance = addWithSaturation(circlesBalance, collectedCircles);
        lifetimeCircles = addWithSaturation(lifetimeCircles, collectedCircles);
    }

    preferences.edit()
            .putLong(CIRCLES_BALANCE_KEY, circlesBalance)
            .putLong(LIFETIME_CIRCLES_KEY, lifetimeCircles)
            .putLong(LAST_PROGRESS_UPDATE_KEY, lastProgressUpdateMillis)
            .putLong(
                    FRACTIONAL_PROGRESS_KEY,
                    Double.doubleToRawLongBits(fractionalProgress)
            )
            .apply();
    return collectedCircles;
}

/**
 * Saves the moment from which the next offline period will be measured.
 *
 * @param nowMillis current wall-clock time, in milliseconds
 */
public void markBackgroundStarted(long nowMillis) {
    lastProgressUpdateMillis = nowMillis;
    preferences.edit()
            .putLong(LAST_PROGRESS_UPDATE_KEY, nowMillis)
            .apply();
}

private boolean enteredBackground;

/**
 * Shows a message when at least one whole offline circle was collected.
 *
 * @param collectedCircles number of whole circles collected offline
 */
private void showOfflineProgress(long collectedCircles) {
    if (collectedCircles <= 0) {
        return;
    }
    Toast.makeText(
            this,
            getString(R.string.offline_progress_message, collectedCircles),
            Toast.LENGTH_LONG
    ).show();
}

/** Rebuilds the autonomous board after the View has been measured. */
private void startFreshAutonomousBoard() {
    binding.gameBoard.post(() -> {
        if (gameProgress.isAutonomousMode()) {
            binding.gameBoard.startAutonomousGame(gameProgress.getPusherCount());
        }
    });
}

gameProgress.markBackgroundStarted(System.currentTimeMillis());
enteredBackground = true;

/** Verifies rate limiting, whole-circle output, and saved fractions. */
@Test
public void offlineProgressUsesTheSlowerRateAndKeepsFractions() {
    OfflineProgressCalculator.Result onePusher =
            OfflineProgressCalculator.calculate(12_000, 1, 0);
    assertEquals(2, onePusher.getWholeCircles());
    assertEquals(0.4, onePusher.getFraction(), 0.0001);

    OfflineProgressCalculator.Result twoPushers =
            OfflineProgressCalculator.calculate(10_000, 2, 0);
    assertEquals(4, twoPushers.getWholeCircles());

    OfflineProgressCalculator.Result noPushers =
            OfflineProgressCalculator.calculate(60_000, 0, 0);
    assertEquals(0, noPushers.getWholeCircles());
}