如何为 JavaFX 编写 KeyListener

Question

我想写一个小游戏，我可以使用 W、A、S, D 键.
我有一个 getPosX() 和 setPosX() 但我不知道如何写一个 KeyListener 这将例如如果我按 D.

计算 setPosX(getPosX()+1)

我需要做什么？

Answer 1

场景中添加了按键和释放处理程序，并更新应用程序中记录的移动状态变量。一个动画计时器挂接到 JavaFX 脉冲机制（默认情况下将被限制为每秒触发一个事件 60 次）——因此这是一种游戏“循环”。在计时器中，检查移动状态变量并将它们的增量动作应用于角色位置——这实际上是在屏幕上移动角色以响应按键。

import javafx.animation.AnimationTimer;
import javafx.application.Application;
import javafx.event.EventHandler;
import javafx.scene.*;
import javafx.scene.image.*;
import javafx.scene.input.KeyEvent;
import javafx.scene.paint.Color;
import javafx.stage.Stage;
 
/**
 * Hold down an arrow key to have your hero move around the screen.
 * Hold down the shift key to have the hero run.
 */
public class Runner extends Application {
 
    private static final double W = 600, H = 400;
 
    private static final String HERO_IMAGE_LOC =
            "http://icons.iconarchive.com/icons/raindropmemory/legendora/64/Hero-icon.png";
 
    private Image heroImage;
    private Node  hero;
 
    boolean running, goNorth, goSouth, goEast, goWest;
 
    @Override
    public void start(Stage stage) throws Exception {
        heroImage = new Image(HERO_IMAGE_LOC);
        hero = new ImageView(heroImage);
 
        Group dungeon = new Group(hero);
 
        moveHeroTo(W / 2, H / 2);
 
        Scene scene = new Scene(dungeon, W, H, Color.FORESTGREEN);
 
        scene.setOnKeyPressed(new EventHandler<KeyEvent>() {
            @Override
            public void handle(KeyEvent event) {
                switch (event.getCode()) {
                    case UP:    goNorth = true; break;
                    case DOWN:  goSouth = true; break;
                    case LEFT:  goWest  = true; break;
                    case RIGHT: goEast  = true; break;
                    case SHIFT: running = true; break;
                }
            }
        });
 
        scene.setOnKeyReleased(new EventHandler<KeyEvent>() {
            @Override
            public void handle(KeyEvent event) {
                switch (event.getCode()) {
                    case UP:    goNorth = false; break;
                    case DOWN:  goSouth = false; break;
                    case LEFT:  goWest  = false; break;
                    case RIGHT: goEast  = false; break;
                    case SHIFT: running = false; break;
                }
            }
        });
 
        stage.setScene(scene);
        stage.show();
 
        AnimationTimer timer = new AnimationTimer() {
            @Override
            public void handle(long now) {
                int dx = 0, dy = 0;
 
                if (goNorth) dy -= 1;
                if (goSouth) dy += 1;
                if (goEast)  dx += 1;
                if (goWest)  dx -= 1;
                if (running) { dx *= 3; dy *= 3; }
 
                moveHeroBy(dx, dy);
            }
        };
        timer.start();
    }
 
    private void moveHeroBy(int dx, int dy) {
        if (dx == 0 && dy == 0) return;
 
        final double cx = hero.getBoundsInLocal().getWidth()  / 2;
        final double cy = hero.getBoundsInLocal().getHeight() / 2;
 
        double x = cx + hero.getLayoutX() + dx;
        double y = cy + hero.getLayoutY() + dy;
 
        moveHeroTo(x, y);
    }
 
    private void moveHeroTo(double x, double y) {
        final double cx = hero.getBoundsInLocal().getWidth()  / 2;
        final double cy = hero.getBoundsInLocal().getHeight() / 2;
 
        if (x - cx >= 0 &&
            x + cx <= W &&
            y - cy >= 0 &&
            y + cy <= H) {
            hero.relocate(x - cx, y - cy);
        }
    }
 
    public static void main(String[] args) { launch(args); }
}

关于过滤器、处理程序和焦点

要接收按键事件，设置事件处理程序的对象必须是focus traversable。此示例直接在场景上设置处理程序，但如果您要在窗格而不是场景上设置处理程序，则需要焦点可遍历并具有焦点。

如果你想要一个全局拦截点来覆盖或拦截将通过内置事件处理程序路由的事件，这些事件处理程序将使用你想要的事件（例如按钮和文本字段），你可以有一个 event filter 在现场而不是处理程序。

为了更好地理解处理程序和过滤器之间的区别，请确保您按照 JavaFX event tutorial.

中的说明学习并理解了事件捕获和冒泡阶段。

通用输入处理程序

如果已提供的信息足以满足您的目的，请忽略此答案的其余部分。

虽然上述解决方案足以回答这个问题，但如果有兴趣，可以在这个演示 breakout 游戏中找到更复杂的输入处理程序（具有更通用和分离的输入和更新处理逻辑）：

Breakout input handler.

示例突围游戏中的示例通用输入处理程序：

class InputHandler implements EventHandler<KeyEvent> {
    final private Set<KeyCode> activeKeys = new HashSet<>();

    @Override
    public void handle(KeyEvent event) {
        if (KeyEvent.KEY_PRESSED.equals(event.getEventType())) {
            activeKeys.add(event.getCode());
        } else if (KeyEvent.KEY_RELEASED.equals(event.getEventType())) {
            activeKeys.remove(event.getCode());
        }
    }

    public Set<KeyCode> getActiveKeys() {
        return Collections.unmodifiableSet(activeKeys);
    }
}

虽然具有适当设置更改侦听器的 ObservableSet 可用于活动键集，但我使用了一个访问器，其中 returns 一组不可修改的键在快照时处于活动状态及时，因为这是我在这里感兴趣的，而不是实时观察活动键集的变化。

通用输入处理程序用法示例：

Scene gameScene = createGameScene();

// register the input handler to the game scene.
InputHandler inputHandler = new InputHandler();
gameScene.setOnKeyPressed(inputHandler);
gameScene.setOnKeyReleased(inputHandler);

gameLoop = createGameLoop();

// . . .

private AnimationTimer createGameLoop() {
    return new AnimationTimer() {
        public void handle(long now) {
            update(now, inputHandler.getActiveKeys());
            if (gameState.isGameOver()) {
                this.stop();
            }
        }
    };
}

public void update(long now, Set<KeyCode> activeKeys) {
    applyInputToPaddle(activeKeys);
    // . . . rest of logic to update game state and view.
}

// The paddle is sprite implementation with
// an in-built velocity setting that is used to
// update its position for each frame.
//
// on user input, The paddle velocity changes 
// to point in the correct predefined direction.
private void applyInputToPaddle(Set<KeyCode> activeKeys) {
    Point2D paddleVelocity = Point2D.ZERO;

    if (activeKeys.contains(KeyCode.LEFT)) {
        paddleVelocity = paddleVelocity.add(paddleLeftVelocity);
    }

    if (activeKeys.contains(KeyCode.RIGHT)) {
        paddleVelocity = paddleVelocity.add(paddleRightVelocity);
    }

    gameState.getPaddle().setVelocity(paddleVelocity);
}

Answer 2

Scene myScene = new Scene();

KeyCombination cntrlZ = new KeyCodeCombination(KeyCode.Z, KeyCodeCombination.CONTROL_DOWN);
myScene.setOnKeyPressed(new EventHandler<KeyEvent>(){
    @Override
    public void handle(KeyEvent event) {
        if(contrlZ.match(event)){
           //Do something
        }
    }
});

Answer 3

使用 JNativeHook： https://github.com/kwhat/jnativehook

<!-- https://mvnrepository.com/artifact/com.1stleg/jnativehook -->
<dependency>
  <groupId>com.1stleg</groupId>
  <artifactId>jnativehook</artifactId>
  <version>2.1.0</version>
</dependency>



    private void initKeyListener(Stage primaryStage){
    /* Note: JNativeHook does *NOT* operate on the event dispatching thread.
     * Because Swing components must be accessed on the event dispatching
     * thread, you *MUST* wrap access to Swing components using the
     * SwingUtilities.invokeLater() or EventQueue.invokeLater() methods.
     */
    try {
        GlobalScreen.registerNativeHook();
    } catch (NativeHookException e1) {
        // TODO Auto-generated catch block
        e1.printStackTrace();
    }
    GlobalScreen.addNativeKeyListener(new NativeKeyListener() {
        public void nativeKeyPressed(NativeKeyEvent e) {
            if ( (e.getModifiers() & NativeKeyEvent.CTRL_MASK) != 0
                    && (e.getModifiers() & NativeKeyEvent.ALT_MASK) != 0
                    && (e.getKeyCode() == NativeKeyEvent.VC_B)){
                logger.debug("key :Hide");
                primaryStage.hide();
            }
            if ( (e.getModifiers() & NativeKeyEvent.CTRL_MASK) != 0
                    && (e.getModifiers() & NativeKeyEvent.SHIFT_MASK) != 0
                    && (e.getModifiers() & NativeKeyEvent.ALT_MASK) != 0
                    && (e.getKeyCode() == NativeKeyEvent.VC_B)){
                logger.debug("key :Show");
                primaryStage.show();
            }
            //System.out.println("Key Pressed: " + NativeKeyEvent.getKeyText(e.getKeyCode()));
        }

        public void nativeKeyReleased(NativeKeyEvent e) {
            //System.out.println("Key Released: " + NativeKeyEvent.getKeyText(e.getKeyCode()));
        }

        public void nativeKeyTyped(NativeKeyEvent e) {
            //System.out.println("Key Typed: " + NativeKeyEvent.getKeyText(e.getKeyCode()));
        }
    });
    /*
    GlobalScreen.addNativeMouseListener(new NativeMouseListener() {
        @Override
        public void nativeMouseReleased(NativeMouseEvent arg0) {
            // TODO Auto-generated method stub
            System.out.println("MouseReleased()");
        }

        @Override
        public void nativeMousePressed(NativeMouseEvent arg0) {
            // TODO Auto-generated method stub
            System.out.println("MousePressed()");
        }

        @Override
        public void nativeMouseClicked(NativeMouseEvent arg0) {
            // TODO Auto-generated method stub
            System.out.println("MouseClicked()");
        }
    });
    */
}

如何为 JavaFX 编写 KeyListener

How to write a KeyListener for JavaFX

javafx

keylistener

actionlistener

java-8