Processing 我怎样才能使每个球体之间有一定的距离？

嗨，每次按下键，我都想在随机位置（x、y、z）重新定位对象（球体）。 但我希望他们永远分开。 我怎样才能做到呢？ 对不起，我的问题不清楚。我不会说英语。如果你想的话，我会尽量提供更多的细节

Mover movers[] = new Mover[1000];
Attractor attractors[]=new Attractor[5];

void setup() {
  size(300, 400, P3D);
  for (int i=0; i<attractors.length; i++) {
    attractors[i] = new Attractor(random(0.1, 2), random(0, width), random(0, height), random(-100, 100));
  }
}

void draw() {
  background(255);
  for (int i=0; i<attractors.length; i++) {
    attractors[i].display();
  }
  
}

void keyPressed() {
for (int i=0; i<attractors.length; i++) {
    for (int j=0; j<attractors.length; j++) {
     PVector f = PVector.sub(attractors[i].loc,attractors[j].loc);
    float distance = f.mag();
      if (i!=j) {
        while (true) {
          attractors[j].loc.x = random(0, width);
          attractors[j].loc.y = random(0, height);
          attractors[j].loc.z = 0;
          if (distance>=50) {
            break;
          }    
        }

        println(distance);
      }
    }
  
  }
}

Mover-Mover[]=new-Mover[1000]；
吸引子吸引子[]=新吸引子[5]；
无效设置（）{
尺寸（300、400、P3D）；
对于（int i=0；iPoisson圆盘采样是解决此问题的一种常用技术

泊松圆盘采样产生紧密排列的点，但彼此之间的距离不超过指定的最小距离，从而形成更自然的模式

处理示例：

这是2D（分布圆）技术的一个例子；该技术可以扩展到3D（用于球体分布），尽管它会稍微复杂一些


import java.util.Vector；
导入java.util.LinkedList；
泊松分布点=新的泊松分布（）；
int最小距离=50；
无效设置（）{
大小（800800）；
填充（200、40、80）；
生成（0，0，宽度，高度，最小距离，15）；
}
作废提款（）{
背景（255）；
对于（PVector坐标：points.getPoints（））{
椭圆（坐标x，坐标y，最小距离-10，最小距离-10）；
}
}
按下void键（）{
生成（0，0，宽度，高度，最小距离，15）；
}
类泊松分布
{
/**来自“任意维快速泊松圆盘采样”
*罗伯特·布里森
* http://www.cs.ubc.ca/~rbridson/docs/bridson-siggraph07-poissondisk.pdf
**/
泊松分布（）
{
_点=新向量（）；
}
向量getPoints（）{
返回点；
}
向量生成（float xmin、float ymin、float xmax、float ymax、float minDist、int rejectionLimit）
{
_xmin=xmin；
_xmax=xmax；
_ymin=ymin；
_ymax=ymax；
_大提琴尺寸=minDist/sqrt（2）；
_gridWidth=ceil（（xmax xmin）/_cellSize）；
_gridHeight=细胞（（ymax-ymin）/_细胞大小）；
int s=_gridWidth*_gridHeight；
_grid=newarraylist（）；
对于（int i=0；i 0）
{
inti=floor（随机（processList.size（））；
p=processList.get（i）；
进程列表。删除（i）；
对于（i=0；i=xmin&p.x=ymin&p.yimport java.util.Vector;
import java.util.LinkedList;

PoissonDistribution points = new PoissonDistribution();

int minimumDistance = 50;

void setup() {
  size(800, 800);
  fill(200, 40, 80);
  points.generate(0, 0, width, height, minimumDistance, 15);
}

void draw() {
  background(255);
  for (PVector coord : points.getPoints()) {
    ellipse(coord.x, coord.y, minimumDistance - 10, minimumDistance - 10);
  }
}

void keyPressed() {
  points.generate(0, 0, width, height, minimumDistance, 15);
}

class PoissonDistribution
{
  /** From "Fast Poisson Disk Sampling in Arbitrary Dimensions"
   * by Robert Bridson
   * http://www.cs.ubc.ca/~rbridson/docs/bridson-siggraph07-poissondisk.pdf
   **/

  PoissonDistribution()
  {
    _points = new Vector<PVector>();
  }

  Vector<PVector> getPoints() { 
    return _points;
  }

  Vector<PVector> generate(float xmin, float ymin, float xmax, float ymax, float minDist, int rejectionLimit)
  {
    _xmin = xmin; 
    _xmax = xmax; 
    _ymin = ymin; 
    _ymax = ymax;
    _cellSize = minDist / sqrt(2);
    _gridWidth = ceil((xmax-xmin) / _cellSize);
    _gridHeight = ceil((ymax-ymin) / _cellSize);
    int s = _gridWidth * _gridHeight;
    _grid = new ArrayList<Vector<PVector>>();
    for (int i=0; i<s; i++)
      _grid.add(new Vector<PVector>());

    _points.clear();
    LinkedList<PVector> processList = new LinkedList<PVector>();

    PVector p = new PVector(random(_xmin, _xmax), random(_ymin, _ymax));
    processList.add(p);
    _points.add(p);
    addToGrid(p);

    while (processList.size() > 0)
    {
      int i = floor(random(processList.size()));
      p = processList.get(i);
      processList.remove(i);
      for (i=0; i<rejectionLimit; i++)
      {
        PVector n = createRandomPointAround(p, minDist, minDist*2);
        if (insideBoundaries(n) && testGrid(n, minDist)) {
          processList.add(n);
          _points.add(n);
          addToGrid(n);
        }
      }
    }

    return _points;
  }

  private boolean insideBoundaries(PVector p)
  {
    return (p.x >= _xmin && p.x < _xmax && p.y >= _ymin && p.y < _ymax);
  }

  private PVector createRandomPointAround(PVector p, float minDist, float maxDist)
  {
    float a = random(2*PI);
    float r = random(minDist, maxDist);
    return new PVector(p.x + r * cos(a), p.y + r * sin(a));
  }

  // return true if there are no points inside the circle of minDist radius around p
  private boolean testGrid(PVector p, float minDist)
  {
    int minX = floor(max(0, (p.x - minDist - _xmin) / _cellSize));
    int maxX = ceil(min(_gridWidth - 1, (p.x + minDist - _xmin) / _cellSize));
    int minY = floor(max(0, (p.y - minDist - _ymin) / _cellSize));
    int maxY = ceil(min(_gridHeight - 1, (p.y + minDist - _ymin) / _cellSize));

    for (int y=minY; y<=maxY; y++) {
      for (int x=minX; x<=maxX; x++) {
        Vector<PVector> cell = _grid.get(y * _gridWidth + x);
        for (PVector t : cell)
          if (dist(p.x, p.y, t.x, t.y) <= minDist)
            return false;
      }
    }

    return true;
  }

  private void addToGrid(PVector p)
  {
    _grid.get(index(p.x, p.y)).add(p);
  }

  protected int index(float x, float y)
  {
    int gx = floor((x - _xmin) / _cellSize);
    int gy = floor((y - _ymin) / _cellSize);
    return gy * _gridWidth + gx;
  }

  private ArrayList<Vector<PVector>> _grid;
  private float _cellSize;
  private int _gridWidth, _gridHeight;
  private float _xmin, _xmax, _ymin, _ymax;
  private Vector<PVector> _points;
}