@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
if (controller != null) {
Player damagedPlayer = game.getPlayer(targetPointer.getFirst(game, source));
if (damagedPlayer == null) {
return false;
}
FilterCard filter =
new FilterCard(
"target instant or sorcery card from " + damagedPlayer.getName() + "'s graveyard");
filter.add(new OwnerIdPredicate(damagedPlayer.getId()));
filter.add(
Predicates.or(
new CardTypePredicate(CardType.INSTANT), new CardTypePredicate(CardType.SORCERY)));
Target target = new TargetCardInGraveyard(filter);
if (controller.chooseTarget(Outcome.PlayForFree, target, source, game)) {
Card card = game.getCard(target.getFirstTarget());
if (card != null) {
controller.cast(card.getSpellAbility(), game, true);
game.addEffect(new WrexialReplacementEffect(card.getId()), source);
}
}
return true;
}
return false;
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
if (controller != null) {
MageObject mageObject = source.getSourceObject(game);
Permanent permanent = game.getPermanent(source.getSourceId());
if (permanent != null
&& mageObject != null
&& new MageObjectReference(permanent, game).refersTo(mageObject, game)) {
if (permanent.sacrifice(source.getSourceId(), game)) {
UUID exileId =
CardUtil.getExileZoneId(
game, source.getSourceId(), source.getSourceObjectZoneChangeCounter());
if (exileId != null) {
ExileZone exileZone = game.getExile().getExileZone(exileId);
Card exiledCard = null;
if (exileZone != null) {
for (Card card : exileZone.getCards(game)) {
exiledCard = card;
break;
}
}
if (exiledCard != null) {
if (exiledCard.getSpellAbility().canChooseTarget(game)) {
controller.cast(exiledCard.getSpellAbility(), game, true);
}
}
}
}
}
return true;
}
return false;
}
@Override
public boolean apply(Game game, Ability source) {
Player player = game.getPlayer(source.getControllerId());
if (player != null) {
FilterCard filter = new FilterCard("red instant or sorcery card from your graveyard to play");
filter.add(new ColorPredicate(ObjectColor.RED));
filter.add(
Predicates.or(
new CardTypePredicate(CardType.INSTANT), new CardTypePredicate(CardType.SORCERY)));
String message =
"Play red instant or sorcery card from your graveyard without paying its mana cost?";
Set<Card> cards = player.getGraveyard().getCards(filter, game);
TargetCardInGraveyard target = new TargetCardInGraveyard(filter);
while (!cards.isEmpty() && player.chooseUse(outcome, message, source, game)) {
target.clearChosen();
if (player.choose(outcome, target, source.getSourceId(), game)) {
Card card = game.getCard(target.getFirstTarget());
if (card != null) {
player.cast(card.getSpellAbility(), game, true);
player.getGraveyard().remove(card);
cards.remove(card);
}
}
}
return true;
}
return false;
}
@Override
public boolean apply(Game game, Ability source) {
Cards cardsToCast = new CardsImpl();
Player targetOpponent = game.getPlayer(targetPointer.getFirst(game, source));
MageObject sourceObject = source.getSourceObject(game);
if (targetOpponent != null && sourceObject != null) {
List<Card> allCards = targetOpponent.getLibrary().getTopCards(game, 7);
Cards cards = new CardsImpl(Zone.LIBRARY, allCards);
targetOpponent.revealCards(
sourceObject.getIdName() + " - " + targetOpponent.getName() + "'s top library cards",
cards,
game);
for (Card card : allCards) {
if (filter.match(card, game)) {
cardsToCast.add(card);
}
}
// cast an instant or sorcery for free
if (cardsToCast.size() > 0) {
int numberOfSpells = 1;
if (SpellMasteryCondition.getInstance().apply(game, source)) {
numberOfSpells++;
}
Player controller = game.getPlayer(source.getControllerId());
if (controller != null) {
TargetCard target = new TargetCard(Zone.LIBRARY, filter); // zone should be ignored here
target.setNotTarget(true);
while (numberOfSpells > 0
&& cardsToCast.size() > 0
&& controller.chooseUse(
outcome,
"Cast an instant or sorcery card from among them for free?",
source,
game)
&& controller.choose(outcome, cardsToCast, target, game)) {
Card card = cardsToCast.get(target.getFirstTarget(), game);
if (card != null) {
controller.cast(card.getSpellAbility(), game, true);
numberOfSpells--;
cardsToCast.remove(card);
allCards.remove(card);
}
if (!controller.isInGame()) {
return false;
}
target.clearChosen();
}
}
targetOpponent.moveCards(allCards, Zone.LIBRARY, Zone.GRAVEYARD, source, game);
}
return true;
}
return false;
}
@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;
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
MageObject sourceObject = source.getSourceObject(game);
if (controller != null && sourceObject != null) {
if (controller.getLibrary().size() > 0) {
Card card = controller.getLibrary().getFromTop(game);
if (card == null) {
return false;
}
controller.revealCards(sourceObject.getIdName(), new CardsImpl(card), game);
if (card.getCardType().contains(CardType.CREATURE)) {
FilterControlledCreaturePermanent filter = new FilterControlledCreaturePermanent();
boolean found = false;
for (Permanent permanent :
game.getBattlefield().getAllActivePermanents(filter, controller.getId(), game)) {
if (CardUtil.shareSubtypes(card, permanent, game)) {
found = true;
break;
}
}
if (found) {
game.informPlayers(
sourceObject.getLogName()
+ ": Found a creature that shares a creature type with the revealed card.");
if (controller.chooseUse(Outcome.Benefit, "Cast the card?", source, game)) {
controller.cast(card.getSpellAbility(), game, true);
} else {
game.informPlayers(
sourceObject.getLogName()
+ ": "
+ controller.getLogName()
+ " canceled casting the card.");
controller.getLibrary().putOnBottom(card, game);
}
} else {
game.informPlayers(
sourceObject.getLogName()
+ ": No creature that shares a creature type with the revealed card.");
controller.getLibrary().putOnBottom(card, game);
}
} else {
game.informPlayers(
sourceObject.getLogName() + ": Put " + card.getLogName() + " on the bottom.");
controller.getLibrary().putOnBottom(card, game);
}
return true;
}
}
return false;
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
if (controller != null) {
Card card = game.getCard(this.getTargetPointer().getFirst(game, source));
if (card != null) {
if (controller.chooseUse(outcome, "Cast " + card.getLogName() + "?", source, game)) {
if (controller.cast(card.getSpellAbility(), game, true)) {
ContinuousEffect effect = new TorrentialGearhulkReplacementEffect(card.getId());
effect.setTargetPointer(
new FixedTarget(card.getId(), game.getState().getZoneChangeCounter(card.getId())));
game.addEffect(effect, source);
}
}
}
return true;
}
return false;
}
@Override
public boolean apply(Game game, Ability source) {
Player you = game.getPlayer(source.getControllerId());
if (you != null) {
if (you.getLibrary().size() > 0) {
TargetCardInLibrary target = new TargetCardInLibrary(filter);
if (you.searchLibrary(target, game, you.getId())) {
UUID targetId = target.getFirstTarget();
Card card = you.getLibrary().remove(targetId, game);
if (card != null) {
you.cast(card.getSpellAbility(), game, true);
}
}
}
you.shuffleLibrary(game);
return true;
}
return false;
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
Card sourceCard = game.getCard(source.getSourceId());
if (controller == null || sourceCard == null) {
return false;
}
if (controller.getLibrary().size() > 0) {
controller.shuffleLibrary(game);
Card card = controller.getLibrary().getFromTop(game);
if (card == null) {
return false;
}
controller.revealCards(sourceCard.getName(), new CardsImpl(card), game);
if (card.getCardType().contains(CardType.LAND)) {
String message = "Put " + card.getName() + " onto the battlefield?";
if (controller.chooseUse(Outcome.PutLandInPlay, message, game)) {
card.putOntoBattlefield(
game, Zone.LIBRARY, source.getSourceId(), source.getControllerId());
return sourceCard.moveToZone(Zone.HAND, source.getSourceId(), game, false);
}
} else {
if (controller.chooseUse(
outcome,
new StringBuilder("Cast ")
.append(card.getName())
.append(" without paying its mana cost?")
.toString(),
game)) {
return controller.cast(card.getSpellAbility(), game, true);
}
}
return true;
}
return false;
}
@Override
public boolean apply(Game game, Ability source) {
Spell spell = game.getStack().getSpell(targetPointer.getFirst(game, source));
Permanent eyeOfTheStorm = game.getPermanentOrLKIBattlefield(source.getSourceId());
if (spell != null && eyeOfTheStorm != null) {
Player spellController = game.getPlayer(spell.getControllerId());
Card card = spell.getCard();
if (spellController == null || card == null || !instantOrSorceryfilter.match(card, game)) {
return false;
}
UUID exileZoneId =
CardUtil.getExileZoneId(
game, source.getSourceId(), eyeOfTheStorm.getZoneChangeCounter(game));
if (spellController.moveCardsToExile(
spell, source, game, true, exileZoneId, eyeOfTheStorm.getIdName())) {
eyeOfTheStorm.imprint(card.getId(), game);
if (eyeOfTheStorm.getImprinted() != null && eyeOfTheStorm.getImprinted().size() > 0) {
CardsImpl copiedCards = new CardsImpl();
for (UUID uuid : eyeOfTheStorm.getImprinted()) {
card = game.getCard(uuid);
// Check if owner of card is still in game
if (card != null && game.getPlayer(card.getOwnerId()) != null) {
if (card.isSplitCard()) {
copiedCards.add(((SplitCard) card).getLeftHalfCard());
copiedCards.add(((SplitCard) card).getRightHalfCard());
} else {
copiedCards.add(card);
}
}
}
boolean continueCasting = true;
while (continueCasting) {
continueCasting =
copiedCards.size() > 1
&& spellController.chooseUse(
outcome,
"Cast one of the copied cards without paying its mana cost?",
source,
game);
Card cardToCopy;
if (copiedCards.size() == 1) {
cardToCopy = copiedCards.getCards(game).iterator().next();
} else {
TargetCard target = new TargetCard(1, Zone.EXILED, new FilterCard("card to copy"));
spellController.choose(Outcome.Copy, copiedCards, target, game);
cardToCopy = copiedCards.get(target.getFirstTarget(), game);
copiedCards.remove(cardToCopy);
}
if (cardToCopy != null) {
Card copy = game.copyCard(cardToCopy, source, source.getControllerId());
if (spellController.chooseUse(
outcome, "Cast the copied card without paying mana cost?", source, game)) {
spellController.cast(copy.getSpellAbility(), game, true);
}
}
}
return true;
}
}
}
return false;
}
