/*********************************************************************
/ Wheel.java
/ Written by Timothy M. Bailey
/ Started: March 31, 1998
/ Updated: May 13, 1998
/
/ Wheel of Fortune applet for cs406 class with Dr. Roger Webster
/
********************************/

import java.awt.*;
import java.applet.*;
import java.net.*;
import java.util.*;

public class Wheel extends Applet implements Runnable {
    TitlePanel titlePanel;
    PuzzlePanel puzzlePanel;
    PlayerPanel playerPanel;
    ButtonPanel buttonPanel;
    CardPanel cardPanel;
    SpinPanel spinPanel;
    public static final int DONE = 0;
    public static final int SPIN = 1;
    int num_puzzles = 88;
    int num_amounts = 30;
    int puzzle1, puzzle2, puzzle3, puzzle4, current_puzzle;
    int vowel_count, letter_count, state, vowel_bell, intro_clip;
    int curr_spin, gameMoney, matchMoney;
    int intAmount[] = new int[num_amounts];
    Image titleImage, noiseImage, grayImage, pointer, guessx, guesso;
    Image letters[] = new Image[27];
    Image Amount[] = new Image[num_amounts];
    Image puzzle_images[][] = new Image[8][15];
    char puzzle[][] = new char[8][15];
    String puzzles[] = new String[num_puzzles];
    String type[] = new String[num_puzzles];
    String playerName = new String("");
    AudioClip ding, wrong, start, intro, vowel, bankrupt, solve, spin;
    PuzzleDialog pd;
    Thread th;
    Random rand = new Random(), rand2 = new Random();
    Frame f = new Frame("");

    public void init() {
	int i, j;

	LoadSounds();
	intro_clip = 0;
	intro.play();
	LoadImages();
	GetPuzzles();

	this.setBackground(new Color(11,111,20));

	LoginWindow login = new LoginWindow(f, "Wheel of Treasures", this); // pop up a window requesting the player's name

	titlePanel = new TitlePanel(titleImage);
	puzzlePanel = new PuzzlePanel(puzzle_images);
	playerPanel = new PlayerPanel(guessx, guesso, playerName);
	buttonPanel = new ButtonPanel();
	cardPanel = new CardPanel();
	spinPanel = new SpinPanel(Amount[0], pointer);
	this.add(titlePanel);
	this.add(puzzlePanel);
	this.add(playerPanel);
	this.add(buttonPanel);
	this.add(spinPanel);
	this.add(cardPanel);

	this.show();
	this.repaint();
	
	matchMoney = 0; // set the match money to $0
	playerPanel.setMatchMoney(matchMoney);

	state = DONE;
	current_puzzle = puzzle1;
	SetupPuzzle(current_puzzle);
    }

    public void start() {
	// start the thread so that we are able to sleep when we need to
	if (th == null) {
	    th = new Thread(this);
	    th.start();
	}
    }

    public void destroy() {
	// this is supposed to get rid of any windows if they happen to be around
	try {
	    if (pd.isVisible()) {
	    	pd.hide();
	    	pd.dispose();
	    }
	} catch (NullPointerException ex) {}
    }

    public void run() {
    }

    public void paint (Graphics g) {
	titlePanel.repaint();
	puzzlePanel.repaint();
	playerPanel.repaint();
	buttonPanel.repaint();
	cardPanel.repaint();
	spinPanel.repaint();
    }


    public void LoadImages() {
	int i, j;
	char ch;
	URL docBase;

	docBase = getDocumentBase();
	MediaTracker tracker = new MediaTracker(this);
	titleImage = getImage(docBase, "./images/logo2.jpg");
	tracker.addImage(titleImage,0);
	noiseImage = getImage(docBase, "./images/noise.jpg");
	tracker.addImage(noiseImage,0);
	grayImage = getImage(docBase, "./images/gray.jpg");
	tracker.addImage(grayImage,0);
	pointer = getImage(docBase, "./images/pointer.jpg");
	tracker.addImage(pointer,0);
	guessx = getImage(docBase, "./images/guessx.jpg");
	tracker.addImage(guessx,0);
	guesso = getImage(docBase, "./images/guesso.jpg");
	tracker.addImage(guesso,0);

	// load the wheel images
	Amount[0] = getImage(docBase, "./images/100.jpg");
	intAmount[0] = 100;
	Amount[1] = getImage(docBase, "./images/200.jpg");
	intAmount[1] = 200;
	Amount[2] = getImage(docBase, "./images/250.jpg");
	intAmount[2] = 250;
	Amount[3] = getImage(docBase, "./images/300.jpg");
	intAmount[3] = 300;
	Amount[4] = getImage(docBase, "./images/350.jpg");
	intAmount[4] = 350;
	Amount[5] = getImage(docBase, "./images/400.jpg");
	intAmount[5] = 400;
	Amount[6] = getImage(docBase, "./images/450.jpg");
	intAmount[6] = 450;
	Amount[7] = getImage(docBase, "./images/500.jpg");
	intAmount[7] = 500;
	Amount[8] = getImage(docBase, "./images/750.jpg");
	intAmount[8] = 750;
	Amount[9] = getImage(docBase, "./images/1000.jpg");
	intAmount[9] = 1000;
	Amount[10] = getImage(docBase, "./images/1250.jpg");
	intAmount[10] = 1250;
	Amount[11] = getImage(docBase, "./images/1500.jpg");
	intAmount[11] = 1500;
	Amount[12] = getImage(docBase, "./images/2000.jpg");
	intAmount[12] = 2000;
	Amount[13] = getImage(docBase, "./images/2500.jpg");
	intAmount[13] = 2500;
	Amount[14] = getImage(docBase, "./images/bankrupt.jpg");
	intAmount[14] = -1;
	Amount[15] = getImage(docBase, "./images/lose_a_turn.jpg");
	intAmount[15] = 0;

	// the next few lines adds more aof the lower amounts into the array of amounts.
	// this improves the probablitity of gettting the lower dollar amounts
	Amount[16] = Amount[0];
	intAmount[16] = intAmount[0];
	Amount[17] = Amount[0];
	intAmount[17] = intAmount[0];
	Amount[18] = Amount[1];
	intAmount[18] = intAmount[1];
	Amount[19] = Amount[1];
	intAmount[19] = intAmount[1];
	Amount[20] = Amount[2];
	intAmount[20] = intAmount[2];
	Amount[21] = Amount[2];
	intAmount[21] = intAmount[2];
	Amount[22] = Amount[3];
	intAmount[22] = intAmount[3];
	Amount[23] = Amount[3];
	intAmount[23] = intAmount[3];
	Amount[24] = Amount[4];
	intAmount[24] = intAmount[4];
	Amount[25] = Amount[5];
	intAmount[25] = intAmount[5];
	Amount[26] = Amount[6];
	intAmount[26] = intAmount[6];
	Amount[27] = Amount[7];
	intAmount[27] = intAmount[7];
	Amount[28] = Amount[14];
	intAmount[28] = intAmount[14];
	Amount[29] = Amount[15];
	intAmount[29] = intAmount[15];
	for (i=0; i<=15; i++) {
	    tracker.addImage(Amount[i],0);
	}

	for (ch='a', i=0; ch<='z'; ch++, i++) {
	    letters[i] = getImage(docBase, "./images/"+ch+".jpg");
	    tracker.addImage(letters[i], 0);
	}
	letters[i] = getImage(docBase, "./images/apos.jpg");
	tracker.addImage(letters[i], 0);
	try {
    	    tracker.waitForID(0);
	}
	catch(InterruptedException e) {
	    e.printStackTrace();
	}
    }

    public void LoadSounds() {
	ding = getAudioClip(getCodeBase(), "./sounds/letter.au");
	wrong = getAudioClip(getCodeBase(), "./sounds/wrong.au");
	intro = getAudioClip(getCodeBase(), "./sounds/intro.au");
	start = getAudioClip(getCodeBase(), "./sounds/start.au");
	vowel = getAudioClip(getCodeBase(), "./sounds/vowel.au");
	bankrupt = getAudioClip(getCodeBase(), "./sounds/bankrupt.au");
	solve = getAudioClip(getCodeBase(), "./sounds/solve.au");
	spin = getAudioClip(getCodeBase(), "./sounds/spin.au");
    }

    public void GetPuzzles() {
	// if this game were being done on a server, these puzzles could be in a flat
	// file.  The random routine could also be done there, with only the selected
	// puzzles being sent to the client.
	puzzles[0] = "game over    hit shift and reload to start a new game.";
	type[0] = "Phrase";
	puzzles[1] = "all roads lead to rome.";
	type[1] = "Phrase";
	puzzles[2] = "most likely to succeed.";
	type[2] = "Phrase";
	puzzles[3] = "christmas dinner with all the trimmings.";
	type[3] = "Phrase";
	puzzles[4] = "six to one half a dozen to the other.";
	type[4] = "Phrase";
	puzzles[5] = "throwing the baby out with the bath water.";
	type[5] = "Phrase";
	puzzles[6] = "counting your chickens before they've hatched.";
	type[6] = "Phrase";
	puzzles[7] = "as the crow flies.";
	type[7] = "Phrase";
	puzzles[8] = "beating a dead horse.";
	type[8] = "Phrase";
	puzzles[9] = "comparing apples and oranges.";
	type[9] = "Phrase";
	puzzles[10] = "politics makes for strange bedfellows.";
	type[10] = "Phrase";
	puzzles[11] = "indiana jones and the last crusade.";
	type[11] = "Title";
	puzzles[12] = "doctor jekyll and mister hyde.";
	type[12] = "Title";
	puzzles[13] = "the hunchback of notre dame.";
	type[13] = "Title";
	puzzles[14] = "late night with david letterman.";
	type[14] = "Title";
	puzzles[15] = "a christmas carol.";
	type[15] = "Title";
	puzzles[16] = "the three musketeers.";
	type[16] = "Title";
	puzzles[17] = "the gift of the magi.";
	type[17] = "Title";
	puzzles[18] = "monty python and the holy grail.";
	type[18] = "Title";
	puzzles[19] = "the adventures of huckleberry finn.";
	type[19] = "Title";
	puzzles[20] = "the catcher in the rye.";
	type[20] = "Title";
	puzzles[21] = "college dormitory.";
	type[21] = "Place";
	puzzles[22] = "international airport.";
	type[22] = "Place";
	puzzles[23] = "seattle washington.";
	type[23] = "Place";
	puzzles[24] = "notre dame university.";
	type[24] = "Place";
	puzzles[25] = "showboat casino in atlantic city.";
	type[25] = "Place";
	puzzles[26] = "madison square garden.";
	type[26] = "Place";
	puzzles[27] = "london england.";
	type[27] = "Place";
	puzzles[28] = "mount rushmore.";
	type[28] = "Place";
	puzzles[29] = "the canary islands.";
	type[29] = "Place";
	puzzles[30] = "the sea of tranquility.";
	type[30] = "Place";
	puzzles[31] = "country singer garth brooks.";
	type[31] = "Person";
	puzzles[32] = "philadelphia flyers.";
	type[32] = "People";
	puzzles[33] = "chevy chase.";
	type[33] = "Person";
	puzzles[34] = "the people's court judge ed koch.";
	type[34] = "Person";
	puzzles[35] = "gossip columnist liz smith.";
	type[35] = "Person";
	puzzles[36] = "winston churchill.";
	type[36] = "Person";
	puzzles[37] = "ernest hemingway.";
	type[37] = "Person";
	puzzles[38] = "tarzan king of the apes.";
	type[38] = "Person";
	puzzles[39] = "king henry the eighth.";
	type[39] = "Person";
	puzzles[40] = "carly simon and garfunkle.";
	type[40] = "Before & After";
	puzzles[41] = "chemistry teacher.";
	type[41] = "Occupation";
	puzzles[42] = "washington monument.";
	type[42] = "Landmark";
	puzzles[43] = "bottled water under the bridge.";
	type[43] = "Before & After";
	puzzles[44] = "periodic table manners.";
	type[44] = "Before & After";
	puzzles[45] = "children of the corn tortillas.";
	type[45] = "Before & After";
	puzzles[46] = "greco roman wrestling.";
	type[46] = "Event";
	puzzles[47] = "papal bull fighter.";
	type[47] = "Before & After";
	puzzles[48] = "give me liberty or give me death.";
	type[48] = "Quotation";
	puzzles[49] = "pat and daniel boone.";
	type[49] = "Same Name";
	puzzles[50] = "lookout point of no return.";
	type[50] = "Before & After";
	puzzles[51] = "pumpkin pie with whipped cream.";
	type[51] = "Things";
	puzzles[52] = "apple macintosh computer.";
	type[52] = "Thing";
	puzzles[53] = "chevrolet cavalier.";
	type[53] = "Thing";
	puzzles[54] = "three piece suit.";
	type[54] = "Thing";
	puzzles[55] = "four leaf clover.";
	type[55] = "Thing";
	puzzles[56] = "the loch ness monster.";
	type[56] = "Thing";
	puzzles[57] = "ninety mile an hour fastball.";
	type[57] = "Thing";
	puzzles[58] = "internal combustion engine.";
	type[58] = "Thing";
	puzzles[59] = "the great wall of china.";
	type[59] = "Thing";
	puzzles[60] = "the stanley cup.";
	type[60] = "Thing";
	puzzles[61] = "beggars can't be choosers.";
	type[61] = "Phrase";
	puzzles[62] = "the only thing we have to fear is fear itself.";
	type[62] = "Quotation";
	puzzles[63] = "oh my god the cubs win the pennant.";
	type[63] = "Quotation";
	puzzles[64] = "four score and seven years ago.";
	type[64] = "Quotation";
	puzzles[65] = "winona ryder truck.";
	type[65] = "Before & After";
	puzzles[66] = "filing for bankruptcy.";
	type[66] = "Event";
	puzzles[67] = "gold rush limbaugh.";
	type[67] = "Before & After";
	puzzles[68] = "bud abbott and lou costello.";
	type[68] = "People";
	puzzles[69] = "to be or not to be that is the question.";
	type[69] = "Quotation";
	puzzles[70] = "go ahead make my day.";
	type[70] = "Quotation";
	puzzles[71] = "stuck between a rock and a hard place.";
	type[71] = "Phrase";
	puzzles[72] = "stuck in the middle with you.";
	type[72] = "Title";
	puzzles[73] = "i get by with a little help from my friends.";
	type[73] = "Quotation";
	puzzles[74] = "frankly scarlett i don't give a damn.";
	type[74] = "Quotation";
	puzzles[75] = "little shop of horrors.";
	type[75] = "Title";
	puzzles[76] = "supermodel kathy ireland.";
	type[76] = "Person";
	puzzles[77] = "to bite off your nose to spite your face.";
	type[77] = "Phrase";
	puzzles[78] = "can't see the forest for the trees.";
	type[78] = "Phrase";
	puzzles[79] = "whipped cream of wheat.";
	type[79] = "Before & After";
	puzzles[80] = "wealth of nations.";
	type[80] = "Title";
	puzzles[81] = "communist manifesto.";
	type[81] = "Title";
	puzzles[82] = "gone with the wind.";
	type[82] = "Title";
	puzzles[83] = "a coney island hot dog.";
	type[83] = "Thing";
	puzzles[84] = "falling asleep on the job.";
	type[84] = "Phrase";
	puzzles[85] = "one flew over the cuckoo's nest.";
	type[85] = "Title";
	puzzles[86] = "alfred hitchcock.";
	type[86] = "Person";
	puzzles[87] = "twenty thousand leagues under the sea.";
	type[87] = "Title";

	int nextPuzzle;
	
	// do random selection here.
	nextPuzzle = rand2.nextInt() % num_puzzles;
	// if the random number is negative, invert it
	if (nextPuzzle < 0) {
		nextPuzzle *= -1;
	}
	// if the puzzle is 0, pick another -- 0 is for the end of the game
	while (nextPuzzle == 0) {
	    nextPuzzle = rand2.nextInt() % num_puzzles;
	    if (nextPuzzle < 0) {
		nextPuzzle *= -1;
	    }
	}
	puzzle1 = nextPuzzle;

	nextPuzzle = rand2.nextInt() % num_puzzles;
	if (nextPuzzle < 0) {
		nextPuzzle *= -1;
	}
	// if the puzzle is 0 or the same as the first, pick another
	while ((nextPuzzle == puzzle1) || (nextPuzzle == 0)) {
	    nextPuzzle = rand2.nextInt() % num_puzzles;
	    if (nextPuzzle < 0) {
		nextPuzzle *= -1;
	    }
	}
	puzzle2 = nextPuzzle;

	nextPuzzle = rand2.nextInt() % num_puzzles;
	if (nextPuzzle < 0) {
		nextPuzzle *= -1;
	}
	// if the puzzle is 0, or the same as puzzle1 or puzzle2, pick another
	while ((nextPuzzle == puzzle1) || (nextPuzzle == puzzle2) || (nextPuzzle == 0)) {
	    nextPuzzle = rand2.nextInt() % num_puzzles;
	    if (nextPuzzle < 0) {
		nextPuzzle *= -1;
	    }
	}
	puzzle3 = nextPuzzle;
	puzzle4 = 0;
    }

    public void SetupPuzzle(int puzzle_number) {
	char ch, word[] = new char[15];
	int len, temp_count;
	int i, j, x, y;

	// clear the player panel of any garbage and reset the count
	playerPanel.spinWorth = "";
	playerPanel.letterCount = "";
	playerPanel.resetGuess();
	playerPanel.repaint();

	// if this is the first puzzle, make sure intro won't play anymore
	if (intro_clip == 0) {
	    try {
	    	th.sleep(17000);
	    	intro_clip = 1;
	    } catch (InterruptedException e) {}
	}

	// turn all letters into noise images to "clear" board
	for (i=0; i<8; i++) {
	    for (j=0; j<15; j++) {
		puzzle_images[i][j] = noiseImage;
		puzzle[i][j] = ' ';
	    }
 	}
	puzzlePanel.repaint();

	vowel_count = 0;
	letter_count = 0;
	vowel_bell = 0;

	// show the type of puzzle
	puzzlePanel.puzzleType = type[puzzle_number];

	// layout the puzzle -- no words spanning 2 lines, etc.  semi-complex algorithm
	x = 0; y = 0;
	temp_count = 0;
	len = puzzles[puzzle_number].length();
	for (i=0; i<len; i++) {
	    ch = puzzles[puzzle_number].charAt(i);
	    // if ch != ' ', store ch in word
	    if ((ch != ' ') && (ch != '.')) {
		if ((ch == 'a') || (ch == 'e') || (ch == 'i') || (ch == 'o') || (ch == 'u')) {
		    vowel_count++;
		}
		letter_count++;
		word[temp_count] = ch;
		temp_count++;
	    } else {
		// if ch == ' ', display gray squares for letters
		if (temp_count > (15-x)) {
		    x = 0;
		    y++;
		}
		for (int w=x; w<x+temp_count; w++) {
		    if (word[w-x] == '\'') {
			letter_count--;
			puzzle_images[y][w] = letters[26];
		    } else {
		    	puzzle_images[y][w] = grayImage;
		    }
		    puzzle[y][w] = word[w-x];
		}
		x += temp_count + 1;  // adds a space between words
		temp_count = 0;
		for (int z=0; z<15; z++) {
			word[z] = ' ';
		}
	    }
	}
	// reset gameMoney to 0
	gameMoney = 0;
	playerPanel.setGameMoney(gameMoney);

	// play sound clip to start new puzzle
	start.play();
	// make sure that the spin card is showing
	cardPanel.cardLayout.show(cardPanel.cards, "Spin");
	ShowButtons();

	if (current_puzzle == puzzle4) {
	    EndOfGame();
	}
    }

    void EndOfGame() {
	// when the game is over, show puzzle[0] and hide the card and button panels.
	// this assures that the user cannot do anything when the game is over.
	ShowPuzzle();
	cardPanel.hide();
	buttonPanel.hide();	
    }

    public void ShowButtons() {

	cardPanel.a.show();
	cardPanel.b.show();
	cardPanel.c.show();
	cardPanel.d.show();
	cardPanel.e.show();
	cardPanel.f.show();
	cardPanel.g.show();
	cardPanel.h.show();
	cardPanel.i.show();
	cardPanel.j.show();
	cardPanel.k.show();
	cardPanel.l.show();
	cardPanel.m.show();
	cardPanel.n.show();
	cardPanel.o.show();
	cardPanel.p.show();
	cardPanel.q.show();
	cardPanel.r.show();
	cardPanel.s.show();
	cardPanel.t.show();
	cardPanel.u.show();
	cardPanel.v.show();
	cardPanel.w.show();
	cardPanel.x.show();
	cardPanel.y.show();
	cardPanel.z.show();
    }


    public void SpinWheel() {
	int index;
	int solved = 1;

	// clear the status fields in the player panel
	playerPanel.spinWorth = "";
	playerPanel.letterCount = "";

	// play the sound clip and sleep while it is playing
	try {
	    spin.play();
	    th.sleep(3500);
	} catch (InterruptedException e) {}

	// do random selection for the amount of the spin
	index = rand.nextInt() % num_amounts;
	if (index < 0) {
	    index = index * -1;
	}
	if (intAmount[index] == -1) { // bankrupt
	    state = DONE;
	    gameMoney = 0;
	    if (playerPanel.guessWrong() == 5) {
		solved = 0;
	    }
	    playerPanel.setGameMoney(gameMoney);
	    bankrupt.play();
	    playerPanel.spinWorth = "Bankrupt!!!  Lose all your money!";
	} else if (intAmount[index] == 0) { // lose turn
	    state = DONE;
	    if (playerPanel.guessWrong() == 5) {
		solved = 0;
	    }
	    wrong.play();
	    playerPanel.spinWorth = "Lose a Turn";
	} else {
	    playerPanel.spinWorth = "Spin is worth $"+intAmount[index];
	}
	playerPanel.repaint();
	curr_spin = intAmount[index];
	spinPanel.spin(Amount[index]);

	if (solved == 0) {
	    PuzzleSolved(0);  // send 0 since puzzle NOT solved correctly and all chances used up
	} // else, keep playing same puzzle	
    }


    public void GetLetter(char chosen, int index) {
	int i, j, count = 0;
	int solved = -1;

	// see if letter is in the puzzle
	for (i=0; i<8; i++) {
	    for (j=0; j<15; j++) {
		if (chosen == puzzle[i][j]) {
		    count++;	
		    puzzle_images[i][j] = letters[index];
		    try {
	    		ding.play();
	    		th.sleep(1000);
		    } catch (InterruptedException e) {}
		}
	    }
	}

	if (count == 0) { // letter not in puzzle, play buzz sound
	    wrong.play();
	    if (playerPanel.guessWrong() == 5) {
		solved = 0;
	    }
	} else { // decrement the count of letters in the puzzle
	    letter_count -= count;
	    if (letter_count == 0) { // all letters have been chosen
		solved = 1;  
	    }
	    if ((chosen == 'a') || (chosen == 'e') || (chosen == 'i') || (chosen == 'o') || (chosen == 'u')) {
	    // vowel, decrement money and vowel count
		vowel_count -= count;
		gameMoney -= 250;
	    	playerPanel.setGameMoney(gameMoney);
	    } else { // increase money appropriately
	    	gameMoney += (count * curr_spin);
	    	playerPanel.setGameMoney(gameMoney);
	    }
	    puzzlePanel.repaint();
	}

	if (((letter_count - vowel_count) == 0) && (vowel_bell == 0)) {  // if only vowels left in the puzzle
	    vowel.play();
	    pd = new PuzzleDialog(f, "Vowels Left", "There are only VOWELS left in the puzzle!");
	    pd.show();
	    vowel_bell = 1;
	}

	// display number of correct letters that appear in the puzzle
	if (count == 1) {
	    playerPanel.letterCount = "There is "+count+" "+chosen;
	} else {
	    playerPanel.letterCount = "There are "+count+" "+chosen+"'s";
	}
	if (solved == 0) {
	    PuzzleSolved(0);  // send 0 since puzzle NOT solved correctly and all chances used up
	} else if (solved == 1) {
	    PuzzleSolved(1);  // send 1 since puzzle solved correctly
	} // else, keep playing same puzzle	
    }

    void ShowPuzzle() {
	int i, j;

	// puzzle is solved correctly, or all five chances are used up.
	// show the puzzle
	if (letter_count != 0) {
	    for (i=0; i<8; i++) {
	    	for (j=0; j<15; j++) {
		    if (puzzle[i][j] == 'a') {
		    	puzzle_images[i][j] = letters[0];
		    } else if (puzzle[i][j] == 'b') {
		    	puzzle_images[i][j] = letters[1];
		    } else if (puzzle[i][j] == 'c') {
			puzzle_images[i][j] = letters[2];
		    } else if (puzzle[i][j] == 'd') {
		    	puzzle_images[i][j] = letters[3];
		    } else if (puzzle[i][j] == 'e') {
		    	puzzle_images[i][j] = letters[4];
		    } else if (puzzle[i][j] == 'f') {
		    	puzzle_images[i][j] = letters[5];
		    } else if (puzzle[i][j] == 'g') {
		    	puzzle_images[i][j] = letters[6];
		    } else if (puzzle[i][j] == 'h') {
		    	puzzle_images[i][j] = letters[7];
		    } else if (puzzle[i][j] == 'i') {
		    	puzzle_images[i][j] = letters[8];
		    } else if (puzzle[i][j] == 'j') {
		    	puzzle_images[i][j] = letters[9];
		    } else if (puzzle[i][j] == 'k') {
		    	puzzle_images[i][j] = letters[10];
		    } else if (puzzle[i][j] == 'l') {
		    	puzzle_images[i][j] = letters[11];
		    } else if (puzzle[i][j] == 'm') {
		    	puzzle_images[i][j] = letters[12];
		    } else if (puzzle[i][j] == 'n') {
		    	puzzle_images[i][j] = letters[13];
		    } else if (puzzle[i][j] == 'o') {
		    	puzzle_images[i][j] = letters[14];
		    } else if (puzzle[i][j] == 'p') {
		    	puzzle_images[i][j] = letters[15];
		    } else if (puzzle[i][j] == 'q') {
		    	puzzle_images[i][j] = letters[16];
		    } else if (puzzle[i][j] == 'r') {
		    	puzzle_images[i][j] = letters[17];
		    } else if (puzzle[i][j] == 's') {
		    	puzzle_images[i][j] = letters[18];
		    } else if (puzzle[i][j] == 't') {
		    	puzzle_images[i][j] = letters[19];
		    } else if (puzzle[i][j] == 'u') {
		        puzzle_images[i][j] = letters[20];
		    } else if (puzzle[i][j] == 'v') {
		    	puzzle_images[i][j] = letters[21];
		    } else if (puzzle[i][j] == 'w') {
		    	puzzle_images[i][j] = letters[22];
		    } else if (puzzle[i][j] == 'x') {
		    	puzzle_images[i][j] = letters[23];
		    } else if (puzzle[i][j] == 'y') {
		    	puzzle_images[i][j] = letters[24];
		    } else if (puzzle[i][j] == 'z') {
		    	puzzle_images[i][j] = letters[25];
		    }
		} 
	    }
	    puzzlePanel.repaint();
	} // end if letter_count != 0
    }

    public void PuzzleSolved(int correct) {
	ShowPuzzle();

	if (correct == 1) {  // correctly solved the puzzle
	    solve.play();
	    pd = new PuzzleDialog(f, "Congratulations", "You solved the puzzle. Click OK to continue");
	    pd.show();
	    matchMoney += gameMoney;
	    playerPanel.setMatchMoney(matchMoney);
	} else {  // ran out of chances
	    pd = new PuzzleDialog(f, "Sorry!", "You used up your five chances. Click OK to continue");
	    pd.show();
	}

	// select the new puzzle
	if (current_puzzle == puzzle1) {
	   current_puzzle = puzzle2;
	} else if (current_puzzle == puzzle2) {
	   current_puzzle = puzzle3;
	} else {
	    current_puzzle = puzzle4;
	}
	SetupPuzzle(current_puzzle);
	cardPanel.solveField.setText("");
    }

    public boolean handleEvent(Event event) {
	// this is probably not the best way to do this, but it works!! :)
        if (event.id == Event.ACTION_EVENT && event.target == buttonPanel.spinButton) {
	    cardPanel.cardLayout.show(cardPanel.cards, "Spin");
	    if (state == DONE && vowel_bell == 0) {
	    	state = SPIN;
	    	SpinWheel();
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == buttonPanel.letterButton) {
	    if (state == DONE) {
	    	cardPanel.cardLayout.show(cardPanel.cards, "Spin");
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == buttonPanel.vowelButton) {
	    if (state == DONE) {
	    	cardPanel.cardLayout.show(cardPanel.cards, "Vowel");
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == buttonPanel.solveButton) {
	    if (state == DONE) {
	    	cardPanel.cardLayout.show(cardPanel.cards, "Solve");
		cardPanel.solveField.requestFocus();
	    }
	} else if ((event.id == Event.ACTION_EVENT && event.target == cardPanel.solve) || (event.id == Event.KEY_RELEASE && event.key == 10)) {
	    if (state == DONE) {
	    	String temp = cardPanel.solveField.getText() + ".";
	    	if (puzzles[current_puzzle].equalsIgnoreCase(temp)) {
		    PuzzleSolved(1); // send 1 since puzzle solved correctly
	    	} else {
		    wrong.play();
		    pd = new PuzzleDialog(f, "Sorry", "That is not the solution!");
		    pd.show();
		    cardPanel.solveField.setText("");
		    if (playerPanel.guessWrong() == 5) {
			PuzzleSolved(0);  // send 0 since puzzle NOT solved correctly
		    }
		}
	    } else {
		pd = new PuzzleDialog(f, "Sorry", "Cannot SOLVE the puzzle yet!");
		pd.show();
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.a) {
	    if (gameMoney < 250) {
		pd = new PuzzleDialog(f, "Sorry", "You do not have enough money to buy a VOWEL!");
		pd.show();
	    } else {
		    cardPanel.a.hide();
		    GetLetter('a', 0);
		    state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.b) {
	    if (state == SPIN) {
		cardPanel.b.hide();
	    	GetLetter('b', 1);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.c) {
	    if (state == SPIN) {
		cardPanel.c.hide();
	    	GetLetter('c', 2);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.d) {
	    if (state == SPIN) {
		cardPanel.d.hide();
	    	GetLetter('d', 3);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.e) {
	    if (gameMoney < 250) {
		pd = new PuzzleDialog(f, "Sorry", "You do not have enough money to buy a VOWEL!");
		pd.show();
	    } else {
		    cardPanel.e.hide();
	    	    GetLetter('e', 4);
		    state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.f) {
	    if (state == SPIN) {
		cardPanel.f.hide();
	    	GetLetter('f', 5);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.g) {
	    if (state == SPIN) {
		cardPanel.g.hide();
	    	GetLetter('g', 6);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.h) {
	    if (state == SPIN) {
		cardPanel.h.hide();
	    	GetLetter('h', 7);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.i) {
	    if (gameMoney < 250) {
		pd = new PuzzleDialog(f, "Sorry", "You do not have enough money to buy a VOWEL!");
		pd.show();
	    } else {
		    cardPanel.i.hide();
	    	    GetLetter('i', 8);
		    state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.j) {
	    if (state == SPIN) {
		cardPanel.j.hide();
	    	GetLetter('j', 9);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.k) {
	    if (state == SPIN) {
		cardPanel.k.hide();
	    	GetLetter('k', 10);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.l) {
	    if (state == SPIN) {
		cardPanel.l.hide();
	    	GetLetter('l', 11);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.m) {
	    if (state == SPIN) {
		cardPanel.m.hide();
	    	GetLetter('m', 12);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.n) {
	    if (state == SPIN) {
		cardPanel.n.hide();
	    	GetLetter('n', 13);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.o) {
	    if (gameMoney < 250) {
		pd = new PuzzleDialog(f, "Sorry", "You do not have enough money to buy a VOWEL!");
		pd.show();
	    } else {
		    cardPanel.o.hide();
	    	    GetLetter('o', 14);
		    state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.p) {
	    if (state == SPIN) {
		cardPanel.p.hide();
	    	GetLetter('p', 15);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.q) {
	    if (state == SPIN) {
		cardPanel.q.hide();
	    	GetLetter('q', 16);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.r) {
	    if (state == SPIN) {
		cardPanel.r.hide();
	    	GetLetter('r', 17);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.s) {
	    if (state == SPIN) {
		cardPanel.s.hide();
	    	GetLetter('s', 18);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.t) {
	    if (state == SPIN) {
		cardPanel.t.hide();
	    	GetLetter('t', 19);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.u) {
	    if (gameMoney < 250) {
		pd = new PuzzleDialog(f, "Sorry", "You do not have enough money to buy a VOWEL!");
		pd.show();
	    } else {
		    cardPanel.u.hide();
	 	    GetLetter('u', 20);
		    state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.v) {
	    if (state == SPIN) {
		cardPanel.v.hide();
		GetLetter('v', 21);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.w) {
	    if (state == SPIN) {
		cardPanel.w.hide();
		GetLetter('w', 22);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.x) {
	    if (state == SPIN) {
		cardPanel.x.hide();
		GetLetter('x', 23);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.y) {
	    if (state == SPIN) {
		cardPanel.y.hide();
		GetLetter('y', 24);
		state = DONE;
	    }
        } else if (event.id == Event.ACTION_EVENT && event.target == cardPanel.z) {
	    if (state == SPIN) {
		cardPanel.z.hide();
		GetLetter('z', 25);
		state = DONE;
	    }
	}
        return super.handleEvent(event);
    } 

}

/*********************************************************************
/ LoginWindow
/ Written by Timothy M. Bailey
/
/ Used so that the user can type their name which will then 
/ appear in a panel with their score.
/
********************************/

class LoginWindow extends Dialog{
	public Wheel parent;
	public Panel buttonPanel;
	public Button okay;
	public TextField user;
	public String login_info = new String("");

	public LoginWindow(Frame f, String title, Wheel parent){
		//Instantiate variables
		super(f, title, true);
		this.parent = parent;
		user = new TextField(15);
		buttonPanel = new Panel();
		okay = new Button("OK");

		//Add button to panel and panel to window
		setLayout(new FlowLayout());
		buttonPanel.setLayout(new GridLayout(4,1));
		buttonPanel.add(new Label("Please Enter Your Name"));
		buttonPanel.add(user);	
		buttonPanel.add(new Label(""));
		buttonPanel.add(okay);
		add(buttonPanel);

		//Size window to preferred size
		this.reshape(300, 450, 300, 200);
		move(300,450);
		show();
		user.requestFocus();
	}//end LoginWindow(String, String)

	public boolean action(Event e, Object arg){
		if((e.target == okay) || (e.target == user && e.key == 0)){
			parent.playerName = user.getText();
			this.hide();
			this.dispose();
			return true;
		} else {
			return false;
		}
	} //end action(Event, Object)
}//end class definition

/*********************************************************************
/ TitlePanel
/ Written by Timothy M. Bailey
/
/ draws the title image
/
********************************/

class TitlePanel extends Panel {
    Image titleImage;

    public TitlePanel(Image i) {
	this.titleImage = i;
    }

    public void paint (Graphics g) {
	this.reshape(0,0,800,100);
	g.drawImage(titleImage,0,0,800,100,this);
    }
}

/*********************************************************************
/ PuzzlePanel
/ Written by Timothy M. Bailey
/
/ puzzle panel draws the actual "board".  The letters are stored in an array that 
/ gets passed from the Applet itself.
/
********************************/

class PuzzlePanel extends Panel {
    Image[][] puzzle;
    String puzzleType;
    int i, j;

    public PuzzlePanel(Image[][] puzzle) {
	this.puzzle = puzzle;
	this.show();
    }

    public void paint (Graphics g) {
	this.reshape(0, 100, 533, 300);

	for (i=0; i<8; i++) {
	    for (j=0; j<15; j++) {
		g.drawImage(puzzle[i][j], (30*j)+40, (30*i)+15, 30, 30, this);
	    }
	}
	g.setFont(new Font("TimesRoman", Font.BOLD, 18));
	g.setColor(Color.cyan);
	g.drawString(puzzleType, 200, 275);
	this.show();
    }
}

/*********************************************************************
/ PlayerPanel
/ Written by Timothy M. Bailey
/
/ this panel shows the player's name, their score for the current round,
/ their total score for the match, the number of chances they have 
/ remaining, and two status lines which give the amount of each
/ spin and the number of occurrences of the letter chosen.
/
********************************/

class PlayerPanel extends Panel {
    String name, gameMoney, matchMoney;    
    String spinWorth, letterCount;
    Image guessx, guesso;
    int count;

    public PlayerPanel(Image x, Image o, String name) {
	this.name = new String(name);
	this.gameMoney = new String("Game = $ 0");
	this.matchMoney = new String("Match = $ 0");
	this.spinWorth = new String("");
	this.letterCount = new String("");
	this.guessx = x;
	this.guesso = o;
	this.count = 0;
    }

    public void paint (Graphics g) {
	this.reshape(533, 100, 267, 300);
	g.setColor(Color.blue);
	g.drawLine(0, 0, 267, 0);
	g.drawLine(0, 0, 0, 290);
	g.drawLine(0, 290, 267, 290);
	g.setColor(Color.black);
	g.setFont(new Font("TimesRoman", Font.BOLD, 36));
	g.drawString(name, 15, 40);
	g.setColor(Color.red);
	g.setFont(new Font("TimesRoman", Font.BOLD, 18));
	g.drawString(gameMoney, 50, 100);
	g.setColor(Color.yellow);
	g.drawString(matchMoney, 50, 150);
	g.setColor(Color.cyan);
	g.setFont(new Font("TimesRoman", Font.BOLD, 16));
	g.drawString(spinWorth, 25, 225);
	g.setColor(Color.lightGray);
	g.drawString(letterCount, 25, 250);
	for (int i=0; i<count; i++) {
	    g.drawImage(guessx, 220, (i*20)+85, 15, 15, this);
	}
	for (int i=count; i<5; i++) {
	    g.drawImage(guesso, 220, (i*20)+85, 15, 15, this);
	}
	this.show();
    }

    void setGameMoney(int total) {
	// create the string to be shown on the player panel
	gameMoney = "Game = $ " + total;
	this.repaint();
    }

    void setMatchMoney(int total) {
	// create the string to be shown on the player panel
	matchMoney = "Match = $ " + total;
	this.repaint();
    }

    int guessWrong() {
	// increment the number of wrong guesses and repaint to draw another "x"
	count++;
	if (count > 5) {
		count = 5;
	}
	repaint();
	return count;
    }

    void resetGuess() {
	// start of new puzzle, therefore five new chances
	count = 0;
    }
}

/*********************************************************************
/ ButtonPanel
/ Written by Timothy M. Bailey
/
/ draws four buttons: spin, show letters, show vowels, and solve
/
********************************/

class ButtonPanel extends Panel {
    Button spinButton, letterButton, vowelButton, solveButton;

    public ButtonPanel() {
	this.setLayout(new GridLayout(4,1));
	spinButton = new Button("Spin");
	letterButton = new Button("Show Letters");
	vowelButton = new Button("Show Vowels");
	solveButton = new Button("Solve");
	spinButton.setBackground(Color.yellow);
	letterButton.setBackground(Color.yellow);
	vowelButton.setBackground(Color.yellow);
	solveButton.setBackground(Color.yellow);
	this.add(spinButton);
	this.add(letterButton);
 	this.add(vowelButton);
	this.add(solveButton);
	this.show();
    }

    public void paint (Graphics g) {
	this.reshape(10, 425, 100, 150);
    }
}

/*********************************************************************
/ SpinPanel
/ Written by Timothy M. Bailey
/
/ draws the image of the wheel
/
********************************/

class SpinPanel extends Panel {
    Image amount, pointer;

    public SpinPanel(Image fore, Image point) {
	this.amount = fore;
	this.pointer = point;
    }

    public void destroy() {
	// i don't think this quite works
	amount = null;
	pointer = null;
	this.repaint();
    }

    public void paint (Graphics g) {
	this.reshape(140, 425, 123, 110);
	g.drawImage(pointer, 0, 0, 123, 10, this);
	g.drawImage(amount, 0, 10, 123, 100, this);
	this.show();
    }

    public void spin(Image fore) {
	this.amount = fore;
	this.repaint();
    }
}

/*********************************************************************
/ CardPanel
/ Written by Timothy M. Bailey
/
/ this panel contains three cards: letters, vowels, and solve.
/ since the player can only do one of these three things at
/ a time, cardLayout seemed the best option.
/
********************************/

class CardPanel extends Panel {
    public Panel cards;
    CardLayout cardLayout;
    public Panel spinWheel, chooseVowel, solvePuzzle;
    TextField solveField;
    Label solveLabel;
    Button solve;
    Button b, c, d, f, g, h, j, k, l, m, n, p, q, r, s, t, v, w, x, y, z;
    Button a, e, i, o, u;

    public CardPanel() {
	this.setLayout(new BorderLayout());

	cards = new Panel();
	cardLayout = new CardLayout();
	cards.setLayout(cardLayout);
	
	spinWheel = new Panel();
	spinWheel.setLayout(new GridLayout(3, 7));
	b = new Button("B");
	c = new Button("C");
	d = new Button("D");
	f = new Button("F");
	g = new Button("G");
	h = new Button("H");
	j = new Button("J");
	k = new Button("K");
	l = new Button("L");
	m = new Button("M");
	n = new Button("N");
	p = new Button("P");
	q = new Button("Q");
	r = new Button("R");
	s = new Button("S");
	t = new Button("T");
	v = new Button("V");
	w = new Button("W");
	x = new Button("X");
	y = new Button("Y");
	z = new Button("Z");
	b.setBackground(Color.yellow);
	c.setBackground(Color.yellow);
	d.setBackground(Color.yellow);
	f.setBackground(Color.yellow);
	g.setBackground(Color.yellow);
	h.setBackground(Color.yellow);
	j.setBackground(Color.yellow);
	k.setBackground(Color.yellow);
	l.setBackground(Color.yellow);
	m.setBackground(Color.yellow);
	n.setBackground(Color.yellow);
	p.setBackground(Color.yellow);
	q.setBackground(Color.yellow);
	r.setBackground(Color.yellow);
	s.setBackground(Color.yellow);
	t.setBackground(Color.yellow);
	v.setBackground(Color.yellow);
	w.setBackground(Color.yellow);
	x.setBackground(Color.yellow);
	y.setBackground(Color.yellow);
	z.setBackground(Color.yellow);
	spinWheel.add(b);
	spinWheel.add(c);
	spinWheel.add(d);
	spinWheel.add(f);
	spinWheel.add(g);
	spinWheel.add(h);
	spinWheel.add(j);
	spinWheel.add(k);
	spinWheel.add(l);
	spinWheel.add(m);
	spinWheel.add(n);
	spinWheel.add(p);
	spinWheel.add(q);
	spinWheel.add(r);
	spinWheel.add(s);
	spinWheel.add(t);
	spinWheel.add(v);
	spinWheel.add(w);
	spinWheel.add(x);
	spinWheel.add(y);
	spinWheel.add(z);
	cards.add("Spin", spinWheel);

	chooseVowel = new Panel();
	chooseVowel.setLayout(new GridLayout(1,5));
	a = new Button("A");
	e = new Button("E");
	i = new Button("I");
	o = new Button("O");
	u = new Button("U");
	a.setBackground(Color.yellow);
	e.setBackground(Color.yellow);
	i.setBackground(Color.yellow);
	o.setBackground(Color.yellow);
	u.setBackground(Color.yellow);
	chooseVowel.add(a);
	chooseVowel.add(e);
	chooseVowel.add(i);
	chooseVowel.add(o);
	chooseVowel.add(u);
	cards.add("Vowel", chooseVowel);

	solvePuzzle = new Panel();
	solvePuzzle.setLayout(new BorderLayout());
	solveLabel = new Label("Solve the puzzle:", Label.CENTER);
	solveLabel.setFont(new Font("TimesRoman", Font.BOLD, 18));
	solvePuzzle.add("North", solveLabel);
	solve = new Button("Click Here When Done");
	solvePuzzle.add("South", solve);
	solveField = new TextField("", 50);
	solveField.setFont(new Font("TimesRoman", Font.PLAIN, 18));
	solvePuzzle.add("Center", solveField);
	cards.add("Solve", solvePuzzle);

	this.add("Center", cards);
    }

    public void paint (Graphics g) {
	this.reshape(300, 425, 500, 150);
    }
}

/*********************************************************************
/ PuzzleDialog
/ Written by Timothy M. Bailey
/
/ This class is used for popping up a dialog box with info that is
/ pertinant to the game.
/
********************************/

class PuzzleDialog extends Dialog
{
	protected Button close;

	public PuzzleDialog(Frame parent, String title, String mesg) {
		//Instantiate variables
		super(parent, title, true);

		Label return_message = new Label(mesg);
		this.add("Center", return_message);

		Panel panelButton = new Panel();
		close = new Button("OK");
		panelButton.add(close);
		this.add("South", panelButton);

		//Size window to preferred size
		this.pack();
		this.reshape(300, 425, 400, 150);
		this.move(300, 425);
	} //end PuzzleDialog(Frame, String, String)
	
	public boolean action(Event e, Object arg){
		if(e.target == close){
			this.hide();
			this.dispose();
			return true;
		} else {
			return false;
		}
	} //end action(Event, Object)

}//end class definition