.gitignore

@@ -1,8 +1,8 @@
 *bin/*
 *doc/*
+*report/*
 *deliverable/*
 *.project
 *.classpath
 *.pdf
 
-/bin/

src/net/hoo2/auth/dsproject/snake/Apple.java

@@ -1,5 +1,7 @@
 package net.hoo2.auth.dsproject.snake;
 
+import java.lang.Math;
+
 /**
  * @class Apple
  * @brief Represent an Apple in the Board.

src/net/hoo2/auth/dsproject/snake/Board.java

@@ -1,7 +1,6 @@
 package net.hoo2.auth.dsproject.snake;
 
 import java.lang.Math;
-import java.util.*;
 
 /**
  * @class Board
@@ -34,7 +33,6 @@ public class Board {
       snakes  = null;
       ladders = null;
       apples  = null;
-      players = null;
    }
    
    /**
@@ -66,7 +64,6 @@ public class Board {
       snakes  = new Snake[numOfSnakes];
       ladders = new Ladder[numOfLadders];
       apples  = new Apple[numOfApples];
-      players = null;
       createBoard ();   // Complete board preparation and make all the element memory allocations
    }
    
@@ -84,7 +81,6 @@ public class Board {
       snakes  = new Snake[B.getSnakes().length];
       ladders = new Ladder[B.getLadders().length];
       apples  = new Apple[B.getApples().length];
-      players = B.getPlayers();  // reference only (don't need to clone)
       // Copy B's guts into new memory
       copyTiles(B.getTiles());
       copySnakes(B.getSnakes());
@@ -143,13 +139,6 @@ public class Board {
     */
    void setApples(Apple[] apples) { this.apples = apples; }
    
-   /** get reference to players */
-   ArrayList<Player> getPlayers() { return players; }
-   /** set reference to players */
-   void setPlayers (ArrayList<Player> players) {
-      this.players = players;
-   }
-
    /**
     * Copy tiles
     * @param   tiles    Source of tiles to use
@@ -234,11 +223,11 @@ public class Board {
     * @param tile    The tile to check
     * @return        The result tile
     */
-   int checkLadder (int tile, boolean climb) {
+   int checkLadder (int tile) {
       for (int i =0 ; i<ladders.length ; ++i) {
          if (ladders[i].getDownStepId() == tile &&
              ladders[i].getBroken() == false) {
-            ladders[i].setBroken(climb);
+            ladders[i].setBroken(true);
             return ladders[i].getUpStepId();
          }
       }
@@ -250,14 +239,13 @@ public class Board {
     * @param tile    The tile to check
     * @return        The score difference
     */
-   int checkApple (int tile, boolean eat) {
+   int checkApple (int tile) {
       int ds =0;  // delta-score
       for (int i =0 ; i<apples.length ; ++i) {
          if (apples[i].getAppleTileId() == tile) {
-            ds = apples[i].getPoints();
             // eat it
-            if (eat)
+            ds = apples[i].getPoints();
-               apples[i].setPoints(0);
+            apples[i].setPoints(0);
          }
       }
       return ds;
@@ -563,7 +551,6 @@ public class Board {
    private Snake[]  snakes;   /**< Board's snakes */
    private Ladder[] ladders;  /**< Board's ladders */
    private Apple[]  apples;   /**< Board's apples */
-   private ArrayList<Player> players;  /**< board's copy of players reference vector */
    /** @} */
 }
 

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

@@ -2,7 +2,7 @@ package net.hoo2.auth.dsproject.snake;
 
 /**
  * @mainpage
- * @title Snake game project. -- Part 3 --
+ * @title Snake game project. -- Part 1 --
  * 
  * This is the code documentation page of the Snake game project.
  * Listed are:
@@ -13,7 +13,9 @@ package net.hoo2.auth.dsproject.snake;
  * @author Christos Choutouridis AEM:8997
  * @email  cchoutou@ece.auth.gr
  */ 
-import java.util.*;
+
+import java.lang.Math;
+import java.util.ArrayList;
 
 /**
  * @class Game
@@ -29,74 +31,40 @@ import java.util.*;
 public class Game {
    /** @name Constants */
    /**@{ */
-   static final int MAX_PLAYERS = 6;   /**< The maximum number of allowed players in the game */
+   static final int MAX_PLAYERS = 4;   /**< The maximum number of allowed players in the game */
-   static final int MAX_GAME_ROUNDS = 1000;  /**< the maximum allowed round of the game */
+   static final int MAX_GAME_ROUNDS = 10000;  /**< 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 ArrayList<Player> players;  /**< A reference to players */
-   private Map<Integer, Integer> playingOrder;  /**< A Map with {PlayerID, Dice-roll} pairs 
-                                      @note
-                                         This way of storing the playing order is unnecessary.
-                                         The old style was far more better. We had a turn variable
-                                         in each Player and we used to sort the players vector based on
-                                         that value. This made the rest of the program simpler, faster, easer.
-                                         We have adopt the above approach just because it is one of the
-                                         homework requirements.
-                                         */
    /** @} */
    
    /** @name private api */
    /** @{ */
-
    /**
-    * Search the players already in the pairs vector and compare their turn to play
+    * 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 roll       The dice result to check in order to find player's turn to play
+    * @param turn       The dice result to check in order to find player's turn to play
-    * @param pairs      Reference to already register players and their dice result
+    * @param players    Reference to already register players
     * @return           True if there is another player with the same dice result
     */
-   private boolean _search (int roll, ArrayList<Integer[]> pairs) {
+   private boolean _search (int die, ArrayList<Player> players) {
-      for (int i =0; i<pairs.size() ; ++i)
+      for (int i =0; i<players.size() ; ++i)
-         if (pairs.get(i)[1] == roll)
+         if (players.get(i).getTurn() == die)
             return true;
       return false;
    }
-
-   /**
-    * Sort the pairs vector using second parameter witch represent the
-    * dice roll. We use bubblesort for the implementation.
-    * @param pairs   A vector with {PlayerId, dice-roll} pairs to sort
-    */
-   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);
-            }
-         }
-      }
-   }
-
-   /**
-    * Helper function to get a player from players vector using it's ID
-    * @param   playerId    The player's ID to seek
-    * @return  Reference to Player or null
-    */
-   private Player _getPlayer(int playerId) {
-      for (Player p : players) {
-         if (p.getPlayerId() == playerId)
-            return p;
-      }
-      return null;
-   }
    /** @} */
 
 
@@ -107,8 +75,6 @@ public class Game {
       round    = 0;
       board    = new Board();
       players  = new ArrayList<>();
-      playingOrder
-               = new HashMap<Integer, Integer>();
    }
 
    /**
@@ -126,8 +92,6 @@ public class Game {
       // delegate constructors
       board    = new Board (N, M, numOfSnakes, numOfLadders, numOfApples);
       players  = new ArrayList<>();
-      playingOrder
-               = new HashMap<Integer, Integer>();
    }
    /** @} */
    
@@ -154,12 +118,6 @@ public class Game {
    void setPlayers(ArrayList<Player> players) {
       this.players = players;
    }
-   /** Get reference to playingOrder Map */
-   Map<Integer, Integer> getPlayingOrder () { return playingOrder; }
-   /** Set the playingOrder Map */
-   void setPlayingOrder (Map<Integer, Integer> playingOrder) {
-      this.playingOrder = playingOrder;
-   }
    /** @} */
    
    /** @name Public functionality */
@@ -173,71 +131,29 @@ public class Game {
    boolean registerPlayer (int playerId, String name) {
       if (players.size() >= MAX_PLAYERS)
          return false;
-      players.add(new Player(playerId, name));
+      players.add(new Player(playerId, name, board));
       return true;
    }
-   
-//   /** 
-//    * Register a heuristic 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));
-//      players.add(new HeuristicPlayer(playerId, name));
-//      return true;
-//   }
-   
-   /** 
-    * Register a heuristic 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 registerMinMaxPlayer (int playerId, String name) {
-      if (players.size() >= MAX_PLAYERS)
-         return false;
-      //players.add(new HeuristicPlayer(playerId, name, board));
-      players.add(new MinMaxPlayer(playerId, name));
-      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) {
+   void playOrder () {
-      int[]       pairData = new int[2];  // We use plain int[] to create an Integer[]
+      int d;
-      Integer[]   PairData;     // The Integer[] to push to ArrayList<>          
+      for (int i =0 ; i<players.size() ; ++i) {
-      ArrayList<Integer[]>
-                  pairList = new ArrayList<>(); // Use use ArrayList before Map in order to sort
-
-      for (int d, i =0 ; i<players.size() ; ++i) {
          do
-            // Keep rolling the dice until we get a unique value
+            // Keep rolling the dice as the die belongs to another user
-            d = players.get(i).dice ();
+            d = _dice();
-         while (_search (d, pairList));
+         while (_search (d, players));
-         // Make Integer[] pair
+         players.get(i).setTurn(d);
-         pairData[0] = players.get(i).getPlayerId();
-         pairData[1] = d;
-         PairData = Arrays.stream(pairData)
-                          .boxed()
-                          .toArray(Integer[]::new);
-         pairList.add(PairData); // Add to vector
       }
-      // Sort playeingOrger
+      // Sort players vector
-      _sort (pairList);
+      players.sort((p1, p2) ->
-      // Make and return the Map
+         Integer.compare (p1.getTurn(), p2.getTurn())
-      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
     */
@@ -250,22 +166,19 @@ public class Game {
    /**
     * A game round. In each round every player plays when is his turn
     *
-    * @param   verbose  Flag to indicate how much we print to console
     * @return  The winner if we have one, or null
     */
-   Player round (boolean verbose) {
+   Player round () {
-      int tile;
+      int [] mret;
       ++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()) {
+      for (int i =0 ; i<players.size() ; ++i) {
-         Player p = _getPlayer(pid);
+         mret = players.get(i).move (players.get(i).getTile(), _dice());
-         tile = p.getNextMove (board, p.getTile())[0];
+         if (mret[0]>= board.getN()*board.getM())
-         p.statistics(verbose, false);
-         if (tile>= board.getN()*board.getM())
             // The first one here is the winner
-            return p;
+            return players.get(i);
       }
       return null;   // No one finished yet
    }
@@ -290,7 +203,6 @@ public class Game {
       int numOfLadders  = 3;
       int numOfApples   = 6;
       int numOfPlayers  = 2;
-      boolean verbose   = true;
 
       // Print caption
       System.out.println("================== Snake Game ==================");
@@ -302,18 +214,14 @@ public class Game {
       Game game = new Game (lines, columns, numOfSnakes, numOfLadders, numOfApples);
       // game.getBoard().createElementBoard();  // Not explicitly required
 
-      // Player registration, the one is cheater
+      // Player registration
-      for (int i=0 ; i<numOfPlayers && i<MAX_PLAYERS; ++i) {
+      for (int i=0 ; i<numOfPlayers && i<MAX_PLAYERS; ++i)
-         if (i == 0)
+         game.registerPlayer(i+1, String.format("Player %d", i+1));    
-            game.registerMinMaxPlayer(i+1, String.format("Player %d", i+1));
+      game.playOrder();                      // Choose play order
-         else
+
-            game.registerPlayer(i+1, String.format("Player %d", i+1));
-      }
-      game.setTurns(game.getPlayers());         // Choose play order
-      game.board.setPlayers(game.getPlayers()); // inform the board with the players
       Player winner;
-      do                                        // Keep going until someone finishes
+      do                                     // Keep going until someone finishes
-         winner = game.round (verbose);
+         winner = game.round ();
       while (winner == null
           && game.getRound() < MAX_GAME_ROUNDS);
       if (game.getRound() == MAX_GAME_ROUNDS) {
@@ -323,10 +231,8 @@ public class Game {
       }
 
       // Print the results
-      System.out.println("*** Game finished ***");
+      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: ");
@@ -339,13 +245,5 @@ public class Game {
          else
             System.out.println("   " +p.getName() + ": " + p.getScore() +" points");
       }
-
-      // Print the extra statistics for the heuristic player only
-      // We use a little reflection for that
-      for (Player p : game.getPlayers()) {
-         if (p.getClass().getSimpleName().equals("HeuristicPlayer"))
-            p.statistics(verbose, true);
-      }
-
    }
 }

src/net/hoo2/auth/dsproject/snake/HeuristicPlayer.java

@@ -1,140 +0,0 @@
-package net.hoo2.auth.dsproject.snake;
-
-import java.util.*;
-
-/**
- * @class HeuristicPlayer
- * @brief Represent a Heuristic Player in the Game
- * 
- * The players are playing in a round-robin sequence and we keep track
- * for each one of them their playing order, score and place on the board.
- * This kind of player, is a cheater. He can control the dice. Not fair dude.
- * 
- * @author Christos Choutouridis AEM:8997
- * @email  cchoutou@ece.auth.gr
- */
-public class HeuristicPlayer
-             extends Player {
-
-   /** @name Constructors */
-   /** @{ */
-   /** Default doing nothing constructor */
-   public HeuristicPlayer() {
-      super ();
-      path = new ArrayList<Integer[]>();
-   }
-   /**
-    * @brief   The main constructor
-    * 
-    * This creates a player for the game
-    * @param playerId   The player's to create
-    * @param name       The name of the player
-    * @param board      Reference to the board the player will play on.
-    */
-   HeuristicPlayer (int playerId, String name) {
-      super (playerId, name);
-      path = new ArrayList<Integer[]>();
-   }
-   /* @} */
-
-   /** @name Get/Set interface */
-   /** @{ */
-   ArrayList<Integer[]> getPath() { return path; }
-   void setPath (ArrayList<Integer[]> path) {
-      this.path = path;
-   }
-   /** @} */
-   
-   /**
-    * Override dice functionality for the player
-    * @return  As this is called from the game only to select playing order 
-    *          we cheat and return 1
-    */
-   @Override
-   int dice () {
-      return 1;
-   }
-   
-   /**
-    * Override get the next tile after the user's move
-    * @param tile    The initial tile
-    * @return  The tile after the move
-    */
-   @Override
-   int getNextMove (int tile) {
-      Map<Integer, Double> moves = new HashMap<Integer, Double>();
-      double max = Double.NEGATIVE_INFINITY;
-      double ev  = Double.NEGATIVE_INFINITY;
-      int   roll = 0;
-
-      // Evaluate each possible dice result and find the better one
-      for (int r=1 ; r<=6 ; ++r) {
-         moves.put (new Integer(r), evaluate (tile, r));
-         if ((ev = moves.get(r)) > max) {
-            max = ev;
-            roll = r;
-         }
-      }
-      // Do the move and get the move data
-      Integer[] move_data = Arrays.stream(move (tile, roll, true))
-                                  .boxed()
-                                  .toArray(Integer[]::new);
-      // Store the move data
-      path.add(move_data);
-      return tile + roll;  // return the new tile position
-   }
-
-   /**
-    * The Heuristic statistics version
-    * @param verbose    Flag to select the verbosity
-    * @param sum        Flag to select if we need to print a summarize of the user hystory
-    */
-   @Override
-   void statistics (boolean verbose, boolean sum) {
-      if (sum) {
-         // If we run the summarize
-         int nSnakes      =0;
-         int nLadders     =0;
-         int nRedApples   =0;
-         int nBlackApples =0;
-
-         // Calculate frequencies
-         for (int i=0 ; i<path.size() ; ++i) {
-            nSnakes += path.get(i)[MOVE_SNAKES_IDX];
-            nLadders+= path.get(i)[MOVE_LADDERS_IDX];
-            nRedApples   += path.get(i)[MOVE_RED_APPLES_IDX];
-            nBlackApples += path.get(i)[MOVE_BLACK_APPLES_IDX];
-         }
-         // Print the results
-         System.out.println("");
-         System.out.println("*** Statistics for " + name + " ***");
-         System.out.println("   Number of Snake bites       : " + nSnakes);
-         System.out.println("   Number of Ladders used      : " + nLadders);
-         System.out.println("   Number of Red Apples eaten  : " + nRedApples);
-         System.out.println("   Number of Black Apples eaten: " + nBlackApples);
-         
-      }
-      else
-         // Call the base version
-         super.statistics(verbose, sum);
-   }
-
-   
-   /**
-    * The main evaluation function
-    * @param tile    The current tile of the player
-    * @param roll    the roll to check
-    * @return        The evaluation of the roll
-    */
-   private double evaluate (int tile, int roll) {
-      int[] check = new int[MOVE_DATA_SIZE]; 
-      check = move(tile, roll, false);
-      
-      return 0.65*check[MOVE_STEPS_IDX] + 0.35*check[MOVE_POINTS_IDX];
-   }
-
-   /** @name Data members package access only */
-   /** @{ */
-   private ArrayList<Integer[]> path;  /**< Players history as required */
-   /** @} */
-}

src/net/hoo2/auth/dsproject/snake/MinMaxPlayer.java

@@ -1,290 +0,0 @@
-package net.hoo2.auth.dsproject.snake;
-
-import java.util.*;
-
-/**
- * @class MinMaxPlayer
- * @brief Represent a MinMax Player in the Game
- * 
- * The players are playing in a round-robin sequence and we keep track
- * for each one of them their playing order, score and place on the board.
- * This kind of player, is a cheater. He can control the dice. Not fair dude.
- * 
- * @author Christos Choutouridis AEM:8997
- * @email  cchoutou@ece.auth.gr
- */
-public class MinMaxPlayer
-             extends Player {
-   static final int MINIMAX_TREE_DEPTH    = 2;  /**< The maximum depth of the minimax tree */
-   /** @name Constructors */
-   /** @{ */
-   /** Default doing nothing constructor */
-   public MinMaxPlayer() {
-      super ();
-      path = new ArrayList<Integer[]>();
-   }
-   /**
-    * @brief   The main constructor
-    * 
-    * This creates a player for the game
-    * @param playerId   The player's to create
-    * @param name       The name of the player
-    * @param board      Reference to the board the player will play on.
-    */
-   MinMaxPlayer (int playerId, String name) {
-      super (playerId, name);
-      path = new ArrayList<Integer[]>();
-   }
-   /* @} */
-
-   /** @name Get/Set interface */
-   /** @{ */
-   ArrayList<Integer[]> getPath() { return path; }
-   void setPath (ArrayList<Integer[]> path) {
-      this.path = path;
-   }
-   /** @} */
-   
-   /**
-    * Override dice functionality for the player
-    * @return  As this is called from the game only to select playing order 
-    *          we cheat and return 1
-    */
-   @Override
-   int dice () {
-      return 1;
-   }
-   
-   /**
-    * Override get the next move after the user's move
-    * @param board   The board in which we play on
-    * @param tile    The initial tile
-    * @return  The the move as an array
-    *          See @ref Node.nodeMove
-    */
-   @Override
-   int[] getNextMove (Board board, int tile) {
-      int [] ret = new int[4]; 
-      Node root = new Node (board);
-      
-      createMySubtree(root, 1, tile, selectOpponent(board).getTile());
-      // Evaluate each possible dice result and find the better one
-      Node r = MaxValue (root, Double.NEGATIVE_INFINITY, Double.POSITIVE_INFINITY);
-      // Do the move and get the move data
-      Integer[] move_data = Arrays.stream (move (board, tile, r.getNodeMove()[3], true))
-                                  .boxed()
-                                  .toArray(Integer[]::new);
-      // Store the move data
-      path.add(move_data);
-      ret[0] = move_data[MOVE_TILE_IDX];
-      ret[1] = move_data[MOVE_INITTILE_IDX];
-      ret[2] = move_data[MOVE_POINTS_IDX];
-      ret[3] = move_data[MOVE_ROLL_IDX];
-      return ret;  // return the new tile position
-   }
-
-   /**
-    * The MinMax statistics version
-    * @param verbose    Flag to select the verbosity
-    * @param sum        Flag to select if we need to print a summarize of the user history
-    */
-   @Override
-   void statistics (boolean verbose, boolean sum) {
-      if (sum) {
-         // If we run the summarize
-         int nSnakes      =0;
-         int nLadders     =0;
-         int nRedApples   =0;
-         int nBlackApples =0;
-
-         // Calculate frequencies
-         for (int i=0 ; i<path.size() ; ++i) {
-            nSnakes += path.get(i)[MOVE_SNAKES_IDX];
-            nLadders+= path.get(i)[MOVE_LADDERS_IDX];
-            nRedApples   += path.get(i)[MOVE_RED_APPLES_IDX];
-            nBlackApples += path.get(i)[MOVE_BLACK_APPLES_IDX];
-         }
-         // Print the results
-         System.out.println("");
-         System.out.println("*** Statistics for " + name + " ***");
-         System.out.println("   Number of Snake bites       : " + nSnakes);
-         System.out.println("   Number of Ladders used      : " + nLadders);
-         System.out.println("   Number of Red Apples eaten  : " + nRedApples);
-         System.out.println("   Number of Black Apples eaten: " + nBlackApples);
-         
-      }
-      else
-         // Call the base version
-         super.statistics(verbose, sum);
-   }
-
-   /** @name Private helper API */
-   /** @{ */
-   /** 
-    * Select the the best Opponent
-    * @param   board    Reference to current board
-    * @return  Reference to the player who is most far in the board
-    */
-   private Player selectOpponent (Board board) {
-      Player opp = null;
-      int max_tile = Integer.MIN_VALUE;
-      for (Player p : board.getPlayers()) {
-         if (p == this)                // Please do not return me
-            continue;
-         if (opp == null)  opp = p;    // init variable
-         if (p.getTile() > max_tile) { // max filtering
-            opp = p;
-            max_tile = p.getTile();
-         }
-      }
-      return opp;
-   }
-
-   /**
-    * One of the 2 recursive functions for creating the minimax tree. This one 
-    * creates children for the MinMax player
-    * @param parent  The parent Node
-    * @param depth   the current depth for the children
-    * @param tile    the tile of MinMax player
-    * @param oppTile the tile of the best opponent
-    */
-   private void createMySubtree (Node parent, int depth, int tile, int oppTile) {
-      int [] moveData;
-      int [] nodeMove;
-      for (int roll = 1 ; roll <= 6 ; ++roll) {
-         Board nodeBoard = new Board (parent.getNodeBoard());  // clone board
-         moveData = move (nodeBoard, tile, roll, false);       // simulate move
-         nodeMove = new int[4];                                // create nodeMove
-         nodeMove[0] = moveData[MOVE_TILE_IDX];
-         nodeMove[1] = moveData[MOVE_INITTILE_IDX];
-         nodeMove[2] = moveData[MOVE_POINTS_IDX];
-         nodeMove[3] = moveData[MOVE_ROLL_IDX];
-         // make child Node
-         Node child = new Node (parent, depth, nodeMove, nodeBoard);
-         parent.addChild(child);                               // add child to tree
-         createOppSubtree (child, depth+1, nodeMove[0], oppTile);
-      }
-   }
-
-   /**
-    * One of the 2 recursive functions for creating the minimax tree. This one 
-    * creates children for the opponent player
-    * @param parent  The parent Node
-    * @param depth   the current depth for the children
-    * @param tile    the tile of MinMax player
-    * @param oppTile the tile of the best opponent
-    */
-   private void createOppSubtree (Node parent, int depth, int tile, int oppTile) {
-      int [] moveData;
-      int [] nodeMove;
-      for (int roll =1 ; roll <= 6 ; ++roll) {
-         Board nodeBoard = new Board(parent.getNodeBoard());   // clone board
-         moveData = move (nodeBoard, oppTile, roll, false);    // simulate move
-         nodeMove = new int[4];
-         nodeMove[0] = moveData[MOVE_TILE_IDX];
-         nodeMove[1] = moveData[MOVE_INITTILE_IDX];
-         nodeMove[2] = moveData[MOVE_POINTS_IDX];
-         nodeMove[3] = moveData[MOVE_ROLL_IDX];
-         Node child = new Node (parent, depth, nodeMove, nodeBoard);   // make child Node
-         parent.addChild(child);                               // add child to tree
-         if (depth >= MINIMAX_TREE_DEPTH) {
-            child.setNodeEvaluation(
-                  evaluate(parent.getNodeMove()[0],                           // our tile
-                           parent.getNodeMove()[0] - parent.getNodeMove()[1], // our steps
-                           parent.getNodeMove()[2],                           // our points
-                           nodeMove[0])                                       // opponent tile
-            );
-         }
-         else {
-            createMySubtree (child, depth+1, tile, nodeMove[0]);
-         }
-      }
-   }
-   /**
-    * The main evaluation function
-    * @param tile    The current tile of the player
-    * @param steps   The total steps of the move
-    * @param points  The total points of the move
-    * @param oppTile The tile of the best opponent
-    * @return        The evaluation of the roll
-    */
-   private double evaluate (int tile, int steps, int points, int oppTile) {
-      if (tile > oppTile)
-         return 0.65*steps + 0.35*points;
-      else
-         return 0.8*steps + 0.2*points - (oppTile - tile)*0.5;
-   }
-
-   /**
-    * The Minimax recursive function for the maximizing part
-    * @param s    The current Node
-    * @param a    The alpha for pruning
-    * @param b    The beta for pruning
-    * @return     The selected Node
-    */
-   private Node MaxValue (Node s, double a, double b) {
-      if (s.getChildren() == null)
-         return s;
-      else {
-         Node r = null;
-         double vv, v = Double.NEGATIVE_INFINITY;
-         for (Node c : s.getChildren()) {
-            if (r == null) r = c;
-            vv = MinValue (c, a, b).getNodeEvaluation();
-            //v = max (v, vv);
-            if (vv > v) {
-               v = vv;
-               r = c;
-            }
-            if (vv >= b)
-               return c;   // prune
-            a = max (a, vv);
-         }
-         return r;
-      }
-   }
-   
-   /**
-    * The Minimax recursive function for the minimizing part
-    * @param s    The current Node
-    * @param a    The alpha for pruning
-    * @param b    The beta for pruning
-    * @return     The selected Node
-    */
-   private Node MinValue (Node s, double a, double b) {
-      if (s.getChildren() == null)
-         return s;
-      else {
-         Node r = null;
-         double vv, v = Double.POSITIVE_INFINITY;
-         for (Node c : s.getChildren()) {
-            if (r == null) r = c;
-            vv = MaxValue (c, a, b).getNodeEvaluation();
-            //v = min (v, vv);
-            if (vv < v) {
-               v = vv;
-               r = c;
-            }
-            if (vv <= a)
-               return c;   // prune
-            b = min (b, vv);
-         }
-         return r;
-      }
-   }
-
-   /** @return the minimum of x and y */
-   private static double min (double x, double y) {
-      return (x < y) ? x : y;
-   }
-   /** return the maximum of x and y */
-   private static double max (double x, double y) {
-      return (x > y) ? x : y;
-   }
-   /** @} */
-   
-   /** @name Data members package access only */
-   /** @{ */
-   private ArrayList<Integer[]> path;  /**< Players history as required */
-   /** @} */
-}

src/net/hoo2/auth/dsproject/snake/Node.java

@@ -1,102 +0,0 @@
-package net.hoo2.auth.dsproject.snake;
-
-import java.util.*;
-
-/**
- * @class Node
- * @brief Represent a node in the Minimax tree
- * 
- * @author Christos Choutouridis AEM:8997
- * @email  cchoutou@ece.auth.gr
- */
-class Node {
-
-
-   /** @name Constructors */
-   /** @{ */
-   /** Null initialize constructor */
-   Node () { }
-   /** The main constructor for the Node */
-   Node (Node parent, int nodeDepth, int [] nodeMove, Board nodeBoard) {
-      this.parent    = parent;
-      this.children  = null;
-      this.nodeDepth = nodeDepth;
-      this.nodeMove  = nodeMove;
-      this.nodeBoard = nodeBoard;
-      this.nodeEvaluation = 0;
-   }
-   /** A special constructor for creating a root Node */
-   Node (Board nodeBoard) {
-      this.parent    = null;
-      this.children  = null;
-      this.nodeDepth = 0;
-      this.nodeMove  = new int [4];
-      this.nodeBoard = nodeBoard;
-      this.nodeEvaluation = 0;
-   }
-   /**@} */
-   
-   /** @name Get/Set interface */
-   /** @{ */
-   /** Get parent */
-   Node getParent()           { return parent; }
-   /** get children */
-   ArrayList<Node>
-      getChildren()           { return children; }
-   /** get nodeDepth */
-   int getNodeDepth()         { return nodeDepth; }
-   /** get nodeMove */
-   int[] getNodeMove()        { return nodeMove; }
-   /** get nodeBoard */
-   Board getNodeBoard()       { return nodeBoard; }
-   /** get nodeEvluation */
-   double getNodeEvaluation (){ return nodeEvaluation; }
-
-   /** set parent */
-   void setParent(Node parent) { this.parent = parent; }
-   /** set children */
-   void setChildren(ArrayList<Node> children) {
-      this.children = children;
-   }
-   /** set nodeDepth */
-   void setNodeDepth(int nodeDepth) {
-      this.nodeDepth = nodeDepth;
-   }
-   /** set nodeMove */
-   void setNodeMove(int[] nodeMove) {
-      this.nodeMove = nodeMove;
-   }
-   /** set nodeBoard */
-   void setNodeBoard(Board nodeBoard) {
-      this.nodeBoard = nodeBoard;
-   }
-   /** set nodeEvaluation */
-   void setNodeEvaluation(double nodeEvaluation) {
-      this.nodeEvaluation = nodeEvaluation;
-   }
-   /**@}*/
-
-   /** @name Public API */
-   /** @{ */
-   /**
-    * Add a child to the tree
-    * @param   child   The child to add
-    * @return  the status of the operation
-    */
-   boolean addChild (Node child) {
-      if (children == null)
-         children = new ArrayList<>();
-      return children.add(child);
-   }
-   /**@}*/
-
-   /** @name Data members */
-   /** @{ */
-   private Node            parent;     /**< Back reference to parent Node */
-   private ArrayList<Node> children;   /**< Fwd reference to leaf Nodes */
-   private int             nodeDepth;  /**< The Node's depth */
-   private int[]           nodeMove;   /**< The Node's move data [tile, initTile, points, roll]*/
-   private Board           nodeBoard;  /**< Reference to Board's copy of the current node*/
-   private double          nodeEvaluation; /**< The Node's evaluation result */
-   /**@}*/
-}

src/net/hoo2/auth/dsproject/snake/Player.java

@@ -1,8 +1,5 @@
 package net.hoo2.auth.dsproject.snake;
 
-import java.util.Arrays;
-import java.lang.Math;
-
 /**
  * @class Player
  * @brief Represent a Player in the Game
@@ -14,26 +11,13 @@ import java.lang.Math;
  * @email  cchoutou@ece.auth.gr
  */
 public class Player {
-   /** Helper variables to keep track of the move() return values @see move() */
-   static final int MOVE_DATA_SIZE        = 9;  /**< The move return data array size */
-   static final int MOVE_TILE_IDX         = 0;  /**< The index of tile */
-   static final int MOVE_INITTILE_IDX     = 1;  /**< The index of  init tile */
-   static final int MOVE_STEPS_IDX        = 2;  /**< The index of steps */
-   static final int MOVE_ROLL_IDX         = 3;  /**< The index of roll */
-   static final int MOVE_POINTS_IDX       = 4;  /**< The index of  points */
-   static final int MOVE_SNAKES_IDX       = 5;  /**< The index for number of snakes (Always <= 1) */
-   static final int MOVE_LADDERS_IDX      = 6;  /**< The index for number of ladders (Always <= 1) */
-   static final int MOVE_RED_APPLES_IDX   = 7;  /**< The index for number of red apples (Always <= 1) */
-   static final int MOVE_BLACK_APPLES_IDX = 8;  /**< The index for number of black apples (Always <= 1) */
-
    /** @name Constructors */
    /** @{ */
    /** Default doing nothing constructor */
    Player () {
-      playerId = score = tile = 0;
+      playerId = score = tile = turn = 0;
       name = "";
-      lastMove = new int[MOVE_DATA_SIZE];
+      board = null;
-      dryMove  = new int[MOVE_DATA_SIZE];
    }
    /**
     * @brief   The main constructor
@@ -43,13 +27,13 @@ public class Player {
     * @param name       The name of the player
     * @param board      Reference to the board the player will play on.
     */
-   Player (int playerId, String name) {
+   Player (int playerId, String name, Board board) {
       this.playerId  = playerId;
       this.name      = name;
+      this.board     = board;
       score          = 0;
       tile           = 0;
-      lastMove       = new int[MOVE_DATA_SIZE];
+      turn           = 0;
-      dryMove        = new int[MOVE_DATA_SIZE];
    }
    /** @} */
 
@@ -67,172 +51,87 @@ public class Player {
    void setScore (int score) {
       this.score = score;
    }
-
+   /** Get reference to Board */
+   Board getBoard () { return board; }
+   /** Set Board reference */
+   void setBoard (Board board) {
+      this.board = board;
+   }
    /** Get tile */
    int getTile () { return tile; }
    /** Set tile */
    void setTile (int tile) {
       this.tile = tile;
    }
-   
+   /** Get turn */
-   /** Get lastMove */
+   int getTurn () { return turn; }
-   int[] getLastMove () { return lastMove; }
+   /** Set turn */
-   /** Set lastMove */
+   void setTurn (int turn) {
-   void setLastMove (int[] lastMove) {
+      this.turn = turn;
-      this.lastMove = lastMove;
-   }
-   /** Get dryMove */
-   int[] getDryMove () { return dryMove; }
-   /** Set dryMove */
-   void setDryMove (int[] dryMove) {
-      this.dryMove = dryMove;
    }
    /** @} */
    
    /** @name Exposed API members */
    /** @{ */
    
-   /**
-    * Dice functionality for the players
-    * @return  An integer in the range [1 .. 6]
-    */
-   int dice () {
-      return (int)(1 + Math.random()*5);
-   }
-   
-   /**
-    * Get the next tile after the user's move
-    * @param board   The board in which we play on
-    * @param tile    The initial tile
-    * @return The the move as an array
-    *    [0]:  Tile after move
-    *    [1]:  The roll of the dice
-    * @note
-    *    We add this move() 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
-    */
-   int[] getNextMove (Board board, int tile) {
-      int [] ret = new int[4];            // allocate move memory
-      move (board, tile, dice(), true);   // make the move
-      ret[0] = dryMove[MOVE_TILE_IDX];
-      ret[1] = dryMove[MOVE_INITTILE_IDX];
-      ret[2] = dryMove[MOVE_POINTS_IDX];
-      ret[3] = dryMove[MOVE_ROLL_IDX];
-      return ret;
-   }
-  
    /**
     * @brief   Move functionality
+    * This function prints to stdout various logs about user interaction with elements
     * 
     * @param tile    The initial tile of the player
-    * @param roll    The dice roll to play
+    * @param die     The die to play
-    * @param run     Flag to indicate if we fake the move(dry run) or we do make the move.
     * @return
-    *    int[MOVE_TILE_IDX         (0)]   tile after move
+    *    int[0]   tile after move
-    *    int[MOVE_INITTILE_IDX     (1)]   tile before move
+    *    int[1]   number of snake bites
-    *    int[MOVE_STEPS_IDX        (2)]   number of total steps for the move
+    *    int[2]   number of ladder used
-    *    int[MOVE_ROLL_IDX         (3)]   the roll of the dice
+    *    int[3]   number of apples eaten
-    *    int[MOVE_POINTS_IDX       (4)]   the points of the move
-    *    int[MOVE_SNAKES_IDX       (5)]   number of snake bites
-    *    int[MOVE_LADDERS_IDX      (6)]   number of ladders used
-    *    int[MOVE_RED_APPLES_IDX   (7)]   number of red apples eaten
-    *    int[MOVE_BLACK_APPLES_IDX (8)]   number of black apples eaten
-    * @note
-    *    Probably a mutable class like: <pre>
-    *    class MoveData {
-    *       int tile;
-    *       int initTile;
-    *       ...
-    *    }
-    *    </pre>
-    *    for returning value would be better, less error prone, cleaner, etc...
-    *    We could also had members like: <pre> MoveData previous; </pre> to help us further.
-    *    We kept this representation just because it was a requirement.
     */
-   int [] move (Board board, int tile, int roll, boolean run) {
+   int [] move (int tile, int die) {
+      int [] ret = new int[4];
       int t;
-
+      
-      Arrays.fill(dryMove, 0);
+      tile += die;      // Initial move
-      dryMove[MOVE_INITTILE_IDX]  = tile;
+      //System.out.println(name + " +" + die + "->tile: " + tile); //XXX: Debug only
-      dryMove[MOVE_ROLL_IDX]      = roll;
-
-      tile += roll;      // Initial move
       boolean keepGoing;
       do {
          keepGoing = false;
          // Check apples
-         //if ((t = board.checkApple(tile, run)) != 0) {
+         t = board.checkApple(tile);
-         if ((t = board.checkApple(tile, true)) != 0) {
+         if (t != 0) {
-            dryMove[MOVE_POINTS_IDX] += t;
+            score += t;
-            if (t > 0)
+            ++ret[3];
-               ++dryMove[MOVE_RED_APPLES_IDX];
+            System.out.println(name + " Apple @" + tile + " " + t + " points");
-            else
-               ++dryMove[MOVE_BLACK_APPLES_IDX];
          }
          // Check ladder
-         //if ((t = board.checkLadder(tile, run)) != tile) {
+         t = board.checkLadder(tile);
-         if ((t = board.checkLadder(tile, true)) != tile) {
+         if (t != tile) {
+            System.out.println(name + " Ladder @" + tile + " new position " + t);
             tile = t;
-            ++dryMove[MOVE_LADDERS_IDX];
+            ++ret[2];
             keepGoing = true;
          }
          // Check snakes
-         if ((t = board.checkSnake(tile)) != tile) {
+         t = board.checkSnake(tile);
+         if (t != tile) {
+            System.out.println(name + " Ouch!! Snake @" + tile + " new position " + t);
             tile = t;
-            ++dryMove[MOVE_SNAKES_IDX];
+            ++ret[1];
             keepGoing = true;
          }
       } while (keepGoing);
-
+      ret[0] = this.tile = tile;
-      dryMove[MOVE_TILE_IDX] = tile;
+      return ret;
-      dryMove[MOVE_STEPS_IDX]= tile - dryMove[MOVE_INITTILE_IDX];
-      // Check if we do run the move
-      if (run) {
-         lastMove = dryMove.clone();
-         this.tile = lastMove[MOVE_TILE_IDX];
-         score    += lastMove[MOVE_POINTS_IDX];
-      }
-      return dryMove;
-   }
-   
-   /**
-    * The base statistics version
-    * @param verbose    Flag to select the verbosity
-    * @param sum        Flag to select if we need to print a summarize (not used here)
-    * @note
-    *    We added this function because:
-    *    1) we need to keep the "Is a" relationship (Liskov substitution principle)
-    *    2) It help us get rid of the move() console output code
-    *    3) makes the code smaller
-    */
-   void statistics (boolean verbose, boolean sum) {
-      int begin = lastMove[MOVE_INITTILE_IDX];
-      int roll  = lastMove[MOVE_ROLL_IDX];
-      int last  = lastMove[MOVE_TILE_IDX];
-      if (verbose)
-         System.out.println(name + " +" + roll + "->tile: " + (begin + roll));
-      if (lastMove[MOVE_RED_APPLES_IDX] > 0)
-         System.out.println(name + " Apple " + lastMove[MOVE_POINTS_IDX] + " points");
-      if (lastMove[MOVE_BLACK_APPLES_IDX] > 0)
-         System.out.println(name + " Apple " + lastMove[MOVE_POINTS_IDX] + " points");
-      if (lastMove[MOVE_LADDERS_IDX] > 0)
-         System.out.println(name + " Ladder @" + (begin + roll) + " new position " + last);
-      if (lastMove[MOVE_SNAKES_IDX] > 0)
-         System.out.println(name + " Ouch!! Snake @" + (begin + roll) + " new position " + last);
-      // No use of sum here
    }
    /**@} */
-
+   
-   /** @name Data members package access only */
+   
+   /** @name Data members (private) */
    /** @{ */
-   int    playerId;   /**< Player's ID */
+   private int    playerId;   /**< Player's ID */
-   String name;       /**< Player's name */
+   private String name;       /**< Player's name */
-   int    score;      /**< Player's score */
+   private int    score;      /**< Player's score */
-   int    tile;       /**< Player's tile location */
+   private Board  board;      /**< Reference to current board */
-   int[]  lastMove;   /**< move() return data for statistics. These are only valid after a true move */
+   private int    tile;       /**< Player's tile location */
-   private int [] dryMove;    /**< Fake (dry run) move return buffer */
+   private int    turn;       /**< Player's turn of playing */
    /** @} */
 }
-