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 AEM:8997
 * @email  cchoutou@ece.auth.gr
 */ 
import java.util.*;

/**
 * @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 AEM:8997
 * @email  cchoutou@ece.auth.gr
 */
public class Game {
   /** @name Constants */
   /**@{ */
   static final int MAX_PLAYERS = 6;   /**< The maximum number of allowed players in the game */
   static final int MAX_GAME_ROUNDS = 1000;  /**< the maximum allowed round of the game */
   /**@} */

   /** @name 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 Map<Integer, Integer> playingOrder;
   /** @} */
   
   /** @name private api */
   /** @{ */

   /**
    * 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<Integer[]> pairs) {
      for (int i =0; i<pairs.size() ; ++i)
         if (pairs.get(i)[1] == die)
            return true;
      return false;
   }
   
   private void _sort (ArrayList<Integer[]> pairs) {
      Integer[] temp;
      for (int i=pairs.size()-1 ; i>0 ; --i) {
         for (int j =0 ; j<i ; ++j) {
            if (pairs.get(j)[1] > pairs.get(i)[1]) {
               temp       = pairs.get(i);
               pairs.set(i, pairs.get(j));
               pairs.set(j, temp);
            }
         }
      }
   }
   
   private Player _getPlayer(int playerId) {
      for (Player p : players) {
         if (p.getPlayerId() == playerId)
            return p;
      }
      return null;
   }
   /** @} */


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

   /**
    * @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<>();
      playingOrder
               = new HashMap<Integer, Integer>();
   }
   /** @} */
   
   /** @name 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;
   }
   
   Map<Integer, Integer> getPlayingOrder () { return playingOrder; }
   void setPlayingOrder (Map<Integer, Integer> playingOrder) {
      this.playingOrder = playingOrder;
   }
   /** @} */
   
   /** @name 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;
   }
   
   /** 
    * 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 registerHeuristicPlayer (int playerId, String name) {
      if (players.size() >= MAX_PLAYERS)
         return false;
      players.add(new HeuristicPlayer(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.
    */
   Map<Integer, Integer> setTurns (ArrayList<Player> players) {
      int[]       pairData = new int[2];
      Integer[]   PairData;
      ArrayList<Integer[]>
                  pairList = new ArrayList<>();

      for (int d, i =0 ; i<players.size() ; ++i) {
         do
            d = players.get(i).dice ();
         while (_search (d, pairList));
         pairData[0] = players.get(i).getPlayerId();
         pairData[1] = d;
         PairData = Arrays.stream(pairData).boxed().toArray( Integer[]::new );
         pairList.add(PairData);
      }
      // Sort playeingOrger
      _sort (pairList);
      // Make and return the Map
      for (int i =0 ; i<pairList.size() ; ++i) {
         playingOrder.put(pairList.get(i)[0], pairList.get(i)[1]);
      }
      return playingOrder;
      
   }
   /**
    * 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 (boolean verbose) {
      int tile;
      ++round;    // keep track of round

      // traverse the players vector and move each player on the board
      // using a dice throw
      for (Integer pid : playingOrder.keySet()) {
         Player p = _getPlayer(pid);
         tile = p.getNextMove (p.getTile());
         p.statistics(verbose, false);
         if (tile>= board.getN()*board.getM())
            // The first one here is the winner
            return p;
      }
      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;
      boolean verbose   = false;

      // 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, the one is cheater
      for (int i=0 ; i<numOfPlayers && i<MAX_PLAYERS; ++i) {
         if (i == 0)
            game.registerHeuristicPlayer(i+1, String.format("Player %d", i+1));
         else
            game.registerPlayer(i+1, String.format("Player %d", i+1));
      }
      game.setTurns(game.getPlayers());      // Choose play order

      Player winner;
      do                                     // Keep going until someone finishes
         winner = game.round (verbose);
      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("");
      System.out.println("*** Game Results ***");
      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");
      }

      for (Player p : game.getPlayers()) {
         if (p.getClass().getSimpleName().equals("HeuristicPlayer"))
            p.statistics(verbose, true);
      }

   }
}