PSNB Tech Blog

Note: I have completely rewritten and improved this game. Most of my traffic comes from these posts, so I've not deleted them. Please use the new version which can be found here.

At the heart of every game is the engine. The engine is responsible for updating the game at fixed intervals, in response to events, or a combination of the two. In the case of the Snake Game, we need to update the game at regular intervals, and accept user input from the Keyboard. This part of the lesson will explain how to setup the basic game engine, which we will add functionality to as we develop the game.

To start, we're going to create a new class and name it Engine. This class will be responsible for handling most of the game's logic, the game loop, and window creation. We will return to this class throughout the tutorial as we add functionality to the game.

The first thing we must do is create the window to render on, so we'll start by creating the main method, and adding the gui code into it.

public static void main(String[] args) {
 /*
  * Create a new JFrame and set it's properties up.
  */
 JFrame frame = new JFrame("Snake Game");
 frame.setDefaultCloseOperation(JFrame.EXIT_ON_CLOSE);
 frame.setResizable(false);
 
 /*
  * Create a new canvas, and set it's properties up.
  */
 Canvas canvas = new Canvas();
 canvas.setBackground(Color.BLACK);
 canvas.setPreferredSize(new Dimension(500, 500));
 
 /*
  * Add the canvas to the frame.
  */
 frame.add(canvas);
 
 /*
  * Pack the frame, position it in the center of the screen, and then display
  * it.
  */
 frame.pack();
 frame.setLocationRelativeTo(null);
 frame.setVisible(true);
}

If we run the code now, we'll see a basic swing window appear on the screen. While this is nice and all, there's really no way of interacting with it yet. That's where the Engine class comes in. First, we'll create the constructor and pass our instance of the canvas to it, so that we may use it later for rendering.

/*
 * The canvas instance that we draw to.
 */
private Canvas canvas;

/*
 * Creates a new Engine instance.
 * @param canvas The canvas instance we're drawing onto.
 */
private Engine(Canvas canvas) {
 this.canvas = canvas;
}

While we're at it, let's also create the startGame method and add it to the class. This is the meat and potatoes of the class, as it will contain the game loop, and rendering context information. I'll post the entire method and explain what each part does in the comments.

/*
 * The number of times to update the game per second.
 */
private static final int UPDATES_PER_SECOND = 10;

/**
 * Responsible for setting up and retrieving the rendering context, then maintaining
 * the game loop.
 */
public void startGame() {
 /*
  * Create the buffers and get the graphics.
  */
 canvas.createBufferStrategy(2);
  
 /*
  * Grab a reference to the graphics object.
  */
 Graphics2D g = (Graphics2D)canvas.getBufferStrategy().getDrawGraphics();
  
 /*
  * Create the variables that keep the loop executing at a constant framerate.
  */
 long start = 0L;
 long sleepDuration = 0L;
 
 /*
  * The game loop will continue to click until the program ends.
  */
 while(true) {

  /*
   * Set the time that the loop started.
   */
  start = System.currentTimeMillis();
  
  /*
   * Update the game.
   */
  update();
   
  /*
   * Draw the game onto the graphics object.
   */
  render(g);
  
  /*
   * Display the graphics onto the screen.
   */
  canvas.getBufferStrategy().show();

  /*
   * Clear the screen so we draw a fresh frame next time.
   */
   g.clearRect(0, 0, canvas.getWidth(), canvas.getHeight());
   
  /*
   * Set the time that the loop finished.
   */
  sleepDuration = (1000L / UPDATES_PER_SECOND) - (System.currentTimeMillis() - start);
   
  /*
   * If the sleep duration is greater than 0 milliseconds, attempt to sleep.
   */
  if(sleepDuration > 0) {
   try {
    Thread.sleep(sleepDuration);
   } catch(Exception e) {
    e.printStackTrace();
   }
  }
 }
}

/*
 * Update the game's logic.
 */
private void update() {
 //Empty for now, we'll fill this in later.
}

/*
 * Draw the game onto the graphics object.
 */
private void render(Graphics2D g) {
 //Empty for now, we'll fill this in later.
}

The last thing we need to do now is create an instance of the engine in the main method.

//Window creation code...

 /*
  * Create the engine and start the game.
  */
 Engine engine = new Engine(canvas);
 engine.startGame();
}

If we run the game now, we'll have an empty game loop that we can play around with, which enables us to start implementing the game logic. Anyway, that's all for now, next time I'll cover how the game board works.