/////////////////////////////////////////////////////////////
//
//	polygon screensaver
//
//	    -= by =- 
//
//	miles zarathustra
//
/////////////////////////////////////////////////////////////
//
//	after an algorithm shown to me by david kaufman at
//	the "people's computer center" in the 1970's.
//	the basic program was then called: "dangling string."
//
//	these names are used throughout:
//  
//	  sides:	how many sides the polygon has
//
//	  center:	center of gravity
//	  gravity:	amount of pull exerted by center 
//                      0<g<1 greater gravity leads to 
//                      quicker movement.
//	  jostling:	random jostling factor
//	  maxVel:	limit on velocity
//	  colorChange:  =n -> color changes about every 
//                      <n>th time.
//
//	  delay:	delay in milliseconds
//

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


//    a point which orbits 1-dimensionally around its center
//
class orbiter {

  // predictable position & motion
  protected int	    center, here;
  protected double  velocity, acceleration, gravity;
  
  // random factor, & limiting
  protected double maxVel,minVel;
  protected double jostling;


  //  gravity will typically be 0 < g < 1
  //
  orbiter(int center, int here, double gravity, double jostling, double maxVel) {
    this.center=center;
    this.here=here;
    this.gravity=gravity;
    this.velocity=0;

    this.jostling=jostling;
    this.maxVel=Math.abs(maxVel);
    this.minVel= -maxVel;
    accelerate();
  }
  orbiter() {
    center=0; here=0; gravity=0; velocity=0; acceleration=0;
    jostling=0; maxVel=0; minVel=0;
  }

  // standard velocity formula. 
  // the properties of this "gravity" are our own invention.
  protected void 
  move() { 
    here += velocity;
  }
  protected void 
  gravitate() { 
    acceleration = (center - here) * gravity;
  }
  protected void 
  accelerate() { 
    velocity += acceleration;
  }

  //  randomize, in a controlled way
  protected void 
  jostle() {
    acceleration *= jostling*Math.random()+ .5*jostling;
  }
  protected void 
  govern() {
    if (velocity<minVel) velocity=minVel;
    if (velocity>maxVel) velocity=maxVel;

  }
 
  int nextVal() {
    move();
    gravitate();    jostle();
    accelerate();   govern();

    return here;
  }

  //  java 'memcpy'
  void 
  copy(orbiter o) {
    acceleration  =o.acceleration;
    center	  =o.center;
    gravity	  =o.gravity;
    here	  =o.here;
    jostling	  =o.jostling;
    maxVel	  =o.maxVel;
    minVel	  =o.minVel;
    velocity	  =o.velocity;
  }
}


//    a polygon (solar system?) of orbiters
//
class planets {
  Color color;
  double colorChange;
  orbiter x[],y[];
  int sides;

  planets(int sides, int center, double gravity, double jostling, double maxVel, 
    double colorChange, Color color) {
    this.sides=sides;

    x=new orbiter[sides];
    y=new orbiter[sides];
    for (int i=0; i<sides; ++i) {
    
      // random starting location
      x[i]=new orbiter(
	center, (int)(2*Math.random()*center),
	gravity, jostling, maxVel);

      y[i]=new orbiter(
	center, (int)(2*Math.random()*center),
	gravity, jostling, maxVel);
    }

    this.colorChange = 1 / colorChange;
    this.color=color;
  }
  planets(planets p) {
    x=new orbiter[p.sides];
    y=new orbiter[p.sides];
    for (int i=0; i<p.sides; ++i) { 
      x[i]=new orbiter();
      y[i]=new orbiter();
    }
    copy(p);
  }

  planets(int sides, int center, 
      double gravity, double jostling, double maxVel, double colorChange) {
    this(sides,center,gravity,jostling,maxVel,colorChange,null);
    setNewColor();
  }

  private void
  setNewColor() {
    color=newColor();
  }

  //  a new color, but not too dark
  //  two possible methods, switched by useSum.
  //
  public static Color 
  newColor() {

    Color color;

    // max possible sum: 255 * 3 = 765
    int threshold=400;
    boolean useSum=true;
    
    do {
      color=new Color(
	(float)Math.random(),
	(float)Math.random(),
	(float)Math.random());
    }
      while ( // ensure brightness
        useSum				  ?
	  color.getRed()+
	  color.getGreen()+
	  color.getBlue()<threshold	  :

	  color.getRed()<threshold &&
	  color.getGreen()<threshold &&
	  color.getBlue()<threshold
      );

    return color;
  }

  // thisPolygon gives the current one. 
  // nextPolygon (below) gives the next 
  Polygon
  thisPolygon() {
    Polygon p=new Polygon();
    for (int i=0; i<sides; ++i) 
      p.addPoint(x[i].here,y[i].here);
    return p;
  }
  Polygon
  nextPolygon() {
    Polygon p=new Polygon();
    for (int i=0; i<sides; ++i) 
      p.addPoint(x[i].nextVal(),y[i].nextVal());
    return p;
  }

  void 
  copy(planets p) {
    color=p.color;
    colorChange=p.colorChange;
    sides=p.sides;
    //  ### the below loop assumes sides is the same,
    //  which (in this application) it is
    for (int i=0; i<sides; ++i) {
      x[i].copy(p.x[i]); 
      y[i].copy(p.y[i]);
    }
  }

  void
  next(Graphics g) {
    if (Math.random() < colorChange) setNewColor();
    g.setColor(color);
    g.drawPolygon(nextPolygon());
  }   

  void
  paint(Graphics g) {
    g.setColor(color);
    g.drawPolygon(thisPolygon());
  }
}

//    a set of orbiter-polygons
//
class tracers {
  int howmany;
  planets ary[];

  tracers(int sides, int howmany, 
      int center, double gravity, double jostling, double maxVel, 
      double colorChange) {
    this.howmany=howmany;
    ary=new planets[howmany];
    Color color=planets.newColor();
    ary[0] = new planets(sides,center,
	gravity,jostling,maxVel,colorChange,color);
    for (int i=1; i<howmany; ++i) {
      ary[i]=new planets(ary[0]);
    }
  }

  void
  shift() {
    for (int i=howmany-1; i>0; --i) {
      ary[i].copy(ary[i-1]);
    }
  }

  //   draw next one, & undraw last
  void
  next(Graphics g) {
    planets last=ary[howmany-1];
    last.color=poly.bgcolor;
    last.paint(g);
    shift();
    ary[0].next(g);
  }
  //  redraw all
  void
  paint(Graphics g) {
    for (int i=0; i<howmany; ++i) {
      ary[i].paint(g);
    }
  }
}

public class poly extends Applet implements Runnable {

    tracers t;
    public static Color bgcolor;
    int delay;

    // used to construct tracers
    int sides,howmany,center,colorChange;
    double gravity, maxVel, jostling;

    public poly() {
      bgcolor=new Color(0,0,0);
    }

    //	like Integer.getInteger, but for parameters
    int
    paramInt(String name, int value) {
      try { 
	Integer i=new Integer(getParameter(name));
	return i.intValue();
      }
      catch (NumberFormatException e) { return value;
      }
      catch (NullPointerException e) { return value;
      }
    }
    double
    paramDouble(String name, double value) {
      try { 
	Double n=new Double(getParameter(name));
	return n.doubleValue();
      }
      catch (NumberFormatException e) { return value;
      }
      catch (NullPointerException e) { return value;
      }
    }

    public void 
    init() {
      Dimension d=this.size();

      sides=3;
      howmany=7; 
      //  ### add: allow them to customize both x,y centers
      center=Math.min(d.width/2, d.height/2);
      gravity=.01;
      maxVel=d.height/10;
      jostling=1.0;
      colorChange=50;
      delay=10;

      sides=paramInt("sides",sides);
      howmany=paramInt("howmany",howmany);
      delay=paramInt("delay",delay);
      colorChange=paramInt("colorChange",colorChange);
      gravity=paramDouble("gravity",gravity);
      jostling=paramDouble("jostling",jostling);
      maxVel=paramDouble("maxVel",maxVel);

      t=new tracers(sides,howmany,center,gravity,jostling,maxVel,colorChange);
    }

    public String [] [] 
    getParameterInfo() {
      String [][] i= {
	{"sides", "integer", "number of sides"},
	{"howmany", "integer", "how many polygons"},
	{"gravity", "double", "0 < s < 1", 
	  "speed (pull towards center)"},
	{"jostling",  "double", "random jostling"},
	{"maxVel",  "double", "maximum velocity"},
	{"colorChange", "integer", 
	  "approximate # of times before color changes"},
	{"delay", "integer", "millisecond delay"}
      };
      return i;
    }

    //  update() never gets called.
    //
    public void 
    paint(Graphics g) {
      Dimension d=this.size();
      g.setColor(bgcolor);
      g.fillRect(0,0,d.width,d.height);
      t.paint(g);
    }

    // This is the thread that runs the animation, and the methods
    // that start it and stop it.
    private Thread poly_thread = null;
    public void 
    start() {
      if (poly_thread == null) {
            poly_thread = new Thread(this);
            poly_thread.start();
      }
    }
    public void 
    stop() {
        if ((poly_thread != null) && poly_thread.isAlive()) 
            poly_thread.stop();
        poly_thread = null; // for the garbage collector
    }
    
    // animate
    //
    public void run() {
        while(true) {

	  Graphics g=this.getGraphics();
	  t.next(g);

          this.getToolkit().sync();  // Force it to be drawn *now*.
          try { Thread.sleep(delay); } catch (InterruptedException e) { ; }
        }
    }
}