How to use

Cards

in

mage.cards

protected void logState(Game game) {
  if (log.isTraceEnabled()) {
    logList("Computer player " + name + " hand: ", new ArrayList<MageObject>(hand.getCards(game)));
  }
}

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

@Override
public boolean apply(Game game, Ability source) {
  Player player = game.getPlayer(targetPointer.getFirst(game, source));
  if (player != null && !player.getHand().isEmpty()) {
    Cards revealed = new CardsImpl();
    revealed.add(player.getHand().getRandom(game));
    player.revealCards("Hired Torturer", revealed, game);
    return true;
  }
  return false;
}

@Override
public Card discardOne(boolean random, Ability source, Game game) {
  Cards cards = discard(1, random, source, game);
  if (cards.isEmpty()) {
    return null;
  }
  return cards.getRandom(game);
}

@Override
public boolean chooseMulligan(Game game) {
  log.debug("chooseMulligan");
  if (hand.size() < 6
      || isTestMode()
      || game.getClass().getName().contains("Momir")) {
    return false;
  }
  Set<Card> lands = hand.getCards(new FilterLandCard(), game);
  return lands.size() < 2
      || lands.size() > hand.size() - 2;
}

  private Card pickCard(Game game, Player player, Cards cards, String message) {
    if (cards.isEmpty()) {
      return null;
    }
    if (cards.size() == 1) {
      Card card = cards.getRandom(game);
      cards.remove(card);
      return card;
    }

    TargetCard target = new TargetCard(Zone.LIBRARY, new FilterCard(message));
    if (player.choose(Outcome.Benefit, cards, target, game)) {
      Card card = cards.get(target.getFirstTarget(), game);
      if (card != null) {
        cards.remove(card);
        return card;
      }
    }

    return null;
  }
}

protected void randomizePlayers(Game game, UUID playerId) {
  for (Player player: game.getState().getPlayers().values()) {
    if (!player.getId().equals(playerId)) {
      int handSize = player.getHand().size();
      player.getLibrary().addAll(player.getHand().getCards(game), game);
      player.getHand().clear();
      player.getLibrary().shuffle();
      for (int i = 0; i < handSize; i++) {
        Card card = player.getLibrary().removeFromTop(game);
        card.setZone(Zone.HAND, game);
        player.getHand().add(card);
      }
    }
    else {
      player.getLibrary().shuffle();                
    }
  }
}

@Override
public boolean canChoose(UUID sourceControllerId, Game game) {
  Cards cardsToCheck = new CardsImpl();
  Player player = game.getPlayer(sourceControllerId);
  if (player == null) {
    return false;
  }
  for (Card card : player.getHand().getCards(filter, game)) {
    cardsToCheck.add(card.getId());
  }
  int possibleCards = 0;
  for (Card card : cardsToCheck.getCards(game)) {
    FilterCard nameFilter = new FilterCard();
    nameFilter.add(new NamePredicate(card.isSplitCard() ? ((SplitCard) card).getLeftHalfCard().getName() : card.getName()));
    if (cardsToCheck.count(nameFilter, game) > 1) {
      ++possibleCards;
    }
  }
  return possibleCards > 0;
}

@Override
public ManaCosts getManaCostToPay(GameEvent event, Ability source, Game game) {
  Player controller = game.getPlayer(source.getControllerId());
  if (controller != null && !controller.getHand().isEmpty()) {
    ManaCosts manaCosts = new ManaCostsImpl();
    manaCosts.add(new GenericManaCost(controller.getHand().size()));
    return manaCosts;
  }
  return null;
}

  @Override
  public boolean apply(Game game, Ability source) {
    Player player = game.getPlayer(source.getControllerId());
    if (player == null) {
      return false;
    }
    Cards cardsToReturn = new CardsImpl();
    cards.getCards(game).stream().filter((card) -> (game.getState().getZone(card.getId()) == Zone.EXILED
        && card.getZoneChangeCounter(game) == cardMap.getOrDefault(card.getId(), -5) + 1)).forEachOrdered((card) -> {
      cardsToReturn.add(card);
    });
    return player.moveCards(cardsToReturn, Zone.GRAVEYARD, source, game);
  }
}

public void add(String name, Card card) {        
  this.createLookedAt(name).add(card);
}

@Override
public boolean canPay(Ability ability, UUID sourceId, UUID controllerId, Game game) {
  Player controller = game.getPlayer(controllerId);
  if (controller != null) {
    return !controller.getHand().isEmpty();
  }
  return false;
}

@Override
public boolean apply(Game game, Ability source) {
  Player you = game.getPlayer(source.getControllerId());
  if (you != null) {
    you.discard(you.getHand().size(), false, source, game);
    you.drawCards(7, game);
    Cards hand = you.getHand();
    for (int i = 0; i < 3; i++) {
      Card card = hand.getRandom(game);
      if (card != null) {
        you.discard(card, source, game);
      }
    }
  }
  return false;
}

@Override
public boolean canPay(Ability ability, UUID sourceId, UUID controllerId, Game game) {
  Player player = game.getPlayer(controllerId);
  if (player != null && player.getHand().count(filter, game) > 0) {
    return true;
  }
  if (mana.canPay(ability, sourceId, controllerId, game)) {
    return true;
  }
  return false;
}

@Override
public void useDeck(Deck deck, Game game) {
  library.clear();
  library.addAll(deck.getCards(), game);
  sideboard.clear();
  for (Card card : deck.getSideboard()) {
    sideboard.add(card);
  }
}

  private void chooseCardInHandAndPutOnTopOfLibrary(Game game, Ability source, Player you, Player targetPlayer) {
    if (!targetPlayer.getHand().isEmpty()) {
      TargetCard target = new TargetCard(Zone.HAND, new FilterCard("card to put on the top of library (last chosen will be on top)"));
      if (you.choose(Outcome.Benefit, targetPlayer.getHand(), target, game)) {
        Card card = targetPlayer.getHand().get(target.getFirstTarget(), game);
        if (card != null) {
          targetPlayer.moveCardToLibraryWithInfo(card, source.getSourceId(), game, Zone.HAND, true, false);
        }
      }
    }
  }
}

  @Override
  public boolean apply(Game game, Ability source) {
    Player player = game.getPlayer(source.getControllerId());
    if (player != null) {
      player.drawCards(1, game);
      Card card = player.getHand().getRandom(game);
      if (card != null) {
        player.discard(card, source, game);
      }
      return true;
    }
    return false;
  }
}

@Override
public void leave() {
  this.passed = true;
  this.loses = true;
  this.left = true;
  this.abort();
  //20100423 - 800.4a
  this.hand.clear();
  this.graveyard.clear();
  this.library.clear();
}

@Override
public boolean canChoose(UUID sourceControllerId, Game game) {
  Cards cardsToCheck = new CardsImpl();
  Player player = game.getPlayer(sourceControllerId);
  for (Card card : player.getHand().getCards(filter, game)) {
    cardsToCheck.add(card.getId());
  }
  int possibleCards = 0;
  for (UUID cardToCheck : cardsToCheck) {
    FilterCard colorFilter = new FilterCard();
    colorFilter.add(new ColorPredicate(game.getCard(cardToCheck).getColor(game)));
    if (cardsToCheck.count(colorFilter, game) > 1) {
      ++possibleCards;
    }
  }
  return possibleCards > 0;
}

  @Override
  public boolean apply(Game game, Ability source) {
    Player player = game.getPlayer(source.getControllerId());
    Permanent thoughtGorger = game.getPermanent(source.getSourceId());
    if (player != null && !player.getHand().isEmpty() && thoughtGorger != null ) {
      int cardsInHand = player.getHand().size();
      thoughtGorger.addCounters(CounterType.P1P1.createInstance(cardsInHand), source, game);
      player.discard(cardsInHand, false, source, game);
      return true;
    }
    return false;
  }
}