如何通过按键旋转Java中的2D矩形？

Question

我目前正在尝试制作我的第一个简单的 java 游戏。到目前为止，我一直遵循某个 Youtube 教程，但想添加我自己的功能，其中之一是能够通过按下某个键来旋转播放器。我一直在寻找如何做到这一点，但经过多次失败的尝试，如果有人能建议我应该如何做到这一点，我将不胜感激。

这是我的播放器类，我尝试通过实现 KeyListener 来旋转播放器：

package topDownGame;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Rectangle;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.geom.AffineTransform;
import java.awt.geom.Path2D;

import javax.swing.Timer;

public class Player extends GameObject implements KeyListener{

    private Handler handler;
    private HUD hud;
    public float rotation = 0;

    public Player(int x, int y, ID id, Handler handler, HUD hud) {
        super(x, y, id);
        this.handler = handler;
        this.hud = hud;

    }

    public void tick() {

        x += velX;
        y += velY;

        x = Game.clamp(x, 0, Game.WIDTH - 38);
        y = Game.clamp(y, 0, Game.HEIGHT - 67);

        collision();

    }

    public void render(Graphics g) {
        //g.setColor(Color.WHITE);      
        //g.fillRect(x, y, 32, 32);
        Graphics2D g2d = (Graphics2D)g;
        Rectangle r = new Rectangle(x, y, 32, 32);
        Path2D.Double path = new Path2D.Double();
        path.append(r, false);

        AffineTransform t = new AffineTransform();
        t.rotate(rotation);
        path.transform(t);
        g2d.setColor(Color.WHITE);
        g2d.draw(path);

    }


    public void collision() {

        for (int i = 0; i < handler.object.size(); i++) {
            GameObject tempObject = handler.object.get(i);

            if (tempObject.getId() == ID.BasicEnemy) {
                if (getBounds().intersects(tempObject.getBounds())) {
                    hud.HEALTH -= 2;
                }
            }
        }

    }


    public Rectangle getBounds() {

        return new Rectangle(x, y, 32, 32);

    }

    @Override
    public void keyPressed(KeyEvent e) {
    int key = e.getKeyCode();

        for (int i = 0; i < handler.object.size(); i++) {
            GameObject tempObject = handler.object.get(i);

            if (tempObject.getId() == ID.Player) {
                if (key == KeyEvent.VK_E) {
                    rotation = (float) (rotation + 0.1);
                }
            }
        }

    }

    @Override
    public void keyReleased(KeyEvent arg0) {
        // TODO Auto-generated method stub

    }

    @Override
    public void keyTyped(KeyEvent arg0) {
        // TODO Auto-generated method stub

    }   

}

以下是我剩余的一些可能很重要的代码

游戏类：

package topDownGame;

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Graphics;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferStrategy;

public class Game extends Canvas implements Runnable{

    /**
     * 
     */
    private static final long serialVersionUID = 1744439430685015162L;
    public static final int WIDTH = 640, HEIGHT = WIDTH / 12*9;

    private boolean running = false;
    private Thread thread;
    private Handler handler;

    public Game() {
        handler = new Handler();
        this.addKeyListener(new KeyInput(handler));
        new Window(WIDTH, HEIGHT, "Game", this);
        handler.addObject(new Player(200, 200, ID.Player, handler, hud));
    }

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

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

    public void run() {
        this.requestFocus();
        long lastTime = System.nanoTime();
        double delta = 0.0;
        double amountOfTicks = 60.0;
        double ns = 1000000000/amountOfTicks;
        long timer = System.currentTimeMillis();
        int frames = 0;
        while(running) {
            long now = System.nanoTime();
            delta += (now-lastTime)/ns;
            lastTime = now;
            while(delta >= 1) {
                delta--;
                tick();
            }
            if (running) {
                frames++;
                render();
            }
            if (System.currentTimeMillis() - timer > 1000) {
                timer += 1000;
                System.out.println("FPS: " + frames);
                frames = 0;
            }
        }
        stop();
    }

    public void tick() {
        handler.tick();
    }

    public void render() {
        BufferStrategy bs = this.getBufferStrategy();
        if (bs == null) {
            this.createBufferStrategy(3);
            return;
        }
        Graphics g = bs.getDrawGraphics();



        g.setColor(Color.BLACK);
        g.fillRect(0, 0, WIDTH, HEIGHT);
        handler.render(g);
        g.dispose();
        bs.show();
    }

    public static int clamp(int var, int min, int max) {

        if (var <= min) {
            var = min;
        }

        if (var >= max) {
            var = max;
        }

        return var;

    }


    public static void main(String args[]) {
        new Game();
    }



}

窗口类：

package topDownGame;

import java.awt.Canvas;
import java.awt.Dimension;

import javax.swing.JFrame;

public class Window extends Canvas{

    /**
     * 
     */
    private static final long serialVersionUID = -8646632868321067448L;

    public Window(int width, int height, String title, Game game) {

        JFrame jframe = new JFrame(title);

        jframe.setMaximumSize(new Dimension(width, height));
        jframe.setMinimumSize(new Dimension(width, height));
        jframe.setPreferredSize(new Dimension(width, height));

        jframe.setVisible(true);
        jframe.setDefaultCloseOperation(jframe.EXIT_ON_CLOSE);
        jframe.setResizable(false);
        jframe.setLocationRelativeTo(null);
        jframe.add(game);
        game.start();

    }

}

游戏对象类：

package topDownGame;

import java.awt.Graphics;
import java.awt.Rectangle;

public abstract class GameObject {

    protected int x, y;
    protected ID id;
    protected int velX, velY;

    public GameObject(int x, int y, ID id) {
        this.x = x;
        this.y = y;
        this.id = id;
    }

    public abstract void tick();
    public abstract void render(Graphics g);
    public abstract Rectangle getBounds();

    public int getX() {
        return x;
    }

    public void setX(int x) {
        this.x = x;
    }

    public int getY() {
        return y;
    }

    public void setY(int y) {
        this.y = y;
    }

    public ID getId() {
        return id;
    }

    public void setId(ID id) {
        this.id = id;
    }

    public int getVelX() {
        return velX;
    }

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

    public int getVelY() {
        return velY;
    }

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



}

处理程序类：

package topDownGame;

import java.awt.Graphics;
import java.util.LinkedList;

public class Handler {

    LinkedList <GameObject> object = new LinkedList <GameObject>();

    public void tick() {
        for (int i = 0; i < object.size(); i++) {
            GameObject tempObject = object.get(i);

            tempObject.tick();
        }
    }

    public void render(Graphics g) {
        for (int i = 0; i < object.size(); i++) {
            GameObject tempObject = object.get(i);

            tempObject.render(g);
        }
    }

    public void addObject(GameObject object) {
        this.object.add(object);
    }

    public void removeObject(GameObject object) {
        this.object.remove(object);
    }

    public void addObject(int x, int y, ID basicenemy) {
        // TODO Auto-generated method stub

    }

}

KeyInput 类：

package topDownGame;

import java.awt.event.KeyAdapter;
import java.awt.event.KeyEvent;

public class KeyInput extends KeyAdapter{


    private Handler handler;
    public KeyInput(Handler handler) {
        this.handler = handler;

    }


    public void keyPressed(KeyEvent e) {
        int key = e.getKeyCode();

        for (int i = 0; i < handler.object.size(); i++) {
            GameObject tempObject = handler.object.get(i);

            if (tempObject.getId() == ID.Player) {
                if (key == KeyEvent.VK_W) {
                    tempObject.setVelY(-5);
                }
                if (key == KeyEvent.VK_S) {
                    tempObject.setVelY(5);
                }
                if (key == KeyEvent.VK_A) {
                    tempObject.setVelX(-5);
                }
                if (key == KeyEvent.VK_D) {
                tempObject.setVelX(5);
                }

            }
        }
        if (key == KeyEvent.VK_SPACE) {
            System.exit(1);
        }
    }

    public void keyReleased(KeyEvent e) {
        int key = e.getKeyCode();
        for (int i = 0; i < handler.object.size(); i++) {
            GameObject tempObject = handler.object.get(i);

            if (tempObject.getId() == ID.Player) {
                if (key == KeyEvent.VK_W) {
                tempObject.setVelY(0);
                }
                if (key == KeyEvent.VK_S) {
                    tempObject.setVelY(0);
                }
                if (key == KeyEvent.VK_A) {
                    tempObject.setVelX(0);
                }
                if (key == KeyEvent.VK_D) {
                    tempObject.setVelX(0);
                }
            }
        }
    }

}

ID 枚举：

package topDownGame;

public enum ID {

    Player();

}

Answer 1

好的，所以我已经研究了这个例子，你遇到的“基本”问题是调用 Player 的 keyPressed/Released 方法 - 事实上，什么都不应该。

目的是，“输入”应该与实体分离，实体应该根据游戏引擎的当前状态更新它们的状态。

所以，我要做的第一件事是“概括”可能发生（以及游戏模型可以响应的）可用“输入操作”

public enum InputAction {
    UP, DOWN, LEFT, RIGHT, ROTATE;
}

就是这样。这些是游戏支持和实体可以使用的输入。它们与它们可能发生的“方式”分离，只是提供了一种方法。

现在，为了支持这个想法，我们实际上需要以某种方式告诉实体它们应该“更新”，这应该在它们被渲染之前完成，但是因为我们试图解耦这些操作（所以对象可以更频繁地更新然后渲染它们），我们需要提供一个新的方法来执行这个操作......

public abstract class GameObject {
    //...
    public void update() {
    }
    //...
}

（注意：从技术上讲，此方法可能是 abstract，因为几乎所有实体都需要以某种方式进行更改，但为简单起见，我只是将其设为空实现）

接下来，我们需要一些方法让实体响应这些输入操作并管理它们，在您的情况下，Handler 可能是最好的选择，因为它提供了实体和其他方面之间的链接系统的（如渲染和输入控制）

public class Handler {
    //...
    private Set<InputAction> inputActions = new HashSet<InputAction>();

    public void render(Graphics g) {
        for (int i = 0; i < object.size(); i++) {
            GameObject tempObject = object.get(i);

            tempObject.update();
            tempObject.render(g);
        }
    }
    
    public boolean is(InputAction action) {
        return inputActions.contains(action);
    }

    public void set(InputAction action) {
        inputActions.add(action);
    }

    public void remove(InputAction action) {
        inputActions.remove(action);
    }
    //...

}

好的，现在“输入机制”可以根据它的实现告诉Handler什么时候状态发生了变化......

public class KeyInput extends KeyAdapter {

    private Handler handler;

    public KeyInput(Handler handler) {
        this.handler = handler;
    }

    public void keyPressed(KeyEvent e) {
        int key = e.getKeyCode();
        if (key == KeyEvent.VK_W) {
            handler.set(InputAction.UP);
        }
        if (key == KeyEvent.VK_S) {
            handler.set(InputAction.DOWN);
        }
        if (key == KeyEvent.VK_A) {
            handler.set(InputAction.LEFT);
        }
        if (key == KeyEvent.VK_D) {
            handler.set(InputAction.RIGHT);
        }
        if (key == KeyEvent.VK_E) {
            handler.set(InputAction.ROTATE);
        }
    }

    public void keyReleased(KeyEvent e) {
        int key = e.getKeyCode();
        if (key == KeyEvent.VK_W) {
            handler.remove(InputAction.UP);
        }
        if (key == KeyEvent.VK_S) {
            handler.remove(InputAction.DOWN);
        }
        if (key == KeyEvent.VK_A) {
            handler.remove(InputAction.LEFT);
        }
        if (key == KeyEvent.VK_D) {
            handler.remove(InputAction.RIGHT);
        }
        if (key == KeyEvent.VK_E) {
            handler.remove(InputAction.ROTATE);
        }
    }

}

（是的，它们可能是 if-else if 语句，但为了简洁起见，我只是修改了现有代码）

最后，我们需要更新Player 对象，以便它可以根据游戏引擎的当前“状态”“更新”它的状态...

public class Player extends GameObject {

    private Handler handler;
    public float rotation = 0;

    public Player(int x, int y, ID id, Handler handler) {//, HUD hud) {
        super(x, y, id);
        this.handler = handler;

    }

    @Override
    public void update() {
        if (handler.is(InputAction.UP)) {
            setVelY(-5);
        } else if (handler.is(InputAction.DOWN)) {
            setVelY(5);
        } else {
            setVelY(0);
        }

        if (handler.is(InputAction.LEFT)) {
            setVelX(-5);
        } else if (handler.is(InputAction.RIGHT)) {
            setVelX(5);
        } else {
            setVelX(0);
        }

        if (handler.is(InputAction.ROTATE)) {
            rotation += 0.1;
        }
    }

    public void tick() {

        x += velX;
        y += velY;

        x = Game.clamp(x, 0, Game.WIDTH - 38);
        y = Game.clamp(y, 0, Game.HEIGHT - 67);

        collision();

    }

    public void render(Graphics g) {
        //g.setColor(Color.WHITE);      
        //g.fillRect(x, y, 32, 32);
        Graphics2D g2d = (Graphics2D) g.create();
        Rectangle r = new Rectangle(0, 0, 32, 32);
        Path2D.Double path = new Path2D.Double();
        path.append(r, false);

        AffineTransform t = new AffineTransform();
        t.translate(x, y);
        t.rotate(rotation, 16, 16);
        path.transform(t);
        g2d.setColor(Color.WHITE);
        g2d.draw(path);
        g2d.dispose();

    }

    public void collision() {

        for (int i = 0; i < handler.object.size(); i++) {
            GameObject tempObject = handler.object.get(i);

//              if (tempObject.getId() == ID.BasicEnemy) {
//                  if (getBounds().intersects(tempObject.getBounds())) {
//                      hud.HEALTH -= 2;
//                  }
//              }
        }

    }

    public Rectangle getBounds() {
        return new Rectangle(x, y, 32, 32);
    }

}

我想仔细看看render 方法，因为它有点复杂...

public void render(Graphics g) {
    // 1...
    Graphics2D g2d = (Graphics2D) g.create();
    // 2...
    Rectangle r = new Rectangle(0, 0, 32, 32);
    Path2D.Double path = new Path2D.Double();
    path.append(r, false);

    AffineTransform t = new AffineTransform();
    // 3...
    t.translate(x, y);
    // 4...
    t.rotate(rotation, 16, 16);
    path.transform(t);
    g2d.setColor(Color.WHITE);
    g2d.draw(path);
    // 5...
    g2d.dispose();
}

好的：

1. Graphics 是一个分片概念，这意味着需要绘制的每个实体都将获得相同的 Graphics 上下文，包括先前实体对其所做的任何和所有更改。这种“可能”是可取的，但总的来说，您希望减少可能发生的“副作用”的数量。因此，我们首先创建它的新副本。
2. 我们创建Rectangle。奇怪的是，这（现在）是一个不好的地方，因为它的状态实际上永远不会改变。 Rectangle 总是创建在位置0x0 并且大小为32x32 ...但是等等，我希望它移动并做一些事情！我知道，你会在...中看到“如何”。
3. 我们将Graphics 上下文的原点转换为玩家的位置...现在0x0 的位置与玩家的位置??相同。这是一个巧妙的作弊手段，正如我上面所说，您不再需要在每次调用 render 时创建一个 Rectangle，这将进一步提高性能
4. 我们围绕对象的中心点旋转Graphics 上下文（对象为32x32 使中心点16x16 - 记住，原点是0x0 ...你明白为什么那么小吗？改变是如此重要和有用?）
5. 我们dispose的副本。这只是释放了这个副本持有的所有资源，我们采取的行动仍然应用回原来的，但不影响之后可能发生的任何操作（所以原点和旋转与@时相同） 987654352@ 第一次被调用）。

观察...

在编写代码时，很明显代码组织得不好。真正让我恼火的一件事是Game 会创建一个Window 的实例以显示自己——这实际上是一种副作用，Game 不应该做的事情（它不应该在意)。

所以，我采用了您的main 方法并争吵它是...

public static void main(String args) {
    EventQueue.invokeLater(new Runnable() {
        @Override
        public void run() {
            JFrame jframe = new JFrame("Game");

            Game game = new Game();
            jframe.setDefaultCloseOperation(jframe.EXIT_ON_CLOSE);
            jframe.add(game);
            jframe.pack();
            jframe.setLocationRelativeTo(null);
            jframe.setVisible(true);
            game.start();
        }
    });
}

所以，一些小的变化......

• game 的实例几乎立即添加到框架中（这对于我所做的另一个更改很重要）
• 框架“打包”在组件周围
• 框架的位置已设置（因此它显示在屏幕中间），这是在打包窗口之后完成的，因为在我们打包它之前不会设置框架的大小。
• 使框架可见 - 这会阻止窗口“跳”到屏幕中心

我也加了...

@Override
public Dimension getPreferredSize() {
    return new Dimension(WIDTH, HEIGHT);
}

到Game，这为添加Game 的容器提供大小提示。这也意味着当JFrame 为packed 时，窗口将比内容区域略大，因为框架的边框被环绕在它周围。

我还建议您查看JavaDocs for BufferStrategy，因为它有一个“如何”使用它的示例。

为此，我相应地修改了你的render方法...

public void render() {
    BufferStrategy bs = this.getBufferStrategy();
    if (bs == null) {
        this.createBufferStrategy(3);
        return;
    }

    do {
        do {
            Graphics g = bs.getDrawGraphics();
            g.setColor(Color.BLACK);
            g.fillRect(0, 0, getWidth(), getHeight());
            handler.render(g);
            g.dispose();
        } while (bs.contentsRestored());
        bs.show();
    } while (bs.contentsLost());
}

我所做的一个重大改变是g.fillRect(0, 0, getWidth(), getHeight()); - 现在它将填充组件的“实际”大小，而不仅仅是“所需”大小......我是那些讨厌（热情地）非- 可调整大小的窗口；）

如果您有兴趣看到稍微复杂一点的解决方案，您可以使用look at this example，它提出了一个更“通用”和“解耦”的概念