prompt
stringlengths 108
1.09k
| completion
stringlengths 1
34.4k
|
|---|---|
Layout: normal
Name: A Killer Among Us
Mana Cost: {4}{G}
Cmc: 5.0
Type Line: Enchantment
Oracle Text: When A Killer Among Us enters, create a 1/1 white Human creature token, a 1/1 blue Merfolk creature token, and a 1/1 red Goblin creature token. Then secretly choose Human, Merfolk, or Goblin.
Sacrifice A Killer Among Us, Reveal the creature type you chose: If target attacking creature token is the chosen type, put three +1/+1 counters on it and it gains deathtouch until end of turn.
Colors: G
Color Identity: G
Rarity: uncommon | package mage.cards.a;
import java.util.LinkedHashSet;
import java.util.Set;
import java.util.UUID;
import mage.MageObject;
import mage.abilities.Ability;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.Cost;
import mage.abilities.costs.CostImpl;
import mage.abilities.costs.common.SacrificeSourceCost;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.CreateTokenEffect;
import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
import mage.abilities.keyword.DeathtouchAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.choices.Choice;
import mage.choices.ChoiceImpl;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.Outcome;
import mage.constants.SubType;
import mage.counters.CounterType;
import mage.filter.common.FilterAttackingCreature;
import mage.filter.predicate.permanent.TokenPredicate;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.game.permanent.token.GoblinToken;
import mage.game.permanent.token.HumanToken;
import mage.game.permanent.token.MerfolkToken;
import mage.players.Player;
import mage.target.TargetPermanent;
public final class AKillerAmongUs extends CardImpl {
private static final FilterAttackingCreature filter = new FilterAttackingCreature("attacking creature token");
static {
filter.add(TokenPredicate.TRUE);
}
public AKillerAmongUs(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{4}{G}");
// When A Killer Among Us enters the battlefield, create a 1/1 white Human creature token, a 1/1 blue Merfolk creature token, and a 1/1 red Goblin creature token. Then secretly choose Human, Merfolk, or Goblin.
Ability ability = new EntersBattlefieldTriggeredAbility(new CreateTokenEffect(new HumanToken()));
ability.addEffect(new CreateTokenEffect(new MerfolkToken())
.setText(", a 1/1 blue Merfolk creature token"));
ability.addEffect(new CreateTokenEffect(new GoblinToken())
.setText(", and a 1/1 red Goblin creature token."));
ability.addEffect(new ChooseHumanMerfolkOrGoblinEffect());
this.addAbility(ability);
// Sacrifice A Killer Among Us, Reveal the chosen creature type: If target attacking creature token is the chosen type, put three +1/+1 counters on it and it gains deathtouch until end of turn.
ability = new SimpleActivatedAbility(new AKillerAmongUsEffect(), new SacrificeSourceCost());
ability.addCost(new AKillerAmongUsCost());
ability.addTarget(new TargetPermanent(filter));
this.addAbility(ability);
}
private AKillerAmongUs(final AKillerAmongUs card) {
super(card);
}
@Override
public AKillerAmongUs copy() {
return new AKillerAmongUs(this);
}
}
class ChooseHumanMerfolkOrGoblinEffect extends OneShotEffect {
public static final String SECRET_CREATURE_TYPE = "_susCreatureType";
public static final String SECRET_OWNER = "_secOwn";
ChooseHumanMerfolkOrGoblinEffect() {
super(Outcome.Neutral);
staticText = "Then secretly choose Human, Merfolk, or Goblin.";
}
private ChooseHumanMerfolkOrGoblinEffect(final ChooseHumanMerfolkOrGoblinEffect effect) {
super(effect);
}
@Override
public ChooseHumanMerfolkOrGoblinEffect copy() {
return new ChooseHumanMerfolkOrGoblinEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
if (controller == null) {
return false;
}
Permanent permanent = game.getPermanentOrLKIBattlefield(source.getSourceId());
if (permanent == null) {
return false;
}
Choice choice = new ChoiceImpl(true);
Set<String> choices = new LinkedHashSet<>();
choices.add("Human");
choices.add("Merfolk");
choices.add("Goblin");
choice.setChoices(choices);
choice.setMessage("Choose Human, Merfolk, or Goblin");
controller.choose(outcome, choice, game);
game.informPlayers(permanent.getName() + ": " + controller.getLogName() + " has secretly chosen a creature type.");
SubType chosenType = SubType.byDescription(choice.getChoice());
setSecretCreatureType(chosenType, source, game);
setSecretOwner(source.getControllerId(), source, game);
return true;
}
public static void setSecretCreatureType(SubType type, Ability source, Game game) {
String uniqueRef = getUniqueReference(source, game);
if (uniqueRef != null) {
game.getState().setValue(uniqueRef + SECRET_CREATURE_TYPE, type);
}
}
public static SubType getSecretCreatureType(Ability source, Game game) {
String uniqueRef = getUniqueReference(source, game);
if (uniqueRef != null) {
return (SubType) game.getState().getValue(uniqueRef +
ChooseHumanMerfolkOrGoblinEffect.SECRET_CREATURE_TYPE);
}
return null;
}
public static void setSecretOwner(UUID owner, Ability source, Game game) {
String uniqueRef = getUniqueReference(source, game);
if (uniqueRef != null) {
game.getState().setValue(getUniqueReference(source, game) + SECRET_OWNER, owner);
}
}
public static UUID getSecretOwner(Ability source, Game game) {
String uniqueRef = getUniqueReference(source, game);
if (uniqueRef != null) {
return (UUID) game.getState().getValue(getUniqueReference(source, game) +
ChooseHumanMerfolkOrGoblinEffect.SECRET_OWNER);
}
return null;
}
private static String getUniqueReference(Ability source, Game game) {
if (game.getPermanentOrLKIBattlefield(source.getSourceId()) != null) {
return source.getSourceId() + "_" + (game.getPermanentOrLKIBattlefield(source.getSourceId()).getZoneChangeCounter(game));
}
return null;
}
}
class AKillerAmongUsEffect extends OneShotEffect {
AKillerAmongUsEffect() {
super(Outcome.Benefit);
this.staticText = "If target attacking creature token is the chosen type, " +
"put three +1/+1 counters on it and it gains deathtouch until end of turn.";
}
private AKillerAmongUsEffect(final AKillerAmongUsEffect effect) {
super(effect);
}
@Override
public AKillerAmongUsEffect copy() {
return new AKillerAmongUsEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Permanent creature = game.getPermanent(source.getFirstTarget());
if (creature == null) {
return false;
}
SubType creatureType = ChooseHumanMerfolkOrGoblinEffect.getSecretCreatureType(source, game);
if (creatureType != null && creature.getSubtype().contains(creatureType)) {
creature.addCounters(CounterType.P1P1.createInstance(3), source, game);
game.addEffect(new GainAbilityTargetEffect(
DeathtouchAbility.getInstance(), Duration.EndOfTurn
), source);
}
return true;
}
}
class AKillerAmongUsCost extends CostImpl {
AKillerAmongUsCost() {
this.text = "Reveal the creature type you chose";
}
private AKillerAmongUsCost(final AKillerAmongUsCost cost) {
super(cost);
}
@Override
public AKillerAmongUsCost copy() {
return new AKillerAmongUsCost(this);
}
@Override
public boolean canPay(Ability ability, Ability source, UUID controllerId, Game game) {
return controllerId != null
&& controllerId.equals(ChooseHumanMerfolkOrGoblinEffect.getSecretOwner(source, game))
&& ChooseHumanMerfolkOrGoblinEffect.getSecretCreatureType(source, game) != null;
}
@Override
public boolean pay(Ability ability, Game game, Ability source, UUID controllerId, boolean noMana, Cost costToPay) {
if (controllerId == null || !controllerId.equals(ChooseHumanMerfolkOrGoblinEffect.getSecretOwner(source, game))) {
return false;
}
SubType creatureType = ChooseHumanMerfolkOrGoblinEffect.getSecretCreatureType(source, game);
if (creatureType == null) {
return paid;
}
Player controller = game.getPlayer(controllerId);
MageObject sourceObject = game.getObject(source);
if (controller != null && sourceObject != null) {
game.informPlayers(sourceObject.getLogName() + ": " + controller.getLogName() +
" reveals the secretly chosen creature type " + creatureType);
}
paid = true;
return paid;
}
} |
Layout: normal
Name: A Little Chat
Mana Cost: {1}{U}
Cmc: 2.0
Type Line: Instant
Oracle Text: Casualty 1 (As you cast this spell, you may sacrifice a creature with power 1 or greater. When you do, copy this spell.)
Look at the top two cards of your library. Put one of them into your hand and the other on the bottom of your library.
Colors: U
Color Identity: U
Keywords: Casualty
Rarity: uncommon | package mage.cards.a;
import mage.abilities.effects.common.LookLibraryAndPickControllerEffect;
import mage.abilities.keyword.CasualtyAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.PutCards;
import java.util.UUID;
public final class ALittleChat extends CardImpl {
public ALittleChat(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{U}");
// Casualty 1
this.addAbility(new CasualtyAbility(1));
// Look at the top two cards of your library. Put one of them into your hand and the other on the bottom of your library.
this.getSpellAbility().addEffect(new LookLibraryAndPickControllerEffect(2, 1, PutCards.HAND, PutCards.BOTTOM_ANY));
}
private ALittleChat(final ALittleChat card) {
super(card);
}
@Override
public ALittleChat copy() {
return new ALittleChat(this);
}
} |
Layout: normal
Name: A Tale for the Ages
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Enchantment
Oracle Text: Enchanted creatures you control get +2/+2.
Colors: W
Color Identity: W
Rarity: rare | package mage.cards.a;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.common.continuous.BoostControlledEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.filter.common.FilterCreaturePermanent;
import mage.filter.predicate.permanent.EnchantedPredicate;
import java.util.UUID;
public final class ATaleForTheAges extends CardImpl {
private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("enchanted creatures");
static {
filter.add(EnchantedPredicate.instance);
}
public ATaleForTheAges(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{1}{W}");
// Enchanted creatures you control get +2/+2.
this.addAbility(new SimpleStaticAbility(new BoostControlledEffect(
2, 2, Duration.WhileOnBattlefield, filter
)));
}
private ATaleForTheAges(final ATaleForTheAges card) {
super(card);
}
@Override
public ATaleForTheAges copy() {
return new ATaleForTheAges(this);
}
} |
Layout: normal
Name: Aarakocra Sneak
Mana Cost: {3}{U}
Cmc: 4.0
Type Line: Creature — Bird Rogue
Oracle Text: Flying
When Aarakocra Sneak enters, you take the initiative.
Power: 1
Toughness: 4
Colors: U
Color Identity: U
Keywords: Flying
Rarity: common | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.common.TakeTheInitiativeEffect;
import mage.abilities.hint.common.InitiativeHint;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import java.util.UUID;
public final class AarakocraSneak extends CardImpl {
public AarakocraSneak(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{U}");
this.subtype.add(SubType.BIRD);
this.subtype.add(SubType.ROGUE);
this.power = new MageInt(1);
this.toughness = new MageInt(4);
// Flying
this.addAbility(FlyingAbility.getInstance());
// When Aarakocra Sneak enters the battlefield, you take the initiative.
this.addAbility(new EntersBattlefieldTriggeredAbility(new TakeTheInitiativeEffect()).addHint(InitiativeHint.instance));
}
private AarakocraSneak(final AarakocraSneak card) {
super(card);
}
@Override
public AarakocraSneak copy() {
return new AarakocraSneak(this);
}
} |
Layout: normal
Name: Abaddon the Despoiler
Mana Cost: {2}{U}{B}{R}
Cmc: 5.0
Type Line: Legendary Creature — Astartes Warrior
Oracle Text: Trample
Mark of Chaos Ascendant — During your turn, spells you cast from your hand with mana value X or less have cascade, where X is the total amount of life your opponents have lost this turn.
Power: 5
Toughness: 5
Colors: B, R, U
Color Identity: B, R, U
Keywords: Mark of Chaos Ascendant, Trample
Rarity: mythic
Promo Types: surgefoil | package mage.cards.a;
import mage.MageInt;
import mage.MageObject;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.condition.common.MyTurnCondition;
import mage.abilities.decorator.ConditionalContinuousEffect;
import mage.abilities.dynamicvalue.common.OpponentsLostLifeCount;
import mage.abilities.effects.common.continuous.GainAbilityControlledSpellsEffect;
import mage.abilities.hint.Hint;
import mage.abilities.hint.ValueHint;
import mage.abilities.keyword.CascadeAbility;
import mage.abilities.keyword.TrampleAbility;
import mage.cards.Card;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.SuperType;
import mage.constants.Zone;
import mage.filter.common.FilterNonlandCard;
import mage.filter.predicate.Predicate;
import mage.filter.predicate.card.CastFromZonePredicate;
import mage.game.Game;
import mage.watchers.common.PlayerLostLifeWatcher;
import java.util.UUID;
public final class AbaddonTheDespoiler extends CardImpl {
private static final FilterNonlandCard filter = new FilterNonlandCard();
static {
filter.add(new CastFromZonePredicate(Zone.HAND));
filter.add(AbaddonTheDespoilerPredicate.instance);
}
private static final Hint hint = new ValueHint(
"Total life lost by opponents this turn", OpponentsLostLifeCount.instance
);
public AbaddonTheDespoiler(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{U}{B}{R}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.ASTARTES);
this.subtype.add(SubType.WARRIOR);
this.power = new MageInt(5);
this.toughness = new MageInt(5);
// Trample
this.addAbility(TrampleAbility.getInstance());
// Mark of Chaos Ascendant — During your turn, spells you cast from your hand with mana value X or less have cascade, where X is the total amount of life your opponents have lost this turn.
this.addAbility(new SimpleStaticAbility(new ConditionalContinuousEffect(
new GainAbilityControlledSpellsEffect(new CascadeAbility(false), filter),
MyTurnCondition.instance, "during your turn, spells you cast from " +
"your hand with mana value X or less have cascade, where X is the " +
"total amount of life your opponents have lost this turn"
)).addHint(hint).withFlavorWord("Mark of Chaos Ascendant"));
}
private AbaddonTheDespoiler(final AbaddonTheDespoiler card) {
super(card);
}
@Override
public AbaddonTheDespoiler copy() {
return new AbaddonTheDespoiler(this);
}
}
enum AbaddonTheDespoilerPredicate implements Predicate<MageObject> {
instance;
@Override
public boolean apply(MageObject input, Game game) {
if (input instanceof Card) {
Card card = (Card) input;
return card.getManaValue() <= game
.getState()
.getWatcher(PlayerLostLifeWatcher.class)
.getAllOppLifeLost(card.getOwnerId(), game);
}
return false;
}
} |
Layout: normal
Name: Abandon Hope
Mana Cost: {X}{1}{B}
Cmc: 2.0
Type Line: Sorcery
Oracle Text: As an additional cost to cast this spell, discard X cards.
Look at target opponent's hand and choose X cards from it. That player discards those cards.
Colors: B
Color Identity: B
Rarity: uncommon | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.costs.CostAdjuster;
import mage.abilities.costs.common.DiscardTargetCost;
import mage.abilities.dynamicvalue.common.GetXValue;
import mage.abilities.effects.common.InfoEffect;
import mage.abilities.effects.common.discard.LookTargetHandChooseDiscardEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Zone;
import mage.filter.StaticFilters;
import mage.game.Game;
import mage.target.common.TargetCardInHand;
import mage.target.common.TargetOpponent;
import mage.util.CardUtil;
import java.util.UUID;
public final class AbandonHope extends CardImpl {
public AbandonHope(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{X}{1}{B}");
// As an additional cost to cast Abandon Hope, discard X cards.
Ability ability = new SimpleStaticAbility(
Zone.ALL, new InfoEffect("As an additional cost to cast this spell, discard X cards")
);
ability.setRuleAtTheTop(true);
this.addAbility(ability);
// Look at target opponent's hand and choose X cards from it. That player discards those cards.
this.getSpellAbility().addEffect(new LookTargetHandChooseDiscardEffect(false, GetXValue.instance));
this.getSpellAbility().addTarget(new TargetOpponent());
this.getSpellAbility().setCostAdjuster(AbandonHopeAdjuster.instance);
}
private AbandonHope(final AbandonHope card) {
super(card);
}
@Override
public AbandonHope copy() {
return new AbandonHope(this);
}
}
enum AbandonHopeAdjuster implements CostAdjuster {
instance;
@Override
public void adjustCosts(Ability ability, Game game) {
int xValue = CardUtil.getSourceCostsTag(game, ability, "X", 0);
if (xValue > 0) {
ability.addCost(new DiscardTargetCost(new TargetCardInHand(xValue, xValue, StaticFilters.FILTER_CARD_CARDS)));
}
}
} |
Layout: normal
Name: Abandon Reason
Mana Cost: {2}{R}
Cmc: 3.0
Type Line: Instant
Oracle Text: Up to two target creatures each get +1/+0 and gain first strike until end of turn.
Madness {1}{R} (If you discard this card, discard it into exile. When you do, cast it for its madness cost or put it into your graveyard.)
Colors: R
Color Identity: R
Keywords: Madness
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.continuous.BoostTargetEffect;
import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
import mage.abilities.keyword.FirstStrikeAbility;
import mage.abilities.keyword.MadnessAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.Outcome;
import mage.target.common.TargetCreaturePermanent;
public final class AbandonReason extends CardImpl {
public AbandonReason(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.INSTANT},"{2}{R}");
// Up to two target creatures each get +1/+0 and gain first strike until end of turn.
Effect effect = new BoostTargetEffect(1, 0, Duration.EndOfTurn);
effect.setOutcome(Outcome.Benefit);
effect.setText("Up to two target creatures each get +1/+0");
this.getSpellAbility().addEffect(effect);
effect = new GainAbilityTargetEffect(FirstStrikeAbility.getInstance(), Duration.EndOfTurn, "and gain first strike until end of turn");
this.getSpellAbility().addEffect(effect);
this.getSpellAbility().addTarget(new TargetCreaturePermanent(0, 2));
// Madness {1}{R}
this.addAbility(new MadnessAbility(new ManaCostsImpl<>("{1}{R}")));
}
private AbandonReason(final AbandonReason card) {
super(card);
}
@Override
public AbandonReason copy() {
return new AbandonReason(this);
}
} |
Layout: normal
Name: Abandon the Post
Mana Cost: {1}{R}
Cmc: 2.0
Type Line: Sorcery
Oracle Text: Up to two target creatures can't block this turn.
Flashback {3}{R} (You may cast this card from your graveyard for its flashback cost. Then exile it.)
Colors: R
Color Identity: R
Keywords: Flashback
Rarity: common | package mage.cards.a;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.combat.CantBlockTargetEffect;
import mage.abilities.keyword.FlashbackAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.TimingRule;
import mage.target.common.TargetCreaturePermanent;
import java.util.UUID;
public final class AbandonThePost extends CardImpl {
public AbandonThePost(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{1}{R}");
// Up to two target creatures can't block this turn.
this.getSpellAbility().addEffect(new CantBlockTargetEffect(Duration.EndOfTurn));
this.getSpellAbility().addTarget(new TargetCreaturePermanent(0, 2));
// Flashback {3}{R}
this.addAbility(new FlashbackAbility(this, new ManaCostsImpl<>("{3}{R}")));
}
private AbandonThePost(final AbandonThePost card) {
super(card);
}
@Override
public AbandonThePost copy() {
return new AbandonThePost(this);
}
} |
Layout: normal
Name: Abandoned Outpost
Type Line: Land
Oracle Text: Abandoned Outpost enters tapped.
{T}: Add {W}.
{T}, Sacrifice Abandoned Outpost: Add one mana of any color.
Color Identity: W
Produced Mana: B, G, R, U, W
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.Ability;
import mage.abilities.common.EntersBattlefieldTappedAbility;
import mage.abilities.costs.common.SacrificeSourceCost;
import mage.abilities.mana.AnyColorManaAbility;
import mage.abilities.mana.WhiteManaAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
public final class AbandonedOutpost extends CardImpl {
public AbandonedOutpost(UUID ownerId, CardSetInfo setInfo){
super(ownerId,setInfo,new CardType[]{CardType.LAND},"");
// This enters the battlefield tapped
this.addAbility(new EntersBattlefieldTappedAbility());
// Tap to add {W}
this.addAbility(new WhiteManaAbility());
// Tap to add any color mana. Sacrifice Abandoned Outpost.
Ability ability = new AnyColorManaAbility();
ability.addCost(new SacrificeSourceCost());
this.addAbility(ability);
}
private AbandonedOutpost(final AbandonedOutpost card) {
super(card);
}
@Override
public AbandonedOutpost copy() {
return new AbandonedOutpost(this);
}
} |
Layout: normal
Name: Abandoned Sarcophagus
Mana Cost: {3}
Cmc: 3.0
Type Line: Artifact
Oracle Text: You may cast spells that have a cycling ability from your graveyard.
If a card that has a cycling ability would be put into your graveyard from anywhere and it wasn't cycled, exile it instead.
Rarity: rare | package mage.cards.a;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import mage.abilities.Ability;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.ReplacementEffectImpl;
import mage.abilities.effects.common.asthought.PlayFromNotOwnHandZoneAllEffect;
import mage.abilities.keyword.CyclingAbility;
import mage.cards.*;
import mage.constants.*;
import mage.filter.FilterCard;
import mage.filter.predicate.Predicates;
import mage.filter.predicate.mageobject.AbilityPredicate;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.game.events.ZoneChangeEvent;
import mage.game.permanent.Permanent;
import mage.players.Player;
import mage.watchers.Watcher;
public final class AbandonedSarcophagus extends CardImpl {
private static final FilterCard filter = new FilterCard("nonland cards with cycling");
static {
filter.add(Predicates.not(CardType.LAND.getPredicate()));
filter.add(new AbilityPredicate(CyclingAbility.class));
}
public AbandonedSarcophagus(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT}, "{3}");
// You may cast nonland cards with cycling from your graveyard.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD,
new PlayFromNotOwnHandZoneAllEffect(filter,
Zone.GRAVEYARD, true, TargetController.YOU, Duration.WhileOnBattlefield)
.setText("You may cast nonland cards with cycling from your graveyard"))
);
// If a card with cycling would be put into your graveyard from anywhere and it wasn't cycled, exile it instead.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new AbandonedSarcophagusReplacementEffect()), new AbandonedSarcophagusWatcher());
}
private AbandonedSarcophagus(final AbandonedSarcophagus card) {
super(card);
}
@Override
public AbandonedSarcophagus copy() {
return new AbandonedSarcophagus(this);
}
}
class AbandonedSarcophagusReplacementEffect extends ReplacementEffectImpl {
AbandonedSarcophagusReplacementEffect() {
super(Duration.WhileOnBattlefield, Outcome.Exile);
staticText = "If a card with cycling would be put into your graveyard from anywhere and it wasn't cycled, exile it instead";
}
private AbandonedSarcophagusReplacementEffect(final AbandonedSarcophagusReplacementEffect effect) {
super(effect);
}
@Override
public AbandonedSarcophagusReplacementEffect copy() {
return new AbandonedSarcophagusReplacementEffect(this);
}
@Override
public boolean replaceEvent(GameEvent event, Ability source, Game game) {
Player controller = game.getPlayer(source.getControllerId());
if (controller == null) {
return false;
}
Permanent permanent = game.getPermanent(event.getTargetId());
if (permanent != null) {
return controller.moveCards(permanent, Zone.EXILED, source, game);
}
Card card = game.getCard(event.getTargetId());
if (card != null) {
return controller.moveCards(card, Zone.EXILED, source, game);
}
return false;
}
@Override
public boolean checksEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.ZONE_CHANGE;
}
@Override
public boolean applies(GameEvent event, Ability source, Game game) {
if (!(((ZoneChangeEvent) event).getToZone() == Zone.GRAVEYARD)) {
return false;
}
Player controller = game.getPlayer(source.getControllerId());
if (controller == null) {
return false;
}
Card card = game.getCard(event.getTargetId());
if (card == null) {
return false;
}
if (!card.isOwnedBy(controller.getId())) {
return false;
}
AbandonedSarcophagusWatcher watcher = game.getState().getWatcher(AbandonedSarcophagusWatcher.class);
if (watcher == null) {
return false;
}
boolean cardHasCycling = false;
for (Ability ability : card.getAbilities(game)) {
if (ability instanceof CyclingAbility) {
cardHasCycling = true;
break;
}
}
Cards cards = watcher.getCardsCycledThisTurn(controller.getId());
boolean cardWasCycledThisTurn = false;
for (Card cardCycledThisTurn : cards.getCards(game)) {
if (cardCycledThisTurn == card) {
cardWasCycledThisTurn = true;
watcher.getCardsCycledThisTurn(controller.getId()).remove(card); //remove reference to the card as it is no longer needed
}
}
return !cardWasCycledThisTurn && cardHasCycling;
}
}
class AbandonedSarcophagusWatcher extends Watcher {
private final Map<UUID, Cards> cycledCardsThisTurn = new HashMap<>();
AbandonedSarcophagusWatcher() {
super(WatcherScope.GAME);
}
@Override
public void watch(GameEvent event, Game game) {
if (event.getType() != GameEvent.EventType.CYCLE_CARD) {
return;
}
Card card = game.getCard(event.getSourceId());
if (card == null) {
return;
}
Player controller = game.getPlayer(event.getPlayerId());
if (controller == null) {
return;
}
if (!card.isOwnedBy(controller.getId())) {
return;
}
Cards c = getCardsCycledThisTurn(event.getPlayerId());
c.add(card);
cycledCardsThisTurn.put(event.getPlayerId(), c);
}
public Cards getCardsCycledThisTurn(UUID playerId) {
return cycledCardsThisTurn.getOrDefault(playerId, new CardsImpl());
}
@Override
public void reset() {
super.reset();
cycledCardsThisTurn.clear();
}
} |
Layout: normal
Name: Abattoir Ghoul
Mana Cost: {3}{B}
Cmc: 4.0
Type Line: Creature — Zombie
Oracle Text: First strike
Whenever a creature dealt damage by Abattoir Ghoul this turn dies, you gain life equal to that creature's toughness.
Power: 3
Toughness: 2
Colors: B
Color Identity: B
Keywords: First strike
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.DealtDamageAndDiedTriggeredAbility;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.keyword.FirstStrikeAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Outcome;
import mage.constants.SubType;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.players.Player;
public final class AbattoirGhoul extends CardImpl {
public AbattoirGhoul(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{B}");
this.subtype.add(SubType.ZOMBIE);
this.power = new MageInt(3);
this.toughness = new MageInt(2);
this.addAbility(FirstStrikeAbility.getInstance());
// Whenever a creature dealt damage by Abattoir Ghoul this turn dies, you gain life equal to that creature's toughness.
this.addAbility(new DealtDamageAndDiedTriggeredAbility(new AbattoirGhoulEffect(), false));
}
private AbattoirGhoul(final AbattoirGhoul card) {
super(card);
}
@Override
public AbattoirGhoul copy() {
return new AbattoirGhoul(this);
}
}
class AbattoirGhoulEffect extends OneShotEffect {
AbattoirGhoulEffect() {
super(Outcome.GainLife);
staticText = "you gain life equal to that creature's toughness";
}
private AbattoirGhoulEffect(final AbattoirGhoulEffect effect) {
super(effect);
}
@Override
public AbattoirGhoulEffect copy() {
return new AbattoirGhoulEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
Permanent creature = getTargetPointer().getFirstTargetPermanentOrLKI(game, source);
if (creature != null) {
int toughness = creature.getToughness().getValue();
if (controller != null) {
controller.gainLife(toughness, game, source);
return true;
}
}
return false;
}
} |
Layout: normal
Name: Abbey Gargoyles
Mana Cost: {2}{W}{W}{W}
Cmc: 5.0
Type Line: Creature — Gargoyle
Oracle Text: Flying, protection from red
Power: 3
Toughness: 4
Colors: W
Color Identity: W
Keywords: Flying, Protection
Digital: True
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.ObjectColor;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.ProtectionAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
public final class AbbeyGargoyles extends CardImpl {
public AbbeyGargoyles(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{2}{W}{W}{W}");
this.subtype.add(SubType.GARGOYLE);
this.power = new MageInt(3);
this.toughness = new MageInt(4);
// Flying
this.addAbility(FlyingAbility.getInstance());
// protection from red
this.addAbility(ProtectionAbility.from(ObjectColor.RED));
}
private AbbeyGargoyles(final AbbeyGargoyles card) {
super(card);
}
@Override
public AbbeyGargoyles copy() {
return new AbbeyGargoyles(this);
}
} |
Layout: normal
Name: Abbey Griffin
Mana Cost: {3}{W}
Cmc: 4.0
Type Line: Creature — Griffin
Oracle Text: Flying, vigilance
Power: 2
Toughness: 2
Colors: W
Color Identity: W
Keywords: Flying, Vigilance
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.VigilanceAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
public final class AbbeyGriffin extends CardImpl {
public AbbeyGriffin(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{W}");
this.subtype.add(SubType.GRIFFIN);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
this.addAbility(FlyingAbility.getInstance());
this.addAbility(VigilanceAbility.getInstance());
}
private AbbeyGriffin(final AbbeyGriffin card) {
super(card);
}
@Override
public AbbeyGriffin copy() {
return new AbbeyGriffin(this);
}
} |
Layout: normal
Name: Abbey Matron
Mana Cost: {2}{W}
Cmc: 3.0
Type Line: Creature — Human Cleric
Oracle Text: {W}, {T}: Abbey Matron gets +0/+3 until end of turn.
Power: 1
Toughness: 3
Colors: W
Color Identity: W
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.common.TapSourceCost;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.continuous.BoostSourceEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.SubType;
import mage.constants.Zone;
public final class AbbeyMatron extends CardImpl {
public AbbeyMatron(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{2}{W}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.CLERIC);
this.power = new MageInt(1);
this.toughness = new MageInt(3);
// {W}, {tap}: Abbey Matron gets +0/+3 until end of turn.
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new BoostSourceEffect(0,3,Duration.EndOfTurn), new ManaCostsImpl<>("{W}"));
ability.addCost(new TapSourceCost());
this.addAbility(ability);
}
private AbbeyMatron(final AbbeyMatron card) {
super(card);
}
@Override
public AbbeyMatron copy() {
return new AbbeyMatron(this);
}
} |
Layout: normal
Name: Abbot of Keral Keep
Mana Cost: {1}{R}
Cmc: 2.0
Type Line: Creature — Human Monk
Oracle Text: Prowess (Whenever you cast a noncreature spell, this creature gets +1/+1 until end of turn.)
When Abbot of Keral Keep enters, exile the top card of your library. Until end of turn, you may play that card.
Power: 2
Toughness: 1
Colors: R
Color Identity: R
Keywords: Prowess
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.common.ExileTopXMayPlayUntilEffect;
import mage.abilities.keyword.ProwessAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
public final class AbbotOfKeralKeep extends CardImpl {
public AbbotOfKeralKeep(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{R}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.MONK);
this.power = new MageInt(2);
this.toughness = new MageInt(1);
// Prowess
this.addAbility(new ProwessAbility());
// When Abbot of Keral Keep enters the battlefield, exile the top card of your library. Until end of turn, you may play that card.
this.addAbility(new EntersBattlefieldTriggeredAbility(new ExileTopXMayPlayUntilEffect(1, Duration.EndOfTurn)
.withTextOptions("that card", false)));
}
private AbbotOfKeralKeep(final AbbotOfKeralKeep card) {
super(card);
}
@Override
public AbbotOfKeralKeep copy() {
return new AbbotOfKeralKeep(this);
}
} |
Layout: normal
Name: Abdel Adrian, Gorion's Ward
Mana Cost: {4}{W}
Cmc: 5.0
Type Line: Legendary Creature — Human Warrior
Oracle Text: When Abdel Adrian, Gorion's Ward enters, exile any number of other nonland permanents you control until Abdel Adrian leaves the battlefield. Create a 1/1 white Soldier creature token for each permanent exiled this way.
Choose a Background (You can have a Background as a second commander.)
Power: 4
Toughness: 4
Colors: W
Color Identity: W
Keywords: Choose a background
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.ChooseABackgroundAbility;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.common.delayed.OnLeaveReturnExiledAbility;
import mage.abilities.effects.OneShotEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.cards.Cards;
import mage.cards.CardsImpl;
import mage.constants.*;
import mage.filter.FilterPermanent;
import mage.filter.common.FilterNonlandPermanent;
import mage.filter.predicate.mageobject.AnotherPredicate;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.game.permanent.token.SoldierToken;
import mage.players.Player;
import mage.target.TargetPermanent;
import mage.util.CardUtil;
import java.util.UUID;
public final class AbdelAdrianGorionsWard extends CardImpl {
public AbdelAdrianGorionsWard(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{4}{W}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.WARRIOR);
this.power = new MageInt(4);
this.toughness = new MageInt(4);
// When Abdel Adrian, Gorion's Ward enters the battlefield, exile any number of other nonland permanents you control until Abdel Adrian leaves the battlefield. Create a 1/1 white Soldier creature token for each permanent exiled this way.
this.addAbility(new EntersBattlefieldTriggeredAbility(new AbdelAdrianGorionsWardEffect()));
// Choose a Background
this.addAbility(ChooseABackgroundAbility.getInstance());
}
private AbdelAdrianGorionsWard(final AbdelAdrianGorionsWard card) {
super(card);
}
@Override
public AbdelAdrianGorionsWard copy() {
return new AbdelAdrianGorionsWard(this);
}
}
class AbdelAdrianGorionsWardEffect extends OneShotEffect {
private static final FilterPermanent filter
= new FilterNonlandPermanent("other nonland permanents you control");
static {
filter.add(AnotherPredicate.instance);
filter.add(TargetController.YOU.getControllerPredicate());
}
AbdelAdrianGorionsWardEffect() {
super(Outcome.Benefit);
staticText = "exile any number of other nonland permanents you control until {this} leaves the battlefield. " +
"Create a 1/1 white Soldier creature token for each permanent exiled this way";
}
private AbdelAdrianGorionsWardEffect(final AbdelAdrianGorionsWardEffect effect) {
super(effect);
}
@Override
public AbdelAdrianGorionsWardEffect copy() {
return new AbdelAdrianGorionsWardEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player player = game.getPlayer(source.getControllerId());
Permanent permanent = source.getSourcePermanentIfItStillExists(game);
if (player == null || permanent == null) {
return false;
}
TargetPermanent target = new TargetPermanent(0, Integer.MAX_VALUE, filter, true);
player.choose(outcome, target, source, game);
Cards cards = new CardsImpl(target.getTargets());
player.moveCardsToExile(
cards.getCards(game), source, game, true,
CardUtil.getExileZoneId(game, source),
CardUtil.getSourceName(game, source)
);
cards.retainZone(Zone.EXILED, game);
int count = cards.size();
if (count > 0) {
new SoldierToken().putOntoBattlefield(count, game, source);
}
game.addDelayedTriggeredAbility(new OnLeaveReturnExiledAbility(), source);
return true;
}
} |
Layout: normal
Name: Abduction
Mana Cost: {2}{U}{U}
Cmc: 4.0
Type Line: Enchantment — Aura
Oracle Text: Enchant creature
When Abduction enters, untap enchanted creature.
You control enchanted creature.
When enchanted creature dies, return that card to the battlefield under its owner's control.
Colors: U
Color Identity: U
Keywords: Enchant
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.abilities.common.DiesAttachedTriggeredAbility;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.common.AttachEffect;
import mage.abilities.effects.common.ReturnToBattlefieldUnderOwnerControlAttachedEffect;
import mage.abilities.effects.common.UntapAttachedEffect;
import mage.abilities.effects.common.continuous.ControlEnchantedEffect;
import mage.abilities.keyword.EnchantAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Outcome;
import mage.constants.SubType;
import mage.constants.Zone;
import mage.target.TargetPermanent;
import mage.target.common.TargetCreaturePermanent;
public final class Abduction extends CardImpl {
public Abduction(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.ENCHANTMENT},"{2}{U}{U}");
this.subtype.add(SubType.AURA);
// Enchant creature
TargetPermanent auraTarget = new TargetCreaturePermanent();
this.getSpellAbility().addTarget(auraTarget);
this.getSpellAbility().addEffect(new AttachEffect(Outcome.GainControl));
this.addAbility(new EnchantAbility(auraTarget));
// When Abduction enters the battlefield, untap enchanted creature.
this.addAbility(new EntersBattlefieldTriggeredAbility(new UntapAttachedEffect()));
// You control enchanted creature.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new ControlEnchantedEffect()));
// When enchanted creature dies, return that card to the battlefield under its owner's control.
this.addAbility(new DiesAttachedTriggeredAbility(new ReturnToBattlefieldUnderOwnerControlAttachedEffect(), "enchanted creature", false));
}
private Abduction(final Abduction card) {
super(card);
}
@Override
public Abduction copy() {
return new Abduction(this);
}
} |
Layout: normal
Name: Aberrant
Mana Cost: {X}{1}{G}
Cmc: 2.0
Type Line: Creature — Tyranid Mutant
Oracle Text: Ravenous (This creature enters with X +1/+1 counters on it. If X is 5 or more, draw a card when it enters.)
Trample
Heavy Power Hammer — Whenever Aberrant deals combat damage to a player, destroy target artifact or enchantment that player controls.
Power: 0
Toughness: 0
Colors: G
Color Identity: G
Keywords: Ravenous, Trample, Heavy Power Hammer
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.DealsCombatDamageToAPlayerTriggeredAbility;
import mage.abilities.effects.common.DestroyTargetEffect;
import mage.abilities.keyword.RavenousAbility;
import mage.abilities.keyword.TrampleAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.filter.common.FilterArtifactOrEnchantmentPermanent;
import mage.target.TargetPermanent;
import mage.target.targetadjustment.DamagedPlayerControlsTargetAdjuster;
import java.util.UUID;
public final class Aberrant extends CardImpl {
private static final FilterArtifactOrEnchantmentPermanent filter
= new FilterArtifactOrEnchantmentPermanent("artifact or enchantment that player controls");
public Aberrant(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{X}{1}{G}");
this.subtype.add(SubType.TYRANID);
this.subtype.add(SubType.MUTANT);
this.power = new MageInt(0);
this.toughness = new MageInt(0);
// Ravenous
this.addAbility(new RavenousAbility());
// Trample
this.addAbility(TrampleAbility.getInstance());
// Heavy Power Hammer -- Whenever Aberrant deals combat damage to a player, destroy target artifact or enchantment that player controls.
Ability ability = new DealsCombatDamageToAPlayerTriggeredAbility(new DestroyTargetEffect(), false, true);
ability.withFlavorWord("Heavy Power Hammer");
ability.addTarget(new TargetPermanent(filter));
ability.setTargetAdjuster(new DamagedPlayerControlsTargetAdjuster());
this.addAbility(ability);
}
private Aberrant(final Aberrant card) {
super(card);
}
@Override
public Aberrant copy() {
return new Aberrant(this);
}
} |
Layout: normal
Name: Aberrant Mind Sorcerer
Mana Cost: {4}{U}
Cmc: 5.0
Type Line: Creature — Human Elf Shaman
Oracle Text: Psionic Spells — When Aberrant Mind Sorcerer enters, choose target instant or sorcery card in your graveyard, then roll a d20.
1—9 | You may put that card on top of your library.
10—20 | Return that card to your hand.
Power: 3
Toughness: 4
Colors: U
Color Identity: U
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.ReturnFromGraveyardToHandTargetEffect;
import mage.abilities.effects.common.RollDieWithResultTableEffect;
import mage.cards.Card;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Outcome;
import mage.constants.SubType;
import mage.filter.StaticFilters;
import mage.game.Game;
import mage.players.Player;
import mage.target.common.TargetCardInYourGraveyard;
import java.util.UUID;
public final class AberrantMindSorcerer extends CardImpl {
public AberrantMindSorcerer(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{4}{U}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.ELF);
this.subtype.add(SubType.SHAMAN);
this.power = new MageInt(3);
this.toughness = new MageInt(4);
// Psionic Spells — When Aberrant Mind Sorcerer enters the battlefield, choose target instant or sorcery card in your graveyard, then roll a d20.
RollDieWithResultTableEffect effect = new RollDieWithResultTableEffect(
20, "choose target instant or sorcery card in your graveyard, then roll a d20"
);
Ability ability = new EntersBattlefieldTriggeredAbility(effect);
ability.addTarget(new TargetCardInYourGraveyard(StaticFilters.FILTER_CARD_INSTANT_OR_SORCERY_FROM_YOUR_GRAVEYARD));
this.addAbility(ability.withFlavorWord("Psionic Spells"));
// 1-9 | You may put that card on top of your library.
effect.addTableEntry(1, 9, new AberrantMindSorcererEffect());
// 10-20 | Return that card to your hand.
effect.addTableEntry(10, 20, new ReturnFromGraveyardToHandTargetEffect().setText("return that card to your hand"));
}
private AberrantMindSorcerer(final AberrantMindSorcerer card) {
super(card);
}
@Override
public AberrantMindSorcerer copy() {
return new AberrantMindSorcerer(this);
}
}
class AberrantMindSorcererEffect extends OneShotEffect {
AberrantMindSorcererEffect() {
super(Outcome.Benefit);
staticText = "you may put that card on top of your library";
}
private AberrantMindSorcererEffect(final AberrantMindSorcererEffect effect) {
super(effect);
}
@Override
public AberrantMindSorcererEffect copy() {
return new AberrantMindSorcererEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player player = game.getPlayer(source.getControllerId());
Card card = game.getCard(getTargetPointer().getFirst(game, source));
return player != null
&& card != null
&& player.chooseUse(
outcome, "Put " + card.getName() + " on top of your library?", source, game
) && player.putCardsOnTopOfLibrary(card, game, source, false);
}
} |
Layout: transform
Name: Aberrant Researcher
Mana Cost: {3}{U}
Type Line: Creature — Human Insect
Oracle Text: Flying
At the beginning of your upkeep, mill a card. If an instant or sorcery card was milled this way, transform Aberrant Researcher.
Colors: U
Power: 3
Toughness: 2
Name: Perfected Form
Type Line: Creature — Insect Horror
Oracle Text: Flying
Colors: U
Color Indicator: U
Power: 5
Toughness: 4 | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.BeginningOfUpkeepTriggeredAbility;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.TransformSourceEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.TransformAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.game.Game;
import mage.players.Player;
import java.util.UUID;
public final class AberrantResearcher extends CardImpl {
public AberrantResearcher(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{U}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.INSECT);
this.power = new MageInt(3);
this.toughness = new MageInt(2);
this.secondSideCardClazz = mage.cards.p.PerfectedForm.class;
// Flying
this.addAbility(FlyingAbility.getInstance());
// At the beginning of your upkeep, put the top card of your library into your graveyard. If it's an instant or sorcery card, transform Aberrant Researcher.
this.addAbility(new TransformAbility());
this.addAbility(new BeginningOfUpkeepTriggeredAbility(Zone.BATTLEFIELD, new AberrantResearcherEffect(), TargetController.YOU, false));
}
private AberrantResearcher(final AberrantResearcher card) {
super(card);
}
@Override
public AberrantResearcher copy() {
return new AberrantResearcher(this);
}
}
class AberrantResearcherEffect extends OneShotEffect {
AberrantResearcherEffect() {
super(Outcome.Benefit);
staticText = "mill a card. If an instant or sorcery card was milled this way, transform {this}";
}
private AberrantResearcherEffect(final AberrantResearcherEffect effect) {
super(effect);
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
if (controller == null
|| controller
.millCards(1, source, game)
.getCards(game)
.stream()
.noneMatch(card -> card.isInstantOrSorcery(game))) {
return false;
}
new TransformSourceEffect().apply(game, source);
return true;
}
@Override
public AberrantResearcherEffect copy() {
return new AberrantResearcherEffect(this);
}
} |
Layout: normal
Name: Abeyance
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Instant
Oracle Text: Until end of turn, target player can't cast instant or sorcery spells, and that player can't activate abilities that aren't mana abilities.
Draw a card.
Colors: W
Color Identity: W
Reserved: True
Rarity: rare | package mage.cards.a;
import mage.MageObject;
import mage.abilities.Ability;
import mage.abilities.effects.ContinuousRuleModifyingEffectImpl;
import mage.abilities.effects.common.DrawCardSourceControllerEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.Outcome;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.target.TargetPlayer;
import java.util.Optional;
import java.util.UUID;
public final class Abeyance extends CardImpl {
public Abeyance(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{W}");
// Until end of turn, target player can't cast instant or sorcery
// spells, and that player can't activate abilities that aren't mana abilities.
this.getSpellAbility().addEffect(new AbeyanceEffect());
this.getSpellAbility().addTarget(new TargetPlayer());
// Draw a card.
this.getSpellAbility().addEffect(new DrawCardSourceControllerEffect(1).concatBy("<br>"));
}
private Abeyance(final Abeyance card) {
super(card);
}
@Override
public Abeyance copy() {
return new Abeyance(this);
}
}
class AbeyanceEffect extends ContinuousRuleModifyingEffectImpl {
AbeyanceEffect() {
super(Duration.EndOfTurn, Outcome.Detriment);
staticText = "Until end of turn, target player can't cast instant or sorcery spells, "
+ "and that player can't activate abilities that aren't mana abilities";
}
private AbeyanceEffect(final AbeyanceEffect effect) {
super(effect);
}
@Override
public AbeyanceEffect copy() {
return new AbeyanceEffect(this);
}
@Override
public String getInfoMessage(Ability source, GameEvent event, Game game) {
MageObject mageObject = game.getObject(source);
if (mageObject != null) {
return "You can't cast instant or sorcery spells or activate abilities "
+ "that aren't mana abilities this turn (" + mageObject.getIdName() + ").";
}
return null;
}
@Override
public boolean checksEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.CAST_SPELL
|| event.getType() == GameEvent.EventType.ACTIVATE_ABILITY;
}
@Override
public boolean applies(GameEvent event, Ability source, Game game) {
if (source.getFirstTarget() != null
&& !source.getFirstTarget().equals(event.getPlayerId())) {
return false;
}
MageObject object = game.getObject(event.getSourceId());
if (object == null) {
return false;
}
if (event.getType() == GameEvent.EventType.CAST_SPELL
&& object.isInstantOrSorcery(game)) {
return true;
}
if (event.getType() == GameEvent.EventType.ACTIVATE_ABILITY) {
Optional<Ability> ability = game.getAbility(event.getTargetId(), event.getSourceId());
return ability.isPresent() && !ability.get().isManaActivatedAbility();
}
return false;
}
} |
Layout: normal
Name: Abhorrent Overlord
Mana Cost: {5}{B}{B}
Cmc: 7.0
Type Line: Creature — Demon
Oracle Text: Flying
When Abhorrent Overlord enters, create a number of 1/1 black Harpy creature tokens with flying equal to your devotion to black. (Each {B} in the mana costs of permanents you control counts toward your devotion to black.)
At the beginning of your upkeep, sacrifice a creature.
Power: 6
Toughness: 6
Colors: B
Color Identity: B
Keywords: Flying
Rarity: rare | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.BeginningOfUpkeepTriggeredAbility;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.dynamicvalue.common.DevotionCount;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.CreateTokenEffect;
import mage.abilities.effects.common.SacrificeControllerEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.TargetController;
import mage.filter.StaticFilters;
import mage.game.permanent.token.HarpyToken;
import java.util.UUID;
public final class AbhorrentOverlord extends CardImpl {
public AbhorrentOverlord(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{5}{B}{B}");
this.subtype.add(SubType.DEMON);
this.power = new MageInt(6);
this.toughness = new MageInt(6);
// Flying
this.addAbility(FlyingAbility.getInstance());
// When Abhorrent Overlord enters the battlefield, create a number of 1/1 black Harpy creature tokens with flying equal to your devotion to black.
Effect effect = new CreateTokenEffect(new HarpyToken(), DevotionCount.B);
effect.setText("create a number of 1/1 black Harpy creature tokens with flying equal to your devotion to black. " + DevotionCount.B.getReminder());
this.addAbility(new EntersBattlefieldTriggeredAbility(effect).addHint(DevotionCount.B.getHint()));
// At the beginning of your upkeep, sacrifice a creature.
this.addAbility(new BeginningOfUpkeepTriggeredAbility(new SacrificeControllerEffect(StaticFilters.FILTER_PERMANENT_CREATURE, 1, null), TargetController.YOU, false));
}
private AbhorrentOverlord(final AbhorrentOverlord card) {
super(card);
}
@Override
public AbhorrentOverlord copy() {
return new AbhorrentOverlord(this);
}
} |
Layout: normal
Name: Abiding Grace
Mana Cost: {2}{W}
Cmc: 3.0
Type Line: Enchantment
Oracle Text: At the beginning of your end step, choose one —
• You gain 1 life.
• Return target creature card with mana value 1 from your graveyard to the battlefield.
Colors: W
Color Identity: W
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.abilities.Ability;
import mage.abilities.Mode;
import mage.abilities.common.BeginningOfYourEndStepTriggeredAbility;
import mage.abilities.effects.common.GainLifeEffect;
import mage.abilities.effects.common.ReturnFromGraveyardToBattlefieldTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.ComparisonType;
import mage.filter.FilterCard;
import mage.filter.predicate.mageobject.ManaValuePredicate;
import mage.target.common.TargetCardInYourGraveyard;
public final class AbidingGrace extends CardImpl {
private static final FilterCard filter = new FilterCard("creature card with mana value 1 from your graveyard");
static {
filter.add(CardType.CREATURE.getPredicate());
filter.add(new ManaValuePredicate(ComparisonType.EQUAL_TO, 1));
}
public AbidingGrace(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{2}{W}");
// At the beginning of your end step, choose one —
// • You gain 1 life.
Ability ability = new BeginningOfYourEndStepTriggeredAbility(new GainLifeEffect(1), false);
// • Return target creature card with mana value 1 from your graveyard to the battlefield.
Mode mode = new Mode(new ReturnFromGraveyardToBattlefieldTargetEffect());
mode.addTarget(new TargetCardInYourGraveyard(filter));
ability.addMode(mode);
this.addAbility(ability);
}
private AbidingGrace(final AbidingGrace card) {
super(card);
}
@Override
public AbidingGrace copy() {
return new AbidingGrace(this);
}
} |
Layout: normal
Name: Abjure
Mana Cost: {U}
Cmc: 1.0
Type Line: Instant
Oracle Text: As an additional cost to cast this spell, sacrifice a blue permanent.
Counter target spell.
Colors: U
Color Identity: U
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.ObjectColor;
import mage.abilities.costs.common.SacrificeTargetCost;
import mage.abilities.effects.common.CounterTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.filter.common.FilterControlledPermanent;
import mage.filter.predicate.mageobject.ColorPredicate;
import mage.target.TargetSpell;
import mage.target.common.TargetControlledPermanent;
public final class Abjure extends CardImpl {
private static final FilterControlledPermanent filter = new FilterControlledPermanent("a blue permanent");
static {
filter.add(new ColorPredicate(ObjectColor.BLUE));
}
public Abjure(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.INSTANT},"{U}");
// As an additional cost to cast Abjure, sacrifice a blue permanent.
this.getSpellAbility().addCost(new SacrificeTargetCost(filter));
// Counter target spell.
this.getSpellAbility().addEffect(new CounterTargetEffect());
this.getSpellAbility().addTarget(new TargetSpell());
}
private Abjure(final Abjure card) {
super(card);
}
@Override
public Abjure copy() {
return new Abjure(this);
}
} |
Layout: normal
Name: Abnormal Endurance
Mana Cost: {1}{B}
Cmc: 2.0
Type Line: Instant
Oracle Text: Until end of turn, target creature gets +2/+0 and gains "When this creature dies, return it to the battlefield tapped under its owner's control."
Colors: B
Color Identity: B
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.common.DiesSourceTriggeredAbility;
import mage.abilities.effects.common.ReturnSourceFromGraveyardToBattlefieldEffect;
import mage.abilities.effects.common.continuous.BoostTargetEffect;
import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.target.common.TargetCreaturePermanent;
public final class AbnormalEndurance extends CardImpl {
public AbnormalEndurance(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{B}");
// Until end of turn, target creature gets +2/+0 and gains "When this creature dies, return it to the battlefield tapped under its owner's control."
getSpellAbility().addTarget(new TargetCreaturePermanent());
getSpellAbility().addEffect(new BoostTargetEffect(2, 0, Duration.EndOfTurn)
.setText("Until end of turn, target creature gets +2/+0")
);
getSpellAbility().addEffect(new GainAbilityTargetEffect(
new DiesSourceTriggeredAbility(new ReturnSourceFromGraveyardToBattlefieldEffect(true, true), false),
Duration.EndOfTurn,
"and gains \"When this creature dies, return it to the battlefield tapped under its owner's control.\""
));
}
private AbnormalEndurance(final AbnormalEndurance card) {
super(card);
}
@Override
public AbnormalEndurance copy() {
return new AbnormalEndurance(this);
}
} |
Layout: normal
Name: Aboleth Spawn
Mana Cost: {2}{U}
Cmc: 3.0
Type Line: Creature — Fish Horror
Oracle Text: Flash
Ward {2}
Probing Telepathy — Whenever a creature entering under an opponent's control causes a triggered ability of that creature to trigger, you may copy that ability. You may choose new targets for the copy.
Power: 2
Toughness: 3
Colors: U
Color Identity: U
Keywords: Probing Telepathy, Ward, Flash
Rarity: rare | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.TriggeredAbility;
import mage.abilities.TriggeredAbilityImpl;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.CopyStackObjectEffect;
import mage.abilities.keyword.FlashAbility;
import mage.abilities.keyword.WardAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.Zone;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.game.permanent.Permanent;
import mage.game.stack.StackObject;
import java.util.UUID;
public final class AbolethSpawn extends CardImpl {
public AbolethSpawn(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{U}");
this.subtype.add(SubType.FISH);
this.subtype.add(SubType.HORROR);
this.power = new MageInt(2);
this.toughness = new MageInt(3);
// Flash
this.addAbility(FlashAbility.getInstance());
// Ward {2}
this.addAbility(new WardAbility(new ManaCostsImpl<>("{2}"), false));
// Whenever a creature entering the battlefield under an opponent's control causes a triggered ability of that creature to trigger,
// you may copy that ability. You may choose new targets for the copy.
this.addAbility(new AbolethSpawnTriggeredAbility().withFlavorWord("Probing Telepathy"));
}
private AbolethSpawn(final AbolethSpawn card) {
super(card);
}
@Override
public AbolethSpawn copy() {
return new AbolethSpawn(this);
}
}
class AbolethSpawnTriggeredAbility extends TriggeredAbilityImpl {
AbolethSpawnTriggeredAbility() {
super(Zone.BATTLEFIELD, new CopyStackObjectEffect(), true);
setTriggerPhrase("Whenever a creature entering the battlefield under an opponent's control causes a triggered ability of that creature to trigger, ");
}
private AbolethSpawnTriggeredAbility(final AbolethSpawnTriggeredAbility ability) {
super(ability);
}
@Override
public boolean checkEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.TRIGGERED_ABILITY;
}
@Override
public boolean checkTrigger(GameEvent event, Game game) {
StackObject stackObject = game.getStack().getStackObject(event.getTargetId());
Permanent permanent = game.getPermanent(event.getSourceId());
if (stackObject == null || permanent == null || !permanent.isCreature(game)) {
return false; // only creatures
}
if (!game.getOpponents(this.getControllerId()).contains(permanent.getControllerId())) {
return false; // only creatures entering under opponent's control
}
Ability stackAbility = stackObject.getStackAbility();
if (!stackAbility.isTriggeredAbility()) {
return false;
}
GameEvent triggerEvent = ((TriggeredAbility) stackAbility).getTriggerEvent();
if (triggerEvent == null || triggerEvent.getType() != GameEvent.EventType.ENTERS_THE_BATTLEFIELD) {
return false; // only ETB triggers
}
if (triggerEvent.getSourceId() != permanent.getId()) {
return false; // only triggered abilities of that creature
}
// CopyStackObjectEffect needs value set
getEffects().setValue("stackObject", stackObject);
return true;
}
@Override
public AbolethSpawnTriggeredAbility copy() {
return new AbolethSpawnTriggeredAbility(this);
}
} |
Layout: normal
Name: Abolish
Mana Cost: {1}{W}{W}
Cmc: 3.0
Type Line: Instant
Oracle Text: You may discard a Plains card rather than pay this spell's mana cost.
Destroy target artifact or enchantment.
Colors: W
Color Identity: W
Rarity: uncommon | package mage.cards.a;
import mage.abilities.costs.AlternativeCostSourceAbility;
import mage.abilities.costs.common.DiscardTargetCost;
import mage.abilities.effects.common.DestroyTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.filter.FilterCard;
import mage.filter.StaticFilters;
import mage.target.TargetPermanent;
import mage.target.common.TargetCardInHand;
import java.util.UUID;
public final class Abolish extends CardImpl {
private static final FilterCard filterCost = new FilterCard("Plains card");
static {
filterCost.add(SubType.PLAINS.getPredicate());
}
public Abolish(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{W}{W}");
// You may discard a Plains card rather than pay Abolish's mana cost.
this.addAbility(new AlternativeCostSourceAbility(new DiscardTargetCost(new TargetCardInHand(filterCost))));
// Destroy target artifact or enchantment.
this.getSpellAbility().addEffect(new DestroyTargetEffect());
this.getSpellAbility().addTarget(new TargetPermanent(StaticFilters.FILTER_PERMANENT_ARTIFACT_OR_ENCHANTMENT));
}
private Abolish(final Abolish card) {
super(card);
}
@Override
public Abolish copy() {
return new Abolish(this);
}
} |
Layout: transform
Name: Voldaren Pariah
Mana Cost: {3}{B}{B}
Type Line: Creature — Vampire Horror
Oracle Text: Flying
Sacrifice three other creatures: Transform Voldaren Pariah.
Madness {B}{B}{B} (If you discard this card, discard it into exile. When you do, cast it for its madness cost or put it into your graveyard.)
Colors: B
Power: 3
Toughness: 3
Name: Abolisher of Bloodlines
Type Line: Creature — Eldrazi Vampire
Oracle Text: Flying
When this creature transforms into Abolisher of Bloodlines, target opponent sacrifices three creatures.
Power: 6
Toughness: 5 | package mage.cards.v;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.common.SacrificeTargetCost;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.TransformSourceEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.MadnessAbility;
import mage.abilities.keyword.TransformAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.Zone;
import mage.filter.common.FilterControlledCreaturePermanent;
import mage.filter.predicate.mageobject.AnotherPredicate;
import mage.target.common.TargetControlledPermanent;
public final class VoldarenPariah extends CardImpl {
private static final FilterControlledCreaturePermanent filter = new FilterControlledCreaturePermanent("other creatures");
static {
filter.add(AnotherPredicate.instance);
}
public VoldarenPariah(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{B}{B}");
this.subtype.add(SubType.VAMPIRE);
this.subtype.add(SubType.HORROR);
this.power = new MageInt(3);
this.toughness = new MageInt(3);
this.secondSideCardClazz = mage.cards.a.AbolisherOfBloodlines.class;
// Flying
this.addAbility(FlyingAbility.getInstance());
// Sacrifice three other creatures: Transform Voldaren Pariah.
this.addAbility(new TransformAbility());
this.addAbility(new SimpleActivatedAbility(Zone.BATTLEFIELD, new TransformSourceEffect(),
new SacrificeTargetCost(3, filter)));
// Madness {B}{B}{B}
this.addAbility(new MadnessAbility(new ManaCostsImpl<>("{B}{B}{B}")));
}
private VoldarenPariah(final VoldarenPariah card) {
super(card);
}
@Override
public VoldarenPariah copy() {
return new VoldarenPariah(this);
}
} |
Layout: normal
Name: Abominable Treefolk
Mana Cost: {2}{G}{U}
Cmc: 4.0
Type Line: Snow Creature — Treefolk
Oracle Text: Trample
Abominable Treefolk's power and toughness are each equal to the number of snow permanents you control.
When Abominable Treefolk enters, tap target creature an opponent controls. That creature doesn't untap during its controller's next untap step.
Power: *
Toughness: *
Colors: G, U
Color Identity: G, U
Keywords: Trample
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.dynamicvalue.DynamicValue;
import mage.abilities.dynamicvalue.common.PermanentsOnBattlefieldCount;
import mage.abilities.effects.common.DontUntapInControllersNextUntapStepTargetEffect;
import mage.abilities.effects.common.TapTargetEffect;
import mage.abilities.effects.common.continuous.SetBasePowerToughnessSourceEffect;
import mage.abilities.keyword.TrampleAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.filter.FilterPermanent;
import mage.filter.common.FilterControlledPermanent;
import mage.target.common.TargetOpponentsCreaturePermanent;
import java.util.UUID;
public final class AbominableTreefolk extends CardImpl {
private static final FilterPermanent filter = new FilterControlledPermanent("snow permanents you control");
static {
filter.add(SuperType.SNOW.getPredicate());
}
private static final DynamicValue xValue = new PermanentsOnBattlefieldCount(filter);
public AbominableTreefolk(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{G}{U}");
this.supertype.add(SuperType.SNOW);
this.subtype.add(SubType.TREEFOLK);
this.power = new MageInt(0);
this.toughness = new MageInt(0);
// Trample
this.addAbility(TrampleAbility.getInstance());
// Abominable Treefolk's power and toughness are each equal to the number of snow permanents you control.
this.addAbility(new SimpleStaticAbility(
Zone.ALL, new SetBasePowerToughnessSourceEffect(xValue)
));
// When Abominable Treefolk enters the battlefield, tap target creature an opponent controls. That creature doesn't untap during its controller's next untap step.
Ability ability = new EntersBattlefieldTriggeredAbility(new TapTargetEffect(), false);
ability.addEffect(new DontUntapInControllersNextUntapStepTargetEffect("That creature"));
ability.addTarget(new TargetOpponentsCreaturePermanent());
this.addAbility(ability);
}
private AbominableTreefolk(final AbominableTreefolk card) {
super(card);
}
@Override
public AbominableTreefolk copy() {
return new AbominableTreefolk(this);
}
} |
Layout: normal
Name: Abomination
Mana Cost: {3}{B}{B}
Cmc: 5.0
Type Line: Creature — Horror
Oracle Text: Whenever Abomination blocks or becomes blocked by a green or white creature, destroy that creature at end of combat.
Power: 2
Toughness: 6
Colors: B
Color Identity: B
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.ObjectColor;
import mage.abilities.common.BlocksOrBlockedByCreatureSourceTriggeredAbility;
import mage.abilities.common.delayed.AtTheEndOfCombatDelayedTriggeredAbility;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.CreateDelayedTriggeredAbilityEffect;
import mage.abilities.effects.common.DestroyTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.filter.common.FilterCreaturePermanent;
import mage.filter.predicate.Predicates;
import mage.filter.predicate.mageobject.ColorPredicate;
public final class Abomination extends CardImpl {
private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("green or white creature");
static {
filter.add(Predicates.or(new ColorPredicate(ObjectColor.GREEN), new ColorPredicate(ObjectColor.WHITE)));
}
public Abomination(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{B}{B}");
this.subtype.add(SubType.HORROR);
this.power = new MageInt(2);
this.toughness = new MageInt(6);
// Whenever Abomination blocks or becomes blocked by a green or white creature, destroy that creature at end of combat.
Effect effect = new CreateDelayedTriggeredAbilityEffect(new AtTheEndOfCombatDelayedTriggeredAbility(new DestroyTargetEffect()), true);
effect.setText("destroy that creature at end of combat");
this.addAbility(new BlocksOrBlockedByCreatureSourceTriggeredAbility(effect, filter));
}
private Abomination(final Abomination card) {
super(card);
}
@Override
public Abomination copy() {
return new Abomination(this);
}
} |
Layout: normal
Name: Abomination of Gudul
Mana Cost: {3}{B}{G}{U}
Cmc: 6.0
Type Line: Creature — Horror
Oracle Text: Flying
Whenever Abomination of Gudul deals combat damage to a player, you may draw a card. If you do, discard a card.
Morph {2}{B}{G}{U} (You may cast this card face down as a 2/2 creature for {3}. Turn it face up any time for its morph cost.)
Power: 3
Toughness: 4
Colors: B, G, U
Color Identity: B, G, U
Keywords: Flying, Morph
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.DealsCombatDamageToAPlayerTriggeredAbility;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.DrawDiscardControllerEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.MorphAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
public final class AbominationOfGudul extends CardImpl {
public AbominationOfGudul(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{B}{G}{U}");
this.subtype.add(SubType.HORROR);
this.power = new MageInt(3);
this.toughness = new MageInt(4);
// Flying
this.addAbility(FlyingAbility.getInstance());
// Whenever Abomination of Gudul deals combat damage to a player, you may draw a card. If you do, discard a card.
Effect effect = new DrawDiscardControllerEffect(1,1);
effect.setText("you may draw a card. If you do, discard a card");
this.addAbility(new DealsCombatDamageToAPlayerTriggeredAbility(effect, true));
// Morph 2BGU
this.addAbility(new MorphAbility(this, new ManaCostsImpl<>("{2}{B}{G}{U}")));
}
private AbominationOfGudul(final AbominationOfGudul card) {
super(card);
}
@Override
public AbominationOfGudul copy() {
return new AbominationOfGudul(this);
}
} |
Layout: normal
Name: Abomination of Llanowar
Mana Cost: {1}{B}{G}
Cmc: 3.0
Type Line: Legendary Creature — Elf Horror
Oracle Text: Vigilance; menace (This creature can't be blocked except by two or more creatures.)
Abomination of Llanowar's power and toughness are each equal to the number of Elves you control plus the number of Elf cards in your graveyard.
Power: *
Toughness: *
Colors: B, G
Color Identity: B, G
Keywords: Vigilance, Menace
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.dynamicvalue.AdditiveDynamicValue;
import mage.abilities.dynamicvalue.DynamicValue;
import mage.abilities.dynamicvalue.common.CardsInControllerGraveyardCount;
import mage.abilities.dynamicvalue.common.PermanentsOnBattlefieldCount;
import mage.abilities.effects.common.continuous.SetBasePowerToughnessSourceEffect;
import mage.abilities.keyword.MenaceAbility;
import mage.abilities.keyword.VigilanceAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.filter.FilterCard;
import mage.filter.FilterPermanent;
import mage.filter.common.FilterControlledPermanent;
import java.util.UUID;
public final class AbominationOfLlanowar extends CardImpl {
private static final FilterPermanent filter
= new FilterControlledPermanent(SubType.ELF, "Elves you control");
private static final FilterCard filter2
= new FilterCard("plus the number of Elf cards");
static {
filter2.add(SubType.ELF.getPredicate());
}
private static final DynamicValue xValue = new AdditiveDynamicValue(
new PermanentsOnBattlefieldCount(filter),
new CardsInControllerGraveyardCount(filter2)
);
public AbominationOfLlanowar(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{B}{G}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.ELF);
this.subtype.add(SubType.HORROR);
this.power = new MageInt(0);
this.toughness = new MageInt(0);
// Vigilance
this.addAbility(VigilanceAbility.getInstance());
// Menace
this.addAbility(new MenaceAbility());
// Abomination of Llanowar's power and toughness are each equal to the number of Elves you control plus the number of Elf cards in your graveyard.
this.addAbility(new SimpleStaticAbility(
Zone.ALL, new SetBasePowerToughnessSourceEffect(xValue)
));
}
private AbominationOfLlanowar(final AbominationOfLlanowar card) {
super(card);
}
@Override
public AbominationOfLlanowar copy() {
return new AbominationOfLlanowar(this);
}
} |
Layout: normal
Name: Aboroth
Mana Cost: {4}{G}{G}
Cmc: 6.0
Type Line: Creature — Elemental
Oracle Text: Cumulative upkeep—Put a -1/-1 counter on Aboroth. (At the beginning of your upkeep, put an age counter on this permanent, then sacrifice it unless you pay its upkeep cost for each age counter on it.)
Power: 9
Toughness: 9
Colors: G
Color Identity: G
Keywords: Cumulative upkeep
Reserved: True
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.costs.common.PutCountersSourceCost;
import mage.abilities.keyword.CumulativeUpkeepAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.counters.CounterType;
public final class Aboroth extends CardImpl {
public Aboroth(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{4}{G}{G}");
this.subtype.add(SubType.ELEMENTAL);
this.power = new MageInt(9);
this.toughness = new MageInt(9);
// Cumulative upkeep-Put a -1/-1 counter on Aboroth.
this.addAbility(new CumulativeUpkeepAbility(new PutCountersSourceCost(CounterType.M1M1.createInstance())));
}
private Aboroth(final Aboroth card) {
super(card);
}
@Override
public Aboroth copy() {
return new Aboroth(this);
}
} |
Layout: normal
Name: Aboshan, Cephalid Emperor
Mana Cost: {4}{U}{U}
Cmc: 6.0
Type Line: Legendary Creature — Octopus Noble
Oracle Text: Tap an untapped Octopus you control: Tap target permanent.
{U}{U}{U}: Tap all creatures without flying.
Power: 3
Toughness: 3
Colors: U
Color Identity: U
Rarity: rare | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.common.TapTargetCost;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.TapAllEffect;
import mage.abilities.effects.common.TapTargetEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.SuperType;
import mage.constants.Zone;
import mage.filter.common.FilterControlledPermanent;
import mage.filter.common.FilterCreaturePermanent;
import mage.filter.predicate.Predicates;
import mage.filter.predicate.mageobject.AbilityPredicate;
import mage.target.TargetPermanent;
import mage.target.common.TargetControlledPermanent;
import java.util.UUID;
public final class AboshanCephalidEmperor extends CardImpl {
static final FilterControlledPermanent filter1 = new FilterControlledPermanent("untapped Octopus you control");
static final FilterCreaturePermanent filter2 = new FilterCreaturePermanent("creatures without flying");
static {
filter1.add(SubType.OCTOPUS.getPredicate());
filter2.add(Predicates.not(new AbilityPredicate(FlyingAbility.class)));
}
public AboshanCephalidEmperor(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{4}{U}{U}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.OCTOPUS, SubType.NOBLE);
this.power = new MageInt(3);
this.toughness = new MageInt(3);
// Tap an untapped Octopus you control: Tap target permanent.
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new TapTargetEffect(), new TapTargetCost(new TargetControlledPermanent(1, filter1)));
ability.addTarget(new TargetPermanent());
this.addAbility(ability);
// {U}{U}{U}: Tap all creatures without flying.
this.addAbility(new SimpleActivatedAbility(Zone.BATTLEFIELD, new TapAllEffect(filter2), new ManaCostsImpl<>("{U}{U}{U}")));
}
private AboshanCephalidEmperor(final AboshanCephalidEmperor card) {
super(card);
}
@Override
public AboshanCephalidEmperor copy() {
return new AboshanCephalidEmperor(this);
}
} |
Layout: normal
Name: Aboshan's Desire
Mana Cost: {U}
Cmc: 1.0
Type Line: Enchantment — Aura
Oracle Text: Enchant creature
Enchanted creature has flying.
Threshold — Enchanted creature has shroud as long as seven or more cards are in your graveyard. (It can't be the target of spells or abilities.)
Colors: U
Color Identity: U
Keywords: Enchant, Threshold
Rarity: common | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.condition.common.ThresholdCondition;
import mage.abilities.decorator.ConditionalContinuousEffect;
import mage.abilities.effects.common.AttachEffect;
import mage.abilities.effects.common.continuous.GainAbilityAttachedEffect;
import mage.abilities.keyword.EnchantAbility;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.ShroudAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.target.TargetPermanent;
import mage.target.common.TargetCreaturePermanent;
import java.util.UUID;
public final class AboshansDesire extends CardImpl {
public AboshansDesire(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{U}");
this.subtype.add(SubType.AURA);
// Enchant creature
TargetPermanent auraTarget = new TargetCreaturePermanent();
this.getSpellAbility().addTarget(auraTarget);
this.getSpellAbility().addEffect(new AttachEffect(Outcome.AddAbility));
Ability ability = new EnchantAbility(auraTarget);
this.addAbility(ability);
// Enchanted creature has flying.
this.addAbility(new SimpleStaticAbility(new GainAbilityAttachedEffect(
FlyingAbility.getInstance(), AttachmentType.AURA, Duration.WhileOnBattlefield
)));
// Threshold - Enchanted creature has shroud as long as seven or more cards are in your graveyard.
this.addAbility(new SimpleStaticAbility(new ConditionalContinuousEffect(
new GainAbilityAttachedEffect(ShroudAbility.getInstance(), AttachmentType.AURA, Duration.WhileOnBattlefield),
ThresholdCondition.instance, "enchanted creature has shroud as long as seven or more cards are in your graveyard"
)).setAbilityWord(AbilityWord.THRESHOLD));
}
private AboshansDesire(final AboshansDesire card) {
super(card);
}
@Override
public AboshansDesire copy() {
return new AboshansDesire(this);
}
} |
Layout: normal
Name: About Face
Mana Cost: {R}
Cmc: 1.0
Type Line: Instant
Oracle Text: Switch target creature's power and toughness until end of turn.
Colors: R
Color Identity: R
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.effects.common.continuous.SwitchPowerToughnessTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.target.common.TargetCreaturePermanent;
public final class AboutFace extends CardImpl {
public AboutFace(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.INSTANT},"{R}");
this.getSpellAbility().addEffect(new SwitchPowerToughnessTargetEffect(Duration.EndOfTurn));
this.getSpellAbility().addTarget(new TargetCreaturePermanent());
}
private AboutFace(final AboutFace card) {
super(card);
}
@Override
public AboutFace copy() {
return new AboutFace(this);
}
} |
Layout: normal
Name: Abrade
Mana Cost: {1}{R}
Cmc: 2.0
Type Line: Instant
Oracle Text: Choose one —
• Abrade deals 3 damage to target creature.
• Destroy target artifact.
Colors: R
Color Identity: R
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.Mode;
import mage.abilities.effects.common.DamageTargetEffect;
import mage.abilities.effects.common.DestroyTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.target.common.TargetArtifactPermanent;
import mage.target.common.TargetCreaturePermanent;
public final class Abrade extends CardImpl {
public Abrade(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{R}");
// Choose one — Abrade deals 3 damage to target creature.;
getSpellAbility().addEffect(new DamageTargetEffect(3));
getSpellAbility().addTarget(new TargetCreaturePermanent());
// Destroy target artifact.
Mode mode = new Mode(new DestroyTargetEffect());
mode.addTarget(new TargetArtifactPermanent());
this.getSpellAbility().addMode(mode);
}
private Abrade(final Abrade card) {
super(card);
}
@Override
public Abrade copy() {
return new Abrade(this);
}
} |
Layout: normal
Name: Abraded Bluffs
Type Line: Land — Desert
Oracle Text: Abraded Bluffs enters tapped.
When Abraded Bluffs enters, it deals 1 damage to target opponent.
{T}: Add {R} or {W}.
Color Identity: R, W
Produced Mana: R, W
Rarity: common | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.common.EntersBattlefieldTappedAbility;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.common.DamageTargetEffect;
import mage.abilities.mana.RedManaAbility;
import mage.abilities.mana.WhiteManaAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.target.common.TargetOpponent;
import java.util.UUID;
public final class AbradedBluffs extends CardImpl {
public AbradedBluffs(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.LAND}, "");
this.subtype.add(SubType.DESERT);
// Abraded Bluffs enters the battlefield tapped.
this.addAbility(new EntersBattlefieldTappedAbility());
// When Abraded Bluffs enters the battlefield, it deals 1 damage to target opponent.
Ability ability = new EntersBattlefieldTriggeredAbility(new DamageTargetEffect(1, "it"));
ability.addTarget(new TargetOpponent());
this.addAbility(ability);
// {T}: Add {R} or {W}.
this.addAbility(new RedManaAbility());
this.addAbility(new WhiteManaAbility());
}
private AbradedBluffs(final AbradedBluffs card) {
super(card);
}
@Override
public AbradedBluffs copy() {
return new AbradedBluffs(this);
}
} |
Layout: normal
Name: Abrupt Decay
Mana Cost: {B}{G}
Cmc: 2.0
Type Line: Instant
Oracle Text: This spell can't be countered.
Destroy target nonland permanent with mana value 3 or less.
Colors: B, G
Color Identity: B, G
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.abilities.common.CantBeCounteredSourceAbility;
import mage.abilities.effects.common.DestroyTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.ComparisonType;
import mage.filter.common.FilterNonlandPermanent;
import mage.filter.predicate.mageobject.ManaValuePredicate;
import mage.target.common.TargetNonlandPermanent;
public final class AbruptDecay extends CardImpl {
private static final FilterNonlandPermanent filter = new FilterNonlandPermanent("nonland permanent with mana value 3 or less");
static {
filter.add(new ManaValuePredicate(ComparisonType.FEWER_THAN, 4));
}
public AbruptDecay(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.INSTANT},"{B}{G}");
// This spell can't be countered.
this.addAbility(new CantBeCounteredSourceAbility().setRuleAtTheTop(true));
// Destroy target nonland permanent with converted mana cost 3 or less.
this.getSpellAbility().addEffect(new DestroyTargetEffect());
this.getSpellAbility().addTarget(new TargetNonlandPermanent(filter));
}
private AbruptDecay(final AbruptDecay card) {
super(card);
}
@Override
public AbruptDecay copy() {
return new AbruptDecay(this);
}
} |
Layout: normal
Name: Absolute Grace
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Enchantment
Oracle Text: All creatures have protection from black.
Colors: W
Color Identity: W
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.ObjectColor;
import mage.abilities.Ability;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.common.continuous.GainAbilityAllEffect;
import mage.abilities.keyword.ProtectionAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.filter.StaticFilters;
public final class AbsoluteGrace extends CardImpl {
public AbsoluteGrace(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{1}{W}");
// All creatures have protection from black.
Ability ability = ProtectionAbility.from(ObjectColor.BLACK);
this.addAbility(new SimpleStaticAbility(new GainAbilityAllEffect(ability, Duration.WhileOnBattlefield,
StaticFilters.FILTER_PERMANENT_ALL_CREATURES, false)));
}
private AbsoluteGrace(final AbsoluteGrace card) {
super(card);
}
@Override
public AbsoluteGrace copy() {
return new AbsoluteGrace(this);
}
} |
Layout: normal
Name: Absolute Law
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Enchantment
Oracle Text: All creatures have protection from red.
Colors: W
Color Identity: W
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.ObjectColor;
import mage.abilities.Ability;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.common.continuous.GainAbilityAllEffect;
import mage.abilities.keyword.ProtectionAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.filter.StaticFilters;
public final class AbsoluteLaw extends CardImpl {
public AbsoluteLaw(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{1}{W}");
Ability ability = ProtectionAbility.from(ObjectColor.RED);
this.addAbility(new SimpleStaticAbility(new GainAbilityAllEffect(ability, Duration.WhileOnBattlefield,
StaticFilters.FILTER_PERMANENT_ALL_CREATURES, false)));
}
private AbsoluteLaw(final AbsoluteLaw card) {
super(card);
}
@Override
public AbsoluteLaw copy() {
return new AbsoluteLaw(this);
}
} |
Layout: normal
Name: Absolver Thrull
Mana Cost: {3}{W}
Cmc: 4.0
Type Line: Creature — Thrull Cleric
Oracle Text: Haunt (When this creature dies, exile it haunting target creature.)
When Absolver Thrull enters or the creature it haunts dies, destroy target enchantment.
Power: 2
Toughness: 3
Colors: W
Color Identity: W
Keywords: Haunt
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.effects.common.DestroyTargetEffect;
import mage.abilities.keyword.HauntAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.target.common.TargetEnchantmentPermanent;
public final class AbsolverThrull extends CardImpl {
public AbsolverThrull(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{W}");
this.subtype.add(SubType.THRULL);
this.subtype.add(SubType.CLERIC);
this.power = new MageInt(2);
this.toughness = new MageInt(3);
// Haunt (When this creature dies, exile it haunting target creature.)
// When Absolver Thrull enters the battlefield or the creature it haunts dies, destroy target enchantment.
Ability ability = new HauntAbility(this, new DestroyTargetEffect());
ability.addTarget(new TargetEnchantmentPermanent());
this.addAbility(ability);
}
private AbsolverThrull(final AbsolverThrull card) {
super(card);
}
@Override
public AbsolverThrull copy() {
return new AbsolverThrull(this);
}
} |
Layout: normal
Name: Absolving Lammasu
Mana Cost: {4}{W}
Cmc: 5.0
Type Line: Creature — Lammasu
Oracle Text: Flying
When Absolving Lammasu enters, all suspected creatures are no longer suspected.
When Absolving Lammasu dies, you gain 3 life and suspect up to one target creature an opponent controls. (A suspected creature has menace and can't block.)
Power: 4
Toughness: 3
Colors: W
Color Identity: W
Keywords: Flying
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.DiesSourceTriggeredAbility;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.GainLifeEffect;
import mage.abilities.effects.common.SuspectTargetEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Outcome;
import mage.constants.SubType;
import mage.filter.StaticFilters;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.target.common.TargetOpponentsCreaturePermanent;
import java.util.UUID;
public final class AbsolvingLammasu extends CardImpl {
public AbsolvingLammasu(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{4}{W}");
this.subtype.add(SubType.LAMMASU);
this.power = new MageInt(4);
this.toughness = new MageInt(3);
// Flying
this.addAbility(FlyingAbility.getInstance());
// When Absolving Lammasu enters the battlefield, all suspected creatures are no longer suspected.
this.addAbility(new EntersBattlefieldTriggeredAbility(new AbsolvingLammasuEffect()));
// When Absolving Lammasu dies, you gain 3 life and suspect up to one target creature an opponent controls.
Ability ability = new DiesSourceTriggeredAbility(new GainLifeEffect(3));
ability.addEffect(new SuspectTargetEffect().concatBy("and"));
ability.addTarget(new TargetOpponentsCreaturePermanent(0, 1));
this.addAbility(ability);
}
private AbsolvingLammasu(final AbsolvingLammasu card) {
super(card);
}
@Override
public AbsolvingLammasu copy() {
return new AbsolvingLammasu(this);
}
}
class AbsolvingLammasuEffect extends OneShotEffect {
AbsolvingLammasuEffect() {
super(Outcome.Benefit);
staticText = "all suspected creatures are no longer suspected";
}
private AbsolvingLammasuEffect(final AbsolvingLammasuEffect effect) {
super(effect);
}
@Override
public AbsolvingLammasuEffect copy() {
return new AbsolvingLammasuEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
for (Permanent permanent : game.getBattlefield().getActivePermanents(
StaticFilters.FILTER_PERMANENT_CREATURE,
source.getControllerId(), source, game
)) {
if (permanent.isSuspected()) {
permanent.setSuspected(false, game, source);
}
}
return true;
}
} |
Layout: normal
Name: Absorb
Mana Cost: {W}{U}{U}
Cmc: 3.0
Type Line: Instant
Oracle Text: Counter target spell. You gain 3 life.
Colors: U, W
Color Identity: U, W
Rarity: rare | package mage.cards.a;
import mage.abilities.effects.common.CounterTargetEffect;
import mage.abilities.effects.common.GainLifeEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.target.TargetSpell;
import java.util.UUID;
public final class Absorb extends CardImpl {
public Absorb(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{W}{U}{U}");
// Counter target spell. You gain 3 life.
this.getSpellAbility().addEffect(new CounterTargetEffect());
this.getSpellAbility().addEffect(new GainLifeEffect(3));
this.getSpellAbility().addTarget(new TargetSpell());
}
private Absorb(final Absorb card) {
super(card);
}
@Override
public Absorb copy() {
return new Absorb(this);
}
} |
Layout: normal
Name: Absorb Identity
Mana Cost: {1}{U}
Cmc: 2.0
Type Line: Instant
Oracle Text: Return target creature to its owner's hand. You may have Shapeshifters you control become copies of that creature until end of turn.
Colors: U
Color Identity: U
Rarity: uncommon
Promo Types: themepack | package mage.cards.a;
import java.util.UUID;
import mage.abilities.Ability;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.ReturnToHandTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.Outcome;
import mage.constants.SubType;
import mage.filter.common.FilterCreaturePermanent;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.players.Player;
import mage.target.common.TargetCreaturePermanent;
import mage.util.functions.EmptyCopyApplier;
public final class AbsorbIdentity extends CardImpl {
public AbsorbIdentity(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{U}");
// Return target creature to its owner's hand.
this.getSpellAbility().addEffect(new ReturnToHandTargetEffect());
// You may have Shapeshifters you control become copies of that creature until end of turn.
this.getSpellAbility().addEffect(new AbsorbIdentityEffect());
this.getSpellAbility().addTarget(new TargetCreaturePermanent());
}
private AbsorbIdentity(final AbsorbIdentity card) {
super(card);
}
@Override
public AbsorbIdentity copy() {
return new AbsorbIdentity(this);
}
}
class AbsorbIdentityEffect extends OneShotEffect {
AbsorbIdentityEffect() {
super(Outcome.Copy);
this.staticText = "You may have Shapeshifters you control become copies of that creature until end of turn.";
}
private AbsorbIdentityEffect(final AbsorbIdentityEffect effect) {
super(effect);
}
@Override
public AbsorbIdentityEffect copy() {
return new AbsorbIdentityEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
Permanent copyFrom = game.getPermanentOrLKIBattlefield(source.getFirstTarget());
if (controller == null || copyFrom == null) {
return false;
}
if (controller.chooseUse(outcome, "Have Shapeshifters you control become copies of "
+ copyFrom.getLogName() + " until end of turn?", source, game)) {
FilterCreaturePermanent filter = new FilterCreaturePermanent("shapeshifter");
filter.add(SubType.SHAPESHIFTER.getPredicate());
for (Permanent copyTo : game.getBattlefield().getAllActivePermanents(filter, controller.getId(), game)) {
game.copyPermanent(Duration.EndOfTurn, copyFrom, copyTo.getId(), source, new EmptyCopyApplier());
}
}
return true;
}
} |
Layout: normal
Name: Absorb Vis
Mana Cost: {6}{B}
Cmc: 7.0
Type Line: Sorcery
Oracle Text: Target player loses 4 life and you gain 4 life.
Basic landcycling {1}{B} ({1}{B}, Discard this card: Search your library for a basic land card, reveal it, put it into your hand, then shuffle.)
Colors: B
Color Identity: B
Keywords: Landcycling, Basic landcycling, Typecycling, Cycling
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.GainLifeEffect;
import mage.abilities.effects.common.LoseLifeTargetEffect;
import mage.abilities.keyword.BasicLandcyclingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.target.TargetPlayer;
public final class AbsorbVis extends CardImpl {
public AbsorbVis(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{6}{B}");
this.getSpellAbility().addEffect(new LoseLifeTargetEffect(4));
this.getSpellAbility().addEffect(new GainLifeEffect(4).setText("and you gain 4 life"));
this.getSpellAbility().addTarget(new TargetPlayer());
this.addAbility(new BasicLandcyclingAbility(new ManaCostsImpl<>("{1}{B}")));
}
private AbsorbVis(final AbsorbVis card) {
super(card);
}
@Override
public AbsorbVis copy() {
return new AbsorbVis(this);
}
} |
Layout: normal
Name: Abstergo Entertainment
Type Line: Legendary Land
Oracle Text: {T}: Add {C}.
{1}, {T}: Add one mana of any color.
{3}, {T}, Exile Abstergo Entertainment: Return up to one target historic card from your graveyard to your hand, then exile all graveyards. (Artifacts, legendaries, and Sagas are historic.)
Produced Mana: B, C, G, R, U, W
Rarity: rare | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.common.ExileSourceCost;
import mage.abilities.costs.common.TapSourceCost;
import mage.abilities.costs.mana.GenericManaCost;
import mage.abilities.effects.common.ExileGraveyardAllPlayersEffect;
import mage.abilities.effects.common.ReturnFromGraveyardToHandTargetEffect;
import mage.abilities.mana.AnyColorManaAbility;
import mage.abilities.mana.ColorlessManaAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SuperType;
import mage.filter.FilterCard;
import mage.filter.common.FilterHistoricCard;
import mage.target.common.TargetCardInYourGraveyard;
import java.util.UUID;
public final class AbstergoEntertainment extends CardImpl {
private static final FilterCard filter = new FilterHistoricCard("historic card from your graveyard");
public AbstergoEntertainment(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.LAND}, "");
this.supertype.add(SuperType.LEGENDARY);
// {T}: Add {C}.
this.addAbility(new ColorlessManaAbility());
// {1}, {T}: Add one mana of any color.
Ability ability = new AnyColorManaAbility(new GenericManaCost(1));
ability.addCost(new TapSourceCost());
this.addAbility(ability);
// {3}, {T}, Exile Abstergo Entertainment: Return up to one target historic card from your graveyard to your hand, then exile all graveyards.
ability = new SimpleActivatedAbility(new ReturnFromGraveyardToHandTargetEffect(), new GenericManaCost(3));
ability.addCost(new TapSourceCost());
ability.addCost(new ExileSourceCost());
ability.addEffect(new ExileGraveyardAllPlayersEffect().concatBy(", then"));
ability.addTarget(new TargetCardInYourGraveyard(0, 1, filter));
this.addAbility(ability);
}
private AbstergoEntertainment(final AbstergoEntertainment card) {
super(card);
}
@Override
public AbstergoEntertainment copy() {
return new AbstergoEntertainment(this);
}
} |
Layout: normal
Name: Abstruse Appropriation
Mana Cost: {2}{W}{B}
Cmc: 4.0
Type Line: Instant
Oracle Text: Devoid (This card has no color.)
Exile target nonland permanent. You may cast that card for as long as it remains exiled, and you may spend colorless mana as though it were mana of any color to cast that spell.
Color Identity: B, W
Keywords: Devoid
Rarity: rare | package mage.cards.a;
import mage.MageObjectReference;
import mage.abilities.Ability;
import mage.abilities.effects.AsThoughEffectImpl;
import mage.abilities.effects.AsThoughManaEffect;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.ExileTargetEffect;
import mage.abilities.keyword.DevoidAbility;
import mage.cards.Card;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.players.ManaPoolItem;
import mage.target.common.TargetNonlandPermanent;
import mage.util.CardUtil;
import java.util.Objects;
import java.util.UUID;
public final class AbstruseAppropriation extends CardImpl {
public AbstruseAppropriation(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{2}{W}{B}");
// Devoid
this.addAbility(new DevoidAbility(this.color));
// Exile target nonland permanent. You may cast that card for as long as it remains exiled, and you may spend colorless mana as though it were mana of any color to cast that spell.
this.getSpellAbility().addTarget(new TargetNonlandPermanent());
this.getSpellAbility().addEffect(new AbstruseAppropriationEffect());
}
private AbstruseAppropriation(final AbstruseAppropriation card) {
super(card);
}
@Override
public AbstruseAppropriation copy() {
return new AbstruseAppropriation(this);
}
}
class AbstruseAppropriationEffect extends OneShotEffect {
AbstruseAppropriationEffect() {
super(Outcome.Exile);
staticText = "Exile target nonland permanent. You may cast that card for as long as it remains exiled, "
+ "and you may spend colorless mana as though it were mana of any color to cast that spell";
}
private AbstruseAppropriationEffect(final AbstruseAppropriationEffect effect) {
super(effect);
}
@Override
public AbstruseAppropriationEffect copy() {
return new AbstruseAppropriationEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Permanent permanent = game.getPermanent(getTargetPointer().getFirst(game, source));
if (permanent == null) {
return false;
}
new ExileTargetEffect()
.setToSourceExileZone(true)
.setTargetPointer(getTargetPointer().copy())
.apply(game, source);
game.processAction();
Card card = game.getCard(getTargetPointer().getFirst(game, source));
if (card == null || !game.getState().getZone(card.getId()).equals(Zone.EXILED)) {
return true;
}
card = card.getMainCard(); // for mdfc
CardUtil.makeCardPlayable(game, source, card, true, Duration.Custom, false);
game.addEffect(new AbstruseAppropriationAsThoughEffect(new MageObjectReference(card, game)), source);
return true;
}
}
class AbstruseAppropriationAsThoughEffect extends AsThoughEffectImpl implements AsThoughManaEffect {
private final MageObjectReference morCard;
public AbstruseAppropriationAsThoughEffect(MageObjectReference mor) {
super(AsThoughEffectType.SPEND_OTHER_MANA, Duration.Custom, Outcome.Benefit);
this.staticText = "You may spend colorless mana as though it were mana of any color to cast that spell";
this.morCard = mor;
}
private AbstruseAppropriationAsThoughEffect(final AbstruseAppropriationAsThoughEffect effect) {
super(effect);
this.morCard = effect.morCard;
}
@Override
public boolean apply(Game game, Ability source) {
return true;
}
@Override
public AbstruseAppropriationAsThoughEffect copy() {
return new AbstruseAppropriationAsThoughEffect(this);
}
@Override
public boolean applies(UUID objectId, Ability source, UUID affectedControllerId, Game game) {
Card currentCard = game.getCard(morCard.getSourceId());
if (currentCard == null || currentCard.getZoneChangeCounter(game) > morCard.getZoneChangeCounter() + 1) {
discard();
return false;
}
Zone zone = game.getState().getZone(currentCard.getId());
if (zone != Zone.STACK && zone != Zone.EXILED) {
discard();
return false;
}
objectId = CardUtil.getMainCardId(game, objectId); // for split cards
return source.isControlledBy(affectedControllerId) && Objects.equals(objectId, currentCard.getId());
}
@Override
public ManaType getAsThoughManaType(ManaType manaType, ManaPoolItem mana, UUID affectedControllerId, Ability source, Game game) {
if (mana.getColorless() > 0) {
return ManaType.COLORLESS;
}
return null;
}
} |
Layout: normal
Name: Abstruse Archaic
Mana Cost: {4}
Cmc: 4.0
Type Line: Creature — Avatar
Oracle Text: Vigilance
{1}, {T}: Copy target activated or triggered ability you control from a colorless source. You may choose new targets for the copy. (Mana abilities can't be targeted.)
Power: 3
Toughness: 4
Keywords: Vigilance
Rarity: rare | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.common.TapSourceCost;
import mage.abilities.costs.mana.GenericManaCost;
import mage.abilities.effects.common.CopyTargetStackObjectEffect;
import mage.abilities.keyword.VigilanceAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.TargetController;
import mage.filter.FilterStackObject;
import mage.filter.predicate.Predicate;
import mage.game.Game;
import mage.game.stack.StackAbility;
import mage.game.stack.StackObject;
import mage.target.common.TargetActivatedOrTriggeredAbility;
import java.util.UUID;
public final class AbstruseArchaic extends CardImpl {
private static final FilterStackObject filter
= new FilterStackObject("activated or triggered ability you control from a colorless source");
static {
filter.add(AbstruseArchaicPredicate.instance);
filter.add(TargetController.YOU.getControllerPredicate());
}
public AbstruseArchaic(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{4}");
this.subtype.add(SubType.AVATAR);
this.power = new MageInt(3);
this.toughness = new MageInt(4);
// Vigilance
this.addAbility(VigilanceAbility.getInstance());
// {1}, {T}: Copy target activated or triggered ability you control from a colorless source. You may choose new targets for the copy.
Ability ability = new SimpleActivatedAbility(new CopyTargetStackObjectEffect(), new GenericManaCost(1));
ability.addCost(new TapSourceCost());
ability.addTarget(new TargetActivatedOrTriggeredAbility(filter));
this.addAbility(ability);
}
private AbstruseArchaic(final AbstruseArchaic card) {
super(card);
}
@Override
public AbstruseArchaic copy() {
return new AbstruseArchaic(this);
}
}
enum AbstruseArchaicPredicate implements Predicate<StackObject> {
instance;
@Override
public boolean apply(StackObject input, Game game) {
return input instanceof StackAbility
&& ((StackAbility) input).getSourceObject(game).getColor(game).isColorless();
}
} |
Layout: normal
Name: Abstruse Interference
Mana Cost: {2}{U}
Cmc: 3.0
Type Line: Instant
Oracle Text: Devoid (This card has no color.)
Counter target spell unless its controller pays {1}. You create a 1/1 colorless Eldrazi Scion creature token. It has "Sacrifice this creature: Add {C}." ({C} represents colorless mana.)
Color Identity: U
Keywords: Devoid
Produced Mana: C
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.costs.mana.GenericManaCost;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.CounterUnlessPaysEffect;
import mage.abilities.effects.common.CreateTokenEffect;
import mage.abilities.keyword.DevoidAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.game.permanent.token.EldraziScionToken;
import mage.target.TargetSpell;
public final class AbstruseInterference extends CardImpl {
public AbstruseInterference(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{2}{U}");
// Devoid
this.addAbility(new DevoidAbility(this.color));
// Counter target spell unless its controller pays {1}.
this.getSpellAbility().addTarget(new TargetSpell());
this.getSpellAbility().addEffect(new CounterUnlessPaysEffect(new GenericManaCost(1)));
// You create a 1/1 colorless Eldrazi Scion creature token. It has "Sacrifice this creature: Add {C}."
Effect effect = new CreateTokenEffect(new EldraziScionToken());
effect.setText("You create a 1/1 colorless Eldrazi Scion creature token. It has \"Sacrifice this creature: Add {C}.\"");
this.getSpellAbility().addEffect(effect);
}
private AbstruseInterference(final AbstruseInterference card) {
super(card);
}
@Override
public AbstruseInterference copy() {
return new AbstruseInterference(this);
}
} |
Layout: normal
Name: Abu Ja'far
Mana Cost: {W}
Cmc: 1.0
Type Line: Creature — Human
Oracle Text: When Abu Ja'far dies, destroy all creatures blocking or blocked by it. They can't be regenerated.
Power: 0
Toughness: 1
Colors: W
Color Identity: W
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.DiesSourceTriggeredAbility;
import mage.abilities.effects.common.DestroyAllEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.filter.FilterPermanent;
import mage.filter.common.FilterCreaturePermanent;
import mage.filter.predicate.permanent.BlockingOrBlockedBySourcePredicate;
import java.util.UUID;
public final class AbuJafar extends CardImpl {
private static final FilterPermanent filter
= new FilterCreaturePermanent("creatures blocking or blocked by it");
static {
filter.add(BlockingOrBlockedBySourcePredicate.EITHER);
}
public AbuJafar(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{W}");
this.subtype.add(SubType.HUMAN);
this.power = new MageInt(0);
this.toughness = new MageInt(1);
// When Abu Ja'far dies, destroy all creatures blocking or blocked by it. They can't be regenerated.
this.addAbility(new DiesSourceTriggeredAbility(new DestroyAllEffect(filter, true), false));
}
private AbuJafar(final AbuJafar card) {
super(card);
}
@Override
public AbuJafar copy() {
return new AbuJafar(this);
}
} |
Layout: normal
Name: Abuelo, Ancestral Echo
Mana Cost: {1}{W}{U}
Cmc: 3.0
Type Line: Legendary Creature — Spirit
Oracle Text: Flying, ward {2}
{1}{W}{U}: Exile another target creature or artifact you control. Return it to the battlefield under its owner's control at the beginning of the next end step.
Power: 2
Toughness: 2
Colors: U, W
Color Identity: U, W
Keywords: Flying, Ward
Rarity: rare | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.ExileReturnBattlefieldNextEndStepTargetEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.WardAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.SuperType;
import mage.filter.StaticFilters;
import mage.target.TargetPermanent;
import java.util.UUID;
public final class AbueloAncestralEcho extends CardImpl {
public AbueloAncestralEcho(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{W}{U}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.SPIRIT);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// Flying
this.addAbility(FlyingAbility.getInstance());
// Ward {2}
this.addAbility(new WardAbility(new ManaCostsImpl<>("{2}"), false));
// {1}{W}{U}: Exile another target creature or artifact you control. Return it to the battlefield under its owner's control at the beginning of the next end step.
Ability ability = new SimpleActivatedAbility(
new ExileReturnBattlefieldNextEndStepTargetEffect().withTextThatCard(false),
new ManaCostsImpl<>("{1}{W}{U}")
);
ability.addTarget(new TargetPermanent(StaticFilters.FILTER_CONTROLLED_ANOTHER_CREATURE_OR_ARTIFACT));
this.addAbility(ability);
}
private AbueloAncestralEcho(final AbueloAncestralEcho card) {
super(card);
}
@Override
public AbueloAncestralEcho copy() {
return new AbueloAncestralEcho(this);
}
} |
Layout: normal
Name: Abuelo's Awakening
Mana Cost: {X}{3}{W}
Cmc: 4.0
Type Line: Sorcery
Oracle Text: Return target artifact or non-Aura enchantment card from your graveyard to the battlefield with X additional +1/+1 counters on it. It's a 1/1 Spirit creature with flying in addition to its other types.
Colors: W
Color Identity: W
Rarity: rare | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.dynamicvalue.common.GetXValue;
import mage.abilities.effects.ContinuousEffectImpl;
import mage.abilities.effects.common.ReturnFromGraveyardToBattlefieldTargetEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.counters.CounterType;
import mage.counters.Counters;
import mage.filter.FilterCard;
import mage.filter.predicate.Predicates;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.target.common.TargetCardInYourGraveyard;
import mage.target.targetpointer.FixedTarget;
import java.util.UUID;
public final class AbuelosAwakening extends CardImpl {
private static final FilterCard filter
= new FilterCard("artifact or non-Aura enchantment card from your graveyard");
static {
filter.add(Predicates.or(
CardType.ARTIFACT.getPredicate(),
Predicates.and(
Predicates.not(SubType.AURA.getPredicate()),
CardType.ENCHANTMENT.getPredicate()
)
));
}
public AbuelosAwakening(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{X}{3}{W}");
// Return target artifact or non-Aura enchantment card from your graveyard to the battlefield with X additional +1/+1 counters on it. It's a 1/1 Spirit creature with flying in addition to its other types.
this.getSpellAbility().addEffect(new AbuelosAwakeningEffect());
this.getSpellAbility().addTarget(new TargetCardInYourGraveyard(filter));
}
private AbuelosAwakening(final AbuelosAwakening card) {
super(card);
}
@Override
public AbuelosAwakening copy() {
return new AbuelosAwakening(this);
}
}
class AbuelosAwakeningEffect extends ReturnFromGraveyardToBattlefieldTargetEffect {
AbuelosAwakeningEffect() {
super();
staticText = "return target artifact or non-Aura enchantment card from your graveyard to the battlefield "
+ "with X additional +1/+1 counters on it. "
+ "It's a 1/1 Spirit creature with flying in addition to its other types";
}
private AbuelosAwakeningEffect(final AbuelosAwakeningEffect effect) {
super(effect);
}
@Override
public AbuelosAwakeningEffect copy() {
return new AbuelosAwakeningEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
int counterAmount = GetXValue.instance.calculate(game, source, this);
for (UUID targetId : getTargetPointer().getTargets(game, source)) {
AbuelosAwakeningContinuousEffect continuousEffect = new AbuelosAwakeningContinuousEffect();
continuousEffect.setTargetPointer(new FixedTarget(targetId, game));
game.addEffect(continuousEffect, source);
if (counterAmount > 0) {
game.setEnterWithCounters(targetId, new Counters().addCounter(CounterType.P1P1.createInstance(counterAmount)));
}
}
return super.apply(game, source);
}
}
class AbuelosAwakeningContinuousEffect extends ContinuousEffectImpl {
AbuelosAwakeningContinuousEffect() {
super(Duration.Custom, Outcome.Neutral);
staticText = "It's a 1/1 Spirit creature with flying in addition to its other types";
}
private AbuelosAwakeningContinuousEffect(final AbuelosAwakeningContinuousEffect effect) {
super(effect);
}
@Override
public AbuelosAwakeningContinuousEffect copy() {
return new AbuelosAwakeningContinuousEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
return false;
}
@Override
public boolean apply(Layer layer, SubLayer sublayer, Ability source, Game game) {
Permanent creature;
if (source.getTargets().getFirstTarget() == null) {
creature = game.getPermanent(getTargetPointer().getFirst(game, source));
} else {
creature = game.getPermanent(source.getTargets().getFirstTarget());
if (creature == null) {
creature = game.getPermanentEntering(source.getTargets().getFirstTarget());
}
}
if (creature == null) {
this.used = true;
return false;
}
switch (layer) {
case TypeChangingEffects_4:
creature.addCardType(game, CardType.CREATURE);
creature.addSubType(game, SubType.SPIRIT);
break;
case AbilityAddingRemovingEffects_6:
creature.addAbility(FlyingAbility.getInstance(), source.getSourceId(), game);
break;
case PTChangingEffects_7:
if (sublayer == SubLayer.SetPT_7b) {
creature.getPower().setModifiedBaseValue(1);
creature.getToughness().setModifiedBaseValue(1);
}
break;
}
return true;
}
@Override
public boolean hasLayer(Layer layer) {
return layer == Layer.TypeChangingEffects_4 ||
layer == Layer.AbilityAddingRemovingEffects_6 ||
layer == Layer.PTChangingEffects_7;
}
} |
Layout: normal
Name: Abuna Acolyte
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Creature — Cat Cleric
Oracle Text: {T}: Prevent the next 1 damage that would be dealt to any target this turn.
{T}: Prevent the next 2 damage that would be dealt to target artifact creature this turn.
Power: 1
Toughness: 1
Colors: W
Color Identity: W
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.common.TapSourceCost;
import mage.abilities.effects.common.PreventDamageToTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.SubType;
import mage.constants.Zone;
import mage.filter.common.FilterCreaturePermanent;
import mage.target.common.TargetAnyTarget;
import mage.target.common.TargetCreaturePermanent;
public final class AbunaAcolyte extends CardImpl {
private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("artifact creature");
static {
filter.add(CardType.ARTIFACT.getPredicate());
}
public AbunaAcolyte(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{1}{W}");
this.subtype.add(SubType.CAT);
this.subtype.add(SubType.CLERIC);
this.power = new MageInt(1);
this.toughness = new MageInt(1);
Ability ability1 = new SimpleActivatedAbility(Zone.BATTLEFIELD, new PreventDamageToTargetEffect(Duration.EndOfTurn, 1), new TapSourceCost());
ability1.addTarget(new TargetAnyTarget());
Ability ability2 = new SimpleActivatedAbility(Zone.BATTLEFIELD, new PreventDamageToTargetEffect(Duration.EndOfTurn, 2), new TapSourceCost());
ability2.addTarget(new TargetCreaturePermanent(filter));
this.addAbility(ability1);
this.addAbility(ability2);
}
private AbunaAcolyte(final AbunaAcolyte card) {
super(card);
}
@Override
public AbunaAcolyte copy() {
return new AbunaAcolyte(this);
}
} |
Layout: normal
Name: Abuna's Chant
Mana Cost: {3}{W}
Cmc: 4.0
Type Line: Instant
Oracle Text: Choose one —
• You gain 5 life.
• Prevent the next 5 damage that would be dealt to target creature this turn.
Entwine {2} (Choose both if you pay the entwine cost.)
Colors: W
Color Identity: W
Keywords: Entwine
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.Mode;
import mage.abilities.effects.common.GainLifeEffect;
import mage.abilities.effects.common.PreventDamageToTargetEffect;
import mage.abilities.keyword.EntwineAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.target.common.TargetCreaturePermanent;
public final class AbunasChant extends CardImpl {
public AbunasChant(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.INSTANT},"{3}{W}");
// Choose one -
this.getSpellAbility().getModes().setMinModes(1);
this.getSpellAbility().getModes().setMaxModes(1);
//You gain 5 life;
this.getSpellAbility().addEffect(new GainLifeEffect(5));
//or prevent the next 5 damage that would be dealt to target creature this turn.
Mode mode = new Mode(new PreventDamageToTargetEffect(Duration.EndOfTurn, 5));
mode.addTarget(new TargetCreaturePermanent());
this.getSpellAbility().getModes().addMode(mode);
// Entwine {2}
this.addAbility(new EntwineAbility("{2}"));
}
private AbunasChant(final AbunasChant card) {
super(card);
}
@Override
public AbunasChant copy() {
return new AbunasChant(this);
}
} |
Layout: normal
Name: Abundance
Mana Cost: {2}{G}{G}
Cmc: 4.0
Type Line: Enchantment
Oracle Text: If you would draw a card, you may instead choose land or nonland and reveal cards from the top of your library until you reveal a card of the chosen kind. Put that card into your hand and put all other cards revealed this way on the bottom of your library in any order.
Colors: G
Color Identity: G
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageObject;
import mage.abilities.Ability;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.ReplacementEffectImpl;
import mage.cards.*;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.Outcome;
import mage.constants.Zone;
import mage.filter.FilterCard;
import mage.filter.predicate.Predicates;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.players.Player;
public final class Abundance extends CardImpl {
public Abundance(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{2}{G}{G}");
// If you would draw a card, you may instead choose land or nonland and reveal cards from the top of your library until you reveal a card of the chosen kind. Put that card into your hand and put all other cards revealed this way on the bottom of your library in any order.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new AbundanceReplacementEffect()));
}
private Abundance(final Abundance card) {
super(card);
}
@Override
public Abundance copy() {
return new Abundance(this);
}
}
class AbundanceReplacementEffect extends ReplacementEffectImpl {
AbundanceReplacementEffect() {
super(Duration.WhileOnBattlefield, Outcome.Benefit);
staticText = "If you would draw a card, you may instead choose land or nonland and reveal cards from the top of your library until you reveal a card of the chosen kind. Put that card into your hand and put all other cards revealed this way on the bottom of your library in any order";
}
private AbundanceReplacementEffect(final AbundanceReplacementEffect effect) {
super(effect);
}
@Override
public AbundanceReplacementEffect copy() {
return new AbundanceReplacementEffect(this);
}
@Override
public boolean replaceEvent(GameEvent event, Ability source, Game game) {
Player controller = game.getPlayer(event.getPlayerId());
MageObject sourceObject = game.getObject(source);
if (controller != null && sourceObject != null) {
FilterCard filter = new FilterCard();
if (controller.chooseUse(Outcome.Detriment, "Choose card type:",
source.getSourceObject(game).getLogName(), "land", "nonland", source, game)) {
game.informPlayers(controller.getLogName() + "chooses land.");
filter.add(CardType.LAND.getPredicate());
} else {
game.informPlayers(controller.getLogName() + "chooses nonland.");
filter.add(Predicates.not(CardType.LAND.getPredicate()));
}
Cards toReveal = new CardsImpl();
Card selectedCard = null;
for (Card card : controller.getLibrary().getCards(game)) {
toReveal.add(card);
if (filter.match(card, source.getControllerId(), source, game)) {
selectedCard = card;
break;
}
}
controller.moveCards(selectedCard, Zone.HAND, source, game);
controller.revealCards(sourceObject.getIdName(), toReveal, game);
toReveal.remove(selectedCard);
controller.putCardsOnBottomOfLibrary(toReveal, game, source, true);
}
return true;
}
@Override
public boolean checksEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.DRAW_CARD;
}
@Override
public boolean applies(GameEvent event, Ability source, Game game) {
if (event.getPlayerId().equals(source.getControllerId())) {
Player player = game.getPlayer(source.getControllerId());
if (player != null) {
return player.chooseUse(Outcome.Detriment, "Choose:", source.getSourceObject(game).getLogName(),
"land or nonland and reveal cards from the top", "normal card draw", source, game);
}
}
return false;
}
} |
Layout: normal
Name: Abundant Growth
Mana Cost: {G}
Cmc: 1.0
Type Line: Enchantment — Aura
Oracle Text: Enchant land
When Abundant Growth enters, draw a card.
Enchanted land has "{T}: Add one mana of any color."
Colors: G
Color Identity: G
Keywords: Enchant
Produced Mana: B, G, R, U, W
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.Ability;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.costs.common.TapSourceCost;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.AttachEffect;
import mage.abilities.effects.common.DrawCardSourceControllerEffect;
import mage.abilities.effects.common.continuous.GainAbilityAttachedEffect;
import mage.abilities.keyword.EnchantAbility;
import mage.abilities.mana.AnyColorManaAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.target.TargetPermanent;
import mage.target.common.TargetLandPermanent;
public final class AbundantGrowth extends CardImpl {
public AbundantGrowth(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.ENCHANTMENT},"{G}");
this.subtype.add(SubType.AURA);
// Enchant land
TargetPermanent auraTarget = new TargetLandPermanent();
this.getSpellAbility().addTarget(auraTarget);
this.getSpellAbility().addEffect(new AttachEffect(Outcome.Benefit));
Ability ability = new EnchantAbility(auraTarget);
this.addAbility(ability);
// When Abundant Growth enters the battlefield, draw a card.
this.addAbility(new EntersBattlefieldTriggeredAbility(new DrawCardSourceControllerEffect(1), false));
// Enchanted land has "{T}: Add one mana of any color."
Ability gainedAbility = new AnyColorManaAbility(new TapSourceCost());
Effect effect = new GainAbilityAttachedEffect(gainedAbility, AttachmentType.AURA);
effect.setText("Enchanted land has \"{T}: Add one mana of any color.\"");
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, effect));
}
private AbundantGrowth(final AbundantGrowth card) {
super(card);
}
@Override
public AbundantGrowth copy() {
return new AbundantGrowth(this);
}
} |
Layout: normal
Name: Abundant Harvest
Mana Cost: {G}
Cmc: 1.0
Type Line: Sorcery
Oracle Text: Choose land or nonland. Reveal cards from the top of your library until you reveal a card of the chosen kind. Put that card into your hand and the rest on the bottom of your library in a random order.
Colors: G
Color Identity: G
Rarity: common | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.effects.OneShotEffect;
import mage.cards.*;
import mage.constants.CardType;
import mage.constants.Outcome;
import mage.constants.Zone;
import mage.game.Game;
import mage.players.Player;
import java.util.UUID;
public final class AbundantHarvest extends CardImpl {
public AbundantHarvest(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{G}");
// Choose land or nonland. Reveal cards from the top of your library until you reveal a card of the chosen kind. Put that card into your hand and the rest on the bottom of your library in a random order.
this.getSpellAbility().addEffect(new AbundantHarvestEffect());
}
private AbundantHarvest(final AbundantHarvest card) {
super(card);
}
@Override
public AbundantHarvest copy() {
return new AbundantHarvest(this);
}
}
class AbundantHarvestEffect extends OneShotEffect {
AbundantHarvestEffect() {
super(Outcome.Benefit);
staticText = "Choose land or nonland. Reveal cards from the top of your library " +
"until you reveal a card of the chosen kind. Put that card into your hand " +
"and the rest on the bottom of your library in a random order.";
}
private AbundantHarvestEffect(final AbundantHarvestEffect effect) {
super(effect);
}
@Override
public AbundantHarvestEffect copy() {
return new AbundantHarvestEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player player = game.getPlayer(source.getControllerId());
if (player == null) {
return false;
}
boolean land = player.chooseUse(
Outcome.Neutral, "Choose land or nonland", null,
"Land", "Nonland", source, game
);
Cards toReveal = new CardsImpl();
Card toHand = null;
for (Card card : player.getLibrary().getCards(game)) {
if (card == null) {
continue;
}
toReveal.add(card);
if (card.isLand(game) == land) {
toHand = card;
break;
}
}
player.revealCards(source, toReveal, game);
if (toHand != null) {
toReveal.remove(toHand);
player.moveCards(toHand, Zone.HAND, source, game);
}
player.putCardsOnBottomOfLibrary(toReveal, game, source, false);
return true;
}
} |
Layout: normal
Name: Abundant Maw
Mana Cost: {8}
Cmc: 8.0
Type Line: Creature — Eldrazi Leech
Oracle Text: Emerge {6}{B} (You may cast this spell by sacrificing a creature and paying the emerge cost reduced by that creature's mana value.)
When you cast this spell, target opponent loses 3 life and you gain 3 life.
Power: 6
Toughness: 4
Color Identity: B
Keywords: Emerge
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.effects.common.CastSourceTriggeredAbility;
import mage.abilities.effects.common.GainLifeEffect;
import mage.abilities.effects.common.LoseLifeTargetEffect;
import mage.abilities.keyword.EmergeAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.target.common.TargetOpponent;
import java.util.UUID;
public final class AbundantMaw extends CardImpl {
public AbundantMaw(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{8}");
this.subtype.add(SubType.ELDRAZI);
this.subtype.add(SubType.LEECH);
this.power = new MageInt(6);
this.toughness = new MageInt(4);
// Emerge {6}{B}
this.addAbility(new EmergeAbility(this, "{6}{B}"));
// When you cast Abundant Maw, target opponent loses 3 life and you gain 3 life.
Ability ability = new CastSourceTriggeredAbility(new LoseLifeTargetEffect(3));
ability.addEffect(new GainLifeEffect(3).concatBy("and"));
ability.addTarget(new TargetOpponent());
this.addAbility(ability);
}
private AbundantMaw(final AbundantMaw card) {
super(card);
}
@Override
public AbundantMaw copy() {
return new AbundantMaw(this);
}
} |
Layout: normal
Name: Abyssal Gatekeeper
Mana Cost: {1}{B}
Cmc: 2.0
Type Line: Creature — Horror
Oracle Text: When Abyssal Gatekeeper dies, each player sacrifices a creature.
Power: 1
Toughness: 1
Colors: B
Color Identity: B
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.DiesSourceTriggeredAbility;
import mage.abilities.effects.common.SacrificeAllEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.filter.StaticFilters;
public final class AbyssalGatekeeper extends CardImpl {
public AbyssalGatekeeper(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{1}{B}");
this.subtype.add(SubType.HORROR);
this.power = new MageInt(1);
this.toughness = new MageInt(1);
// When Abyssal Gatekeeper dies, each player sacrifices a creature.
this.addAbility(new DiesSourceTriggeredAbility(new SacrificeAllEffect(1, StaticFilters.FILTER_PERMANENT_CREATURE)));
}
private AbyssalGatekeeper(final AbyssalGatekeeper card) {
super(card);
}
@Override
public AbyssalGatekeeper copy() {
return new AbyssalGatekeeper(this);
}
} |
Layout: normal
Name: Abyssal Gorestalker
Mana Cost: {4}{B}{B}
Cmc: 6.0
Type Line: Creature — Horror
Oracle Text: When Abyssal Gorestalker enters, each player sacrifices two creatures.
Power: 6
Toughness: 6
Colors: B
Color Identity: B
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.common.SacrificeAllEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.filter.StaticFilters;
import java.util.UUID;
public final class AbyssalGorestalker extends CardImpl {
public AbyssalGorestalker(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{4}{B}{B}");
this.subtype.add(SubType.HORROR);
this.power = new MageInt(6);
this.toughness = new MageInt(6);
// When Abyssal Gorestalker enters the battlefield, each player sacrifices two creatures.
this.addAbility(new EntersBattlefieldTriggeredAbility(new SacrificeAllEffect(2, StaticFilters.FILTER_PERMANENT_CREATURES)));
}
private AbyssalGorestalker(final AbyssalGorestalker card) {
super(card);
}
@Override
public AbyssalGorestalker copy() {
return new AbyssalGorestalker(this);
}
} |
Layout: normal
Name: Abyssal Horror
Mana Cost: {4}{B}{B}
Cmc: 6.0
Type Line: Creature — Horror
Oracle Text: Flying
When Abyssal Horror enters, target player discards two cards.
Power: 2
Toughness: 2
Colors: B
Color Identity: B
Keywords: Flying
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.common.discard.DiscardTargetEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.target.TargetPlayer;
public final class AbyssalHorror extends CardImpl {
public AbyssalHorror (UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{4}{B}{B}");
this.subtype.add(SubType.HORROR);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
this.addAbility(FlyingAbility.getInstance());
Ability ability = new EntersBattlefieldTriggeredAbility(new DiscardTargetEffect(2));
ability.addTarget(new TargetPlayer());
this.addAbility(ability);
}
private AbyssalHorror(final AbyssalHorror card) {
super(card);
}
@Override
public AbyssalHorror copy() {
return new AbyssalHorror(this);
}
} |
Layout: normal
Name: Abyssal Hunter
Mana Cost: {3}{B}
Cmc: 4.0
Type Line: Creature — Human Assassin
Oracle Text: {B}, {T}: Tap target creature. Abyssal Hunter deals damage equal to Abyssal Hunter's power to that creature.
Power: 1
Toughness: 1
Colors: B
Color Identity: B
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.common.TapSourceCost;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.dynamicvalue.common.SourcePermanentPowerCount;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.DamageTargetEffect;
import mage.abilities.effects.common.TapTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.Zone;
import mage.target.common.TargetCreaturePermanent;
public final class AbyssalHunter extends CardImpl {
public AbyssalHunter(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{B}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.ASSASSIN);
this.power = new MageInt(1);
this.toughness = new MageInt(1);
// {B}, {tap}: Tap target creature. Abyssal Hunter deals damage equal to Abyssal Hunter's power to that creature.
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new TapTargetEffect(), new ManaCostsImpl<>("{B}"));
Effect effect = new DamageTargetEffect(new SourcePermanentPowerCount());
effect.setText("{this} deals damage equal to {this}'s power to that creature.");
ability.addEffect(effect);
ability.addCost(new TapSourceCost());
ability.addTarget(new TargetCreaturePermanent());
this.addAbility(ability);
}
private AbyssalHunter(final AbyssalHunter card) {
super(card);
}
@Override
public AbyssalHunter copy() {
return new AbyssalHunter(this);
}
} |
Layout: normal
Name: Abyssal Nightstalker
Mana Cost: {3}{B}
Cmc: 4.0
Type Line: Creature — Nightstalker
Oracle Text: Whenever Abyssal Nightstalker attacks and isn't blocked, defending player discards a card.
Power: 2
Toughness: 2
Colors: B
Color Identity: B
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.AttacksAndIsNotBlockedTriggeredAbility;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.discard.DiscardTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SetTargetPointer;
import mage.constants.SubType;
import java.util.UUID;
public final class AbyssalNightstalker extends CardImpl {
public AbyssalNightstalker(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{B}");
this.subtype.add(SubType.NIGHTSTALKER);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// Whenever Abyssal Nightstalker attacks and isn't blocked, defending player discards a card.
Effect effect = new DiscardTargetEffect(1);
effect.setText("defending player discards a card");
this.addAbility(new AttacksAndIsNotBlockedTriggeredAbility(effect, false, SetTargetPointer.PLAYER));
}
private AbyssalNightstalker(final AbyssalNightstalker card) {
super(card);
}
@Override
public AbyssalNightstalker copy() {
return new AbyssalNightstalker(this);
}
} |
Layout: normal
Name: Abyssal Nocturnus
Mana Cost: {1}{B}{B}
Cmc: 3.0
Type Line: Creature — Horror
Oracle Text: Whenever an opponent discards a card, Abyssal Nocturnus gets +2/+2 and gains fear until end of turn. (It can't be blocked except by artifact creatures and/or black creatures.)
Power: 2
Toughness: 2
Colors: B
Color Identity: B
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.DiscardsACardOpponentTriggeredAbility;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.continuous.BoostSourceEffect;
import mage.abilities.effects.common.continuous.GainAbilitySourceEffect;
import mage.abilities.keyword.FearAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.SubType;
public final class AbyssalNocturnus extends CardImpl {
public AbyssalNocturnus(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{1}{B}{B}");
this.subtype.add(SubType.HORROR);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// Whenever an opponent discards a card, Abyssal Nocturnus gets +2/+2 and gains fear until end of turn.
Effect boostEffect = new BoostSourceEffect(2, 2, Duration.EndOfTurn);
boostEffect.setText("{this} gets +2/+2");
Ability ability = new DiscardsACardOpponentTriggeredAbility(boostEffect, false); // not optional
Effect fearEffect = new GainAbilitySourceEffect(FearAbility.getInstance(), Duration.EndOfTurn);
fearEffect.setText("and gains fear until end of turn");
ability.addEffect(fearEffect);
this.addAbility(ability);
}
private AbyssalNocturnus(final AbyssalNocturnus card) {
super(card);
}
@Override
public AbyssalNocturnus copy() {
return new AbyssalNocturnus(this);
}
} |
Layout: normal
Name: Abyssal Persecutor
Mana Cost: {2}{B}{B}
Cmc: 4.0
Type Line: Creature — Demon
Oracle Text: Flying, trample
You can't win the game and your opponents can't lose the game.
Power: 6
Toughness: 6
Colors: B
Color Identity: B
Keywords: Flying, Trample
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.ContinuousRuleModifyingEffectImpl;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.TrampleAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.game.events.GameEvent.EventType;
public final class AbyssalPersecutor extends CardImpl {
public AbyssalPersecutor(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{2}{B}{B}");
this.subtype.add(SubType.DEMON);
this.power = new MageInt(6);
this.toughness = new MageInt(6);
// Flying, trample
this.addAbility(FlyingAbility.getInstance());
this.addAbility(TrampleAbility.getInstance());
// You can't win the game and your opponents can't lose the game.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new AbyssalPersecutorCannotWinEffect()));
}
private AbyssalPersecutor(final AbyssalPersecutor card) {
super(card);
}
@Override
public AbyssalPersecutor copy() {
return new AbyssalPersecutor(this);
}
}
class AbyssalPersecutorCannotWinEffect extends ContinuousRuleModifyingEffectImpl {
AbyssalPersecutorCannotWinEffect() {
super(Duration.WhileOnBattlefield, Outcome.Detriment, false, false);
staticText = "You can't win the game and your opponents can't lose the game";
}
AbyssalPersecutorCannotWinEffect ( final AbyssalPersecutorCannotWinEffect effect ) {
super(effect);
}
@Override
public boolean checksEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.LOSES || event.getType() == GameEvent.EventType.WINS ;
}
@Override
public boolean applies(GameEvent event, Ability source, Game game) {
if ((event.getType() == GameEvent.EventType.LOSES && game.getOpponents(source.getControllerId()).contains(event.getPlayerId()))
|| (event.getType() == GameEvent.EventType.WINS && event.getPlayerId().equals(source.getControllerId()))) {
return true;
}
return false;
}
@Override
public AbyssalPersecutorCannotWinEffect copy() {
return new AbyssalPersecutorCannotWinEffect(this);
}
} |
Layout: normal
Name: Abyssal Specter
Mana Cost: {2}{B}{B}
Cmc: 4.0
Type Line: Creature — Specter
Oracle Text: Flying
Whenever Abyssal Specter deals damage to a player, that player discards a card.
Power: 2
Toughness: 3
Colors: B
Color Identity: B
Keywords: Flying
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.DealsDamageToAPlayerTriggeredAbility;
import mage.abilities.effects.common.discard.DiscardTargetEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
public final class AbyssalSpecter extends CardImpl {
public AbyssalSpecter(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{2}{B}{B}");
this.subtype.add(SubType.SPECTER);
this.power = new MageInt(2);
this.toughness = new MageInt(3);
// Flying
this.addAbility(FlyingAbility.getInstance());
// Whenever Abyssal Specter deals damage to a player, that player discards a card.
this.addAbility(new DealsDamageToAPlayerTriggeredAbility(new DiscardTargetEffect(1, false), false, true));
}
private AbyssalSpecter(final AbyssalSpecter card) {
super(card);
}
@Override
public AbyssalSpecter copy() {
return new AbyssalSpecter(this);
}
} |
Layout: normal
Name: Abzan Advantage
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Instant
Oracle Text: Target player sacrifices an enchantment. Bolster 1. (Choose a creature with the least toughness among creatures you control and put a +1/+1 counter on it.)
Colors: W
Color Identity: W
Keywords: Bolster
Rarity: common | package mage.cards.a;
import mage.abilities.effects.common.SacrificeEffect;
import mage.abilities.effects.keyword.BolsterEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.filter.StaticFilters;
import mage.target.TargetPlayer;
import java.util.UUID;
public final class AbzanAdvantage extends CardImpl {
public AbzanAdvantage(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.INSTANT},"{1}{W}");
// Target player sacrifices an enchantment. Bolster 1.
this.getSpellAbility().addEffect(new SacrificeEffect(StaticFilters.FILTER_PERMANENT_ENCHANTMENT, 1, "Target player"));
this.getSpellAbility().addEffect(new BolsterEffect(1));
this.getSpellAbility().addTarget(new TargetPlayer());
}
private AbzanAdvantage(final AbzanAdvantage card) {
super(card);
}
@Override
public AbzanAdvantage copy() {
return new AbzanAdvantage(this);
}
} |
Layout: normal
Name: Abzan Ascendancy
Mana Cost: {W}{B}{G}
Cmc: 3.0
Type Line: Enchantment
Oracle Text: When Abzan Ascendancy enters, put a +1/+1 counter on each creature you control.
Whenever a nontoken creature you control dies, create a 1/1 white Spirit creature token with flying.
Colors: B, G, W
Color Identity: B, G, W
Rarity: rare | package mage.cards.a;
import mage.abilities.common.DiesCreatureTriggeredAbility;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.common.CreateTokenEffect;
import mage.abilities.effects.common.counter.AddCountersAllEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.TargetController;
import mage.counters.CounterType;
import mage.filter.StaticFilters;
import mage.filter.common.FilterCreaturePermanent;
import mage.filter.predicate.permanent.TokenPredicate;
import mage.game.permanent.token.SpiritWhiteToken;
import java.util.UUID;
public final class AbzanAscendancy extends CardImpl {
public AbzanAscendancy(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{W}{B}{G}");
// When Abzan Ascendancy enters the battlefield, put a +1/+1 counter on each creature you control.
this.addAbility(new EntersBattlefieldTriggeredAbility(new AddCountersAllEffect(CounterType.P1P1.createInstance(), StaticFilters.FILTER_CONTROLLED_CREATURE), false));
// Whenever a nontoken creature you control dies, create a 1/1 white Spirit creature token with flying.
this.addAbility(new DiesCreatureTriggeredAbility(new CreateTokenEffect(new SpiritWhiteToken()), false, StaticFilters.FILTER_CONTROLLED_CREATURE_NON_TOKEN));
}
private AbzanAscendancy(final AbzanAscendancy card) {
super(card);
}
@Override
public AbzanAscendancy copy() {
return new AbzanAscendancy(this);
}
} |
Layout: normal
Name: Abzan Banner
Mana Cost: {3}
Cmc: 3.0
Type Line: Artifact
Oracle Text: {T}: Add {W}, {B}, or {G}.
{W}{B}{G}, {T}, Sacrifice Abzan Banner: Draw a card.
Color Identity: B, G, W
Produced Mana: B, G, W
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.Ability;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.common.SacrificeSourceCost;
import mage.abilities.costs.common.TapSourceCost;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.DrawCardSourceControllerEffect;
import mage.abilities.mana.BlackManaAbility;
import mage.abilities.mana.GreenManaAbility;
import mage.abilities.mana.WhiteManaAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Zone;
public final class AbzanBanner extends CardImpl {
public AbzanBanner(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.ARTIFACT},"{3}");
// {T}: Add {W}, {B}, or {G}.
this.addAbility(new WhiteManaAbility());
this.addAbility(new BlackManaAbility());
this.addAbility(new GreenManaAbility());
// {W}{B}{G}, {T}, Sacrifice Abzan Banner: Draw a card.
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new DrawCardSourceControllerEffect(1), new ManaCostsImpl<>("{W}{B}{G}"));
ability.addCost(new TapSourceCost());
ability.addCost(new SacrificeSourceCost());
this.addAbility(ability);
}
private AbzanBanner(final AbzanBanner card) {
super(card);
}
@Override
public AbzanBanner copy() {
return new AbzanBanner(this);
}
} |
Layout: normal
Name: Abzan Battle Priest
Mana Cost: {3}{W}
Cmc: 4.0
Type Line: Creature — Human Cleric
Oracle Text: Outlast {W} ({W}, {T}: Put a +1/+1 counter on this creature. Outlast only as a sorcery.)
Each creature you control with a +1/+1 counter on it has lifelink.
Power: 3
Toughness: 2
Colors: W
Color Identity: W
Keywords: Outlast
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.continuous.GainAbilityAllEffect;
import mage.abilities.keyword.LifelinkAbility;
import mage.abilities.keyword.OutlastAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.filter.StaticFilters;
import java.util.UUID;
public final class AbzanBattlePriest extends CardImpl {
public AbzanBattlePriest(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{W}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.CLERIC);
this.power = new MageInt(3);
this.toughness = new MageInt(2);
// Outlast {W}
this.addAbility(new OutlastAbility(new ManaCostsImpl<>("{W}")));
// Each creature you control with a +1/+1 counter on it has lifelink.
this.addAbility(new SimpleStaticAbility(
Zone.BATTLEFIELD,
new GainAbilityAllEffect(
LifelinkAbility.getInstance(), Duration.WhileOnBattlefield,
StaticFilters.FILTER_EACH_CONTROLLED_CREATURE_P1P1,
"Each creature you control with a +1/+1 counter on it has lifelink"
)
));
}
private AbzanBattlePriest(final AbzanBattlePriest card) {
super(card);
}
@Override
public AbzanBattlePriest copy() {
return new AbzanBattlePriest(this);
}
} |
Layout: normal
Name: Abzan Beastmaster
Mana Cost: {2}{G}
Cmc: 3.0
Type Line: Creature — Dog Shaman
Oracle Text: At the beginning of your upkeep, draw a card if you control the creature with the greatest toughness or tied for the greatest toughness.
Power: 2
Toughness: 1
Colors: G
Color Identity: G
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.BeginningOfUpkeepTriggeredAbility;
import mage.abilities.condition.common.ControlsCreatureGreatestToughnessCondition;
import mage.abilities.decorator.ConditionalInterveningIfTriggeredAbility;
import mage.abilities.effects.common.DrawCardSourceControllerEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.TargetController;
public final class AbzanBeastmaster extends CardImpl {
public AbzanBeastmaster(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{2}{G}");
this.subtype.add(SubType.DOG);
this.subtype.add(SubType.SHAMAN);
this.power = new MageInt(2);
this.toughness = new MageInt(1);
// At the beginning of your upkeep, draw a card if you control the creature with the greatest toughness or tied for the greatest toughness.
this.addAbility(new ConditionalInterveningIfTriggeredAbility(
new BeginningOfUpkeepTriggeredAbility(new DrawCardSourceControllerEffect(1), TargetController.YOU, false),
ControlsCreatureGreatestToughnessCondition.instance,
"At the beginning of your upkeep, draw a card if you control the creature with the greatest toughness or tied for the greatest toughness."
));
}
private AbzanBeastmaster(final AbzanBeastmaster card) {
super(card);
}
@Override
public AbzanBeastmaster copy() {
return new AbzanBeastmaster(this);
}
} |
Layout: normal
Name: Abzan Charm
Mana Cost: {W}{B}{G}
Cmc: 3.0
Type Line: Instant
Oracle Text: Choose one —
• Exile target creature with power 3 or greater.
• You draw two cards and you lose 2 life.
• Distribute two +1/+1 counters among one or two target creatures.
Colors: B, G, W
Color Identity: B, G, W
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.abilities.Mode;
import mage.abilities.effects.common.DrawCardSourceControllerEffect;
import mage.abilities.effects.common.ExileTargetEffect;
import mage.abilities.effects.common.LoseLifeSourceControllerEffect;
import mage.abilities.effects.common.counter.DistributeCountersEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.ComparisonType;
import mage.counters.CounterType;
import mage.filter.common.FilterCreaturePermanent;
import mage.filter.predicate.mageobject.PowerPredicate;
import mage.target.common.TargetCreaturePermanent;
import mage.target.common.TargetCreaturePermanentAmount;
public final class AbzanCharm extends CardImpl {
private static final FilterCreaturePermanent FILTER = new FilterCreaturePermanent("creature with power 3 or greater");
static {
FILTER.add(new PowerPredicate(ComparisonType.MORE_THAN, 2));
}
public AbzanCharm(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.INSTANT},"{W}{B}{G}");
// Choose one -
// *Exile target creature with power 3 or greater
this.getSpellAbility().addTarget(new TargetCreaturePermanent(FILTER));
this.getSpellAbility().addEffect(new ExileTargetEffect());
// *You draw two cards and you lose 2 life
Mode mode = new Mode(new DrawCardSourceControllerEffect(2, true));
mode.addEffect(new LoseLifeSourceControllerEffect(2).concatBy("and"));
this.getSpellAbility().addMode(mode);
// *Distribute two +1/+1 counters among one or two target creatures.
mode = new Mode(new DistributeCountersEffect(CounterType.P1P1, 2, false, "one or two target creatures"));
mode.addTarget(new TargetCreaturePermanentAmount(2));
this.getSpellAbility().addMode(mode);
}
private AbzanCharm(final AbzanCharm card) {
super(card);
}
@Override
public AbzanCharm copy() {
return new AbzanCharm(this);
}
} |
Layout: normal
Name: Abzan Falconer
Mana Cost: {2}{W}
Cmc: 3.0
Type Line: Creature — Human Soldier
Oracle Text: Outlast {W} ({W}, {T}: Put a +1/+1 counter on this creature. Outlast only as a sorcery.)
Each creature you control with a +1/+1 counter on it has flying.
Power: 2
Toughness: 3
Colors: W
Color Identity: W
Keywords: Outlast
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.costs.mana.ColoredManaCost;
import mage.abilities.effects.common.continuous.GainAbilityAllEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.OutlastAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.filter.StaticFilters;
public final class AbzanFalconer extends CardImpl {
public AbzanFalconer(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{2}{W}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.SOLDIER);
this.power = new MageInt(2);
this.toughness = new MageInt(3);
// Outlast {W}
this.addAbility(new OutlastAbility(new ColoredManaCost(ColoredManaSymbol.W)));
// Each creature you control with a +1/+1 counter on it has flying.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new GainAbilityAllEffect(
FlyingAbility.getInstance(),
Duration.WhileOnBattlefield,
StaticFilters.FILTER_EACH_CONTROLLED_CREATURE_P1P1)
));
}
private AbzanFalconer(final AbzanFalconer card) {
super(card);
}
@Override
public AbzanFalconer copy() {
return new AbzanFalconer(this);
}
} |
Layout: normal
Name: Abzan Guide
Mana Cost: {3}{W}{B}{G}
Cmc: 6.0
Type Line: Creature — Human Warrior
Oracle Text: Lifelink (Damage dealt by this creature also causes you to gain that much life.)
Morph {2}{W}{B}{G} (You may cast this card face down as a 2/2 creature for {3}. Turn it face up any time for its morph cost.)
Power: 4
Toughness: 4
Colors: B, G, W
Color Identity: B, G, W
Keywords: Lifelink, Morph
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.keyword.LifelinkAbility;
import mage.abilities.keyword.MorphAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
public final class AbzanGuide extends CardImpl {
public AbzanGuide(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{W}{B}{G}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.WARRIOR);
this.power = new MageInt(4);
this.toughness = new MageInt(4);
// Lifelink
this.addAbility(LifelinkAbility.getInstance());
// Morph {2}{W}{B}{G}
this.addAbility(new MorphAbility(this, new ManaCostsImpl<>("{2}{W}{B}{G}")));
}
private AbzanGuide(final AbzanGuide card) {
super(card);
}
@Override
public AbzanGuide copy() {
return new AbzanGuide(this);
}
} |
Layout: normal
Name: Abzan Kin-Guard
Mana Cost: {3}{G}
Cmc: 4.0
Type Line: Creature — Human Warrior
Oracle Text: Abzan Kin-Guard has lifelink as long as you control a white or black permanent.
Power: 3
Toughness: 3
Colors: G
Color Identity: G
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.ObjectColor;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.condition.common.PermanentsOnTheBattlefieldCondition;
import mage.abilities.decorator.ConditionalContinuousEffect;
import mage.abilities.effects.common.continuous.GainAbilitySourceEffect;
import mage.abilities.keyword.LifelinkAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.SubType;
import mage.constants.Zone;
import mage.filter.common.FilterControlledPermanent;
import mage.filter.predicate.Predicates;
import mage.filter.predicate.mageobject.ColorPredicate;
public final class AbzanKinGuard extends CardImpl {
private static final FilterControlledPermanent filter = new FilterControlledPermanent("as long as you control a white or black permanent");
static {
filter.add(Predicates.or(new ColorPredicate(ObjectColor.WHITE), new ColorPredicate(ObjectColor.BLACK)));
}
public AbzanKinGuard(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{G}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.WARRIOR);
this.power = new MageInt(3);
this.toughness = new MageInt(3);
// Abzan Kin-Guard has lifelink as long as you control a white or black permanent.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD,
new ConditionalContinuousEffect(new GainAbilitySourceEffect(LifelinkAbility.getInstance(), Duration.WhileOnBattlefield),
new PermanentsOnTheBattlefieldCondition(filter), "{this} has lifelink as long as you control a white or black permanent")));
}
private AbzanKinGuard(final AbzanKinGuard card) {
super(card);
}
@Override
public AbzanKinGuard copy() {
return new AbzanKinGuard(this);
}
} |
Layout: normal
Name: Abzan Runemark
Mana Cost: {2}{W}
Cmc: 3.0
Type Line: Enchantment — Aura
Oracle Text: Enchant creature
Enchanted creature gets +2/+2.
Enchanted creature has vigilance as long as you control a black or green permanent.
Colors: W
Color Identity: W
Keywords: Enchant
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.ObjectColor;
import mage.abilities.Ability;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.condition.common.PermanentsOnTheBattlefieldCondition;
import mage.abilities.decorator.ConditionalContinuousEffect;
import mage.abilities.effects.common.AttachEffect;
import mage.abilities.effects.common.continuous.BoostEnchantedEffect;
import mage.abilities.effects.common.continuous.GainAbilityAttachedEffect;
import mage.abilities.keyword.EnchantAbility;
import mage.abilities.keyword.VigilanceAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.filter.common.FilterControlledPermanent;
import mage.filter.predicate.Predicates;
import mage.filter.predicate.mageobject.ColorPredicate;
import mage.target.TargetPermanent;
import mage.target.common.TargetCreaturePermanent;
public final class AbzanRunemark extends CardImpl {
private static final FilterControlledPermanent filter = new FilterControlledPermanent("as long as you control a black or green permanent");
static {
filter.add(Predicates.or(new ColorPredicate(ObjectColor.GREEN), new ColorPredicate(ObjectColor.BLACK)));
}
public AbzanRunemark(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.ENCHANTMENT},"{2}{W}");
this.subtype.add(SubType.AURA);
// Enchant creature
TargetPermanent auraTarget = new TargetCreaturePermanent();
this.getSpellAbility().addTarget(auraTarget);
this.getSpellAbility().addEffect(new AttachEffect(Outcome.BoostCreature));
Ability ability = new EnchantAbility(auraTarget);
this.addAbility(ability);
// Enchanted creature gets +2/+2.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new BoostEnchantedEffect(2, 2, Duration.WhileOnBattlefield)));
// Enchanted creature has vigilance as long as you control a black or green permanent.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD,
new ConditionalContinuousEffect(new GainAbilityAttachedEffect(VigilanceAbility.getInstance(), AttachmentType.AURA),
new PermanentsOnTheBattlefieldCondition(filter), "Enchanted creature has vigilance as long as you control a black or green permanent")));
}
private AbzanRunemark(final AbzanRunemark card) {
super(card);
}
@Override
public AbzanRunemark copy() {
return new AbzanRunemark(this);
}
} |
Layout: normal
Name: Abzan Skycaptain
Mana Cost: {3}{W}
Cmc: 4.0
Type Line: Creature — Bird Soldier
Oracle Text: Flying
When Abzan Skycaptain dies, bolster 2. (Choose a creature with the least toughness among creatures you control and put two +1/+1 counters on it.)
Power: 2
Toughness: 2
Colors: W
Color Identity: W
Keywords: Bolster, Flying
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.DiesSourceTriggeredAbility;
import mage.abilities.effects.keyword.BolsterEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
public final class AbzanSkycaptain extends CardImpl {
public AbzanSkycaptain(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{W}");
this.subtype.add(SubType.BIRD);
this.subtype.add(SubType.SOLDIER);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// Flying
this.addAbility(FlyingAbility.getInstance());
// When Abzan Captain dies, bolster 2.
this.addAbility(new DiesSourceTriggeredAbility(new BolsterEffect(2)));
}
private AbzanSkycaptain(final AbzanSkycaptain card) {
super(card);
}
@Override
public AbzanSkycaptain copy() {
return new AbzanSkycaptain(this);
}
} |
Layout: normal
Name: Academic Dispute
Mana Cost: {R}
Cmc: 1.0
Type Line: Instant
Oracle Text: Target creature blocks this turn if able. You may have it gain reach until end of turn.
Learn. (You may reveal a Lesson card you own from outside the game and put it into your hand, or discard a card to draw a card.)
Colors: R
Color Identity: R
Keywords: Learn
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.abilities.Ability;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.LearnEffect;
import mage.abilities.effects.common.combat.BlocksIfAbleTargetEffect;
import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
import mage.abilities.hint.common.OpenSideboardHint;
import mage.abilities.keyword.ReachAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.Outcome;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.players.Player;
import mage.target.common.TargetCreaturePermanent;
public final class AcademicDispute extends CardImpl {
public AcademicDispute(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{R}");
// Target creature blocks this turn if able. You may have that creature gain reach until end of turn.
this.getSpellAbility().addEffect(new BlocksIfAbleTargetEffect(Duration.EndOfTurn));
this.getSpellAbility().addEffect(new AcademicDisputeEffect());
this.getSpellAbility().addTarget(new TargetCreaturePermanent());
// Learn.
this.getSpellAbility().addEffect(new LearnEffect().concatBy("<br>"));
this.getSpellAbility().addHint(OpenSideboardHint.instance);
}
private AcademicDispute(final AcademicDispute card) {
super(card);
}
@Override
public AcademicDispute copy() {
return new AcademicDispute(this);
}
}
class AcademicDisputeEffect extends OneShotEffect {
AcademicDisputeEffect() {
super(Outcome.AddAbility);
this.staticText = "You may have it gain reach until end of turn";
}
private AcademicDisputeEffect(final AcademicDisputeEffect effect) {
super(effect);
}
@Override
public AcademicDisputeEffect copy() {
return new AcademicDisputeEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player player = game.getPlayer(source.getControllerId());
if (player != null) {
Permanent permanent = game.getPermanent(this.getTargetPointer().getFirst(game, source));
if (permanent != null) {
if (player.chooseUse(outcome, "Have " + permanent.getLogName() + " gain reach until end of turn?", source, game)) {
GainAbilityTargetEffect effect = new GainAbilityTargetEffect(ReachAbility.getInstance(), Duration.EndOfTurn);
game.addEffect(effect, source);
return true;
}
}
}
return false;
}
} |
Layout: normal
Name: Academic Probation
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Sorcery — Lesson
Oracle Text: Choose one —
• Choose a nonland card name. Opponents can't cast spells with the chosen name until your next turn.
• Choose target nonland permanent. Until your next turn, it can't attack or block, and its activated abilities can't be activated.
Colors: W
Color Identity: W
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.abilities.Ability;
import mage.abilities.Mode;
import mage.abilities.effects.Effect;
import mage.abilities.effects.RestrictionEffect;
import mage.abilities.effects.common.OpponentsCantCastChosenUntilNextTurnEffect;
import mage.abilities.effects.common.ChooseACardNameEffect;
import mage.constants.Duration;
import mage.constants.Outcome;
import mage.constants.SubType;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.target.common.TargetNonlandPermanent;
public final class AcademicProbation extends CardImpl {
public AcademicProbation(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{1}{W}");
this.subtype.add(SubType.LESSON);
// Choose one —
// • Choose a nonland card name. Opponents can't cast spells with the chosen name until your next turn.
Effect effect = new ChooseACardNameEffect(ChooseACardNameEffect.TypeOfName.NON_LAND_NAME);
effect.setText("Choose a nonland card name");
this.getSpellAbility().addEffect(effect);
this.getSpellAbility().addEffect(new OpponentsCantCastChosenUntilNextTurnEffect().setText("opponents can't cast spells with the chosen name until your next turn"));
// • Choose target nonland permanent. Until your next turn, it can't attack or block, and its activated abilities can't be activated.
Mode restrictMode = new Mode(new AcademicProbationRestrictionEffect());
restrictMode.addTarget(new TargetNonlandPermanent());
this.getSpellAbility().addMode(restrictMode);
}
private AcademicProbation(final AcademicProbation card) {
super(card);
}
@Override
public AcademicProbation copy() {
return new AcademicProbation(this);
}
}
class AcademicProbationRestrictionEffect extends RestrictionEffect {
AcademicProbationRestrictionEffect() {
super(Duration.UntilYourNextTurn, Outcome.UnboostCreature);
staticText = "choose target nonland permanent. Until your next turn, it can't attack or block, and its activated abilities can't be activated";
}
private AcademicProbationRestrictionEffect(final AcademicProbationRestrictionEffect effect) {
super(effect);
}
@Override
public AcademicProbationRestrictionEffect copy() {
return new AcademicProbationRestrictionEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
return true;
}
@Override
public boolean applies(Permanent permanent, Ability source, Game game) {
return this.getTargetPointer().getTargets(game, source).contains(permanent.getId());
}
@Override
public boolean canAttack(Game game, boolean canUseChooseDialogs) {
return false;
}
@Override
public boolean canBlock(Permanent attacker, Permanent blocker, Ability source, Game game, boolean canUseChooseDialogs) {
return false;
}
@Override
public boolean canUseActivatedAbilities(Permanent permanent, Ability source, Game game, boolean canUseChooseDialogs) {
return false;
}
} |
End of preview. Expand
in Dataset Viewer.
No dataset card yet
New: Create and edit this dataset card directly on the website!
Contribute a Dataset Card- Downloads last month
- 2