SnakeGame.java

package examples.snake;

import io.termd.core.function.BiConsumer;
import io.termd.core.function.Consumer;
import io.termd.core.tty.TtyConnection;
import io.termd.core.tty.TtyEvent;
import io.termd.core.util.Vector;

import java.util.HashSet;
import java.util.LinkedList;
import java.util.Random;
import java.util.concurrent.TimeUnit;

/**
 * The snake game implementation, fully non blocking, one thread to handle all players : massive scalability
 */
public class SnakeGame implements Consumer<TtyConnection> {

  @Override
  public void accept(final TtyConnection conn) {
    if (conn.size() != null) {
      new Game(conn).execute();
    } else {
      conn.setSizeHandler(new Consumer<Vector>() {
        @Override
        public void accept(Vector size) {
          new Game(conn).execute();
        }
      });
    }
  }

  enum Direction {
    LEFT, RIGHT, UP, DOWN
  }

  /**
   * The game automaton state
   */
  class GameState {

    final int width, height;
    HashSet<Vector> tiles;
    LinkedList<Vector> snake = new LinkedList<Vector>();
    Direction direction;

    GameState(int width, int height, int size) {
      this.width = width;
      this.height = height;
      tiles = new HashSet<Vector>();
      while (size > 0) {
        int x = new Random().nextInt(width);
        int y = new Random().nextInt(height);
        Vector tile = new Vector(x, y);
        if (tiles.add(tile)) {
          size--;
        }
      }
      snake.addFirst(new Vector(0, 0));
      snake.addFirst(new Vector(1, 0));
      snake.addFirst(new Vector(2, 0));
      snake.addFirst(new Vector(3, 0));
      direction = Direction.RIGHT;
    }

    /**
     * Update the state with one game iteration
     *
     * @throws Exception when user lose
     */
    void update() throws Exception {
      Vector curr = snake.peekFirst();
      Vector next = null;
      switch (direction) {
        case RIGHT:
          next = new Vector(curr.x() + 1, curr.y());
          break;
        case LEFT:
          next = new Vector(curr.x() - 1, curr.y());
          break;
        case UP:
          next = new Vector(curr.x(), curr.y() - 1);
          break;
        case DOWN:
          next = new Vector(curr.x(), curr.y() + 1);
          break;
      }
      if (next.x() < 0 || next.x() >= width || next.y() < 0 || next.y() >= height || snake.contains(next)) {
        throw new Exception("lost");
      }
      if (!tiles.remove(next)) {
        // Eat a tile : grow
        snake.removeLast();
      }
      snake.addFirst(next);
    }
  }

  /**
   * The game itself.
   */
  class Game {

    final TtyConnection conn;
    GameState game;
    boolean interrupted;

    public Game(final TtyConnection conn) {
      this.conn = conn;

      // When user resize the screen : launch a new game
      conn.setSizeHandler(new Consumer<Vector>() {
        @Override
        public void accept(Vector size) {
          reset(size);
        }
      });

      // Ctrl-C ends the game
      conn.setEventHandler(new BiConsumer<TtyEvent, Integer>() {
        @Override
        public void accept(TtyEvent event, Integer ch) {
          switch (event) {
            case INTR:
              interrupted = true;
              conn.close();
              break;
          }
        }
      });

      // Keyboard handling
      conn.setStdinHandler(new Consumer<int[]>() {
        @Override
        public void accept(int[] keys) {
          if (keys.length == 3) {
            if (keys[0] == 27 && keys[1] == '[') {
              switch (keys[2]) {
                case 'A':
                  game.direction = Direction.UP;
                  break;
                case 'B':
                  game.direction = Direction.DOWN;
                  break;
                case 'C':
                  game.direction = Direction.RIGHT;
                  break;
                case 'D':
                  game.direction = Direction.LEFT;
                  break;
              }
            }
          }
        }
      });

      // Init current game
      reset(conn.size());
    }

    /**
     * Execute one iteration of the game, at the end schedule the next iteration until user lose or hits Ctrl-C
     */
    void execute() {
      if (interrupted) {
        return;
      }
      GameState game = this.game;

      // Compute the ANSI magic string that draws the game
      StringBuilder buf = new StringBuilder();
      for (int y = 0;y < game.height;y++) {
        buf.append("\033[").append(y + 1).append(";1H\033[K");
      }
      for (Vector tile : game.tiles) {
        buf.append("\033[").append(tile.y() + 1).append(";").append(tile.x() + 1).append("H").append("X");
      }
      for (Vector tile : game.snake) {
        buf.append("\033[").append(tile.y() + 1).append(";").append(tile.x() + 1).append("H").append('0');
      }
      buf.append("\033[").append(game.height).append(";").append(game.width).append("H\033[K");

      // Update screen
      conn.write(buf.toString());

      // Now update game and handle losing the game
      try {
        game.update();
      } catch (Exception e) {
        conn.write("YOU LOST");
        conn.close();
        return;
      }

      // Schedule a new execution of the game
      conn.schedule(new Runnable() {
        @Override
        public void run() {
          execute();
        }
      }, 500, TimeUnit.MILLISECONDS);
    }

    private void reset(Vector size) {
      // Fill factory area / 25
      game = new GameState(size.x(), size.y(), (size.x() * size.y()) / 10);
    }
  }
}