Plusieurs graphiques mobiles dans Java JFrame

Les variables statiques ne seront disponibles qu'une seule fois par Runtime. Pour créer plusieurs GameObject, vous devez éviter les static mots clés.

Puis appelez new GameObject() plusieurs fois pour créer des instances serveral de GameObject, chacune avec son propre ensemble de variables.

Modifier:

1. déplacer les variables strtCoX et strtCoY dans GameObject (comme suggéré par @andrew thomson )
2. corriger toutes les références à strtCoX et strtCoY à l'intérieur de GameObject
3. changer g.fillRect(strtCoX, strtCoY, size, size); en for (GameObject currentObject : GameObjectsArray) g.fillRect(currentObject.strtCoX, currentObject.strtCoY, size, size);

Explication: Les coordonnées sont des attributs de GameObject. Chaque GameObject doit avoir ses propres coordonnées.

=> Votre code devrait fonctionner comme avant

1. supprimer tous les mots-clés static dans GameObject
2. remplacer GameObject.move(); par for (GameObject currentObject : GameObjectsArray) currentObject.move();
3. initialisez votre GameObjectArray dans public MovingSquares() constructeur comme ceci: for (int i = 0; i < GameObjectsArray.length; i++) GameObjectsArray[i] = new GameObject();

Explication: avec new GameObject() nous créons 30 instances (dans cette boucle à l'intérieur du constructeur). Par conséquent nous avons également pour appeler move() 30 fois (et c'est pourquoi cela est également imbriqué dans une boucle)

=> Portez des lunettes de soleil!

Voici une version de Moving Squares qui, espérons-le, vous aidera à comprendre comment faire une animation.

L'une des premières choses que j'ai faites a été de séparer les classes en une classe model, une classe view ou une classe controller. Le modèle modèle / vue / contrôleur aide à séparer les préoccupations.

Regardons la version révisée de votre classe model, la classe 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;
    }
}

Il ne reste qu'un seul champ statique, la taille du carré. Tout le reste est une variable ou une méthode dynamique. Cela nous permet de créer plus d'une instance du GameObject.

J'ai changé le nom de la méthode de dessin de peinture pour dessiner. C'est pour que nous ne soyons pas confus quant aux méthodes qui sont des méthodes Swing, et quelles méthodes sont nos méthodes.

Nous passons la largeur du panneau de dessin dans le constructeur. De cette façon, nous n'avons qu'à définir la largeur en un seul endroit. Vous pouvez voir dans la méthode move que nous autorisons une marge taille du carré dans la zone de dessin.

Le constructeur définit une position initiale aléatoire et une vitesse initiale. La méthode de déplacement maintient simplement le carré en mouvement en ligne droite.

Ensuite, regardons la version révisée de votre classe principale, la classe 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());
    }
}

Nous définissons ici la largeur du panneau de dessin, ainsi qu'un tableau pour contenir les objets du jeu.

Nous démarrons l'application Swing sur le Event Dispatch thread (EDT) en invoquant la méthode SwingUtilities invokeLater. Une application Swing doit toujours démarrer sur l'EDT.

Nous créons les objets de jeu dans le constructeur et créons les composants Swing dans la méthode run. J'ai déplacé le panneau de dessin dans sa propre classe, dont nous parlerons plus tard.

Nous utilisons un écouteur de fenêtre afin que nous puissions arrêter le thread lorsque nous avons terminé avec l'application.

Nous emballons le JFrame. Le seul endroit où nous spécifions une taille est lorsque nous créons le panneau de dessin. Nous utilisons un JFrame. La seule fois où vous étendez un composant Swing, ou une classe Java, est lorsque vous souhaitez remplacer l'une des méthodes.

Regardons la classe drawing panel, la classe 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);
        }
    }

}

Nous remplaçons la méthode paintComponent pour dessiner sur le JPanel. Puisque les objets du jeu se dessinent eux-mêmes, nous appelons la méthode draw sur chaque objet du jeu.

Enfin, regardons l'animation runnable, la classe 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;
    }

}

Ceci est une animation simple ou boucle de jeu. J'ai mis l'appel repaint dans une autre méthode SwingUtilities invokeLater pour m'assurer que les composants Swing sont mis à jour sur l'EDT.

J'espère que cela vous a été utile.