private void RunScript(List<On3dPoint> P, List<On3dVector> D, double W, double L, double H, int S, ref object B_Loc, ref object B_Dir)
  {
    Print("Number of Flocking Boids:{0}\n\n", P.Count);
    if(P.Count != D.Count) return;

    // Add an initial set of boids into the system
    if(flock == null)
    {
      Print("Flock is null");
      flock = new Flock();
      for (int i = 0; i < P.Count; i++)
      {
        flock.addBoid(new Boid(P[i], D[i], 50.0, 5, W, L, H));
      }
    }

    flock.run();

    B_Loc = flock.getBoidsLocs();
    B_Dir = flock.getBoidsDirs();

  }

  Flock flock = null;// = new Flock();
  static public Random ran = new Random();

  public class Boid
  {
    public On3dPoint loc;
    public On3dVector vel;
    On3dVector acc;
    double r;
    double maxforce;    // Maximum steering force
    double maxspeed;    // Maximum speed
    double width;
    double length;
    double height;

    public Boid(On3dPoint lc, On3dVector v, double mf, double ms, double wd, double len, double ht)
    {
      loc = lc;
      acc = new On3dVector(0, 0, 0);
      vel = v;
      r = 2.0;
      maxforce = mf;
      maxspeed = ms;
      width = wd;
      length = len;
      height = ht;
    }

    public void run(List<Boid> boids) {
      flock(boids);
      update();
      borders();
    }

    // We accumulate a new acceleration each time based on three rules
    void flock(List<Boid> boids)
    {
      On3dVector sep = separate(boids);   // Separation
      On3dVector ali = align(boids);      // Alignment
      On3dVector coh = cohesion(boids);   // Cohesion

      // Arbitrarily weight these forces
      //sep.mult(1.5); ali.mult(1.0); coh.mult(1.0);
      sep *= (1.5);
      ali *= (1 );
      coh *= (1 );

      // Add the force vectors to acceleration
      acc += (sep);
      acc += (ali);
      acc += (coh);
    }

    // Method to update location
    void update() {
      // Update velocity
      vel += (acc);

      // Limit speed
      if(vel.Length() > maxspeed)// Limit to maximum steering force
      {
        vel.Unitize();
        vel *= maxspeed;
      }

      loc += (vel);
      // Reset accelertion to 0 each cycle
      acc *= (0);
    }

    // Wraparound
    void borders() {
      if (loc.x < -r) loc.x = width + r;
      if (loc.y < -r) loc.y = length + r;
      if( loc.z < -r) loc.z = height + r;
      if (loc.x > width + r) loc.x = -r;
      if (loc.y > length + r) loc.y = -r;
      if( loc.z > height + r) loc.z = -r;
    }

    void render()
    {

    }

    // Separation
    // Method checks for nearby boids and steers away
    public On3dVector separate(List<Boid> boids)
    {
      double desiredseparation = 10.0;//20.0;
      On3dVector steer = new On3dVector(0, 0, 0);
      int count = 0;
      // For every boid in the system, check if it's too close
      foreach( Boid b in boids)
      {
        double d = loc.DistanceTo(b.loc);
        if((d > 0) && (d < desiredseparation))
        {
          // Calculate vector pointing away from neighbor
          On3dVector diff = loc - b.loc;
          diff.Unitize();
          diff /= d; // Weight by distance

          steer += diff;
          count++;
        }
      }

      if (count > 0) {
        steer /= count;
      }

      // As long as the vector is greater than 0
      if (steer.Length() > 0) {
        // Implement Reynolds: Steering = Desired - Velocity
        steer.Unitize();
        steer *= maxspeed;
        steer -= vel;

        if(steer.Length() > maxforce)// Limit to maximum steering force
        {
          steer.Unitize();
          steer *= maxforce;
        }
      }

      return steer;
    }