/**             
 * Written by Josh Lifton 31JUL2002.
 * Adapted from code written on 10MAY2000.
 * Copyright (c) Josh Lifton 2000-2002.
 * GUI for duelling flocks of boids.
 *
 */

import java.applet.*;
import java.awt.*;
import java.awt.event.*;
import java.util.*;

public class BoidDuel extends Applet 
  implements Runnable, ActionListener, AdjustmentListener, ComponentListener, WindowListener {
                                      
  private static final int SCROLLBARVISIBLE = (int) (0.2*Integer.MAX_VALUE);
  private static final int SCROLLBARMAX = Integer.MAX_VALUE - SCROLLBARVISIBLE;
  private static final Color TEAM1COLOR = Color.black;
  private static final Color TEAM2COLOR = Color.red;
  public Frame frame;
  private Thread thread;
  public boolean pauseFlag, replayFlag;
  public Flock flock;
  public Panel team1Panel, team2Panel, arenaPanel, controlPanel;
  private Button pauseButton, resetButton, random1Button, random2Button, replayButton;
  private Scrollbar turnAngle1, turnAngle2, 
                    acceleration1, acceleration2, 
                    sensorRange1, sensorRange2,
                    collisionRange1, collisionRange2, 
                    attackConstant1, attackConstant2,
                    retreatConstant1, retreatConstant2;
  private Label turnAngle1Label, turnAngle2Label, 
                    acceleration1Label, acceleration2Label, 
                    sensorRange1Label, sensorRange2Label,
                    collisionRange1Label, collisionRange2Label, 
                    attackConstant1Label, attackConstant2Label,
                    retreatConstant1Label, retreatConstant2Label,
                    timeLabel, team1Label, team2Label;
  private int time = 0;    
  public int width = 800;
  public int height = 600;
  private int boidsPerTeam = 30;
  private int numberOfTeams = 2;
  private int team1Wins = 0;
  private int team2Wins = 0;          
  private String startString = "Start";
  private String pauseString = "Pause";
  private String resumeString = "Resume";
  
  private Locale[] supportedLocales = {Locale.US, Locale.JAPAN};
  
  private long seed;

  /** Method called when used as an application. */
  public static void main(String args[]) {
    BoidDuel boidDuel = new BoidDuel();
    boidDuel.frame = new Frame("Boid Duel");
    boidDuel.init();
  }

  
  public void init() {                  
                   
    /*
     * Set random seed.
     */
    setSeed(System.currentTimeMillis());
  
    /*
     * Determine what language to use.
     */                                   
    String resourceBundleName = getClass().getName() + "RB";
    Locale applicationLocale = supportedLocales[0];
    for (int i=0; i<supportedLocales.length; i++) {    
      if (Locale.getDefault().equals(supportedLocales[i])) {
        applicationLocale = supportedLocales[i];
        break;
      }
    }
                              
    if (frame != null) {     
      frame.setSize(width, height); 
      frame.setResizable(false);
      Insets i = frame.getInsets();
      height -= i.top + i.bottom;
      width -= i.left + i.right;
    }
  
    setLayout(new BorderLayout());
    setSize(width, height);
    setBackground(new Color(99,44,99));
    setForeground(Color.yellow);        

    controlPanel = new Panel();
    controlPanel.setSize(width, 100);
    controlPanel.setLayout(new GridLayout(1,3));
    controlPanel.setBackground(getBackground());
    controlPanel.setForeground(getForeground());        
    pauseButton = makeButton(startString, controlPanel);
    resetButton = makeButton("Reset", controlPanel);
    replayButton = makeButton("Replay", controlPanel);
    timeLabel = makeLabel("Time", controlPanel);
                                                            
    team1Panel = new Panel(new GridLayout(14,1));
    team1Panel.setBackground(TEAM1COLOR);
    team1Panel.setForeground(TEAM2COLOR);
    team1Label = makeLabel("Wins", team1Panel);
    team1Label.setAlignment(Label.CENTER);
    
    turnAngle1Label = makeLabel("TurnRate", team1Panel);
    turnAngle1 = makeScrollbar(0, turnAngle1Label.getName(), team1Panel);
    acceleration1Label = makeLabel("Acceleration", team1Panel); 
    acceleration1 = makeScrollbar(0, acceleration1Label.getName(), team1Panel);
    sensorRange1Label = makeLabel("Eyesight", team1Panel);
    sensorRange1 = makeScrollbar(0, sensorRange1Label.getName(), team1Panel);  
    collisionRange1Label = makeLabel("PersonalSpace", team1Panel); 
    collisionRange1 = makeScrollbar(0,collisionRange1Label.getName(), team1Panel);
    attackConstant1Label = makeLabel("Attack!", team1Panel); 
    attackConstant1 = makeScrollbar(0, attackConstant1Label.getName(), team1Panel);
    retreatConstant1Label = makeLabel("Retreat!", team1Panel);
    retreatConstant1 = makeScrollbar(0, retreatConstant1Label.getName(), team1Panel);
    random1Button = makeButton("Randomize", team1Panel);
    
    team2Panel = new Panel(new GridLayout(14,1));
    team2Panel.setBackground(TEAM2COLOR);
    team2Panel.setForeground(TEAM1COLOR);
    team2Label = makeLabel("Wins", team2Panel);
    team2Label.setAlignment(Label.CENTER);
    
    turnAngle2Label = makeLabel("TurnRate", team2Panel);
    turnAngle2 = makeScrollbar(0, turnAngle2Label.getName(), team2Panel);
    acceleration2Label = makeLabel("Acceleration", team2Panel); 
    acceleration2 = makeScrollbar(0, acceleration2Label.getName(), team2Panel);
    sensorRange2Label = makeLabel("Eyesight", team2Panel);
    sensorRange2 = makeScrollbar(0, sensorRange2Label.getName(), team2Panel);  
    collisionRange2Label = makeLabel("PersonalSpace", team2Panel); 
    collisionRange2 = makeScrollbar(0,collisionRange2Label.getName(), team2Panel);
    attackConstant2Label = makeLabel("Attack!", team2Panel); 
    attackConstant2 = makeScrollbar(0, attackConstant2Label.getName(), team2Panel);
    retreatConstant2Label = makeLabel("Retreat!", team2Panel);
    retreatConstant2 = makeScrollbar(0, retreatConstant2Label.getName(), team2Panel);
    random2Button = makeButton("Randomize", team2Panel);
                                        
    /*
     * Localize all display strings and, if needed, refresh their values.
     */
    setNamesFromResourceBundle(team1Panel.getComponents(), resourceBundleName, applicationLocale);
    setNamesFromResourceBundle(team2Panel.getComponents(), resourceBundleName, applicationLocale); 
    setNamesFromResourceBundle(controlPanel.getComponents(), resourceBundleName, applicationLocale); 
    startString = getStringFromResourceBundle(startString, resourceBundleName, applicationLocale);
    pauseString = getStringFromResourceBundle(pauseString, resourceBundleName, applicationLocale);
    resumeString = getStringFromResourceBundle(resumeString, resourceBundleName, applicationLocale);
    setLabelLengths(team1Panel.getComponents(), " :   0");
    setLabelLengths(team2Panel.getComponents(), " :   0");
    setLabelLengths(controlPanel.getComponents(), ":     ");
    resetButton.setLabel(resetButton.getName());
    pauseButton.setLabel(pauseButton.getName());
    replayButton.setLabel(replayButton.getName());
    random1Button.setLabel(random1Button.getName());
    random2Button.setLabel(random2Button.getName());

    arenaPanel = new Panel();
    arenaPanel.setSize(width - team1Panel.getSize().width - team2Panel.getSize().width, 
                       height - team1Panel.getSize().height - team2Panel.getSize().height);
    arenaPanel.setBackground(new Color(88,99,88));
    arenaPanel.addComponentListener(this);

    add("Center", arenaPanel);
    add("South", controlPanel);
    add("West", team1Panel);
    add("East", team2Panel);
    pauseFlag = true;
    replayFlag = false;
    
    resetFlock();
    
    if (frame != null) {
      frame.addWindowListener(this);
      frame.add("Center", this);
      frame.setVisible(true);
    }
                                                                        
    setVisible(true);                                                   
    updateAllLabels();        
    start();
  }
  
  private void setLabelLengths(Component[] c, String addOn) {       
    if (c != null && addOn != null) {
      for (int i=0; i<c.length; i++) {
        if (c[i] instanceof Label) {
          ((Label) c[i]).setText(c[i].getName() + addOn);
        }
      }
    }
  }
  
  private void setNamesFromResourceBundle(Component[] c, String RBName, Locale locale) {
    ResourceBundle rb;
    if (c != null && RBName != null && locale != null) {
      try {
       rb = ResourceBundle.getBundle(RBName, locale);
      }
      catch (MissingResourceException x0) {
        /*
         * Oops, can't do anything without a ResourceBundle.
         */
        System.out.println(x0);
        return;
      }
      for (int i=0; i<c.length; i++) {
        try {
          c[i].setName(rb.getString(c[i].getName()));
        }
        catch (MissingResourceException x1) {             
          /*
           * Not all components will need to be I18L'ed, so it shouldn't 
           * be a surprise if there isn't a matching resource for each.
           */             
        }
      }
    }
  }
     
  private String getStringFromResourceBundle(String s, String RBName, Locale locale) {
    ResourceBundle rb;
    if (s != null && RBName != null && locale != null) {
      try {
       rb = ResourceBundle.getBundle(RBName, locale);
      }
      catch (MissingResourceException x0) {
        /*
         * Oops, can't do anything without a ResourceBundle.
         */
        System.out.println(x0);
        return s;
      }
      try {
        return rb.getString(s);
      }
      catch (MissingResourceException x1) {             
        /*
         * Requested string probably doesn't exist.
         */                                        
        System.out.println(x1);
      }
    }
    return s;
  }
    
  private void resetFlock() {
    flock = new Flock(seed, boidsPerTeam, numberOfTeams, 
        arenaPanel.getSize().height, 
        arenaPanel.getSize().width);
    updateFlockParameters();
    time = 0;
  }

  public void start() {
    if (thread == null) {
      thread = new Thread(this);
      thread.start();
    }
  }

  public void stop() {
    if (thread != null) {
      thread.destroy();
      thread = null;
    }
  }

 public void run() {
    while (true) {
      while(!pauseFlag) {
        time = time + 1;
        flock.moveMembers();
        updateGUI();
        repaint();
        if (flock.getGameOverFlag()) {
          if (!replayFlag) {
            Enumeration e = flock.elements();
            if (e.hasMoreElements()) {
              Color c = ((Boid) (e.nextElement())).getColor();
              if (c == TEAM1COLOR) {
                team1Wins++;
                team1Label.setText(team1Label.getName() + " : " + String.valueOf(team1Wins));
              }
              else if (c == TEAM2COLOR) {
                team2Wins++;
                team2Label.setText(team2Label.getName() + " : " + String.valueOf(team2Wins));
              }
            }                           
          }
          replayFlag = false;
          pauseFlag = true;
          pauseButton.setLabel(startString);
        }    
        try {
          Thread.sleep(20);
        }
        catch (InterruptedException exception) { 
          System.out.println("I'm melting!"); 
        }
      }  
    }
 }

 public void updateGUI() {     
    if (time < 10) {
      timeLabel.setText(timeLabel.getName() + ":    " + String.valueOf(time));
    }
    else if (time < 100) {
      timeLabel.setText(timeLabel.getName() + ":   " + String.valueOf(time));
    }
    else if (time < 1000) {
      timeLabel.setText(timeLabel.getName() + ":  " + String.valueOf(time));
    }                             
    else if (time < 10000) {
      timeLabel.setText(timeLabel.getName() + ": " + String.valueOf(time));
    } 
 }
                             
 public Scrollbar makeScrollbar(int initialValue, String name, Container parent) {
    Scrollbar sb = new Scrollbar(Scrollbar.HORIZONTAL, initialValue, SCROLLBARVISIBLE, 0, Integer.MAX_VALUE);
    sb.setUnitIncrement((int) (((double) SCROLLBARMAX)/((double) 100)));
    sb.setBlockIncrement((int)(SCROLLBARVISIBLE/2));
    sb.addAdjustmentListener(this);
    sb.setName(name);
    sb.setForeground(parent.getForeground());
    sb.setBackground(parent.getBackground());
    parent.add(sb);
    return sb;
 }                   
 
 public Label makeLabel(String name, Container parent) {
    Label label = new Label(name);
    label.setName(name);
    label.setForeground(parent.getForeground());
    label.setBackground(parent.getBackground());
    parent.add(label);
    return label;
 }                                 
 
 public Button makeButton(String name, Container parent) {
    Button b = new Button(name);
    b.setName(name);
    b.addActionListener(this);
    b.setForeground(parent.getForeground());
    b.setBackground(parent.getBackground());
    parent.add(b);
    return b;
 }      
 
 private void setSeed(long newSeed) {
    seed = newSeed;
 }
                   
 public void updateLabel(Scrollbar sb) {
    if (sb != null && sb.getParent() != null) {
      Component c[] = sb.getParent().getComponents();
      for (int i=0; i<c.length; i++) {
        if (c[i].getName() == sb.getName() && !sb.equals(c[i]) && c[i] instanceof Label) {          
          ((Label) c[i]).setText(sb.getName() + " : " + String.valueOf((int) (100*(((double) sb.getValue())/((double) (sb.getMaximum() - sb.getVisibleAmount()))))));
          break;
        }
      }
    }
 }                    
                   
 public void updateAllLabels() {
    updateLabels(team1Panel.getComponents());
    updateLabels(team2Panel.getComponents());
 }
 
 public void updateLabels(Component[] c) {
    for (int i=0; i<c.length; i++) {
      if (c[i] instanceof Scrollbar) {
        updateLabel((Scrollbar) c[i]);
      }
    }
 }

 public synchronized void paint(Graphics g) {
    Enumeration e = flock.elements();
    Boid boid;
    int[] xPoints = {0,0,0};
    int[] yPoints = {0,0,0};
    g = arenaPanel.getGraphics();
    g.clearRect(0, 0, arenaPanel.getSize().width, arenaPanel.getSize().height);
    while (e.hasMoreElements()) {
        boid = (Boid) e.nextElement();
        g.setColor(boid.getColor());
        xPoints[0] = (int) (boid.getX()+10.0*Math.cos(boid.getHeading()));
        yPoints[0] = (int) (boid.getY()+10.0*Math.sin(boid.getHeading()));
        xPoints[1] = (int) (boid.getX()+5.0*Math.cos(boid.getHeading() + (2.0/3.0)*Math.PI));
        yPoints[1] = (int) (boid.getY()+5.0*Math.sin(boid.getHeading() + (2.0/3.0)*Math.PI));
        xPoints[2] = (int) (boid.getX()+5.0*Math.cos(boid.getHeading() - (2.0/3.0)*Math.PI));
        yPoints[2] = (int) (boid.getY()+5.0*Math.sin(boid.getHeading() - (2.0/3.0)*Math.PI));
        g.fillPolygon(xPoints, yPoints, 3);
    }
 }

 public void update(Graphics g) {
    paint(g);
 }
  
 public void updateFlockParameters() {
    Enumeration boids = flock.elements();
    Boid b;
    while (boids.hasMoreElements()) {
      b = (Boid) (boids.nextElement());
      if (b.getColor() == TEAM1COLOR) {
        b.setTurnAngle(((double) (turnAngle1.getValue())/((double)SCROLLBARMAX))*(Math.PI));
        b.setAcceleration(((double) (acceleration1.getValue())/((double)SCROLLBARMAX)));
        b.setSensorRange(((double) (sensorRange1.getValue())/((double)SCROLLBARMAX))*400);
        b.setCollisionRange(((double) (collisionRange1.getValue())/((double)SCROLLBARMAX))*20);
        b.setAttackConstant(((double) (attackConstant1.getValue())/((double)SCROLLBARMAX))*boidsPerTeam);
        b.setRetreatConstant(((double) (retreatConstant1.getValue())/((double)SCROLLBARMAX))*boidsPerTeam);
      }
      else if (b.getColor() == TEAM2COLOR) {
        b.setTurnAngle(((double) (turnAngle2.getValue())/((double)SCROLLBARMAX))*(Math.PI));
        b.setAcceleration(((double) (acceleration2.getValue())/((double)SCROLLBARMAX)));
        b.setSensorRange(((double) (sensorRange2.getValue())/((double)SCROLLBARMAX))*400);
        b.setCollisionRange(((double) (collisionRange2.getValue())/((double)SCROLLBARMAX))*20);
        b.setAttackConstant(((double) (attackConstant2.getValue())/((double)SCROLLBARMAX))*boidsPerTeam);
        b.setRetreatConstant(((double) (retreatConstant2.getValue())/((double)SCROLLBARMAX))*boidsPerTeam);
      }
    }
 }

 public void adjustmentValueChanged(AdjustmentEvent event) {
    if (event.getSource() instanceof Scrollbar) {
      Scrollbar source = (Scrollbar) event.getSource();
      Enumeration boids = flock.elements();
      Boid b;
      updateLabel(source);
      if (source == turnAngle1) {
        while (boids.hasMoreElements()) { 
          b = (Boid) (boids.nextElement());
          if (b.getColor() == TEAM1COLOR) {
            b.setTurnAngle(((double) (source.getValue())/((double)SCROLLBARMAX))*(Math.PI));
          }
        }
      }
      else if (source == turnAngle2) {
        while (boids.hasMoreElements()) { 
          b = (Boid) (boids.nextElement());
          if (b.getColor() == TEAM2COLOR) {
            b.setTurnAngle(((double) (source.getValue())/((double)SCROLLBARMAX))*(Math.PI));
          }
        } 
      }
      else if (source == acceleration1) {
        while (boids.hasMoreElements()) { 
          b = (Boid) (boids.nextElement());
          if (b.getColor() == TEAM1COLOR) {
            b.setAcceleration(((double) (source.getValue())/((double)SCROLLBARMAX)));
          }
        }       
      }
      else if (source == acceleration2) {
        while (boids.hasMoreElements()) { 
          b = (Boid) (boids.nextElement());
          if (b.getColor() == TEAM2COLOR) {
            b.setAcceleration(((double) (source.getValue())/((double)SCROLLBARMAX)));
          }
        }       
      }
      else if (source == sensorRange1) {
        while (boids.hasMoreElements()) { 
          b = (Boid) (boids.nextElement());
          if (b.getColor() == TEAM1COLOR) {
            b.setSensorRange(((double) (source.getValue())/((double)SCROLLBARMAX))*400);
          }
        }       
      }
      else if (source == sensorRange2) {
        while (boids.hasMoreElements()) { 
          b = (Boid) (boids.nextElement());
          if (b.getColor() == TEAM2COLOR) {
            b.setSensorRange(((double) (source.getValue())/((double)SCROLLBARMAX))*400);
          }
        }
      }
      else if (source == collisionRange1) {
        while (boids.hasMoreElements()) { 
          b = (Boid) (boids.nextElement());
          if (b.getColor() == TEAM1COLOR) {
            b.setCollisionRange(((double) (source.getValue())/((double)SCROLLBARMAX))*20);
          }
        }
      }
      else if (source == collisionRange2) {
        while (boids.hasMoreElements()) { 
          b = (Boid) (boids.nextElement());
          if (b.getColor() == TEAM2COLOR) {
            b.setCollisionRange(((double) (source.getValue())/((double)SCROLLBARMAX))*20);
          }
        }
      }
      else if (source == attackConstant1) {
        while (boids.hasMoreElements()) { 
          b = (Boid) (boids.nextElement());
          if (b.getColor() == TEAM1COLOR) {
            b.setAttackConstant(((double) (source.getValue())/((double)SCROLLBARMAX))*boidsPerTeam);
          }
        }
      }
      else if (source == attackConstant2) {
        while (boids.hasMoreElements()) { 
          b = (Boid) (boids.nextElement());
          if (b.getColor() == TEAM2COLOR) {
            b.setAttackConstant(((double) (source.getValue())/((double)SCROLLBARMAX))*boidsPerTeam);
          }
        }
      }
      else if (source == retreatConstant1) {
        while (boids.hasMoreElements()) { 
          b = (Boid) (boids.nextElement());
          if (b.getColor() == TEAM1COLOR) {
            b.setRetreatConstant(((double) (source.getValue())/((double)SCROLLBARMAX))*boidsPerTeam);
          }
        }
      }
      else if (source == retreatConstant2) {
        while (boids.hasMoreElements()) { 
          b = (Boid) (boids.nextElement());
          if (b.getColor() == TEAM2COLOR) {
            b.setRetreatConstant(((double) (source.getValue())/((double)SCROLLBARMAX))*boidsPerTeam);
            updateLabel(source);
          }
        }
      }
    }
 }
         

 public void actionPerformed(ActionEvent event) {
    if (event.getSource() instanceof Button) {
        Button source = (Button) event.getSource();
        if (source == pauseButton) { 
             pauseFlag = !pauseFlag;
             if (pauseFlag) {
                pauseButton.setLabel(resumeString);
             }
             else {
                 if (flock.getGameOverFlag()) {
                    setSeed(System.currentTimeMillis());
                    resetFlock();
                 }
                 pauseButton.setLabel(pauseString);
             }
         } 
         else if (source == replayButton) {
             /*
              * Don't count the same victory twice.
              */
             replayFlag = true;  
             /*
              * Renew the flock using the same seed.
              */
             resetFlock();
             pauseFlag = false;
             pauseButton.setLabel(pauseString);
         }
         else if (source == resetButton) {
             flock.initializeFlock();
             updateFlockParameters();
             time = 0;
         }                      
         else if (source == random1Button) {
            Random r = new Random();
            turnAngle1.setValue(r.nextInt(SCROLLBARMAX + 1));
            acceleration1.setValue(r.nextInt(SCROLLBARMAX + 1));
            sensorRange1.setValue(r.nextInt(SCROLLBARMAX + 1));
            collisionRange1.setValue(r.nextInt(SCROLLBARMAX + 1));
            attackConstant1.setValue(r.nextInt(SCROLLBARMAX + 1));
            retreatConstant1.setValue(r.nextInt(SCROLLBARMAX + 1));
            updateAllLabels();
            updateFlockParameters();
         }
         else if (source == random2Button) {
            Random r = new Random();
            turnAngle2.setValue(r.nextInt(SCROLLBARMAX + 1));
            acceleration2.setValue(r.nextInt(SCROLLBARMAX + 1));
            sensorRange2.setValue(r.nextInt(SCROLLBARMAX + 1));
            collisionRange2.setValue(r.nextInt(SCROLLBARMAX + 1));
            attackConstant2.setValue(r.nextInt(SCROLLBARMAX + 1));
            retreatConstant2.setValue(r.nextInt(SCROLLBARMAX + 1));
            updateAllLabels();
            updateFlockParameters();
         }                    
     }
 }

 public void windowActivated(WindowEvent e) {}
 public void windowClosed(WindowEvent e) {
     System.exit(0);
 }
 public void windowClosing(WindowEvent e) {
    frame.dispose();
 }
 public void windowDeactivated(WindowEvent e) {}
 public void windowDeiconified(WindowEvent e) {}
 public void windowIconified(WindowEvent e) {}
 public void windowOpened(WindowEvent e) {}

 public void componentHidden(ComponentEvent e) {}
 public void componentMoved(ComponentEvent e) {}
 public void componentResized(ComponentEvent e) {
     if (e.getSource() == arenaPanel) {
        flock.setWidth(arenaPanel.getWidth());
        flock.setHeight(arenaPanel.getHeight());
     }
 }
 public void componentShown(ComponentEvent e) {}

}