Как рисовать несколько объектов, которые перемещаются с разных скоростей в Java?

Question

Я работаю над домашним заданием для класса, и его поздно, потому что я не могу понять материал, несмотря на все исследования, которые я делаю. Я новичок и не знаю много на пути к java. Кроме того, это мой первый пост, поэтому, пожалуйста, прощайте, когда вы читаете это.

Я основываюсь на исходном тексте из моего учебника, который я недавно обновил для прошлой домашней работы, но теперь я пытаюсь создать класс, который рисует несколько квадратов и перемещает эти объекты независимо и с разной скоростью. Им все также придется отскакивать от стен. Я выполнил инструкции и создал два массива, которые будут содержать случайные значения x и y от 1 до 10. Однако я борюсь с массивами, и я уверен, что я делаю это неправильно. Итак, я хотел бы получить некоторую обратную связь, чтобы узнать, правильно ли я настроил ее.

У меня есть jpanel, подтягивающий и рисующий, и до тех пор, пока есть 1 квадрат, он отлично работает, отскакивая от стен, но все меняется, когда я рисую больше одного. Не двигайтесь самостоятельно, и они также имеют одинаковую скорость. Некоторые даже время от времени исчезают. Это действительно меня отбросило. Я ценю любую помощь!

Вкратце, я пытаюсь нарисовать новые квадраты, которые все перемещаются в разных направлениях и на разных скоростях. В соответствии с инструкциями мы предполагаем создание и использование двух массивов, которые обрабатывают значения x и y.

Вот то, что я до сих пор:

public class DotsPanel extends JPanel 
{ 
private int delay = 15; 
private final int SIZE = 7, IMAGE_SIZE = 3; // radius of each dot 
private Timer timer; 
private int x, y, i; 
private ArrayList<Point> pointList; 
static int [] xarray = new int [1000]; 
static int [] yarray = new int [1000]; 
Random rand = new Random(); 
    //----------------------------------------------------------------- 
    // Constructor: Sets up this panel to listen for mouse events. 
    //----------------------------------------------------------------- 
    public DotsPanel() 
    { 
     pointList = new ArrayList<Point>(); 
     int [] xarray = new int [1000]; 
     int [] yarray = new int [1000]; 

     timer = new Timer(delay, new ReboundListener()); 
     addMouseListener (new DotsListener()); 
     addMouseMotionListener (new DotsListener()); 

     setBackground(Color.gray); 
     setPreferredSize(new Dimension(700, 500)); 
     for(int i = 0; i < xarray.length; i++) 
     { 
     xarray[i] = rand.nextInt(7); 
     yarray[i] = rand.nextInt(7); 
     } 
     timer.start();   
    } 

    //----------------------------------------------------------------- 
    // Draws all of the dots stored in the list. 
    //----------------------------------------------------------------- 
    public void paintComponent(Graphics page) 
    { 
     super.paintComponent(page); 
     page.setColor(Color.BLUE); 

     for (Point spot : pointList) 
     { 
     page.fillRect(spot.x-SIZE, spot.y-SIZE, 25, 25); 
     page.drawString("Count: " + pointList.size(), 5, 15); 
     } 
    } 



//***************************************************************** 
    // Represents the listener for mouse events. 
    //***************************************************************** 
    private class DotsListener implements MouseListener, MouseMotionListener 
    { 
     //-------------------------------------------------------------- 
     // Adds the current point to the list of points and redraws 
     // the panel whenever the mouse button is pressed. 
     //-------------------------------------------------------------- 
     public void mousePressed(MouseEvent event) 
     { 
      pointList.add(event.getPoint());  
      repaint(); 
     } 
     public void mouseDragged(MouseEvent event) 
     { 
     // initially I had two xarray and yarray in here just like in 
     // mouseClicked 
     // but it did not change anything when removed 
     } 
     //-------------------------------------------------------------- 
     // Provide empty definitions for unused event methods. 
     //-------------------------------------------------------------- 
     public void mouseClicked(MouseEvent event) 
     { 
      xarray[i] = rand.nextInt(7); 
      yarray[i] = rand.nextInt(7);    
     } 
     public void mouseReleased(MouseEvent event) {} 
     public void mouseEntered(MouseEvent event) {} 
     public void mouseExited(MouseEvent event) {} 
     public void mouseMoved(MouseEvent e) {} 
    } 
    private class ReboundListener implements ActionListener 
    { 
     //-------------------------------------------------------------- 
     // Updates the position of the image and possibly the direction 
     // of movement whenever the timer fires an action event. 
     //-------------------------------------------------------------- 
     public void actionPerformed(ActionEvent event) 
     { 


      for (Point spot : pointList) 
      { 
       spot.x += xarray[i]; 
       spot.y += yarray[i]; 
       if (spot.x <= 0 || spot.x >= 700) 
        xarray[i] = xarray[i] * -1; 
       if (spot.y <= 0 || spot.y >= 500) 
        yarray[i] = yarray[i] * -1; 
       repaint(); 
      } 
     } 
    } 
} 

Answer 1

Однако, я борюсь с массивами, и я уверен, что я не делаю это правильно.

Я бы не использовал Массивы.

Вместо этого, объект Ball управляет своим собственным состоянием. Тогда вы можете иметь разные цвета, скорость, размер и т. Д. Для каждого Ball. Затем, когда срабатывает Timer, вы просто вычисляете новое положение и перекрашиваете Ball.

Вот пример, чтобы вы начали:

import java.awt.*; 
import java.awt.event.*; 
import java.awt.image.*; 
import java.util.*; 
import javax.swing.*; 
import javax.swing.Timer; 

public class BallAnimation4 
{ 
    private static void createAndShowUI() 
    { 
     BallPanel panel = new BallPanel(500); 

     JFrame frame = new JFrame("BallAnimation4"); 
     frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE); 
     frame.setExtendedState(JFrame.MAXIMIZED_BOTH); 
     frame.add(panel); 
     frame.pack(); 
     frame.setVisible(true); 

     panel.startAnimation(); 
    } 

    public static void main(String[] args) 
    { 
     EventQueue.invokeLater(new Runnable() 
     { 
      public void run() 
      { 
       createAndShowUI(); 
      } 
     }); 
    } 

    static class BallPanel extends JPanel implements ActionListener 
    { 
     private ArrayList<Ball> balls = new ArrayList<Ball>(); 

     public BallPanel(int ballCount) 
     { 
      Dimension screenSize = Toolkit.getDefaultToolkit().getScreenSize(); 

      setLayout(null); 
      setBackground(Color.BLACK); 

      Random random = new Random(); 

      for (int i = 0; i < ballCount; i++) 
      { 
       Ball ball = new Ball(); 
       ball.setRandomColor(true); 
       ball.setLocation(random.nextInt(screenSize.width), random.nextInt(screenSize.height)); 
       ball.setMoveRate(32, 32, 1, 1, true); 
       ball.setSize(32, 32); 
       balls.add(ball); 
      } 
     } 

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

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

     public void startAnimation() 
     { 
      Timer timer = new Timer(75, this); 
      timer.start(); 
     } 

     public void actionPerformed(ActionEvent e) 
     { 
      move(); 
      repaint(); 
     } 

     private void move() 
     { 
      for (Ball ball : balls) 
      { 
       ball.move(this); 
      } 
     } 
    } 

    static class Ball 
    { 
     public Color color = Color.BLACK; 

     public int x = 0; 
     public int y = 0; 
     public int width = 1; 
     public int height = 1; 

     private int moveX = 1; 
     private int moveY = 1; 
     private int directionX = 1; 
     private int directionY = 1; 
     private int xScale = moveX; 
     private int yScale = moveY; 

     private boolean randomMove = false; 
     private boolean randomColor = false; 
     private Random myRand = null; 

     public Ball() 
     { 
      myRand = new Random(); 
      setRandomColor(randomColor); 
     } 

     public void move(JPanel parent) 
     { 
      int iRight = parent.getSize().width; 
      int iBottom = parent.getSize().height; 

      x += 5 + (xScale * directionX); 
      y += 5 + (yScale * directionY); 

      if (x <= 0) 
      { 
       x = 0; 
       directionX *= (-1); 
       xScale = randomMove ? myRand.nextInt(moveX) : moveX; 
       if (randomColor) setRandomColor(randomColor); 
      } 

      if (x >= iRight - width) 
      { 
       x = iRight - width; 
       directionX *= (-1); 
       xScale = randomMove ? myRand.nextInt(moveX) : moveX; 
       if (randomColor) setRandomColor(randomColor); 
      } 

      if (y <= 0) 
      { 
       y = 0; 
       directionY *= (-1); 
       yScale = randomMove ? myRand.nextInt(moveY) : moveY; 
       if (randomColor) setRandomColor(randomColor); 
      } 

      if (y >= iBottom - height) 
      { 
       y = iBottom - height; 
       directionY *= (-1); 
       yScale = randomMove ? myRand.nextInt(moveY) : moveY; 
       if (randomColor) setRandomColor(randomColor); 
      } 
     } 

     public void draw(Graphics g) 
     { 
      g.setColor(color); 
      g.fillOval(x, y, width, height); 
     } 

     public void setColor(Color c) 
     { 
      color = c; 
     } 

     public void setLocation(int x, int y) 
     { 
      this.x = x; 
      this.y = y; 
     } 

     public void setMoveRate(int xMove, int yMove, int xDir, int yDir, boolean randMove) 
     { 
      this.moveX = xMove; 
      this.moveY = yMove; 
      directionX = xDir; 
      directionY = yDir; 
      randomMove = randMove; 
     } 

     public void setRandomColor(boolean randomColor) 
     { 
      this.randomColor = randomColor; 

      switch (myRand.nextInt(3)) 
      { 
       case 0: color = Color.BLUE; 
         break; 
       case 1: color = Color.GREEN; 
         break; 
       case 2: color = Color.RED; 
         break; 
       default: color = Color.BLACK; 
         break; 
      } 
     } 

     public void setSize(int width, int height) 
     { 
      this.width = width; 
      this.height = height; 
     } 
    } 

} 

Поскольку ваши Массивы содержат только точку, которую вы хотите, чтобы нарисовать у вас нет никакой информации о скорости каждая точка должна быть перемещена в. Лучшее, что вы могли бы сделать, это создать случайную сумму, которую каждая точка должна перемещать каждый раз при изменении ее местоположения. Это будет приводить к неустойчивому движению, так как каждый раз, когда вы перемещаете точку, расстояние будет случайным.

Если вам нужна более постоянная скорость, вам нужно будет создать второй массив, чтобы содержать расстояние, которое каждая точка должна перемещать каждый раз.

Это начинает запутываться, создавая новый массив каждый раз, когда вы хотите, чтобы новое свойство было уникальным для объекта, который вы хотите рисовать. Вот почему подход к созданию пользовательского объекта с несколькими свойствами проще в управлении.