Comment animer efficacement plusieurs balles rebondissantes en Java sans se chevaucher ?

Balle rebondissante Java

Problème :

Lorsque vous dessinez plusieurs balles sur l'écran qui rebondissent sur les bords du cadre , la deuxième balle écrase la balle initiale.

Étant donné Code :

Le code fourni tente de dessiner plusieurs balles rebondissantes, mais la deuxième balle écrase la balle initiale.

Avec l'approche actuelle, les problèmes suivants sont présents :

• Les composants opaques sont placés les uns sur les autres.
• Un gestionnaire de mise en page n'est pas spécifié, ce qui affecte le placement des balles.
• Le contrôle de la taille et de l'emplacement de la balle n'est pas géré efficacement.
• La vitesse et l'emplacement des balles ne sont pas aléatoires.
• Les mises à jour du ballon doivent être effectuées dans le contexte de l'EDT.
• Les valeurs X/Y ne sont pas nécessaires, car les panneaux peuvent être utilisé.

Problèmes d'évolutivité avec plusieurs threads :

L'approche actuelle consiste à créer un thread séparé pour chaque balle. Cela peut mettre à rude épreuve les ressources du système, en particulier lorsque le nombre de balles augmente.

Approche alternative :

Au lieu d'utiliser des composants pour chaque balle, envisagez de créer un conteneur pour les balles. et en utilisant une simple boucle d'animation pour mettre à jour leurs positions et les redessiner. Cette approche est plus évolutive.

Mise en œuvre :

Voici une implémentation alternative qui répond aux problèmes mentionnés ci-dessus :

public class AnimatedBalls {

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

    public AnimatedBalls() {
        EventQueue.invokeLater(() -> {
            JFrame frame = new JFrame("Bouncing Balls");
            frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
            frame.setSize(400, 400);
            frame.setVisible(true);

            // Create a container for the balls
            BallsPane ballsPane = new BallsPane();
            frame.add(ballsPane);
        });
    }

    public class BallsPane extends JPanel {

        private List<Ball> balls;

        public BallsPane() {
            balls = new ArrayList<>();

            for (int i = 0; i < 10; i++) {
                Random random = new Random();
                int x = (int) (Math.random() * getWidth());
                int y = (int) (Math.random() * getHeight());
                int vx = (int) (Math.random() * 10) - 5;
                int vy = (int) (Math.random() * 10) - 5;
                Ball ball = new Ball(x, y, vx, vy);
                balls.add(ball);
            }
        }

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

            for (Ball ball : balls) {
                ball.draw(g);
            }
        }

    }

    public class Ball {

        private int x;
        private int y;
        private int vx;
        private int vy;

        public Ball() {
            this(0, 0, 0, 0);
        }

        public Ball(int x, int y, int vx, int vy) {
            this.x = x;
            this.y = y;
            this.vx = vx;
            this.vy = vy;
        }

        public void update() {
            // Bounce off the edges of the frame
            if (x < 0 || x > getWidth())
                vx *= -1;
            if (y < 0 || y > getHeight())
                vy *= -1;

            // Update the ball's position
            x += vx;
            y += vy;
        }

        public void draw(Graphics g) {
            // Draw the ball as a filled circle
            g.setColor(Color.RED);
            g.fillOval(x - 5, y - 5, 10, 10);
        }

    }

}

Dans cette implémentation alternative :

• Une seule boucle d'animation met à jour tous les balles.
• Les balles sont représentées par des structures de données simples (pas des composants).
• La boucle d'animation gère les limites des bords du cadre.
• La randomisation est utilisée pour varier la vitesse de départ et l'emplacement des balles.
• La méthode update() calcule la nouvelle position de chaque balle.
• La méthode draw() rend la balle sous la forme d'un cercle rempli.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!