当键在Javafx中持有时，如何限制键输入？

Question

我在写一个地牢风格的游戏，地牢基本上是一个网格窗格。我想让玩家每0.5秒移动一格，如果他保持控制键。但我不知道如何做到这一点。我读过JavaFX：如何检测钥匙是否被按下。但这个问题与我的问题并没有特别的关系（除了我可以追踪发生了多少关键事件，或许可以在此基础上做更多）。所以我跟随这篇文章并尝试使用线程。sleep（）解决了我的问题，但事实证明玩家只是停了几秒钟，然后突然移动了几格。

有人知道怎么解决吗？

@FXML
public void handleKeyPress(KeyEvent event) {

    switch (event.getCode()) {
    case UP:
        System.out.println("Up");
        player.moveUp();
        break;
    case DOWN:
        System.out.println("Down");
        player.moveDown();
        break;
    case LEFT:
        System.out.println("Left");
        player.moveLeft();
        break;
    case RIGHT:
        System.out.println("Right");
        player.moveRight();
        break;
    default:
        break;
    }
}

Answer 1

基本上，你必须记录你最后一次允许移动的时间，并且只有在经过指定的时间后才能再次移动。以下是概念证明：

import javafx.application.Application;
import javafx.scene.Group;
import javafx.scene.Scene;
import javafx.scene.input.KeyEvent;
import javafx.scene.paint.Color;
import javafx.scene.shape.Rectangle;
import javafx.stage.Stage;

public class Main extends Application {

    private static final long THRESHOLD = 500_000_000L; // 500 ms

    private long lastMoveNanos;
    private Rectangle rect;

    @Override
    public void start(Stage primaryStage) {
        rect = new Rectangle(25, 25, Color.DODGERBLUE);
        rect.setStroke(Color.BLACK);
        rect.setStrokeWidth(1);

        var root = new Group(rect);
        root.setOnKeyPressed(this::handleKeyPressed);

        var scene = new Scene(root, 600, 400);
        rect.setX(scene.getWidth() / 2 - rect.getWidth() / 2);
        rect.setY(scene.getHeight() / 2 - rect.getHeight() / 2);

        primaryStage.setScene(scene);
        primaryStage.setResizable(false);
        primaryStage.show();

        root.requestFocus();
    }

    private void handleKeyPressed(KeyEvent event) {
        if (event.getCode().isArrowKey()) {
            event.consume();

            long now = System.nanoTime();
            if (lastMoveNanos <= 0L || now - lastMoveNanos >= THRESHOLD) {
                switch (event.getCode()) {
                    case UP:
                        rect.setY(rect.getY() - rect.getHeight());
                        break;
                    case DOWN:
                        rect.setY(rect.getY() + rect.getHeight());
                        break;
                    case LEFT:
                        rect.setX(rect.getX() - rect.getWidth());
                        break;
                    case RIGHT:
                        rect.setX(rect.getX() + rect.getWidth());
                        break;
                    default:
                        throw new AssertionError();
                }
                lastMoveNanos = now;
            }
        }
    }

}

上面以每500毫秒移动1次的最大速度移动矩形，移动量等于其宽度/高度（以模拟“网格”）。如果位置变化应该是连续的，则可以使用动画进行移动（例如，设置了byX和byY属性的translation）。使用动画时，如果持续时间与所需的调节时间一样长，则可以使用动画本身来跟踪下一步的允许时间。

更可靠的示例可能使用AnimationTimer，并跟踪所有已按下但尚未释放的移动键（例如，在释放“当前”键时拾取最后一个仍按下的键，如果有）。下面是另一个概念证明：

import java.util.ArrayDeque;
import java.util.Deque;
import javafx.animation.AnimationTimer;
import javafx.scene.input.KeyCode;
import javafx.scene.shape.Rectangle;

class MoveAnimationTimer extends AnimationTimer {

    private static final long THRESHOLD = 500_000_000L; // 500 ms

    private final Rectangle node;

    private final Deque<KeyCode> keyStack = new ArrayDeque<>(4);
    private long then;

    MoveAnimationTimer(Rectangle node) {
        this.node = node;
    }

    void pushKeyIfAbsent(KeyCode code) {
        if (code.isArrowKey() && !keyStack.contains(code)) {
            keyStack.push(code);
            start();
        }
    }

    void removeKey(KeyCode code) {
        if (code.isArrowKey()) {
            keyStack.remove(code);
            if (keyStack.isEmpty()) {
                stop();
            }
        }
    }

    @Override
    public void handle(long now) {
        if (then <= 0L || now - then >= THRESHOLD) {
            switch (keyStack.getFirst()) {
                case UP:
                    node.setY(node.getY() - node.getHeight());
                    break;
                case DOWN:
                    node.setY(node.getY() + node.getHeight());
                    break;
                case LEFT:
                    node.setX(node.getX() - node.getWidth());
                    break;
                case RIGHT:
                    node.setX(node.getX() + node.getWidth());
                    break;
                default:
                    throw new AssertionError();
            }
            then = now;
        }
    }

}