import java.applet.*;
import java.awt.*;

public class bezierlet extends Applet implements Runnable {
  private class i_points {
    public int[] xx, yy;
    public i_points(int[] nxx, int[] nyy) { xx = nxx; yy = nyy; }
  }
  private class point {
    public double x, y;
    public point() {}
    public point(double px, double py) { x = px; y = py; }
    public point(point p) { x = p.x; y = p.y; }
  }
  private class bezier {
    private point[] pts_;
    public bezier(point[] p) {
      int n = p.length;
      pts_ = new point[n];
      for(int i=0; i<n; i++)
	pts_[i] = p[i];
    } 
    private i_points eval(int n_points, point scale, point offset) {
      
      int[] xx = new int[n_points], yy = new int[n_points];
      
      int n = pts_.length;
      double[] tt = new double[n], ss = new double[n], bin = new double[n];
      
      double t = 0.0, dt = 1.0 / (double) (n_points - 1);
      tt[0] = 1.0; ss[0] = 1.0;

      double n_d = (double) n, i_d = 1.0;
      bin[0] = 1.0;
      for(int i = 1; i<n; i++) {
	bin[i] = bin[i-1]*(n_d - i_d) / i_d;
	i_d += 1.0;
      }
      
      for(int count = 0; count<n_points; count++) {
	for(int i = 1; i<n; i++) {
	  tt[i] = tt[i-1] * t;
	  ss[i] = ss[i-1] * (1.0-t);
	}
	double x = 0.0, y = 0.0;
	for(int i = 0; i<n; i++) {
	  double c = bin[i] * tt[i] * ss[n-1-i];
	  x += c * pts_[i].x;
	  y += c * pts_[i].y;
	}
	xx[count] = (int) (x*scale.x + offset.x);
	yy[count] = (int) (y*scale.y + offset.y);
	t += dt;
      }
      return new i_points(xx, yy);
    }
  }

  private i_points plots_;
  private Thread thread_;

  public void init() {
    plots_ = null;
  }
  public void start() {
    thread_ = new Thread(this);
    thread_.start();
  }
  public void stop() {
    thread_.stop();
    thread_ = null;
  }
  public void paint(Graphics g) {
    if(plots_ != null) {
      int n = plots_.xx.length;
      //      for(int i = 1; i<n; i++)
      //	g.drawLine(plots_.xx[i-1], plots_.yy[i-1],
      //                   plots_.xx[i], plots_.yy[i]);
      g.drawPolygon(plots_.xx, plots_.yy, n);
    }
  }
  public void run() {
    long time_step = 100;
    int degree = 15, n_points = 100;
    double vscale = 0.01;
    bezier bez;
    point[] guides = new point[degree], velocities = new point[degree];
    double top = 0, left = 0, bottom = 1, right = 1;
    Rectangle bounds = bounds();
    point scale = new point(bounds.width, bounds.height);
    point offset = new point(0,0);

    for(int i = 0; i<degree-1; i++) {
      guides[i] = new point(Math.random(), Math.random());
      velocities[i] = new point(Math.random()*vscale,
				Math.random()*vscale);
    }
    guides[degree-1] = guides[0];
    velocities[degree-1] = velocities[0];
    guides[degree-2] = new point();
    guides[degree-2].x = 2.0*guides[0].x - guides[1].x;
    guides[degree-2].y = 2.0*guides[0].y - guides[1].y;

    bez = new bezier(guides);

    while(true) {
      long t0 = System.currentTimeMillis();
      plots_ = bez.eval(n_points, scale, offset);
      repaint();
      
      for(int i = 0; i<degree-2; i++) {
	guides[i].x += velocities[i].x;
	guides[i].y += velocities[i].y;
	if(guides[i].x < left) {
	  guides[i].x = 2.0*left - guides[i].x;
	  velocities[i].x = - velocities[i].x;
	} else if(guides[i].x > right) {
	  guides[i].x = 2.0*right - guides[i].x;
	  velocities[i].x = - velocities[i].x;
	}
	if(guides[i].y < top) {
	  guides[i].y = 2.0*top - guides[i].y;
	  velocities[i].y = - velocities[i].y;
	} else if(guides[i].y > bottom) {
	  guides[i].y = 2.0*bottom - guides[i].y;
	  velocities[i].y = - velocities[i].y;
	}
      }
      guides[degree-2].x = 2.0*guides[0].x - guides[1].x;      
      guides[degree-2].y = 2.0*guides[0].y - guides[1].y;

      try {
	long dt = time_step - (System.currentTimeMillis() - t0);
	if(dt < 0)
	  dt = 20;
	Thread.sleep(dt);
      } catch(InterruptedException e) {}
    }
  }
}