我目前正在尝试制作我的第一个简单的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
}
}

键输入类：

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);
}
}
}
}
}

标识枚举：

package topDownGame;
public enum ID {
Player();
}

好的，我已经深入研究了这个例子，你遇到的"基本"问题是没有什么可以调用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();
}

好：

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

观察。。。

在我完成代码时，很明显代码组织得不好。真正让我恼火的一件事是，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的容器提供大小调整提示。这也意味着，当packJFrame时，窗口将略大于内容区域，因为框架的边框环绕着它。

我还建议看一下JavaDocsBufferStrategy因为它有一个"如何"使用它的例子。

为此，我相应地修改了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());- 现在它将填充组件的"实际"大小，而不仅仅是"所需"大小......我是那些讨厌(热情地)不可调整大小的窗口的人之一;)

如果你有兴趣看到一个稍微复杂的解决方案，你可以看看这个例子，它提出了一个更"通用"和"解耦"的概念。

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

观察。。。

相关内容

最新更新

热门标签：