SnakeCanvas

import java.awt.Canvas;
import java.awt.Color;
import java.awt.Dimension;
import java.awt.Graphics;
import java.awt.Image;
import java.awt.Point;
import java.awt.Toolkit;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.image.BufferedImage;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.IOException;
import java.util.LinkedList;
import java.util.Random;
import java.io.File;
import java.io.FileWriter;
import java.net.URL;

import javax.swing.JOptionPane;

public class SnakeCanvas extends Canvas implements Runnable, KeyListener {
	private final int BOX_HEIGHT = 15;
	private final int BOX_WIDTH = 15;
	private final int GRID_WIDTH = 25;
	private final int GRID_HEIGHT = 25;

	private LinkedList<Point> snake; // Point is for x,y coordinate
	private Point fruit;
	private int direction = Direction.NO_DIRECTION;

	private Thread runThread;
	private int score = 0;
	private String highScore = "";

	private Image menuImage = null;
	private boolean isInMenu = true;

	private boolean isAtEndGame = false;
	private boolean won = false;

	public void paint(Graphics g) {
		setBackground(Color.YELLOW);

		if (runThread == null) {
			this.setPreferredSize(new Dimension(640, 480));
			this.addKeyListener(this);
			runThread = new Thread(this);
			runThread.start();
		}
		if (isInMenu) {
			// Things to do when menus displayed
			drawMenu(g);
		}

		else if (isAtEndGame) {
			// draw end game screen
			drawEndGame(g);
		}

		else {
			// things to do when menu is not being displayed

			if (snake == null) {
				snake = new LinkedList<Point>();
				generateDefaultSnake();
				placeFruit();
			}
			if (highScore.equals("")) {
				// initialize highscore
				highScore = this.getHighScoreValue();

			}
			drawGrid(g);
			drawSnake(g);
			drawFruit(g);
			drawScore(g);
		}

	}

	public void drawEndGame(Graphics g) {
		BufferedImage endGameImage = new BufferedImage(
				this.getPreferredSize().width, this.getPreferredSize().height,
				BufferedImage.TYPE_INT_ARGB);
		Graphics endGameGraphics = endGameImage.getGraphics();
		endGameGraphics.setColor(Color.BLACK);

		if (won)
			endGameGraphics.drawString("WINNER WINNER",
					this.getPreferredSize().width / 2,
					this.getPreferredSize().height / 2);
		else

			endGameGraphics.drawString("You LOST",
					this.getPreferredSize().width / 2,
					this.getPreferredSize().height / 2);
		endGameGraphics.drawString("Your score: " + this.score, this
				.getPreferredSize().width / 2,
				(this.getPreferredSize().height / 2) + 20); // moves 20 px below
		endGameGraphics.drawString("Press \"space\" to start a new game!", this
				.getPreferredSize().width / 2,
				(this.getPreferredSize().height / 2) + 40);

		g.drawImage(endGameImage, 0, 0, this);
	}

	public void drawMenu(Graphics g) {
		if (menuImage == null) {
			try {
				URL imagePath = SnakeCanvas.class.getResource("menuImage.png");
				menuImage = Toolkit.getDefaultToolkit().getImage(imagePath);
			} catch (Exception e) {
				// error would occur if image does not exist
				e.printStackTrace();
			}
		}
		g.drawImage(menuImage, 0, 0, 640, 480, this);
	}

	public void update(Graphics g) {
		// default update method which contains double buffering
		Graphics offScreenGraphics;// graphics to draw off screen
		BufferedImage offScreen = null;
		Dimension d = this.getSize();

		offScreen = new BufferedImage(d.width, d.height,
				BufferedImage.TYPE_INT_ARGB);
		offScreenGraphics = offScreen.getGraphics();
		offScreenGraphics.setColor(this.getBackground());
		offScreenGraphics.fillRect(0, 0, d.width, d.height);
		offScreenGraphics.setColor(this.getForeground());
		paint(offScreenGraphics);

		// flip
		g.drawImage(offScreen, 0, 0, this);

	}

	public void generateDefaultSnake() {
		score = 0;
		snake.clear();

		snake.add(new Point(0, 2));
		snake.add(new Point(0, 1));
		snake.add(new Point(0, 0));
		direction = Direction.NO_DIRECTION;
	}

	public void move() {
		if (direction == Direction.NO_DIRECTION)
			return;

		Point head = snake.peekFirst(); // gets first point on LinkedList
		Point newPoint = head;
		switch (direction) {
		case Direction.NORTH:
			newPoint = new Point(head.x, head.y - 1); // y typically goes down
														// from bottom of
														// screen, so reverse
			break;
		case Direction.SOUTH:
			newPoint = new Point(head.x, head.y + 1);
			break;
		case Direction.WEST:
			newPoint = new Point(head.x - 1, head.y);
			break;
		case Direction.EAST:
			newPoint = new Point(head.x + 1, head.y);
			break;
		}

		if (this.direction != Direction.NO_DIRECTION)
			snake.remove(snake.peekLast()); // removes last box of the snake
											// when moves

		if (newPoint.equals(fruit)) {
			// the snake has hit the fruit
			score += 10;

			Point addPoint = (Point) newPoint.clone();

			switch (direction) {
			case Direction.NORTH:
				newPoint = new Point(head.x, head.y - 1); // y typically goes
															// down from bottom
															// of screen, so
															// reverse
				break;
			case Direction.SOUTH:
				newPoint = new Point(head.x, head.y + 1);
				break;
			case Direction.WEST:
				newPoint = new Point(head.x - 1, head.y);
				break;
			case Direction.EAST:
				newPoint = new Point(head.x + 1, head.y);
				break;
			}
			snake.push(addPoint);
			placeFruit();

		} else if (newPoint.x < 0 || newPoint.x > (GRID_WIDTH - 1))// w/out -1
																	// you would
																	// be able
																	// to go one
																	// space
																	// into
																	// empty out
																	// of border
		{
			// the snake went out of bounds,resets the game
			// checkScore();
			won = false;
			isAtEndGame = true;
			return;

		} else if (newPoint.y < 0 || newPoint.y > (GRID_HEIGHT - 1)) {
			// the snake went out of bounds,resets the game
			// checkScore();//if I remove these there is not a null point error
			// anymore
			won = false;
			isAtEndGame = true;
			return;
		} else if (snake.contains(newPoint)) {
			// the snake ran into itself,resets the game

			if (direction != Direction.NO_DIRECTION) {
				// checkScore();
				won = false;
				isAtEndGame = true;
				return;
			}

		} else if (snake.size() == (GRID_WIDTH * GRID_HEIGHT)) {
			// player wins!
			// checkScore();
			won = true;
			isAtEndGame = true;
			return;
		}

		// if player reaches this point, they're still fine
		snake.push(newPoint);
	}

	public void drawScore(Graphics g) {
		g.drawString("Score: " + score, 0, BOX_HEIGHT * GRID_HEIGHT + 10);
		g.drawString("Highscore: " + highScore, 0, BOX_HEIGHT * GRID_HEIGHT
				+ 20);
	}

	public void checkScore() {
		if (highScore.equals(""))
			return;
		// format Noah/:/100 have to split b/c highscore is a string. Splitting
		// it makes it into an array
		if (score > Integer.parseInt((highScore.split(":")[2]))) {
			// user set a new record
			String name = JOptionPane
					.showInputDialog("You set a new high score! Type your name.");
			highScore = name + ":" + score;

			File scoreFile = new File("highscore.dat");
			if (!scoreFile.exists()) {
				try {
					scoreFile.createNewFile();
				} catch (IOException e) {

					e.printStackTrace();
				}
			}
			FileWriter writeFile = null;
			BufferedWriter writer = null;
			try {
				writeFile = new FileWriter(scoreFile);
				writer = new BufferedWriter(writeFile);
				writer.write(this.highScore);
			} catch (Exception e) {
				// errors
			} finally {
				try {
					if (writer != null)
						writer.close();
				} catch (Exception e) {
				}

			}
		}
	}

	public void drawGrid(Graphics g) {
		// drawing an outside rectangle
		g.drawRect(0, 0, GRID_WIDTH * BOX_WIDTH, GRID_HEIGHT * BOX_HEIGHT);

	}

	public void drawSnake(Graphics g) {
		g.setColor(Color.GREEN);
		for (Point p : snake) {
			g
					.fillOval(p.x * BOX_WIDTH, p.y * BOX_HEIGHT, BOX_WIDTH,
							BOX_HEIGHT);
		}
		g.setColor(Color.BLACK);
	}

	public void drawFruit(Graphics g) {
		g.setColor(Color.RED);
		g.fillOval(fruit.x * BOX_WIDTH, fruit.y * BOX_HEIGHT, BOX_WIDTH,
				BOX_HEIGHT);
		g.setColor(Color.BLACK);
	}

	public void placeFruit() {
		Random rand = new Random();
		int randomX = rand.nextInt(GRID_WIDTH);
		int randomY = rand.nextInt(GRID_HEIGHT);
		Point randomPoint = new Point(randomX, randomY);
		while (snake.contains(randomPoint)) {
			randomX = rand.nextInt(GRID_WIDTH);
			randomY = rand.nextInt(GRID_HEIGHT);
			randomPoint = new Point(randomX, randomY);
		}
		fruit = randomPoint;
	}

	@Override
	public void run() {
		while (true) {
			// runs indefinitley
			repaint();
			if (!isInMenu && !isAtEndGame)
				move();

			try {
				Thread.currentThread();
				Thread.sleep(100); // game updates every 10th of a second for
									// speed of snake
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}

	public String getHighScoreValue() {
		// format: @random: 100
		FileReader readFile = null;
		BufferedReader reader = null;
		try {
			readFile = new FileReader("highscore.dat");
			reader = new BufferedReader(readFile);
			return reader.readLine();
		} catch (Exception e) {
			return "Nobody:0";
		} finally {
			try {
				if (reader != null)
					reader.close();
			} catch (IOException e) {
				e.printStackTrace();
			}
		}

	}

	@Override
	public void keyPressed(KeyEvent e) {

	}

	@Override
	public void keyReleased(KeyEvent e) {
		switch (e.getKeyCode()) {
		case KeyEvent.VK_UP:
			if (direction != Direction.SOUTH)
				direction = Direction.NORTH;
			break;
		case KeyEvent.VK_DOWN:
			if (direction != Direction.NORTH)
				direction = Direction.SOUTH;
			break;
		case KeyEvent.VK_RIGHT:
			if (direction != Direction.WEST)
				direction = Direction.EAST;
			break;
		case KeyEvent.VK_LEFT:
			if (direction != Direction.EAST)
				direction = Direction.WEST;
			break;
		case KeyEvent.VK_ENTER:
			if (isInMenu) {
				isInMenu = false;
				repaint();
			}
			break;
		case KeyEvent.VK_ESCAPE:
			isInMenu = true;
		case KeyEvent.VK_SPACE:
			if (isAtEndGame) {
				isAtEndGame = false;
				won = false;
				generateDefaultSnake();
				repaint();
			}
			break;
		}

	}

	@Override
	public void keyTyped(KeyEvent e) {

	}
}