import javax.swing.JApplet;
import java.awt.*;  // import Graphics, Graphics2D, and Color

public class Dancer extends JApplet
{
     /** Illustration: Draw things on the applet's drawing area. */

     public void paint (Graphics g)
     {    Graphics2D page = (Graphics2D) g;                // 1
          page.setColor (Color.blue);                      // 2
          page.drawString ("stars goes here", 10, 45);     // 3
          page.setColor (Color.red);                       // 4
          page.drawString ("stripes go here", 10, 90);     // 5
          page.drawLine (10, 60, 30, 70);                  // 6
     }    //======================
}    

import javax.swing.JApplet;
import java.awt.*;  // import Graphics, Graphics2D, and Rectangle

public class Boxes extends JApplet
{
     /** Illustration: Draw 3 boxes on the applet's drawing area. */

     public void paint (Graphics g)
     {    Graphics2D page = (Graphics2D) g;
          Rectangle box = new Rectangle (50, 40);
          box.setLocation (30, 60);
          page.draw (box);           // the inner box in the figure
          box.grow (5, 5);  
          page.draw (box);           // the outer box in the figure
          box.translate (70, 0);
          page.fill (box);           // the filled box on the right
     }    //=======================
}

import javax.swing.JApplet;
import java.awt.*; 

public class Dancer extends JApplet
{
     private Flag itsFlag = new Flag();


     public void start()
     {    // leave empty for now; animation comes later
     }    //=======================


     public void paint (Graphics g)
     {    itsFlag.draw ((Graphics2D) g, 10, 20);
     }    //=======================
}

import java.awt.Graphics2D;
import java.awt.Color;
import java.awt.Rectangle;

public class Flag 
{
     public static final int FLAG_WIDE  = 173;
     public static final int FLAG_TALL  = 91;
     public static final int UNION_WIDE = 69;
     public static final int UNION_TALL = 49;
     public static final int PIP = 2;
     public static final int STAR = 5;
     ////////////////////////////////////
     private Rectangle itsUnion = new Rectangle 
                      (UNION_WIDE, UNION_TALL);  // width & height
	private Rectangle itsStripe = new Rectangle 
	                       (FLAG_WIDE, FLAG_TALL / 13);


     /** Draw one American flag. */

     public void draw (Graphics2D page, int x, int y)
     {    drawStripes (page, x, y);
          page.setColor (Color.blue);
          itsUnion.setLocation (x, y);
          page.fill (itsUnion);
          drawAllStars (page, x, y);
     }    //======================


     /** Draw 13 stripes in 173x91 area, top-left at (x,y). */

     private void drawStripes (Graphics2D page, int x, int y) 
	{	itsStripe.setLocation (x, y);
		for (int k = 0;  k < 13;  k++)
		{	if (k % 2 == 0)
				page.setColor (Color.red);
			else
				page.setColor (Color.white);
			page.fill (itsStripe);
			itsStripe.translate (0, TALL);
		}
     }    //======================


     /** Draw the 50 stars on the flag whose union is at (x,y). */

     private void drawAllStars (Graphics2D page, int x, int y) 
     {    page.setColor (Color.white);
          for (int row = 0;  row < 9;  row++)
          {    int end = row % 2 == 0  ?  x + PIP : x + PIP + 6;
               drawRowOfStars (page, x + UNION_WIDE - STAR, end,
                               y + PIP + row * STAR);
          }
     }    //======================


     /** Draw one row of 5 or 6 stars on the union. */

     private void drawRowOfStars (Graphics2D page, int end, 
                                  int x, int y)
     {    for (;  x < end;  x += 12)
               drawOneStar (page, x, y);
     }    //======================


     /** Draw 1 star with bounding box at position (x,y). */

     private void drawOneStar (Graphics2D page, int x, int y) 
	{	int twoPips = PIP * 2;
		page.drawLine (x + PIP, y, x, y + twoPips);
		page.drawLine (x, y + twoPips, x + twoPips, y + PIP);
		page.drawLine (x + twoPips, y + PIP, x, y + PIP);
		page.drawLine (x, y + PIP, x + twoPips, y + twoPips);
		page.drawLine (x + twoPips, y + twoPips, x + PIP, y);
     }    //======================
}    

import javax.swing.JApplet;
import java.awt.*;

public class Dancer extends JApplet
{
	private Flag itsFlag = new Flag();
	private int itsLeftEdge;
	private int itsTopEdge;


	public void start() 
	{	setVisible (true);
		for (int count = 0;  count < 2;  count++)
		{	danceRight();
			danceLeft();
		}
	}	//======================

	private void danceRight() 
	{	itsTopEdge = 20;
		for (itsLeftEdge = 10;  itsLeftEdge <= 49;  itsLeftEdge++)
		{	repaint();
			pause (50);
			itsTopEdge += (itsLeftEdge / 10 % 2 == 1)  ?  4 : -4;
		}
	}	//======================

	private void danceLeft() 
	{	itsTopEdge = 20;
		for (itsLeftEdge = 49;  itsLeftEdge >= 10;  itsLeftEdge--)
		{	repaint();
			pause (50);
			itsTopEdge += (itsLeftEdge / 10 % 2 == 1)  ?  -4 : 4;
		}
	}	//======================

	private static void pause (int wait)  
	{	long timeToQuit = System.currentTimeMillis() + wait;
		while (System.currentTimeMillis() < timeToQuit)
		{  }  // take no action
	}	//======================

	public void paint (Graphics g)  
	{	Graphics2D page = (Graphics2D) g;
		page.setColor (Color.white);
		page.fillRect (0, 0, 320, 160);  // clear the area
		itsFlag.draw (page, itsLeftEdge, itsTopEdge);
	}	//======================
}

import java.awt.*;

public class Collision extends javax.swing.JApplet
{
     public static final int NUM_CYCLES = 4000;
     public static final int SIZE = 21;      // number of Balls
     //////////////////////////////////
     private Ball[] itsItem = new Ball [SIZE];  // the 21 Balls 


     /** Draw the display of 21 balls several thousand times. */

     public void start()
     {    this.setVisible (true);
          Ball.initialize (this.getWidth(), this.getHeight());
          for (int k = 0;  k < SIZE;  k++)
               itsItem[k] = new Ball();
          for (int cycle = 1;  cycle <= NUM_CYCLES;  cycle++)
          {    updateEachBall();
               repaint();
               long timeToQuit = System.currentTimeMillis() + 90;
               while (System.currentTimeMillis() < timeToQuit)
               {  }  // take no action
          }
     }    //======================


     /** Check each ball and make the appropriate changes. */

     private void updateEachBall()
     {    for (int k = 0;  k < SIZE;  k++)
          {    if (itsItem[k].isHealthy())
                    moveAndCheckHits (itsItem[k]);
               else if (itsItem[k].isDying())
                    itsItem[k].deteriorates();
               else
                    itsItem[k] = new Ball();
          }
     }    //======================


     /** Poison any 1 ball that guy comes very close to. */

     private void moveAndCheckHits (Ball guy)
     {    guy.move();
          int c = 0;
          while (c < SIZE && itsItem[c].misses (guy))
               c++;
          if (c < SIZE && itsItem[c].isHealthy())
               itsItem[c].getsPoison();
     }    //======================


     /** Draw the current status of the 21 balls. */

     public void paint (Graphics g)
     {    Graphics2D page = (Graphics2D) g;
          page.setColor (Color.white);
          page.fill (new Rectangle (getWidth(), getHeight()));
          for (int k = 0;  k < SIZE;  k++)
               itsItem[k].drawImage (page);
     }    //======================
}    

import java.util.Random;
import java.awt.geom.Ellipse2D;
import java.awt.*;

public class Ball 
{
     public static final int UNIT = 15;       // width of figure
     private static final int HEALTHY = 100;  // cycles to languish
     private static Random randy = new Random();
     private static int theRight;    // right side of the screen
     private static int theBottom;   // bottom edge of the screen
     //////////////////////////////////
     private int itsXspot;           // x-value of current location
     private int itsYspot;           // y-value of current location
     private int itsXmove;           // change in x each cycle
     private int itsYmove;           // change in y each cycle
     private int itsStatus;          // tells how healthy it is


     public static void initialize (int rightSide, int bottom)
     {    theRight = rightSide;
          theBottom = bottom;
     }    //======================


     public Ball()
     {    itsXspot = (theRight * (1 + randy.nextInt (9))) / 10;
          itsYspot = theBottom - randy.nextInt (40);
          itsXmove = randy.nextInt (5) - 2; // range -2 to 2
          itsYmove = randy.nextInt (3) - 3; // range -1 to -3
          itsStatus = HEALTHY;
     }    //======================


     public boolean isHealthy()
     {    return itsStatus == HEALTHY;
     }    //======================


     public void getsPoison()
     {    itsStatus = HEALTHY - 1;
     }    //======================


     public boolean isDying()
     {    return itsStatus < HEALTHY && itsStatus > 0;
     }    //======================


     public void deteriorates()
     {    itsStatus--;
     }    //======================


// the Ball class, completed

     public void move()
     {    itsXspot += itsXmove;
          itsYspot += itsYmove;
          if (itsXspot <= 1 || itsXspot >= theRight - UNIT)
               itsXmove = - itsXmove;
          if (itsYspot <= 1 || itsYspot >= theBottom - UNIT)
               itsYmove = - itsYmove;
     }    //======================


     public boolean misses (Ball guy)
     {    return this == guy || Math.abs (itsXspot - guy.itsXspot)
                              + Math.abs (itsYspot - guy.itsYspot) > 2;
     }    //======================


     public void drawImage (Graphics2D page)
     {    if (isHealthy())
               page.setColor (Color.red);
          else
               page.setColor (Color.blue);
		page.fillOval (itsXspot, itsYspot, UNIT, UNIT);
     }    //======================
}    

import java.awt.Color;

public class Turtlet 
{	public static final double DEGREE = Math.PI / 180; 
	public static final Color RED = Color.red, BLUE = Color.blue,
	               BLACK = Color.black,      GRAY = Color.gray, 
	               YELLOW = Color.yellow,    PINK = Color.pink,
	               ORANGE = Color.orange,    GREEN = Color.green,
	               MAGENTA = Color.magenta,  WHITE = Color.white;
	private static java.awt.Graphics thePage;
	//////////////////////////////////
	private double heading = 0;         // heading initially east
	private double xcor, ycor;          // current position of Turtle


	/** Set the drawing Color to the given value.  Made an instance method  
	 *  only so that it cannot be called until thePage is assigned, although
	 *  the drawing color is a property of thePage, not of one Turtle. */

	public void switchTo (Color given)
	{	thePage.setColor (given);
	}	//======================


	/** Write words without changing the Turtle's state.  */

	public void say (String message)
	{	thePage.drawString (message, (int) xcor, (int) ycor);
	}	//======================


	/** Pause the animation for wait milliseconds.  Made a class method
	 *  so that an applet can pause an animation "between turtles". */

	public static void sleep (int wait)
	{	try
		{	Thread.sleep (wait);
		}catch (InterruptedException ex)
		{}
	}	//======================


	/** Supply the nearest int value to methods requiring ints. */

	private int round (double x)
	{	return (int) (x + 0.5);
	}	//======================


	/** Make a circle of the given radius, Turtle at center. */

	public void swingAround (double radius)
	{	if (radius > 0.0)
		{	int rad = round (2 * radius);
			thePage.drawOval (round (xcor - radius), 
				      round (ycor - radius), rad, rad);
		}
	}	//======================


// the Turtle class, completed

     /** Rotate left by left degrees; MOVE for forward steps. */

     public Turtle move (double left, double forward)
     {    heading += left * DEGREE;
          xcor += forward * Math.cos (heading);
          ycor -= forward * Math.sin (heading);
          return this;
     }    //======================


     /** Rotate left by left degrees; PAINT for forward steps. */

     public Turtle paint (double left, double forward)
     {    heading += left * DEGREE;
          double x = xcor + forward * Math.cos (heading);
          double y = ycor - forward * Math.sin (heading);
          page.draw (new Line2D.Double (xcor, ycor, x, y));
          xcor = x;
          ycor = y;
          return this;
     }    //======================


     /** Fill a circle of the given radius, Turtle at center. */

     public void fillCircle (double radius)
     {    page.fill (new Ellipse2D.Double (xcor - radius, 
                      ycor - radius, 2 * radius, 2 * radius));
     }    //======================


     /** Fill a rectangle of the given width and height, 
      *  Turtle at center. */

     public void fillBox (double width, double height)
     {    page.fill (new Rectangle2D.Double (xcor - width / 2,
                     ycor - height / 2, width, height));
     }    //======================


     /** Create a turtle on a given page at (xstart, ystart). */

     public Turtle (Graphics g, double xstart, double ystart)
     {    page = (Graphics2D) g;
          xcor = xstart;
          ycor = ystart;
     }    //======================


     public Turtle()
     {    if (page == null)
          {    JFrame area = new JFrame ("Turtle drawings");
               area.addWindowListener (new Closer());  // in Chapter 9
               area.setSize (WIDTH, HEIGHT);
               area.setVisible (true);
               page = (Graphics2D) area.getGraphics();
               area.paint (page);
               page.setColor (BLACK);
          }
     }    //======================
}