// Decompiled by DJ v3.0.0.63 Copyright 2002 Atanas Neshkov  Date: 7/3/02 7:55:53 PM
// Home Page : http://members.fortunecity.com/neshkov/dj.html  - Check often for new version!
// Decompiler options: packimports(3)
// Source File Name:   Hangman.java

import java.applet.Applet;
import java.applet.AudioClip;
import java.awt.*;
import java.awt.event.*;
import java.io.*;

public class Hangman extends Applet
    implements Runnable, MouseListener, KeyListener
{

    public Hangman()
    {
        danceHeight = 68;
        danceImagesLen = 0;
        danceSequenceNum = -1;
        danceX = 0;
        danceDirection = 1;
    }

    public void init()
    {
        tracker = new MediaTracker(this);
        danceMusic = getAudioClip(getDocumentBase(), "audio/dance.au");
        danceImages = new Image[40];
        for(int i = 1; i < 8; i++)
        {
            Image image = getImage(getDocumentBase(), "images/dancing-duke/T" + i + ".gif");
            tracker.addImage(image, 0);
            danceImages[danceImagesLen++] = image;
        }

        hangImages = new Image[5];
        for(int j = 0; j < 5; j++)
        {
            Image image1 = getImage(getDocumentBase(), "images/hanging-duke/h" + (j + 1) + ".gif");
            tracker.addImage(image1, 1);
            hangImages[j] = image1;
        }

        wrongLettersCount = 0;
        wrongLetters = new char[5];
        secretWordLen = 0;
        secretWord = new char[20];
        word = new char[20];
        wordFont = new Font("Courier", 1, 24);
        wordFontMetrics = getFontMetrics(wordFont);
        resize(21 * wordFontMetrics.charWidth('M') + 60, 116 + wordFontMetrics.getHeight());
        addMouseListener(this);
        addKeyListener(this);
    }

    public void paint(Graphics g)
    {
        byte byte0 = 39;
        byte byte1 = 58;
        byte byte2 = 10;
        byte byte3 = 30;
        g.drawLine(byte3 / 2, 0, byte3 / 2, 2 * byte1 - byte2 / 2);
        g.drawLine(byte3 / 2, 0, byte3 + byte0 / 2, 0);
        g.drawLine(byte3 + byte0 / 2, 0, byte3 + byte0 / 2, byte1 / 3);
        g.fillRect(0, 2 * byte1 - byte2, byte3, byte2);
        Font font = new Font("Courier", 0, 15);
        FontMetrics fontmetrics = getFontMetrics(font);
        int i = byte0 + byte3;
        int j = fontmetrics.getHeight();
        g.setFont(font);
        g.setColor(Color.red);
        for(int k = 0; k < wrongLettersCount; k++)
        {
            g.drawChars(wrongLetters, k, 1, i, j);
            i += fontmetrics.charWidth(wrongLetters[k]) + fontmetrics.charWidth(' ');
        }

        if(secretWordLen > 0)
        {
            int l = wordFontMetrics.charWidth('M');
            int i1 = wordFontMetrics.getHeight();
            g.setFont(wordFont);
            g.setColor(Color.black);
            int j1 = 0;
            int k1 = getSize().height - 1;
            for(int l1 = 0; l1 < secretWordLen; l1++)
            {
                g.drawLine(j1, k1, j1 + l, k1);
                j1 += l + 3;
            }

            j1 = 0;
            k1 = getSize().height - 3;
            g.setColor(Color.blue);
            for(int i2 = 0; i2 < secretWordLen; i2++)
            {
                if(word[i2] != 0)
                    g.drawChars(word, i2, 1, j1, k1);
                j1 += l + 3;
            }

            if(wordLen < secretWordLen && wrongLettersCount > 0)
                g.drawImage(hangImages[wrongLettersCount - 1], byte3, byte1 / 3, this);
        }
    }

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

    void updateDancingDuke(Graphics g)
    {
        byte byte0 = 30;
        byte byte1 = 58;
        int i = danceSequence[danceSequenceNum];
        g.clearRect(danceX + byte0, byte1 * 2 - danceHeight, danceImageOffsets[i] + danceImageWidths[i], danceHeight);
        danceX += danceDirection;
        if(danceX < 0)
            danceX = danceDirection = (int)Math.floor(Math.random() * 12D) + 5;
        else
        if(danceX + byte0 > getSize().width / 2)
            danceDirection *= -1;
        else
        if(Math.random() > 0.89999997615814209D)
            danceDirection *= -1;
        danceSequenceNum++;
        if(danceSequenceNum >= danceSequence.length)
            danceSequenceNum = 0;
        i = danceSequence[danceSequenceNum];
        if(i < danceImagesLen && danceImages[i] != null)
            g.drawImage(danceImages[i], danceX + byte0 + danceImageOffsets[i], byte1 * 2 - danceHeight, this);
    }

    public void newGame()
    {
        danceThread = null;

        int i = 0;

        try
		        {
		            FileReader filereader = new FileReader("/home/QtPalmtop/java/wordlist.txt");
		            BufferedReader bufferedreader = new BufferedReader(filereader);
		            String s1;
		            while((s1 = bufferedreader.readLine()) != null)
		            {
		                //as[i] = s1;
		                i++;
		            }
		            filereader.close();
		        }
		        catch(Exception exception)
		        {
		            exception.printStackTrace();
        }

         String as[] = new String[i];
         i=0;
        try
        {
            FileReader filereader = new FileReader("/home/QtPalmtop/java/wordlist.txt");
            BufferedReader bufferedreader = new BufferedReader(filereader);
            String s1;
            while((s1 = bufferedreader.readLine()) != null)
            {
                as[i] = s1;
                i++;
            }
            filereader.close();
        }
        catch(Exception exception)
        {
            exception.printStackTrace();
        }
        String s = as[(int)Math.floor(Math.random() * (double)as.length)];
        secretWordLen = Math.min(s.length(), 20);
        for(int j = 0; j < secretWordLen; j++)
            secretWord[j] = s.charAt(j);

        for(int k = 0; k < 20; k++)
            word[k] = '\0';

        wordLen = 0;
        for(int l = 0; l < 5; l++)
            wrongLetters[l] = '\0';

        wrongLettersCount = 0;
        repaint();
    }

    public void start()
    {
        requestFocus();
        try
        {
            tracker.waitForID(1);
        }
        catch(InterruptedException interruptedexception) { }
        tracker.checkAll(true);
        if(secretWordLen == wordLen || wrongLettersCount == 5)
            newGame();
    }

    public void stop()
    {
        danceThread = null;
    }

    public void run()
    {
        try
        {
            tracker.waitForID(0);
        }
        catch(InterruptedException interruptedexception) { }
        Thread.currentThread().setPriority(1);
        danceMusic.loop();
        while(getSize().width > 0 && getSize().height > 0 && danceThread != null)
        {
            repaint();
            try
            {
                Thread.sleep(100L);
            }
            catch(InterruptedException interruptedexception1) { }
        }
        danceMusic.stop();
    }

    private void startDukeDancing()
    {
        if(danceThread == null)
        {
            danceThread = new Thread(this);
            danceThread.start();
        }
    }

    public String getAppletInfo()
    {
        return "Author: Patrick Chan\nVersion 1.5";
    }

    public void keyPressed(KeyEvent keyevent)
    {
    }

    public void keyReleased(KeyEvent keyevent)
    {
        boolean flag = false;
        char c = keyevent.getKeyChar();
        if(secretWordLen == wordLen || wrongLettersCount == 5)
        {
            newGame();
            keyevent.consume();
            return;
        }
        if(c < 'a' || c > 'z')
        {
            play(getDocumentBase(), "audio/beep.au");
            keyevent.consume();
            return;
        }
        for(int i = 0; i < secretWordLen; i++)
            if(c == word[i])
            {
                flag = true;
                play(getDocumentBase(), "audio/ding.au");
                keyevent.consume();
                return;
            }

        if(!flag)
        {
            for(int j = 0; j < 5; j++)
                if(c == wrongLetters[j])
                {
                    flag = true;
                    play(getDocumentBase(), "audio/ding.au");
                    keyevent.consume();
                    return;
                }

        }
        if(!flag)
        {
            for(int k = 0; k < secretWordLen; k++)
                if(c == secretWord[k])
                {
                    word[k] = c;
                    wordLen++;
                    flag = true;
                }

            if(flag)
                if(wordLen == secretWordLen)
                {
                    play(getDocumentBase(), "audio/whoopy.au");
                    startDukeDancing();
                } else
                {
                    play(getDocumentBase(), "audio/ah.au");
                }
        }
        if(!flag && wrongLettersCount < wrongLetters.length)
        {
            wrongLetters[wrongLettersCount++] = c;
            if(wrongLettersCount < 5)
            {
                play(getDocumentBase(), "audio/ooh.au");
            } else
            {
                for(int l = 0; l < secretWordLen; l++)
                    word[l] = secretWord[l];

                play(getDocumentBase(), "audio/scream.au");
            }
        }
        if(wordLen == secretWordLen)
            danceSequenceNum = -1;
        repaint();
        keyevent.consume();
    }

    public void keyTyped(KeyEvent keyevent)
    {
    }

    public void mouseClicked(MouseEvent mouseevent)
    {
    }

    public void mouseReleased(MouseEvent mouseevent)
    {
    }

    public void mousePressed(MouseEvent mouseevent)
    {
        requestFocus();
        if(secretWordLen > 0 && (secretWordLen == wordLen || wrongLettersCount == 5))
            newGame();
        else
            play(getDocumentBase(), "audio/beep.au");
        mouseevent.consume();
    }

    public void mouseEntered(MouseEvent mouseevent)
    {
    }

    public void mouseExited(MouseEvent mouseevent)
    {
    }

    final int maxTries = 5;
    final int maxWordLen = 20;
    char secretWord[];
    int secretWordLen;
    char wrongLetters[];
    int wrongLettersCount;
    char word[];
    int wordLen;
    Font wordFont;
    FontMetrics wordFontMetrics;
    MediaTracker tracker;
    static final int DANCECLASS = 0;
    static final int HANGCLASS = 1;
    Image hangImages[];
    final int hangImagesWidth = 39;
    final int hangImagesHeight = 58;
    Thread danceThread;
    Image danceImages[];
    private int danceImageWidths[] = {
        70, 85, 87, 90, 87, 85, 70
    };
    int danceHeight;
    int danceImagesLen;
    private int danceImageOffsets[] = {
        8, 0, 0, 8, 18, 21, 27
    };
    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
    };
    int danceSequenceNum;
    int danceX;
    int danceDirection;
    AudioClip danceMusic;

}