Java JFrame中的多个移动图形

Question

我对 Java 还很陌生，现在正在学习游戏设计。我有点刚开始，所以它不是真正的游戏。 我正在处理一个线程和一个数字数组。我必须让多个正方形同时在屏幕上移动。我的代码在一个方块上运行良好，但是当我尝试将它实现到多个方块时遇到了麻烦。我正在使用两个接口，但我不知道如何使用数组来制作单个随机正方形的多个案例。任何帮助将不胜感激。 伙计们干杯。

import java.awt.*;
import javax.swing.*;

public class MovingSquares extends JFrame implements Runnable
{
    private static final Dimension WindowSize = new Dimension(600, 600);    
    private static final int NUMGAMEOBJECTS = 30;
    private GameObject[] GameObjectsArray = new GameObject[NUMGAMEOBJECTS];
    static int strtCoX = (int) (Math.random() * 600);
    static int strtCoY = (int) (Math.random() * 600);


    public MovingSquares() {
        this.setTitle("Crazy squares");
        setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);

        Dimension screensize = java.awt.Toolkit.getDefaultToolkit().getScreenSize();
        int x = screensize.width/2 - WindowSize.width/2;
        int y = screensize.height/2 - WindowSize.height/2;
        setBounds(x, y, WindowSize.width, WindowSize.height);
        setVisible(true);

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

    public void run() {
        while (true) {
            try {
                Thread.sleep(20);
            } catch (InterruptedException e) { }
            GameObject.move();
            this.repaint();
        }   
    }

    public void paint(Graphics g) {
        g.setColor(Color.WHITE);
        g.fillRect(0, 0, WindowSize.width, WindowSize.height);

        int size = 50;
        int R = (int) (Math.random() * 256);
        int G = (int) (Math.random() * 256);        
        int B = (int) (Math.random() * 256);
        Color c = new Color(R, G, B);
        g.setColor(c);
        g.fillRect(strtCoX, strtCoY, size, size);
    }

    public static void main(String[] args) {
        MovingSquares M = new MovingSquares();
    }
}

第二个接口 - GameObject 类。

import java.awt.*;

public class GameObject 
{
    private static double x;
    private static double y;
    private Color c;
    public static int ranCoX = (int) (Math.random() * 20);
    public static int ranCoY = (int) (Math.random() * 20);

    public GameObject() {
        int strtX = (int) x;
        int strtY = (int) y;
        int speedX = (int) (Math.random() * 10);
        int speedY = (int) (Math.random() * 10);
    }

    public static void move() {
        int velX = (int) (Math.random() * ranCoX);
        int velY = (int) (Math.random() * ranCoY);

        if (MovingSquares.strtCoY > 600)
            MovingSquares.strtCoY = MovingSquares.strtCoY - 550;
        else if (MovingSquares.strtCoX > 600)
            MovingSquares.strtCoX = MovingSquares.strtCoX - 550;

        MovingSquares.strtCoX += velX;
        MovingSquares.strtCoY += velY;
    }

    public static void paint(Graphics g) {
        int size = 50;
        x = (Math.random() * 600);
        y = (Math.random() * 600);
        int R = (int) (Math.random() * 256);
        int G = (int) (Math.random() * 256);        
        int B = (int) (Math.random() * 256);
        Color c = new Color(R, G, B);
        g.setColor(c);
        g.fillRect((int)x, (int) y, size, size);
    }
}

Answer 1

这里有一个版本的移动方块，希望能帮助您了解如何制作动画。

我做的第一件事就是将这些类分成模型类、视图类或控制器类。 model / view / controller pattern 有助于分离关注点。

让我们看看你的模型类的修改版本，GameObject 类。

package com.ggl.moving.squares;

import java.awt.Color;
import java.awt.Graphics;

public class GameObject {

    private static final int size = 50;

    private double x;
    private double y;

    private double dx;
    private double dy;

    private int drawingWidth;

    public GameObject(int drawingWidth) {
        x = Math.random() * drawingWidth;
        y = Math.random() * drawingWidth;
        dx = Math.random() * 30D - 15D;
        dy = Math.random() * 30D - 15D;
        this.drawingWidth = drawingWidth;
    }

    public void move() {
        int lowerLimit = size;
        int upperLimit = drawingWidth - size;

        x += dx;
        if (x < lowerLimit) {
            x += upperLimit;
        } else if (x > upperLimit) {
            x -= upperLimit;
        }

        y += dy;
        if (y < lowerLimit) {
            y += upperLimit;
        } else if (y > upperLimit) {
            y -= upperLimit;
        }
    }

    public void draw(Graphics g) {
        g.setColor(generateRandomColor());
        g.fillRect((int) x, (int) y, size, size);
    }

    private Color generateRandomColor() {
        int R = (int) (Math.random() * 256);
        int G = (int) (Math.random() * 256);
        int B = (int) (Math.random() * 256);
        Color c = new Color(R, G, B);
        return c;
    }
}

只剩下一个静态字段，即正方形的大小。其他一切都是动态变量或方法。这允许我们创建多个 GameObject 实例。

我将绘图方法的名称从paint 更改为draw。这样我们就不会混淆哪些方法是 Swing 方法，哪些方法是我们的​​方法。

我们将绘图面板的宽度传递给构造函数。这样，我们只需要在一个地方定义宽度。您可以在 move 方法中看到，我们允许在绘图区域中留出正方形大小的边距。

构造函数定义了一个随机的初始位置和初始速度。移动方法只是保持正方形沿直线移动。

接下来，让我们看看修改后的主类，MovingSquares 类。

package com.ggl.moving.squares;

import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;

import javax.swing.JFrame;
import javax.swing.SwingUtilities;

public class MovingSquares implements Runnable {
    private static final int DRAWING_WIDTH = 600;
    private static final int NUMGAMEOBJECTS = 30;
    private GameObject[] gameObjectsArray = new GameObject[NUMGAMEOBJECTS];

    private JFrame frame;

    private MovingPanel movingPanel;

    private ObjectsRunnable objectsRunnable;

    public MovingSquares() {
        for (int i = 0; i < gameObjectsArray.length; i++) {
            gameObjectsArray[i] = new GameObject(DRAWING_WIDTH);
        }
    }

    @Override
    public void run() {
        frame = new JFrame();
        frame.setTitle("Crazy squares");
        frame.setDefaultCloseOperation(JFrame.DO_NOTHING_ON_CLOSE);
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent event) {
                exitProcedure();
            }
        });

        movingPanel = new MovingPanel(gameObjectsArray, DRAWING_WIDTH);
        frame.add(movingPanel);

        frame.pack();
        frame.setLocationByPlatform(true);
        frame.setVisible(true);

        objectsRunnable = new ObjectsRunnable(this, gameObjectsArray);
        new Thread(objectsRunnable).start();
    }

    private void exitProcedure() {
        objectsRunnable.setRunning(false);
        frame.dispose();
        System.exit(0);
    }

    public void repaintMovingPanel() {
        movingPanel.repaint();
    }

    public static void main(String[] args) {
        SwingUtilities.invokeLater(new MovingSquares());
    }
}

我们在这里定义了绘图面板的宽度，以及一个存放游戏对象的数组。

我们通过调用 SwingUtilities invokeLater 方法在 Event Dispatch thread (EDT) 上启动 Swing 应用程序。 Swing 应用程序必须始终在 EDT 上启动。

我们在构造函数中创建游戏对象，并在 run 方法中创建 Swing 组件。我将绘图面板移到了它自己的类中，我们稍后会谈到。

我们使用窗口侦听器，以便在应用程序完成后停止线程。

我们打包 JFrame。我们指定大小的唯一地方是创建绘图面板时。我们使用 JFrame。您扩展 Swing 组件或任何 Java 类的唯一时间是您想要覆盖其中一种方法。

我们来看看绘图面板类，MovingPanel 类。

package com.ggl.moving.squares;

import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;

import javax.swing.JPanel;

public class MovingPanel extends JPanel {

    private static final long serialVersionUID = -6291233936414618049L;

    private GameObject[] gameObjectsArray;

    public MovingPanel(GameObject[] gameObjectsArray, int width) {
        this.gameObjectsArray = gameObjectsArray;
        setPreferredSize(new Dimension(width, width));
    }

    @Override
    protected void paintComponent(Graphics g) {
        super.paintComponent(g);

        g.setColor(Color.WHITE);
        g.fillRect(0, 0, getWidth(), getHeight());

        for (int i = 0; i < gameObjectsArray.length; i++) {
            gameObjectsArray[i].draw(g);
        }
    }

}

我们重写paintComponent 方法以在JPanel 上绘图。由于游戏对象会自己绘制，因此我们在每个游戏对象上调用 draw 方法。

最后我们来看看动画runnable，ObjectsRunnable类。

package com.ggl.moving.squares;

import javax.swing.SwingUtilities;

public class ObjectsRunnable implements Runnable {

    private volatile boolean running;

    private GameObject[] gameObjectsArray;

    private MovingSquares movingSquares;

    public ObjectsRunnable(MovingSquares movingSquares,
            GameObject[] gameObjectsArray) {
        this.movingSquares = movingSquares;
        this.gameObjectsArray = gameObjectsArray;
        this.running = true;
    }

    @Override
    public void run() {
        while (running) {
            updateObjects();
            xxx();
            sleep();
        }
    }

    private void updateObjects() {
        for (int i = 0; i < gameObjectsArray.length; i++) {
            gameObjectsArray[i].move();
        }
    }

    private void xxx() {
        SwingUtilities.invokeLater(new Runnable() {
            @Override
            public void run() {
                movingSquares.repaintMovingPanel();
            }
        });
    }

    private void sleep() {
        try {
            Thread.sleep(200L);
        } catch (InterruptedException e) {
        }
    }

    public synchronized void setRunning(boolean running) {
        this.running = running;
    }

}

这是一个简单的动画或游戏循环。我将重绘调用放在另一个 SwingUtilities 的 invokeLater 方法中，以确保在 EDT 上更新 Swing 组件。

希望对你有帮助。

Answer 2

静态变量在每个运行时只能使用一次。要创建多个 GameObjects，您必须避免使用 static 关键字。

然后多次调用new GameObject() 来创建多个 GameObject 实例，每个实例都有自己的一组变量。

---

编辑：

1. 将变量 strtCoX 和 strtCoY 移动到 GameObject（如 @andrew-thomson 所建议的那样）
2. 修复所有对strtCoX 和strtCoY 的引用在GameObject 内
3. 将g.fillRect(strtCoX, strtCoY, size, size); 更改为for (GameObject currentObject : GameObjectsArray) g.fillRect(currentObject.strtCoX, currentObject.strtCoY, size, size);

说明：坐标是GameObject的属性。每个游戏对象都应该有自己的坐标。

=> 你的代码应该和以前一样工作

4. 删除GameObject中的所有static关键字
5. 将GameObject.move(); 更改为for (GameObject currentObject : GameObjectsArray) currentObject.move();
6. 像这样在public MovingSquares() 构造函数中初始化你的GameObjectArray：for (int i = 0; i < GameObjectsArray.length; i++) GameObjectsArray[i] = new GameObject();

解释：使用new GameObject()，我们创建了 30 个实例（在构造函数内的那个循环中）。因此我们还必须调用move() 30 次（这就是为什么它也嵌套在一个循环中）

=> 戴太阳镜！