我一直在研究通用的2d瓷砖风格游戏。目前在我的主线程中，我有一个尽可能快的循环，并调用另一个处理游戏内容的类的JPanel的重绘方法。它看起来像这样：
public class Main {
public static void main(String[] args) {
Island test = new Island();
while(true) {
test.getCanvas().requestFocus();
test.getCanvas().repaint();
}
}
}
getCanvas（）只返回JPanel。
目前这已经完成了我想要的，现在我已经开始为玩家添加动作，显然我不想尽可能快地将他移动到屏幕上。所以我在Island类中有一个输入映射和动作映射，它可以检测按键和释放按键，并告诉我的播放器类正在按住哪些键。然后我用一个每10ms调用一次的摇摆计时器将我的播放器移到播放器类内。所以我想这就像我的游戏滴答，我的游戏会尽可能快地制作帧，然后游戏每秒100次执行所有逻辑操作，我当然会添加更多的游戏逻辑，而不仅仅是移动。
经过一些研究后，看起来摇摆计时器并不是最好的方法，因为它是专为执行小任务和摆动任务而设计的。所以我想我的问题是，以我的主要方法制作我的框架是否明智，以及每10毫秒或其他什么方式让我的游戏可靠地打勾的好方法？我有一些想法，比如也许我应该创建一个新的线程来处理游戏逻辑并使用System.getnanotime或其他任何调用来测量刻度所需的时间然后做一个小的thread.sleep但是直到我们达到10毫秒然后重复。
如果您愿意，我很乐意发布更多代码:)，并提前感谢。
答案 0 :(得分：3)
执行此操作的标准方法是在线程中。继承人标准游戏准系统游戏线程
public class GameThread implements Runnable {
private Thread runThread;
private boolean running = false;
private boolean paused = false;
public GameThread() {
}
public void start() {
running = true;
paused = false;
if(runThread == null || !runThread.isAlive())
runThread = new Thread(this);
else if(runThread.isAlive())
throw new IllegalStateException("Thread already started.");
runThread.start();
}
public void stop() {
if(runThread == null)
throw new IllegalStateException("Thread not started.");
synchronized (runThread) {
try {
running = false;
runThread.notify();
runThread.join();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
public void pause() {
if(runThread == null)
throw new IllegalStateException("Thread not started.");
synchronized (runThread) {
paused = true;
}
}
public void resume() {
if(runThread == null)
throw new IllegalStateException("Thread not started.");
synchronized (runThread) {
paused = false;
runThread.notify();
}
}
public void run() {
long sleep = 0, before;
while(running) {
// get the time before we do our game logic
before = System.currentTimeMillis();
// move player and do all game logic
try {
// sleep for 100 - how long it took us to do our game logic
sleep = 100-(System.currentTimeMillis()-before);
Thread.sleep(sleep > 0 ? sleep : 0);
} catch (InterruptedException ex) {
}
synchronized (runThread) {
if(paused) {
try {
runThread.wait();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
}
paused = false;
}
}
注意你需要调用gameThead.start（）来开始你的游戏！
答案 1 :(得分：1)
在不吃CPU 100％的情况下创建一个好的（窗口应用程序）游戏循环实际上是一个非常棘手的任务。 Sidescroll以恒定速度动画精灵很容易引入急动，如果有一个可见。
在运行了几个想法后，这是最好的选择，侧面滚动大部分时间是黄油顺利。 VSYNCing可以在窗口模式下运行良好，我在不同的机器和操作系统上发现了不同的结果。
测试应用程序没有使用SwingUI，因为大多数游戏无论如何都不需要它。 Gameloop是一个活跃的更新渲染循环，没有外部线程使事情更容易编程。使用keyPressed回调来更新 firePressed = true和etc 标记变量并在循环中使用值。
运行测试应用 C：GT; java -cp ./classes GameLoop2“fullscreen = false”“fps = 60”“vsync = true”
//http://www.javagaming.org/index.php/topic,19971.0.html
//http://fivedots.coe.psu.ac.th/~ad/jg/ch1/ch1.pdf
import java.util.*;
import java.awt.Color;
import java.awt.Frame;
import java.awt.Graphics;
import java.awt.GraphicsConfiguration;
import java.awt.GraphicsDevice;
import java.awt.GraphicsEnvironment;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.geom.Rectangle2D;
import java.awt.image.BufferStrategy;
import java.awt.DisplayMode; // for full-screen mode
public class GameLoop2 implements KeyListener {
Frame mainFrame;
private static final long NANO_IN_MILLI = 1000000L;
// num of iterations with a sleep delay of 0ms before
// game loop yields to other threads.
private static final int NO_DELAYS_PER_YIELD = 16;
// max num of renderings that can be skipped in one game loop,
// game's internal state is updated but not rendered on screen.
private static int MAX_RENDER_SKIPS = 5;
private static int TARGET_FPS = 60;
//private long prevStatsTime;
private long gameStartTime;
private long curRenderTime;
private long rendersSkipped = 0L;
private long period; // period between rendering in nanosecs
long fps;
long frameCounter;
long lastFpsTime;
Rectangle2D rect, rect2, rect3;
/**
* Create a new GameLoop that will use the specified GraphicsDevice.
*
* @param device
*/
public GameLoop2(Map<String,String> args, GraphicsDevice device) {
try {
if (args.containsKey("fps"))
TARGET_FPS = Integer.parseInt(args.get("fps"));
// Setup the frame
GraphicsConfiguration gc = device.getDefaultConfiguration();
mainFrame = new Frame(gc);
//mainFrame.setUndecorated(true);
mainFrame.setIgnoreRepaint(true);
mainFrame.setVisible(true);
mainFrame.setSize(640, 480);
//mainFrame.setLocationRelativeTo();
mainFrame.setLocation(700,100);
mainFrame.createBufferStrategy(2);
mainFrame.addKeyListener(this);
if ("true".equalsIgnoreCase(args.get("fullscreen"))) {
device.setFullScreenWindow(mainFrame);
device.setDisplayMode(new DisplayMode(640, 480, 8, DisplayMode.REFRESH_RATE_UNKNOWN));
}
final boolean VSYNC = "true".equalsIgnoreCase(args.get("vsync"));
// Cache the buffer strategy and create a rectangle to move
BufferStrategy bufferStrategy = mainFrame.getBufferStrategy();
rect = new Rectangle2D.Float(0,100, 64,64);
rect2 = new Rectangle2D.Float(0,200, 32,32);
rect3 = new Rectangle2D.Float(500,300, 128,128);
// loop initialization
long beforeTime, afterTime, timeDiff, sleepTime;
long overSleepTime = 0L;
int noDelays = 0;
long excess = 0L;
gameStartTime = System.nanoTime();
//prevStatsTime = gameStartTime;
beforeTime = gameStartTime;
period = (1000L*NANO_IN_MILLI)/TARGET_FPS; // rendering FPS (nanosecs/targetFPS)
System.out.println("FPS: " + TARGET_FPS + ", vsync=" + VSYNC);
System.out.println("FPS period: " + period);
// Main loop
while(true) {
// **2) execute physics
updateWorld(0);
// **1) execute drawing
Graphics g = bufferStrategy.getDrawGraphics();
drawScreen(g);
g.dispose();
// Synchronise with the display hardware. Note that on
// Windows Vista this method may cause your screen to flash.
// If that bothers you, just comment it out.
if (VSYNC) Toolkit.getDefaultToolkit().sync();
// Flip the buffer
if( !bufferStrategy.contentsLost() )
bufferStrategy.show();
afterTime = System.nanoTime();
curRenderTime = afterTime;
calculateFramesPerSecond();
timeDiff = afterTime - beforeTime;
sleepTime = (period-timeDiff) - overSleepTime;
if (sleepTime > 0) { // time left in cycle
//System.out.println("sleepTime: " + (sleepTime/NANO_IN_MILLI));
try {
Thread.sleep(sleepTime/NANO_IN_MILLI);//nano->ms
} catch(InterruptedException ex){}
overSleepTime = (System.nanoTime()-afterTime) - sleepTime;
} else { // sleepTime <= 0;
System.out.println("Rendering too slow");
// this cycle took longer than period
excess -= sleepTime;
// store excess time value
overSleepTime = 0L;
if (++noDelays >= NO_DELAYS_PER_YIELD) {
Thread.yield();
// give another thread a chance to run
noDelays = 0;
}
}
beforeTime = System.nanoTime();
/* If the rendering is taking too long, then
update the game state without rendering
it, to get the UPS nearer to the
required frame rate. */
int skips = 0;
while((excess > period) && (skips < MAX_RENDER_SKIPS)) {
// update state but don’t render
System.out.println("Skip renderFPS, run updateFPS");
excess -= period;
updateWorld(0);
skips++;
}
rendersSkipped += skips;
}
} catch (Exception ex) {
ex.printStackTrace();
} finally {
device.setFullScreenWindow(null);
}
}
private void updateWorld(long elapsedTime) {
// speed: 150 pixels per second
//double xMov = (140f/(NANO_IN_MILLI*1000)) * elapsedTime;
double posX = rect.getX() + (140f / TARGET_FPS);
if (posX > mainFrame.getWidth())
posX = -rect.getWidth();
rect.setRect(posX, rect.getY(), rect.getWidth(), rect.getHeight());
posX = rect2.getX() + (190f / TARGET_FPS);
if (posX > mainFrame.getWidth())
posX = -rect2.getWidth();
rect2.setRect(posX, rect2.getY(), rect2.getWidth(), rect2.getHeight());
posX = rect3.getX() - (300f / TARGET_FPS);
if (posX < -rect3.getWidth())
posX = mainFrame.getWidth();
rect3.setRect(posX, rect3.getY(), rect3.getWidth(), rect3.getHeight());
}
private void drawScreen(Graphics g) {
g.setColor(Color.BLACK);
g.fillRect(0, 0, mainFrame.getWidth(), mainFrame.getHeight());
g.setColor(Color.WHITE);
g.drawString("FPS: " + fps, 40, 50);
g.setColor(Color.RED);
g.fillRect((int)rect.getX(), (int)rect.getY(), (int)rect.getWidth(), (int)rect.getHeight());
g.setColor(Color.GREEN);
g.fillRect((int)rect2.getX(), (int)rect2.getY(), (int)rect2.getWidth(), (int)rect2.getHeight());
g.setColor(Color.BLUE);
g.fillRect((int)rect3.getX(), (int)rect3.getY(), (int)rect3.getWidth(), (int)rect3.getHeight());
}
private void calculateFramesPerSecond() {
if( curRenderTime - lastFpsTime >= NANO_IN_MILLI*1000 ) {
fps = frameCounter;
frameCounter = 0;
lastFpsTime = curRenderTime;
}
frameCounter++;
}
public void keyPressed(KeyEvent e) {
if( e.getKeyCode() == KeyEvent.VK_ESCAPE ) {
System.exit(0);
}
}
public void keyReleased(KeyEvent e) { }
public void keyTyped(KeyEvent e) { }
public static void main(String[] args) {
try {
Map<String,String> mapArgs = parseArguments(args);
GraphicsEnvironment env = GraphicsEnvironment.getLocalGraphicsEnvironment();
GraphicsDevice device = env.getDefaultScreenDevice();
new GameLoop2(mapArgs, device);
} catch (Exception ex) {
ex.printStackTrace();
}
}
/**
* Parse commandline arguments, each parameter is a name-value pair.
* Example: java.exe MyApp "key1=value1" "key2=value2"
*/
private static Map<String,String> parseArguments(String[] args) {
Map<String,String> mapArgs = new HashMap<String,String>();
for(int idx=0; idx < args.length; idx++) {
String val = args[idx];
int delimIdx = val.indexOf('=');
if (delimIdx < 0) {
mapArgs.put(val, null);
} else if (delimIdx == 0) {
mapArgs.put("", val.substring(1));
} else {
mapArgs.put(
val.substring(0, delimIdx).trim(),
val.substring(delimIdx+1)
);
}
}
return mapArgs;
}
}
Gameloop逻辑可能看起来很疯狂，但相信我的工作效果令人惊讶。给它一个运行。 编辑：同时运行TaskManager会在平滑动画中创建急动我想更新仪器统计数据会给人以重创。