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

有没有更好的方法可以对对象数组进行碰撞检测？

1 个答案: