java - Java JFrame 中的多个移动图形

Question

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

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();
    }
}

第二个接口(interface) - 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

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

我做的第一件事就是将类分成模型类、 View 类或 Controller 类。 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 方法中看到，我们允许在绘图区域中留出正方形大小的边距。

构造函数定义了一个随机的初始位置和初始速度。 th 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());
    }
}

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

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

我们在构造函数中创建游戏对象，并在运行方法中创建 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 方法。

最后，我们来看一下动画可运行对象，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 方法中，以确保 Swing 组件在 EDT 上更新。

希望对您有所帮助。