Java Snake-按键响应时间慢

我做了一个蛇游戏（通过尝试遵循youtuber的代码），方向由WASD控制。然而，当我按下其中一个键时，什么也没发生。如果我按住它，它会改变方向，但会有一个巨大的延迟，可能超过一秒钟。我该如何解决这个问题？我已经查看了我的代码，并将其与我关注了好几次的youtube代码进行了比较，但似乎仍然看不出问题出在哪里。这是我第一次做游戏，所以我对这个很陌生

如果有帮助的话，这是我试图跟踪的视频

package应用程序；
导入javafx.animation.KeyFrame；
导入javafx.animation.Timeline；
导入javafx.scene.shape.Rectangle；
导入javafx.application.application；
导入javafx.collections.ObservableList；
导入javafx.scene.Group；
导入javafx.scene.Node；
导入javafx.scene.Parent；
导入javafx.scene.scene；
导入javafx.scene.layout.Pane；
导入javafx.scene.paint.Color；
导入javafx.stage.stage；//科特罗莱尔·蒂特尔、伊康、辛利盖、圣雷尔斯、奥格·德科拉斯乔纳
导入javafx.util.Duration；
公共类应用程序扩展应用程序{
公共枚举方向{
上、下、右、左；
}
公共静态最终整块大小=40；
公共静态最终内部应用程序W=20*块大小；
公共静态最终整数应用程序H=15*块大小；
公共智力得分=0；
公共int高分=0；
private Direction=Direction.RIGHT；//默认生成bevegelse:til høyre
私有布尔值=false；
private boolean running=false；//Applikasjonen khører
私有时间线=新时间线（）；
私家蛇；
私有父createContent（）{
窗格根=新窗格（）；
root.setPrefSize（APP_W，APP_H）；
组蛇体=新组（）；
snake=snakeBody.getChildren（）；
矩形食物=新矩形（块大小，块大小）；
食物。绒毛（颜色。红色）；
food.setTranslateX（（int）（Math.random（）*（APP_W-BLOCK_SIZE））/BLOCK_SIZE*BLOCK_SIZE）；
food.setTranslateY（（int）（Math.random（）*（APP_H-BLOCK_SIZE））/BLOCK_SIZE*BLOCK_SIZE）；
关键帧帧=新关键帧（持续时间。秒（0.5），事件->{
如果（！正在运行）
返回；
布尔值toRemove=snake.size（）>1；
Node tail=toRemove？snake.remove（snake.size（）-1）：snake.get（0）；
double tailX=tail.getTranslateX（）；
double tailY=tail.getTranslateY（）；
开关（方向）{
个案：
setTranslateX（snake.get（0.getTranslateX（））；
tail.setTranslateY（snake.get（0.getTranslateY（）-BLOCK_SIZE）；
打破
按大小写：
setTranslateX（snake.get（0.getTranslateX（））；
tail.setTranslateY（snake.get（0.getTranslateY（）+块大小）；
打破
案例权利：
setTranslateX（snake.get（0.getTranslateX（）+块大小）；
tail.setTranslateY（snake.get（0.getTranslateY（））；
打破
案例左：
setTranslateX（snake.get（0.getTranslateX（）-BLOCK_SIZE）；
tail.setTranslateY（snake.get（0.getTranslateY（））；
打破
}
移动=真；
如果（删除）
snake.add（0，tail）；
//Kollisjonsdesteksjon
//克拉斯杰一世塞尔夫酒店
for（节点rect:snake）{
if（rect！=tail&&tail.getTranslateX（）==rect.getTranslateX（）&&tail.getTranslateY（）==rect.getTranslateY（））{
重启游戏（）；
打破
}
}
//克拉斯杰一世康德
if（tail.getTranslateX（）<0 | | tail.getTranslateX（）>=APP|W | | tail.getTranslateY（）<0 | | tail.getTranslateY（）>=APP|H）{
重启游戏（）；
}
//腿垫
if（tail.getTranslateX（）==food.getTranslateX（）&&tail.getTranslateY（）==food.getTranslateY（））{
food.setTranslateX（（int）（Math.random（）*（APP_W-BLOCK_SIZE））/BLOCK_SIZE*BLOCK_SIZE）；
food.setTranslateY（（int）（Math.random（）*（APP_H-BLOCK_SIZE））/BLOCK_SIZE*BLOCK_SIZE）；
矩形rect=新矩形（块大小，块大小）；
直译setTranslateX（tailX）；
直译直译（tailY）；
snake.add（rect）；
}
});
timeline.getKeyFrames（）.add（frame）；
timeline.setCycleCount（timeline.unfinite）；
root.getChildren（）.addAll（食物、蛇身）；
返回根；
}
私有void restartGame（）{
停止游戏（）；
startGame（）；
}
私人游戏{
运行=错误；
timeline.stop（）；
snake.clear（）；
}
私有void startGame（）{
方向=direction.RIGHT；
矩形头=新矩形（块大小，块大小）；
添加（头）；
timeline.play（）；
运行=真；
}
@凌驾
public void start（final Stage primaryStage）引发异常{
//primaryStage.setTitle（“我的申请”）；
//setScene（新场景（fxmloader.load（App.class.getResource（“App.fxml”）））；
//primaryStage.show（）；
场景=新场景（createContent（））；
场景。按下设置键（事件->{
如果（！移动）
开关（event.getCode（））{
案例W：
如果（方向！=方向向下）
方向=向上的方向；
打破
案例S：
如果（方向！=向上方向）
方向=方向。向下；
打破
案例A：
如果（方向！=方向.右）
迪雷克
package app;


import javafx.animation.KeyFrame;
import javafx.animation.Timeline;
import javafx.scene.shape.Rectangle;
import javafx.application.Application;
import javafx.collections.ObservableList;
import javafx.scene.Group;
import javafx.scene.Node;
import javafx.scene.Parent;
import javafx.scene.Scene;
import javafx.scene.layout.Pane;
import javafx.scene.paint.Color;
import javafx.stage.Stage; // Kontrollerer tittel, ikon, synlighet, størrelse, og dekorasjoner
import javafx.util.Duration;



public class App extends Application {

    public enum Direction {
        UP, DOWN, RIGHT, LEFT;
    }

    public static final int BLOCK_SIZE = 40;
    public static final int APP_W = 20 * BLOCK_SIZE;
    public static final int APP_H = 15 * BLOCK_SIZE;

    public int score = 0;
    public int highScore = 0;

    private Direction direction = Direction.RIGHT; // Default spawn-bevegelse: til høyre
    private boolean moved = false; 
    private boolean running = false; // Applikasjonen kjører

    private Timeline timeline = new Timeline();
    private ObservableList<Node> snake;

    private Parent createContent() {

        Pane root = new Pane();
        root.setPrefSize(APP_W, APP_H);

        Group snakeBody = new Group();
        snake = snakeBody.getChildren();    

        Rectangle food = new Rectangle(BLOCK_SIZE, BLOCK_SIZE);
        food.setFill(Color.RED);
        food.setTranslateX((int)(Math.random() * (APP_W - BLOCK_SIZE)) / BLOCK_SIZE * BLOCK_SIZE);
        food.setTranslateY((int)(Math.random() * (APP_H - BLOCK_SIZE)) / BLOCK_SIZE * BLOCK_SIZE);

        KeyFrame frame = new KeyFrame(Duration.seconds(0.5), event -> {
            if (!running)
                return;
            boolean toRemove = snake.size() > 1;

            Node tail = toRemove ? snake.remove(snake.size()-1) : snake.get(0);

            double tailX = tail.getTranslateX();
            double tailY = tail.getTranslateY();

            switch (direction) {
                case UP: 
                    tail.setTranslateX(snake.get(0).getTranslateX());
                    tail.setTranslateY(snake.get(0).getTranslateY() - BLOCK_SIZE);
                    break;
                case DOWN: 
                    tail.setTranslateX(snake.get(0).getTranslateX());
                    tail.setTranslateY(snake.get(0).getTranslateY() + BLOCK_SIZE);
                    break;
                case RIGHT: 
                    tail.setTranslateX(snake.get(0).getTranslateX() + BLOCK_SIZE);
                    tail.setTranslateY(snake.get(0).getTranslateY());
                    break;
                case LEFT: 
                    tail.setTranslateX(snake.get(0).getTranslateX() - BLOCK_SIZE);
                    tail.setTranslateY(snake.get(0).getTranslateY());
                    break;
            }

            moved = true;

            if (toRemove)
                snake.add(0, tail);

            // Kollisjonsdeteksjon

            // Krasjer i seg selv
            for (Node rect : snake) {
                if (rect != tail && tail.getTranslateX() == rect.getTranslateX() && tail.getTranslateY() == rect.getTranslateY()) {
                    restartGame();
                    break;
                }
            }

            // Krasjer i kant
            if (tail.getTranslateX() < 0 || tail.getTranslateX() >= APP_W || tail.getTranslateY() < 0 || tail.getTranslateY() >= APP_H) {
                restartGame();
            }

            // Legg til mat
            if (tail.getTranslateX() == food.getTranslateX() && tail.getTranslateY() == food.getTranslateY()) {
                food.setTranslateX((int)(Math.random() * (APP_W - BLOCK_SIZE)) / BLOCK_SIZE * BLOCK_SIZE);
                food.setTranslateY((int)(Math.random() * (APP_H - BLOCK_SIZE)) / BLOCK_SIZE * BLOCK_SIZE);

                Rectangle rect = new Rectangle(BLOCK_SIZE, BLOCK_SIZE);
                rect.setTranslateX(tailX);
                rect.setTranslateY(tailY);
                snake.add(rect);
            }



        });

        timeline.getKeyFrames().add(frame);
        timeline.setCycleCount(Timeline.INDEFINITE);

        root.getChildren().addAll(food, snakeBody);

        return root;
    }

    private void restartGame() {
        stopGame();
        startGame();
    }

    private void stopGame() {
        running = false;
        timeline.stop();
        snake.clear();
    }

    private void startGame() {
        direction = Direction.RIGHT;
        Rectangle head = new Rectangle(BLOCK_SIZE, BLOCK_SIZE);
        snake.add(head);
        timeline.play();
        running = true;
    }





    @Override
    public void start(final Stage primaryStage) throws Exception {
//      primaryStage.setTitle("My Application");
//      primaryStage.setScene(new Scene(FXMLLoader.load(App.class.getResource("App.fxml"))));
//      primaryStage.show();    

        Scene scene = new Scene(createContent());
        scene.setOnKeyPressed(event -> {
            if (!moved)

            switch (event.getCode()) {
                case W:
                    if (direction != Direction.DOWN)
                        direction = Direction.UP;
                    break;

                case S:
                    if (direction != Direction.UP)
                        direction = Direction.DOWN;
                    break;
                case A:
                    if (direction != Direction.RIGHT)
                        direction = Direction.LEFT;
                    break;
                case D:
                    if (direction != Direction.LEFT)
                        direction = Direction.RIGHT;
                    break;
            default:
                break;

            }
            moved = false;
        });

        primaryStage.setTitle("Snake");
        primaryStage.setScene(scene);
        primaryStage.show();
        startGame();
    }

    public static void main(final String[] args) {
        App.launch(args); // Kaller init(), start() og så stop()
    }

}

if (!moved)
     return;

switch (event.getCode()) {
     .
     .
     .
}
moved = false;

scene.setOnKeyPressed(event -> {
    if (moved) {

        switch (event.getCode()) {
        case W:
            if (direction != Direction.DOWN)
                direction = Direction.UP;
            break;

        case S:
            if (direction != Direction.UP)
                direction = Direction.DOWN;
            break;
        case A:
            if (direction != Direction.RIGHT)
                direction = Direction.LEFT;
            break;
        case D:
            if (direction != Direction.LEFT)
                direction = Direction.RIGHT;
            break;
        default:
            break;

        }
    }
});

public enum Direction {
    UP(0, -1), RIGHT(1, 0), DOWN(0, 1), LEFT(-1, 0);

    private final int dx;
    private final int dy;

    private Direction(int dx, int dy) {
        this.dx = dx;
        this.dy = dy;
    }

    /**
     * Tests, if 2 directions are parallel (i.e. both either on the x or the y axis).<br>
     * Note: Depends on the order of the enum constants
     * @param other the direction to compare with
     * @return true, if the directions are parallel, false otherwise
     */
    public boolean isParallel(Direction other) {
        return ((ordinal() - other.ordinal()) & 1) == 0;
    }
}

...
double tailX = tail.getTranslateX();
double tailY = tail.getTranslateY();

Node head = snake.get(0);
tail.setTranslateX(head.getTranslateX() + BLOCK_SIZE * direction.dx);
tail.setTranslateY(head.getTranslateY() + BLOCK_SIZE * direction.dy);

moved = true;
...

final Map<KeyCode, Direction> keyMapping = new EnumMap<>(KeyCode.class);
keyMapping.put(KeyCode.W, Direction.UP);
keyMapping.put(KeyCode.S, Direction.DOWN);
keyMapping.put(KeyCode.A, Direction.LEFT);
keyMapping.put(KeyCode.D, Direction.RIGHT);

Scene scene = new Scene(createContent());
scene.setOnKeyPressed(event -> {
    if (moved) {
        Direction newDirection = keyMapping.get(event.getCode());
        if (newDirection != null && !direction.isParallel(newDirection)) {
            direction = newDirection;
        }
    }

});