Ejemplo n.º 1
0
  public int compare(Particle p1, Particle p2) {
    float val1 = PVector.dist(p1.pos, arbitraryPos);
    float val2 = PVector.dist(p2.pos, arbitraryPos);

    if (val1 < val2) {
      return -1;
    }
    if (val1 > val2) {
      return 1;
    }
    return 0;
  }
    public void avoid(ArrayList obstacles) {

      // Make a vector that will be the position of the object
      // relative to the Boid rotated in the direction of boid's velocity
      PVector closestRotated = new PVector(sight + 1, sight + 1);
      float closestDistance = 99999;
      Obstacle avoid = null;

      // Let's look at each obstacle
      for (int i = 0; i < obstacles.size(); i++) {
        Obstacle o = (Obstacle) obstacles.get(i);

        float d = PVector.dist(loc, o.loc);
        PVector dir = vel.get();
        dir.normalize();
        PVector diff = PVector.sub(o.loc, loc);

        // Now we use the dot product to rotate the vector that points from boid to obstacle
        // Velocity is the new x-axis
        PVector rotated = new PVector(diff.dot(dir), diff.dot(getNormal(dir)));

        // Is the obstacle in our path?
        if (PApplet.abs(rotated.y) < (o.radius + r)) {
          // Is it the closest obstacle?
          if ((rotated.x > 0) && (rotated.x < closestRotated.x)) {
            closestRotated = rotated;
            avoid = o;
          }
        }
      }

      // Can we actually see the closest one?
      if (PApplet.abs(closestRotated.x) < sight) {

        // The desired vector should point away from the obstacle
        // The closer to the obstacle, the more it should steer
        PVector desired =
            new PVector(closestRotated.x, -closestRotated.y * sight / closestRotated.x);
        desired.normalize();
        desired.mult(closestDistance);
        desired.limit(maxspeed);
        // Rotate back to the regular coordinate system
        rotateVector(desired, vel.heading2D());

        // Draw some debugging stuff
        if (debug) {
          stroke(0);
          line(loc.x, loc.y, loc.x + desired.x * 10, loc.y + desired.y * 10);
          avoid.highlight(true);
        }

        // Apply Reynolds steering rules
        desired.sub(vel);
        desired.limit(maxforce);
        acc.add(desired);
      }
    }
Ejemplo n.º 3
0
  // TODO: passar métodos de comer para métodos nas classes correspondentes!!
  // método para consumir comida! diferente de caçar comida!!
  void eat(ArrayList<Food> theFood) {
    for (Food f : theFood) {
      float d = PVector.dist(bodyCopy.loc, f.loc);
      if (d < 20) {
        // TODO: implementar métodos de parar para comer, (é uma
        // decisão).

      }
    }
  }
Ejemplo n.º 4
0
  // se outro é predator
  public void beHunted(ArrayList<Creature> creatures) {
    for (Creature other : creatures) {
      float d = PVector.dist(loc, other.loc);

      if (((d > 0) && (d < 40)) && (other.isPredator == true && isPredator == false)) {
        if (other.isHunting) {
          fight(other);
          bodyCopy.fleeFromEnemy(other);
        }
      }
    }
  }
  public void draw() {
    /*---Update---*/
    world.update();
    worm.update();
    for (int i = 0; i < extraNum; i++) {
      extraWorms[i].update();
    }

    /*---Draw--*/
    // Lights
    lights();
    /*
    ambientLight(128f, 128f, 128f);
    directionalLight(128f, 128f, 128f, 0f, 0f, -1f);
    lightFalloff(1f, 0f, 0f);
    lightSpecular(0f, 0f, 0f);
    */

    // Camera
    perspective(fov, aspect, near, far);
    // Calculate camera position
    if (PVector.dist(worm.getPosition(), eye) > eyeDist) {
      eye = PVector.sub(eye, worm.getPosition());
      eye.normalize();
      eye.mult(eyeDist);
      eye.add(worm.getPosition());
    }
    camera(
        eye.x,
        eye.y,
        eye.z, // eyeX, eyeY, eyeZ (camera position)
        worm.getPosition().x,
        worm.getPosition().y,
        worm.getPosition().z, // centerX, centerY, centerZ (look at)
        0f,
        1f,
        0f); // upX, upY, upZ

    // Action
    world.draw();
    worm.draw();
    for (int i = 0; i < extraNum; i++) {
      extraWorms[i].draw();
    }
    // Drama!
  }
Ejemplo n.º 6
0
  private void calcCam(boolean is3D) {
    if (rotVector.mag() != 0 || panVector.mag() != 0 || camDist != prevCamDist) {
      prevCamDist = camDist;
      camRot += rotVector.x;
      if ((camPitch + rotVector.y) < 0.99 && (camPitch + rotVector.y) > 0.01)
        camPitch += rotVector.y;
      if (is3D) {
        PVector camPan =
            new PVector(
                (panVector.x * (float) Math.sin(Math.PI * 0.5 + (Math.PI * camRot)))
                    + (panVector.y * (float) Math.sin(Math.PI * 1.0 + (Math.PI * camRot))),
                (panVector.y * (float) Math.cos(Math.PI * 1.0 + (Math.PI * camRot)))
                    + (panVector.x * (float) Math.cos(Math.PI * 0.5 + (Math.PI * camRot))));
        camPan.mult(0.05f * PVector.dist(camPos, camCenter));
        camCenter.x += camPan.x;
        camCenter.y += camPan.y;
        camPan.x = 0;
        camPan.y = 0;
      } else {
        camCenter.x -= 0.05f * (camPos.z - camCenter.z) * panVector.x;
        camCenter.y += 0.05f * (camPos.z - camCenter.z) * panVector.y;
      }
      panVector.x = 0;
      panVector.y = 0;
      rotVector.x = 0;
      rotVector.y = 0;

      camPos.x =
          camCenter.x
              - camDist * (float) Math.sin(Math.PI * camRot) * (float) Math.sin(Math.PI * camPitch);
      camPos.y =
          camCenter.y
              - camDist * (float) Math.cos(Math.PI * camRot) * (float) Math.sin(Math.PI * camPitch);
      camPos.z = camCenter.z - camDist * (float) Math.cos(Math.PI * camPitch);
    }
  }
Ejemplo n.º 7
0
 public void setPositions(PVector pos1, PVector pos2) {
   this.pos1 = pos1;
   this.pos2 = pos2;
   this.height = pos1.dist(pos2);
 }