@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());
Permanent permanent = (Permanent) game.getLastKnownInformation(target, Zone.BATTLEFIELD);
if (permanent != null && controller != null) {
Player player = game.getPlayer(permanent.getOwnerId());
if (player != null) {
FilterCreatureCard filter =
new FilterCreatureCard(
new StringBuilder("a creature card from ")
.append(player.getLogName())
.append("'s graveyard")
.toString());
filter.add(new OwnerIdPredicate(player.getId()));
Target targetCreature = new TargetCardInGraveyard(filter);
if (targetCreature.canChoose(source.getSourceId(), controller.getId(), game)
&& controller.chooseTarget(outcome, targetCreature, source, game)) {
Card card = game.getCard(targetCreature.getFirstTarget());
if (card != null && game.getState().getZone(card.getId()).equals(Zone.GRAVEYARD)) {
return card.putOntoBattlefield(
game, Zone.GRAVEYARD, source.getSourceId(), player.getId());
}
}
return true;
}
}
return false;
}
@Override
public boolean apply(Game game, Ability source) {
Player player = game.getPlayer(targetPointer.getFirst(game, source));
if (player == null) {
return false;
}
if (player.getLife() > 2
&& player.chooseUse(
Outcome.Neutral,
"Pay 2 life? If you don't, return a permanent you control to its owner's hand.",
game)) {
player.loseLife(2, game);
game.informPlayers(
player.getName() + " pays 2 life. He will not return a permanent he or she controls.");
return true;
} else {
Target target = new TargetControlledPermanent();
if (target.canChoose(source.getSourceId(), player.getId(), game)
&& player.chooseTarget(outcome, target, source, game)) {
Permanent permanent = game.getPermanent(target.getFirstTarget());
if (permanent != null) {
game.informPlayers(player.getName() + " returns " + permanent.getName() + " to hand.");
return permanent.moveToZone(Zone.HAND, source.getSourceId(), game, false);
}
}
}
return false;
}
@Override
public boolean resolve(Game game) {
int manaX = this.getManaCostsToPay().getX();
FilterPermanent filter =
new FilterCreaturePermanent("creature with power " + manaX + " or less");
filter.add(new ConvertedManaCostPredicate(Filter.ComparisonType.LessThan, manaX + 1));
Target target = new TargetPermanent(filter);
Player player = game.getPlayer(controllerId);
if (player != null) {
if (player.chooseTarget(Outcome.Benefit, target, this, game)) {
this.getEffects().get(0).setTargetPointer(new FixedTarget(target.getFirstTarget()));
return super.resolve(game);
}
}
return false;
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
if (controller != null) {
Target target = new TargetSource();
target.setRequired(true);
target.setNotTarget(true);
if (controller.chooseTarget(outcome, target, source, game)) {
ContinuousEffect continuousEffect = new InterventionPactPreventDamageEffect();
continuousEffect.setTargetPointer(new FixedTarget(target.getFirstTarget()));
game.addEffect(continuousEffect, source);
}
return true;
}
return false;
}
@Override
public boolean apply(Game game, Ability source) {
Player player = game.getPlayer(source.getTargets().get(1).getFirstTarget());
if (player == null) {
return false;
}
Target target = new TargetControlledPermanent(new FilterControlledCreaturePermanent());
if (target.canChoose(player.getId(), game)
&& player.choose(Outcome.Sacrifice, target, source.getSourceId(), game)) {
Permanent permanent = game.getPermanent(target.getFirstTarget());
if (permanent != null) {
return permanent.sacrifice(source.getSourceId(), game);
}
}
return false;
}
@Override
public boolean apply(Game game, Ability source) {
Player player = game.getPlayer(source.getControllerId());
if (player == null) {
return false;
}
int cmc = 0;
for (Cost cost : source.getCosts()) {
if (cost instanceof PayVariableLoyaltyCost) {
cmc = ((PayVariableLoyaltyCost) cost).getAmount();
}
}
FilterCard filter =
new FilterCreatureCard(
new StringBuilder("creature card with converted mana cost {")
.append(cmc)
.append("} exiled with Ashiok, Nightmare Weaver")
.toString());
filter.add(new ConvertedManaCostPredicate(Filter.ComparisonType.Equal, cmc));
Target target = new TargetCardInExile(filter, CardUtil.getCardExileZoneId(game, source));
if (target.canChoose(source.getSourceId(), player.getId(), game)) {
if (player.chooseTarget(Outcome.PutCreatureInPlay, target, source, game)) {
Card card = game.getCard(target.getFirstTarget());
if (card != null
&& player.putOntoBattlefieldWithInfo(card, game, Zone.EXILED, source.getSourceId())) {
Permanent permanent = game.getPermanent(card.getId());
if (permanent != null) {
permanent.changeControllerId(source.getControllerId(), game);
}
ContinuousEffectImpl effect = new AshiokNightmareWeaverAddTypeEffect();
effect.setTargetPointer(new FixedTarget(card.getId()));
game.addEffect(effect, source);
return true;
}
}
}
return false;
}
@Override
public boolean apply(Game game, Ability source) {
boolean result = false;
int destroyedCreatures = 0;
for (Target target : source.getTargets()) {
if (target instanceof TargetPermanent) {
Permanent targetPermanent = game.getPermanent(target.getFirstTarget());
if (targetPermanent != null) {
if (targetPermanent.destroy(source.getSourceId(), game, false)) {
destroyedCreatures++;
}
}
}
}
if (destroyedCreatures > 0) {
new SearchLibraryPutInPlayEffect(
new TargetCardInLibrary(destroyedCreatures, filterForest), true, true)
.apply(game, source);
}
return result;
}
@Override
public boolean apply(Game game, Ability source) {
Set<UUID> opponents = game.getOpponents(source.getControllerId());
for (UUID opponentId : opponents) {
Player player = game.getPlayer(opponentId);
Target target = new TargetControlledPermanent(filter);
if (target.canChoose(player.getId(), game)) {
while (!target.isChosen() && target.canChoose(player.getId(), game)) {
player.choose(Outcome.Sacrifice, target, source.getSourceId(), game);
}
Permanent permanent = game.getPermanent(target.getFirstTarget());
if (permanent != null) {
permanent.sacrifice(source.getSourceId(), game);
}
}
}
return true;
}
@Override
public boolean apply(Game game, Ability source) {
boolean result = false;
for (Target target : source.getTargets()) {
if (target instanceof TargetCreaturePermanent) {
Permanent targetCreature = game.getPermanent(target.getFirstTarget());
if (targetCreature != null) {
ContinuousEffect effect1 = new GainControlTargetEffect(Duration.EndOfTurn);
effect1.setTargetPointer(new FixedTarget(targetCreature.getId()));
game.addEffect(effect1, source);
ContinuousEffect effect2 =
new GainAbilityTargetEffect(HasteAbility.getInstance(), Duration.EndOfTurn);
effect2.setTargetPointer(new FixedTarget(targetCreature.getId()));
game.addEffect(effect2, source);
targetCreature.untap(game);
result = true;
}
}
}
return result;
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
MageObject sourceObject = game.getObject(source.getSourceId());
if (sourceObject != null && controller != null) {
Cards cards = new CardsImpl();
cards.addAll(controller.getLibrary().getTopCards(game, 3));
if (!cards.isEmpty()) {
controller.revealCards(staticText, cards, game);
Card cardToGraveyard;
if (cards.size() == 1) {
cardToGraveyard = cards.getRandom(game);
} else {
Player opponent;
Set<UUID> opponents = game.getOpponents(controller.getId());
if (opponents.size() == 1) {
opponent = game.getPlayer(opponents.iterator().next());
} else {
Target target = new TargetOpponent(true);
controller.chooseTarget(Outcome.Detriment, target, source, game);
opponent = game.getPlayer(target.getFirstTarget());
}
TargetCard target = new TargetCard(1, Zone.LIBRARY, new FilterCard());
opponent.chooseTarget(outcome, cards, target, source, game);
cardToGraveyard = game.getCard(target.getFirstTarget());
}
if (cardToGraveyard != null) {
controller.moveCards(cardToGraveyard, Zone.LIBRARY, Zone.GRAVEYARD, source, game);
cards.remove(cardToGraveyard);
}
controller.moveCards(cards, Zone.LIBRARY, Zone.HAND, source, game);
}
return true;
}
return false;
}
/**
* @param game
* @param playerId
* @param forceChange - does only work for targets with maximal one targetId
* @param onlyOneTarget - 114.6b one target must be changed to another target
* @return
*/
public boolean chooseNewTargets(
Game game, UUID playerId, boolean forceChange, boolean onlyOneTarget) {
Player player = game.getPlayer(playerId);
if (player != null) {
for (SpellAbility spellAbility : spellAbilities) {
for (Target target : spellAbility.getTargets()) {
Target newTarget = target.copy();
newTarget.clearChosen();
for (UUID targetId : target.getTargets()) {
MageObject object = game.getObject(targetId);
String name = null;
if (object == null) {
Player targetPlayer = game.getPlayer(targetId);
if (targetPlayer != null) {
name = targetPlayer.getName();
}
} else {
name = object.getName();
}
if (name != null
&& (forceChange
|| player.chooseUse(
spellAbility.getEffects().get(0).getOutcome(),
"Change target from " + name + "?",
game))) {
if (forceChange
&& target.possibleTargets(this.getSourceId(), playerId, game).size() > 1) {
int iteration = 0;
do {
if (iteration > 0) {
game.informPlayer(
player,
"You may only select exactly one target that must be different from the origin target!");
}
iteration++;
newTarget.clearChosen();
player.chooseTarget(
spellAbility.getEffects().get(0).getOutcome(), newTarget, spellAbility, game);
} while (targetId.equals(newTarget.getFirstTarget())
|| newTarget.getTargets().size() != 1);
} else {
if (!player.chooseTarget(
spellAbility.getEffects().get(0).getOutcome(), newTarget, spellAbility, game)) {
newTarget.addTarget(targetId, spellAbility, game, false);
}
}
} else {
newTarget.addTarget(targetId, spellAbility, game, false);
}
}
target.clearChosen();
for (UUID newTargetId : newTarget.getTargets()) {
target.addTarget(newTargetId, spellAbility, game, false);
}
}
}
return true;
}
return false;
}
@Override
public boolean apply(Game game, Ability source) {
List<Card> chosen = new ArrayList<>();
for (UUID playerId : game.getPlayerList()) {
Player player = game.getPlayer(playerId);
Target target1 =
new TargetControlledPermanent(1, 1, new FilterControlledArtifactPermanent(), true);
Target target2 =
new TargetControlledPermanent(1, 1, new FilterControlledCreaturePermanent(), true);
Target target3 =
new TargetControlledPermanent(1, 1, new FilterControlledEnchantmentPermanent(), true);
Target target4 =
new TargetControlledPermanent(1, 1, new FilterControlledLandPermanent(), true);
if (target1.canChoose(player.getId(), game)) {
while (player.canRespond()
&& !target1.isChosen()
&& target1.canChoose(player.getId(), game)) {
player.chooseTarget(Outcome.Benefit, target1, source, game);
}
Permanent artifact = game.getPermanent(target1.getFirstTarget());
if (artifact != null) {
chosen.add(artifact);
}
target1.clearChosen();
}
if (target2.canChoose(player.getId(), game)) {
while (player.canRespond()
&& !target2.isChosen()
&& target2.canChoose(player.getId(), game)) {
player.chooseTarget(Outcome.Benefit, target2, source, game);
}
Permanent creature = game.getPermanent(target2.getFirstTarget());
if (creature != null) {
chosen.add(creature);
}
target2.clearChosen();
}
if (target3.canChoose(player.getId(), game)) {
while (player.canRespond()
&& !target3.isChosen()
&& target3.canChoose(player.getId(), game)) {
player.chooseTarget(Outcome.Benefit, target3, source, game);
}
Permanent enchantment = game.getPermanent(target3.getFirstTarget());
if (enchantment != null) {
chosen.add(enchantment);
}
target3.clearChosen();
}
if (target4.canChoose(player.getId(), game)) {
while (player.canRespond()
&& !target4.isChosen()
&& target4.canChoose(player.getId(), game)) {
player.chooseTarget(Outcome.Benefit, target4, source, game);
}
Permanent land = game.getPermanent(target4.getFirstTarget());
if (land != null) {
chosen.add(land);
}
target4.clearChosen();
}
}
for (Permanent permanent : game.getBattlefield().getAllActivePermanents()) {
if (!chosen.contains(permanent)) {
permanent.sacrifice(source.getSourceId(), game);
}
}
return true;
}