如何在我的 Java 代码中进行更流畅的移动

Question

我试图让我的动作更顺畅。当我按下向上键时它会上升，然后当我按下左键时它会停止然后向左转。我想做到，所以当我按右时，它会立即做到，没有延迟。我怎么能用我的代码

                
        import java.awt.event.*;
        import javax.swing.*;
        import java.awt.*;
        import java.awt.Image;
        import javax.swing.*;
        
        
        class MyFrame extends JFrame implements KeyListener {
            JLabel label;
            
            MyFrame(){ 
             this.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
             addKeyListener(this);
             ImageIcon imageIcon = new ImageIcon("C:\\Users\\jacob\\Downloads\\player.png");
             
             Image image = imageIcon.getImage();
             Image newimg = image.getScaledInstance(150, 150,  java.awt.Image.SCALE_SMOOTH);
             imageIcon = new ImageIcon(newimg);
             label = new JLabel(imageIcon);
             this.add(label);
             this.setSize(500, 500);
             this.setVisible(true);
         }
            @Override
            public void keyTyped(KeyEvent e) {
                // TODO Auto-generated method stub
                
            }
            @Override
            public void keyPressed(KeyEvent e) {
                if (e.getKeyCode() == KeyEvent.VK_UP)
                    label.setLocation(label.getX(), label.getY()-10);
                else if (e.getKeyCode() == KeyEvent.VK_DOWN)
                    label.setLocation(label.getX(), label.getY()+10);
                else if (e.getKeyCode() == KeyEvent.VK_LEFT) 
                    label.setLocation(label.getX()-10, label.getY());
                else if (e.getKeyCode() == KeyEvent.VK_RIGHT) 
                    label.setLocation(label.getX()+10, label.getY());
                
            }
            @Override
            public void keyReleased(KeyEvent e) {
                // TODO Auto-generated method stub
                
            }
        }

Answer 1

这里的主要问题是不同的操作系统具有不同的按键重复功能时间（重复按键传递的频率和加速程度）。

解决这个问题的方法是维护当前键是否关闭的状态，并在某些计时器线程中，如果状态为真，则执行操作。

例如，（在非常粗糙的 Java 中，我认为如果不修复就无法编译）你想要这样的东西

// mark that the key is down
public void keyPressed(KeyEvent e) {
    keyboardState[e.getKeyCode()] = true;
}

// mark that the key has been released
public void keyReleased(KeyEvent e) {
    keyboardState[e.getKeyCode()] = false;
}

// this function should be called at some repeatable interval, fast enough where it looks "smooth"
public void calledAtFixedInterval(int delta) {
    // we can query definitively if the key is currently down or up, rather than waiting on some event to be delivered at an arbitrary interval
    if (keyboardState[KeyEvent.VK_LEFT] == true) {
        // your logic here
    }
}

这种架构大致是大多数游戏引擎的工作方式——它们将使用事件驱动架构来处理用户输入，但只需维护一个巨大的地图，说明当前哪些键已关闭——这样就可以轻松快速地查询是否有键在渲染循环中被按下。

Answer 2

我的猜测是可能会产生velocityX 和velocityY。 而且，如果你想要流畅的动作。你需要一个 tick 方法。

Java游戏开发的基本tick方法：

public synchronized void start() {
    thread = new Thread(this);
    thread.start();
    running = true;
}

public synchronized void stop() {
    try {
        thread.join();
    }catch(Exception e){
        e.printStackTrace();
    }
    }

public void run() {
    long lastTime = System.nanoTime();
    double ns =1000000000 / 60.0;
    double delta = 0;
    long timer = System.currentTimeMillis();
    int ticks = 0;
    int frames = 0;
    while(running) {
        long now = System.nanoTime();
        delta += (now - lastTime) / ns;
        lastTime = now;
        while(delta >= 1) {
            tick();
            ticks++;
            delta--;
        }
        if(running) {
            render();
            frames++;
        }
        
        if(System.currentTimeMillis() - timer > 1000) {
            timer += 1000;
            System.out.println(ticks + " tps" + " | " + frames + " fps");
            frame.setTitle(name + " | " + ticks + " tps" + "  " + frames + " fps");
            frames = 0;
            ticks = 0;
            
            //meanings
            //ns = nanoseconds
            //amountOfTicks = ticks per second
            
        }
    }
    stop();
}

开始和停止方法是针对线程的。 你可以找到关于如何做tick方法的简单教程并完全理解它。

当你的刻度正常工作时，你可以让你的 x 和 y += velX 和 velY，就像这样：

public void tick() {
        y += velY;
        x += velX;
}

让玩家每次更新更新 x 和 y

而 velX 和 velY 需要对您的 KeyInputs 做出反应，所以它们，你知道，有一个值，像这样：

if(key == KeyEvent.VK_W) { tempObject.setVelY(-10); keyDown[0] = true; }
                if(key == KeyEvent.VK_S) { tempObject.setVelY(10); keyDown[1] = 
true; }
                if(key == KeyEvent.VK_D) { tempObject.setVelX(10); keyDown[2] = 
true; }
                if(key == KeyEvent.VK_A) { tempObject.setVelX(-10); keyDown[3] = 
true; }

此代码，请勿复制粘贴。它有不同的方法，因为我将这段代码基于我不久前制作的游戏。所以方法不同。

所以当你得到它时，你基本上就完成了。

setVelY 和 setVelX 看起来像这样：

public void setVelY(int velY){
    this.velY = velY;
}

public void setVelY(int velY){
    this.velX = velX;
}

所以，结论。 如果你想要更流畅的动画，你需要一个 tick 方法，所以 x 和 y 每秒更新一次。

如果你复制粘贴，我的代码基本上没有任何作用，但它只是如何使动作平滑的概念。

所以 x 和 y 需要每秒更新一次。制作 Runnable tick 方法是您唯一的方法。

我真的希望这对你有一点帮助。

祝你好运！ :D

Answer 3

我现在常用的一个解决方案是将游戏动画线程与输入事件（鼠标和键盘）分开，采用松散耦合在两者之间进行通信。

游戏循环可以由以 60 fps 运行的java.util.Timer 驱动。我使用这个速率是因为显示器以 60 fps 刷新是很常见的，因此以更快的速率运行会带来收益递减。

有些人更喜欢使用javax.swing.Timer，但如果这是个好主意的话，请使用 IDK。 EDT（事件调度线程）可能会成为瓶颈。 （经典的 Java 游戏编程书籍：Killer Game Programming in Java 比较了两个计时器，而 util Timer 胜出。）可以说，ScheduledThreadPoolExecutor 比任何一个都更健壮，尽管它需要一个如果您还没有使用 Executors 进行多线程处理，那会有点学习曲线。 （我更喜欢使用JavaFX，所以我使用它的AnimationTimer。）

保存游戏循环的类应该具有公共方法，其中触发的键盘或鼠标事件可以简单地设置变量或切换布尔值（或将变量添加到队列顶部）。键盘的公共输入法可以有一些额外的处理来比较传入的键事件和当前的键状态（例如，保持的键状态映射，如本线程其他地方所述）并为游戏循环线程设置一个字段阅读并采取行动。

这种游戏程序的架构增加了大量的可预测性和控制性，并澄清了各个层的逻辑。它还充分利用了当今处理器的多线程功能。