示例#1
0
  /**
   * Run a game in asynchronous mode: the game waits until a move is returned. In order to slow
   * thing down in case the controllers return very quickly, a time limit can be used. If fasted
   * gameplay is required, this delay should be put as 0.
   *
   * @param pacManController The Pac-Man controller
   * @param ghostController The Ghosts controller
   * @param visual Indicates whether or not to use visuals
   * @param delay The delay between time-steps
   */
  public void runGame(
      Controller<MOVE> pacManController,
      Controller<EnumMap<GHOST, MOVE>> ghostController,
      boolean visual,
      int delay) {
    try {
      PrintStream out = new PrintStream("replay.txt");
      Game game = new Game(0);

      GameView gv = null;

      if (visual) gv = new GameView(game).showGame();

      while (!game.gameOver()) {
        game.advanceGame(
            pacManController.getMove(game.copy(), -1),
            ghostController.getMove(game.copy(), System.currentTimeMillis() + Long.MAX_VALUE));

        try {
          Thread.sleep(delay);
        } catch (Exception e) {
        }

        if (visual) gv.repaint();
        out.println(game.getGameState());
        out.flush();
      }
      out.close();
    } catch (FileNotFoundException e) {
      // TODO Auto-generated catch block
      e.printStackTrace();
    }
  }
  /**
   * Method which simulates the game from a given node/state
   *
   * @param n
   * @return
   */
  private int defaultPolicy(Node n) {
    Game currentState = n.getState().copy();
    int d = 0;

    while (!isStateTerminal(currentState) && d != depth) {
      MOVE localCurrentDirection = null;
      if (d == 0
          || currentState.isJunction(
              currentState.getPacmanCurrentNodeIndex())) { // is in a junction
        MOVE[] moves = currentState.getPossibleMoves(currentState.getPacmanCurrentNodeIndex());
        int i = rng.nextInt(moves.length);
        localCurrentDirection = moves[i];
        while (moves[i] == localCurrentDirection.opposite()) {
          i = rng.nextInt(moves.length);
        }
        localCurrentDirection = moves[i];
      }

      currentState.advanceGame(
          localCurrentDirection,
          controller.Controller.getGhostController().getMove(currentState, 0));
      d++;
    }

    if (isStateTerminal(currentState)) {
      return -1;
    }
    return currentState.getScore();
  }
示例#3
0
  /**
   * Run the game with time limit (asynchronous mode). This is how it will be done in the
   * competition. Can be played with and without visual display of game states.
   *
   * @param pacManController The Pac-Man controller
   * @param ghostController The Ghosts controller
   * @param visual Indicates whether or not to use visuals
   */
  public void runGameTimed(
      Controller<MOVE> pacManController,
      Controller<EnumMap<GHOST, MOVE>> ghostController,
      boolean visual) {
    Game game = new Game(0);

    GameView gv = null;

    if (visual) gv = new GameView(game).showGame();

    if (pacManController instanceof HumanController)
      gv.getFrame().addKeyListener(((HumanController) pacManController).getKeyboardInput());

    new Thread(pacManController).start();
    new Thread(ghostController).start();

    while (!game.gameOver()) {
      pacManController.update(game.copy(), System.currentTimeMillis() + DELAY);
      ghostController.update(game.copy(), System.currentTimeMillis() + DELAY);

      try {
        Thread.sleep(DELAY);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }

      game.advanceGame(pacManController.getMove(), ghostController.getMove());

      if (visual) gv.repaint();
    }

    pacManController.terminate();
    ghostController.terminate();
  }
示例#4
0
  private int Asearch(Game game) {
    Comparator<PacManNode> comparator = new PacComparator();
    PriorityQueue<PacManNode> open = new PriorityQueue<PacManNode>(1, comparator);
    // because we are conducting tree-search, so 'closed' may not be used, but I'll still leave it
    // here
    HashSet<PacManNode> closed = new HashSet<PacManNode>();

    open.add(new PacManNode(game.copy(), 0));
    int score = game.getScore();
    while (!open.isEmpty()) {
      PacManNode node = open.poll();
      closed.add(node);
      if (node.depth == DEPTH) {
        // System.out.
        score = node.currentState.getScore();
        return score;
      }
      MOVE[] moves = MOVE.values();
      for (MOVE move : moves) {
        Game gameCopy = node.currentState.copy();
        gameCopy.advanceGame(move, ghosts.getMove(gameCopy, 0));
        open.add(new PacManNode(gameCopy, node.depth + 1));
      }
    }
    return score;
  }
示例#5
0
  public MOVE getMove(EnumMap<GHOST, MOVE> ghostMoves, Tree tree) {
    long start = System.currentTimeMillis();
    LinkedList<Node> nodes = new LinkedList<Node>();
    nodes.add(tree.getHeadNode());

    int leftValue = Integer.MIN_VALUE;
    int rightValue = Integer.MIN_VALUE;
    int upValue = Integer.MIN_VALUE;
    int downValue = Integer.MIN_VALUE;

    while (!nodes.isEmpty()) {
      Node node = nodes.removeFirst();
      node.setVisited(true);
      if (node.getPredecessor() != null) { // regular Node
        // set gameState and advance move based on current node
        Game gameState = node.getPredecessor().getGameState().copy();
        gameState.advanceGame(node.getMove(), ghostMoves);
        node.setGameState(gameState);
      }
      if (node.getNeighbors() == null) { // end of tree branch
        int value = Evaluation.evaluateGameState(node.getGameState());
        // get head node move type
        Node nodeType = node.getPredecessor();
        while (nodeType.getPredecessor().getMove() != MOVE.NEUTRAL) {
          nodeType = nodeType.getPredecessor();
        }
        switch (nodeType.getMove()) {
          case LEFT:
            if (value > leftValue) leftValue = value;
            break;
          case RIGHT:
            if (value > rightValue) rightValue = value;
            break;
          case UP:
            if (value > upValue) upValue = value;
            break;
          case DOWN:
            if (value > downValue) downValue = value;
            break;
          case NEUTRAL:
            break;
        }
      } else { // regular node
        // add neighbors to be searched
        ArrayList<Node> neighbors = node.getNeighbors();
        for (Node neighbor : neighbors) {
          if (!neighbor.isVisited()) nodes.add(neighbor);
        }
      }
    }

    if (Evaluation.LOG_TIME) System.out.println(System.currentTimeMillis() - start);
    return Evaluation.getBestMove(leftValue, rightValue, upValue, downValue);
  }
示例#6
0
  /**
   * Run the game in asynchronous mode but proceed as soon as both controllers replied. The time
   * limit still applies so so the game will proceed after 40ms regardless of whether the
   * controllers managed to calculate a turn.
   *
   * @param pacManController The Pac-Man controller
   * @param ghostController The Ghosts controller
   * @param fixedTime Whether or not to wait until 40ms are up even if both controllers already
   *     responded
   * @param visual Indicates whether or not to use visuals
   */
  public void runGameTimedSpeedOptimised(
      Controller<MOVE> pacManController,
      Controller<EnumMap<GHOST, MOVE>> ghostController,
      boolean fixedTime,
      boolean visual) {
    Game game = new Game(0);

    GameView gv = null;

    if (visual) gv = new GameView(game).showGame();

    if (pacManController instanceof HumanController)
      gv.getFrame().addKeyListener(((HumanController) pacManController).getKeyboardInput());

    new Thread(pacManController).start();
    new Thread(ghostController).start();

    while (!game.gameOver()) {
      pacManController.update(game.copy(), System.currentTimeMillis() + DELAY);
      ghostController.update(game.copy(), System.currentTimeMillis() + DELAY);

      try {
        int waited = DELAY / INTERVAL_WAIT;

        for (int j = 0; j < DELAY / INTERVAL_WAIT; j++) {
          Thread.sleep(INTERVAL_WAIT);

          if (pacManController.hasComputed() && ghostController.hasComputed()) {
            waited = j;
            break;
          }
        }

        if (fixedTime) Thread.sleep(((DELAY / INTERVAL_WAIT) - waited) * INTERVAL_WAIT);

        game.advanceGame(pacManController.getMove(), ghostController.getMove());
      } catch (InterruptedException e) {
        e.printStackTrace();
      }

      if (visual) gv.repaint();
    }

    pacManController.terminate();
    ghostController.terminate();
  }
示例#7
0
 @Override
 public MOVE getMove(Game game, long timeDue) {
   int score = -1;
   MOVE ret = MOVE.NEUTRAL;
   MOVE[] moves = MOVE.values();
   for (MOVE move : moves) {
     Game gameCopy = game.copy();
     gameCopy.advanceGame(move, ghosts.getMove(gameCopy, timeDue));
     int cur = Asearch(gameCopy);
     System.out.println(move.toString() + "\t score: " + cur);
     if (cur >= score) {
       score = cur;
       ret = move;
     }
   }
   System.out.println("Move to: " + ret.toString());
   System.out.println("\t--------");
   return ret;
 }
  @Override
  public Constants.MOVE getMove(Game game, long timeDue) {

    // Random random = new Random();
    Constants.MOVE[] allMoves = Constants.MOVE.values();

    int highSorce = -1;
    Constants.MOVE highMove = null; // Start State

    // int[] a = new int[5];
    HashMap<MOVE, Integer> map = new HashMap<>();
    HashMap<Integer, MOVE> map2 = new HashMap<>();

    for (Constants.MOVE m : allMoves) {
      Game gameCopy = game.copy();
      Game gameATM = gameCopy;
      gameATM.advanceGame(m, ghosts.getMove(gameATM, timeDue)); // Neighbors
      int tempHightSocre = this.hill_climbing_value(gameATM);

      map.put(m, tempHightSocre);
      map2.put(tempHightSocre, m);

      System.out.println("PacMan Trying Move:" + m + ", Socre:" + tempHightSocre);
    }

    int min = Integer.MAX_VALUE;
    int max = Integer.MIN_VALUE;
    // Pick one with the highest score, if higher than cuurent state, move to the child state
    for (Map.Entry<MOVE, Integer> it : map.entrySet()) {
      min = Math.min(min, it.getValue());
      max = Math.max(max, it.getValue());
    }
    if (min == max) {
      highMove = MOVE.LEFT;
    } else {
      highMove = map2.get(max);
    }
    System.out.println("High Score:" + highSorce + ", High Move:" + highMove);
    return highMove;
  }
示例#9
0
  /**
   * Run a game in asynchronous mode: the game waits until a move is returned. In order to slow
   * thing down in case the controllers return very quickly, a time limit can be used. If fasted
   * gameplay is required, this delay should be put as 0.
   *
   * @param pacManController The Pac-Man controller
   * @param ghostController The Ghosts controller
   * @param visual Indicates whether or not to use visuals
   * @param delay The delay between time-steps
   */
  public void runGame(
      Controller<MOVE> pacManController,
      Controller<EnumMap<GHOST, MOVE>> ghostController,
      boolean visual,
      int delay) {
    Game game = new Game(0);

    GameView gv = null;

    if (visual) gv = new GameView(game).showGame();

    while (!game.gameOver()) {
      game.advanceGame(
          pacManController.getMove(game.copy(), -1), ghostController.getMove(game.copy(), -1));

      try {
        Thread.sleep(delay);
      } catch (Exception e) {
      }

      if (visual) gv.repaint();
    }
  }
示例#10
0
  /**
   * For running multiple games without visuals. This is useful to get a good idea of how well a
   * controller plays against a chosen opponent: the random nature of the game means that
   * performance can vary from game to game. Running many games and looking at the average score
   * (and standard deviation/error) helps to get a better idea of how well the controller is likely
   * to do in the competition.
   *
   * @param pacManController The Pac-Man controller
   * @param ghostController The Ghosts controller
   * @param trials The number of trials to be executed
   */
  public void runExperiment(
      Controller<MOVE> pacManController,
      Controller<EnumMap<GHOST, MOVE>> ghostController,
      int trials) {
    double avgScore = 0;

    Random rnd = new Random(0);
    Game game;

    for (int i = 0; i < trials; i++) {
      game = new Game(rnd.nextLong());

      while (!game.gameOver()) {
        long due = System.currentTimeMillis() + DELAY;
        game.advanceGame(
            pacManController.getMove(game.copy(), due), ghostController.getMove(game.copy(), due));
      }

      avgScore += game.getScore();
      System.out.println(i + "\t" + game.getScore());
    }

    System.out.println(avgScore / trials);
  }
示例#11
0
  // Funcion que ejecuta varias veces el juego con los controladores que se le pasan por parametro y
  // devuelve la media de la puntiacion de todas las partidas
  public double runGenetico(
      Controller<MOVE> pacManController,
      Controller<EnumMap<GHOST, MOVE>> ghostController,
      int trials) {
    double avgScore = 0;

    Random rnd = new Random(0);
    Game game;

    for (int i = 0; i < trials; i++) {
      game = new Game(rnd.nextLong());

      while (!game.gameOver()) {
        game.advanceGame(
            pacManController.getMove(game.copy(), System.currentTimeMillis() + DELAY),
            ghostController.getMove(game.copy(), System.currentTimeMillis() + DELAY));
      }

      avgScore += game.getScore();
    }

    // System.out.println(avgScore/trials);
    return (avgScore / trials);
  }
示例#12
0
  public void runQLearner(
      Controller<MOVE> pacManController,
      Controller<EnumMap<GHOST, MOVE>> ghostController,
      int iteraciones) {
    System.out.println("Entrenamos nuestro controlador con " + iteraciones + " iteraciones.");
    long start_time = System.nanoTime();

    QLearner learner = new QLearner();
    learner.initialize();
    Game game;

    Estado estado;
    Accion accion;
    Estado lastEstado;
    Accion lastAccion;
    Estado ePrima;
    MOVE siguienteMovimiento;
    float recompensa;

    for (int i = 0; i < iteraciones; i++) {
      System.out.println("Ejecucion del juego: " + i);
      game = new Game(0);

      lastEstado = null;
      lastAccion = null;

      while (!game.gameOver()) {
        recompensa = 0;
        estado = learner.getState(game);
        accion = learner.getAccion(estado);
        siguienteMovimiento = accion.getMovimientoFromAccion(game);
        recompensa = estado.getRecompensa();

        if (lastEstado != null) {
          learner.update(lastEstado, lastAccion, recompensa, estado);
        }

        lastEstado = estado;
        lastAccion = accion;

        // Le pasamos el siguiente movimiento al controlador
        ((QController) ghostController).setSiguienteMovimiento(siguienteMovimiento);

        game.advanceGame(
            pacManController.getMove(game.copy(), System.currentTimeMillis() + DELAY),
            ghostController.getMove(game.copy(), System.currentTimeMillis() + DELAY));
      }

      estado = learner.getState(game);
      recompensa = estado.getRecompensa();
      learner.update(lastEstado, lastAccion, recompensa, estado);
    }

    long end_time = System.nanoTime();
    double tiempo = (((end_time - start_time) / 1e6) / 1000);
    System.out.println(learner);

    System.out.printf("Tiempo de entrenamiento: %.2f segundos%n", tiempo);

    System.out.printf(
        "Ejecucion del juego en modo grafico con la QTable generada en el entrenamiento.");

    game = new Game(0);
    GameView gv = new GameView(game).showGame();

    while (!game.gameOver()) {

      pacManController.update(game.copy(), System.currentTimeMillis() + DELAY);
      ghostController.update(game.copy(), System.currentTimeMillis() + DELAY);

      // Obtenemos la mejor accion segun el estado actual (miramos en la QTabla la accion con mas
      // puntuacion para ese estado)
      Accion mejorAccionFromTQtable = learner.getMejorAccion(learner.getState(game));
      siguienteMovimiento = mejorAccionFromTQtable.getMovimientoFromAccion(game);

      // Le pasamos el siguiente movimiento al controlador
      ((QController) ghostController).setSiguienteMovimiento(siguienteMovimiento);

      game.advanceGame(
          pacManController.getMove(game.copy(), System.currentTimeMillis() + DELAY),
          ghostController.getMove(game.copy(), System.currentTimeMillis() + DELAY));

      try {
        Thread.sleep(DELAY);
      } catch (InterruptedException e) {
        e.printStackTrace();
      }

      gv.repaint();
    }
  }
示例#13
0
  public Constants.MOVE kNN(Game game, int k, long timeDue) {
    Constants.MOVE bestMove = myMove;

    int current = game.getPacmanCurrentNodeIndex();

    double averageDistance = averageGhostDistance(game);

    int positionBottom = kNNSearch(0, historicalData.size(), averageDistance);
    int positionTop = positionBottom + 1;
    k--;
    int totalCount = k / 2;
    while (totalCount > 0 && k > 0) {
      if (positionBottom > 0) {
        if (historicalData.get(positionBottom).moveAway) {
          totalCount--;
        }
        positionBottom--;
        k--;
        if (k <= 0) break;
      }

      if (positionTop < historicalData.size()) {
        if (historicalData.get(positionTop).moveAway) {
          totalCount--;
        }
        positionTop++;
        k--;
      }
    }

    Constants.MOVE[] next = game.getPossibleMoves(current);
    if (totalCount > 0) {
      double closestAway = Double.POSITIVE_INFINITY;
      for (int index : game.getActivePillsIndices()) {
        double distanceAway = game.getShortestPathDistance(game.getPacmanCurrentNodeIndex(), index);
        if (distanceAway < closestAway) closestAway = distanceAway;
      }

      for (Constants.MOVE eachMove : next) {
        Game newState = game.copy();
        newState.advanceGame(eachMove, new AggressiveGhosts().getMove());
        // if near to pill good;
        double nextClosestAway = Double.POSITIVE_INFINITY;
        for (int index : newState.getActivePillsIndices()) {
          double distanceAway =
              newState.getShortestPathDistance(newState.getPacmanCurrentNodeIndex(), index);
          if (distanceAway < closestAway) nextClosestAway = distanceAway;
        }
        if (nextClosestAway <= closestAway) bestMove = eachMove;
      }
    } else {
      for (Constants.MOVE eachMove : next) {
        Game newState = game.copy();
        newState.advanceGame(eachMove, new AggressiveGhosts().getMove());
        if (averageGhostDistance(newState) < averageDistance) {
          bestMove = eachMove;
        }
      }
    }

    lastMove = bestMove;
    return bestMove;
  }