在线程上运行的闪烁图像

Question

在我的“SpcaeShip”游戏中，我有一个循环游戏，可以更新和绘制我的所有对象。现在我想在游戏中添加一个小行星数组列表并绘制它们，但问题是如果我在循环游戏中绘制小行星数组，游戏运行速度非常慢。我的解决方案是在计时器线程上绘制小行星，游戏速度非常完美。我唯一的问题是我的小行星一直在闪烁。我需要使用 bufferStrategy 或类似的东西吗？

这是我在游戏循环中的绘制方法（在这个循环中我调用了游戏状态绘制方法）：

private void tick()
{
 //update all objects
}

private void render()
    {
        //how many buffers(hold the same data as our screen) the canvas would use
        bs = display.getCanvas().getBufferStrategy();


        if(bs == null)
        {
            display.getCanvas().createBufferStrategy(3);
            return;
        }


        g = bs.getDrawGraphics();


        g.clearRect(0, 0, width, height);

        if(State.getState() != null)
        {
            State.getState().render(g);

        }   


        bs.show();
        g.dispose();

    }

public void run()
{

    init();

    int fps = 60;
    double timePerTick = 1000000000/ fps;
    double delta = 0;
    long now;
    long lastTime =System.nanoTime();
    long timer = 0;


    //game loop
    while(running)
    {
        now = System.nanoTime();
        delta += (now - lastTime) / timePerTick;
        timer += now - lastTime;
        lastTime = now;

        if(delta >= 1)
        {
            tick();
            render();
        }
    }

    stop();
}

这是我的游戏状态方法：

import java.awt.Graphics;    
import java.awt.event.ActionEvent;    
import java.awt.event.ActionListener;    
import java.util.ArrayList;         
import javax.swing.Timer;
public class GameState extends State 
{

    private SpaceShip spaceShip;
    private BgHandler bgHandler;
    private ArrayList<Meteor> meteors;

    public GameState(Handler handler)
    {
        super(handler);

        bgHandler = new BgHandler(handler.getWidth(), handler.getHeight());
        spaceShip = new SpaceShip(handler, handler.getWidth() / 2 - Things.DEFAULT_OBJECT_WIDTH / 2,
                handler.getHeight() - Things.DEFAULT_OBJECT_HEIGHT - 100);
        meteors = new ArrayList<Meteor>();

        for(int i = 0; i < 5; i++)
        {
            Meteor m = new Meteor(handler,(int) (Math.random() * (handler.getWidth() - Things.DEFAULT_OBJECT_WIDTH ))
                    , -Things.DEFAULT_OBJECT_WIDTH,
                    Things.DEFAULT_OBJECT_WIDTH,
                    Things.DEFAULT_OBJECT_HEIGHT);

            meteors.add(m);
        }

        timer.start();

    }

    Timer timer = new Timer (50, new ActionListener()
    {
        public void actionPerformed(ActionEvent e)
        {
            tickMeteor();
            renderMeteor(); 

        }
    });

    public void tickMeteor()
    {
        for(int i = 0; i < meteors.size(); i++)
        {
            Meteor m = meteors.get(i);

            if(m.getVisible())
            {
                m.tick();
            }
            else
            {
                meteors.remove(i);
            }   
        }
    }

    public void renderMeteor()
    {

        for(Meteor m: meteors)
        {
            Meteor m1 = (Meteor) m;

            if(m1.getVisible())
            {
                m1.render(handler.getGame().getGraphics());
            }
        }
    }


    @Override
    public void tick()
    {
        spaceShip.tick();
        for(int i = 0; i < meteors.size(); i++)
        {
            Meteor m = meteors.get(i);

            if(m.getVisible())
            {
                m.tick();
            }
            else
            {
                meteors.remove(i);
            }   
        }
    }

    }

    @Override
    public void render(Graphics g)
    {
        bgHandler.render(g);
        spaceShip.render(g);

    }    
}    

Answer 1

这个m1.render(handler.getGame().getGraphics()) 大错特错。

流星的渲染应该在render方法中完成，并使用与其他元素相同的Graphics上下文，所以它们都在同一个pass中渲染

永远不要使用getGraphics，因为它在正常绘制周期之外提供了对Graphics 上下文的引用，这意味着在下一个绘制周期中绘制的任何内容都将被删除

老实说，我不知道您的“运行”方法要达到什么目的，但基本上，它是随心所欲的，这可能会不必要地消耗 CPU 周期，从而窃取程序其他部分的周期。

在运行循环中，sleep 绝不允许将时间分配给其他线程（或进程）。

以下示例尝试根据完成实际工作所用的时间量来保持每秒 60 个滴答的恒定速度更新周期。

public void run() {

    int fps = 60;
    long nanosInSecond = TimeUnit.NANOSECONDS.convert(1, TimeUnit.SECONDS);
    long timePerTick = (long)(nanosInSecond / (double)fps);

    //game loop
    while (true) {
        long now = System.nanoTime();

        try {
            // This is simulating the update and rendering process
            Thread.sleep(5);
        } catch (InterruptedException ex) {
        }
        long delta = System.nanoTime() - now;
        long timer = timePerTick - delta;
        timer = TimeUnit.MILLISECONDS.convert(timer, TimeUnit.NANOSECONDS);
        if (timer > 0) {
            try {
                System.out.println("sleep for " + timer + " milliseconds");
                Thread.sleep(timer);
            } catch (InterruptedException ex) {
            }
        }
    }

}