Basic animation Java game “Snake” (like Centipede for Windows), complete w/source code

Package Hierarchy

Root directory:
SnakeMain.java
snake (folder)

snake folder:
enums (folder)
gui (folder)

snake\enums folder:
KeyDirections.java

snake\gui folder:
Level.java
Points.java
SnakeGUI.java
SnakePanel.java

The Game

Download

If you don’t want to copy the source code below, you can download it from here for a small price:

Source Code

SnakeMain.java

import snake.gui.SnakeGUI;

public class SnakeMain
{
/**
 * @param args
 */
  public static void main(String[] args)
  {
    SnakeGUI gui = new SnakeGUI();
    gui.newGame();
  }
}

KeyDirections.java

package snake.enums;
public enum KeyDirections
{
  UP(38),
  DOWN(40),
  LEFT(37),
  RIGHT(39);
  private int my_direction;
  private KeyDirections(final int the_direction)
  {
    setDirection(the_direction); 
  }
  public void setDirection(final int the_direction)
  {
    my_direction = the_direction;
  }
  public int getDirection()
  {
    return my_direction;
  }
}

Level.java

package snake.gui;

import java.awt.Color;

public class Level
{
  Color[][] layout = new Color[30][30];
  
  String convertFromImage;
  public Color[][] getLevel()
  {
    return null;
  }
  public Color[][] getLevel(final int levelNumber)
  {
    switch(levelNumber)
    {
      case 1:
        convertFromImage = "******************************" +
        		               "*        *    s              *" +
        		               "*        *    s              *" +
        		               "*   f    *                   *" +
        		               "*        *                   *" +
        		               "*   f    *                   *" +
        		               "*        *                   *" +
        		               "*        *                   *" +
        		               "*                            *" +
        		               "*              f             *" +
        		               "*                            *" +
        		               "*              f             *" +
        		               "*                            *" +
        		               "*              f             *" +
        		               "*                            *" +
        		               "*              f             *" +
        		               "*                            *" +
        		               "*                            *" +
        		               "*                            *" +
        		               "*                            *" +
        		               "*                            *" +
        		               "*       x                    *" +
        		               "*                            *" +
        		               "*          x                 *" +
        		               "*                            *" +
        		               "*             x              *" +
        		               "*                            *" +
        		               "*                            *" +
        		               "*                            *" +
        		               "******************************";
        break;
      case 2:
        convertFromImage = "******************************" +
        "*         *   s              *" +
        "*         *   s              *" +
        "*   f     *                  *" +
        "*         *                  *" +
        "*   f     *          *       *" +
        "*         *          *       *" +
        "*         *          *       *" +
        "*         *          *       *" +
        "*         *     f    *       *" +
        "*         *          *       *" +
        "*         *     f    *       *" +
        "*         *          *       *" +
        "*         *     f    *       *" +
        "*         *          *x      *" +
        "*         *     f    *       *" +
        "*         *          *       *" +
        "*         *          *       *" +
        "*         ************       *" +
        "*                            *" +
        "*                            *" +
        "*                            *" +
        "*                            *" +
        "*               **************" +
        "*                            *" +
        "*                            *" +
        "*                            *" +
        "*                     f      *" +
        "*                            *" +
        "******************************";
        break;
      case 3:
        convertFromImage = "******************************" +
        "*             s              *" +
        "*             s              *" +
        "*                   **********" +
        "*                ***         *" +
        "* f             *       f    *" +
        "*       ********             *" +
        "*                        *   *" +
        "*                       *    *" +
        "*        ***           *     *" +
        "*           ***    *****     *" +
        "*    f         *   *         *" +
        "*          *****   *         *" +
        "*        **        *    f    *" +
        "*     ***     f    *         *" +
        "*    **           *          *" +
        "*    *           *           *" +
        "*  **       *****         ****" +
        "*  *   f   *            **   *" +
        "*  *       *        ****     *" +
        "*   *     *   f    *         *" +
        "*         *       *     f    *" +
        "*      ***       *           *" +
        "*               *            *" +
        "*              *             *" +
        "*             *              *" +
        "*                            *" +
        "*                            *" +
        "*                            *" +
        "******************************";
        break;
      case 4:
        convertFromImage = "******************************" +
        "*        f  * s    *         *" +
        "*           * s    *  f  **  *" +
        "*         f *      *  *   *  *" +
        "*****  ******      *  ********" +
        "*           *      *  *      *" +
        "*                     *   *  *" +
        "*********            f    * f*" +
        "*                    *****   *" +
        "*                f           *" +
        "*   **************           *" +
        "*                         *  *" +
        "*                         *  *" +
        "*       *                 *  *" +
        "*   *****************     *  *" +
        "*       *      *          *  *" +
        "*              *          *  *" +
        "*              *    ff    *  *" +
        "*      *       ************  *" +
        "*     * *                 *  *" +
        "*    * f                     *" +
        "*   *  f                     *" +
        "*********************        *" +
        "*              f    **       *" +
        "*        f            **     *" +
        "*     *************     **   *" +
        "*    ***           *     *   *" +
        "*     **  f     f   *        *" +
        "*                            *" +
        "******************************";

        break;
      case 5:

        convertFromImage = "******************************" +
        "*             s      *       *" +
        "*             s      *    f  *" +
        "*                    ***     *" +
        "*                            *" +
        "*       f                    *" +
        "*                    *    f  *" +
        "*   **************   *       *" +
        "*                    *xxx    *" +
        "*                    *****xx**" +
        "*     f     f                *" +
        "*                 f          *" +
        "************                 *" +
        "*          **************    *" +
        "*    f                       *" +
        "*                      ffff  *" +
        "*                        *****" +
        "**********   *************   *" +
        "*        *   ***             *" +
        "*        *   **              *" +
        "*        *   *               *" +
        "*        *   *****           *" +
        "*        *        *          *" +
        "*        *         *         *" +
        "*        *****      ******   *" +
        "*             *           *  *" +
        "*              *      f  *   *" +
        "*               *********    *" +
        "*                            *" +
        "******************************";
        break;
      case 6:
        convertFromImage = "******************************" +
        "*  f          s              *" +
        "*             s              *" +
        "*    f                       *" +
        "***************************  *" +
        "*                f           *" +
        "*                            *" +
        "*  ***************************" +
        "*                            *" +
        "***************************  *" +
        "*                            *" +
        "*  ***************************" +
        "*  *    f       f            *" +
        "*  *                         *" +
        "*  ****************          *" +
        "*  *                         *" +
        "*  *                         *" +
        "*  *                         *" +
        "*  *  *****************      *" +
        "*  *  *                      *" +
        "*  * f* f        f           *" +
        "*  *  *      *****************" +
        "*  *  *           f          *" +
        "*  *  ******************     *" +
        "*  *  *                      *" +
        "*  *  *       ****************" +
        "*  *f *                      *" +
        "*     ***************      f *" +
        "*     *    f                 *" +
        "******************************";
        break;
      case 7:
        convertFromImage = "******************************" +
        "*           * s*             *" +
        "*      ff  f* s*             *" +
        "*  ***     **  *         *****" +
        "*    *     f*       *****  f *" +
        "*    *      *                *" +
        "*    *  **  f                *" +
        "*          *            x    *" +
        "*  *        *           x    *" +
        "*  *                    x    *" +
        "*  *           x        x    *" +
        "*  *           *             *" +
        "*              *             *" +
        "*  x  x  f     *       ***   *" +
        "*   xx         *    ***   *  *" +
        "*    *             *      ** *" +
        "*     **           *       * *" +
        "*                  *       * *" +
        "*           *     *        * *" +
        "*      *    *    *           *" +
        "*     *     *    *           *" +
        "*    *     *     *           *" +
        "*   *            *           *" +
        "*    *   f       *     f     *" +
        "*     ***       *            *" +
        "* *    *       *       f     *" +
        "* *           *              *" +
        "*       f                 *  *" +
        "*                    ******* *" +
        "******************************";
        break;
      case 8:
        convertFromImage = "******************************" +
        "*             s              *" +
        "*             s              *" +
        "*                            *" +
        "***************************  *" +
        "*                            *" +
        "*                            *" +
        "*  ***************************" +
        "*                            *" +
        "*                            *" +
        "*   *xxxxx*******  *******  x*" +
        "*   *   f       *  *xxxxxx  x*" +
        "*   *    f      *  *******  x*" +
        "*   *x*****     *           x*" +
        "*  *xxx   *     *  f     f  x*" +
        "* *x*x*****     **************" +
        "*  *x*                       *" +
        "*   *                        *" +
        "*   xxxx      **********     *" +
        "*    ****     **xx   f  **   *" +
        "*     ****     **      **    *" +
        "*      ****     **    **     *" +
        "*    f  ****          **     *" +
        "*        ****       ****     *" +
        "*  *********       ****      *" +
        "*  ***    f       xxxx       *" +
        "*  **            xxxx        *" +
        "*  ***************           *" +
        "*                            *" +
        "******************************";
        break;
      case 9:

        convertFromImage = "******************************" +
        "*           * s*             *" +
        "*      ff  f* s*             *" +
        "*  **********  *  f*     *****" +
        "*    *     f*  *****      *f *" +
        "*    *      *  *    f        *" +
        "*    *  ****f  **            *" +
        "*          *    *****   x*   *" +
        "*  *        *  f*xx     xx   *" +
        "*  *  *******  **xxxx   *x   *" +
        "*  *           xxxxxx   **   *" +
        "*  *           *             *" +
        "*  xxx      *  *             *" +
        "*  xxxx  f  *  *       ***   *" +
        "*   xxxx    *  *    ***   *  *" +
        "*    **** **       *      ** *" +
        "*     ****         *       * *" +
        "*                  *       * *" +
        "*           *     *        * *" +
        "*      *    *    *     ***** *" +
        "*     *     *    *     *     *" +
        "*    *     *     *     ***** *" +
        "*   *******      *         * *" +
        "*    **x**       *     f   * *" +
        "*     ***       *          * *" +
        "* *  f *       *       f   * *" +
        "* **  *  f    *            * *" +
        "*    f             ****x*x**f*" +
        "*   ***              ******* *" +
        "******************************";
         break;
      case 10:
        convertFromImage = "******************************" +
        "*f           *s*f            *" +
        "*       **** *s* *********** *" +
        "*      *   * * * *           *" +
        "**   f**   * * * * ***********" +
        "***    *   * *f  *       f   *" +
        "*****  *   * *************** *" +
        "**  * **   *   *       *   * *" +
        "*   *f*    *** * ***** * * * *" +
        "*     *   **** * *  ** * * * *" +
        "* ***     *xx* *    *  * * * *" +
        "* *  ********* **** * ** * * *" +
        "* *     f   *     * *    *  f*" +
        "* *  ****** ***** * **********" +
        "* *  **   * ***** *          *" +
        "*f**   ** *  **** ********** *" +
        "*  *    ***  ****    *     * *" +
        "*  *f          ** *  * *** * *" +
        "* **   *****    f ** *   * * *" +
        "*f**   *   *      ** *** * * *" +
        "* **   *   *  ******   * *f  *" +
        "*  *f  *   *  *   **  *  *****" +
        "*  *   *   *  * *    *   **  *" +
        "*  **      *  *  *  *    **  *" +
        "*  *       *  *f  **      *  *" +
        "*  ****   *   *        ****  *" +
        "*   **** *    ***********x*  *" +
        "*     ***             f  **  *" +
        "* f                          *" +
        "******************************";
    }
    int y = -1;
    int z;
    for(int x = 0; x < 900; x++)
    {
      char c = convertFromImage.charAt(x);
      z = x / 30;
      if (y == 29) { y = -1; }
      y++;
      //System.out.println("" + z + ", " + y);
      if (c == '*')
      {
        layout[z][y] = Color.DARK_GRAY;  
      }
      else if (c == ' ')
      {
        layout[z][y] = Color.GREEN;
      }
      else if (c == 'f')
      {
        layout[z][y] = Color.BLUE;
      }
      else if (c == 's')
      {
        layout[z][y] = Color.YELLOW;
      }
      else if (c == 'x')
      {
        layout[z][y] = Color.RED;
      }
    }
    
    //Colors of board are correct on x and y axis here
    return layout.clone();
  }
}

Points.java

package snake.gui;

import java.awt.Point;

import snake.enums.KeyDirections;

public class Points
{
  /*
   * "thisPartsPoint" = the coordinates for this part of the snake's body
   * "thisPartsDirection" = the direction this part of the snake's body is facing
   */
  Point thisPartsPoint = new Point();
  KeyDirections thisPartsDirection;
  public Points(final Point the_point, final KeyDirections the_direction)
  { 
    thisPartsPoint = the_point;
    thisPartsDirection = the_direction;
  }
  public Point getPoint()
  {
    return thisPartsPoint;   
  }
}

SnakeGUI.java

package snake.gui;

import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.awt.event.ActionListener;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.Point;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JFrame;
import javax.swing.JMenu;
import javax.swing.JMenuBar;
import javax.swing.JMenuItem;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.Timer;

import snake.enums.KeyDirections;

@SuppressWarnings("serial")
public class SnakeGUI extends JFrame
{
  public static final int FRAME_HEIGHT = 500;
  public static final int FRAME_WIDTH = 455;
  //private int[] my_keys;
  
  private int my_snake_direction;
  private int my_current_level;
  
  private Listener my_listener = new Listener();
  
  private MyTimer my_timer_listener = new MyTimer();
  private Timer my_timer;
  private KeyboardListener my_keyboardlistener = new KeyboardListener();
  
  private final JPanel my_main_panel = new JPanel(new BorderLayout());
 
  private final JMenuBar my_menubar = new JMenuBar();
  
  private final JMenu my_menubar_game = new JMenu("Game");
  private final JMenuItem my_menubar_game_newgame = new JMenuItem("New Game");
  private final JMenuItem my_menubar_game_pause = new JMenuItem("Pause");
  private final JMenuItem my_menubar_game_quit = new JMenuItem("Quit");
  /*******/
  private final JMenu my_menubar_help = new JMenu("Help");
  private final JMenuItem my_menubar_help_rules = new JMenuItem("Rules");
  private final JMenuItem my_menubar_help_about = new JMenuItem("About");

  private SnakePanel my_panel;
  
  private Color[][] board;
  private Level level = new Level();
  
  private List<Point> my_snake;
  private List<Point> new_snake;

  public SnakeGUI()
  {
    my_current_level = 1;
    my_timer = new Timer(1000, my_timer_listener); 

    my_snake = new ArrayList<Point>();
    new_snake = new ArrayList<Point>();
    
    my_timer.setDelay(1000);

    newGame();
    setup();
  }
  public void newGame()
  {
    my_timer.start();
    my_snake.clear();
    board = level.getLevel(my_current_level);   //set level at the same time of assigning my_current_level to 1
    my_snake.add(new Point(1, 14));
    my_snake.add(new Point(2, 14));
    my_snake_direction = 40;

  }
  public void setup()
  {
    my_panel = new SnakePanel(board);
    //my_panel.updateSnake(my_snake);    //temp
    my_main_panel.add(my_panel, BorderLayout.CENTER);
    addKeyListener(my_keyboardlistener);
    add(my_main_panel);
    setupMenuBar();
    setJMenuBar(my_menubar);
    setTitle("Snake");
    setResizable(false);
    setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
    setSize(FRAME_WIDTH, FRAME_HEIGHT);
    setLocationRelativeTo(null);
    setVisible(true);
    //my_panel.resetCollided();
    my_panel.updateSnake(my_snake);
    my_menubar_game_newgame.addActionListener(my_listener);
    my_menubar_game_pause.addActionListener(my_listener);
    my_menubar_game_quit.addActionListener(my_listener);
    my_menubar_help_rules.addActionListener(my_listener);
    my_menubar_help_about.addActionListener(my_listener);

    
  }
  private void setupMenuBar()
  {
    my_menubar.add(my_menubar_game);
    my_menubar_game.add(my_menubar_game_newgame);
    my_menubar_game.add(my_menubar_game_pause);
    my_menubar_game.addSeparator();
    my_menubar_game.add(my_menubar_game_quit);
    my_menubar.add(my_menubar_help);
    my_menubar_help.add(my_menubar_help_rules);
    my_menubar_help.addSeparator();
    my_menubar_help.add(my_menubar_help_about);
  }
  
  private class KeyboardListener implements KeyListener
  {
    /**
     * The key that was just pressed.
     * @param the_event The event that just happened (used to acquire what key was pressed).
     */
    public void keyPressed(final KeyEvent the_event)
    {
      final int key = the_event.getKeyCode();
      if (my_timer.isRunning())
      {
        if (key == 38 && my_snake_direction != 40)
 
        {
          my_snake_direction = key;
          moveSnake(KeyDirections.UP.getDirection());
        }
        else if (key == 40 && my_snake_direction != 38)
        {
          my_snake_direction = key;
          moveSnake(KeyDirections.DOWN.getDirection());
          //System.out.println("DOWN pressed");
        }
        else if (key == 37 && my_snake_direction != 39)
        {
          my_snake_direction = key;
          moveSnake(KeyDirections.LEFT.getDirection());
          //System.out.println("LEFT pressed");
        }
        else if (key == 39 && my_snake_direction != 37)
        {
          my_snake_direction = key;
          moveSnake(KeyDirections.RIGHT.getDirection());
          //System.out.println("RIGHT pressed");
        }
      }
    }
      /**
       * The key that was just released.
       * @param the_event The event that just happened (used to acquire what key was released). 
       */
    public void keyReleased(final KeyEvent the_event)
    {
    }
    /**
     * The key that was just typed.
     * @param the_event The event that just happened (used to acquire what key was typed).
     */
    public void keyTyped(final KeyEvent the_event)
    {
    }
  }

  private void moveSnake(int direction)
  {
    //System.out.println(my_timer.getDelay());
    boolean skipit = true;
    new_snake.clear();
    my_panel.clearOldSnake(my_snake);
    
    //System.out.println(direction + "");
    //If the desired direction is UP and the snake's not going down (can't go down to up, must go left or right first)
    if (direction == 38)
    {
      //System.out.println("Going UP");
      Point newPoint = new Point(my_snake.get(my_snake.size() - 1).x - 1,
          my_snake.get(my_snake.size() - 1).y);
      my_snake.add(newPoint);
      //my_snake.remove(0);
    }
    //Want to go DOWN, but can't if going UP
    else if (direction == 40)
    {
      //System.out.println("Going DOWN");
      Point newPoint = new Point(my_snake.get(my_snake.size() - 1).x + 1,
                                 my_snake.get(my_snake.size() - 1).y);
      my_snake.add(newPoint);
      //my_snake.remove(0);
    }
    //Want to go LEFT, but can't if going RIGHT
    else if (direction == 37)
    {
      //System.out.println("Going LEFT");
      Point newPoint = new Point(my_snake.get(my_snake.size() - 1).x,
                                 my_snake.get(my_snake.size() - 1).y - 1);
      my_snake.add(newPoint);
      //my_snake.remove(0);
    }
    //Want to go RIGHT, but can't if going LEFT
    else if (direction == 39)
    {
      //System.out.println("Going RIGHT");
      Point newPoint = new Point(my_snake.get(my_snake.size() - 1).x,
                                 my_snake.get(my_snake.size() - 1).y + 1);
      my_snake.add(newPoint);
      //my_snake.remove(0);
    }
    else
    {
      skipit = false;
    }
    if (skipit)
    {
      if (my_panel.growMode())
      {
        if(my_panel.checkForLevelCompletion())
        {
          my_current_level++;
          if (my_current_level == 11)
          {
            JOptionPane.showMessageDialog(null, "Good job.  You beat the game.");
            my_current_level = 1;
          }
          
          my_timer.setDelay(my_timer.getDelay() - 80);
          
          newGame();
        }
       }
      else
      {
        my_snake.remove(0);
          
      }
      my_panel.updateSnake(my_snake);
      
      if (my_panel.isCollided())
      {
        //System.out.println("COLLIDED");
        gameOver();
      }
    }
  }
  private class MyTimer implements ActionListener
  {
    public void actionPerformed(final ActionEvent the_event)
    {
      moveSnake(my_snake_direction);
    }
  }
 
  private void gameOver()
  {
    my_timer.stop();
    //System.out.println("Game over");

    newGame();
    my_panel.resetCollided();    
  }
  
  private class Listener implements ActionListener
  {
    public void actionPerformed(final ActionEvent the_event)
    {
      final String the_action = the_event.getActionCommand();
 
      if (the_action.equals(my_menubar_game_newgame.getActionCommand()))
      {
        my_timer.setDelay(1000);

        my_current_level = 1;
        newGame();
      }
      else if (the_action.equals(my_menubar_game_quit.getActionCommand()))
      {
        System.exit(0);
      }
      else if (the_action.equals(my_menubar_help_rules.getActionCommand()))
      {
        JOptionPane.showMessageDialog(null,
            "Eric Sweeten\nSnake v1.0\n\n" + 
            "Keep the snake on the green.  Gather up all the food\n" +
            "(blue squares), and once all the food is gathered, you\n" +
            "pass the level.  There are 10 levels total.  Once you\n" + 
            "pass the 10th level, you beat the game.");
      }
      else if (the_action.equals(my_menubar_help_about.getActionCommand()))
      {
        JOptionPane.showMessageDialog(null, 
        "Eric Sweeten\nSnake v1.0\n\neric.sweeten@gmail.com");
      }
      else if (the_action.equals(my_menubar_game_pause.getActionCommand()))
      {
        togglePause();
      }
    }
  }
  private void togglePause()
  {
    if (my_timer.isRunning())
    {
      my_timer.stop();
    }
    else
    {
      my_timer.start();
    }
  }
}

SnakePanel.java

package snake.gui;

import java.awt.Color;
import java.awt.Graphics;
import java.awt.Graphics2D;
import java.awt.Point;
import java.awt.RenderingHints;
import java.awt.geom.Rectangle2D;
import java.util.ArrayList;
import java.util.List;

import javax.swing.JPanel;

@SuppressWarnings("serial")
public class SnakePanel extends JPanel
{
  Color board[][] = new Color[30][30];
  private Rectangle2D[][] my_board = new Rectangle2D[30][30];
  private boolean collided;
  private boolean growMode;
  int growingThreeSpaces;
  int spacesToGrowTotal;
  int beginning;
  
  public SnakePanel(Color[][] gameBoard)
  {
    collided = false;
    growMode = false;
    beginning = 0;
    board = gameBoard;
    
    for (int x = 0; x < 30; x++)
    {
      for (int y = 0; y < 30; y++)
      {
        my_board[x][y] =
          new Rectangle2D.Double(y * 15, x * 15, 14, 14);      //Quick fix
      }
    }   //board is correct here
  }
  
  public void paintComponent(final Graphics the_graphics)
  {
    super.paintComponent(the_graphics);
    //Rectangle2D my_square;
    final Graphics2D g2d = (Graphics2D) the_graphics;
    g2d.setRenderingHint(RenderingHints.KEY_ANTIALIASING, RenderingHints.VALUE_ANTIALIAS_ON);
    for (int x = 0; x < 30; x++)
    {
      for (int y = 0; y < 30; y++)
      {
        g2d.setColor(board[x][y]);
        g2d.fill(my_board[x][y]);
        g2d.draw(my_board[x][y]);
      }
    }  
  }
  public void clearOldSnake(List<Point> points)
  {
    //System.out.println("clearOldSnake(List<Points> points (points.size() = " + points.size() + ")");
    for (int x = 0; x < points.size(); x++)
    {
      board[points.get(x).x][points.get(x).y] = Color.GREEN;
    }
  }
  public boolean growMode()
  {
    return growMode;
  }
  /*
   * This updates the position of the snake by points (positions) on the map level
   */
  public void updateSnake(List<Point> points)
  {
    if (beginning < 2) { beginning++; }
    if (growMode)
    {
      growingThreeSpaces++;
      if (growingThreeSpaces == spacesToGrowTotal)
      {
        resetGrowMode();
      }
    }

    for (int x = 0; x < points.size(); x++)
    {
      //System.out.println("Coords: " + board[points.get(x).x][points.get(x).y]);
      if (board[points.get(x).x][points.get(x).y] == Color.BLUE)
      {
        //System.out.println("COLLIDED WITH SOMETHING THAT MAKES SNAKE GROW");
        spacesToGrowTotal += 3;
        growMode = true;

      }
      
      else if (board[points.get(x).x][points.get(x).y] != Color.GREEN &&
               board[points.get(x).x][points.get(x).y] != Color.BLUE)
      {
        if (beginning > 1) { collided = true; }
      }

      board[points.get(x).x][points.get(x).y] = Color.YELLOW;
      //System.out.println("Coloring the snake yellow");
      //System.out.println(points.get(x).x + ", " + points.get(x).y);
    }
    repaint();
  }
  public boolean isCollided()
  {
    return collided;
  }
  public void resetCollided()
  {
    collided = false;
  }
  public void resetGrowMode()
  {
    spacesToGrowTotal = 0;
    growingThreeSpaces = 0;
    growMode = false;
  }
  public boolean checkForLevelCompletion()
  {
    boolean complete = true;
    for (int x = 0; x < 30; x++)
    {
      for (int y = 0; y < 30; y++)
      {
        if (board[x][y] == Color.BLUE)
        {
          complete = false;
        }
      }
    }
    return complete;
  }
}