Snake/src/net/hoo2/auth/dsproject/snake/Game.java

package net.hoo2.auth.dsproject.snake;

/**
 * @mainpage
 * @title Snake game project. -- Part 1 --
 * 
 * This is the code documentation page of the Snake game project.
 * Listed are:
 * * All used classes
 * * All member functions
 * * All data members
 * 
 * @author Christos Choutouridis 8997
 * @email  cchoutou@ece.auth.gr
 */ 

import java.lang.Math;
import java.util.ArrayList;

/**
 * @class Game
 * 
 * @brief This is the main control class of the game. 
 * 
 * This class includes the main function.Using this class's api
 * the user can create a board, register players and roll the game. 
 * 
 * @author Christos Choutouridis 8997
 * @email  cchoutou@ece.auth.gr
 */
public class Game {
   /** Constants */
   /**@{ */
   static final int MAX_PLAYERS = 4;   /**< The maximum number of allowed players in the game */
   static final int MAX_GAME_ROUNDS = 10000;  /**< the maximum allowed round of the game */
   /**@} */

   /** Private data members */
   /** @{ */
   private int round;         /**< The current round of the game */
   private Board board;       /**< A reference to board */
   private ArrayList<Player> players;  /**< A reference to players */
   /** @} */
   
   /** private api */
   /** @{ */
   /**
    * Dice functionality
    * @return  An integer in the range [1 .. 6]
    */
   private int _dice () {
      return (int)(1 + Math.random()*5);
   }
   /**
    * Search the players already in the players vector and compare their turn to play
    * with the result of a dice. If there is another one with the same dice result return true.
    * 
    * @param turn       The dice result to check in order to find player's turn to play
    * @param players    Reference to already register players
    * @return           True if there is another player with the same dice result
    */
   private boolean _search (int die, ArrayList<Player> players) {
      for (int i =0; i<players.size() ; ++i)
         if (players.get(i).getTurn() == die)
            return true;
      return false;
   }
   /** @} */


   /** Constructors */
   /** @{ */
   /** Default doing nothing constructor */
   Game () {
      round    = 0;
      board    = new Board();
      players  = new ArrayList<>();
   }

   /**
    * @brief   The main constructor
    * This constructor create a board and prepares the board for the game.
    * After this call the user can call @ref registerPlayer()
    * @param N             The row for the board
    * @param M             The columns of the board
    * @param numOfSnakes   Number of snakes to place
    * @param numOfLadders  Number of ladders to place
    * @param numOfApples   Number of Apples to place
    */
   Game (int N, int M, int numOfSnakes, int numOfLadders, int numOfApples) {
      round    = 0;
      // delegate constructors
      board    = new Board (N, M, numOfSnakes, numOfLadders, numOfApples);
      players  = new ArrayList<>();
   }
   /** @} */
   
   /** Get/Set interface */
   /** @{ */
   int getRound () { return round; }
   void setRound (int round) { this.round = round; }
   /** Get reference to board */
   Board getBoard () { return board; }
   /** Set board
    * @param   board    Reference to board to use
    * @note    This requires board must be allocated elsewhere.
    */
   void setBoard (Board board) {
      this.board = board;
   }
   /** Get reference to players */
   ArrayList<Player> getPlayers() { return players; }
   /**
    * Set players
    * @param   players  Reference to players to use
    * @note    This requires players must be allocated elsewhere.
    */
   void setPlayers(ArrayList<Player> players) {
      this.players = players;
   }
   /** @} */
   
   /** Public functionality */
   /** @{ */
   /** 
    * Register a player to the game
    * @param playerId   The player ID to use
    * @param name       The player name to use
    * @return     The status of the operation
    */
   boolean registerPlayer (int playerId, String name) {
      if (players.size() >= MAX_PLAYERS)
         return false;
      players.add(new Player(playerId, name, board));
      return true;
   }
   /** 
    * @brief Set the playing order of players
    * This function emulates the classic roll of dice to decide which player
    * plays first which second and so on.
    */
   void playOrder () {
      int d;
      for (int i =0 ; i<players.size() ; ++i) {
         do
            // Keep rolling the dice as the die belongs to another user
            d = _dice();
         while (_search (d, players));
         players.get(i).setTurn(d);
      }
      // Sort players vector
      players.sort((p1, p2) ->
         Integer.compare (p1.getTurn(), p2.getTurn())
      );
   }

   /**
    * Sort the players according to their score
    */
   void scoreSort () {
      players.sort((p1, p2) ->
         Integer.compare (p1.getScore(), p2.getScore())
      );
   }

   /**
    * A game round. In each round every player plays when is his turn
    *
    * @return  The winner if we have one, or null
    */
   Player round () {
      int [] mret;
      ++round;    // keep track of round

      // traverse the players vector and move each player on the board
      // using a dice throw
      for (int i =0 ; i<players.size() ; ++i) {
         mret = players.get(i).move (players.get(i).getTile(), _dice());
         if (mret[0]>= board.getN()*board.getM())
            // The first one here is the winner
            return players.get(i);
      }
      return null;   // No one finished yet
   }
   /** @} */

   /**
    * @brief Main
    * As the requirements of the project suggested.
    * We:
    *  * Create a game
    *  * Manually create a board
    *  * Register 2 players (John Doe for now)
    *  * Place a predefined number of snakes, ladders and apples
    *  * Deploy the game by calling @ref playOrder() and @ref round()
    * At the end we print the results and exit
    */
   public static void main(String[] args) {     
      // Current project requirements
      int lines         = 20;
      int columns       = 10;
      int numOfSnakes   = 3;
      int numOfLadders  = 3;
      int numOfApples   = 6;
      int numOfPlayers  = 2;

      // Print caption
      System.out.println("================== Snake Game ==================");
      System.out.println("Board: " +lines +"x" +columns +" with " +numOfSnakes +" snakes, "
                         +numOfLadders +" ladders and " +numOfApples +" apples.");
      System.out.println("Players: " + numOfPlayers);
      System.out.println("");
      // Board creation
      Game game = new Game (lines, columns, numOfSnakes, numOfLadders, numOfApples);
      // game.getBoard().createElementBoard();  // Not explicitly required

      // Player registration
      for (int i=0 ; i<numOfPlayers && i<MAX_PLAYERS; ++i)
         game.registerPlayer(i+1, String.format("Player %d", i+1));    
      game.playOrder();                      // Choose play order

      Player winner;
      do                                     // Keep going until someone finishes
         winner = game.round ();
      while (winner == null
          && game.getRound() < MAX_GAME_ROUNDS);
      if (game.getRound() == MAX_GAME_ROUNDS) {
         // Check if we finished
         System.out.println("Game did not finished in " + MAX_GAME_ROUNDS + " rounds. Abort.");
         return;
      }

      // Print the results
      System.out.println("***** Game finished *****");
      System.out.println("");
      System.out.println("Rounds: " + game.getRound());
      System.out.println("Winner: " + winner.getName() + " [" + winner.getScore() +" points]");
      System.out.println("Score: ");
      game.scoreSort ();                     // sort players based on their score
      for (int i=game.getPlayers().size()-1 ; i>=0 ; --i) {
         // Loop all players
         Player p = game.getPlayers().get(i);
         if (p == winner)
            System.out.println(" * " +p.getName() + ": " + p.getScore() +" points");
         else
            System.out.println("   " +p.getName() + ": " + p.getScore() +" points");
      }
   }
}