How to use

hasLeft

method

in

mage.players.Player

public String getPlayerNameList() {
  StringBuilder sb = new StringBuilder(" [");
  for (UUID playerId : userPlayerMap.values()) {
    Player player = game.getPlayer(playerId);
    if (player != null) {
      sb.append(player.getName()).append("(Left=").append(player.hasLeft() ? "Y" : "N").append(") ");
    } else {
      sb.append("player missing: ").append(playerId).append(' ');
    }
  }
  return sb.append(']').toString();
}

@Override
public Set<UUID> possibleTargets(UUID sourceControllerId, Game game) {
  Set<UUID> possibleTargets = new HashSet<>();
  for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) {
    Player player = game.getPlayer(playerId);
    if (player != null && !player.hasLeft() && filter.match(player, game)) {
      possibleTargets.add(playerId);
    }
  }
  return possibleTargets;
}

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

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;
}

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;
}

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

@Override
public Set<UUID> possibleTargets(UUID sourceId, UUID sourceControllerId, Game game) {
  Set<UUID> possibleTargets = new HashSet<>();
  MageObject targetSource = game.getObject(sourceId);
  for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) {
    Player player = game.getPlayer(playerId);
    if (player != null && !player.hasLeft() && filter.match(player, sourceId, sourceControllerId, game)) {
      if (isNotTarget() || player.canBeTargetedBy(targetSource, sourceControllerId, game)) {
        possibleTargets.add(playerId);
      }
    }
  }
  return possibleTargets;
}

@Override
public boolean changeControllerId(UUID controllerId, Game game) {
  Player newController = game.getPlayer(controllerId);
  GameEvent loseControlEvent = GameEvent.getEvent(GameEvent.EventType.LOSE_CONTROL, this.getId(), null, controllerId);
  if (game.replaceEvent(loseControlEvent)) {
    return false;
  }
  if (newController != null && (!newController.hasLeft() || !newController.hasLost())) {
    this.controllerId = controllerId;
    return true;
  }
  return false;
}

/**
 * Checks if there are enough {@link Player} that can be selected. Should
 * not be used for Ability targets since this does not check for protection,
 * shroud etc.
 *
 * @param sourceControllerId - controller of the select event
 * @param game
 * @return - true if enough valid {@link Player} exist
 */
@Override
public boolean canChoose(UUID sourceControllerId, Game game) {
  int count = 0;
  for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) {
    Player player = game.getPlayer(playerId);
    if (player != null && !player.hasLeft() && filter.match(player, game)) {
      count++;
      if (count >= this.minNumberOfTargets) {
        return true;
      }
    }
  }
  return false;
}

int numLosers = 0;
for (Player player : state.getPlayers().values()) {
  if (!player.hasLeft()) {
    remainingPlayers++;
    logger.debug("DRAW for gameId: " + getId());
    for (Player player : state.getPlayers().values()) {
      logger.debug("-- " + player.getName() + " left: " + (player.hasLeft() ? "Y" : "N") + " lost: " + (player.hasLost() ? "Y" : "N"));
    if (!player.hasLeft() && !player.hasLost()) {
      logger.debug("Player " + player.getName() + " has won gameId: " + this.getId());
      player.won(this);

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;
}

@Override
public void setConcedingPlayer(UUID playerId) {
  Player player = null;
  if (state.getChoosingPlayerId() != null) {
    player = getPlayer(state.getChoosingPlayerId());
  } else if (state.getPriorityPlayerId() != null) {
    player = getPlayer(state.getPriorityPlayerId());
  }
  if (player != null) {
    if (!player.hasLeft() && player.isHuman()) {
      if (!concedingPlayers.contains(playerId)) {
        logger.debug("Game over for player Id: " + playerId + " gameId " + getId());
        concedingPlayers.add(playerId);
        player.signalPlayerConcede();
      }
    } else {
      // no asynchronous action so check directly
      concedingPlayers.add(playerId);
      checkConcede();
    }
  } else {
    checkConcede();
    checkIfGameIsOver();
  }
}

/**
 * Returns a list of all active players of the game, setting the playerId to
 * the current player of the list.
 *
 * @param playerId
 * @return playerList
 */
public PlayerList getPlayerList(UUID playerId) {
  PlayerList newPlayerList = new PlayerList();
  for (Player player : players.values()) {
    if (!player.hasLeft() && !player.hasLost()) {
      newPlayerList.add(player.getId());
    }
  }
  newPlayerList.setCurrent(playerId);
  return newPlayerList;
}

/**
 * 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;
}

private void sendInfoAboutPlayersNotJoinedYet() {
  for (Player player : game.getPlayers().values()) {
    if (!player.hasLeft() && player.isHuman()) {
      Optional<User> requestedUser = getUserByPlayerId(player.getId());
      if (requestedUser.isPresent()) {
        User user = requestedUser.get();
        if (!user.isConnected()) {
          if (gameSessions.get(player.getId()) == null) {
            // join the game because player has not joined are was removed because of disconnect
            user.removeConstructing(player.getId());
            GameManager.instance.joinGame(game.getId(), user.getId());
            logger.debug("Player " + player.getName() + " (disconnected) has joined gameId: " + game.getId());
          }
          ChatManager.instance.broadcast(chatId, player.getName(), user.getPingInfo() + " is pending to join the game", MessageColor.BLUE, true, ChatMessage.MessageType.STATUS, null);
          if (user.getSecondsDisconnected() > 240) {
            // Cancel player join possibility lately after 4 minutes
            logger.debug("Player " + player.getName() + " - canceled game (after 240 seconds) gameId: " + game.getId());
            player.leave();
          }
        }
      } else if (!player.hasLeft()) {
        logger.debug("Player " + player.getName() + " canceled game (no user) gameId: " + game.getId());
        player.leave();
      }
    }
  }
  checkStart();
}

/**
 * Checks if there are enough {@link Player} that can be chosen. Should only
 * be used for Ability targets since this checks for protection, shroud etc.
 *
 * @param sourceId - the target event source
 * @param sourceControllerId - controller of the target event source
 * @param game
 * @return - true if enough valid {@link Player} exist
 */
@Override
public boolean canChoose(UUID sourceId, UUID sourceControllerId, Game game) {
  int count = 0;
  MageObject targetSource = game.getObject(sourceId);
  for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) {
    Player player = game.getPlayer(playerId);
    if (player != null && !player.hasLeft() && filter.match(player, sourceId, sourceControllerId, game)) {
      if (player.canBeTargetedBy(targetSource, sourceControllerId, game)) {
        count++;
        if (count >= this.minNumberOfTargets) {
          return true;
        }
      }
    }
  }
  return false;
}

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;
}

@Override
public void controlPlayersTurn(Game game, UUID playerId) {
  Player player = game.getPlayer(playerId);
  player.setTurnControlledBy(this.getId());
  game.informPlayers(getLogName() + " controls the turn of " + player.getLogName());
  if (!playerId.equals(this.getId())) {
    this.playersUnderYourControl.add(playerId);
    if (!player.hasLeft() && !player.hasLost()) {
      player.setGameUnderYourControl(false);
    }
    DelayedTriggeredAbility ability = new AtTheEndOfTurnStepPostDelayedTriggeredAbility(new LoseControlOnOtherPlayersControllerEffect(this.getLogName(), player.getLogName()));
    ability.setSourceId(getId());
    ability.setControllerId(getId());
    game.addDelayedTriggeredAbility(ability);
  }
}

@Override
public boolean canChoose(UUID sourceId, UUID sourceControllerId, Game game) {
  int count = 0;
  MageObject targetSource = game.getObject(sourceId);
  Player controller = game.getPlayer(sourceControllerId);
  if (controller != null && targetSource != null) {
    for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) {
      Player player = game.getPlayer(playerId);
      if (player != null
          && controller.getLife() < player.getLife()
          && !player.hasLeft()
          && filter.match(player, sourceId, sourceControllerId, game)
          && player.canBeTargetedBy(targetSource, sourceControllerId, game)) {
        count++;
        if (count >= this.minNumberOfTargets) {
          return true;
        }
      }
    }
  }
  return false;
}

@Override
public boolean canChoose(UUID sourceId, UUID sourceControllerId, Game game) {
  int count = 0;
  MageObject targetSource = game.getObject(sourceId);
  Player controller = game.getPlayer(sourceControllerId);
  if (controller != null && targetSource != null) {
    for (UUID playerId : game.getState().getPlayersInRange(sourceControllerId, game)) {
      Player player = game.getPlayer(playerId);
      if (player != null
          && game.getBattlefield().countAll(StaticFilters.FILTER_PERMANENT_CREATURE, sourceControllerId, game)
          < game.getBattlefield().countAll(StaticFilters.FILTER_PERMANENT_CREATURE, playerId, game)
          && !player.hasLeft()
          && filter.match(player, sourceId, sourceControllerId, game)
          && player.canBeTargetedBy(targetSource, sourceControllerId, game)) {
        count++;
        if (count >= this.minNumberOfTargets) {
          return true;
        }
      }
    }
  }
  return false;
}