Java 帆布不'；t在绘制图像后更新

我正在用Java设计一个游戏。我正在使用在上找到的一些代码，它似乎工作得很奇怪

当我按照给定的方式运行循环时，它将正确地更新画布。然而，我不希望它总是更新我的“背景”，可以这么说。为了解决这个问题，我只运行了一次。现在它似乎运行，但不显示我绘制的图像

我上传了程序运行一次（中断）和程序持续运行（工作）的截图。在电视上看到他们

tldr；所有内容似乎都在运行，但在我的框架中没有显示任何内容。请参阅下面的代码

package main;

//imports...
import java.awt.Canvas;
import java.awt.Dimension;
import java.awt.Graphics2D;
import java.awt.event.KeyListener;
import java.awt.image.BufferStrategy;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

import javax.imageio.ImageIO;
import javax.swing.JFrame;
import javax.swing.JPanel;

public class GameEngine implements Runnable {
    //declare variables...
    final static int B_HEIGHT = 20;
    final static int B_WIDTH = 20;
    private int cellWidth = GameTester.WIDTH / B_WIDTH;
    private int cellHeight = GameTester.HEIGHT / B_HEIGHT;
    protected boolean init = true;
    JFrame frame;
    Canvas canvas;
    BufferStrategy bufferStrategy;
    Board gameBoard;
    Generator gen;

    long desiredFPS = 60;
    long desiredDeltaLoop = (1000 * 1000 * 1000) / desiredFPS;
    boolean running = true;

    public GameEngine(int width, int height) {

        //create the gamespace...
        gameBoard = new Board(B_WIDTH, B_HEIGHT);
        gen = new Generator();

        gen.addWalls(gameBoard);
        agents.Champion champ = new agents.Champion();
        items.Item item = new items.Item();
        gameBoard.placeChampion(champ);
        gameBoard.placeItem(item);

        //frame magic...
        frame = new JFrame("Basic Game");

        JPanel panel = (JPanel) frame.getContentPane();
        panel.setPreferredSize(new Dimension(width, height));
        panel.setLayout(null);

        canvas = new Canvas();
        canvas.setBounds(0, 0, width, height);
        canvas.setIgnoreRepaint(true);

        panel.add(canvas);

        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.pack();
        frame.setResizable(false);
        frame.setVisible(true);

        canvas.createBufferStrategy(2);
        bufferStrategy = canvas.getBufferStrategy();

        canvas.requestFocus();
    }

    //actual game mechanics...
    public void run() {

        long beginLoopTime;
        long endLoopTime;
        long currentUpdateTime = System.nanoTime();
        long lastUpdateTime;
        long deltaLoop;

        //game loop...
        while (running) {
            beginLoopTime = System.nanoTime();


            //this draws things
            render();


            lastUpdateTime = currentUpdateTime;
            currentUpdateTime = System.nanoTime();

            //update magic...
            update((int) ((currentUpdateTime - lastUpdateTime) / (1000 * 1000)));

            endLoopTime = System.nanoTime();
            deltaLoop = endLoopTime - beginLoopTime;

            if (deltaLoop <= desiredDeltaLoop) {
                try {
                    Thread.sleep((desiredDeltaLoop - deltaLoop) / (1000 * 1000));
                } catch (InterruptedException e) {
                    // Do nothing
                }
            }
        }
    }

    //creates g object...
    private void render() {
        Graphics2D g = (Graphics2D) bufferStrategy.getDrawGraphics();
        g.clearRect(0, 0, GameTester.WIDTH, GameTester.HEIGHT);
        render(g);
        g.dispose();
        bufferStrategy.show();
    }

    // does nothing important...
    private double x = 0;
    protected void update(int deltaTime) {
        if (GameTester.dbglvl > 1) {
            System.out.println("update called");
        }
        x += deltaTime * 0.2;
        while (x > 500) {
            x -= 500;
        }
    }

    // ACTUAL GAME DRAWING MECHANISM...
    protected void render(Graphics2D g) {
        //first run
        if (init) {
            renderinit(g);
        } else {
            //every other time after first run
        }
    }

    //first run (generates game board)
    protected void renderinit(Graphics2D g) {
        BufferedImage img = null;

        //loop through 2d array
        for (int row = 0; row < gameBoard.getWidth(); row++) {
            for (int col = 0; col < gameBoard.getHeight(); col++) {
                //get image path
                String str = gameBoard.getSpace(row, col).getPath();

                //debug info
                if (GameTester.dbglvl > 1) {
                    System.out.println(gameBoard.getSpace(row, col).getPath());
                }

                //get the image to be rendered
                try {
                    img = ImageIO.read(new File(str));
                } catch (IOException e) {
                    if (GameTester.dbglvl > 0) {
                        System.out
                                .println("image get failed - image specified: "
                                        + str + " ");
                    }
                }

                if (GameTester.dbglvl > 1) {
                    System.out.println("Image Destination: (" + row * cellWidth
                            + ", " + col * cellHeight + ")");
                }

                //draws given image
                g.drawImage(img, row * cellWidth, // DX1
                        col * cellHeight, // DY1
                        (row * cellWidth) + cellWidth, // DX2
                        (col * cellHeight) + cellHeight, // DY2
                        0, // SX1
                        0, // SY1
                        img.getWidth(), // SX2
                        img.getHeight(), // SY2
                        null);

            }
        }
        //done with first time run
        init = false;
        if (GameTester.dbglvl > 0) {
            System.out.println("Board Rendered");
        }
    }
}

packagemain；
//进口。。。
导入java.awt.Canvas；
导入java.awt.Dimension；
导入java.awt.Graphics2D；
导入java.awt.event.KeyListener；
导入java.awt.image.BufferStrategy；
导入java.awt.image.buffereImage；
导入java.io.File；
导入java.io.IOException；
导入javax.imageio.imageio；
导入javax.swing.JFrame；
导入javax.swing.JPanel；
公共类GameEngine实现了Runnable{
//声明变量。。。
最终静态int B_高度=20；
最终静态int B_宽度=20；
private int cellWidth=GameTester.WIDTH/B_WIDTH；
私有int cellHeight=GameTester.HEIGHT/B_HEIGHT；
受保护的布尔init=true；
JFrame框架；
帆布；
缓冲策略缓冲策略；
棋盘游戏；
发电机发电机；
长期期望fps=60；
长期期望deltaloop=（1000*1000*1000）/desiredFPS；
布尔运行=真；
公共游戏引擎（整数宽度、整数高度）{
//创建游戏空间。。。
游戏板=新板（B_宽度、B_高度）；
gen=新发电机（）；
一般添加墙（游戏板）；
agents.Champion champ=新的agents.Champion（）；
items.Item=新items.Item（）；
placeChampion（冠军）；
游戏板。放置物品（物品）；
//框架魔法。。。
框架=新的JFrame（“基本游戏”）；
JPanel面板=（JPanel）frame.getContentPane（）；
面板。设置首选尺寸（新尺寸（宽度、高度））；
panel.setLayout（空）；
画布=新画布（）；
画布.立根（0，0，宽度，高度）；
canvas.setIgnoreRepaint（true）；
panel.add（画布）；
frame.setDefaultCloseOperation（JFrame.EXIT_ON_CLOSE）；
frame.pack（）；
frame.setresizeable（false）；
frame.setVisible（true）；
canvas.createBufferStrategy（2）；
bufferStrategy=canvas.getBufferStrategy（）；
requestFocus（）；
}
//实际的游戏机制。。。
公开募捐{
开始时间长；
长时间；
长currentUpdateTime=System.nanoTime（）；
长的最后更新时间；
长三角帆；
//游戏循环。。。
（跑步时）{
beginLoopTime=System.nanoTime（）；
//这很吸引人
render（）；
lastUpdateTime=currentUpdateTime；
currentUpdateTime=System.nanoTime（）；
//更新魔术。。。
更新（（int）（（currentUpdateTime-lastUpdateTime）/（1000*1000））；
endLoopTime=System.nanoTime（）；
deltaLoop=endLoopTime-beginLoopTime；
如果（deltaLoop 1）{
System.out.println（“调用更新”）；
}
x+=deltaTime*0.2；
而（x>500）{
x-=500；
}
}
//实际游戏绘图机制。。。
受保护的无效渲染（Graphics2D g）{
//首轮
if（init）{
renderinit（g）；
}否则{
//第一次跑步后每隔一次
}
}
//第一次运行（生成游戏板）
受保护的void renderinit（图形2d g）{
BuffereImage img=null；
//循环通过二维阵列
对于（int row=0；row1）{
System.out.println（gameBoard.getSpace（row，col.getPath（））；
}
//获取要渲染的图像
试一试{
img=ImageIO.read（新文件（str））；
}捕获（IOE异常）{
如果（GameTester.dbglvl>0）{
系统输出
.println（“图像获取失败-指定图像：”
+str+）；
}
}
如果（GameTester.dbglvl>1）{
System.out.println（“图像目标：（“+行*单元格宽度
+“，“+col*单元格高度+”）；
}
//绘制给定图像
g、 drawImage（img，行*单元格宽度，//DX1
col*cellHeight，//DY1
（行*cellWidth）+cellWidth，//DX2
（列*单元高度）+单元高度，//DY2
0，//SX1
0，//SY1
img.getWidth（），//SX2
img.getHeight（），//SY2
无效）；
}
}
//完成第一次运行
init=false；
如果（GameTester.dbglvl>0）{
System.out.println（“提交的董事会”）；
}
}
}

绘画是破坏性的，也就是说，每次你被要求“渲染”您必须从头开始重建整个状态。使用

缓冲策略

时，这一点更为重要，因为它使用的是翻页技术，这意味着从一个渲染到另一个渲染的

图形

上下文可能与上一个或下一个渲染周期不同。如果可能，请选择任何内容不会改变（太多）的内容应预先呈现到

缓冲区图像

，仅在需要时更改。Th