hoo2
/
PacMan


			
							/**
 * @file Node89978445.java
 * @brief
 *    File containing the Node class witch represents
 *    the moves of Pacman 
 * 
 * @author  Christos Choutouridis   8997 cchoutou@ece.auth.gr
 * @author  Konstantina Tsechelidou 8445 konstsec@ece.auth.gr
 */

package gr.auth.ee.dsproject.node;

//import java.awt.image.PackedColorModel;
import gr.auth.ee.dsproject.pacman.PacmanUtilities;
import gr.auth.ee.dsproject.pacman.Room;


/**
 * @class   Node89978445
 * @brief
 *    This class holds each move of the current round and it's evaluation
 *    
 */
public class Node89978445
{
   double nodeEvaluation;  /**<
                            * Pacman's current move evaluation
                            * This is used also as the "return status" of the object
                            */
   int nodeMove;        // Pacman's current move
   int[] nodeXY;        // Pacman's current x,y coordinate
   int[] newXY;         // Pacman's new x,y coordinate
   int[][] currentGhostPos;      // Array holding the Ghost (x,y) pairs
   
   
   int[][] flagPos;              // Array holding the flag (x,y) pairs
   boolean[] currentFlagStatus;  // Array holding the flag capture status
   Room[][] Maze;                // copy of the current Maze


   /*
    * ============ Constructors ==============
    */
   /**
    * @brief
    *    The simple constructor. Just initialize the data
    * @note
    *    Using this constructor means that the user MUST call setMaze(), setPosition()
    *    and setMove manually after the creation of the Node89978445 object
    */
   public Node89978445 ()
   {
      // Fill members
      nodeXY = newXY = Globals.FALSE_POS;
      nodeMove = Globals.INVALID_MOVE;
      nodeEvaluation = Globals.NO_EVAL;

      // allocate objects
      currentGhostPos = new int [PacmanUtilities.numberOfGhosts][2];
      flagPos = new int [PacmanUtilities.numberOfFlags][2];
      currentFlagStatus = new boolean[PacmanUtilities.numberOfFlags];

   }

   /**
    * @brief
    *    Constructor for the Node89978445
    * @param Maze    The current maze object
    * @param curXY   The current pacman's (x, y) position
    * @param move    The move under inspection
    */
   public Node89978445 (Room[][] Maze, int[] curXY, int move)
   {
      this.Maze = Maze; // Fill members
      nodeXY = newXY = curXY;
      nodeMove = move;
      nodeEvaluation = Globals.NO_EVAL;
      
      //calculate members
      newXY = pacmanValidMove (nodeXY, move);

      // allocate objects
      currentGhostPos = new int [PacmanUtilities.numberOfGhosts][2];
      flagPos = new int [PacmanUtilities.numberOfFlags][2];
      currentFlagStatus = new boolean[PacmanUtilities.numberOfFlags];

   }

   /*
    * ============== Setters ===============
    */
   /**
    * @brief   SetMaze (Room) to Node object
    * @param   maze  The room to set 
    */
   public void setMaze (Room[][] maze) {
      this.Maze = maze;
   }

   /**
    * @brief   Set pacman's position
    * @param curXY   Pacman's current X, Y position
    */
   public void setPosition (int[] curXY) {
      nodeXY = curXY;
      //update members
      newXY = pacmanValidMove (curXY, nodeMove);
   }

   /**
    * @brief   Set the move to Node object
    * @param move    The move under inspection
    */
   public void setMove (int move) {
      nodeMove = move;
      //update members
      newXY = pacmanValidMove (nodeXY, move);
   }

   /*
    * ============== getters =================
    */

   /**
    * @brief   If not done runs the evaluation algorithm and returns the result
    * @return  The evaluation result
    */
   public double getEvaluation ()
   {
       // calculate helper arrays
       currentGhostPos = findGhosts ();
       flagPos = findFlags ();
       currentFlagStatus = checkFlags ();

       // validation and evaluate move
       if (newXY != Globals.FALSE_POS) {
          // If already evaluated do not re-evaluate the move
          if (nodeEvaluation == Globals.NO_EVAL)
             nodeEvaluation = evaluate ();
       }
       else {
          nodeEvaluation = Globals.NO_EVAL;
       }
      return nodeEvaluation;
   }

   /**
    * @return
    *    The current move of the Node89978445
    */
   public int getMove () {
      return nodeMove;
   }

   /*
    * ============= Node's private methods =============
    */
   /**
    * @brief
    *    Loop entire maze and return an object that holds Ghost positions
    * @param   none
    * @return  Object with Ghost position
    *          The first dimension holds the number of the ghost
    *          The 2nd dimension holds the (x, y) coordinates of the ghost
    */
   private int[][] findGhosts ()
   {
      int [][] ret = new int [PacmanUtilities.numberOfGhosts][2]; // Make an object to return
      int g = 0;                    // Ghost index
      boolean  keepGoing = true;    // Boundary check helper variable

      // Loop entire Maze (i, j)
      for (int x=0 ; keepGoing && x<PacmanUtilities.numberOfRows ; ++x) {
         for (int y=0 ; keepGoing && y<PacmanUtilities.numberOfColumns ; ++y) {
            if (Maze[x][y].isGhost ()) {
               // In case of a Ghost save its position to return object
               ret[g][0] = x;
               ret[g][1] = y;
               // boundary check
               if (++g > PacmanUtilities.numberOfGhosts)
                  keepGoing = false;
            }
         }
      }
      return ret;
   }
   
   /**
    * @brief
    *    Loop entire maze and return an object that holds flags positions
    * @param   none
    * @return  Object with flag positions
    *          The first dimension holds the number of the flag
    *          The 2nd dimension holds the (x, y) coordinates of the flag
    */
   private int[][] findFlags ()
   {
      int [][] ret = new int [PacmanUtilities.numberOfFlags][2]; // Make an object to return
      int g = 0;                    // Flag index
      boolean  keepGoing = true;    // Boundary check helper variable

      // Loop entire Maze (i, j)
      for (int x=0 ; keepGoing && x<PacmanUtilities.numberOfRows ; ++x) {
         for (int y=0 ; keepGoing && y<PacmanUtilities.numberOfColumns ; ++y) {
            if (Maze[x][y].isFlag()) {
               // In case of a Ghost save its position to return object
               ret[g][0] = x;
               ret[g][1] = y;
               // boundary check
               if (++g > PacmanUtilities.numberOfFlags)
                  keepGoing = false;
            }
         }
      }
      return ret;
   }

   /**
    * @brief
    *    Loop through flags and check their status
    * @param   none
    * @return  Object with flag status
    */
   private boolean[] checkFlags ()
   {
      boolean[] ret = new boolean [PacmanUtilities.numberOfFlags];
      int x, y;
      
     for (int i=0 ; i<PacmanUtilities.numberOfFlags ; ++i) {
        x = flagPos[i][0]; // Get row,col coordinates
        y = flagPos[i][1];
        ret[i] = (Maze[x][y].isCapturedFlag()) ? true : false;
     }
     return ret;
   }

   /*
    * ============ evaluation helper methods ==============
    */

   
   /**
    * @param creature   creature's (x,y)
    * @return
    *    Return true if the creature is inside the maze boxes
    */
   private boolean isInsideBox (int[] creature)
   {
      boolean ret = false; //have faith
      for (int i=0 ; i<4 ; ++i) {
         if ((creature[0]>=Globals.BOXES[i][0][0] && creature[0]<=Globals.BOXES[i][1][0]) &&
             (creature[1]>=Globals.BOXES[i][0][1] && creature[1]<=Globals.BOXES[i][1][1]))
            ret = true;
      }
      return ret;
   }

   private int[] ghostValidMove (int[] ghost, int move)
   {
      int[] newPos = new int[2];

      // find hypothetical new position
      newPos[0] = ghost[0];
      newPos[1] = ghost[1];
      newPos[0] += (move == Room.SOUTH) ? 1:0;
      newPos[0] -= (move == Room.NORTH) ? 1:0;
      newPos[1] += (move == Room.EAST) ? 1:0;
      newPos[1] -= (move == Room.WEST) ? 1:0;

      // Valid filters
      if (!((newPos[0] >= 0 && newPos[0] < PacmanUtilities.numberOfRows) &&
          (newPos[1] >= 0 && newPos[1] < PacmanUtilities.numberOfColumns)))
         return Globals.FALSE_POS;
      if (!isInsideBox(ghost) && (Maze[ghost[0]][ghost[1]].walls[move] == 0))
         return Globals.FALSE_POS;
      return newPos;
   }

   /**
    * @brief
    *    Check if the requested move is valid
    */
   private int[] pacmanValidMove (int[] pacman, int move)
   {
      int[] newPos = new int[2];

      // find hypothetical new position
      newPos[0] = pacman[0];
      newPos[1] = pacman[1];
      newPos[0] += (move == Room.SOUTH) ? 1:0;
      newPos[0] -= (move == Room.NORTH) ? 1:0;
      newPos[1] += (move == Room.EAST) ? 1:0;
      newPos[1] -= (move == Room.WEST) ? 1:0;

      // Pacman curves Maze plane to a Torus
      if (newPos[0] < 0)   newPos[0] = PacmanUtilities.numberOfRows;
      if (newPos[0] >= PacmanUtilities.numberOfRows ) newPos[0] = 0;
      if (newPos[1] < 0)   newPos[1] = PacmanUtilities.numberOfColumns;
      if (newPos[1] >= PacmanUtilities.numberOfColumns ) newPos[1] = 0;

      // Valid filters
      if (!isInsideBox(pacman) && (Maze[pacman[0]][pacman[1]].walls[move] == 0))
         return Globals.FALSE_POS;
      return newPos;
   }

   /**
    * @brief
    *    A Breadth-first search to find the shortest path distance
    *    from a ghost to a point in the maze
    * @param ghost   Ghost (x, y)
    * @param xy      The x, y coordinate in Maze
    * @return
    */
   private int ghostMoveDist (int[] ghost, int[] xy)
   {
      int move;
      int steps, qStepItems;  // distance and group counters
      boolean done = false;   // algo ending flag
      int r = PacmanUtilities.numberOfRows;     // helper for shorting names
      int c = PacmanUtilities.numberOfColumns;  // helper for shorting names
      int[] xyItem = new int [2];   // Coordinates of the current position of the algo
      int[] xyNext = new int [2];   // Coordinates of the next valid position of the algo
      Queue2D q = new Queue2D (r+c - 1);  // Queue to feed with possible position
      int [][] dist = new int [r][c];
      /*
       * 2D array holding all the distances from the ghost to each square of the maze
       */

      // If target square is inside a box abort with max distance
      if (isInsideBox(xy))
         return Globals.MAX_DISTANCE;

      /*
       *  init data for algorithm
       */
      for (int i=0 ; i<r ; ++i) {
         for (int j=0 ; j<c ; ++j) {
            dist[i][j] = -1;
            // dist array starts with -1
         }
      }
      // loop data
      dist [ghost[0]][ghost[1]] = 0;   //starting point is the ghost position
      q.insert (ghost);                // feed first loop data
      qStepItems = 1;                  // init counters
      steps = 1;
      /*
       *          Main loop of the algorithm
       * 
       * For every position we check the valid moves, we apply to them
       * the step number and we push them to queue. We group the items in
       * queue with their step number by measuring how many we push them for
       * the current steps variable value.
       */
      while (done == false) {
         if (qStepItems>0) {           // Have we any item on the current group?
            xyItem = q.remove ();      //load an item of the current group
            --qStepItems;              // mark the removal of the item
            for (move=0 ; move<4 ; ++move) {
               // loop every valid next position for the current position
               if ((xyNext = ghostValidMove (xyItem, move)) != Globals.FALSE_POS) {
                  if (dist[xyNext[0]][xyNext[1]] == -1) {
                     // If we haven't been there
                     dist[xyNext[0]][xyNext[1]] = steps; // mark the distance
                     if ((xyNext[0] == xy[0]) && (xyNext[1] == xy[1])) {
                        /*
                         *  first match:
                         *  The first time we reach destination we have count the
                         *  distance. No need any other try
                         */
                        done = true;
                        break;
                     }
                     else {
                        // If we are not there yet, feed queue with another position
                        q.insert (xyNext);
                     }
                  }
               }
            }
         }
         else {
            // We are done with group, mark how many are for the next one
            if ((qStepItems = q.size()) <= 0)
               return dist[xy[0]][xy[1]];    // fail safe return
            ++steps;                         // Update distance counter
         }
      }
      return dist[xy[0]][xy[1]];
   }

   /**
    * @brief
    *    A Breadth-first search to find the shortest path distance
    *    from the pacman to a point in the maze. The point will normaly
    *    represent a flag
    * @param pacman  Pacman's (x, y)
    * @param xy      The x, y coordinate in Maze
    * @return
    */
   private int pacmanMoveDist (int[] pacman, int[] xy)
   {
      int move;
      int steps, qStepItems;  // distance and group counters
      boolean done = false;   // algo ending flag
      int r = PacmanUtilities.numberOfRows;     // helper for shorting names
      int c = PacmanUtilities.numberOfColumns;  // helper for shorting names
      int[] xyItem = new int [2];   // Coordinates of the current position of the algo
      int[] xyNext = new int [2];   // Coordinates of the next valid position of the algo
      Queue2D q = new Queue2D (r+c - 1);  // Queue to feed with possible position
      int [][] dist = new int [r][c];
      /*
       * 2D array holding all the distances from pacman to each square of the maze
       */

      // If target square is inside a box abort with max distance
      if (isInsideBox (xy))
         return Globals.MAX_DISTANCE;

      /*
       *  init data for algorithm
       */
      for (int i=0 ; i<r ; ++i) {
         for (int j=0 ; j<c ; ++j) {
            dist[i][j] = -1;
            // dist array starts with -1
         }
      }
      // loop data
      dist [pacman[0]][pacman[1]] = 0; //starting point is the pacman position
      q.insert (pacman);               // feed first loop data
      qStepItems = 1;                  // init counters
      steps = 1;
      /*
       *          Main loop of the algorithm
       * 
       * For every position we check the valid moves, we apply to them
       * the step number and we push them to queue. We group the items in
       * queue with their step number by measuring how many we push them for
       * the current steps variable value.
       */
      while (done == false) {
         if (qStepItems>0) {           // Have we any item on the current group?
            xyItem = q.remove ();      //load an item of the current group
            --qStepItems;              // mark the removal of the item
            for (move=0 ; move<4 ; ++move) {
               // loop every valid next position for the current position
               if ((xyNext = pacmanValidMove (xyItem, move)) != Globals.FALSE_POS) {
                  if (dist[xyNext[0]][xyNext[1]] == -1) {
                     // If we haven't been there
                     dist[xyNext[0]][xyNext[1]] = steps; // mark the distance
                     if ((xyNext[0] == xy[0]) && (xyNext[1] == xy[1])) {
                        /*
                         *  first match:
                         *  The first time we reach destination we have count the
                         *  distance. No need any other try
                         */
                        done = true;
                        break;
                     }
                     else {
                        // If we are not there yet, feed queue with another position
                        q.insert (xyNext);
                     }
                  }
               }
            }
         }
         else {
            // We are done with group, mark how many are for the next one
            if ((qStepItems = q.size()) <= 0)
               return dist[xy[0]][xy[1]];    // fail safe return
            ++steps;                         // Update distance counter
         }
      }
      return dist[xy[0]][xy[1]];
   }

   /**
    * @brief
    *    Evaluate the current move
    */
   private double evaluate ()
   {
      double ghostEval=0, gd=0;
      double flagEval=0;
      int i;
      int[] flagDist = new int[PacmanUtilities.numberOfFlags];
      int[] ghostDist = new int[PacmanUtilities.numberOfGhosts];
      int minGhostDist=Globals.MAX_DISTANCE+1;
      int averGhostDist;      // cast to integer
      int minFlagDist=Globals.MAX_DISTANCE+1;

      // Find ghost distances, min and average
      for (i=0, averGhostDist=0 ; i<PacmanUtilities.numberOfGhosts ; ++i) {
         ghostDist [i] = ghostMoveDist (currentGhostPos[i], newXY);
         averGhostDist += ghostDist [i];
         if (minGhostDist > ghostDist[i])
            minGhostDist = ghostDist[i];
      }
      averGhostDist /= PacmanUtilities.numberOfGhosts;
      // extract the ghostEval as a combination of the minimum distance and the average
      gd = Globals.EVAL_GHOSTDIST_MIN_FACTOR * minGhostDist + Globals.EVAL_GHOSTDIST_MIN_FACTOR * averGhostDist;
      // normalize the ghostEval to our interval
      ghostEval = (-1.0 / (1+gd)) * (Globals.EVAL_MAX - Globals.EVAL_MIN) + (Globals.EVAL_MAX - Globals.EVAL_MIN)/2;

      // Find flag distances and min
      for (i=0 ; i<PacmanUtilities.numberOfFlags ; ++i) {
         if (currentFlagStatus[i] == false) {
            flagDist[i] = pacmanMoveDist (newXY, flagPos[i]);
            if (minFlagDist > flagDist[i])
               minFlagDist = flagDist[i];
         }
      }
      // normalize the flagEval to our interval
      flagEval = (1.0 / (1+minFlagDist)) * (Globals.EVAL_MAX - Globals.EVAL_MIN) - (Globals.EVAL_MAX - Globals.EVAL_MIN)/2;
      
      // mix the life and goal to output
      return ghostEval * Globals.EVAL_GHOSTDIST_FACTOR
             + flagEval * Globals.EVAL_FLAGDIST_FACTOR;

   }

}