How to use

Player

in

mage.players

protected UUID findWinnersAndLosers() {
  UUID winnerIdFound = null;
  for (Player player : state.getPlayers().values()) {
    if (player.hasWon()) {
      logger.debug(player.getName() + " has won gameId: " + getId());
      winnerIdFound = player.getId();
      break;
    }
    if (!player.hasLost() && !player.hasLeft()) {
      logger.debug(player.getName() + " has not lost so he won gameId: " + this.getId());
      player.won(this);
      winnerIdFound = player.getId();
      break;
    }
  }
  for (Player player : state.getPlayers().values()) {
    if (winnerIdFound != null && !player.getId().equals(winnerIdFound) && !player.hasLost()) {
      player.lost(this);
    }
  }
  return winnerIdFound;
}

private void processControlledPlayers(Player player, GameView gameView) {
  if (!player.getPlayersUnderYourControl().isEmpty()) {
    Map<String, SimpleCardsView> handCards = new HashMap<>();
    for (UUID controlledPlayerId : player.getPlayersUnderYourControl()) {
      Player opponent = game.getPlayer(controlledPlayerId);
      handCards.put(opponent.getName(), new SimpleCardsView(opponent.getHand().getCards(game), true));
    }
    gameView.setOpponentHands(handCards);
  }
}

@Override
public boolean apply(ObjectSourcePlayer<Player> input, Game game) {
  Player targetOpponent = input.getObject();
  Player controller = game.getPlayer(input.getPlayerId());
  if (targetOpponent == null
      || controller == null
      || !controller.hasOpponent(targetOpponent.getId(), game)) {
    return false;
  }
  return targetOpponent.getLife() > controller.getLife();
}
 

protected boolean allPassed(Game game) {
  for (Player player : game.getPlayers().values()) {
    if (!player.isPassed()
        && !player.hasLost()
        && !player.hasLeft()) {
      return false;
    }
  }
  return true;
}

@Override
public UUID getChooser() {
  UUID loserId = null;
  Game game = getGame();
  for (MatchPlayer player : this.players) {
    Player p = game.getPlayer(player.getPlayer().getId());
    if (p != null && p.hasLost() && !p.hasQuit()) {
      loserId = p.getId();
    }
  }
  return loserId;
}

@Override
public boolean apply(Game game, Ability source) {
  Player player = game.getPlayer(targetPointer.getFirst(game, source));
  if (player != null) {
    int count = player.getHand().size();
    player.putCardsOnBottomOfLibrary(player.getHand(), game, source, true);
    player.drawCards(count, game);
  }
  return true;
}

public static int evaluate(UUID playerId, Game game, boolean ignoreTapped) {
  Player player = game.getPlayer(playerId);
  Player opponent = game.getPlayer(game.getOpponents(playerId).iterator().next());
  if (game.checkIfGameIsOver()) {
    if (player.hasLost() || opponent.hasWon()) {
      return LOSE_SCORE;
    }
    if (opponent.hasLost() || player.hasWon()) {
      return WIN_SCORE;
    }
  }
  int lifeScore = (player.getLife() - opponent.getLife()) * LIFE_FACTOR;
  int poisonScore = (opponent.getCounters().getCount(CounterType.POISON) - player.getCounters().getCount(CounterType.POISON)) * LIFE_FACTOR * 2;
  int permanentScore = 0;
  for (Permanent permanent : game.getBattlefield().getAllActivePermanents(playerId)) {
    permanentScore += evaluatePermanent(permanent, game, ignoreTapped);
  }
  for (Permanent permanent : game.getBattlefield().getAllActivePermanents(opponent.getId())) {
    permanentScore -= evaluatePermanent(permanent, game, ignoreTapped);
  }
  permanentScore *= PERMANENT_FACTOR;
  int handScore = 0;
  handScore = player.getHand().size() - opponent.getHand().size();
  handScore *= HAND_FACTOR;
  int score = lifeScore + poisonScore + permanentScore + handScore;
  if (logger.isDebugEnabled()) {
    logger.debug("game state for player " + player.getName() + " evaluated to- lifeScore:" + lifeScore + " permanentScore:" + permanentScore + " handScore:" + handScore + " total:" + score);
  }
  return score;
}

Player opponent = game.getPlayer(game.getOpponents(playerId).iterator().next());
if (game.checkIfGameIsOver()) {
  if (player.hasLost() 
      || opponent.hasWon()) {
    return LOSE_GAME_SCORE;
  if (opponent.hasLost() 
      || player.hasWon()) {
    return WIN_GAME_SCORE;
if (player.getLife() <= 0) { // we don't want a tie
  lifeScore = ArtificialScoringSystem.LOSE_GAME_SCORE;
} else if (opponent.getLife() <= 0) {
  lifeScore = ArtificialScoringSystem.WIN_GAME_SCORE;
} else {
  lifeScore = ArtificialScoringSystem.getLifeScore(player.getLife()) - ArtificialScoringSystem.getLifeScore(opponent.getLife());
  for (Permanent permanent : game.getBattlefield().getAllActivePermanents(opponent.getId())) {
    int onePermScore = evaluatePermanent(permanent, game);
    opponentScore += onePermScore;
handScore = player.getHand().size() - opponent.getHand().size();
handScore *= 5;

playerList = state.getPlayerList(nextPlayerId);
Player playerByOrder = getPlayer(playerList.get());
state.setPlayerByOrderId(playerByOrder.getId());
while (!isPaused() && !checkIfGameIsOver()) {
  if (!playExtraTurns()) {
    break;
  GameEvent event = new GameEvent(GameEvent.EventType.PLAY_TURN, null, null, playerByOrder.getId());
  if (!replaceEvent(event)) {
    if (!playTurn(playerByOrder)) {
  state.setPlayerByOrderId(playerByOrder.getId());
    sb.append(" - ");
  sb.append('[').append(player.getName()).append(" => ");
  sb.append(player.hasWon() ? "W" : "");
  sb.append(player.hasLost() ? "L" : "");
  sb.append(player.hasQuit() ? "Q" : "");
  sb.append(player.hasIdleTimeout() ? "I" : "");
  sb.append(player.hasTimerTimeout() ? "T" : "");
  sb.append(']');
  count++;

public Player getNext(Game game) {
  UUID start = this.get();
  if (start == null) {
    return null;
  }
  Player player;
  while (true) {
    player = game.getPlayer(super.getNext());
    if (!player.hasLeft() && !player.hasLost()) {
      break;
    }
    if (!player.hasReachedNextTurnAfterLeaving()) {
      player.setReachedNextTurnAfterLeaving(true);
    }
    if (player.getId().equals(start)) {
      return null;
    }
  }
  return player;
}

public Player getPrevious(Game game) {
  Player player;
  UUID start = this.get();
  while (true) {
    player = game.getPlayer(super.getPrevious());
    if (!player.hasLeft() && !player.hasLost()) {
      break;
    }
    if (player.getId().equals(start)) {
      return null;
    }
  }
  return player;
}

/**
 * Returns a list of all active players of the game in range of playerId,
 * also setting the playerId to the first/current player of the list. Also
 * returning the other players in turn order.
 *
 * @param playerId
 * @param game
 * @return playerList
 */
public PlayerList getPlayersInRange(UUID playerId, Game game) {
  PlayerList newPlayerList = new PlayerList();
  Player currentPlayer = game.getPlayer(playerId);
  if (currentPlayer != null) {
    for (Player player : players.values()) {
      if (!player.hasLeft() && !player.hasLost() && currentPlayer.getInRange().contains(player.getId())) {
        newPlayerList.add(player.getId());
      }
    }
    newPlayerList.setCurrent(playerId);
  }
  return newPlayerList;
}

super.onCreate(icicle);
toJoin = Player.unbundle(getArguments());
Log.d(TAG, "Player id in PasswordFragment: " + toJoin.getId());

@Override
public boolean apply(Game game, Ability source) {
  Player player = game.getPlayer(getTargetPointer().getFirst(game, source));
  if (player != null) {
    player.revealCards(player.getName() + "'s hand cards", player.getHand(), game, false);
  }
  return true;
}

/**
 * Copies game and replaces all players in copy with simulated players
 *
 * @param game
 * @return a new game object with simulated players
 */
protected Game createSimulation(Game game) {
  Game sim = game.copy();
  sim.setSimulation(true);
  for (Player copyPlayer : sim.getState().getPlayers().values()) {
    Player origPlayer = game.getState().getPlayers().get(copyPlayer.getId()).copy();
    if (!suggested.isEmpty()) {
      logger.debug(origPlayer.getName() + " suggested: " + suggested);
    }
    SimulatedPlayer2 newPlayer = new SimulatedPlayer2(copyPlayer.getId(), copyPlayer.getId().equals(playerId), suggested);
    newPlayer.restore(origPlayer);
    sim.getState().getPlayers().put(copyPlayer.getId(), newPlayer);
  }
  return sim;
}

@Override
public boolean apply(Game game, Ability source) {
  Player controller = game.getPlayer(source.getControllerId());
  Player targetPlayer = game.getPlayer(source.getFirstTarget());
  if (controller != null && targetPlayer != null) {
    controller.moveCards(targetPlayer.getLibrary().getTopCards(game, targetPlayer.getLibrary().size()), Zone.EXILED, source, game);
    targetPlayer.moveCards(targetPlayer.getHand(), Zone.LIBRARY, source, game);
    targetPlayer.shuffleLibrary(source, game);
    return true;
  }
  return false;
}

  @Override
  public boolean apply(Game game, Ability source) {
    Player player = game.getPlayer(game.getActivePlayerId());
    return player != null && player.getHand().size() <= 2;
  }
}

@Override
public synchronized void concede(UUID playerId) {
  Player player = state.getPlayer(playerId);
  if (player != null && !player.hasLost()) {
    logger.debug("Player " + player.getName() + " concedes game " + this.getId());
    fireInformEvent(player.getLogName() + " has conceded.");
    player.concede(this);
  }
}

private boolean allJoined() {
  for (Player player : game.getPlayers().values()) {
    if (!player.hasLeft()) {
      Optional<User> user = getUserByPlayerId(player.getId());
      if (user.isPresent()) {
        if (!user.get().isConnected()) {
          return false;
        }
      }
      if (player.isHuman() && !gameSessions.containsKey(player.getId())) {
        return false;
      }
    }
  }
  return true;
}

@Override
public boolean apply(Game game, Ability source) {
  Player you = game.getPlayer(source.getControllerId());
  Player targetPlayer = game.getPlayer(source.getFirstTarget());
  MageObject sourceObject = game.getObject(source.getSourceId());
  if (you != null && targetPlayer != null) {
    you.lookAtCards("Hand of " + targetPlayer.getName() + " (" + (sourceObject != null ? sourceObject.getIdName() : null) + ')', targetPlayer.getHand(), game);
    return true;
  }
  return false;
}