/* 1D random walk from Random starts. */

import java.awt.*;
import java.applet.Applet;
import java.text.DecimalFormat;
/** Walker performs a random walk. */
class Walker {
     // Constants.
     public static final Color  WALKER_COLOR = Color.blue;
     public static final int    WALKER_DIAMETER = 50;
     public int           xpos ; 
     public int           plus = 0 ; 
     public int           minus = 0 ; 

     // Instance variables accessible to objects in the same package.

     int                  ypos;

     // Private instance variables.
     private   int        h;
     private   Random   p;
     private 	int oldsleep =0;

     /** Construct the Walker  */
     Walker (Random pen) {
        xpos     = WALKER_DIAMETER;
        ypos     = 240;
        h        = ypos;
        p        = pen;
     }

     /** The primary method that steps the walker. */
     public void step() {
        int dir;
        if ((Math.random())> (double) 0.5){
	dir=1;
	plus++;
	} else {
	dir=-1;
	minus--;
	}
//	        System.out.println(" In step p.fall " +
//					p.fall); 
	if(!p.fall){
        xpos = xpos +
		(dir*(p.size().width- 2*WALKER_DIAMETER)/p.NSTEPS);
	}
//        ypos = ypos + 10;

     }





     /** Set the Walker to where the user drags it. */
     public void newPosition(int x, int y) {
        xpos = x;
        ypos = y;

     }

     /** Draw the Walker. */
     public void draw(Graphics g) {

        int radius = WALKER_DIAMETER/2;
        int start = 0;
	int step = 0;
        g.setColor(WALKER_COLOR);  
//        g.drawString("Fall "+String.valueOf(p.fall),200,390);


	if(!p.fall){
        g.fillOval(xpos - radius, ypos - radius, WALKER_DIAMETER,
                        WALKER_DIAMETER);  } 


/*      If falls off the end, show it */
	else {
		 if(p.fallsteps>9){oldsleep=p.sleep;}
                 p.fallsteps--; 
		 p.sleep=40;
		if(p.fallsteps<1){p.fall=false;p.fallsteps=10;p.sleep=oldsleep;}
		if(p.fall){
		if(xpos+p.step<p.end){        
	g.fillOval(p.start-(int)((double)((radius)*(10-p.fallsteps))/(double)10.0), ypos +(int)( ( (double)Math.pow((2*(10-p.fallsteps)),2)/(double)100.0)*(double)radius), WALKER_DIAMETER, WALKER_DIAMETER); 
//        g.drawString("Fall steps "+String.valueOf(p.fallsteps),200,90);
//        g.drawString("Fall steps "+String.valueOf(p.start+p.step-radius-(int)((double)((radius)*(10-p.fallsteps))/(double)10.0)),280,90);

//        g.drawString("Xpos fall start"+String.valueOf(xpos),200,390);
                        } 

		else {

	g.fillOval(p.end+(int)((double)((radius)*(10-p.fallsteps))/(double)10.0), ypos +(int)( ( (double)Math.pow((2*(10-p.fallsteps)),2)/(double)100.0)*(double)radius), WALKER_DIAMETER, WALKER_DIAMETER); 
//        g.drawString("Fall steps "+String.valueOf(( (double)(2*(10-p.fallsteps))/(double)100.0)*(double)radius),200,90);


		}
		}
		}
	




//        step=(p.size().width- 2*WALKER_DIAMETER)/p.NSTEPS; 
//        start=WALKER_DIAMETER -step;
	  start=p.start;
        g.drawString("5' ",p.start+p.step-p.tick,ypos+p.tick/2);
        g.drawString("3' ",p.start+p.NSTEPS*p.step+p.tick,ypos+p.tick/2);
        g.drawLine(p.start+p.step,ypos,p.start+p.NSTEPS*p.step,ypos);	
//        g.drawString("xpos "+String.valueOf(p.start+(int)((Math.random())*(double)p.NSTEPS)*p.step),100,300);
//        g.drawString("Plus "+String.valueOf(plus),100,120);
//        g.drawString("Minus "+String.valueOf(minus),200,120);
        g.drawString("<Faster ",250,10);
        g.drawString("Slower> ",370,10);
        g.drawString("Set Bases ",25,30);
//        g.drawString("start "+String.valueOf(p.start),100,300);
//        g.drawString("step "+String.valueOf(p.step),100,310);
//        g.drawString("end "+String.valueOf(p.end),100,320);
//       g.drawString("xpos "+String.valueOf(xpos),100,330);
//        g.drawString("rand "+String.valueOf((int)((Math.random())*(double)p.NSTEPS)),100,340);
//        g.drawString("rand st "+String.valueOf(p.ranst),100,350);
//        g.drawString("N trials "+String.valueOf(p.ntrial),100,360);
//        g.drawString("Dist "+String.valueOf(p.dist),100,370);
//        g.drawString("Distsum "+String.valueOf(p.distsum),100,380);
//        g.drawString("Distav "+String.valueOf(p.distav),100,390);


        for (int j=0; j <p.NSTEPS; j++) {
     		start = start+p.step;
        g.drawString(String.valueOf(j+1),start,ypos+2*p.tick);
     		g.drawLine(start,ypos+p.tick,start,ypos);	
	}
     }

}



/** Controlling class to produce 1D random walk with random start. */
public class Random extends Applet implements Runnable {
   
    // Public instance variables.
    public Walker   walker;
    
    // Private instance variables.
    private Thread  myThread;
    private boolean freeze = true;
    private boolean lstart = false;
    private boolean lstep = true;
    private boolean lrand = false;
    private boolean changentry = true;
    public int NSTEPS =5;
    public     int tick = 12 ; // Tick mark size for bases on image
    public    int start = 0;
    public	int step = 0;
  public	int end = 0;
  public	int ranst = 0;
  public	int ntrial = 0;
public	int dist = 0;
public	int distsum = 0;
public	double distav = (double)0;
    public boolean fall = false;
    public int fallsteps = 10;
    public int sleep =100;
	private int newt = 1;
	
    private Panel choicePanel;
    private Panel p2;
    private Panel outputPanel;
    private Panel slider;
    private Choice ntry;
    private String sntry;
    private Panel buttonPanel;
    private Button startButton;
    private Button randButton;
    private Button stepButton;
    private Font buttonFont;
    private Scrollbar upDown;
    private TextArea t2,t3,t4;
    private DecimalFormat twoDigits = new DecimalFormat(".00");
    /** Initialize the appplication. */
    public void init () {
       //resize (500,400);
       walker = new Walker(this);
        step=(size().width- 2*walker.WALKER_DIAMETER)/NSTEPS; 
        start=(int)((double)1.5*(double)walker.WALKER_DIAMETER -(double)step);
	end=start+NSTEPS*step;
	
      ntry = new Choice(); 
      ntry.addItem("5");
      ntry.addItem("7");
      ntry.addItem("9");
      ntry.addItem("11");
      ntry.addItem("13");
      ntry.addItem("15");

	setLayout(new BorderLayout()); 
	choicePanel = new Panel();
	outputPanel = new Panel();
	choicePanel.add("South",ntry);  
//	add("South",choicePanel);

	buttonPanel = new Panel();
	buttonFont = new Font("Helvetica", Font.BOLD, 16) ;
	buttonPanel.add("South",ntry);  
	startButton = new Button("Start");
	randButton = new Button("Middle");
	startButton.setBackground(Color.cyan);
	stepButton = new Button("Step");
	stepButton.setBackground(Color.cyan);
        buttonPanel.add(choicePanel);
	buttonPanel.add(startButton);
//	buttonPanel.add(randButton);
//	buttonPanel.add(stepButton);
	upDown = new Scrollbar(Scrollbar.HORIZONTAL,40,300,40,1000);
	buttonPanel.setLayout(new GridLayout(1,3,10,10));
//	add("South",buttonPanel);

	slider = new Panel ();
	slider.setLayout(new GridLayout(1,2,10,10));
	slider.add(upDown);
//	add("East",slider);
  	t2=new TextArea("Average Steps per Trial ",2,30,TextArea.SCROLLBARS_NONE);
	t3=new TextArea("Distance this trial ",2,30,TextArea.SCROLLBARS_NONE);
	t4=new TextArea("Trial no",2,30,TextArea.SCROLLBARS_NONE);
	t2.setEditable(false);
	t3.setEditable(false);
	t4.setEditable(false);

//	add("South",outputPanel);
	p2 = new Panel();
        p2.setLayout(new GridLayout(1,2,10,10));
	p2.add(buttonPanel);
	p2.add(slider);
//        p2.add(outputPanel);
	setLayout( new FlowLayout(FlowLayout.RIGHT));
	add(p2);

        outputPanel.setLayout(new GridLayout(3,1,1,1));
	outputPanel.add(t4);
	outputPanel.add(t3);
	outputPanel.add(t2);
//	setLayout( new FlowLayout(FlowLayout.CENTER,10,100));
	setLayout( new FlowLayout(FlowLayout.CENTER,10,15));
	add("South",outputPanel);

 }

    /** Create a thread and make this thread's target the applet. */
    public void start () {
      if (myThread == null) {
         myThread = new Thread(this, "Random");
         myThread.start();
      }
    }

   /** Keep on updating and redrawing the walker. */
   public void run() { 
       while (myThread != null) {

           // slow things down for looks.
           try {
              myThread.sleep(sleep); // = 1/10ths of a second
           } catch (InterruptedException e) {
           }


           
//           if (!freeze)

		if(changentry){
		t3.setText("Distance this trial ");
		t2.setText("Average Steps per Trial ");
		t4.setText("Trial no ");

		changentry=false;
        if(sntry=="5"){NSTEPS=5;}
        if(sntry=="7"){NSTEPS=7;}
        if(sntry=="9"){NSTEPS=9;}
        if(sntry=="11"){NSTEPS=11;}
        if(sntry=="13"){NSTEPS=13;}
        if(sntry=="15"){NSTEPS=15;}
        step=(size().width- 2*walker.WALKER_DIAMETER)/NSTEPS; 
        start=(int)((double)1.5*(double)walker.WALKER_DIAMETER -(double)step);
	end=start+NSTEPS*step;
		distsum=0;
		dist=0;
		distav=0;
		ntrial=0;
//	        System.out.println(" NSTEPS " +
//					NSTEPS);
		}
     if(lstart){
	if(lstep){
//	lstep=false;

/*    A new trial - reset start  */

		if(newt>0){
		newt=0;
//	    walker.xpos=start+(int)((Math.random())*(double)NSTEPS)*step;

	    if(!fall){

		if(lrand){walker.xpos=start+ ((NSTEPS-1)/2)*step +step;}
		else{
			walker.xpos=start+(int)((Math.random())*(double)NSTEPS)*step +step;
		    }
//	        System.out.println(" Xpos on restart " +walker.xpos);
		dist=-1;
                     }
		}

/*     If walker within bounds, step - else, set falling sequence */

		if(!fall&&(walker.xpos>start+step&&walker.xpos<end)){

             	  if(dist>-1){walker.step();}
           	  myRepaint();
		  dist++;
		t3.setText("Distance this trial "+String.valueOf(dist));
		} else {
		 if(dist>0){distsum=distsum+dist;}
//		 distsum=distsum+dist;
		 dist=0;
		 if(!fall){ntrial++;}
		  distav = (double)distsum/(double)ntrial;

		t2.setText("Average Steps per Trial "+twoDigits.format(distav));
		t4.setText("Trial no "+String.valueOf(ntrial+1));
		  newt = 1;
		  fall = true;
           	  myRepaint();
		}
       }
     }
    }
   }

   /** Stop the walk. */
   public void stop() {
       myThread.stop();
       myThread = null;
   }

   /** Draw the walker. */
   public void paint(Graphics g) {
      walker.draw(g);

   }

   /** Reset the walker to this position as the user drags it around. */
   public boolean mouseDrag(Event e, int x, int y) {
//      walker.newPosition(x, y);
      return false; // pass this event up the window hierarchy
   }

   /** Called when the mouse goes down. Stop random. */
   public boolean mouseDown(Event e, int x, int y) {
      freeze = true;
      return false; // pass this event up the window hierarchy
   }

    public boolean action(Event e, Object o) {
	if( e.target.equals(ntry)){
	  sntry=ntry.getSelectedItem();
	  changentry=true;
          }
	if( e.target == startButton){
            lstart = !lstart;
	    if (lstart) {
		startButton.setLabel("Stop");
	    } else {
		startButton.setLabel("Start");
	    }
       }
	if( e.target == randButton){
            lrand = !lrand;
	    if (lrand) {
		randButton.setLabel("Middle");
	    } else {
		randButton.setLabel("Random");
	    }
       }

	if( e.target == stepButton){
            lstep = !lstep;
       }

	  return false;

   }
   /** Called when the mouse goes up. Start random walk again. */
   public boolean mouseUp(Event e, int x, int y) {
      freeze = false;
      
      // Do a total repaint after the user drags the walker
      // to clean up the screen.
      repaint();
     
      return false; // pass this event up the window hierarchy
   }

    public boolean handleEvent(Event e) {
	if(e.target instanceof Scrollbar){
	    if( e.target == upDown){
		sleep=upDown.getValue();
	    }
            return true; 
	 }
        return super.handleEvent(e); 
    }

   /** Focus the repaint to the walker. */
   private void myRepaint() {
      int x;
      int y;
      int w;
      int h;
      int border = Walker.WALKER_DIAMETER * 2;

//      y = Cord.CORD_PIVOT_Y;
//      h = walker.ypos + Walker.WALKER_DIAMETER;
//      x = (walker.xpos > Cord.CORD_PIVOT_X) ? 
//            Cord.CORD_PIVOT_X - border : walker.xpos - border;
//      w = Math.abs(Cord.CORD_PIVOT_X - walker.xpos) + (border * 2);

      y = 0;
      h = 400;
      x = 0;
      w = 500;

      repaint(x, y, w, h);
   }

   /** Provide a main routine so that we can run stand-alone. */
    public static void main(String args[]) {
      Random p = new Random();
      p.init();

      // Create a window hierarchy and hook it up.
      Frame f = new Frame("Random");
      f.add(p);
      f.resize(500,400);
      f.show();

      // Start the app (this is done by the appletviewer or Web browser
      // for us automatically, but it's not done if we're running the app
      // from the command line).
      p.start();
    }   
}