import java.*;
import awt.*;
import java.io.*;
import net.www.html.*;
import browser.*;
import browser.audio.*;
import browser.Applet;



class DukeHangOl extends Applet implements Runnable {

    /* This is the maximum number of incorrect guesses. */
    final int maxTries = 5;

    /* This is the maximum length of a secret word. */
    final int maxWordLen = 15;

    /* This buffer holds the letters in the secret word. */
    char secretWord[];

    /* This is the length of the secret word. */
    int secretWordLen;

    /* This buffer holds the letters which the user typed
       but don't appear in the secret word. */
    char wrongLetters[];
    
    /* This is the current number of incorrect guesses. */
    int wrongLettersCount;

    /* This buffer holds letters that the user has successfully
       guessed. */
    char word[];

    /* Number of correct letters in 'word'. */
    int wordLen;

    /* This is the font used to paint correctly guessed letters. */
    Font wordFont;

    /* This is the sequence of images for Duke hanging on the gallows. */
    Image hangImages[];

    // Dancing Duke related variables

    /* This thread makes Duke dance. */
    Thread danceThread;

    /* These are the images that make up the dance animation. */
    Image danceImages[];

    /* This variable holds the number of valid images in danceImages. */
    int danceImagesLen = 0;

    /* These offsets refer to the dance images.  The dance images
       are not of the same size so we need to add these offset 
       in order to make the images "line" up. */
    private int danceImageOffsets[] = { 0, 20, 0, 20, 20, 0, 27 };

    /* This represents the sequence to display the dance images
       in order to make Duke "dance".  */
    private int danceSequence[] = { 3, 4, 5, 6, 6, 5, 6, 6, 5, 4, 3, 
            2, 1, 0, 0, 1, 2, 2, 1, 0, 0, 1, 2 };

    /* This is the current sequence number.  -1 implies
       that Duke hasn't begun to dance. */
    int danceSequenceNum = -1;

    /* This is the maximum width and height of all the dance images. */
    int danceHeight = 0;

    /* This variable is used to adjust Duke's x-position while
       he's dancing. */
    int danceX = 0;

    /* This variable specifies the currently x-direction of
       Duke's dance.  1=>right and -1=>left. */
    int danceDirection = 1;

    /* This is the stream for the dance music. */
    InputStream danceMusic;

    /**
     * Initialize the applet. Resize and load images.
     */
    public void init() {

        int i;

        // load in dance animation
	danceMusic = getContinuousAudioStream(
	    new URL(appletURL, "audio/dance.au"));
	danceImages = new Image[40];

	for (i = 1; i < 8; i++) {
	    Image im = getImage("images/dancing-duke/T" + i + ".gif");

	    if (im == null) {
		break;
	    }
	    danceHeight = Math.max(danceHeight, im.height);
	    danceImages[danceImagesLen++] = im;
        }

        // load in hangman image sequnce
        hangImages = new Image[maxTries];
        for (i=0; i 0) {
	    // draw underlines for secret word
	    int Mwidth = wordFont.widths['M'];
	    int Mheight = wordFont.height;
	    g.setFont(wordFont);
	    g.setForeground(Color.yellow);
	    x = 0;
	    y = height - 1 ;
	    for (i=0; i 0) {
		// draw Duke on gallows
		g.drawImage(hangImages[wrongLettersCount-1], 
                    (1.9*baseW), imageH);
	    }
        }
 		
    }

    public void update(Graphics g) {
	if (wordLen == 0) {
	    g.clearRect(0, 0, width, height);
            paint(g);
	} else if (wordLen == secretWordLen) {
            if (danceSequenceNum < 0) {
		g.clearRect(0, 0, width, height);
		paint(g);
		danceSequenceNum = 0;
	    }
            updateDancingDuke(g);
        } else {
		 paint(g); 
        }
    }

    void updateDancingDuke(Graphics g) {
Image img, img1;
img = getImage("images/koala.gif");
/* img1 = getImage("images/crab.gif"); */
int q,w;
boolean m=true;

        int baseW = 30;
        int imageH = hangImages[0].height;
	int danceImageNum = danceSequence[danceSequenceNum];
q = 100;
w = 150;
	// first, clear Duke's current image
	g.clearRect(danceX+baseW, imageH*2 - danceHeight, 
            danceImageOffsets[danceImageNum]+danceImages[danceImageNum].width, 
            danceHeight);

        // update dance position
	danceX += danceDirection;
	if (danceX < 0) {
	    danceX = danceDirection = (int)Math.floor(Math.random() * 12) + 5;
	} else if (danceX + baseW > width / 2) {
	    //danceDirection = -(int)Math.floor(Math.random() * 12) - 5;
	    danceDirection *= -1;
	} else if (Math.random() > .9) {
	    danceDirection *= -1;
	}

        // update dance sequence
	danceSequenceNum++;
	if (danceSequenceNum >= danceSequence.length) {
	    danceSequenceNum = 0;
        }

	// now paint Duke's new image
	danceImageNum = danceSequence[danceSequenceNum];
	if ((danceImageNum < danceImagesLen) && (danceImages[danceImageNum] != null)) {
	    g.drawImage(danceImages[danceImageNum], 
		danceX+baseW+danceImageOffsets[danceImageNum], 
		imageH*2 - danceHeight);
	       m = true;
if (m=true) {
drawupdate(g); 
}
   	}
    }


void drawupdate(Graphics g) {
Image img, img1;
img = getImage("images/koala.gif");
int q,w;
q = 100;
w = 150;
g.drawImage(img,q,w); 
g.setForeground(Color.green);
g.drawString("Hello Everyone", 300, 300);

}



    public void keyDown(int key) {
        int i;
        boolean found = false;

        // start new game if user has already won or lost.
        if (secretWordLen == wordLen || wrongLettersCount == maxTries) {
            newGame();
            return;
        }

        // check if valid letter
        if (key < 'a' || key > 'z') {
	    play("audio/beep.au");
            return;    
        }
        // check if already in secret word
        for (i=0; i 0 && 
           (secretWordLen == wordLen || wrongLettersCount == maxTries)) {
	    newGame();
        } else {
	    play("audio/beep.au");
        }
    }

    /**
     * Starts a new game.  Chooses a new secret word
     * and clears all the buffers
     */
    public void newGame() {


        int i;
        // stop animation thread.
        danceThread = null;
    // pick secret word
        String s = wordlist[(int)Math.floor(Math.random() * wordlist.length)];
        secretWordLen = Math.min(s.length(), maxWordLen);
        for (i=0; i 0 && height > 0 && danceThread != null) {
	    repaint();
	    Thread.sleep(100);
	}

        // The dance is done so stop the music.
	stopPlaying(danceMusic);
    }

    /**
     * Starts Duke's dancing animation.
     */
    private void startDukeDancing () {
	if (danceThread == null) {
	    danceThread = new Thread(this);
	    danceThread.start();
	}
    }

    /* This is the hangman's limited word list. */
    String wordlist[] = {
        "alligator",
        "bear",
        "bat",
        "cat",
	"chipmunk",
	"crab",
	"dog",
        "dinasour"};
}