有没有传递对象的磁盘阵列上执行碰撞检测一个更好的方式？ [关闭]

Question

所以我使用Java（处理），我有对象的数组，我需要他们做能够与自己发生碰撞，但我也不太清楚如何有效地做到这一点。我做的一个基本方式，但它写得很糟糕，并且不允许对一个动态数组。

我现在有一个静态数组，但我想在未来充满动力。我目前运行的检测通过检查每个可能的组合碰撞的方法。总是会有3个对象，是不是有可能存在永远是小于3。

这里是我的代码：

Circle[] arrayOfCircles = new Circle[3]; //declare array

void setup() {

  size(1000, 1000);

  for (int i = 0; i < arrayOfCircles.length; i++) {
    createPuck(i);
  } // creates objects

}

void createPuck(int i) {

  float speedY;
  float speedX;

  if (tempSpeedX == 0 && tempSpeedY == 0) {
    speedY = createSpeedY();
    speedY = speedY * multiplier;
    speedX = 3 * multiplier;
  } else {
    speedX = tempSpeedX;
    speedY = tempSpeedY;
    tempSpeedX = 0;
    tempSpeedY = 0;
  }
  arrayOfPucks[i] = new Puck(width, int(random(0, height)), speedX, speedY);
}

int createSpeedY() {

  int tempSpeed = int(random(-3, 3));

  do {
    if (tempSpeed == 0) {
      tempSpeed = int(random(-3, 3));
    }
  } while (tempSpeed == 0);

  return tempSpeed;
}

void draw() {
  detectCollisions();
}

void detectCollisions() {
  for (int i = 0; i < arrayOfCircles.length; i++) {

    boolean collision = false;

    if (i==0) {

      collision = arrayOfCircles[i].detectCollision(arrayOfCircles[i+1]);

      if (collision == true) {
        arrayOfCircles[i].bounce(arrayOfCircles[i+1]);
      }

      collision = arrayOfCircles[i].detectCollision(arrayOfCircles[i+2]);

      if (collision == true) {
        arrayOfCircles[i].bounce(arrayOfCircles[i+2]);
      }
    } else if (i==1) {

      collision = arrayOfCircles[i].detectCollision(arrayOfCircles[i-1]);

      if (collision == true) {
        arrayOfCircles[i].bounce(arrayOfCircles[i-1]);
      }

      collision = arrayOfCircles[i].detectCollision(arrayOfCircles[i+1]);

      if (collision == true) {
        arrayOfCircles[i].bounce(arrayOfCircles[i+1]);
      }
    } else if (i==2) {

      collision = arrayOfCircles[i].detectCollision(arrayOfCircles[i-1]);

      if (collision == true) {
        arrayOfCircles[i].bounce(arrayOfCircles[i-1]);
      }

      collision = arrayOfCircles[i].detectCollision(arrayOfCircles[i-2]);

      if (collision == true) {
        arrayOfCircles[i].bounce(arrayOfCircles[i-2]);
      }
    } // end of if
  } // end of for loop
} // end of function

class Circle {

  float x, y;
  float speedX, speedY;
  final int radius = 10;

  Circle(float x, float y, float speedX, float speedY) {
    this.x = x;
    this.y = y;

    this.speedX = speedX;
    this.speedY = speedY;
  }
  // constructor

  void move() {
    this.x = this.x-speedX; //move left
    this.y = this.y-speedY;
  }

  //methods
  void render() {
    fill(0);
    ellipse(this.x, this.y, this.radius, this.radius);
  }

  void bounce() {
    this.speedX = this.speedX * -1;
    this.speedY = this.speedY * -1;
  }

  boolean detectSelfCollision(Puck other) {
    for (int i = 0; i == 2; i++) {
    }
    float distX = this.x - other.x;
    float distY = this.y - other.y;
    float distance = sqrt( (distX*distX) + (distY*distY) );

    if (distance <= radius*2) {
      return true;
    } else {
      return false;
    }
  }
}

该代码不工作的，因为它不会是我想要什么，但它，但它是不是很整齐，有很多重复的，是不是很扩展。

任何建议或帮助，将不胜感激，我甚至可以重新创建基于伪代码的任何建议。我只是打砖墙这里。

Answer 1

你detectCollisions()方法可以改写：

public void detectCollisions() {
    for (int i = 0; i < circles.length; i++)
        for (int j = 0; j < circles.length; j++)
            if (i != j && circles[i].detectCollision(circles[j]))
                circles[i].bounce(circles[j]);
}