Java-如何调整2D游戏的大小？

Question

I'm developing a 2D game but i get stuck on the resizing. So as you can see in the code below, I draw all the game things into a BufferedImage. After that i get the graphics from my JPanel and draw the image on it.

So my question is how can i resize my game now? I think there are many possibilities: 1 would be that the image is just resizing with the jpanel as well and the other method could be that if you have a 2d world and you resize the frame, the game will be still in the same size but you can see now more of the 2d world, like that your viewing distance increased.

Does someone knows a solution for my code?

package de.avarion.theenchanter;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.RenderingHints;
import java.awt.image.BufferedImage;

import javax.swing.JFrame;
import javax.swing.JPanel;

public class Game implements Runnable{

    public static int WIDTH = 800;
    public static int HEIGHT = 600;
    public static int FPS = 30;

    private JFrame frame;
    private JPanel panel;

    private BufferedImage image;
    private Graphics2D g;

    private Thread thread;
    private boolean running


    public Game() {
        panel = new JPanel();
        panel.setPreferredSize(new Dimension(WIDTH, HEIGHT));
        panel.setFocusable(true);
        panel.requestFocus();

        frame = new JFrame("The Enchanter - pre Alpha");
        frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
        frame.setLayout(new BorderLayout());
        frame.add(panel, BorderLayout.CENTER);
        frame.pack();
        frame.setLocationRelativeTo(null);
        frame.setResizable(true);
        frame.setVisible(true);

        image = new BufferedImage(WIDTH, HEIGHT, BufferedImage.TYPE_INT_RGB);
        g = (Graphics2D) image.getGraphics();
        g.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
        running = true;

        thread = new Thread(this);
        thread.start();
    }

    @Override
    public void run() { //game loop
        while(running) {
            update();
            render();
            try {
                Thread.sleep(1000/FPS);
            } catch(InterruptedException e) {
                e.printStackTrace();
            }
        }
    }


    private void update() {
        if(frame.getWidth() != WIDTH || frame.getHeight() != HEIGHT) {
            frame.pack();
        }
    }

    private void render() {
        g.setColor(Color.black);//drawing on my image
        g.fillRect(0, 0, WIDTH, HEIGHT);

        Graphics g2 = panel.getGraphics(); // get graphics from panel
        g2.drawImage(image, 0, 0, null); //drawing on my panel
        g2.dispose();       
    }   
}

Answer 1

Let's start with Graphics g2 = panel.getGraphics(); - This is not how painting is done in Swing. Swing uses a passive rendering algorithm, this means that a paint cycle may occur at any time and for any reason, many of which are out of your control or knowledge.

Using your current approach, at best, you run the risk of the introducing flickering, as your rendering loop and Swing compete with each other or having partial updates due to a thread race condition between your thread and the EDT.

You should also never dispose of a Graphics context you did not create yourself, on some systems, this could actually prevent anything from been painted.

Take a look at Painting in AWT and Swing , Performing Custom Painting and Concurrency in Swing for more details.

A simple solution would be to override the paintComponent method of a Swing component, like JPanel and perform your custom painting directly within it. This allows you to not only ascertain the current size of the component, but the paintComponent method will be called automatically when the component is resized.

Swing components are double buffered by default, so you get that automatically for free

You could use a Swing Timer to act as the "game loop", updating the current state of the game and scheduling a repaint request with the RepaintManager , for example...

import java.awt.Color;
import java.awt.Dimension;
import java.awt.EventQueue;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import javax.swing.JFrame;
import javax.swing.JPanel;
import javax.swing.Timer;
import javax.swing.UIManager;
import javax.swing.UnsupportedLookAndFeelException;

public class Test {

    public static void main(String[] args) {
        new Test();
    }

    public Test() {
        EventQueue.invokeLater(new Runnable() {
            @Override
            public void run() {
                try {
                    UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
                } catch (ClassNotFoundException | InstantiationException | IllegalAccessException | UnsupportedLookAndFeelException ex) {
                    ex.printStackTrace();
                }

                JFrame frame = new JFrame("Testing");
                frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
                frame.add(new TestPane());
                frame.pack();
                frame.setLocationRelativeTo(null);
                frame.setVisible(true);
            }
        });
    }

    public class TestPane extends JPanel {

        private int xPos, yPos;
        private int xDelta = 2;

        public TestPane() {
            Timer timer = new Timer(40, new ActionListener() {
                @Override
                public void actionPerformed(ActionEvent e) {
                    int x = (int) (getWidth() * 0.1);
                    int y = (int) (getHeight() * 0.1);
                    int width = getWidth() - (x * 2);
                    int height = getHeight()- (y * 2);

                    xPos += xDelta;
                    yPos = y + ((height - 5) / 2);

                    if (xPos + 10 > x + width) {
                        xPos = x + (width - 10);
                        xDelta *= -1;
                    } else if (xPos < x) {
                        xPos = x;
                        xDelta *= -1;
                    }

                    repaint();
                }
            });
            timer.start();
        }

        @Override
        public Dimension getPreferredSize() {
            return new Dimension(200, 200);
        }

        @Override
        protected void paintComponent(Graphics g) {
            super.paintComponent(g);
            Graphics2D g2d = (Graphics2D) g.create();
            int x = (int) (getWidth() * 0.1);
            int y = (int) (getHeight() * 0.1);
            g2d.drawRect(x, y, getWidth() - (x * 2), getHeight() - (y * 2));
            g2d.setColor(Color.RED);
            g2d.drawOval(xPos, yPos, 10, 10);
            g2d.dispose();
        }

    }

}

If you want something that gives you more control over the rendering process, then you will need consider using something like a BufferStrategy . This allows you to employee a active painting process, painting to the buffer when you want to, without fear of some other thread painting to it as well.

See BufferStrategy and BufferCapabilities for more details