深入理解JavaFX Timeline：解决多速率KeyFrame同步问题

package TickSystem;

import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.event.ActionEvent;
import javafx.scene.shape.Rectangle;
import javafx.util.Duration;
import java.util.ArrayList;
import java.util.List;
import javafx.animation.Animation; // 导入 Animation 类

public class TickSystem {
    private Rectangle r;
    public int curFrame = 0; // 用于绘制的帧计数
    public int tick = 0;     // 用于更新的逻辑计数

    // 定义三个独立的Timeline，分别用于更新、绘制和FPS计算
    private final Timeline updateLoop;
    private final Timeline drawLoop;
    private final Timeline fpsLoop;

    public int fps; // 实际测量的FPS
    private int lastFrames = 0; // 上一秒的帧计数

    public TickSystem(Rectangle r){
        this.r = r;

        // 定义更新任务的KeyFrame和Timeline (60次/秒)
        Duration updateTime = Duration.millis(1000.0 / 60);
        KeyFrame kfU = new KeyFrame(updateTime, "tickKeyUpdate", this::handleUpdate);
        this.updateLoop = new Timeline(kfU); // 直接在构造Timeline时添加KeyFrame
        this.updateLoop.setCycleCount(Animation.INDEFINITE); // 无限循环

        // 定义绘制任务的KeyFrame和Timeline (120次/秒)
        Duration drawTime = Duration.millis(1000.0 / 120);
        KeyFrame kfD = new KeyFrame(drawTime, "tickKeyDraw", this::handleDraw);
        this.drawLoop = new Timeline(kfD);
        this.drawLoop.setCycleCount(Animation.INDEFINITE);

        // 定义FPS计算任务的KeyFrame和Timeline (1次/秒)
        KeyFrame kfFPS = new KeyFrame(Duration.seconds(1), "tickKeyFPS", this::handleFPS);
        this.fpsLoop = new Timeline(kfFPS);
        this.fpsLoop.setCycleCount(Animation.INDEFINITE);
    }

    /**
     * 更简洁的构造函数，利用辅助方法创建Timeline
     */
    public TickSystem(Rectangle r, boolean succinct) {
        this.r = r;
        // 使用列表管理Timelines，方便统一操作
        List<Timeline> timelines = new ArrayList<>();
        timelines.add(createTimeline(60, this::handleUpdate)); // 更新逻辑，60Hz
        timelines.add(createTimeline(120, this::handleDraw)); // 绘制逻辑，120Hz
        timelines.add(createTimeline(1, this::handleFPS));   // FPS计算，1Hz

        // 将这些Timeline赋值给成员变量，以便后续控制
        this.updateLoop = timelines.get(0);
        this.drawLoop = timelines.get(1);
        this.fpsLoop = timelines.get(2);
    }

    /**
     * 辅助方法：创建并配置一个Timeline
     * @param frequency 每秒触发次数
     * @param handler   事件处理器
     * @return 配置好的Timeline实例
     */
    private Timeline createTimeline(int frequency, javafx.event.EventHandler<ActionEvent> handler) {
        Timeline timeline = new Timeline(); // 注意：这里Timeline构造函数不再接受频率参数
        timeline.getKeyFrames().add(new KeyFrame(Duration.millis(1000.0 / frequency), handler));
        timeline.setCycleCount(Animation.INDEFINITE);
        return timeline;
    }

    public void start(){
        this.updateLoop.play();
        this.drawLoop.play();
        this.fpsLoop.play();
    }

    public void pause(){
        this.updateLoop.pause();
        this.drawLoop.pause();
        this.fpsLoop.pause();
    }

    public void stop(){
        this.updateLoop.stop();
        this.drawLoop.stop();
        this.fpsLoop.stop();
    }

    public void handleUpdate(ActionEvent ae) { // 用于更新逻辑
        this.tick++;
        // System.out.println("Update tick: " + this.tick); // 调试用
    }

    public void handleDraw(ActionEvent ae){ // 用于绘制逻辑
        this.curFrame++;
        this.r.setWidth(curFrame); // 每次调用增加矩形宽度
        // System.out.println("Draw frame: " + this.curFrame); // 调试用
    }

    public void handleFPS(ActionEvent ae) { // 用于FPS计数
        this.fps = this.curFrame - this.lastFrames;
        this.lastFrames = this.curFrame;
        System.out.println("Current FPS: " + this.fps); // 打印每秒绘制的帧数
    }
}

import javafx.animation.AnimationTimer;
import javafx.scene.shape.Rectangle;

public class GameLoopTimer extends AnimationTimer {
    private Rectangle r;
    private long lastUpdateTime = 0;
    private long lastFpsTime = 0;
    private int frameCount = 0;
    private int logicTick = 0;

    private static final double UPDATE_INTERVAL_NS = 1_000_000_000.0 / 60.0; // 60 updates per second
    private static final double DRAW_INTERVAL_NS = 1_000_000_000.0 / 120.0; // 120 draws per second (conceptual, as handle is ~60Hz)

    private double updateAccumulator = 0;
    private double drawAccumulator = 0;

    public GameLoopTimer(Rectangle r) {
        this.r = r;
    }

    @Override
    public void handle(long now) {
        if (lastUpdateTime == 0) {
            lastUpdateTime = now;
            lastFpsTime = now;
            return;
        }

        double deltaTimeNs = now - lastUpdateTime;
        lastUpdateTime = now;

        // 逻辑更新 (例如，每秒60次)
        updateAccumulator += deltaTimeNs;
        while (updateAccumulator >= UPDATE_INTERVAL_NS) {
            logicTick++;
            // System.out.println("Logic Update: " + logicTick);
            // 这里放置需要60Hz更新的逻辑
            updateAccumulator -= UPDATE_INTERVAL_NS;
        }

        // 绘制逻辑 (AnimationTimer本身大约60Hz，所以直接在这里更新绘制状态)
        // 如果需要120Hz的视觉更新，AnimationTimer无法直接达到，
        // 但可以在每次handle调用时更新属性，JavaFX会尽可能快地渲染。
        // 对于游戏，通常是每帧（handle调用一次）进行一次渲染。
        frameCount++;
        r.setWidth(r.getWidth() + 1); // 每次handle调用时增加宽度，模拟绘制
        // System.out.println("Draw Frame: " + frameCount);

        // FPS计算 (每秒一次)
        if (now - lastFpsTime >= 1_000_000_000L) { // 1秒
            System.out.println("Actual FPS (handle calls): " + frameCount);
            frameCount = 0;
            lastFpsTime = now;
        }
    }

    public void startLoop() {
        super.start();
    }

    public void stopLoop() {
        super.stop();
    }
}