DEV: 2nd version of the assignment (the code part)

src/host/labyrinth/Common.java

@@ -57,6 +57,7 @@ class DirRange {
    static final int  Begin =1;   /**< Iterator style begin of range direction (starting north) */
    static final int  End   =8;   /**< Iterator style end of range direction (one place after the last) */
    static final int  Step  =2;   /**< Step for iterator style direction */
+   static final int  numOfDirections =4;
 }
 
 /**

src/host/labyrinth/Game.java

@@ -18,12 +18,13 @@
  * all the supplies of the board before Minotaur catches him and before the
  * game ends.
  * 
- * In this first assignment we deal with the board's creation and a basic
+ * In this 2nd assignment we deal with the creation of a new heuristic player
- * player-game logic. The game is build around a number of classes:
+ * who can cheat and manipulate the dice. Documented classes:
- *  - \ref Tile
+ *  - Tile
  *  - Supply
  *  - Board
  *  - Player
+ *  - HeuristicPlayer
  *  - Game
  *
  * Which are the requested classes. We also provide some extra functionalities in:
@@ -153,10 +154,11 @@ public class Game {
          if (!Game.getArguments(args)) throw new Exception("");
 
          // Create a game, a board and 2 players.
-         Game game   = new Game();
+         Game game         = new Game();
-         Board board = new Board(Session.boardSize, Session.supplySize);
+         Board board       = new Board(Session.boardSize, Session.supplySize);
-         Player T    = new HeuristicPlayer("Theseus", true, board, 0);
+         Player T          = new HeuristicPlayer("Theseus", true, board, 0);
-         Player M    = new Player("Minotaur", false, board, Position.toID(Session.boardSize/2, Session.boardSize/2));
+         Player M          = new Player("Minotaur", false, board, Position.toID(Session.boardSize/2, Session.boardSize/2));
+         Player players [] = {T, M};
 
          // Populate data to the board
          board.createBoard(T.playerTileId(), M.playerTileId());
@@ -169,34 +171,36 @@ public class Game {
          game.waitUser ();
          // Main game loop
          while (true) {
-            int[] m;
             System.out.println();
-            System.out.println("State after round: " + (game.round()+1));
+            System.out.println("Round: " + (game.round()+1));
 
-            // Player moves
+            // Players moves
-            m = T.move(T.playerTileId());
+            for (Player p : players) {
-               System.out.println(T.getName() + ":\t tileId =" + m[0] + " (" + m[1] + ", " + m[2] + ")");
+               p.move(p.playerTileId());
-            m = M.move(M.playerTileId());
+               p.statistics();
-               System.out.println(M.getName() + ":\t tileId =" + m[0] + " (" + m[1] + ", " + m[2] + ")");
+            }
             board.printBoard(
                   board.getStringRepresentation(T.playerTileId(), M.playerTileId())
             );
 
             // Loop termination cases
             if (T.getScore() == 4) {
-               System.out.println(T.getName() + " Wins!!! Score =" + T.getScore());
+               System.out.println("**** " + T.getName() + " Wins!!! Score =" + T.getScore() + " ****");
-               System.exit(0);
+               break;
             }
             if (M.getScore() == 4 || M.playerTileId() == T.playerTileId()) {
-               System.out.println(M.getName() + " Wins!!! Score =" + M.getScore());
+               System.out.println("**** " + M.getName() + " Wins!!! Score =" + M.getScore());
-               System.exit(0);
+               break;
             }
             if (!(game.nextRound() < Session.maxRounds)) {
-               System.out.println("New day has come... Tie!!!");
+               System.out.println("**** New day has come... Tie! ****");
-               System.exit(0);
+               break;
             }
             game.waitUser ();
          }
+         for (Player p : players)
+            p.final_statistics();
+         System.exit(0);
       }
       catch (Exception e) {
          // We don't handle exceptions. Print error and exit with error status.

src/host/labyrinth/HeuristicPlayer.java

@@ -12,9 +12,6 @@
 
 package host.labyrinth;
 
-import java.util.ArrayList;
-//import java.util.Arrays;
-
 /**
  * @brief
  *    This class represents the game's player who cheats.
@@ -23,14 +20,28 @@ class HeuristicPlayer extends Player {
 
    /** @name Constructors */
    /** @{ */
+
+   /**
+    * Create a new player and put him at the row-column coordinates 
+    * @param name       The name of the player
+    * @param champion   Flag to indicate if a player is a `champion`
+    * @param board      Reference to the board of the game
+    * @param row        The row coordinate of initial player position
+    * @param column     The column coordinate of initial player's position
+    */
    public HeuristicPlayer(String name, boolean champion, Board board, int row, int column) {
       super(name, champion, board, row, column);
-      path = new ArrayList<Integer[]>();
    }
 
+   /**
+    * Create a new player and put him at the row-column coordinates 
+    * @param name       The name of the player
+    * @param champion   Flag to indicate if a player is a `champion`
+    * @param board      Reference to the board of the game
+    * @param tileId     The tileId coordinate of player's initial position
+    */
    public HeuristicPlayer(String name, boolean champion, Board board, int tileId) {
       super(name, champion, board, tileId);
-      path = new ArrayList<Integer[]>();
    }
    /** @} */
 
@@ -74,34 +85,21 @@ class HeuristicPlayer extends Player {
       return Const.noOpponent;
    }
 
-   double evaluate (int currentPos, int dice) {
+   /**
-      int opDist  = opponetInDirection (currentPos, dice);
+    * This is the main move evaluation function.
-      int supDist = supplyInDirection(currentPos, dice);
+    * @param currentPos    The current position of the player (before the move to evaluate)
+    * @param direction     The direction (a.k.a. the move) to evaluate
+    * @return              A signed real number. The higher the output, the higher the evaluation.
+    */
+   double evaluate (int currentPos, int direction) {
+      int opDist  = opponetInDirection (currentPos, direction);
+      int supDist = supplyInDirection(currentPos, direction);
 
       // saturate
-      opDist  = (opDist == Const.noOpponent) ? Integer.MAX_VALUE : opDist;
+      opDist  = (opDist == Const.noOpponent) ? 0: opDist;
-      supDist = (supDist == Const.noSupply)  ? Integer.MAX_VALUE : supDist;
+      supDist = (supDist == Const.noSupply)  ? 0 : supDist;
-      return 1.0/supDist * Const.supplyFactor
+      return ((supDist != 0)? (1.0/supDist * Const.supplyFactor) : 0)
-           - 1.0/opDist  * Const.opponentFactor; 
+           - ((opDist != 0) ? (1.0/opDist  * Const.opponentFactor) : 0); 
-   }
-
-   int directionOfMax (double[] eval, int[] eval_dir, int N) {
-      double M = Double.NEGATIVE_INFINITY;
-      int M_idx = -1;
-      for (int i =0; i < N ; ++i) {
-         if (eval[i] > M) {
-            M = eval[i];
-            M_idx = i;
-         }
-      }
-      return eval_dir[M_idx];
-   }
-
-   boolean isUnevaluated (double[] eval, int N) {
-      for (int i =0 ; i<N ; ++i)
-         if (eval[i] != 0 && eval[i] != Double.NEGATIVE_INFINITY)
-            return false;
-      return true;
    }
 
    // Must return a new move always
@@ -149,43 +147,119 @@ class HeuristicPlayer extends Player {
     * <li> int[3]: The supplyId in case player picked one (Const.noSupply otherwise).   
     * </ul>
     */
+   @Override
    int[] move(int id) {
       // Initialize return array with the current data
       int[] ret = new int[Const.moveItems];
       ret[0] = getNextMove(id);
       ret[1] = y = Position.toRow(ret[0]);
       ret[2] = x = Position.toCol(ret[0]);
-      int supplyFlag = 0;
+      int supplyFlag =0, moveFlag =1;
       // In case of a champion player, try also to pick a supply
       if (champion && (ret[3] = board.tryPickSupply(ret[0])) != Const.noSupply) {
          ++score;                               // keep score
          ++supplyFlag;
-         System.out.println(name + ":\t*Found a supply. [score: " + score + "]");
       }
+      int dir = Direction.get(id, ret[0]);      // update direction counters
+      ++dirCounter[dir];
       board.updateMove(ret, playerId);
 
       // Update supply and opponent distance
-      int dir = Direction.get(id, ret[0]);
       int smin =DirRange.End, omin =DirRange.End;
       for (int d = DirRange.Begin ; d<DirRange.End ; d += DirRange.Step) {
          int s = supplyInDirection (ret[0], d);
          int o = opponetInDirection(ret[0], d);
-         if (s < smin)  smin = s;
+         if (s >= 0 && s < smin)  smin = s;
-         if (o < omin)  omin = o;
+         if (o >= 0 && o < omin)  omin = o;
       }
-      Integer[] p = {dir, supplyFlag, smin, omin };
+      // update path
-
+      Integer[] p = {
+            ret[0], dir, moveFlag, supplyFlag,
+            dirCounter[Direction.UP], dirCounter[Direction.RIGHT], dirCounter[Direction.DOWN], dirCounter[Direction.LEFT],
+            (smin != DirRange.End)? smin:Const.noSupply, (omin != DirRange.End)? omin:Const.noOpponent
+      };
       path.add(p);
       return ret;
    }
 
+   /**
+    * Prints round information for the player
+    */
+   void statistics() {
+      if (!path.isEmpty()) {
+         Integer[] last = path.get(path.size()-1);
+         String who = String.format("%12s", name);
+         System.out.print(who + ": score[" + score + "]" + ", dice =" + last[1] + ", tileId =" + last[0] + " (" + Position.toRow(last[0]) + ", " + Position.toCol(last[0]) + ")");
+         if (last[2] == 0)
+            System.out.println(" *Can not move.");
+         else if (last[3] != 0)
+            System.out.println(" *Found a supply.");
+         else
+            System.out.println("");
+         // extra prints for heuristic
+         if (last[8] != Const.noSupply)   System.out.println("            supply distance   =" + last[8]);
+         else                             System.out.println("            supply distance   = blind");
+         if (last[9] != Const.noOpponent) System.out.println("            opponent distance =" + last[9]);
+         else                             System.out.println("            opponent distance = blind");
+      }
+   }
+   
+   /**
+    * Prints final statistics for the player
+    */
+   void final_statistics () {
+      String who = String.format("%12s", name);
+      System.out.println();
+      System.out.println(who + ": score[" + score + "]");
+      System.out.println("    Moves up: " + dirCounter[Direction.UP]);
+      System.out.println(" Moves right: " + dirCounter[Direction.RIGHT]);
+      System.out.println("  Moves down: " + dirCounter[Direction.DOWN]);
+      System.out.println("  Moves left: " + dirCounter[Direction.LEFT]);
+   }
+
    /** @} */
+
+   /**
+    * A small utility to extract the direction of maximum evaluation result.
+    *
+    * We search into the \c eval results and find the index of the maximum evaluation.
+    * Then we return the direction of \c eval_dir matrix at the same index we found.
+    *
+    * @param eval       Array with evaluation results for each direction
+    * @param eval_dir   Array with the matching direction to \c eval array
+    * @param N          The size of both arrays
+    * @return           The direction of maximum evaluation. If \c eval is empty returns the first item \c eval[0]
+    * @note
+    *    This function should not be called if there is at least one evaluation result in \c eval
+    */
+   private int directionOfMax (double[] eval, int[] eval_dir, int N) {
+      double M = Double.NEGATIVE_INFINITY;
+      int M_idx = 0;
+      for (int i =0; i < N ; ++i) {
+         if (eval[i] > M) {
+            M = eval[i];
+            M_idx = i;
+         }
+      }
+      return eval_dir[M_idx];
+   }
+
+   /**
+    * A small utility to check if there is at least one evaluation result in the \c eval array
+    * @param eval    The array to check
+    * @param N       The size of the array
+    * @return        True if there is none, false otherwise
+    */
+   private boolean isUnevaluated (double[] eval, int N) {
+      for (int i =0 ; i<N ; ++i)
+         if (eval[i] != 0 && eval[i] != Double.NEGATIVE_INFINITY)
+            return false;
+      return true;
+   }
+   
    /** @name Class data */
    /** @{ */
-   private ArrayList<Integer[]>     path;   /**< our history
+
-                                             * The integer[] format is:
-                                             * { dice, tookSupply, SupplyDistance, OpponentDistance}
-                                             */
 
    /** @} */
 }

src/host/labyrinth/Player.java

@@ -12,6 +12,8 @@
 
 package host.labyrinth;
 
+import java.util.ArrayList;
+
 /**
  * @brief
  *    This class represents the game's player
@@ -22,7 +24,6 @@ class Player {
 
    /**
     * Create a new player and put him at the row-column coordinates 
-    * @param id         The id of the player
     * @param name       The name of the player
     * @param champion   Flag to indicate if a player is a `champion`
     * @param board      Reference to the board of the game
@@ -37,13 +38,16 @@ class Player {
       this.x         = column;
       this.y         = row;
       this.champion  = champion;
-      int[] m = {Position.toID(row, column), row, column, Const.noSupply};
+      this.dirCounter= new int[DirRange.End];      // yes we spoil some memory. Java is worst.
+      this.path      = new ArrayList<Integer[]>();
+      int[] m        = {
+            Position.toID(row, column), row, column, Const.noSupply
+      };
       board.updateMove(m, playerId);
    }
 
    /**
     * Create a new player and put him at the row-column coordinates 
-    * @param id         The id of the player
     * @param name       The name of the player
     * @param champion   Flag to indicate if a player is a `champion`
     * @param board      Reference to the board of the game
@@ -57,7 +61,11 @@ class Player {
       this.x         = Position.toCol(tileId);
       this.y         = Position.toRow(tileId);
       this.champion  = champion;
-      int[] m = {tileId, Position.toRow(tileId), Position.toCol(tileId), Const.noSupply};
+      this.dirCounter= new int[DirRange.End];      // yes we spoil some memory. Java is worst.
+      this.path      = new ArrayList<Integer[]>();
+      int[] m        = {
+            tileId, Position.toRow(tileId), Position.toCol(tileId), Const.noSupply
+      };
       board.updateMove(m, playerId);
    }
    /** @} */
@@ -89,9 +97,11 @@ class Player {
       ret[1] = Position.toRow(id);
       ret[2] = Position.toCol(id);
       ret[3] = Const.noSupply;
+      int supplyFlag =0, moveFlag =0;
 
       int diceDirection = board.dice();            // throw the dice
       if (board.isWalkable(id, diceDirection)) {   // The result is walkable
+         moveFlag =1;                              // mark the successful move
          // Get next tile
          Position next = new Position(Position.toRow(id), Position.toCol(id), diceDirection);
          ret[0] = next.getId();                    // Update player's and return data
@@ -99,16 +109,49 @@ class Player {
          ret[2] = x = next.getCol();
          // In case of a champion player, try also to pick a supply
          if (champion && (ret[3] = board.tryPickSupply(next.getId())) != Const.noSupply) {
+            supplyFlag =1;                         // mark the successful supply pickup
             ++score;                               // keep score
-            System.out.println(name + ":\t*Found a supply. [score: " + score + "]");
          }
+         ++dirCounter[diceDirection];              // update direction counters
          board.updateMove(ret, playerId);
       }
-      else
+      // update path
-         System.out.println(name + ":\t*Can not move.");
+      Integer[] p = {
+            ret[0], diceDirection, moveFlag, supplyFlag,
+            dirCounter[Direction.UP], dirCounter[Direction.RIGHT], dirCounter[Direction.DOWN], dirCounter[Direction.LEFT],
+            Const.noSupply, Const.noOpponent
+      };
+      path.add(p);
       return ret;
    }
 
+   /**
+    * Prints round information for the player
+    */
+   void statistics() {
+      if (!path.isEmpty()) {
+         Integer[] last = path.get(path.size()-1);
+         String who = String.format("%12s", name);
+         System.out.print(who + ": score[" + score + "]" + ", dice =" + last[1] + ", tileId =" + last[0] + " (" + Position.toRow(last[0]) + ", " + Position.toCol(last[0]) + ")");
+         if (last[2] == 0)
+            System.out.println(" *Can not move.");
+         else if (last[3] != 0)
+            System.out.println(" *Found a supply.");
+         else
+            System.out.println("");
+      }
+   }
+
+   /**
+    * Prints final statistics for the player
+    * @note
+    *    We add this final_statistics() wrapper in order to provide polymorphism to
+    *    Player class hierarchy and to be sure that we are not braking the
+    *    Liskov substitution principle
+    *    @see https://en.wikipedia.org/wiki/Liskov_substitution_principle
+    */
+   void final_statistics () { }
+
    /** Utility to access player's tileID */
    int playerTileId()   { return Position.toID(y, x); }
    /** Utility to access player's row position (row coordinate) */
@@ -147,17 +190,34 @@ class Player {
    void setChampion (boolean champion) {
       this.champion = champion;
    }
-
    /** @} */
 
    /** @name Class data */
    /** @{ */
-   protected int    playerId;   /**< The unique identifier of the player */
+   protected int     playerId;      /**< The unique identifier of the player */
-   protected String name;       /**< The name of the player */ 
+   protected String  name;          /**< The name of the player */ 
-   protected Board  board;      /**< Reference to the session's boards */
+   protected Board   board;         /**< Reference to the session's boards */
-   protected int    score;      /**< The current score of the player */
+   protected int     score;         /**< The current score of the player */
-   protected int    x;          /**< The column coordinate of the player on the board */
+   protected int     x;             /**< The column coordinate of the player on the board */
-   protected int    y;          /**< The row coordinate of the player on the board */
+   protected int     y;             /**< The row coordinate of the player on the board */
-   protected boolean champion;  /**< Champion indicate a player who plays against the Minotaur */
+   protected boolean champion;      /**< Champion indicate a player who plays against the Minotaur */
+   protected int     dirCounter[];
+   protected ArrayList<Integer[]> path;
+   /**<
+    * our history. The integer[] format is:
+    * <ul> 
+    * <li> Integer[0]: tileId       - The tile id we choose for the move
+    * <li> Integer[1]: dice         - The dice (a.k.a direction) of move
+    * <li> Integer[2]: moveStatus   - True if it was successful (we can move in that direction)
+    * <li> Integer[3]: tookSupply   - True if we took supply
+    * <li> Integer[4]: upCounter    - Accumulator to count all the up moves
+    * <li> Integer[5]: righrCounter - Accumulator to count all the right moves
+    * <li> Integer[6]: downCounter  - Accumulator to count all the down moves
+    * <li> Integer[7]: leftCounter  - Accumulator to count all the left moves
+    * <li> Integer[8]: SupDistance  - The distance of the nearest supply (only for heuristic players)
+    * <li> Integer[9]: OppDistance  - The distance of the nearest opponent (only for heuristic players)
+    * </ul>
+    * }
+    */
    /** @} */
 }