@Override
 public boolean apply(Game game, Ability source) {
   Player controller = game.getPlayer(source.getControllerId());
   MageObject sourceObject = source.getSourceObject(game);
   if (controller != null && sourceObject != null) {
     Permanent permanent = game.getPermanent(getTargetPointer().getFirst(game, source));
     UUID exileId =
         CardUtil.getExileZoneId(
             game, source.getSourceId(), source.getSourceObjectZoneChangeCounter());
     if (permanent != null) {
       return controller.moveCardToExileWithInfo(
           permanent,
           exileId,
           sourceObject.getIdName(),
           source.getSourceId(),
           game,
           Zone.BATTLEFIELD,
           true);
     } else {
       Card card = game.getCard(getTargetPointer().getFirst(game, source));
       if (card != null) {
         return controller.moveCardToExileWithInfo(
             card,
             exileId,
             sourceObject.getIdName(),
             source.getSourceId(),
             game,
             game.getState().getZone(card.getId()),
             true);
       }
     }
   }
   return false;
 }
Example #2
0
 @Override
 public boolean apply(Game game, Ability source) {
   Player controller = game.getPlayer(source.getControllerId());
   MageObject sourceObject = source.getSourceObject(game);
   if (sourceObject != null && controller != null) {
     TargetCardInYourGraveyard target =
         new TargetCardInYourGraveyard(
             new FilterInstantOrSorceryCard("instant or sorcery card from your graveyard"));
     if (controller.chooseTarget(outcome, target, source, game)) {
       UUID exileId =
           CardUtil.getExileZoneId(
               game, source.getSourceId(), source.getSourceObjectZoneChangeCounter());
       Card card = controller.getGraveyard().get(target.getFirstTarget(), game);
       if (card != null) {
         controller.moveCardToExileWithInfo(
             card,
             exileId,
             sourceObject.getIdName(),
             source.getSourceId(),
             game,
             Zone.GRAVEYARD,
             true);
       }
     }
     return true;
   }
   return false;
 }
Example #3
0
 @Override
 public boolean pay(
     Ability ability,
     Game game,
     UUID sourceId,
     UUID controllerId,
     boolean noMana,
     Cost costToPay) {
   Player controller = game.getPlayer(controllerId);
   MageObject sourceObject = ability.getSourceObject(game);
   if (controller != null && sourceObject != null) {
     if (targets.choose(Outcome.Exile, controllerId, sourceId, game)) {
       UUID exileId =
           CardUtil.getExileZoneId(
               game, ability.getSourceId(), ability.getSourceObjectZoneChangeCounter());
       for (UUID targetId : targets.get(0).getTargets()) {
         Permanent permanent = game.getPermanent(targetId);
         if (permanent == null) {
           return false;
         }
         paid |=
             controller.moveCardToExileWithInfo(
                 permanent,
                 exileId,
                 sourceObject.getIdName() + " championed permanents",
                 sourceId,
                 game,
                 Zone.BATTLEFIELD,
                 true);
       }
     }
   }
   return paid;
 }
Example #4
0
 @Override
 public boolean apply(Game game, Ability source) {
   Permanent permanent = game.getPermanent(source.getFirstTarget());
   Player controller = game.getPlayer(source.getControllerId());
   Permanent sourcePermanent = game.getPermanentOrLKIBattlefield(source.getSourceId());
   if (controller != null && permanent != null && sourcePermanent != null) {
     CopyEffect copyEffect = new CopyEffect(Duration.EndOfTurn, permanent, source.getSourceId());
     if (controller.moveCardToExileWithInfo(
         permanent,
         source.getSourceId(),
         sourcePermanent.getIdName(),
         source.getSourceId(),
         game,
         Zone.BATTLEFIELD,
         true)) {
       // Copy exiled permanent
       game.addEffect(copyEffect, source);
       // Create delayed triggered ability
       AtTheBeginOfNextEndStepDelayedTriggeredAbility delayedAbility =
           new AtTheBeginOfNextEndStepDelayedTriggeredAbility(
               new ReturnFromExileEffect(source.getSourceId(), Zone.BATTLEFIELD, false));
       delayedAbility.setSourceId(source.getSourceId());
       delayedAbility.setControllerId(source.getControllerId());
       delayedAbility.setSourceObject(source.getSourceObject(game), game);
       game.addDelayedTriggeredAbility(delayedAbility);
       return true;
     }
   }
   return false;
 }
Example #5
0
 @Override
 public boolean apply(Game game, Ability source) {
   Player controller = game.getPlayer(source.getControllerId());
   MageObject sourceObject = source.getSourceObject(game);
   if (controller != null && sourceObject != null) {
     controller.shuffleLibrary(source, game);
     if (controller.getLibrary().size() > 0) {
       Card card = controller.getLibrary().removeFromTop(game);
       if (card != null) {
         controller.moveCardToExileWithInfo(
             card,
             source.getSourceId(),
             sourceObject.getIdName(),
             source.getSourceId(),
             game,
             Zone.LIBRARY,
             true);
         ContinuousEffect effect = new MindsDesireCastFromExileEffect();
         effect.setTargetPointer(new FixedTarget(card.getId()));
         game.addEffect(effect, source);
       }
     }
     return true;
   }
   return false;
 }
Example #6
0
  @Override
  public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    Player opponent = game.getPlayer(source.getFirstTarget());
    Permanent sourcePermanent = game.getPermanentOrLKIBattlefield(source.getSourceId());
    if (controller != null && opponent != null && sourcePermanent != null) {
      opponent.revealCards(sourcePermanent.getName(), opponent.getHand(), game);

      TargetCard target = new TargetCard(Zone.PICK, new FilterNonlandCard("nonland card to exile"));
      if (controller.choose(Outcome.Exile, opponent.getHand(), target, game)) {
        Card card = opponent.getHand().get(target.getFirstTarget(), game);
        if (card != null) {
          controller.moveCardToExileWithInfo(
              card,
              CardUtil.getCardExileZoneId(game, source),
              sourcePermanent.getName(),
              source.getSourceId(),
              game,
              Zone.HAND);
        }
      }

      return true;
    }
    return false;
  }
Example #7
0
  @Override
  public boolean apply(Game game, Ability source) {
    Player controller = game.getPlayer(source.getControllerId());
    Permanent sourcePermanent = game.getPermanentOrLKIBattlefield(source.getSourceId());
    if (controller == null || sourcePermanent == null) {
      return false;
    }
    for (UUID playerId : controller.getInRange()) {
      Player player = game.getPlayer(playerId);
      String playerName = new StringBuilder(player.getLogName()).append("'s").toString();
      if (source.getControllerId().equals(player.getId())) {
        playerName = "your";
      }
      TargetCardInLibrary target =
          new TargetCardInLibrary(
              new FilterNonlandCard(
                  new StringBuilder("nonland card from ")
                      .append(playerName)
                      .append(" library")
                      .toString()));
      if (controller.searchLibrary(target, game, playerId)) {
        UUID targetId = target.getFirstTarget();
        Card card = player.getLibrary().remove(targetId, game);
        if (card != null) {
          controller.moveCardToExileWithInfo(
              card,
              CardUtil.getCardExileZoneId(game, source),
              sourcePermanent.getIdName(),
              source.getSourceId(),
              game,
              Zone.LIBRARY,
              true);
        }
      }
      player.shuffleLibrary(game);
    }

    ExileZone jaceExileZone =
        game.getExile().getExileZone(CardUtil.getCardExileZoneId(game, source));
    if (jaceExileZone == null) {
      return true;
    }
    FilterCard filter = new FilterCard("card to cast without mana costs");
    TargetCardInExile target = new TargetCardInExile(filter, source.getSourceId());
    while (jaceExileZone.count(filter, game) > 0
        && controller.choose(Outcome.PlayForFree, jaceExileZone, target, game)) {
      Card card = game.getCard(target.getFirstTarget());
      if (card != null) {
        if (controller.cast(card.getSpellAbility(), game, true)) {
          game.getExile().removeCard(card, game);
        }
      }
      target.clearChosen();
    }
    return true;
  }
Example #8
0
 @Override
 public boolean replaceEvent(GameEvent event, Ability source, Game game) {
   Player controller = game.getPlayer(source.getControllerId());
   Permanent permanent = ((ZoneChangeEvent) event).getTarget();
   if (controller != null && permanent != null) {
     return controller.moveCardToExileWithInfo(
         permanent, null, "", source.getSourceId(), game, Zone.BATTLEFIELD, true);
   }
   return false;
 }
Example #9
0
 @Override
 public boolean replaceEvent(GameEvent event, Ability source, Game game) {
   Player controller = game.getPlayer(source.getControllerId());
   Card card = game.getCard(this.cardId);
   if (controller != null && card != null) {
     controller.moveCardToExileWithInfo(
         card, null, "", source.getSourceId(), game, Zone.STACK, true);
     return true;
   }
   return false;
 }
Example #10
0
  @Override
  public boolean apply(Game game, Ability source) {
    UUID exileId = source.getSourceId();
    Permanent targetPermanent = game.getPermanent(getTargetPointer().getFirst(game, source));
    Player controller = game.getPlayer(source.getControllerId());
    MageObject sourceObject = game.getObject(source.getSourceId());
    if (sourceObject != null && exileId != null && targetPermanent != null && controller != null) {

      if (targetPermanent.getName().isEmpty()) { // face down creature
        controller.moveCardToExileWithInfo(
            targetPermanent,
            exileId,
            sourceObject.getIdName(),
            source.getSourceId(),
            game,
            Zone.BATTLEFIELD,
            true);
      } else {
        String name = targetPermanent.getName();
        for (Permanent permanent :
            game.getBattlefield().getActivePermanents(source.getControllerId(), game)) {
          if (permanent != null && permanent.getName().equals(name)) {
            controller.moveCardToExileWithInfo(
                permanent,
                exileId,
                sourceObject.getIdName(),
                source.getSourceId(),
                game,
                Zone.BATTLEFIELD,
                true);
          }
        }
      }
      return true;
    }
    return false;
  }
Example #11
0
 @Override
 public boolean apply(Game game, Ability source) {
   UUID exileId = CardUtil.getCardExileZoneId(game, source);
   Player opponent = game.getPlayer(this.getTargetPointer().getFirst(game, source));
   Player controller = game.getPlayer(source.getControllerId());
   if (opponent != null && controller != null) {
     for (int i = 0; i < 3; i++) {
       Card card = opponent.getLibrary().getFromTop(game);
       if (card != null) {
         controller.moveCardToExileWithInfo(
             card, exileId, "Ashiok, Nightmare Weaver", source.getSourceId(), game, Zone.LIBRARY);
       }
     }
     return true;
   }
   return false;
 }
Example #12
0
 @Override
 public boolean apply(Game game, Ability source) {
   Player controller = game.getPlayer(source.getControllerId());
   if (controller != null) {
     for (Permanent permanent :
         game.getBattlefield()
             .getActivePermanents(
                 new FilterPermanent(), controller.getId(), source.getSourceId(), game)) {
       if (permanent instanceof PermanentToken) {
         controller.moveCardToExileWithInfo(
             permanent, null, "", source.getSourceId(), game, Zone.BATTLEFIELD, true);
       } else if (!permanent.getCounters(game).isEmpty()) {
         Counters counters = permanent.getCounters(game).copy();
         for (Counter counter : counters.values()) {
           permanent.removeCounters(counter, game);
         }
       }
     }
     return true;
   }
   return false;
 }