SnakeAI.java

import java.awt.Color;
import java.util.ArrayList;
/**
 * AI for the Snake Game.
 * 
 * @author Jin Kim
 * @author David Melisso
 * @version 13 May 2016
 */
public class SnakeAI extends SnakeGame
{
 /**
 * Constructor for objects of class SnakeAI
 */
 public SnakeAI(Color color, int sp)
 {
 super(color, sp);
 }
 
 public SnakeAI(Color color)
 {
 this(color, 10);
 }
 
 public SnakeAI(int sp)
 {
 this(Color.BLUE, sp);
 }
 
 /**
 * Default constructor for SnakeAI
 */
 public SnakeAI()
 {
 this(Color.BLUE, 10);
 }

 /**
 * Changes the direction of the snake
 * 
 * @return the direction it changed to
 */
 public String change()
 {
 Location foodLocation = foodLocator();
 Location headLocation = snake.getHeadLocation();
 int headRow = headLocation.getRow();
 int headCol = headLocation.getCol();
 MyBoundedGrid<Block> grid = getGrid();
 int[][] mat;
 String res;
 try
 {
 mat = grid.makeNumberGrid(headLocation, foodLocation);
 }
 catch (IllegalArgumentException e)
 {
 try
 {
 mat = grid.makeNumberGrid(headLocation, snake.getTailLocation());
 }
 catch (IllegalArgumentException i)
 {
 try
 {
 String destination = directionFarthestFromBarrier();
 int sp = spacesToBarrierDirection(destination);
 mat = grid.makeNumberGrid(headLocation, getLocationFromHead(headLocation, destination, sp));
 }
 catch (IllegalArgumentException p)
 {
 res = snake.getDirection();
 if (isDirectionClear(res))
 {
 return res;
 }
 else
 {
 res = snake.getRightDirection();
 if (isDirectionClear(res))
 {
 snake.changeDirection(res);
 return res;
 }
 else
 {
 res = snake.getLeftDirection();
 snake.changeDirection(res);
 return res;
 }
 }
 }
 }
 }

 ArrayList<Location> adjacents = grid.getValidAdjacentLocations(headLocation);
 int smallestVal = Integer.MAX_VALUE;
 int dir = 0;
 for(int i = 0; i < adjacents.size(); i++)
 {
 Location loc = adjacents.get(i);
 int cur = mat[loc.getRow()][loc.getCol()];
 if (cur < smallestVal && cur!=0 && cur!=-2)
 {
 smallestVal = cur;
 dir = i;
 }
 }
 res = directionFromHead(adjacents.get(dir));
 snake.changeDirection(res);
 return res;
 }

 public boolean isDirectionClear(String direction)
 {
 Location test = getLocationFromHead(snake.getHeadLocation(), direction, 1);
 try
 {
 return getGrid().get(test)==null;
 }
 catch (IndexOutOfBoundsException e)
 {
 return false;
 }
 }

 public String directionFromHead(Location loc)
 {
 Location head = snake.getHeadLocation();
 int locRow = loc.getRow();
 int locCol = loc.getCol();

 Location locUP = new Location(locRow-1, locCol);
 Location locDOWN = new Location(locRow+1, locCol);
 Location locRIGHT = new Location(locRow, locCol+1);
 Location locLEFT = new Location(locRow, locCol-1);

 if (head.equals(locUP))
 {
 return "DOWN";
 }
 if (head.equals(locDOWN))
 {
 return "UP";
 }
 if (head.equals(locRIGHT))
 {
 return "LEFT";
 }
 if (head.equals(locLEFT))
 {
 return "RIGHT";
 }

 return "";
 }

 public String directionFarthestFromBarrier()
 {
 int right = spacesToBarrierDirection(snake.getRightDirection());
 int left = spacesToBarrierDirection(snake.getLeftDirection());
 int forward = spacesToBarrierDirection(snake.getDirection());
 int max = Math.max(Math.max(right, left), forward);
 
 if(max == right)
 {
 return snake.getRightDirection();
 }
 else if(max == left)
 {
 return snake.getLeftDirection();
 }
 else
 {
 return snake.getDirection();
 }
 }

 public int spacesToBarrierDirection(String dir)
 {
 Location headLoc = snake.getHeadLocation();
 MyBoundedGrid<Block> grid = getGrid();
 int spaces = 1;
 Location test = getLocationFromHead(headLoc, dir, spaces);
 while(grid.isValid(test) && test == null)
 {
 test = getLocationFromHead(headLoc, dir, spaces++);
 }
 spaces--;
 return spaces;
 }

 public Location getLocationFromHead(Location loc, String direc, int spaces)
 {
 int row = loc.getRow();
 int col = loc.getCol();
 Location res = snake.getHeadLocation();
 if (direc.equals("RIGHT"))
 {
 res = new Location(row, col+spaces);
 }
 else if (direc.equals("LEFT"))
 {
 res = new Location(row, col-spaces);
 }
 else if (direc.equals("DOWN"))
 {
 res = new Location(row+spaces, col);
 }
 else if (direc.equals("UP"))
 {
 res = new Location(row-spaces, col);
 }
 return res;
 }

 /**
 * Runs the game
 */
 public void play()
 { 
 spawnFoodStuff();
 while(playay)
 {
 try 
 {
 Thread.sleep(getWaitTime());
 change();

 if(snake.determineDirection()) //we need a new method to get the direction of the snake.
 {
 display.showBlocks();
 }
 else
 {
 //snake dies here.
 gameOver(false);
 }
 }
 catch(InterruptedException e)
 {
 //ignore
 }
 }
 }

 /*
 public int disLeftWall()
 {
 return snakeHead.getCol();
 }

 public int disRightWall()
 {
 return aiGrid.getNumCols() - snakeHead.getCol();
 }

 public int disDownWall()
 {
 return aiGrid.getNumRows() - snakeHead.getRow();
 }

 public int disUpWall()
 {
 return snakeHead.getRow();
 }
 */
 /**
 * Gets the Location of the Food
 */
 public Location foodLocator()
 {
 return getFoodStuffSpawningLocation();
 }
}