Processing 处理帮助。尝试创建更多的对象，如我当前已有的对象

我对使用处理是新手，一段时间以来我一直在尝试让一个对象在我的草图上随机移动。我终于完成了那个部分，可以让它随意移动了。唯一的问题是，我需要3个这样的对象，但我只有1个。我尝试使用数组，但没有任何运气。我目前的项目是玩一个游戏，你用箭头键控制一个物体（土耳其），然后把它穿过草图带到房子里去赢。但是在你和房子之间有三个猎人。这3个猎人必须随机移动。我有一个可以随机移动，但现在我还需要两个，我尝试使用数组，但无法让它工作。我的代码可能很混乱，但我现在很困惑

int radius = 30, directionX = 1, directionY = 0;
float x=20, y=20, speed=5;
PImage turkey;

Hunter[] hunters = new Hunter[3];
// =========================================================
void setup()
{
  size(1600,900);
  smooth();
  fill (color(222, 22, 22));
  noStroke();
  ellipseMode(RADIUS);
  turkey = loadImage("Turkey.png");
  random = new Hunter[3];
  random[1] = new Hunter(color(0, 255, 0), 
    (float)(width/444), (float)(height/2), 5f);
}
void draw()
{
  background(255);
  random[1].display();
  random[1].walkRandom();
  // changing Position
  x=x+speed*directionX;
  y=y+speed*directionY; 
  // check boundaries
  if ((x>width-radius) || (x<radius))
  {   
    directionX=-directionX;
  }
  if ((y>height-radius) || (y<radius))
  {   
    directionY=-directionY;
  } 
  // draw
  fill (color(222, 22, 22)); 
  ellipse (x, y, radius, radius);
  imageMode(CENTER);
  image(turkey,x,y);
  // body
}
// =========================================================
void keyPressed()
{
  if (key == CODED)
  {
    if (keyCode == LEFT)
    {
      directionX=-1;
      directionY=0;
    }
    else if (keyCode == RIGHT)
    {  
      directionX=1;
      directionY=0;
    }
    else if (keyCode == UP)
    {
      directionY=-1;
      directionX=0;
    }
    else if (keyCode == DOWN)
    {
      directionY=1;
      directionX=0;
    }
  }
}


////////////////////////////////////


class HunterOne{

  int colour;
  float xPos;
  float yPos;
  float xSpeed;
  float ySpeed;

  HunterOne(int colour, 
    float xPos, float yPos, 
    float xSpeed) {
    this.colour = colour;
    this.xPos = xPos;
    this.yPos = yPos;
    this.xSpeed = xSpeed;
  }

  public void display() {      
    rectMode(CENTER);
    fill(colour);
    ellipse(xPos, yPos, 20, 20);
  }

  public void walkRandom() {

    xPos = xPos + xSpeed;
    yPos = yPos + ySpeed;

    if (xPos > width) {     
      xPos = width;
      PVector newMovment = new PVector(-5f, 0);
      xSpeed = newMovment.x;
      ySpeed = newMovment.y;
    }
    if (yPos > height) {
      yPos = height;
      // PVector newMovment = doTheThingBottom();
      ySpeed = -ySpeed;
    }
    if (xPos < 0) {
      xPos = 0;
      xSpeed = -xSpeed;
    }
    if (yPos < 0) {
      yPos = 0;
      ySpeed = -ySpeed;
    }

    // random turn
    if (random(100)>97) {
      PVector newMovment = doTheThing();
      xSpeed = newMovment.x;
      ySpeed = newMovment.y;
    }
  }

  PVector doTheThing() {

    // random turn

    PVector result=new PVector(0, 0);

    int randomDirection = int (random(4));

    switch(randomDirection) {

    case 0:
      // Up
      result = new PVector(0, -5f);
      break;

    case 1:
      // Left
      result = new PVector(-5f, 0);
      break;

    case 2:
      // Down
      result = new PVector(0, 5f);
      break;

    case 3:
      // Right
      result = new PVector( 5f, 0);
      break;

    default:
      // error 
      println("error 63");
      result = new PVector( 5f, 0);
      break;
    }//switch  

    return result;
  }
} // class 
HunterOne[] random;
public void settings() {
  size(1600, 900);
  smooth();
}

int半径=30，方向X=1，方向Y=0；
浮动x=20，y=20，速度=5；
皮马杰土耳其；
猎人[]猎人=新猎人[3]；
// =========================================================
无效设置（）
{
规模（1600900）；
光滑的（）；
填充（颜色（222,22,22））；
仰泳（）；
椭圆模型（半径）；
turkey=loadImage（“turkey.png”）；
随机=新猎人[3]；
随机[1]=新猎人（颜色（0,255,0），
（浮子）（宽/444），（浮子）（高/2），5f；
}
作废提款（）
{
背景（255）；
随机[1]。显示（）；
random[1]。walkRandom（）；
//换位
x=x+速度*方向x；
y=y+速度*方向y；
//检查边界
如果（（x>宽度半径）| |（xheight半径）| |（y宽度）{
xPos=宽度；
PVector newmove=新PVector（-5f，0）；
xSpeed=newmovement.x；
ySpeed=newmovement.y；
}
如果（yPos>高度）{
yPos=高度；
//PVector newmoment=doTheThingBottom（）；
ySpeed=-ySpeed；
}
如果（xPos<0）{
xPos=0；
xSpeed=-xSpeed；
}
if（yPos<0）{
yPos=0；
ySpeed=-ySpeed；
}
//随机转向
如果（随机（100）>97）{
PVector newmovement=doTheThing（）；
xSpeed=newmovement.x；
ySpeed=newmovement.y；
}
}
PVector doTheThing（）{
//随机转向
PVector结果=新PVector（0,0）；
int randomDirection=int（随机（4））；
开关（随机方向）{
案例0：
//向上
结果=新的PVector（0，-5f）；
打破
案例1：
//左
结果=新的PVector（-5f，0）；
打破
案例2：
//向下
结果=新的PVector（0，5f）；
打破
案例3：
//对
结果=新的PVector（5f，0）；
打破
违约：
//错误
println（“错误63”）；
结果=新的PVector（5f，0）；
打破
}//开关
返回结果；
}
}//类
亨特罗[]随机；
公共无效设置（）{
尺寸（1600900）；
光滑的（）；
}
在处理（java）中，没有操作符创建对象的拷贝。与C++不同，在处理中，如果使用赋值运算符，则它将创建一个<强>引用变量的拷贝，而不是对象< /强> .<
因此，您必须克隆对象，下面是示例（）：

void setup（）{
book book One=新书（《1984年》，《乔治·奥威尔》，1949年）；
bookbooktwo=bookOne.clone（）；
第二册标题为“动物农场”；
第二册：年份=1945年；
//印刷品“1945年乔治·奥威尔出版的动物农场”，这是正确的。
println（bookTwo.title+“by”+bookTwo.author+“发表于”+bookTwo.year）；
//现在还正确地印刷了乔治·奥威尔1949年出版的《1984》
println（bookOne.title+“by”+bookOne.author+“发表于”+bookOne.year）；
}
课堂用书{
字符串标题；
字符串作者；
国际年；
书本（字符串t、字符串a、整数y）{
title=t；
作者=a；
年份=y；
}
书籍克隆（）{
新书=新书（书名、作者、年份）；
归还新书；
}
}
在处理（java）中，没有操作符创建对象的拷贝。与C++不同，在处理中，如果使用赋值运算符，则它将创建一个<强>引用变量的拷贝，而不是对象< /强> .<
因此，您必须克隆对象，下面是示例（）：

void setup（）{
book book One=新书（《1984年》，《乔治·奥威尔》，1949年）；
bookbooktwo=bookOne.clone（）；
第二册标题为“动物农场”；
第二册：年份=1945年；
//印刷品“1945年乔治·奥威尔出版的动物农场”，这是正确的。
println（bookTwo.title+“by”+bookTwo.author+“发表于”+bookTwo.year）；
//现在还正确地印刷了乔治·奥威尔1949年出版的《1984》
println（bookOne.title+“by”+bookOne.author+“发表于”+bookOne.year）；
}
课堂用书{
字符串标题；
字符串作者；
国际年；
书本（字符串t、字符串a、整数y）{
title=t；
作者=a；
年份=y；
}
书籍克隆（）{
新书=新书（书名、作者、年份）；
归还新书；
}
}