Java - 吃 bean 人 - GUI - 绘图问题，以及给有抱负的程序员的一般提示

Question

我正在制作吃 bean 人，但在框架上绘制图形时遇到问题，当我绘制点图像时，它看起来像蛇游戏，我尝试将我的背景和字符绘制方法都放在渲染中方法，但比我的点图像闪烁

它现在的样子，随意忽略那张随机的脸，这是一个内部笑话。

此外，这是我的第一款游戏，所以任何关于结构的提示、关于我做对的事情(如果有的话)和我做错的事情的指示，以及一般提示都会非常有帮助!

另外我知道我有几个未使用的方法

代码:

---

package game;

import graphics.map;

import java.awt.BorderLayout;
import java.awt.Canvas;
import java.awt.Color;
import java.awt.Container;
import java.awt.Dimension;
import java.awt.Font;
import java.awt.Graphics;
import java.awt.Insets;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.image.BufferedImage;
import java.io.File;
import java.io.IOException;

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



public class main extends Canvas implements Runnable{
    private static final long serialVersionUID = 1L; //not sure why it wanted me to do this, maybe ask bender, or just google it later

    public static boolean running = false;
    public static int HEIGHT = 800;
    public static int WIDTH = 600;
    public static int posX = 50;
    public static int posY = 50;
    public static final String name = "Pac Man Alpha 1.4";
    private static final double speed = 1.2;

    public input input;

    static BufferedImage background = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);;
    static BufferedImage pacman = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);;
    static BufferedImage settingsBackground = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);;
    static BufferedImage level1 = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);;
    static BufferedImage level2 = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);;

    static BufferedImage points = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);;
    static BufferedImage point = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);;


    static JFrame frame;
    private input keypress = new input();
    private map map;

    private static boolean charLoaded = false;
    public static boolean MAIN_MENU = true;
    public static boolean GAME = false;
    public static boolean level1test = true;
    public static boolean level2test = false;
    public static boolean level3test = false;
    public static boolean level4test = false;


    static boolean drawn = false;

    public static boolean key_down;

    public static boolean key_up;

    public static boolean key_right;

    public static boolean key_left;

    //private Screen screen;
    JButton startButton = new JButton("Start"); //Start
    JButton settingsButton = new JButton("Settings"); //Settings
    JButton exitButton = new JButton("Exit"); //Exit


    public main() 
    {


        setMinimumSize(new Dimension(WIDTH , HEIGHT ));
        setMaximumSize(new Dimension(WIDTH , HEIGHT )); // keeps the canvas same size
        setPreferredSize(new Dimension(WIDTH, HEIGHT));

        frame = new JFrame(name);


        if(MAIN_MENU == true && GAME == false){
        buttons(frame.getContentPane());
        }

        frame.setLayout(new BorderLayout());
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); // ends program on
                                                                // close
        frame.addKeyListener(new input() );
        frame.add(this, BorderLayout.CENTER);
        frame.pack(); // keeps size correct
        frame.setResizable(false);
        frame.setVisible(true);
        this.addKeyListener(keypress);

    }

    public static void main(String[] args) 
    {
        try {
            background = ImageIO.read(new File("res\\Background.png"));     
            pacman = ImageIO.read(new File("res\\pacmansprites.png"));
            settingsBackground = ImageIO.read(new File("res\\Background.png"));
            level1 = ImageIO.read(new File("res\\level1.png"));
            //level2 = ImageIO.read(new File("res\\level2.png"));


            point = ImageIO.read(new File("res\\Points for pacman.png"));

        } catch (IOException e) {
        }

        running = true;
        new main().start();

    }



    public void run() 
    {
        long lastTime = System.nanoTime();
        double nsPerTick = 1000000000 / 60D;
        long lastTimer = System.currentTimeMillis();
        double delta = 0;

        int frames = 0;
        int ticks = 0;

        while (running == true) {
            long now = System.nanoTime();
            delta += (now - lastTime) / nsPerTick;
            lastTime = now;
            boolean render = false;

            while (delta >= 1) {
                ticks++;
                tick();
                delta -= 1;
                render = true;

            }

                try {
                    Thread.sleep(3);        //keep the Frames from going to high
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }

            if(render == true){
            frames++;
            render();
            }

            if (System.currentTimeMillis() - lastTimer >= 1000) {
                lastTimer +=1000;
                //System.out.println("Frames: " + frames + "   Ticks: " + ticks); 

                frames = 0;
                ticks = 0;
            }
        }
    }



    public synchronized void start() 
    {
        new Thread(this).start();
        run();
    }




    public synchronized void stop() 
    {
        running = false;

    }



    public void tick()
    {
        if (key_up) posY -= speed / 2;
        if (key_down) posY += speed;
        if (key_left) posX -= speed / 2;
        if (key_right) posX += speed;
    }


    public void render()
    {
        drawn = false;




        if(MAIN_MENU == false && GAME == true)
            {   
                drawMap();
                drawChar();
            }

        else if(MAIN_MENU == false && GAME == false) {
            Graphics g = getGraphics();
            {
                g.drawImage(settingsBackground,0,0,getWidth(),getHeight(),null);
                g.dispose();
            }
        } else {
                Graphics g = getGraphics();{

                    g.drawImage(background,0,0,getWidth(), getHeight(),null);
                    g.dispose(); //kill it  
            }
        }
    }

    public void drawMap(){
        if(level1test == true){
            Graphics g = getGraphics();
            {
        g.drawImage(level1,0,0,getWidth(),getHeight(),null);
        g.dispose();
        }
        }

        if(level2test == true && drawn == false){
            Graphics g = getGraphics();
            {
        g.drawImage(level2,0,0,getWidth(),getHeight(),null);
        }
        g.dispose();
        }
        drawn = true;
    }


    public void drawChar(){
        //drawMap();
        Graphics g = getGraphics();{
            g.drawImage(point,posX,posY,20, 20,null);
            g.dispose();
            revalidate();
        }
    }



    public void begin() {
        if (key_up) System.out.println("up");
        if (key_down) System.out.println("down");
        if (key_left) System.out.println("left");
        if (key_right) System.out.println("right");
    }





    public void loadMap(){
        if(!drawn && level1test){
        }else if(!drawn && level2test){
            //draw 2nd map here
        }else if(!drawn && level3test){
            //draw 3rd map here
        }
}




    public void buttons(Container pane)
    {
        pane.setLayout(null);

        startButton.addActionListener( new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                MAIN_MENU = false;
                GAME = true;
                frame.remove(startButton);
                frame.remove(settingsButton);
                frame.remove(exitButton);
                frame.revalidate();
                drawMap();
                System.out.println("Start Button Clicked");
            }
        } );


        settingsButton.addActionListener( new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                MAIN_MENU = false;
                GAME = false;
                frame.remove(startButton);
                frame.remove(settingsButton);
                frame.remove(exitButton);
                frame.revalidate();
                frame.repaint();
                System.out.println("Settings Button Clicked");
                }
        } );



        exitButton.addActionListener( new ActionListener() {
            public void actionPerformed(ActionEvent ae) {
                System.out.println("Exit Button Clicked");
                System.exit(0);
            }
        } );



        pane.add(startButton);
        pane.add(settingsButton);
        pane.add(exitButton);


        Insets insets = pane.getInsets();
        Dimension size = startButton.getPreferredSize();

        startButton.setBackground(new Color(0, 0, 0));
        startButton.setForeground(Color.CYAN);
        startButton.setFocusPainted(false);
        startButton.setFont(new Font("Calabri", Font.BOLD, 16));

        settingsButton.setBackground(new Color(0, 0, 0));
        settingsButton.setForeground(Color.RED);
        settingsButton.setFocusPainted(false);
        settingsButton.setFont(new Font("Calabri", Font.BOLD, 16));

        exitButton.setBackground(new Color(0, 0, 0));
        exitButton.setForeground(Color.YELLOW);
        exitButton.setFocusPainted(false);
        exitButton.setFont(new Font("Calabri", Font.BOLD, 16));

        startButton.setBounds((WIDTH - 125) + insets.left, 10 + insets.top,
                size.width + 50, size.height + 10);


        settingsButton.setBounds((WIDTH - 125) + insets.left, 55 + insets.top,
                size.width + 50, size.height + 10);

        exitButton.setBounds((WIDTH - 125) + insets.left, 100 + insets.top,
                size.width + 50, size.height + 10);
    }
}

Answer 1

getGraphics不是定制绘画的完成方式。在您的情况下，您应该覆盖 paint方法，并确保调用 super.paint在进行任何自定义绘画之前。

getGraphics返回 Graphics最后用于绘制组件的上下文，可以在下一个绘制周期中丢弃，为 null 或不再被组件使用

请记住，绘画使用“画家 Canvas ”方法，也就是说，就像在物理 Canvas 上绘画一样，当您在其中绘画时，您会在之前的内容上绘画，但不会删除它。

现在，如果您覆盖 paint ，你会发现你会有闪烁的问题。这是因为 Canvas 不是双缓冲

要解决这个问题，您应该考虑用户 a BufferStrategy ，它不仅允许您生成多个要绘制的缓冲区，还可以控制绘制过程本身

只是不要忘记在绘制之前清除每个缓冲区...