How to use

isHuman

method

in

mage.players.Player

public void eliminateComputer() {
  if (!player1.getPlayer().isHuman()) {
    player1.setEliminated();
    return;
  }
  if (!player2.getPlayer().isHuman()) {
    player2.setEliminated();
  }
}

private boolean allJoined() {
  if (!tournament.allJoined()) {
    return false;
  }
  for (TournamentPlayer player : tournament.getPlayers()) {
    if (player.getPlayer().isHuman() && tournamentSessions.get(player.getPlayer().getId()) == null) {
      return false;
    }
  }
  return true;
}

private boolean allJoined() {
  if (!draft.allJoined()) {
    return false;
  }
  for (DraftPlayer player: draft.getPlayers()) {
    if (player.getPlayer().isHuman() && !draftSessions.containsKey(player.getPlayer().getId())) {
      return false;
    }
  }
  return true;
}

public UserData getControllingPlayersUserData(Game game) {
  if (!isGameUnderControl()) {
    Player player = game.getPlayer(getTurnControlledBy());
    if (player.isHuman()) {
      return player.getUserData();
    }
  }
  return this.userData;
}

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

private int requestPermissionToRollback(UUID userIdRequester, int numberTurns) {
  int requests = 0;
  for (Player player : game.getState().getPlayers().values()) {
    Optional<User> requestedUser = getUserByPlayerId(player.getId());
    if (player.isInGame() && player.isHuman()
        && requestedUser.isPresent()
        && !requestedUser.get().getId().equals(userIdRequester)) {
      requests++;
      GameSessionPlayer gameSession = gameSessions.get(player.getId());
      if (gameSession != null) {
        gameSession.requestPermissionToRollbackTurn(userIdRequester, numberTurns);
      }
    }
  }
  return requests;
}

public void addPlayer(UUID userId, Player player, PlayerType playerType, Deck deck) throws GameException {
  if (table.getState() != TableState.WAITING) {
    return;
  }
  Seat seat = table.getNextAvailableSeat(playerType);
  if (seat == null) {
    throw new GameException("No available seats.");
  }
  match.addPlayer(player, deck);
  table.joinTable(player, seat);
  if (player.isHuman()) {
    userPlayerMap.put(userId, player.getId());
  }
}

private void viewLimitedDeck(UUID userIdRequester, UUID origId) {
  Player viewLimitedDeckPlayer = game.getPlayer(userIdRequester);
  if (viewLimitedDeckPlayer != null) {
    if (viewLimitedDeckPlayer.isHuman()) {
      for (MatchPlayer p : TableManager.instance.getTable(tableId).getMatch().getPlayers()) {
        if (p.getPlayer().getId().equals(userIdRequester)) {
          Optional<User> u = UserManager.instance.getUser(origId);
          if (u.isPresent() && p.getDeck() != null) {
            u.get().ccViewLimitedDeck(p.getDeck(), tableId, requestsOpen, true);
          }
        }
      }
    }
  }
}

  @Override
  public boolean applies(GameEvent event, Ability source, Game game) {
    Player blockController = game.getPlayer(game.getCombat().getAttackingPlayerId());
    if (blockController != null) {
      // temporary workaround for AI bugging out while choosing blockers
      if (blockController.isHuman()) {
        game.getCombat().selectBlockers(blockController, game);
        return event.getPlayerId().equals(game.getCombat().getAttackingPlayerId());
      }
    }
    return false;
  }
}

if (grantingPlayer != null) {
  if (!grantingPlayer.getUsersAllowedToSeeHandCards().contains(userIdRequester)) {
    if (grantingPlayer.isHuman()) {
      GameSessionPlayer gameSession = gameSessions.get(userIdGranter);
      if (gameSession != null) {

@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();
  }
}

private void checkPlayersState() {
  for (TournamentPlayer tournamentPlayer : tournament.getPlayers()) {
    if (!tournamentPlayer.isEliminated() && tournamentPlayer.getPlayer().isHuman()) {
      if (tournamentSessions.containsKey(tournamentPlayer.getPlayer().getId())) {
        if (tournamentSessions.get(tournamentPlayer.getPlayer().getId()).isKilled()) {
          tournamentPlayer.setEliminated();
          tournamentPlayer.setStateInfo("disconnected");
        }
      } else {
        tournamentPlayer.setEliminated();
        tournamentPlayer.setStateInfo("no tournament session");
      }
    }
  }
}

private boolean checkToReplaceDraftPlayerByAi(UUID userId, TournamentPlayer leavingPlayer) {
  int humans = 0;
  for (TournamentPlayer tPlayer : tournament.getPlayers()) {
    if (tPlayer.getPlayer().isHuman()) {
      humans++;
    }
  }
  // replace player that quits with draft bot
  if (humans > 1) {
    Optional<User> user = UserManager.instance.getUser(userId);
    TableManager.instance.getController(tableId).ifPresent(tableController -> {
      String replacePlayerName = "Draftbot";
      if (user.isPresent()) {
        replacePlayerName = "Draftbot (" + user.get().getName() + ')';
      }
      tableController.replaceDraftPlayer(leavingPlayer.getPlayer(), replacePlayerName, PlayerType.COMPUTER_DRAFT_BOT, 5);
      if (user.isPresent()) {
        user.get().removeDraft(leavingPlayer.getPlayer().getId());
        user.get().removeTable(leavingPlayer.getPlayer().getId());
        user.get().removeTournament(leavingPlayer.getPlayer().getId());
      }
      ChatManager.instance.broadcast(chatId, "", leavingPlayer.getPlayer().getLogName() + " was replaced by draftbot", MessageColor.BLACK, true, MessageType.STATUS, null);
    });
    return true;
  }
  return false;
}

@Override
public synchronized void rollbackTurns(int turnsToRollback) {
  if (gameOptions.rollbackTurnsAllowed) {
    int turnToGoTo = getTurnNum() - turnsToRollback;
    if (turnToGoTo < 1 || !gameStatesRollBack.containsKey(turnToGoTo)) {
      informPlayers(GameLog.getPlayerRequestColoredText("Player request: It's not possible to rollback " + turnsToRollback + " turn(s)"));
    } else {
      GameState restore = gameStatesRollBack.get(turnToGoTo);
      if (restore != null) {
        informPlayers(GameLog.getPlayerRequestColoredText("Player request: Rolling back to start of turn " + restore.getTurnNum()));
        state.restoreForRollBack(restore);
        playerList.setCurrent(state.getPlayerByOrderId());
        // Reset temporary created bookmarks because no longer valid after rollback
        savedStates.clear();
        gameStates.clear();
        // because restore uses the objects without copy each copy the state again
        gameStatesRollBack.put(getTurnNum(), state.copy());
        executingRollback = true;
        for (Player playerObject : getPlayers().values()) {
          if (playerObject.isHuman() && playerObject.isInGame()) {
            playerObject.resetStoredBookmark(this);
            playerObject.abort();
            playerObject.resetPlayerPassedActions();
          }
        }
        fireUpdatePlayersEvent();
      }
    }
  }
}

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

if (!player.getPlayer().isHuman()) {
  player.setJoined();
  logger.debug("player " + player.getPlayer().getId() + " has joined draft " + draft.getId());

private MatchPlayerProto matchToProto(Match match, TournamentPlayer player) {
  MatchPlayer matchPlayer = match.getPlayer(player.getPlayer().getId());
  MatchQuitStatus quit = !matchPlayer.hasQuit() ? MatchQuitStatus.NO_MATCH_QUIT
      : matchPlayer.getPlayer().hasIdleTimeout() ? MatchQuitStatus.IDLE_TIMEOUT
      : matchPlayer.getPlayer().hasTimerTimeout() ? MatchQuitStatus.TIMER_TIMEOUT
      : MatchQuitStatus.QUIT;
  return MatchPlayerProto.newBuilder()
      .setName(player.getPlayer().getName())
      .setHuman(player.getPlayer().isHuman())
      .setWins(matchPlayer.getWins())
      .setQuit(quit)
      .build();
}

if (currentPlayer.chooseUse(Outcome.GainControl, text, source, game)) {
  int newBid = 0;
  if (!currentPlayer.isHuman()) {//AI will evaluate the creature and bid
    CreatureEvaluator eval = new CreatureEvaluator();
    int computerLife = currentPlayer.getLife();

@Override
public MatchProto toProto() {
  MatchProto.Builder builder = MatchProto.newBuilder()
      .setName(this.getName())
      .setGameType(this.getOptions().getGameType())
      .setDeckType(this.getOptions().getDeckType())
      .setGames(this.getNumGames())
      .setDraws(this.getDraws())
      .setMatchOptions(this.getOptions().toProto())
      .setEndTimeMs((this.getEndTime() != null ? this.getEndTime() : new Date()).getTime());
  for (MatchPlayer matchPlayer : this.getPlayers()) {
    MatchQuitStatus status = !matchPlayer.hasQuit() ? MatchQuitStatus.NO_MATCH_QUIT
        : matchPlayer.getPlayer().hasTimerTimeout() ? MatchQuitStatus.TIMER_TIMEOUT
        : matchPlayer.getPlayer().hasIdleTimeout() ? MatchQuitStatus.IDLE_TIMEOUT
        : MatchQuitStatus.QUIT;
    builder.addPlayersBuilder()
        .setName(matchPlayer.getName())
        .setHuman(matchPlayer.getPlayer().isHuman())
        .setQuit(status)
        .setWins(matchPlayer.getWins());
  }
  return builder.build();
}

if (controller.isHuman()) { // only human player can decide to do the block in another way
  continue;