/**
 * Written by Josh Lifton 10MAY2000.
 * Copyright (c) Josh Lifton 2000.
 **/

 import java.awt.*;
 import java.util.*;

 public class Flock {

    /* FIELDS */

    private int numberOfMembers;                    // Number of critters on each team.
    private int numberOfTeams;                      // Number of teams.
    private Vector members;                         // The critters.
    double meanHeading, meanSpeed, meanX, meanY;    // Flock averages.
    double height, width;                           // The world.  (0,0) is in the upper left corner.
    boolean endFlag;                                // Indicates if the fight is over.               
    boolean gameOverFlag;                           // Indicates this flock should be disposed of.
    private long seed;                              // The initial random seed used for this Flock.
    private Random PNG;                             // Pseudo-random Number Generator.

    /* CONSTRUCTOR */

    public Flock(long s, int size, int teams, double h, double w) {
        setSeed(s);
        setNumberOfMembers(size);
        setNumberOfTeams(teams);
        setHeight(h);
        setWidth(w);
        initializeFlock();
    }

    /* METHODS */

    public void moveMembers() {
        Enumeration e = elements();
        Boid boid;
        Color colorSeen = null;
        setEndFlag(true);
        setGameOverFlag(false);
        setMeanHeading(0.0);
        setMeanSpeed(0.0);
        setMeanX(0.0);
        setMeanY(0.0);
        while (e.hasMoreElements()) {
            boid = (Boid) e.nextElement();
            if (getNumberOfTeams() > 1 && getEndFlag()) {
                if (colorSeen == null) {
                    colorSeen = boid.getColor();
                }
                else if (boid.getColor() != colorSeen) {
                    setEndFlag(false);
                }
            }
            boid.senseFlock(this);
            boid.decide();
            boid.move();
            checkBounds(boid);
            addToMomentum(boid);
            setMeanX(getMeanX() + boid.getX());
            setMeanY(getMeanY() + boid.getY());
        }
        setMeanX(getMeanX()/getNumberOfMembers());
        setMeanY(getMeanY()/getNumberOfMembers());
        if (getNumberOfTeams() == 1) {
            setEndFlag(false);
        }
        if (getEndFlag()) {
          setGameOverFlag(true);
        }
    }

    private void checkBounds(Boid boid) {
        if (boid.getX() > width) {
            boid.setX(boid.getX() - width);
        }
        if (boid.getX() < 0) {
            boid.setX(boid.getX() + width);
        }
        if (boid.getY() > height) {
            boid.setY(boid.getY() - height);
        }
        if (boid.getY() < 0) {
            boid.setY(boid.getY() + height);
        }
    }

    private void addToMomentum(Boid b) {
        double x = getMeanSpeed()*Math.cos(getMeanHeading()) + b.getSpeed()*Math.cos(b.getHeading());
        double y = getMeanSpeed()*Math.sin(getMeanHeading()) + b.getSpeed()*Math.sin(b.getHeading());
        double r = Math.sqrt(x*x + y*y);
        double angle = Math.acos(x/r);
        if (y < 0) {
            angle = 2.0*Math.PI - angle;
        }
        setMeanSpeed(r);
        setMeanHeading(angle);
    }

    private double calculateMeanX() {
        Enumeration e = elements();
        double sum = 0;
        while (e.hasMoreElements()) {
            sum = sum + ((Boid) e.nextElement()).getX();
        }
        return sum/numberOfMembers;
    }

    private double calculateMeanY() {
        Enumeration e = elements();
        double sum = 0;
        while (e.hasMoreElements()) {
            sum = sum + ((Boid) e.nextElement()).getY();
        }
        return sum/numberOfMembers;
    }

    /* UTILITY METHODS */

    public void initializeFlock() {
        Color teamColor;
        members = new Vector(numberOfMembers*numberOfTeams);
        for (int team=0; team<getNumberOfTeams(); team++) {
            if (getNumberOfTeams() == 2) {
                if (team == 1) {
                    teamColor = Color.red;
                }
                else {
                    teamColor = Color.black;
                }
            }
            else {
                teamColor = new Color(team*50, team*10, team*50);
            }
            BoidGene gene = new BoidGene(
                             PNG,                           // Pseudo-random Number Generator
                             2*PNG.nextDouble()*Math.PI,    // heading
                             PNG.nextDouble()*10.0 + 2.0,   // speed
                             PNG.nextDouble()*width,        // x position
                             PNG.nextDouble()*height,       // y position
                             12.0,                          // maximum speed
                             2.0,                           // minimum speed
                             teamColor,                     // color
                             0.1,                           // turning rate
                             0.05,                          // acceleration
                             50.0,                          // sensor range
                             10.0,                          // death range
                             0.23109,                       // death constant
                             5.0,                           // collision range
                             1.0,                           // attack constant
                             1.0,                           // retreat constant
                             this);                         // flock
            for (int i=0; i<getNumberOfMembers(); i++) {
                add(new Boid(gene));
            }
        }
        setMeanX(calculateMeanX());
        setMeanY(calculateMeanY());
    }

    public void initializeDuel(BoidGene gene, BoidGene challenger) {
        members = new Vector(numberOfMembers*2);
        for (int i=0; i<getNumberOfMembers(); i++) {
            add(new Boid(gene));
        }
        for (int i=0; i<getNumberOfMembers(); i++) {
            add(new Boid(challenger));
        }
        setMeanX(calculateMeanX());
        setMeanY(calculateMeanY());
    }

    public Enumeration elements() {
        return members.elements();
    }

    public void add(Boid b) {
        members.addElement(b);
    }

    public void remove(Boid b) {
        members.removeElement(b);
    }

    /* GET AND SET METHODS */
                                            
    public void setSeed(long d) {
      if (PNG != null) {
        PNG.setSeed(d);
      }
      else {
        PNG = new Random(d);
      }
    }
    
    public long getSeed() {
      return seed;
    }

    public boolean getGameOverFlag() {return gameOverFlag;}
    public void setGameOverFlag(boolean x) {
        gameOverFlag = x;
    }

    public boolean getEndFlag() {return endFlag;}
    public void setEndFlag(boolean x) {endFlag = x;}

    public int getNumberOfMembers() {return numberOfMembers;}
    public void setNumberOfMembers(int n) {numberOfMembers = Math.abs(n);}

    public int getNumberOfTeams() {return numberOfTeams;}
    public void setNumberOfTeams(int teams) {numberOfTeams = Math.abs(teams);}

    public double getMeanHeading() {return meanHeading;}
    private void setMeanHeading(double heading) {meanHeading=heading;}

    public double getMeanSpeed() {return meanSpeed;}
    private void setMeanSpeed(double speed) {meanSpeed=speed;}

    public double getMeanX() {return meanX;}
    private void setMeanX(double x) {meanX=x;}

    public double getMeanY() {return meanY;}
    private void setMeanY(double y) {meanY=y;}

    public double getHeight() {return height;}
    public void setHeight(double h) {height=Math.abs(h);}

    public double getWidth() {return width;}
    public void setWidth(double w) {width=Math.abs(w);}

 }