prompt
stringlengths 108
1.09k
| completion
stringlengths 1
34.4k
|
|---|---|
Layout: normal
Name: Accumulated Knowledge
Mana Cost: {1}{U}
Cmc: 2.0
Type Line: Instant
Oracle Text: Draw a card, then draw cards equal to the number of cards named Accumulated Knowledge in all graveyards.
Colors: U
Color Identity: U
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.dynamicvalue.common.CardsInAllGraveyardsCount;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.DrawCardSourceControllerEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.filter.FilterCard;
import mage.filter.predicate.mageobject.NamePredicate;
public final class AccumulatedKnowledge extends CardImpl {
private static final FilterCard filter = new FilterCard("card named Accumulated Knowledge");
static {
filter.add(new NamePredicate("Accumulated Knowledge"));
}
public AccumulatedKnowledge(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.INSTANT},"{1}{U}");
// Draw a card, then draw cards equal to the number of cards named Accumulated Knowledge in all graveyards.
this.getSpellAbility().addEffect(new DrawCardSourceControllerEffect(1));
Effect effect = new DrawCardSourceControllerEffect(new CardsInAllGraveyardsCount(filter));
effect.setText(", then draw cards equal to the number of cards named {this} in all graveyards");
this.getSpellAbility().addEffect(effect);
}
private AccumulatedKnowledge(final AccumulatedKnowledge card) {
super(card);
}
@Override
public AccumulatedKnowledge copy() {
return new AccumulatedKnowledge(this);
}
} |
Layout: normal
Name: Accursed Centaur
Mana Cost: {B}
Cmc: 1.0
Type Line: Creature — Zombie Centaur
Oracle Text: When Accursed Centaur enters, sacrifice a creature.
Power: 2
Toughness: 2
Colors: B
Color Identity: B
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.common.SacrificeControllerEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.filter.StaticFilters;
public final class AccursedCentaur extends CardImpl {
public AccursedCentaur(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{B}");
this.subtype.add(SubType.ZOMBIE);
this.subtype.add(SubType.CENTAUR);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// When Accursed Centaur enters the battlefield, sacrifice a creature.
this.addAbility(new EntersBattlefieldTriggeredAbility(new SacrificeControllerEffect(StaticFilters.FILTER_PERMANENT_CREATURE, 1, null)));
}
private AccursedCentaur(final AccursedCentaur card) {
super(card);
}
@Override
public AccursedCentaur copy() {
return new AccursedCentaur(this);
}
} |
Layout: normal
Name: Accursed Horde
Mana Cost: {3}{B}
Cmc: 4.0
Type Line: Creature — Zombie
Oracle Text: {1}{B}: Target attacking Zombie gains indestructible until end of turn. (Damage and effects that say "destroy" don't destroy it. If its toughness is 0 or less, it's still put into its owner's graveyard.)
Power: 3
Toughness: 3
Colors: B
Color Identity: B
Rarity: uncommon | 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.continuous.GainAbilityTargetEffect;
import mage.abilities.keyword.IndestructibleAbility;
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.FilterAttackingCreature;
import mage.target.TargetPermanent;
import java.util.UUID;
public final class AccursedHorde extends CardImpl {
private static final FilterAttackingCreature filter = new FilterAttackingCreature("attacking Zombie");
static {
filter.add(SubType.ZOMBIE.getPredicate());
}
public AccursedHorde(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(3);
// {1}{B}: Target attacking Zombie gains indestructible until end of turn.
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new GainAbilityTargetEffect(IndestructibleAbility.getInstance(), Duration.EndOfTurn), new ManaCostsImpl<>("{1}{B}"));
ability.addTarget(new TargetPermanent(filter));
this.addAbility(ability);
}
private AccursedHorde(final AccursedHorde card) {
super(card);
}
@Override
public AccursedHorde copy() {
return new AccursedHorde(this);
}
} |
Layout: normal
Name: Accursed Marauder
Mana Cost: {1}{B}
Cmc: 2.0
Type Line: Creature — Zombie Warrior
Oracle Text: When Accursed Marauder enters, each player sacrifices a nontoken creature.
Power: 2
Toughness: 1
Colors: B
Color Identity: B
Rarity: common | 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.FilterPermanent;
import mage.filter.common.FilterControlledCreaturePermanent;
import mage.filter.predicate.permanent.TokenPredicate;
import java.util.UUID;
public final class AccursedMarauder extends CardImpl {
private static final FilterPermanent filter = new FilterControlledCreaturePermanent("a nontoken creature");
static {
filter.add(TokenPredicate.FALSE);
}
public AccursedMarauder(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{B}");
this.subtype.add(SubType.ZOMBIE);
this.subtype.add(SubType.WARRIOR);
this.power = new MageInt(2);
this.toughness = new MageInt(1);
// When Accursed Marauder enters the battlefield, each player sacrifices a nontoken creature.
this.addAbility(new EntersBattlefieldTriggeredAbility(new SacrificeAllEffect(1, filter)));
}
private AccursedMarauder(final AccursedMarauder card) {
super(card);
}
@Override
public AccursedMarauder copy() {
return new AccursedMarauder(this);
}
} |
Layout: normal
Name: Accursed Spirit
Mana Cost: {3}{B}
Cmc: 4.0
Type Line: Creature — Spirit
Oracle Text: Intimidate (This creature can't be blocked except by artifact creatures and/or creatures that share a color with it.)
Power: 3
Toughness: 2
Colors: B
Color Identity: B
Keywords: Intimidate
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.keyword.IntimidateAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
public final class AccursedSpirit extends CardImpl {
public AccursedSpirit(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{B}");
this.subtype.add(SubType.SPIRIT);
this.power = new MageInt(3);
this.toughness = new MageInt(2);
// Intimidate
this.addAbility(IntimidateAbility.getInstance());
}
private AccursedSpirit(final AccursedSpirit card) {
super(card);
}
@Override
public AccursedSpirit copy() {
return new AccursedSpirit(this);
}
} |
Layout: transform
Name: Accursed Witch
Mana Cost: {3}{B}
Type Line: Creature — Human Shaman
Oracle Text: Spells your opponents cast that target Accursed Witch cost {1} less to cast.
When Accursed Witch dies, return it to the battlefield transformed under your control attached to target opponent.
Colors: B
Power: 4
Toughness: 2
Name: Infectious Curse
Type Line: Enchantment — Aura Curse
Oracle Text: Enchant player
Spells you cast that target enchanted player cost {1} less to cast.
At the beginning of enchanted player's upkeep, that player loses 1 life and you gain 1 life.
Colors: B
Color Indicator: B | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.DiesSourceTriggeredAbility;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.cost.SpellsCostModificationThatTargetSourceEffect;
import mage.abilities.keyword.TransformAbility;
import mage.cards.Card;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.filter.FilterCard;
import mage.game.Game;
import mage.players.Player;
import mage.target.common.TargetOpponent;
import java.util.UUID;
public final class AccursedWitch extends CardImpl {
public AccursedWitch(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{B}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.SHAMAN);
this.power = new MageInt(4);
this.toughness = new MageInt(2);
this.secondSideCardClazz = mage.cards.i.InfectiousCurse.class;
// Spells your opponents cast that target Accursed Witch cost {1} less to cast.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD,
new SpellsCostModificationThatTargetSourceEffect(-1, new FilterCard("Spells"), TargetController.OPPONENT))
);
// When Accursed Witch dies, return it to the battlefield transformed under your control attached to target opponent.
this.addAbility(new TransformAbility());
Ability ability = new DiesSourceTriggeredAbility(new AccursedWitchReturnTransformedEffect());
ability.addTarget(new TargetOpponent());
this.addAbility(ability);
}
private AccursedWitch(final AccursedWitch card) {
super(card);
}
@Override
public AccursedWitch copy() {
return new AccursedWitch(this);
}
}
class AccursedWitchReturnTransformedEffect extends OneShotEffect {
AccursedWitchReturnTransformedEffect() {
super(Outcome.PutCardInPlay);
this.staticText = "return it to the battlefield transformed under your control attached to target opponent";
}
private AccursedWitchReturnTransformedEffect(final AccursedWitchReturnTransformedEffect effect) {
super(effect);
}
@Override
public AccursedWitchReturnTransformedEffect copy() {
return new AccursedWitchReturnTransformedEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
Player attachTo = game.getPlayer(getTargetPointer().getFirst(game, source));
if (controller == null || !(game.getState().getZone(source.getSourceId()) == Zone.GRAVEYARD) || attachTo == null) {
return false;
}
Card card = game.getCard(source.getSourceId());
if (card == null) {
return false;
}
game.getState().setValue(TransformAbility.VALUE_KEY_ENTER_TRANSFORMED + source.getSourceId(), Boolean.TRUE);
game.getState().setValue("attachTo:" + source.getSourceId(), attachTo.getId());
if (controller.moveCards(card, Zone.BATTLEFIELD, source, game)) {
attachTo.addAttachment(card.getId(), source, game);
}
return true;
}
} |
Layout: normal
Name: Ace, Fearless Rebel
Mana Cost: {3}{G}
Cmc: 4.0
Type Line: Legendary Creature — Human Rebel
Oracle Text: Nitro-9 — Whenever Ace, Fearless Rebel attacks, you may sacrifice an artifact. When you do, put a +1/+1 counter on Ace, Fearless Rebel, then it fights up to one target creature defending player controls.
Doctor's companion (You can have two commanders if the other is the Doctor.)
Power: 2
Toughness: 2
Colors: G
Color Identity: G
Keywords: Nitro-9, Fight, Doctor's companion
Rarity: rare | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.AttacksTriggeredAbility;
import mage.abilities.common.delayed.ReflexiveTriggeredAbility;
import mage.abilities.costs.common.SacrificeTargetCost;
import mage.abilities.effects.common.DoWhenCostPaid;
import mage.abilities.effects.common.FightTargetSourceEffect;
import mage.abilities.effects.common.counter.AddCountersSourceEffect;
import mage.abilities.keyword.DoctorsCompanionAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.SuperType;
import mage.counters.CounterType;
import mage.filter.FilterPermanent;
import mage.filter.StaticFilters;
import mage.filter.common.FilterCreaturePermanent;
import mage.filter.predicate.permanent.DefendingPlayerControlsSourceAttackingPredicate;
import mage.target.TargetPermanent;
import java.util.UUID;
public final class AceFearlessRebel extends CardImpl {
private static final FilterPermanent filter = new FilterCreaturePermanent("creature defending player controls");
static {
filter.add(DefendingPlayerControlsSourceAttackingPredicate.instance);
}
public AceFearlessRebel(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{G}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.REBEL);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// Nitro-9 -- Whenever Ace, Fearless Rebel attacks, you may sacrifice an artifact. When you do, put a +1/+1 counter on Ace, Fearless Rebel, then it fights up to one target creature defending player controls.
ReflexiveTriggeredAbility ability = new ReflexiveTriggeredAbility(
new AddCountersSourceEffect(CounterType.P1P1.createInstance(), false), false
);
ability.addEffect(new FightTargetSourceEffect()
.setText(", then it fights up to one target creature defending player controls"));
ability.addTarget(new TargetPermanent(filter));
this.addAbility(new AttacksTriggeredAbility(new DoWhenCostPaid(
ability,
new SacrificeTargetCost(StaticFilters.FILTER_CONTROLLED_PERMANENT_ARTIFACT_AN),
"Sacrifice an artifact?"
)).withFlavorWord("Nitro-9"));
// Doctor's companion
this.addAbility(DoctorsCompanionAbility.getInstance());
}
private AceFearlessRebel(final AceFearlessRebel card) {
super(card);
}
@Override
public AceFearlessRebel copy() {
return new AceFearlessRebel(this);
}
} |
Layout: normal
Name: Acererak the Archlich
Mana Cost: {2}{B}
Cmc: 3.0
Type Line: Legendary Creature — Zombie Wizard
Oracle Text: When Acererak the Archlich enters, if you haven't completed Tomb of Annihilation, return Acererak the Archlich to its owner's hand and venture into the dungeon.
Whenever Acererak the Archlich attacks, for each opponent, you create a 2/2 black Zombie creature token unless that player sacrifices a creature.
Power: 5
Toughness: 5
Colors: B
Color Identity: B
Keywords: Venture into the dungeon
Rarity: mythic | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.AttacksTriggeredAbility;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.condition.Condition;
import mage.abilities.condition.common.CompletedDungeonCondition;
import mage.abilities.decorator.ConditionalInterveningIfTriggeredAbility;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.ReturnToHandSourceEffect;
import mage.abilities.effects.keyword.VentureIntoTheDungeonEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Outcome;
import mage.constants.SubType;
import mage.constants.SuperType;
import mage.filter.StaticFilters;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.game.permanent.token.ZombieToken;
import mage.players.Player;
import mage.target.TargetPermanent;
import mage.target.common.TargetControlledCreaturePermanent;
import mage.target.common.TargetSacrifice;
import mage.watchers.common.CompletedDungeonWatcher;
import java.util.UUID;
public final class AcererakTheArchlich extends CardImpl {
public AcererakTheArchlich(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{B}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.ZOMBIE);
this.subtype.add(SubType.WIZARD);
this.power = new MageInt(5);
this.toughness = new MageInt(5);
// When Acererak the Archlich enters the battlefield, if you have not completed Tomb of Annihilation, return Acererak the Archlich to its owner's hand and venture into the dungeon.
Ability ability = new ConditionalInterveningIfTriggeredAbility(
new EntersBattlefieldTriggeredAbility(new ReturnToHandSourceEffect(true)),
AcererakTheArchlichCondition.instance, "When {this} enters, " +
"if you haven't completed Tomb of Annihilation, return {this} " +
"to its owner's hand and venture into the dungeon."
);
ability.addEffect(new VentureIntoTheDungeonEffect());
this.addAbility(ability.addHint(CompletedDungeonCondition.getHint()), new CompletedDungeonWatcher());
// Whenever Acererak the Archlich attacks, for each opponent, you create a 2/2 black Zombie creature token unless that player sacrifices a creature.
this.addAbility(new AttacksTriggeredAbility(new AcererakTheArchlichEffect()));
}
private AcererakTheArchlich(final AcererakTheArchlich card) {
super(card);
}
@Override
public AcererakTheArchlich copy() {
return new AcererakTheArchlich(this);
}
}
enum AcererakTheArchlichCondition implements Condition {
instance;
@Override
public boolean apply(Game game, Ability source) {
return !CompletedDungeonWatcher.getCompletedNames(
source.getControllerId(), game
).contains("Tomb of Annihilation");
}
}
class AcererakTheArchlichEffect extends OneShotEffect {
AcererakTheArchlichEffect() {
super(Outcome.Benefit);
staticText = "for each opponent, you create a 2/2 black Zombie creature " +
"token unless that player sacrifices a creature";
}
private AcererakTheArchlichEffect(final AcererakTheArchlichEffect effect) {
super(effect);
}
@Override
public AcererakTheArchlichEffect copy() {
return new AcererakTheArchlichEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
int tokens = 0;
for (UUID playerId : game.getOpponents(source.getControllerId())) {
tokens++;
Player player = game.getPlayer(playerId);
if (player == null) {
continue;
}
TargetSacrifice target = new TargetSacrifice(0, 1, StaticFilters.FILTER_PERMANENT_CREATURE);
player.choose(Outcome.Sacrifice, target, source, game);
Permanent permanent = game.getPermanent(target.getFirstTarget());
if (permanent != null && permanent.sacrifice(source, game)) {
tokens--;
}
}
if (tokens > 0) {
new ZombieToken().putOntoBattlefield(tokens, game, source, source.getControllerId());
}
return true;
}
} |
Layout: normal
Name: Ace's Baseball Bat
Mana Cost: {2}
Cmc: 2.0
Type Line: Legendary Artifact — Equipment
Oracle Text: Equipped creature gets +3/+0.
As long as equipped creature is attacking, it has first strike and must be blocked by a Dalek if able.
Equip legendary creature {1}
Equip {3}
Keywords: Equip
Rarity: rare | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.condition.Condition;
import mage.abilities.costs.mana.GenericManaCost;
import mage.abilities.decorator.ConditionalContinuousEffect;
import mage.abilities.effects.common.combat.MustBeBlockedByAtLeastOneAttachedEffect;
import mage.abilities.effects.common.continuous.BoostEquippedEffect;
import mage.abilities.effects.common.continuous.GainAbilityAttachedEffect;
import mage.abilities.keyword.EquipAbility;
import mage.abilities.keyword.FirstStrikeAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.filter.common.FilterControlledCreaturePermanent;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.target.common.TargetControlledCreaturePermanent;
import java.util.UUID;
public final class AcesBaseballBat extends CardImpl {
private static final FilterControlledCreaturePermanent filterLegendary
= new FilterControlledCreaturePermanent("legendary creature");
static {
filterLegendary.add(SuperType.LEGENDARY.getPredicate());
}
private static final FilterControlledCreaturePermanent filterDalek
= new FilterControlledCreaturePermanent("a Dalek");
static {
filterDalek.add(SubType.DALEK.getPredicate());
}
public AcesBaseballBat(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT}, "{2}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.EQUIPMENT);
// Equipped creature gets +3/+0
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new BoostEquippedEffect(3, 0)));
// As long as equipped creature is attacking, it has first strike and must be blocked by a Dalek if able.
Ability ability = new SimpleStaticAbility(new ConditionalContinuousEffect(
new GainAbilityAttachedEffect(FirstStrikeAbility.getInstance(), AttachmentType.EQUIPMENT),
AttachedToAttackingCondition.instance, "As long as equipped creature is attacking, it has first strike"));
ability.addEffect(new MustBeBlockedByAtLeastOneAttachedEffect(filterDalek).concatBy("and"));
this.addAbility(ability);
// Equip legendary creature (1)
this.addAbility(new EquipAbility(Outcome.AddAbility, new GenericManaCost(1), new TargetControlledCreaturePermanent(filterLegendary), false));
// Equip {3}
this.addAbility(new EquipAbility(Outcome.AddAbility, new GenericManaCost(3), false));
}
private AcesBaseballBat(final AcesBaseballBat card) {
super(card);
}
@Override
public AcesBaseballBat copy() {
return new AcesBaseballBat(this);
}
}
enum AttachedToAttackingCondition implements Condition {
instance;
@Override
public boolean apply(Game game, Ability source) {
Permanent attachment = game.getPermanent(source.getSourceId());
if (attachment == null || attachment.getAttachedTo() == null) {
return false;
}
Permanent attachedTo = game.getPermanent(attachment.getAttachedTo());
if (attachedTo == null) {
return false;
}
return attachedTo.isAttacking();
}
} |
Layout: normal
Name: "Ach! Hans, Run!"
Mana Cost: {2}{R}{R}{G}{G}
Cmc: 6.0
Type Line: Enchantment
Oracle Text: At the beginning of your upkeep, you may say "Ach! Hans, run! It's the . . ." and the name of a creature card. If you do, search your library for a card with that name, put it onto the battlefield, then shuffle. That creature gains haste. Exile it at the beginning of the next end step.
Colors: G, R
Color Identity: G, R
Rarity: rare | 1 |
Layout: normal
Name: Achilles Davenport
Mana Cost: {2}{U}{B}
Cmc: 4.0
Type Line: Legendary Creature — Human Assassin
Oracle Text: Freerunning {U}{B} (You may cast this spell for its freerunning cost if you dealt combat damage to a player this turn with an Assassin or commander.)
Menace (This creature can't be blocked except by two or more creatures.)
Other Assassins you control get +1/+1.
Power: 3
Toughness: 3
Colors: B, U
Color Identity: B, U
Keywords: Freerunning, Menace
Rarity: rare | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.common.continuous.BoostControlledEffect;
import mage.abilities.keyword.FreerunningAbility;
import mage.abilities.keyword.MenaceAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.SubType;
import mage.constants.SuperType;
import mage.filter.common.FilterCreaturePermanent;
import java.util.UUID;
public final class AchillesDavenport extends CardImpl {
private static final FilterCreaturePermanent filter = new FilterCreaturePermanent(SubType.ASSASSIN, "Assassins");
public AchillesDavenport(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{U}{B}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.ASSASSIN);
this.power = new MageInt(3);
this.toughness = new MageInt(3);
// Freerunning {U}{B}
this.addAbility(new FreerunningAbility("{U}{B}"));
// Menace
this.addAbility(new MenaceAbility());
// Other Assassins you control get +1/+1.
this.addAbility(new SimpleStaticAbility(new BoostControlledEffect(
1, 1, Duration.WhileOnBattlefield, filter, true
)));
}
private AchillesDavenport(final AchillesDavenport card) {
super(card);
}
@Override
public AchillesDavenport copy() {
return new AchillesDavenport(this);
}
} |
Layout: normal
Name: Acid Rain
Mana Cost: {3}{U}
Cmc: 4.0
Type Line: Sorcery
Oracle Text: Destroy all Forests.
Colors: U
Color Identity: U
Reserved: True
Digital: True
Rarity: rare | package mage.cards.a;
import java.util.UUID;
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;
public final class AcidRain extends CardImpl {
private static final FilterPermanent filter = new FilterPermanent("Forests");
static {
filter.add(SubType.FOREST.getPredicate());
}
public AcidRain(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.SORCERY},"{3}{U}");
// Destroy all Forests.
this.getSpellAbility().addEffect(new DestroyAllEffect(filter));
}
private AcidRain(final AcidRain card) {
super(card);
}
@Override
public AcidRain copy() {
return new AcidRain(this);
}
} |
Layout: normal
Name: Acid-Spewer Dragon
Mana Cost: {5}{B}
Cmc: 6.0
Type Line: Creature — Dragon
Oracle Text: Flying, deathtouch
Megamorph {5}{B}{B} (You may cast this card face down as a 2/2 creature for {3}. Turn it face up any time for its megamorph cost and put a +1/+1 counter on it.)
When Acid-Spewer Dragon is turned face up, put a +1/+1 counter on each other Dragon creature you control.
Power: 3
Toughness: 3
Colors: B
Color Identity: B
Keywords: Deathtouch, Flying, Megamorph
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.TurnedFaceUpSourceTriggeredAbility;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.counter.AddCountersAllEffect;
import mage.abilities.keyword.DeathtouchAbility;
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;
import mage.counters.CounterType;
import mage.filter.common.FilterControlledCreaturePermanent;
import mage.filter.predicate.mageobject.AnotherPredicate;
public final class AcidSpewerDragon extends CardImpl {
private static final FilterControlledCreaturePermanent filter = new FilterControlledCreaturePermanent("other Dragon creature you control");
static {
filter.add(AnotherPredicate.instance);
filter.add(SubType.DRAGON.getPredicate());
}
public AcidSpewerDragon(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{5}{B}");
this.subtype.add(SubType.DRAGON);
this.power = new MageInt(3);
this.toughness = new MageInt(3);
// Flying
this.addAbility(FlyingAbility.getInstance());
// Deathtouch
this.addAbility(DeathtouchAbility.getInstance());
// Megamorph {5}{B}{B}
this.addAbility(new MorphAbility(this, new ManaCostsImpl<>("{5}{B}{B}"), true));
// When Acid-Spewer Dragon is turned face up, put a +1/+1 counter on each other Dragon creature you control.
this.addAbility(new TurnedFaceUpSourceTriggeredAbility(new AddCountersAllEffect(CounterType.P1P1.createInstance(), filter), false, false));
}
private AcidSpewerDragon(final AcidSpewerDragon card) {
super(card);
}
@Override
public AcidSpewerDragon copy() {
return new AcidSpewerDragon(this);
}
} |
Layout: normal
Name: Acid Web Spider
Mana Cost: {3}{G}{G}
Cmc: 5.0
Type Line: Creature — Spider
Oracle Text: Reach
When Acid Web Spider enters, you may destroy target Equipment.
Power: 3
Toughness: 5
Colors: G
Color Identity: G
Keywords: Reach
Rarity: uncommon | 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.DestroyTargetEffect;
import mage.abilities.keyword.ReachAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.filter.FilterPermanent;
import mage.target.TargetPermanent;
public final class AcidWebSpider extends CardImpl {
private static final FilterPermanent filter = new FilterPermanent("Equipment");
static {
filter.add(SubType.EQUIPMENT.getPredicate());
}
public AcidWebSpider (UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{G}{G}");
this.subtype.add(SubType.SPIDER);
this.power = new MageInt(3);
this.toughness = new MageInt(5);
this.addAbility(ReachAbility.getInstance());
Ability ability = new EntersBattlefieldTriggeredAbility(new DestroyTargetEffect(), true);
ability.addTarget(new TargetPermanent(filter));
this.addAbility(ability);
}
private AcidWebSpider(final AcidWebSpider card) {
super(card);
}
@Override
public AcidWebSpider copy() {
return new AcidWebSpider(this);
}
} |
Layout: normal
Name: Acidic Dagger
Mana Cost: {4}
Cmc: 4.0
Type Line: Artifact
Oracle Text: {4}, {T}: Whenever target creature deals combat damage to a non-Wall creature this turn, destroy that non-Wall creature. When the targeted creature leaves the battlefield this turn, sacrifice Acidic Dagger. Activate only before blockers are declared.
Reserved: True
Rarity: rare | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.DelayedTriggeredAbility;
import mage.abilities.condition.common.BeforeBlockersAreDeclaredCondition;
import mage.abilities.costs.common.TapSourceCost;
import mage.abilities.costs.mana.GenericManaCost;
import mage.abilities.decorator.ConditionalActivatedAbility;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.CreateDelayedTriggeredAbilityEffect;
import mage.abilities.effects.common.DestroyTargetEffect;
import mage.abilities.effects.common.SacrificeSourceEffect;
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.filter.predicate.Predicates;
import mage.game.Game;
import mage.game.events.DamagedEvent;
import mage.game.events.GameEvent;
import mage.game.events.ZoneChangeEvent;
import mage.game.permanent.Permanent;
import mage.target.common.TargetCreaturePermanent;
import mage.target.targetpointer.FixedTarget;
import java.util.UUID;
public final class AcidicDagger extends CardImpl {
public AcidicDagger(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT}, "{4}");
// {4}, {tap}: Whenever target creature deals combat damage to a non-Wall creature this turn,
// destroy that non-Wall creature. When the targeted creature leaves the battlefield this turn,
// sacrifice Acidic Dagger. Activate this ability only before blockers are declared.
Ability ability = new ConditionalActivatedAbility(
new CreateDelayedTriggeredAbilityEffect(new AcidicDaggerDestroyNonWallAbility()),
new GenericManaCost(4),
BeforeBlockersAreDeclaredCondition.instance);
ability.addCost(new TapSourceCost());
ability.addTarget(new TargetCreaturePermanent());
ability.addEffect(new CreateDelayedTriggeredAbilityEffect(new AcidicDaggerSacrificeSourceAbility()));
this.addAbility(ability);
}
private AcidicDagger(final AcidicDagger card) {
super(card);
}
@Override
public AcidicDagger copy() {
return new AcidicDagger(this);
}
}
class AcidicDaggerDestroyNonWallAbility extends DelayedTriggeredAbility {
private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("non-Wall creature");
static {
filter.add(Predicates.not(SubType.WALL.getPredicate()));
}
AcidicDaggerDestroyNonWallAbility() {
super(new DestroyTargetEffect(), Duration.EndOfTurn, false);
}
protected AcidicDaggerDestroyNonWallAbility(AcidicDaggerDestroyNonWallAbility ability) {
super(ability);
}
@Override
public boolean checkEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.DAMAGED_PERMANENT;
}
@Override
public boolean checkTrigger(GameEvent event, Game game) {
Permanent damagedPermanent = game.getPermanent(event.getTargetId());
Permanent attackingPermanent = game.getPermanent(event.getSourceId());
Permanent targetedPermanent = game.getPermanent(this.getTargets().getFirstTarget());
if (damagedPermanent == null
|| attackingPermanent == null
|| targetedPermanent == null
|| !filter.match(damagedPermanent, game)
|| !((DamagedEvent) event).isCombatDamage()
|| !attackingPermanent.getId().equals(targetedPermanent.getId())) {
return false;
}
this.getTargets().clear(); // else ability fizzles if target creature died
for (Effect effect : this.getEffects()) {
effect.setTargetPointer(new FixedTarget(damagedPermanent, game));
}
return true;
}
@Override
public AcidicDaggerDestroyNonWallAbility copy() {
return new AcidicDaggerDestroyNonWallAbility(this);
}
@Override
public String getRule() {
return "Whenever target creature deals combat damage to a non-Wall creature this turn, destroy that non-Wall creature.";
}
}
// Based on HeartWolfDelayedTriggeredAbility
class AcidicDaggerSacrificeSourceAbility extends DelayedTriggeredAbility {
AcidicDaggerSacrificeSourceAbility() {
super(new SacrificeSourceEffect(), Duration.EndOfTurn, false);
}
protected AcidicDaggerSacrificeSourceAbility(AcidicDaggerSacrificeSourceAbility ability) {
super(ability);
}
@Override
public boolean checkEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.ZONE_CHANGE;
}
@Override
public boolean checkTrigger(GameEvent event, Game game) {
ZoneChangeEvent zEvent = (ZoneChangeEvent) event;
if (zEvent.getFromZone() == Zone.BATTLEFIELD && zEvent.getTarget() != null && zEvent.getTargetId().equals(getTargets().getFirstTarget())) {
this.getTargets().clear(); // else ability fizzles because target creature died
return true;
}
return false;
}
@Override
public AcidicDaggerSacrificeSourceAbility copy() {
return new AcidicDaggerSacrificeSourceAbility(this);
}
@Override
public String getRule() {
return "When the targeted creature leaves the battlefield this turn, sacrifice {this}.";
}
} |
Layout: normal
Name: Acidic Slime
Mana Cost: {3}{G}{G}
Cmc: 5.0
Type Line: Creature — Ooze
Oracle Text: Deathtouch (Any amount of damage this deals to a creature is enough to destroy it.)
When Acidic Slime enters, destroy target artifact, enchantment, or land.
Power: 2
Toughness: 2
Colors: G
Color Identity: G
Keywords: Deathtouch
Rarity: uncommon | 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.DestroyTargetEffect;
import mage.abilities.keyword.DeathtouchAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.filter.FilterPermanent;
import mage.filter.predicate.Predicates;
import mage.target.Target;
import mage.target.TargetPermanent;
public final class AcidicSlime extends CardImpl {
private static final FilterPermanent filter = new FilterPermanent("artifact, enchantment, or land");
static {
filter.add(Predicates.or(
CardType.ARTIFACT.getPredicate(),
CardType.ENCHANTMENT.getPredicate(),
CardType.LAND.getPredicate()));
}
public AcidicSlime(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{G}{G}");
this.subtype.add(SubType.OOZE);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
this.addAbility(DeathtouchAbility.getInstance());
Ability ability = new EntersBattlefieldTriggeredAbility(new DestroyTargetEffect(), false);
Target target = new TargetPermanent(filter);
ability.addTarget(target);
this.addAbility(ability);
}
private AcidicSlime(final AcidicSlime card) {
super(card);
}
@Override
public AcidicSlime copy() {
return new AcidicSlime(this);
}
} |
Layout: normal
Name: Acidic Sliver
Mana Cost: {B}{R}
Cmc: 2.0
Type Line: Creature — Sliver
Oracle Text: All Slivers have "{2}, Sacrifice this permanent: This permanent deals 2 damage to any target."
Power: 2
Toughness: 2
Colors: B, R
Color Identity: B, R
Digital: True
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.common.SimpleStaticAbility;
import mage.abilities.costs.common.SacrificeSourceCost;
import mage.abilities.costs.mana.GenericManaCost;
import mage.abilities.effects.common.DamageTargetEffect;
import mage.abilities.effects.common.continuous.GainAbilityAllEffect;
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.StaticFilters;
import mage.target.common.TargetAnyTarget;
public final class AcidicSliver extends CardImpl {
public AcidicSliver(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{B}{R}");
this.subtype.add(SubType.SLIVER);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// All Slivers have "{2}, Sacrifice this permanent: This permanent deals 2 damage to any target."
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new DamageTargetEffect(2), new SacrificeSourceCost());
ability.addCost(new GenericManaCost(2));
ability.addTarget(new TargetAnyTarget());
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD,
new GainAbilityAllEffect(ability,
Duration.WhileOnBattlefield, StaticFilters.FILTER_PERMANENT_ALL_SLIVERS,
"All Slivers have \"{2}, Sacrifice this permanent: This permanent deals 2 damage to any target.\"")));
}
private AcidicSliver(final AcidicSliver card) {
super(card);
}
@Override
public AcidicSliver copy() {
return new AcidicSliver(this);
}
} |
Layout: normal
Name: Acidic Soil
Mana Cost: {2}{R}
Cmc: 3.0
Type Line: Sorcery
Oracle Text: Acidic Soil deals damage to each player equal to the number of lands they control.
Colors: R
Color Identity: R
Rarity: uncommon | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.effects.OneShotEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Outcome;
import mage.filter.StaticFilters;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.players.Player;
import java.util.List;
import java.util.UUID;
public final class AcidicSoil extends CardImpl {
public AcidicSoil(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{2}{R}");
//Acidic Soil deals damage to each player equal to the number of lands they control.
this.getSpellAbility().addEffect(new AcidicSoilEffect());
}
private AcidicSoil(final AcidicSoil card) {
super(card);
}
@Override
public AcidicSoil copy() {
return new AcidicSoil(this);
}
}
class AcidicSoilEffect extends OneShotEffect {
AcidicSoilEffect() {
super(Outcome.Damage);
staticText = "{this} deals damage to each player equal to the number of lands they control";
}
private AcidicSoilEffect(final AcidicSoilEffect effect) {
super(effect);
}
@Override
public boolean apply(Game game, Ability source) {
List<Permanent> permanents = game.getBattlefield().getActivePermanents(StaticFilters.FILTER_LAND, source.getControllerId(), source, game);
for (UUID playerId : game.getState().getPlayersInRange(source.getControllerId(), game)) {
Player player = game.getPlayer(playerId);
if (player != null) {
int amount = 0;
for (Permanent permanent : permanents) {
if (permanent.isControlledBy(playerId)) {
amount++;
}
}
if (amount > 0) {
player.damage(amount, source.getSourceId(), source, game);
}
}
}
return true;
}
@Override
public AcidicSoilEffect copy() {
return new AcidicSoilEffect(this);
}
} |
Layout: transform
Name: Aclazotz, Deepest Betrayal
Mana Cost: {3}{B}{B}
Type Line: Legendary Creature — Bat God
Oracle Text: Flying, lifelink
Whenever Aclazotz attacks, each opponent discards a card. For each opponent who can't, you draw a card.
Whenever an opponent discards a land card, create a 1/1 black Bat creature token with flying.
When Aclazotz dies, return it to the battlefield tapped and transformed under its owner's control.
Colors: B
Power: 4
Toughness: 4
Name: Temple of the Dead
Type Line: Land
Oracle Text: (Transforms from Aclazotz, Deepest Betrayal.)
{T}: Add {B}.
{2}{B}, {T}: Transform Temple of the Dead. Activate only if a player has one or fewer cards in hand and only as a sorcery. | package mage.cards.a;
import mage.MageInt;
import mage.MageObject;
import mage.abilities.Ability;
import mage.abilities.TriggeredAbilityImpl;
import mage.abilities.common.AttacksTriggeredAbility;
import mage.abilities.common.DiesSourceTriggeredAbility;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.CreateTokenEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.LifelinkAbility;
import mage.abilities.keyword.TransformAbility;
import mage.cards.*;
import mage.constants.*;
import mage.filter.StaticFilters;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.game.permanent.token.BatToken;
import mage.players.Player;
import mage.target.Target;
import mage.target.common.TargetDiscard;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
public final class AclazotzDeepestBetrayal extends CardImpl {
public AclazotzDeepestBetrayal(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{B}{B}");
this.secondSideCardClazz = mage.cards.t.TempleOfTheDead.class;
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.BAT);
this.subtype.add(SubType.GOD);
this.power = new MageInt(4);
this.toughness = new MageInt(4);
// Flying
this.addAbility(FlyingAbility.getInstance());
// Lifelink
this.addAbility(LifelinkAbility.getInstance());
// Whenever Aclazotz attacks, each opponent discards a card. For each opponent who can't, you draw a card.
this.addAbility(new AttacksTriggeredAbility(new AclazotzDeepestBetrayalEffect()));
// Whenever an opponent discards a land card, create a 1/1 black Bat creature token with flying.
this.addAbility(new AclazotzDeepestBetrayalTriggeredAbility());
// When Aclazotz dies, return it to the battlefield tapped and transformed under its owner's control.
this.addAbility(new TransformAbility());
this.addAbility(new DiesSourceTriggeredAbility(new AclazotzDeepestBetrayalTransformEffect()));
}
private AclazotzDeepestBetrayal(final AclazotzDeepestBetrayal card) {
super(card);
}
@Override
public AclazotzDeepestBetrayal copy() {
return new AclazotzDeepestBetrayal(this);
}
}
// Inspired by Cruel Grimnarch
class AclazotzDeepestBetrayalEffect extends OneShotEffect {
AclazotzDeepestBetrayalEffect() {
super(Outcome.Benefit);
this.staticText = "each opponent discards a card. For each opponent who can't, you draw a card";
}
private AclazotzDeepestBetrayalEffect(final AclazotzDeepestBetrayalEffect effect) {
super(effect);
}
@Override
public AclazotzDeepestBetrayalEffect copy() {
return new AclazotzDeepestBetrayalEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
Map<UUID, Cards> cardsToDiscard = new HashMap<>();
// choose cards to discard
for (UUID playerId : game.getOpponents(source.getControllerId(), true)) {
Player player = game.getPlayer(playerId);
if (player == null) {
continue;
}
int numberOfCardsToDiscard = Math.min(1, player.getHand().size());
Cards cards = new CardsImpl();
Target target = new TargetDiscard(numberOfCardsToDiscard, numberOfCardsToDiscard, StaticFilters.FILTER_CARD, playerId);
player.chooseTarget(outcome, target, source, game);
cards.addAll(target.getTargets());
cardsToDiscard.put(playerId, cards);
}
// discard all chosen cards
for (UUID playerId : game.getOpponents(source.getControllerId(), true)) {
Player player = game.getPlayer(playerId);
if (player == null) {
continue;
}
int amountDiscarded = player.discard(cardsToDiscard.get(playerId), false, source, game).size();
if (amountDiscarded == 0 && controller != null) {
controller.drawCards(1, source, game);
}
}
return true;
}
}
// Inspired by Waste Not
class AclazotzDeepestBetrayalTriggeredAbility extends TriggeredAbilityImpl {
AclazotzDeepestBetrayalTriggeredAbility() {
super(Zone.BATTLEFIELD, new CreateTokenEffect(new BatToken()), false);
setTriggerPhrase("Whenever an opponent discards a land card, ");
}
private AclazotzDeepestBetrayalTriggeredAbility(final AclazotzDeepestBetrayalTriggeredAbility ability) {
super(ability);
}
@Override
public AclazotzDeepestBetrayalTriggeredAbility copy() {
return new AclazotzDeepestBetrayalTriggeredAbility(this);
}
@Override
public boolean checkEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.DISCARDED_CARD;
}
@Override
public boolean checkTrigger(GameEvent event, Game game) {
if (game.getOpponents(this.getControllerId()).contains(event.getPlayerId())) {
Card discarded = game.getCard(event.getTargetId());
return discarded != null && discarded.isLand(game);
}
return false;
}
}
// Inspired by Edgar, Charmed Groom
class AclazotzDeepestBetrayalTransformEffect extends OneShotEffect {
AclazotzDeepestBetrayalTransformEffect() {
super(Outcome.Benefit);
staticText = "return it to the battlefield tapped and transformed under its owner's control";
}
private AclazotzDeepestBetrayalTransformEffect(final AclazotzDeepestBetrayalTransformEffect effect) {
super(effect);
}
@Override
public AclazotzDeepestBetrayalTransformEffect copy() {
return new AclazotzDeepestBetrayalTransformEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
Card card = source.getSourceCardIfItStillExists(game);
if (controller == null || card == null) {
return false;
}
game.getState().setValue(TransformAbility.VALUE_KEY_ENTER_TRANSFORMED + source.getSourceId(), Boolean.TRUE);
controller.moveCards(card, Zone.BATTLEFIELD, source, game, true, false, true, null);
return true;
}
} |
Layout: normal
Name: Acolyte Hybrid
Mana Cost: {2}{R}
Cmc: 3.0
Type Line: Creature — Tyranid Human
Oracle Text: Heavy Rock Cutter — Whenever Acolyte Hybrid attacks, destroy up to one target artifact. If an artifact is destroyed this way, its controller draws a card.
Power: 2
Toughness: 2
Colors: R
Color Identity: R
Keywords: Heavy Rock Cutter
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.AttacksTriggeredAbility;
import mage.abilities.effects.OneShotEffect;
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;
import mage.target.common.TargetArtifactPermanent;
import java.util.UUID;
public final class AcolyteHybrid extends CardImpl {
public AcolyteHybrid(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{R}");
this.subtype.add(SubType.TYRANID);
this.subtype.add(SubType.HUMAN);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// Heavy Rock Cutter -- Whenever Acolyte Hybrid attacks, destroy up to one target artifact. If an artifact is destroyed this way, its controller draws a card.
Ability ability = new AttacksTriggeredAbility(new AcolyteHybridEffect());
ability.addTarget(new TargetArtifactPermanent(0, 1));
this.addAbility(ability.withFlavorWord("Heavy Rock Cutter"));
}
private AcolyteHybrid(final AcolyteHybrid card) {
super(card);
}
@Override
public AcolyteHybrid copy() {
return new AcolyteHybrid(this);
}
}
class AcolyteHybridEffect extends OneShotEffect {
AcolyteHybridEffect() {
super(Outcome.Benefit);
staticText = "destroy up to one target artifact. " +
"If an artifact is destroyed this way, its controller draws a card";
}
private AcolyteHybridEffect(final AcolyteHybridEffect effect) {
super(effect);
}
@Override
public AcolyteHybridEffect copy() {
return new AcolyteHybridEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Permanent permanent = game.getPermanent(getTargetPointer().getFirst(game, source));
if (permanent == null || !permanent.destroy(source, game)) {
return false;
}
Player player = game.getPlayer(permanent.getControllerId());
if (player != null) {
player.drawCards(1, source, game);
}
return true;
}
} |
Layout: normal
Name: Acolyte of Aclazotz
Mana Cost: {2}{B}
Cmc: 3.0
Type Line: Creature — Vampire Cleric
Oracle Text: {T}, Sacrifice another creature or artifact: Each opponent loses 1 life and you gain 1 life.
Power: 1
Toughness: 4
Colors: B
Color Identity: B
Rarity: common | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.common.SacrificeTargetCost;
import mage.abilities.costs.common.TapSourceCost;
import mage.abilities.effects.common.GainLifeEffect;
import mage.abilities.effects.common.LoseLifeOpponentsEffect;
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 AcolyteOfAclazotz extends CardImpl {
public AcolyteOfAclazotz(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{B}");
this.subtype.add(SubType.VAMPIRE);
this.subtype.add(SubType.CLERIC);
this.power = new MageInt(1);
this.toughness = new MageInt(4);
// {T}, Sacrifice another creature or artifact: Each opponent loses 1 life and you gain 1 life.
Ability ability = new SimpleActivatedAbility(new LoseLifeOpponentsEffect(1), new TapSourceCost());
ability.addCost(new SacrificeTargetCost(StaticFilters.FILTER_CONTROLLED_ANOTHER_CREATURE_OR_ARTIFACT));
ability.addEffect(new GainLifeEffect(1).concatBy("and"));
this.addAbility(ability);
}
private AcolyteOfAclazotz(final AcolyteOfAclazotz card) {
super(card);
}
@Override
public AcolyteOfAclazotz copy() {
return new AcolyteOfAclazotz(this);
}
} |
Layout: normal
Name: Acolyte of Affliction
Mana Cost: {2}{B}{G}
Cmc: 4.0
Type Line: Creature — Human Cleric
Oracle Text: When Acolyte of Affliction enters, mill two cards, then you may return a permanent card from your graveyard to your hand.
Power: 2
Toughness: 3
Colors: B, G
Color Identity: B, G
Keywords: Mill
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.cards.Card;
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.filter.FilterCard;
import mage.filter.common.FilterPermanentCard;
import mage.game.Game;
import mage.players.Player;
import mage.target.TargetCard;
import mage.target.common.TargetCardInYourGraveyard;
import java.util.UUID;
public final class AcolyteOfAffliction extends CardImpl {
public AcolyteOfAffliction(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{B}{G}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.CLERIC);
this.power = new MageInt(2);
this.toughness = new MageInt(3);
// When Acolyte of Affliction enters the battlefield, put the top two cards of your library into your graveyard, then you may return a permanent card from your graveyard to your hand.
this.addAbility(new EntersBattlefieldTriggeredAbility(new AcolyteOfAfflictionEffect()));
}
private AcolyteOfAffliction(final AcolyteOfAffliction card) {
super(card);
}
@Override
public AcolyteOfAffliction copy() {
return new AcolyteOfAffliction(this);
}
}
class AcolyteOfAfflictionEffect extends OneShotEffect {
private static final FilterCard filter = new FilterPermanentCard("permanent card from your graveyard");
AcolyteOfAfflictionEffect() {
super(Outcome.Benefit);
staticText = "mill two cards, then you may return a permanent card from your graveyard to your hand.";
}
private AcolyteOfAfflictionEffect(final AcolyteOfAfflictionEffect effect) {
super(effect);
}
@Override
public AcolyteOfAfflictionEffect copy() {
return new AcolyteOfAfflictionEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player player = game.getPlayer(source.getControllerId());
if (player == null) {
return false;
}
player.moveCards(player.getLibrary().getTopCards(game, 2), Zone.GRAVEYARD, source, game);
TargetCard target = new TargetCardInYourGraveyard(0, 1, filter, true);
if (!player.choose(Outcome.ReturnToHand, target, source, game)) {
return true;
}
Card card = game.getCard(target.getFirstTarget());
if (card == null) {
return true;
}
player.moveCards(card, Zone.HAND, source, game);
return true;
}
} |
Layout: normal
Name: Acolyte of Bahamut
Mana Cost: {1}{G}
Cmc: 2.0
Type Line: Legendary Enchantment — Background
Oracle Text: Commander creatures you own have "The first Dragon spell you cast each turn costs {2} less to cast."
Colors: G
Color Identity: G
Rarity: uncommon | package mage.cards.a;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.common.continuous.GainAbilityAllEffect;
import mage.abilities.effects.common.cost.SpellsCostReductionControllerEffect;
import mage.cards.Card;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.filter.FilterCard;
import mage.filter.StaticFilters;
import mage.filter.predicate.ObjectSourcePlayer;
import mage.filter.predicate.ObjectSourcePlayerPredicate;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.game.stack.Spell;
import mage.watchers.Watcher;
import java.util.HashSet;
import java.util.Set;
import java.util.UUID;
public final class AcolyteOfBahamut extends CardImpl {
private static final FilterCard filter = new FilterCard("the first Dragon spell you cast each turn");
static {
filter.add(SubType.DRAGON.getPredicate());
filter.add(AcolyteOfBahamutPredicate.instance);
}
public AcolyteOfBahamut(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{1}{G}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.BACKGROUND);
// Commander creatures you own have "The first Dragon spell you cast each turn costs {2} less to cast."
this.addAbility(new SimpleStaticAbility(new GainAbilityAllEffect(
new SimpleStaticAbility(new SpellsCostReductionControllerEffect(filter, 2)),
Duration.WhileOnBattlefield,
StaticFilters.FILTER_CREATURES_OWNED_COMMANDER
).withForceQuotes()), new AcolyteOfBahamutWatcher());
}
private AcolyteOfBahamut(final AcolyteOfBahamut card) {
super(card);
}
@Override
public AcolyteOfBahamut copy() {
return new AcolyteOfBahamut(this);
}
}
enum AcolyteOfBahamutPredicate implements ObjectSourcePlayerPredicate<Card> {
instance;
@Override
public boolean apply(ObjectSourcePlayer<Card> input, Game game) {
return input.getObject().hasSubtype(SubType.DRAGON, game)
&& !AcolyteOfBahamutWatcher.checkPlayer(input.getPlayerId(), game);
}
}
class AcolyteOfBahamutWatcher extends Watcher {
private final Set<UUID> playerSet = new HashSet<>();
AcolyteOfBahamutWatcher() {
super(WatcherScope.GAME);
}
@Override
public void watch(GameEvent event, Game game) {
if (event.getType() != GameEvent.EventType.SPELL_CAST) {
return;
}
Spell spell = game.getStack().getSpell(event.getTargetId());
if (spell != null && spell.hasSubtype(SubType.DRAGON, game)) {
playerSet.add(event.getPlayerId());
}
}
@Override
public void reset() {
super.reset();
playerSet.clear();
}
public static boolean checkPlayer(UUID playerId, Game game) {
return game
.getState()
.getWatcher(AcolyteOfBahamutWatcher.class)
.playerSet
.contains(playerId);
}
} |
Layout: normal
Name: Acolyte of the Inferno
Mana Cost: {2}{R}
Cmc: 3.0
Type Line: Creature — Human Monk
Oracle Text: Renown 1 (When this creature deals combat damage to a player, if it isn't renowned, put a +1/+1 counter on it and it becomes renowned.)
Whenever Acolyte of the Inferno becomes blocked by a creature, it deals 2 damage to that creature.
Power: 3
Toughness: 1
Colors: R
Color Identity: R
Keywords: Renown
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.BecomesBlockedByCreatureTriggeredAbility;
import mage.abilities.effects.common.DamageTargetEffect;
import mage.abilities.keyword.RenownAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
public final class AcolyteOfTheInferno extends CardImpl {
public AcolyteOfTheInferno(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{2}{R}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.MONK);
this.power = new MageInt(3);
this.toughness = new MageInt(1);
// Renown 1
this.addAbility(new RenownAbility(1));
// Whenever Acolyte of the Inferno becomes blocked by a creature, it deals 2 damage to that creature
this.addAbility(new BecomesBlockedByCreatureTriggeredAbility(new DamageTargetEffect(2, true, "that creature", "it"), false));
}
private AcolyteOfTheInferno(final AcolyteOfTheInferno card) {
super(card);
}
@Override
public AcolyteOfTheInferno copy() {
return new AcolyteOfTheInferno(this);
}
} |
Layout: normal
Name: Acolyte of Xathrid
Mana Cost: {B}
Cmc: 1.0
Type Line: Creature — Human Cleric
Oracle Text: {1}{B}, {T}: Target player loses 1 life.
Power: 0
Toughness: 1
Colors: B
Color Identity: B
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.LoseLifeTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.Zone;
import mage.target.TargetPlayer;
public final class AcolyteOfXathrid extends CardImpl {
public AcolyteOfXathrid(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{B}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.CLERIC);
this.power = new MageInt(0);
this.toughness = new MageInt(1);
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new LoseLifeTargetEffect(1), new ManaCostsImpl<>("{1}{B}"));
ability.addCost(new TapSourceCost());
ability.addTarget(new TargetPlayer());
this.addAbility(ability);
}
private AcolyteOfXathrid(final AcolyteOfXathrid card) {
super(card);
}
@Override
public AcolyteOfXathrid copy() {
return new AcolyteOfXathrid(this);
}
} |
Layout: normal
Name: Acolyte's Reward
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Instant
Oracle Text: Prevent the next X damage that would be dealt to target creature this turn, where X is your devotion to white. If damage is prevented this way, Acolyte's Reward deals that much damage to any target. (Each {W} in the mana costs of permanents you control counts toward your devotion to white.)
Colors: W
Color Identity: W
Rarity: uncommon | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.dynamicvalue.common.DevotionCount;
import mage.abilities.effects.PreventionEffectImpl;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.game.Game;
import mage.game.events.DamageEvent;
import mage.game.events.GameEvent;
import mage.game.events.PreventDamageEvent;
import mage.game.events.PreventedDamageEvent;
import mage.game.permanent.Permanent;
import mage.players.Player;
import mage.target.common.TargetAnyTarget;
import mage.target.common.TargetCreaturePermanent;
import java.util.UUID;
public final class AcolytesReward extends CardImpl {
public AcolytesReward(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{W}");
// Prevent the next X damage that would be dealt to target creature this turn, where X is your devotion to white. If damage is prevented this way, Acolyte's Reward deals that much damage to any target.
this.getSpellAbility().addEffect(new AcolytesRewardEffect());
this.getSpellAbility().addTarget(new TargetCreaturePermanent());
this.getSpellAbility().addTarget(new TargetAnyTarget());
this.getSpellAbility().addHint(DevotionCount.W.getHint());
}
private AcolytesReward(final AcolytesReward card) {
super(card);
}
@Override
public AcolytesReward copy() {
return new AcolytesReward(this);
}
}
class AcolytesRewardEffect extends PreventionEffectImpl {
protected int amount = 0;
AcolytesRewardEffect() {
super(Duration.EndOfTurn);
staticText = "Prevent the next X damage that would be dealt to target creature this turn, where X is your devotion to white. If damage is prevented this way, {this} deals that much damage to any target";
}
private AcolytesRewardEffect(final AcolytesRewardEffect effect) {
super(effect);
this.amount = effect.amount;
}
@Override
public AcolytesRewardEffect copy() {
return new AcolytesRewardEffect(this);
}
@Override
public void init(Ability source, Game game) {
super.init(source, game);
amount = DevotionCount.W.calculate(game, source, this);
}
@Override
public boolean replaceEvent(GameEvent event, Ability source, Game game) {
boolean result = false;
int toPrevent = amount;
if (event.getAmount() < this.amount) {
toPrevent = event.getAmount();
amount -= event.getAmount();
} else {
amount = 0;
}
GameEvent preventEvent = new PreventDamageEvent(event.getTargetId(), source.getSourceId(), source, source.getControllerId(), toPrevent, ((DamageEvent) event).isCombatDamage());
if (game.replaceEvent(preventEvent)) {
return result;
}
Permanent targetCreature = game.getPermanent(event.getTargetId());
if (targetCreature == null) {
return result;
}
if (amount == 0) {
this.used = true;
this.discard();
}
if (event.getAmount() >= toPrevent) {
event.setAmount(event.getAmount() - toPrevent);
} else {
event.setAmount(0);
result = true;
}
if (toPrevent == 0) {
return result;
}
game.informPlayers("Acolyte's Reward prevented " + toPrevent + " to " + targetCreature.getName());
game.fireEvent(new PreventedDamageEvent(event.getTargetId(), source.getSourceId(), source, source.getControllerId(), toPrevent));
Player targetPlayer = game.getPlayer(source.getTargets().get(1).getFirstTarget());
if (targetPlayer != null) {
targetPlayer.damage(toPrevent, source.getSourceId(), source, game);
game.informPlayers("Acolyte's Reward deals " + toPrevent + " damage to " + targetPlayer.getLogName());
return result;
}
Permanent targetDamageCreature = game.getPermanent(source.getTargets().get(1).getFirstTarget());
if (targetDamageCreature == null) {
return result;
}
targetDamageCreature.damage(toPrevent, source.getSourceId(), source, game, false, true);
game.informPlayers("Acolyte's Reward deals " + toPrevent + " damage to " + targetDamageCreature.getName());
return result;
}
@Override
public boolean applies(GameEvent event, Ability source, Game game) {
return !this.used && super.applies(event, source, game) && event.getTargetId().equals(source.getFirstTarget());
}
} |
Layout: normal
Name: Acorn Catapult
Mana Cost: {4}
Cmc: 4.0
Type Line: Artifact
Oracle Text: {1}, {T}: Acorn Catapult deals 1 damage to any target. That permanent's controller or that player creates a 1/1 green Squirrel creature token.
Rarity: rare | package mage.cards.a;
import java.util.UUID;
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.OneShotEffect;
import mage.abilities.effects.common.DamageTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Outcome;
import mage.constants.Zone;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.game.permanent.token.SquirrelToken;
import mage.players.Player;
import mage.target.common.TargetAnyTarget;
public final class AcornCatapult extends CardImpl {
public AcornCatapult(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT}, "{4}");
// {1}, {T}: Acorn Catapult deals 1 damage to any target. That creature's controller or that player creates a 1/1 green Squirrel creature token.
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new DamageTargetEffect(1), new ManaCostsImpl<>("{1}"));
ability.addCost(new TapSourceCost());
ability.addEffect(new AcornCatapultEffect());
ability.addTarget(new TargetAnyTarget());
this.addAbility(ability);
}
private AcornCatapult(final AcornCatapult card) {
super(card);
}
@Override
public AcornCatapult copy() {
return new AcornCatapult(this);
}
}
class AcornCatapultEffect extends OneShotEffect {
AcornCatapultEffect() {
super(Outcome.PutCreatureInPlay);
staticText = "that creature's controller or that player creates a 1/1 green Squirrel creature token";
}
private AcornCatapultEffect(final AcornCatapultEffect effect) {
super(effect);
}
@Override
public AcornCatapultEffect copy() {
return new AcornCatapultEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player player = game.getPlayer(getTargetPointer().getFirst(game, source));
if (player == null) {
Permanent permanent = getTargetPointer().getFirstTargetPermanentOrLKI(game, source);
if (permanent != null) {
player = game.getPlayer(permanent.getControllerId());
}
}
if (player != null) {
new SquirrelToken().putOntoBattlefield(1, game, source, player.getId());
return true;
}
return false;
}
} |
Layout: normal
Name: Acorn Harvest
Mana Cost: {3}{G}
Cmc: 4.0
Type Line: Sorcery
Oracle Text: Create two 1/1 green Squirrel creature tokens.
Flashback—{1}{G}, Pay 3 life. (You may cast this card from your graveyard for its flashback cost. Then exile it.)
Colors: G
Color Identity: G
Keywords: Flashback
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.costs.common.PayLifeCost;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.CreateTokenEffect;
import mage.abilities.keyword.FlashbackAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.TimingRule;
import mage.game.permanent.token.SquirrelToken;
public final class AcornHarvest extends CardImpl {
public AcornHarvest(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.SORCERY},"{3}{G}");
// Create two 1/1 green Squirrel creature tokens.
this.getSpellAbility().addEffect(new CreateTokenEffect(new SquirrelToken(), 2));
// Flashback-{1}{G} - Pay 3 life.
FlashbackAbility ability = new FlashbackAbility(this, new ManaCostsImpl<>("{1}{G}"));
ability.addCost(new PayLifeCost(3));
this.addAbility(ability);
}
private AcornHarvest(final AcornHarvest card) {
super(card);
}
@Override
public AcornHarvest copy() {
return new AcornHarvest(this);
}
} |
Layout: normal
Name: Acquire
Mana Cost: {3}{U}{U}
Cmc: 5.0
Type Line: Sorcery
Oracle Text: Search target opponent's library for an artifact card and put that card onto the battlefield under your control. Then that player shuffles.
Colors: U
Color Identity: U
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.abilities.Ability;
import mage.abilities.effects.OneShotEffect;
import mage.cards.Card;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Outcome;
import mage.constants.Zone;
import mage.filter.FilterCard;
import mage.game.Game;
import mage.players.Player;
import mage.target.common.TargetCardInLibrary;
import mage.target.common.TargetOpponent;
public final class Acquire extends CardImpl {
public Acquire(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.SORCERY},"{3}{U}{U}");
// Search target opponent's library for an artifact card and put that card onto the battlefield under your control.
// Then that player shuffles their library.
this.getSpellAbility().addEffect(new AcquireEffect());
this.getSpellAbility().addTarget(new TargetOpponent());
}
private Acquire(final Acquire card) {
super(card);
}
@Override
public Acquire copy() {
return new Acquire(this);
}
}
class AcquireEffect extends OneShotEffect {
private static final FilterCard filter = new FilterCard("an artifact card");
static {
filter.add(CardType.ARTIFACT.getPredicate());
}
public AcquireEffect() {
super(Outcome.PutCardInPlay);
staticText = "Search target opponent's library for an artifact card and put that card onto the battlefield under your control. Then that player shuffles";
}
private AcquireEffect(final AcquireEffect effect) {
super(effect);
}
@Override
public boolean apply(Game game, Ability source) {
Player opponent = game.getPlayer(source.getFirstTarget());
Player controller = game.getPlayer(source.getControllerId());
if (opponent != null && controller != null) {
TargetCardInLibrary target = new TargetCardInLibrary(filter);
controller.searchLibrary(target, source, game, opponent.getId());
Card targetCard = game.getCard(target.getFirstTarget());
if (targetCard != null) {
controller.moveCards(targetCard, Zone.BATTLEFIELD, source, game);
}
opponent.shuffleLibrary(source, game);
return true;
}
return false;
}
@Override
public AcquireEffect copy() {
return new AcquireEffect(this);
}
} |
Layout: normal
Name: Acquired Mutation
Mana Cost: {2}{R}
Cmc: 3.0
Type Line: Enchantment — Aura
Oracle Text: Enchant creature
Enchanted creature gets +2/+2 and is goaded. (It attacks each combat if able and attacks a player other than you if able.)
Whenever enchanted creature attacks, defending player gets two rad counters.
Colors: R
Color Identity: R
Keywords: Goad, Enchant
Rarity: uncommon | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.common.AttacksAttachedTriggeredAbility;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.common.AttachEffect;
import mage.abilities.effects.common.combat.GoadAttachedEffect;
import mage.abilities.effects.common.continuous.BoostEnchantedEffect;
import mage.abilities.effects.common.counter.AddCountersTargetEffect;
import mage.abilities.keyword.EnchantAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.counters.CounterType;
import mage.target.TargetPermanent;
import mage.target.common.TargetCreaturePermanent;
import java.util.UUID;
public final class AcquiredMutation extends CardImpl {
public AcquiredMutation(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{2}{R}");
this.subtype.add(SubType.AURA);
// Enchant creature
TargetPermanent auraTarget = new TargetCreaturePermanent();
this.getSpellAbility().addTarget(auraTarget);
this.getSpellAbility().addEffect(new AttachEffect(Outcome.BoostCreature));
this.addAbility(new EnchantAbility(auraTarget));
// Enchanted creature gets +2/+2 and is goaded.
Ability ability = new SimpleStaticAbility(new BoostEnchantedEffect(2, 2));
ability.addEffect(new GoadAttachedEffect());
this.addAbility(ability);
// Whenever enchanted creature attacks, defending player gets two rad counters.
this.addAbility(new AttacksAttachedTriggeredAbility(
new AddCountersTargetEffect(CounterType.RAD.createInstance(2))
.setText("defending player gets two rad counters"),
AttachmentType.AURA, false, SetTargetPointer.PLAYER
));
}
private AcquiredMutation(final AcquiredMutation card) {
super(card);
}
@Override
public AcquiredMutation copy() {
return new AcquiredMutation(this);
}
} |
Layout: normal
Name: Acquisition Octopus
Mana Cost: {2}{U}
Cmc: 3.0
Type Line: Artifact Creature — Equipment Octopus
Oracle Text: Whenever Acquisition Octopus or equipped creature deals combat damage to a player, draw a card.
Reconfigure {2} ({2}: Attach to target creature you control; or unattach from a creature. Reconfigure only as a sorcery. While attached, this isn't a creature.)
Power: 2
Toughness: 2
Colors: U
Color Identity: U
Keywords: Reconfigure
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.TriggeredAbilityImpl;
import mage.abilities.effects.common.DrawCardSourceControllerEffect;
import mage.abilities.keyword.ReconfigureAbility;
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.DamagedEvent;
import mage.game.events.GameEvent;
import mage.game.permanent.Permanent;
import java.util.UUID;
public final class AcquisitionOctopus extends CardImpl {
public AcquisitionOctopus(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{2}{U}");
this.subtype.add(SubType.EQUIPMENT);
this.subtype.add(SubType.OCTOPUS);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// When Acquisition Octopus or equipped creature deals combat damage to a player, draw a card.
this.addAbility(new AcquisitionOctopusTriggeredAbility());
// Reconfigure {2}
this.addAbility(new ReconfigureAbility("{2}"));
}
private AcquisitionOctopus(final AcquisitionOctopus card) {
super(card);
}
@Override
public AcquisitionOctopus copy() {
return new AcquisitionOctopus(this);
}
}
class AcquisitionOctopusTriggeredAbility extends TriggeredAbilityImpl {
AcquisitionOctopusTriggeredAbility() {
super(Zone.BATTLEFIELD, new DrawCardSourceControllerEffect(1));
}
private AcquisitionOctopusTriggeredAbility(final AcquisitionOctopusTriggeredAbility ability) {
super(ability);
}
@Override
public AcquisitionOctopusTriggeredAbility copy() {
return new AcquisitionOctopusTriggeredAbility(this);
}
@Override
public boolean checkEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.DAMAGED_PLAYER;
}
@Override
public boolean checkTrigger(GameEvent event, Game game) {
if (!((DamagedEvent) event).isCombatDamage()) {
return false;
}
if (getSourceId().equals(event.getSourceId())) {
return true;
}
Permanent permanent = getSourcePermanentOrLKI(game);
return permanent != null && event.getSourceId().equals(permanent.getAttachedTo());
}
@Override
public String getRule() {
return "Whenever {this} or equipped creature deals combat damage to a player, draw a card.";
}
} |
Layout: normal
Name: Acquisitions Expert
Mana Cost: {1}{B}
Cmc: 2.0
Type Line: Creature — Human Rogue
Oracle Text: When Acquisitions Expert enters, target opponent reveals a number of cards from their hand equal to the number of creatures in your party. You choose one of those cards. That player discards that card. (Your party consists of up to one each of Cleric, Rogue, Warrior, and Wizard.)
Power: 1
Toughness: 2
Colors: B
Color Identity: B
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.dynamicvalue.common.PartyCount;
import mage.abilities.effects.common.discard.DiscardCardYouChooseTargetEffect;
import mage.abilities.hint.common.PartyCountHint;
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 AcquisitionsExpert extends CardImpl {
public AcquisitionsExpert(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{B}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.ROGUE);
this.power = new MageInt(1);
this.toughness = new MageInt(2);
// When Acquisitions Expert enters the battlefield, target opponent reveals a number of cards from their hand equal to the number of creatures in your party. You choose one of those cards. That player discards that card.
Ability ability = new EntersBattlefieldTriggeredAbility(
new DiscardCardYouChooseTargetEffect(PartyCount.instance)
.setText("target opponent reveals a number of cards from their hand " +
"equal to the number of creatures in your party. You choose one of those cards. " +
"That player discards that card. " + PartyCount.getReminder())
);
ability.addTarget(new TargetOpponent());
this.addAbility(ability.addHint(PartyCountHint.instance));
}
private AcquisitionsExpert(final AcquisitionsExpert card) {
super(card);
}
@Override
public AcquisitionsExpert copy() {
return new AcquisitionsExpert(this);
}
} |
Layout: normal
Name: Acridian
Mana Cost: {1}{G}
Cmc: 2.0
Type Line: Creature — Insect
Oracle Text: Echo {1}{G} (At the beginning of your upkeep, if this came under your control since the beginning of your last upkeep, sacrifice it unless you pay its echo cost.)
Power: 2
Toughness: 4
Colors: G
Color Identity: G
Keywords: Echo
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.keyword.EchoAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
public final class Acridian extends CardImpl {
public Acridian (UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{1}{G}");
this.subtype.add(SubType.INSECT);
this.power = new MageInt(2);
this.toughness = new MageInt(4);
this.addAbility(new EchoAbility("{1}{G}"));
}
private Acridian(final Acridian card) {
super(card);
}
@Override
public Acridian copy() {
return new Acridian(this);
}
} |
Layout: normal
Name: Acrobatic Leap
Mana Cost: {W}
Cmc: 1.0
Type Line: Instant
Oracle Text: Target creature gets +1/+3 and gains flying until end of turn. Untap it.
Colors: W
Color Identity: W
Rarity: common | package mage.cards.a;
import mage.abilities.effects.common.UntapTargetEffect;
import mage.abilities.effects.common.continuous.BoostTargetEffect;
import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.target.common.TargetCreaturePermanent;
import java.util.UUID;
public final class AcrobaticLeap extends CardImpl {
public AcrobaticLeap(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{W}");
// Target creature gets +1/+3 and gains flying until end of turn. Untap it.
this.getSpellAbility().addEffect(new BoostTargetEffect(
1, 3, Duration.EndOfTurn
).setText("Target creature gets +1/+3"));
this.getSpellAbility().addEffect(new GainAbilityTargetEffect(
FlyingAbility.getInstance(), Duration.EndOfTurn
).setText("and gains flying until end of turn"));
this.getSpellAbility().addEffect(new UntapTargetEffect("untap it"));
this.getSpellAbility().addTarget(new TargetCreaturePermanent());
}
private AcrobaticLeap(final AcrobaticLeap card) {
super(card);
}
@Override
public AcrobaticLeap copy() {
return new AcrobaticLeap(this);
}
} |
Layout: normal
Name: Acrobatic Maneuver
Mana Cost: {2}{W}
Cmc: 3.0
Type Line: Instant
Oracle Text: Exile target creature you control, then return that card to the battlefield under its owner's control.
Draw a card.
Colors: W
Color Identity: W
Rarity: common | package mage.cards.a;
import mage.abilities.effects.common.DrawCardSourceControllerEffect;
import mage.abilities.effects.common.ExileThenReturnTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.target.common.TargetControlledCreaturePermanent;
import java.util.UUID;
public final class AcrobaticManeuver extends CardImpl {
public AcrobaticManeuver(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{2}{W}");
// Exile target creature you control, then return that card to the battlefield under its owner's control.
this.getSpellAbility().addTarget(new TargetControlledCreaturePermanent());
this.getSpellAbility().addEffect(new ExileThenReturnTargetEffect(false, true));
// Draw a card.
this.getSpellAbility().addEffect(new DrawCardSourceControllerEffect(1).concatBy("<br>"));
}
private AcrobaticManeuver(final AcrobaticManeuver card) {
super(card);
}
@Override
public AcrobaticManeuver copy() {
return new AcrobaticManeuver(this);
}
} |
Layout: normal
Name: Act of Aggression
Mana Cost: {3}{R/P}{R/P}
Cmc: 5.0
Type Line: Instant
Oracle Text: ({R/P} can be paid with either {R} or 2 life.)
Gain control of target creature an opponent controls until end of turn. Untap that creature. It gains haste until end of turn.
Colors: R
Color Identity: R
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.abilities.effects.common.UntapTargetEffect;
import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
import mage.abilities.effects.common.continuous.GainControlTargetEffect;
import mage.abilities.keyword.HasteAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.filter.StaticFilters;
import mage.target.common.TargetCreaturePermanent;
public final class ActOfAggression extends CardImpl {
public ActOfAggression(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{3}{R/P}{R/P}");
this.getSpellAbility().addTarget(new TargetCreaturePermanent(StaticFilters.FILTER_OPPONENTS_PERMANENT_CREATURE));
this.getSpellAbility().addEffect(new GainControlTargetEffect(Duration.EndOfTurn));
this.getSpellAbility().addEffect(new UntapTargetEffect().setText("Untap that creature"));
this.getSpellAbility().addEffect(new GainAbilityTargetEffect(HasteAbility.getInstance(), Duration.EndOfTurn).setText("It gains haste until end of turn."));
}
private ActOfAggression(final ActOfAggression card) {
super(card);
}
@Override
public ActOfAggression copy() {
return new ActOfAggression(this);
}
} |
Layout: normal
Name: Act of Authority
Mana Cost: {1}{W}{W}
Cmc: 3.0
Type Line: Enchantment
Oracle Text: When Act of Authority enters, you may exile target artifact or enchantment.
At the beginning of your upkeep, you may exile target artifact or enchantment. If you do, its controller gains control of Act of Authority.
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.common.BeginningOfUpkeepTriggeredAbility;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.ContinuousEffect;
import mage.abilities.effects.ContinuousEffectImpl;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.ExileTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.filter.StaticFilters;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.target.TargetPermanent;
import mage.target.targetpointer.FixedTarget;
public final class ActOfAuthority extends CardImpl {
public ActOfAuthority(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{1}{W}{W}");
// When Act of Authority enters the battlefield, you may exile target artifact or enchantment.
Ability ability = new EntersBattlefieldTriggeredAbility(new ExileTargetEffect(), true);
ability.addTarget(new TargetPermanent(StaticFilters.FILTER_PERMANENT_ARTIFACT_OR_ENCHANTMENT));
this.addAbility(ability);
// At the beginning of your upkeep, you may exile target artifact or enchantment. If you do, its controller gains control of Act of Authority.
ability = new BeginningOfUpkeepTriggeredAbility(new ActOfAuthorityEffect(), TargetController.YOU, true);
ability.addTarget(new TargetPermanent(StaticFilters.FILTER_PERMANENT_ARTIFACT_OR_ENCHANTMENT));
this.addAbility(ability);
}
private ActOfAuthority(final ActOfAuthority card) {
super(card);
}
@Override
public ActOfAuthority copy() {
return new ActOfAuthority(this);
}
}
class ActOfAuthorityEffect extends OneShotEffect {
ActOfAuthorityEffect() {
super(Outcome.Exile);
this.staticText = "you may exile target artifact or enchantment. If you do, its controller gains control of {this}";
}
private ActOfAuthorityEffect(final ActOfAuthorityEffect effect) {
super(effect);
}
@Override
public ActOfAuthorityEffect copy() {
return new ActOfAuthorityEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Permanent targetPermanent = game.getPermanent(getTargetPointer().getFirst(game, source));
if (targetPermanent == null) {
return false;
}
ExileTargetEffect exileTargetEffect = new ExileTargetEffect();
if (!exileTargetEffect.apply(game, source)) {
return false;
}
Permanent sourcePermanent = source.getSourcePermanentIfItStillExists(game);
if (sourcePermanent == null) { return true; }
ContinuousEffect effect = new ActOfAuthorityGainControlEffect(Duration.Custom, targetPermanent.getControllerId());
effect.setTargetPointer(new FixedTarget(sourcePermanent, game));
game.addEffect(effect, source);
return true;
}
}
// TODO: These and it's duplicates can probably be replaced by a gain control of effect
class ActOfAuthorityGainControlEffect extends ContinuousEffectImpl {
private final UUID controller;
public ActOfAuthorityGainControlEffect(Duration duration, UUID controller) {
super(duration, Layer.ControlChangingEffects_2, SubLayer.NA, Outcome.GainControl);
this.controller = controller;
this.staticText = "Gain control of {this}";
}
private ActOfAuthorityGainControlEffect(final ActOfAuthorityGainControlEffect effect) {
super(effect);
this.controller = effect.controller;
}
@Override
public ActOfAuthorityGainControlEffect copy() {
return new ActOfAuthorityGainControlEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Permanent permanent;
permanent = game.getPermanent(getTargetPointer().getFirst(game, source));
if (permanent == null) {
permanent = game.getPermanent(source.getFirstTarget());
}
if (permanent == null) {
return false;
}
return permanent.changeControllerId(controller, game, source);
}
} |
Layout: normal
Name: Act of Heroism
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Instant
Oracle Text: Untap target creature. It gets +2/+2 until end of turn and can block an additional creature this turn.
Colors: W
Color Identity: W
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.UntapTargetEffect;
import mage.abilities.effects.common.combat.CanBlockAdditionalCreatureTargetEffect;
import mage.abilities.effects.common.continuous.BoostTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.target.common.TargetCreaturePermanent;
public final class ActOfHeroism extends CardImpl {
public ActOfHeroism(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{W}");
// Untap target creature.
Effect effect = new UntapTargetEffect();
effect.setText("Untap target creature");
this.getSpellAbility().addEffect(effect);
// It gets +2/+2 until end of turn
effect = new BoostTargetEffect(2, 2, Duration.EndOfTurn);
effect.setText("It gets +2/+2 until end of turn");
this.getSpellAbility().addEffect(effect);
// and can block an additional creature this turn
effect = new CanBlockAdditionalCreatureTargetEffect();
effect.setText("and can block an additional creature this turn.");
this.getSpellAbility().addEffect(effect);
this.getSpellAbility().addTarget(new TargetCreaturePermanent());
}
private ActOfHeroism(final ActOfHeroism card) {
super(card);
}
@Override
public ActOfHeroism copy() {
return new ActOfHeroism(this);
}
} |
Layout: normal
Name: Act of Treason
Mana Cost: {2}{R}
Cmc: 3.0
Type Line: Sorcery
Oracle Text: Gain control of target creature until end of turn. Untap that creature. It gains haste until end of turn. (It can attack and {T} this turn.)
Colors: R
Color Identity: R
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.effects.common.UntapTargetEffect;
import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
import mage.abilities.effects.common.continuous.GainControlTargetEffect;
import mage.abilities.keyword.HasteAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.target.common.TargetCreaturePermanent;
public final class ActOfTreason extends CardImpl {
public ActOfTreason(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{2}{R}");
// Gain control of target creature until end of turn. Untap that creature.
// It gains haste until end of turn. (It can attack and {T} this turn.)
this.getSpellAbility().addTarget(new TargetCreaturePermanent());
this.getSpellAbility().addEffect(new GainControlTargetEffect(Duration.EndOfTurn));
this.getSpellAbility().addEffect(new UntapTargetEffect().setText("Untap that creature"));
this.getSpellAbility().addEffect(new GainAbilityTargetEffect(HasteAbility.getInstance(), Duration.EndOfTurn).setText("It gains haste until end of turn."));
}
private ActOfTreason(final ActOfTreason card) {
super(card);
}
@Override
public ActOfTreason copy() {
return new ActOfTreason(this);
}
} |
Layout: normal
Name: Act on Impulse
Mana Cost: {2}{R}
Cmc: 3.0
Type Line: Sorcery
Oracle Text: Exile the top three cards of your library. Until end of turn, you may play those cards. (If you cast a spell this way, you still pay its costs. You can play a land this way only if you have an available land play remaining.)
Colors: R
Color Identity: R
Rarity: uncommon | package mage.cards.a;
import mage.abilities.effects.common.ExileTopXMayPlayUntilEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import java.util.UUID;
public final class ActOnImpulse extends CardImpl {
public ActOnImpulse(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{2}{R}");
// Exile the top three cards of your library. Until end of turn, you may play cards exiled this way.
this.getSpellAbility().addEffect(new ExileTopXMayPlayUntilEffect(3, Duration.EndOfTurn)
.withTextOptions("cards exiled this way. <i>(If you cast a spell this way, you still pay its costs. " +
"You can play a land this way only if you have an available land play remaining.)</i>", false));
}
private ActOnImpulse(final ActOnImpulse card) {
super(card);
}
@Override
public ActOnImpulse copy() {
return new ActOnImpulse(this);
}
} |
Layout: normal
Name: Activated Sleeper
Mana Cost: {2}{B}
Cmc: 3.0
Type Line: Creature — Phyrexian Shapeshifter
Oracle Text: Flash
You may have Activated Sleeper enter as a copy of any creature card in a graveyard that was put there from the battlefield this turn, except it's a Phyrexian in addition to its other types.
Power: 0
Toughness: 0
Colors: B
Color Identity: B
Keywords: Flash
Rarity: rare | package mage.cards.a;
import mage.MageInt;
import mage.MageObject;
import mage.abilities.Ability;
import mage.abilities.common.EntersBattlefieldAbility;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.CopyEffect;
import mage.abilities.keyword.FlashAbility;
import mage.cards.Card;
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.FilterCard;
import mage.filter.common.FilterCreatureCard;
import mage.filter.predicate.card.PutIntoGraveFromBattlefieldThisTurnPredicate;
import mage.game.Game;
import mage.players.Player;
import mage.target.Target;
import mage.target.common.TargetCardInGraveyard;
import mage.util.functions.CopyApplier;
import mage.watchers.common.CardsPutIntoGraveyardWatcher;
import java.util.UUID;
public final class ActivatedSleeper extends CardImpl {
public ActivatedSleeper(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{B}");
this.subtype.add(SubType.PHYREXIAN);
this.subtype.add(SubType.SHAPESHIFTER);
this.power = new MageInt(0);
this.toughness = new MageInt(0);
// Flash
this.addAbility(FlashAbility.getInstance());
// You may have Activated Sleeper enter the battlefield as a copy of any creature card in a graveyard that was put there from the battelfield this turn, except it's a Phyrexian in addition to its other types.
this.addAbility(new EntersBattlefieldAbility(
new ActivatedSleeperEffect(), true
), new CardsPutIntoGraveyardWatcher());
}
private ActivatedSleeper(final ActivatedSleeper card) {
super(card);
}
@Override
public ActivatedSleeper copy() {
return new ActivatedSleeper(this);
}
}
class ActivatedSleeperEffect extends OneShotEffect {
private static final FilterCard filter = new FilterCreatureCard(
"creature card in a graveyard that was put there from the battelfield this turn"
);
static {
filter.add(PutIntoGraveFromBattlefieldThisTurnPredicate.instance);
}
ActivatedSleeperEffect() {
super(Outcome.Benefit);
staticText = "as a copy of any creature card in a graveyard that was put there from " +
"the battlefield this turn, except it's a Phyrexian in addition to its other types";
}
private ActivatedSleeperEffect(final ActivatedSleeperEffect effect) {
super(effect);
}
@Override
public ActivatedSleeperEffect copy() {
return new ActivatedSleeperEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player player = game.getPlayer(source.getControllerId());
if (player == null) {
return false;
}
Target target = new TargetCardInGraveyard(filter);
target.withNotTarget(true);
if (!target.canChoose(source.getControllerId(), source, game)) {
return true;
}
player.choose(outcome, target, source, game);
Card copyFromCard = game.getCard(target.getFirstTarget());
if (copyFromCard != null) {
CopyEffect copyEffect = new CopyEffect(Duration.Custom, copyFromCard, source.getSourceId());
copyEffect.setApplier(new CopyApplier() {
@Override
public boolean apply(Game game, MageObject blueprint, Ability source, UUID targetObjectId) {
blueprint.addSubType(SubType.PHYREXIAN);
return true;
}
});
game.addEffect(copyEffect, source);
}
return true;
}
} |
Layout: normal
Name: Active Volcano
Mana Cost: {R}
Cmc: 1.0
Type Line: Instant
Oracle Text: Choose one —
• Destroy target blue permanent.
• Return target Island to its owner's hand.
Colors: R
Color Identity: R
Digital: True
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.ObjectColor;
import mage.abilities.Mode;
import mage.abilities.effects.common.DestroyTargetEffect;
import mage.abilities.effects.common.ReturnToHandTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.filter.FilterPermanent;
import mage.filter.predicate.mageobject.ColorPredicate;
import mage.target.TargetPermanent;
public final class ActiveVolcano extends CardImpl {
private static final FilterPermanent filterBlue = new FilterPermanent("blue permanent");
private static final FilterPermanent filterIsland = new FilterPermanent("Island");
static {
filterBlue.add(new ColorPredicate(ObjectColor.BLUE));
filterIsland.add(SubType.ISLAND.getPredicate());
}
public ActiveVolcano(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.INSTANT},"{R}");
// Choose one - Destroy target blue permanent;
this.getSpellAbility().addEffect(new DestroyTargetEffect());
this.getSpellAbility().addTarget(new TargetPermanent(filterBlue));
// or return target Island to its owner's hand.
Mode mode = new Mode(new ReturnToHandTargetEffect());
mode.addTarget(new TargetPermanent(filterIsland));
this.getSpellAbility().addMode(mode);
}
private ActiveVolcano(final ActiveVolcano card) {
super(card);
}
@Override
public ActiveVolcano copy() {
return new ActiveVolcano(this);
}
} |
Layout: normal
Name: Ad Nauseam
Mana Cost: {3}{B}{B}
Cmc: 5.0
Type Line: Instant
Oracle Text: Reveal the top card of your library and put that card into your hand. You lose life equal to its mana value. You may repeat this process any number of times.
Colors: B
Color Identity: B
Rarity: rare | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.effects.OneShotEffect;
import mage.cards.Card;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.cards.CardsImpl;
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 AdNauseam extends CardImpl {
public AdNauseam(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{3}{B}{B}");
// Reveal the top card of your library and put that card into your hand. You lose life equal to its converted mana cost. You may repeat this process any number of times.
this.getSpellAbility().addEffect(new AdNauseamEffect());
}
private AdNauseam(final AdNauseam card) {
super(card);
}
@Override
public AdNauseam copy() {
return new AdNauseam(this);
}
}
class AdNauseamEffect extends OneShotEffect {
AdNauseamEffect() {
super(Outcome.DrawCard);
this.staticText = "Reveal the top card of your library and put that card into your hand. You lose life equal to its mana value. You may repeat this process any number of times";
}
private AdNauseamEffect(final AdNauseamEffect effect) {
super(effect);
}
@Override
public AdNauseamEffect copy() {
return new AdNauseamEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
String message = "Reveal the top card of your library and put that card into your hand? You lose life equal to its mana value.";
Card sourceCard = game.getCard(source.getSourceId());
Player controller = game.getPlayer(source.getControllerId());
if (controller == null || sourceCard == null) {
return false;
}
while (controller.chooseUse(outcome, message, source, game) && controller.getLibrary().hasCards()) {
Card card = controller.getLibrary().getFromTop(game);
if (card == null) {
break;
}
controller.moveCards(card, Zone.HAND, source, game);
int cmc = card.getManaValue();
if (cmc > 0) {
controller.loseLife(cmc, game, source, false);
}
controller.revealCards(sourceCard.getIdName() + " put into hand", new CardsImpl(card), game);
// AI workaround to stop infinite choose (only one card allows)
if (controller.isComputer()) {
break;
}
}
return true;
}
} |
Layout: normal
Name: Adamant Will
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Instant
Oracle Text: Target creature gets +2/+2 and gains indestructible until end of turn. (Damage and effects that say "destroy" don't destroy it.)
Colors: W
Color Identity: W
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.continuous.BoostTargetEffect;
import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
import mage.abilities.keyword.IndestructibleAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.target.common.TargetCreaturePermanent;
public final class AdamantWill extends CardImpl {
public AdamantWill(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.INSTANT},"{1}{W}");
// Target creature gets +2/+2 and gains indestructible until end of turn.
Effect effect = new BoostTargetEffect(2, 2, Duration.EndOfTurn);
effect.setText("Target creature gets +2/+2");
this.getSpellAbility().addEffect(effect);
effect = new GainAbilityTargetEffect(IndestructibleAbility.getInstance(), Duration.EndOfTurn);
effect.setText("and gains indestructible until end of turn");
this.getSpellAbility().addEffect(effect);
this.getSpellAbility().addTarget(new TargetCreaturePermanent());
}
private AdamantWill(final AdamantWill card) {
super(card);
}
@Override
public AdamantWill copy() {
return new AdamantWill(this);
}
} |
Layout: normal
Name: Adamaro, First to Desire
Mana Cost: {1}{R}{R}
Cmc: 3.0
Type Line: Legendary Creature — Spirit
Oracle Text: Adamaro, First to Desire's power and toughness are each equal to the number of cards in the hand of the opponent with the most cards in hand.
Power: *
Toughness: *
Colors: R
Color Identity: R
Rarity: rare | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.dynamicvalue.DynamicValue;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.continuous.SetBasePowerToughnessSourceEffect;
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 AdamaroFirstToDesire extends CardImpl {
public AdamaroFirstToDesire(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{R}{R}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.SPIRIT);
this.power = new MageInt(0);
this.toughness = new MageInt(0);
// Adamaro, First to Desire's power and toughness are each equal to the number of cards in the hand of the opponent with the most cards in hand.
this.addAbility(new SimpleStaticAbility(Zone.ALL, new SetBasePowerToughnessSourceEffect(new MostCardsInOpponentsHandCount())));
}
private AdamaroFirstToDesire(final AdamaroFirstToDesire card) {
super(card);
}
@Override
public AdamaroFirstToDesire copy() {
return new AdamaroFirstToDesire(this);
}
}
class MostCardsInOpponentsHandCount implements DynamicValue {
@Override
public int calculate(Game game, Ability sourceAbility, Effect effect) {
int maxCards = 0;
for (UUID opponentId : game.getOpponents(sourceAbility.getControllerId())) {
Player opponent = game.getPlayer(opponentId);
if (opponent != null) {
int cards = opponent.getHand().size();
if (cards > maxCards) {
maxCards = cards;
}
}
}
return maxCards;
}
@Override
public MostCardsInOpponentsHandCount copy() {
return new MostCardsInOpponentsHandCount();
}
@Override
public String getMessage() {
return "cards in the hand of the opponent with the most cards in hand";
}
@Override
public String toString() {
return "1";
}
} |
Layout: transform
Name: Legion's Landing
Mana Cost: {W}
Type Line: Legendary Enchantment
Oracle Text: When Legion's Landing enters, create a 1/1 white Vampire creature token with lifelink.
When you attack with three or more creatures, transform Legion's Landing.
Colors: W
Name: Adanto, the First Fort
Type Line: Legendary Land
Oracle Text: (Transforms from Legion's Landing.)
{T}: Add {W}.
{2}{W}, {T}: Create a 1/1 white Vampire creature token with lifelink. | package mage.cards.l;
import java.util.UUID;
import mage.abilities.TriggeredAbilityImpl;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.CreateTokenEffect;
import mage.abilities.effects.common.TransformSourceEffect;
import mage.abilities.keyword.TransformAbility;
import mage.constants.SuperType;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Zone;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.game.permanent.token.IxalanVampireToken;
public final class LegionsLanding extends CardImpl {
public LegionsLanding(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ENCHANTMENT}, "{W}");
this.supertype.add(SuperType.LEGENDARY);
this.secondSideCardClazz = mage.cards.a.AdantoTheFirstFort.class;
// When Legion's Landing enters the battlefield, create a 1/1 white Vampire creature token with lifelink.
this.addAbility(new EntersBattlefieldTriggeredAbility(new CreateTokenEffect(new IxalanVampireToken())));
// When you attack with three or more creatures, transform Legion's Landing.
this.addAbility(new TransformAbility());
this.addAbility(new LegionsLandingTriggeredAbility(new TransformSourceEffect()));
}
private LegionsLanding(final LegionsLanding card) {
super(card);
}
@Override
public LegionsLanding copy() {
return new LegionsLanding(this);
}
}
class LegionsLandingTriggeredAbility extends TriggeredAbilityImpl {
public LegionsLandingTriggeredAbility(Effect effect) {
super(Zone.BATTLEFIELD, effect, false);
setTriggerPhrase("When you attack with three or more creatures, " );
}
private LegionsLandingTriggeredAbility(final LegionsLandingTriggeredAbility ability) {
super(ability);
}
@Override
public LegionsLandingTriggeredAbility copy() {
return new LegionsLandingTriggeredAbility(this);
}
@Override
public boolean checkEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.DECLARED_ATTACKERS;
}
@Override
public boolean checkTrigger(GameEvent event, Game game) {
return game.getCombat().getAttackers().size() >= 3 && game.getCombat().getAttackingPlayerId().equals(getControllerId());
}
} |
Layout: normal
Name: Adanto Vanguard
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Creature — Vampire Soldier
Oracle Text: As long as Adanto Vanguard is attacking, it gets +2/+0.
Pay 4 life: Adanto Vanguard gains indestructible until end of turn. (Damage and effects that say "destroy" don't destroy it.)
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.common.SimpleActivatedAbility;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.condition.common.SourceAttackingCondition;
import mage.abilities.costs.common.PayLifeCost;
import mage.abilities.decorator.ConditionalContinuousEffect;
import mage.abilities.effects.common.continuous.BoostSourceEffect;
import mage.abilities.effects.common.continuous.GainAbilitySourceEffect;
import mage.abilities.keyword.IndestructibleAbility;
import mage.constants.SubType;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.Zone;
public final class AdantoVanguard extends CardImpl {
public AdantoVanguard(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{W}");
this.subtype.add(SubType.VAMPIRE);
this.subtype.add(SubType.SOLDIER);
this.power = new MageInt(1);
this.toughness = new MageInt(1);
// As long as Adanto Vanguard is attacking, it gets +2/+0.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new ConditionalContinuousEffect(
new BoostSourceEffect(2, 0, Duration.WhileOnBattlefield),
SourceAttackingCondition.instance,
"As long as {this} is attacking, it gets +2/+0"
)));
// Pay 4 life: Adanto Vanguard gains indestructible until end of turn.
this.addAbility(new SimpleActivatedAbility(
Zone.BATTLEFIELD,
new GainAbilitySourceEffect(IndestructibleAbility.getInstance(), Duration.EndOfTurn),
new PayLifeCost(4)
));
}
private AdantoVanguard(final AdantoVanguard card) {
super(card);
}
@Override
public AdantoVanguard copy() {
return new AdantoVanguard(this);
}
} |
Layout: normal
Name: Adaptive Automaton
Mana Cost: {3}
Cmc: 3.0
Type Line: Artifact Creature — Construct
Oracle Text: As Adaptive Automaton enters, choose a creature type.
Adaptive Automaton is the chosen type in addition to its other types.
Other creatures you control of the chosen type get +1/+1.
Power: 2
Toughness: 2
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.effects.common.continuous.AddChosenSubtypeEffect;
import mage.abilities.common.AsEntersBattlefieldAbility;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.common.ChooseCreatureTypeEffect;
import mage.abilities.effects.common.continuous.BoostAllOfChosenSubtypeEffect;
import mage.abilities.effects.common.enterAttribute.EnterAttributeAddChosenSubtypeEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.filter.common.FilterCreaturePermanent;
public final class AdaptiveAutomaton extends CardImpl {
private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("creatures you control of the chosen type");
static {
filter.add(TargetController.YOU.getControllerPredicate());
}
public AdaptiveAutomaton(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{3}");
this.subtype.add(SubType.CONSTRUCT);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// As Adaptive Automaton enters the battlefield, choose a creature type.
// Adaptive Automaton is the chosen type in addition to its other types.
AsEntersBattlefieldAbility ability = new AsEntersBattlefieldAbility(new ChooseCreatureTypeEffect(Outcome.BoostCreature));
ability.addEffect(new EnterAttributeAddChosenSubtypeEffect());
this.addAbility(ability);
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new AddChosenSubtypeEffect()));
// Other creatures you control of the chosen type get +1/+1.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new BoostAllOfChosenSubtypeEffect(1, 1, Duration.WhileOnBattlefield, filter, true)));
}
private AdaptiveAutomaton(final AdaptiveAutomaton card) {
super(card);
}
@Override
public AdaptiveAutomaton copy() {
return new AdaptiveAutomaton(this);
}
} |
Layout: normal
Name: Adaptive Gemguard
Mana Cost: {3}{W}
Cmc: 4.0
Type Line: Artifact Creature — Gnome
Oracle Text: Tap two untapped artifacts and/or creatures you control: Put a +1/+1 counter on Adaptive Gemguard. Activate only as a sorcery.
Power: 3
Toughness: 3
Colors: W
Color Identity: W
Rarity: common | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.ActivateAsSorceryActivatedAbility;
import mage.abilities.costs.common.TapTargetCost;
import mage.abilities.effects.common.counter.AddCountersSourceEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.counters.CounterType;
import mage.filter.common.FilterControlledPermanent;
import mage.filter.predicate.Predicates;
import mage.filter.predicate.permanent.TappedPredicate;
import mage.target.common.TargetControlledPermanent;
import java.util.UUID;
public final class AdaptiveGemguard extends CardImpl {
private static final FilterControlledPermanent filter = new FilterControlledPermanent("untapped artifacts and/or creatures you control");
static {
filter.add(TappedPredicate.UNTAPPED);
filter.add(Predicates.or(
CardType.ARTIFACT.getPredicate(),
CardType.CREATURE.getPredicate()
));
}
public AdaptiveGemguard(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{3}{W}");
this.subtype.add(SubType.GNOME);
this.power = new MageInt(3);
this.toughness = new MageInt(3);
// Tap two untapped artifacts and/or creatures you control: Put a +1/+1 counter on Adaptive Gemguard. Activate only as a sorcery.
this.addAbility(new ActivateAsSorceryActivatedAbility(new AddCountersSourceEffect(CounterType.P1P1.createInstance()),
new TapTargetCost(new TargetControlledPermanent(2, filter))));
}
private AdaptiveGemguard(final AdaptiveGemguard card) {
super(card);
}
@Override
public AdaptiveGemguard copy() {
return new AdaptiveGemguard(this);
}
} |
Layout: normal
Name: Adaptive Shimmerer
Mana Cost: {5}
Cmc: 5.0
Type Line: Creature — Insect
Oracle Text: Flash
Adaptive Shimmerer enters with three +1/+1 counters on it.
Power: 0
Toughness: 0
Keywords: Flash
Rarity: common | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.EntersBattlefieldAbility;
import mage.abilities.effects.common.counter.AddCountersSourceEffect;
import mage.abilities.keyword.FlashAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.counters.CounterType;
import java.util.UUID;
public final class AdaptiveShimmerer extends CardImpl {
public AdaptiveShimmerer(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{5}");
this.subtype.add(SubType.INSECT);
this.power = new MageInt(0);
this.toughness = new MageInt(0);
// Flash
this.addAbility(FlashAbility.getInstance());
// Adaptive Shimmerer enters the battlefield with three +1/+1 counters on it.
this.addAbility(new EntersBattlefieldAbility(new AddCountersSourceEffect(
CounterType.P1P1.createInstance(3), true
), "with three +1/+1 counters on it"));
}
private AdaptiveShimmerer(final AdaptiveShimmerer card) {
super(card);
}
@Override
public AdaptiveShimmerer copy() {
return new AdaptiveShimmerer(this);
}
} |
Layout: normal
Name: Adaptive Snapjaw
Mana Cost: {4}{G}
Cmc: 5.0
Type Line: Creature — Lizard Beast
Oracle Text: Evolve (Whenever a creature you control enters, if that creature has greater power or toughness than this creature, put a +1/+1 counter on this creature.)
Power: 6
Toughness: 2
Colors: G
Color Identity: G
Keywords: Evolve
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.keyword.EvolveAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
public final class AdaptiveSnapjaw extends CardImpl {
public AdaptiveSnapjaw(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{4}{G}");
this.subtype.add(SubType.LIZARD);
this.subtype.add(SubType.BEAST);
this.power = new MageInt(6);
this.toughness = new MageInt(2);
// Evolve
this.addAbility(new EvolveAbility());
}
private AdaptiveSnapjaw(final AdaptiveSnapjaw card) {
super(card);
}
@Override
public AdaptiveSnapjaw copy() {
return new AdaptiveSnapjaw(this);
}
} |
Layout: normal
Name: Adaptive Sporesinger
Mana Cost: {2}{G}
Cmc: 3.0
Type Line: Creature — Phyrexian Druid
Oracle Text: Vigilance
When Adaptive Sporesinger enters, choose one —
• Target creature gets +2/+2 and gains vigilance until end of turn.
• Proliferate. (Choose any number of permanents and/or players, then give each another counter of each kind already there.)
Power: 2
Toughness: 2
Colors: G
Color Identity: G
Keywords: Vigilance, Proliferate
Rarity: common | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.Mode;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.common.continuous.BoostTargetEffect;
import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
import mage.abilities.effects.common.counter.ProliferateEffect;
import mage.abilities.keyword.VigilanceAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.target.common.TargetCreaturePermanent;
import java.util.UUID;
public final class AdaptiveSporesinger extends CardImpl {
public AdaptiveSporesinger(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{G}");
this.subtype.add(SubType.PHYREXIAN);
this.subtype.add(SubType.DRUID);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// Vigilance
this.addAbility(VigilanceAbility.getInstance());
// When Adaptive Sporesinger enters the battlefield, choose one--
// * Target creature gets +2/+2 and gains vigilance until end of turn.
Ability ability = new EntersBattlefieldTriggeredAbility(
new BoostTargetEffect(2, 2)
.setText("target creature gets +2/+2")
);
ability.addEffect(new GainAbilityTargetEffect(VigilanceAbility.getInstance())
.setText("and gains vigilance until end of turn"));
ability.addTarget(new TargetCreaturePermanent());
// * Proliferate.
ability.addMode(new Mode(new ProliferateEffect()));
this.addAbility(ability);
}
private AdaptiveSporesinger(final AdaptiveSporesinger card) {
super(card);
}
@Override
public AdaptiveSporesinger copy() {
return new AdaptiveSporesinger(this);
}
} |
Layout: normal
Name: Adarkar Sentinel
Mana Cost: {5}
Cmc: 5.0
Type Line: Artifact Creature — Soldier
Oracle Text: {1}: Adarkar Sentinel gets +0/+1 until end of turn.
Power: 3
Toughness: 3
Digital: True
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.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 AdarkarSentinel extends CardImpl {
public AdarkarSentinel(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.ARTIFACT,CardType.CREATURE},"{5}");
this.subtype.add(SubType.SOLDIER);
this.power = new MageInt(3);
this.toughness = new MageInt(3);
// {1}: Adarkar Sentinel gets +0/+1 until end of turn.
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new BoostSourceEffect(0,1,Duration.EndOfTurn), new ManaCostsImpl<>("{1}"));
this.addAbility(ability);
}
private AdarkarSentinel(final AdarkarSentinel card) {
super(card);
}
@Override
public AdarkarSentinel copy() {
return new AdarkarSentinel(this);
}
} |
Layout: normal
Name: Adarkar Unicorn
Mana Cost: {1}{W}{W}
Cmc: 3.0
Type Line: Creature — Unicorn
Oracle Text: {T}: Add {U} or {C}{U}. Spend this mana only to pay cumulative upkeep costs.
Power: 2
Toughness: 2
Colors: W
Color Identity: U, W
Produced Mana: C, U
Rarity: common | package mage.cards.a;
import mage.ConditionalMana;
import mage.MageInt;
import mage.Mana;
import mage.abilities.Ability;
import mage.abilities.condition.Condition;
import mage.abilities.costs.Cost;
import mage.abilities.keyword.CumulativeUpkeepAbility;
import mage.abilities.mana.ConditionalColoredManaAbility;
import mage.abilities.mana.builder.ConditionalManaBuilder;
import mage.abilities.mana.conditional.ManaCondition;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.game.Game;
import java.util.UUID;
public final class AdarkarUnicorn extends CardImpl {
public AdarkarUnicorn(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{W}{W}");
this.subtype.add(SubType.UNICORN);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// {tap}: Add {U} or {1}{U}. Spend this mana only to pay cumulative upkeep costs.
this.addAbility(new ConditionalColoredManaAbility(
new Mana(0, 1, 0, 0, 0, 0, 0, 0), new AdarkarUnicornManaBuilder()));
this.addAbility(new ConditionalColoredManaAbility(
new Mana(0, 1, 0, 0, 0, 0, 0, 1), new AdarkarUnicornManaBuilder()));
}
private AdarkarUnicorn(final AdarkarUnicorn card) {
super(card);
}
@Override
public AdarkarUnicorn copy() {
return new AdarkarUnicorn(this);
}
}
class AdarkarUnicornManaBuilder extends ConditionalManaBuilder {
@Override
public ConditionalMana build(Object... options) {
return new AdarkarUnicornConditionalMana(this.mana);
}
@Override
public String getRule() {
return "Spend this mana only to pay cumulative upkeep costs";
}
}
class AdarkarUnicornConditionalMana extends ConditionalMana {
public AdarkarUnicornConditionalMana(Mana mana) {
super(mana);
staticText = "Spend this mana only to pay cumulative upkeep costs";
addCondition(new AdarkarUnicornManaCondition());
}
}
class AdarkarUnicornManaCondition extends ManaCondition implements Condition {
@Override
public boolean apply(Game game, Ability source) {
if (source != null) {
return source instanceof CumulativeUpkeepAbility;
}
return false;
}
@Override
public boolean apply(Game game, Ability source, UUID originalId, Cost costToPay) {
return apply(game, source);
}
} |
Layout: normal
Name: Adarkar Valkyrie
Mana Cost: {4}{W}{W}
Cmc: 6.0
Type Line: Snow Creature — Angel
Oracle Text: Flying, vigilance
{T}: When target creature other than Adarkar Valkyrie dies this turn, return that card to the battlefield under your control.
Power: 4
Toughness: 5
Colors: W
Color Identity: W
Keywords: Flying, Vigilance
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.DelayedTriggeredAbility;
import mage.abilities.common.delayed.WhenTargetDiesDelayedTriggeredAbility;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.common.TapSourceCost;
import mage.abilities.effects.common.CreateDelayedTriggeredAbilityEffect;
import mage.abilities.effects.common.ReturnFromGraveyardToBattlefieldTargetEffect;
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.SetTargetPointer;
import mage.constants.SubType;
import mage.constants.SuperType;
import mage.filter.StaticFilters;
import mage.target.TargetPermanent;
public final class AdarkarValkyrie extends CardImpl {
public AdarkarValkyrie(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{4}{W}{W}");
this.supertype.add(SuperType.SNOW);
this.subtype.add(SubType.ANGEL);
this.power = new MageInt(4);
this.toughness = new MageInt(5);
// Flying
this.addAbility(FlyingAbility.getInstance());
// Vigilance
this.addAbility(VigilanceAbility.getInstance());
// {T}: When target creature other than Adarkar Valkyrie dies this turn, return that card to the battlefield under your control.
DelayedTriggeredAbility delayedAbility = new WhenTargetDiesDelayedTriggeredAbility(
new ReturnFromGraveyardToBattlefieldTargetEffect()
.setText("return that card to the battlefield under your control"),
SetTargetPointer.CARD
);
delayedAbility.setTriggerPhrase("When target creature other than {this} dies this turn, ");
Ability ability = new SimpleActivatedAbility(new CreateDelayedTriggeredAbilityEffect(delayedAbility), new TapSourceCost());
ability.addTarget(new TargetPermanent(StaticFilters.FILTER_ANOTHER_TARGET_CREATURE));
this.addAbility(ability);
}
private AdarkarValkyrie(final AdarkarValkyrie card) {
super(card);
}
@Override
public AdarkarValkyrie copy() {
return new AdarkarValkyrie(this);
}
} |
Layout: normal
Name: Adarkar Wastes
Type Line: Land
Oracle Text: {T}: Add {C}.
{T}: Add {W} or {U}. Adarkar Wastes deals 1 damage to you.
Color Identity: U, W
Produced Mana: C, U, W
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.Mana;
import mage.abilities.Ability;
import mage.abilities.costs.common.TapSourceCost;
import mage.abilities.effects.common.DamageControllerEffect;
import mage.abilities.mana.ColorlessManaAbility;
import mage.abilities.mana.SimpleManaAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Zone;
public final class AdarkarWastes extends CardImpl {
public AdarkarWastes(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.LAND},"");
this.addAbility(new ColorlessManaAbility());
Ability whiteManaAbility = new SimpleManaAbility(Zone.BATTLEFIELD, Mana.WhiteMana(1), new TapSourceCost());
whiteManaAbility.addEffect(new DamageControllerEffect(1));
this.addAbility(whiteManaAbility);
Ability blueManaAbility = new SimpleManaAbility(Zone.BATTLEFIELD, Mana.BlueMana(1), new TapSourceCost());
blueManaAbility.addEffect(new DamageControllerEffect(1));
this.addAbility(blueManaAbility);
}
private AdarkarWastes(final AdarkarWastes card) {
super(card);
}
@Override
public AdarkarWastes copy() {
return new AdarkarWastes(this);
}
} |
Layout: normal
Name: Adarkar Windform
Mana Cost: {4}{U}
Cmc: 5.0
Type Line: Snow Creature — Illusion
Oracle Text: Flying
{1}{S}: Target creature loses flying until end of turn. ({S} can be paid with one mana from a snow source.)
Power: 3
Toughness: 3
Colors: U
Color Identity: U
Keywords: Flying
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.mana.ManaCostsImpl;
import mage.abilities.effects.common.continuous.LoseAbilityTargetEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.target.common.TargetCreaturePermanent;
public final class AdarkarWindform extends CardImpl {
public AdarkarWindform(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{4}{U}");
this.supertype.add(SuperType.SNOW);
this.subtype.add(SubType.ILLUSION);
this.power = new MageInt(3);
this.toughness = new MageInt(3);
// Flying
this.addAbility(FlyingAbility.getInstance());
// {1}{S}: Target creature loses flying until end of turn.
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new LoseAbilityTargetEffect(
FlyingAbility.getInstance(), Duration.EndOfTurn), new ManaCostsImpl<>("{1}{S}"));
ability.addTarget(new TargetCreaturePermanent());
this.addAbility(ability);
}
private AdarkarWindform(final AdarkarWindform card) {
super(card);
}
@Override
public AdarkarWindform copy() {
return new AdarkarWindform(this);
}
} |
Layout: normal
Name: Adder-Staff Boggart
Mana Cost: {1}{R}
Cmc: 2.0
Type Line: Creature — Goblin Warrior
Oracle Text: When Adder-Staff Boggart enters, clash with an opponent. If you win, put a +1/+1 counter on Adder-Staff Boggart. (Each clashing player reveals the top card of their library, then puts that card on the top or bottom. A player wins if their card had a higher mana value.)
Power: 2
Toughness: 1
Colors: R
Color Identity: R
Keywords: Clash
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.common.DoIfClashWonEffect;
import mage.abilities.effects.common.counter.AddCountersSourceEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.counters.CounterType;
public final class AdderStaffBoggart extends CardImpl {
public AdderStaffBoggart(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{1}{R}");
this.subtype.add(SubType.GOBLIN);
this.subtype.add(SubType.WARRIOR);
this.power = new MageInt(2);
this.toughness = new MageInt(1);
// When Adder-Staff Boggart enters the battlefield, clash with an opponent. If you win, put a +1/+1 counter on Adder-Staff Boggart.
this.addAbility(new EntersBattlefieldTriggeredAbility(new DoIfClashWonEffect(new AddCountersSourceEffect(CounterType.P1P1.createInstance()))));
}
private AdderStaffBoggart(final AdderStaffBoggart card) {
super(card);
}
@Override
public AdderStaffBoggart copy() {
return new AdderStaffBoggart(this);
}
} |
Layout: normal
Name: Addle
Mana Cost: {1}{B}
Cmc: 2.0
Type Line: Sorcery
Oracle Text: Choose a color. Target player reveals their hand and you choose a card of that color from it. That player discards that card.
Colors: B
Color Identity: B
Digital: True
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.ObjectColor;
import mage.abilities.Ability;
import mage.abilities.effects.Effect;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.discard.DiscardCardYouChooseTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.choices.ChoiceColor;
import mage.constants.CardType;
import mage.constants.Outcome;
import mage.filter.FilterCard;
import mage.filter.predicate.mageobject.ColorPredicate;
import mage.game.Game;
import mage.players.Player;
import mage.target.TargetPlayer;
public final class Addle extends CardImpl {
public Addle(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{1}{B}");
// Choose a color. Target player reveals their hand and you choose a card of that color from it. That player discards that card.
this.getSpellAbility().addEffect(new AddleEffect());
this.getSpellAbility().addTarget(new TargetPlayer());
}
private Addle(final Addle card) {
super(card);
}
@Override
public Addle copy() {
return new Addle(this);
}
}
class AddleEffect extends OneShotEffect {
AddleEffect() {
super(Outcome.Discard);
staticText = "Choose a color. Target player reveals their hand and you choose a card of that color from it. That player discards that card.";
}
private AddleEffect(final AddleEffect effect) {
super(effect);
}
@Override
public AddleEffect copy() {
return new AddleEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
Player controller = game.getPlayer(source.getControllerId());
ChoiceColor choice = new ChoiceColor();
if (controller != null && controller.choose(outcome, choice, game)) {
ObjectColor color = choice.getColor();
game.informPlayers(controller.getLogName() + " chooses " + color + '.');
FilterCard filter = new FilterCard();
filter.add(new ColorPredicate(color));
Effect effect = new DiscardCardYouChooseTargetEffect(filter);
return effect.apply(game, source);
}
return false;
}
} |
Layout: normal
Name: Adeline, Resplendent Cathar
Mana Cost: {1}{W}{W}
Cmc: 3.0
Type Line: Legendary Creature — Human Knight
Oracle Text: Vigilance
Adeline, Resplendent Cathar's power is equal to the number of creatures you control.
Whenever you attack, for each opponent, create a 1/1 white Human creature token that's tapped and attacking that player or a planeswalker they control.
Power: *
Toughness: 4
Colors: W
Color Identity: W
Keywords: Vigilance
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.AttacksWithCreaturesTriggeredAbility;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.dynamicvalue.common.CreaturesYouControlCount;
import mage.abilities.effects.OneShotEffect;
import mage.abilities.effects.common.continuous.SetBasePowerSourceEffect;
import mage.abilities.hint.common.CreaturesYouControlHint;
import mage.constants.*;
import mage.abilities.keyword.VigilanceAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.game.Game;
import mage.game.permanent.token.HumanToken;
public final class AdelineResplendentCathar extends CardImpl {
public AdelineResplendentCathar(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{W}{W}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.KNIGHT);
this.power = new MageInt(0);
this.toughness = new MageInt(4);
// Vigilance
this.addAbility(VigilanceAbility.getInstance());
// Adeline, Resplendent Cathar's power is equal to the number of creatures you control.
this.addAbility(new SimpleStaticAbility(Zone.ALL, new SetBasePowerSourceEffect(
CreaturesYouControlCount.instance)).addHint(CreaturesYouControlHint.instance)
);
// Whenever you attack, for each opponent, create a 1/1 white Human creature token that's tapped and attacking that player or a planeswalker they control.
this.addAbility(new AttacksWithCreaturesTriggeredAbility(new AdelineResplendentCatharEffect(), 1));
}
private AdelineResplendentCathar(final AdelineResplendentCathar card) {
super(card);
}
@Override
public AdelineResplendentCathar copy() {
return new AdelineResplendentCathar(this);
}
}
class AdelineResplendentCatharEffect extends OneShotEffect {
AdelineResplendentCatharEffect() {
super(Outcome.Benefit);
staticText = "for each opponent, create a 1/1 white Human creature token that's tapped and attacking that player or a planeswalker they control";
}
private AdelineResplendentCatharEffect(final AdelineResplendentCatharEffect effect) {
super(effect);
}
@Override
public AdelineResplendentCatharEffect copy() {
return new AdelineResplendentCatharEffect(this);
}
@Override
public boolean apply(Game game, Ability source) {
for (UUID opponentId : game.getOpponents(source.getControllerId())) {
new HumanToken().putOntoBattlefield(1, game, source, source.getControllerId(), true, true, opponentId);
}
return true;
}
} |
Layout: normal
Name: Adeliz, the Cinder Wind
Mana Cost: {1}{U}{R}
Cmc: 3.0
Type Line: Legendary Creature — Human Wizard
Oracle Text: Flying, haste
Whenever you cast an instant or sorcery spell, Wizards you control get +1/+1 until end of turn.
Power: 2
Toughness: 2
Colors: R, U
Color Identity: R, U
Keywords: Flying, Haste
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.SpellCastControllerTriggeredAbility;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.continuous.BoostControlledEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.HasteAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.filter.StaticFilters;
import mage.filter.common.FilterCreaturePermanent;
import java.util.UUID;
public final class AdelizTheCinderWind extends CardImpl {
private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("Wizards");
static {
filter.add(TargetController.YOU.getControllerPredicate());
filter.add(SubType.WIZARD.getPredicate());
}
public AdelizTheCinderWind(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{U}{R}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.HUMAN, SubType.WIZARD);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// Flying
this.addAbility(FlyingAbility.getInstance());
// Haste
this.addAbility(HasteAbility.getInstance());
// Whenever you cast an instant or sorcery spell, Wizards you control get +1/+1 until end of turn.
Effect effect = new BoostControlledEffect(1, 1, Duration.EndOfTurn, filter);
Ability ability = new SpellCastControllerTriggeredAbility(effect, StaticFilters.FILTER_SPELL_AN_INSTANT_OR_SORCERY, false);
this.addAbility(ability);
}
private AdelizTheCinderWind(final AdelizTheCinderWind card) {
super(card);
}
@Override
public AdelizTheCinderWind copy() {
return new AdelizTheCinderWind(this);
}
} |
Layout: normal
Name: Adherent of Hope
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Creature — Human Soldier
Oracle Text: At the beginning of combat on your turn, if you control a Basri planeswalker, put a +1/+1 counter on Adherent of Hope.
Power: 2
Toughness: 1
Colors: W
Color Identity: W
Rarity: common
Promo Types: planeswalkerdeck | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.BeginningOfCombatTriggeredAbility;
import mage.abilities.condition.common.PermanentsOnTheBattlefieldCondition;
import mage.abilities.decorator.ConditionalInterveningIfTriggeredAbility;
import mage.abilities.effects.common.counter.AddCountersSourceEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.TargetController;
import mage.counters.CounterType;
import mage.filter.common.FilterControlledPermanent;
import java.util.UUID;
public final class AdherentOfHope extends CardImpl {
private static final FilterControlledPermanent filter = new FilterControlledPermanent();
static {
filter.add(CardType.PLANESWALKER.getPredicate());
filter.add(SubType.BASRI.getPredicate());
}
public AdherentOfHope(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{W}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.SOLDIER);
this.power = new MageInt(2);
this.toughness = new MageInt(1);
// At the beginning of combat on your turn, if you control a Basri planeswalker, put a +1/+1 counter on Adherent of Hope.
this.addAbility(new ConditionalInterveningIfTriggeredAbility(
new BeginningOfCombatTriggeredAbility(new AddCountersSourceEffect(CounterType.P1P1.createInstance()), TargetController.YOU, false),
new PermanentsOnTheBattlefieldCondition(filter),
"At the beginning of combat on your turn, if you control a Basri planeswalker, put a +1/+1 counter on {this}."));
}
private AdherentOfHope(final AdherentOfHope card) {
super(card);
}
@Override
public AdherentOfHope copy() {
return new AdherentOfHope(this);
}
} |
Layout: normal
Name: Adipose Offspring
Mana Cost: {3}{W}
Cmc: 4.0
Type Line: Creature — Alien
Oracle Text: Emerge {5}{W} (You may cast this spell by sacrificing a creature and paying the emerge cost reduced by that creature's mana value.)
When Adipose Offspring enters, create a 2/2 white Alien creature token. If Adipose Offspring's emerge cost was paid, instead create X of those tokens, where X is the sacrificed creature's toughness.
Power: 2
Toughness: 2
Colors: W
Color Identity: W
Keywords: Emerge
Rarity: rare | package mage.cards.a;
import mage.MageInt;
import mage.MageObjectReference;
import mage.abilities.Ability;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.dynamicvalue.DynamicValue;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.CreateTokenEffect;
import mage.abilities.keyword.EmergeAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.game.Game;
import mage.game.permanent.Permanent;
import mage.game.permanent.token.AlienToken;
import mage.util.CardUtil;
import java.util.UUID;
public final class AdiposeOffspring extends CardImpl {
public AdiposeOffspring(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{W}");
this.subtype.add(SubType.ALIEN);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// Emerge {5}{W}
this.addAbility(new EmergeAbility(this, "{5}{W}"));
// When Adipose Offspring enters the battlefield, create a 2/2 white Alien creature token. If Adipose Offspring's emerge cost was paid, instead create X of those tokens, where X is the sacrificed creature's toughness.
this.addAbility(new EntersBattlefieldTriggeredAbility(new CreateTokenEffect(new AlienToken(), AdiposeOffspringValue.instance)
.setText("create a 2/2 white Alien creature token. If {this}'s emerge cost was paid, "
+ "instead create X of those tokens, where X is the sacrificed creature's toughness.")));
}
private AdiposeOffspring(final AdiposeOffspring card) {
super(card);
}
@Override
public AdiposeOffspring copy() {
return new AdiposeOffspring(this);
}
}
enum AdiposeOffspringValue implements DynamicValue {
instance;
@Override
public int calculate(Game game, Ability sourceAbility, Effect effect) {
MageObjectReference blank = new MageObjectReference(new UUID(0,0));
MageObjectReference mor = CardUtil.getSourceCostsTag(game, sourceAbility, EmergeAbility.EMERGE_ACTIVATION_CREATURE_REFERENCE, blank);
if (!mor.equals(blank)) {
Permanent creature = mor.getPermanentOrLKIBattlefield(game);
if (creature != null) {
return creature.getToughness().getValue();
}
}
return 1;
}
@Override
public AdiposeOffspringValue copy() {
return this;
}
@Override
public String getMessage() {
return "One or the sacrificed creature's toughness";
}
@Override
public String toString() {
return "1";
}
} |
Layout: normal
Name: Admiral Beckett Brass
Mana Cost: {1}{U}{B}{R}
Cmc: 4.0
Type Line: Legendary Creature — Human Pirate
Oracle Text: Other Pirates you control get +1/+1.
At the beginning of your end step, gain control of target nonland permanent controlled by a player who was dealt combat damage by three or more Pirates this turn.
Power: 3
Toughness: 3
Colors: B, R, U
Color Identity: B, R, U
Rarity: mythic | package mage.cards.a;
import java.util.*;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.BeginningOfEndStepTriggeredAbility;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.common.continuous.BoostAllEffect;
import mage.abilities.effects.common.continuous.GainControlTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.filter.common.FilterCreaturePermanent;
import mage.filter.common.FilterNonlandPermanent;
import mage.filter.predicate.Predicate;
import mage.game.Game;
import mage.game.events.DamagedPlayerEvent;
import mage.game.events.GameEvent;
import mage.game.permanent.Permanent;
import mage.target.common.TargetNonlandPermanent;
import mage.watchers.Watcher;
public final class AdmiralBeckettBrass extends CardImpl {
private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("Pirates you control");
private static final FilterNonlandPermanent filter2 = new FilterNonlandPermanent("nonland permanent controlled by a player who was dealt combat damage by three or more Pirates this turn");
static {
filter.add(SubType.PIRATE.getPredicate());
filter.add(TargetController.YOU.getControllerPredicate());
filter2.add(new ControllerDealtDamageByPiratesPredicate());
}
public AdmiralBeckettBrass(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{U}{B}{R}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.PIRATE);
this.power = new MageInt(3);
this.toughness = new MageInt(3);
// Other Pirates you control get +1/+1.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new BoostAllEffect(1, 1, Duration.WhileOnBattlefield, filter, true)));
// At the beginning of your end step, gain control of target nonland permanent controlled by a player who was dealt combat damage by three or more Pirates this turn.
Ability ability = new BeginningOfEndStepTriggeredAbility(new GainControlTargetEffect(Duration.Custom, true), TargetController.YOU, false);
ability.addTarget(new TargetNonlandPermanent(filter2));
this.addAbility(ability, new DamagedByPiratesWatcher());
}
private AdmiralBeckettBrass(final AdmiralBeckettBrass card) {
super(card);
}
@Override
public AdmiralBeckettBrass copy() {
return new AdmiralBeckettBrass(this);
}
}
class DamagedByPiratesWatcher extends Watcher {
private final Map<UUID, Set<UUID>> damageSourceIds = new HashMap<>();
public DamagedByPiratesWatcher() {
super(WatcherScope.GAME);
}
@Override
public void watch(GameEvent event, Game game) {
if (event.getType() == GameEvent.EventType.DAMAGED_PLAYER) {
if (((DamagedPlayerEvent) event).isCombatDamage()) {
Permanent creature = game.getPermanentOrLKIBattlefield(event.getSourceId());
if (creature != null && creature.hasSubtype(SubType.PIRATE, game)) {
if (damageSourceIds.containsKey(event.getTargetId())) {
damageSourceIds.get(event.getTargetId()).add(creature.getId());
} else {
Set<UUID> creatureSet = new HashSet<>();
creatureSet.add(creature.getId());
damageSourceIds.put(event.getTargetId(), creatureSet);
}
}
}
}
}
public boolean damagedByEnoughPirates(UUID sourceId) {
return damageSourceIds.containsKey(sourceId) && damageSourceIds.get(sourceId).size() > 2;
}
@Override
public void reset() {
super.reset();
damageSourceIds.clear();
}
}
class ControllerDealtDamageByPiratesPredicate implements Predicate<Permanent> {
@Override
public boolean apply(Permanent input, Game game) {
DamagedByPiratesWatcher watcher = game.getState().getWatcher(DamagedByPiratesWatcher.class);
if (watcher != null) {
return watcher.damagedByEnoughPirates(input.getControllerId());
}
return false;
}
} |
Layout: normal
Name: Admiral Brass, Unsinkable
Mana Cost: {2}{U}{B}{R}
Cmc: 5.0
Type Line: Legendary Creature — Human Pirate
Oracle Text: When Admiral Brass, Unsinkable enters, mill four cards.
At the beginning of combat on your turn, you may return target Pirate creature card from your graveyard to the battlefield with a finality counter on it. It has base power and toughness 4/4. It gains haste until end of turn. (If a creature with a finality counter on it would die, exile it instead.)
Power: 3
Toughness: 3
Colors: B, R, U
Color Identity: B, R, U
Keywords: Mill
Rarity: mythic | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.BeginningOfCombatTriggeredAbility;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.Effect;
import mage.abilities.effects.common.MillCardsControllerEffect;
import mage.abilities.effects.common.ReturnFromGraveyardToBattlefieldWithCounterTargetEffect;
import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
import mage.abilities.effects.common.continuous.SetBasePowerToughnessTargetEffect;
import mage.abilities.keyword.HasteAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.SubType;
import mage.constants.SuperType;
import mage.constants.TargetController;
import mage.counters.CounterType;
import mage.filter.common.FilterCreatureCard;
import mage.target.common.TargetCardInYourGraveyard;
public final class AdmiralBrassUnsinkable extends CardImpl {
private static final FilterCreatureCard filter = new FilterCreatureCard("Pirate creature card from your graveyard");
static {
filter.add(SubType.PIRATE.getPredicate());
}
public AdmiralBrassUnsinkable(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{U}{B}{R}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.PIRATE);
this.power = new MageInt(3);
this.toughness = new MageInt(3);
// When Admiral Brass, Unsinkable enters the battlefield, mill four cards.
this.addAbility(new EntersBattlefieldTriggeredAbility(
new MillCardsControllerEffect(4), false)
);
// At the beginning of combat on your turn, you may return target Pirate creature card from your graveyard
// to the battlefield with a finality counter on it. It has base power and toughness 4/4.
// It gains haste until end of turn. (If a creature with a finality counter on it would die, exile it instead.)
Effect returnFromGraveyardEffect = new ReturnFromGraveyardToBattlefieldWithCounterTargetEffect(CounterType.FINALITY.createInstance());
BeginningOfCombatTriggeredAbility ability = new BeginningOfCombatTriggeredAbility(
returnFromGraveyardEffect,
TargetController.YOU,
true
);
ability.addEffect(new SetBasePowerToughnessTargetEffect(4, 4, Duration.WhileOnBattlefield).setText("It has base power and toughness 4/4."));
ability.addEffect(new GainAbilityTargetEffect(HasteAbility.getInstance(), Duration.EndOfTurn).setText("It gains haste until end of turn. <i>(If a creature with a finality counter on it would die, exile it instead.)</i>"));
ability.addTarget(new TargetCardInYourGraveyard(filter));
this.addAbility(ability);
}
private AdmiralBrassUnsinkable(final AdmiralBrassUnsinkable card) {
super(card);
}
@Override
public AdmiralBrassUnsinkable copy() {
return new AdmiralBrassUnsinkable(this);
}
} |
Layout: normal
Name: Admiral's Order
Mana Cost: {1}{U}{U}
Cmc: 3.0
Type Line: Instant
Oracle Text: Raid — If you attacked this turn, you may pay {U} rather than pay this spell's mana cost.
Counter target spell.
Colors: U
Color Identity: U
Keywords: Raid
Rarity: rare | package mage.cards.a;
import mage.abilities.condition.common.RaidCondition;
import mage.abilities.costs.AlternativeCostSourceAbility;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.CounterTargetEffect;
import mage.abilities.hint.common.RaidHint;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.target.TargetSpell;
import mage.watchers.common.PlayerAttackedWatcher;
import java.util.UUID;
public final class AdmiralsOrder extends CardImpl {
public AdmiralsOrder(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{U}{U}");
// Raid - If you attacked with a creature this turn, you may pay {U} rather than pay this spell's mana cost.
this.addAbility(new AlternativeCostSourceAbility(new ManaCostsImpl<>("{U}"), RaidCondition.instance,
"<br/><i>Raid</i> — If you attacked this turn, you may pay {U} rather than pay this spell's mana cost."),
new PlayerAttackedWatcher());
// Counter target spell.
this.getSpellAbility().addEffect(new CounterTargetEffect());
this.getSpellAbility().addTarget(new TargetSpell());
this.getSpellAbility().addHint(RaidHint.instance);
}
private AdmiralsOrder(final AdmiralsOrder card) {
super(card);
}
@Override
public AdmiralsOrder copy() {
return new AdmiralsOrder(this);
}
} |
Layout: normal
Name: Admonition Angel
Mana Cost: {3}{W}{W}{W}
Cmc: 6.0
Type Line: Creature — Angel
Oracle Text: Flying
Landfall — Whenever a land you control enters, you may exile target nonland permanent other than Admonition Angel.
When Admonition Angel leaves the battlefield, return all cards exiled with it to the battlefield under their owners' control.
Power: 6
Toughness: 6
Colors: W
Color Identity: W
Keywords: Landfall, Flying
Rarity: mythic | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.TriggeredAbility;
import mage.abilities.common.LandfallAbility;
import mage.abilities.common.LeavesBattlefieldTriggeredAbility;
import mage.abilities.effects.common.ExileTargetForSourceEffect;
import mage.abilities.effects.common.ReturnFromExileForSourceEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.Zone;
import mage.filter.FilterPermanent;
import mage.filter.predicate.Predicates;
import mage.filter.predicate.mageobject.AnotherPredicate;
import mage.target.TargetPermanent;
public final class AdmonitionAngel extends CardImpl {
private static final FilterPermanent filter = new FilterPermanent("nonland permanent other than Admonition Angel");
static {
filter.add(AnotherPredicate.instance);
filter.add(Predicates.not(CardType.LAND.getPredicate()));
}
public AdmonitionAngel(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{W}{W}{W}");
this.subtype.add(SubType.ANGEL);
this.power = new MageInt(6);
this.toughness = new MageInt(6);
// Flying
this.addAbility(FlyingAbility.getInstance());
// Landfall - Whenever a land you control enters, you may exile target nonland permanent other than Admonition Angel.
TriggeredAbility ability = new LandfallAbility(Zone.BATTLEFIELD, new ExileTargetForSourceEffect(), true);
ability.addTarget(new TargetPermanent(filter));
this.addAbility(ability);
// When Admonition Angel leaves the battlefield, return all cards exiled with it to the battlefield under their owners' control.
Ability ability2 = new LeavesBattlefieldTriggeredAbility(new ReturnFromExileForSourceEffect(Zone.BATTLEFIELD)
.setText("return all cards exiled with it to the battlefield under their owners' control"), false);
this.addAbility(ability2);
}
private AdmonitionAngel(final AdmonitionAngel card) {
super(card);
}
@Override
public AdmonitionAngel copy() {
return new AdmonitionAngel(this);
}
} |
Layout: normal
Name: Adorned Pouncer
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Creature — Cat
Oracle Text: Double strike
Eternalize {3}{W}{W} ({3}{W}{W}, Exile this card from your graveyard: Create a token that's a copy of it, except it's a 4/4 black Zombie Cat with no mana cost. Eternalize only as a sorcery.)
Power: 1
Toughness: 1
Colors: W
Color Identity: W
Keywords: Double strike, Eternalize
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.keyword.DoubleStrikeAbility;
import mage.abilities.keyword.EternalizeAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
public final class AdornedPouncer extends CardImpl {
public AdornedPouncer(UUID ownerId, CardSetInfo cardSetInfo) {
super(ownerId, cardSetInfo, new CardType[]{CardType.CREATURE}, "{1}{W}");
subtype.add(SubType.CAT);
this.power = new MageInt(1);
this.toughness = new MageInt(1);
// Double strike
addAbility(DoubleStrikeAbility.getInstance());
// Eternalize 3WW
addAbility(new EternalizeAbility(new ManaCostsImpl<>("{3}{W}{W}"), this));
}
private AdornedPouncer(final AdornedPouncer card) {
super(card);
}
@Override
public AdornedPouncer copy() {
return new AdornedPouncer(this);
}
} |
Layout: normal
Name: Adriana, Captain of the Guard
Mana Cost: {3}{R}{W}
Cmc: 5.0
Type Line: Legendary Creature — Human Knight
Oracle Text: Melee (Whenever this creature attacks, it gets +1/+1 until end of turn for each opponent you attacked this combat.)
Other creatures you control have melee. (If a creature has multiple instances of melee, each triggers separately.)
Power: 4
Toughness: 4
Colors: R, W
Color Identity: R, W
Keywords: Melee
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.common.continuous.GainAbilityControlledEffect;
import mage.abilities.keyword.MeleeAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.filter.common.FilterControlledCreaturePermanent;
public final class AdrianaCaptainOfTheGuard extends CardImpl {
public AdrianaCaptainOfTheGuard(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{R}{W}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.KNIGHT);
this.power = new MageInt(4);
this.toughness = new MageInt(4);
// Melee
this.addAbility(new MeleeAbility());
// Other creatures you control have melee.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new GainAbilityControlledEffect(new MeleeAbility(), Duration.WhileOnBattlefield, new FilterControlledCreaturePermanent("creatures"), true)));
}
private AdrianaCaptainOfTheGuard(final AdrianaCaptainOfTheGuard card) {
super(card);
}
@Override
public AdrianaCaptainOfTheGuard copy() {
return new AdrianaCaptainOfTheGuard(this);
}
} |
Layout: normal
Name: Adric, Mathematical Genius
Mana Cost: {1}{U}
Cmc: 2.0
Type Line: Legendary Creature — Human Artificer
Oracle Text: {2}{U}, {T}: Copy target activated or triggered ability you control. You may choose new targets for the copy.
Ultimate Sacrifice — {1}{U}, Sacrifice Adric: Counter target activated or triggered ability.
Doctor's companion (You can have two commanders if the other is the Doctor.)
Power: 1
Toughness: 1
Colors: U
Color Identity: U
Keywords: Ultimate Sacrifice, Doctor's companion
Rarity: rare | package mage.cards.a;
import mage.MageInt;
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.CopyTargetStackObjectEffect;
import mage.abilities.effects.common.CounterTargetEffect;
import mage.abilities.keyword.DoctorsCompanionAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.SuperType;
import mage.constants.TargetController;
import mage.filter.FilterStackObject;
import mage.target.common.TargetActivatedOrTriggeredAbility;
import java.util.UUID;
public final class AdricMathematicalGenius extends CardImpl {
private static final FilterStackObject filter
= new FilterStackObject("activated or triggered ability you control");
static {
filter.add(TargetController.YOU.getControllerPredicate());
}
public AdricMathematicalGenius(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{U}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.ARTIFICER);
this.power = new MageInt(1);
this.toughness = new MageInt(1);
// {2}{U}, {T}: Copy target activated or triggered ability you control. You may choose new targets for the copy.
Ability ability = new SimpleActivatedAbility(new CopyTargetStackObjectEffect(), new ManaCostsImpl<>("{2}{U}"));
ability.addCost(new TapSourceCost());
ability.addTarget(new TargetActivatedOrTriggeredAbility(filter));
this.addAbility(ability);
// Ultimate Sacrifice -- {1}{U}, Sacrifice Adric: Counter target activated or triggered ability.
ability = new SimpleActivatedAbility(new CounterTargetEffect(), new ManaCostsImpl<>("{1}{U}"));
ability.addCost(new SacrificeSourceCost());
ability.addTarget(new TargetActivatedOrTriggeredAbility());
this.addAbility(ability.withFlavorWord("Ultimate Sacrifice"));
// Doctor's companion
this.addAbility(DoctorsCompanionAbility.getInstance());
}
private AdricMathematicalGenius(final AdricMathematicalGenius card) {
super(card);
}
@Override
public AdricMathematicalGenius copy() {
return new AdricMathematicalGenius(this);
}
} |
Layout: normal
Name: Adrix and Nev, Twincasters
Mana Cost: {2}{G}{U}
Cmc: 4.0
Type Line: Legendary Creature — Merfolk Wizard
Oracle Text: Ward {2} (Whenever this creature becomes the target of a spell or ability an opponent controls, counter it unless that player pays {2}.)
If one or more tokens would be created under your control, twice that many of those tokens are created instead.
Power: 2
Toughness: 2
Colors: G, U
Color Identity: G, U
Keywords: Ward
Rarity: mythic | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.replacement.CreateTwiceThatManyTokensEffect;
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 java.util.UUID;
public final class AdrixAndNevTwincasters extends CardImpl {
public AdrixAndNevTwincasters(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{2}{G}{U}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.MERFOLK);
this.subtype.add(SubType.WIZARD);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// Ward {2}
this.addAbility(new WardAbility(new ManaCostsImpl<>("{2}")));
// If one or more tokens would be created under your control, twice that many of those tokens are created instead.
this.addAbility(new SimpleStaticAbility(new CreateTwiceThatManyTokensEffect()));
}
private AdrixAndNevTwincasters(final AdrixAndNevTwincasters card) {
super(card);
}
@Override
public AdrixAndNevTwincasters copy() {
return new AdrixAndNevTwincasters(this);
}
} |
Layout: normal
Name: Adult Gold Dragon
Mana Cost: {3}{R}{W}
Cmc: 5.0
Type Line: Creature — Dragon
Oracle Text: Flying, lifelink, haste
Power: 4
Toughness: 3
Colors: R, W
Color Identity: R, W
Keywords: Flying, Lifelink, Haste
Rarity: rare | package mage.cards.a;
import mage.MageInt;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.HasteAbility;
import mage.abilities.keyword.LifelinkAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import java.util.UUID;
public final class AdultGoldDragon extends CardImpl {
public AdultGoldDragon(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{R}{W}");
this.subtype.add(SubType.DRAGON);
this.power = new MageInt(4);
this.toughness = new MageInt(3);
// Flying
this.addAbility(FlyingAbility.getInstance());
// Lifelink
this.addAbility(LifelinkAbility.getInstance());
// Haste
this.addAbility(HasteAbility.getInstance());
}
private AdultGoldDragon(final AdultGoldDragon card) {
super(card);
}
@Override
public AdultGoldDragon copy() {
return new AdultGoldDragon(this);
}
} |
Layout: normal
Name: Adun Oakenshield
Mana Cost: {B}{R}{G}
Cmc: 3.0
Type Line: Legendary Creature — Human Knight
Oracle Text: {B}{R}{G}, {T}: Return target creature card from your graveyard to your hand.
Power: 1
Toughness: 2
Colors: B, G, R
Color Identity: B, G, R
Reserved: True
Digital: True
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.ManaCostsImpl;
import mage.abilities.effects.common.ReturnFromGraveyardToHandTargetEffect;
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.common.TargetCardInYourGraveyard;
import java.util.UUID;
public final class AdunOakenshield extends CardImpl {
public AdunOakenshield(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{B}{R}{G}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.KNIGHT);
this.power = new MageInt(1);
this.toughness = new MageInt(2);
//{B}{R}{G}, {T}: Return target creature card from your graveyard to your hand.
Ability ability = new SimpleActivatedAbility(new ReturnFromGraveyardToHandTargetEffect(), new ManaCostsImpl<>("{B}{R}{G}"));
ability.addTarget(new TargetCardInYourGraveyard(StaticFilters.FILTER_CARD_CREATURE_YOUR_GRAVEYARD));
ability.addCost(new TapSourceCost());
this.addAbility(ability);
}
private AdunOakenshield(final AdunOakenshield card) {
super(card);
}
@Override
public AdunOakenshield copy() {
return new AdunOakenshield(this);
}
} |
Layout: normal
Name: Advance Scout
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Creature — Human Soldier Scout
Oracle Text: First strike
{W}: Target creature gains first strike until end of turn.
Power: 1
Toughness: 1
Colors: W
Color Identity: W
Keywords: First strike
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.mana.ColoredManaCost;
import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
import mage.abilities.keyword.FirstStrikeAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.target.common.TargetCreaturePermanent;
public final class AdvanceScout extends CardImpl {
public AdvanceScout(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{1}{W}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.SOLDIER);
this.subtype.add(SubType.SCOUT);
this.power = new MageInt(1);
this.toughness = new MageInt(1);
this.addAbility(FirstStrikeAbility.getInstance());
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new GainAbilityTargetEffect(FirstStrikeAbility.getInstance(), Duration.EndOfTurn), new ColoredManaCost(ColoredManaSymbol.W));
ability.addTarget(new TargetCreaturePermanent());
this.addAbility(ability);
}
private AdvanceScout(final AdvanceScout card) {
super(card);
}
@Override
public AdvanceScout copy() {
return new AdvanceScout(this);
}
} |
Layout: normal
Name: Advanced Hoverguard
Mana Cost: {3}{U}
Cmc: 4.0
Type Line: Creature — Drone
Oracle Text: Flying
{U}: Advanced Hoverguard gains shroud until end of turn. (It can't be the target of spells or abilities.)
Power: 2
Toughness: 2
Colors: U
Color Identity: U
Keywords: Flying
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.continuous.GainAbilitySourceEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.ShroudAbility;
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 AdvancedHoverguard extends CardImpl {
public AdvancedHoverguard(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{U}");
this.subtype.add(SubType.DRONE);
this.power = new MageInt(2);
this.toughness = new MageInt(2);
// Flying
this.addAbility(FlyingAbility.getInstance());
// {U}: Advanced Hoverguard gains shroud until end of turn.
this.addAbility(new SimpleActivatedAbility(Zone.BATTLEFIELD, new GainAbilitySourceEffect(ShroudAbility.getInstance(), Duration.EndOfTurn), new ManaCostsImpl<>("{U}")));
}
private AdvancedHoverguard(final AdvancedHoverguard card) {
super(card);
}
@Override
public AdvancedHoverguard copy() {
return new AdvancedHoverguard(this);
}
} |
Layout: normal
Name: Advanced Stitchwing
Mana Cost: {3}{U}{U}
Cmc: 5.0
Type Line: Creature — Zombie Horror
Oracle Text: Flying
{2}{U}, Discard two cards: Return Advanced Stitchwing from your graveyard to the battlefield tapped.
Power: 3
Toughness: 4
Colors: U
Color Identity: U
Keywords: Flying
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.DiscardTargetCost;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.ReturnSourceFromGraveyardToBattlefieldEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.Zone;
import mage.filter.StaticFilters;
import mage.target.common.TargetCardInHand;
public final class AdvancedStitchwing extends CardImpl {
public AdvancedStitchwing(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{3}{U}{U}");
this.subtype.add(SubType.ZOMBIE);
this.subtype.add(SubType.HORROR);
this.power = new MageInt(3);
this.toughness = new MageInt(4);
// Flying
this.addAbility(FlyingAbility.getInstance());
// {2}{U}, Discard two cards: Return Advanced Stitchwing from your graveyard to the battlefield tapped.
Ability ability = new SimpleActivatedAbility(Zone.GRAVEYARD, new ReturnSourceFromGraveyardToBattlefieldEffect(true, false), new ManaCostsImpl<>("{2}{U}"));
ability.addCost(new DiscardTargetCost(new TargetCardInHand(2, StaticFilters.FILTER_CARD_CARDS)));
this.addAbility(ability);
}
private AdvancedStitchwing(final AdvancedStitchwing card) {
super(card);
}
@Override
public AdvancedStitchwing copy() {
return new AdvancedStitchwing(this);
}
} |
Layout: normal
Name: Advent of the Wurm
Mana Cost: {1}{G}{G}{W}
Cmc: 4.0
Type Line: Instant
Oracle Text: Create a 5/5 green Wurm creature token with trample.
Colors: G, W
Color Identity: G, W
Rarity: rare | package mage.cards.a;
import mage.abilities.effects.common.CreateTokenEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.game.permanent.token.WurmWithTrampleToken;
import java.util.UUID;
public final class AdventOfTheWurm extends CardImpl {
public AdventOfTheWurm(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{G}{G}{W}");
// Create a 5/5 green Wurm creature token with trample.
this.getSpellAbility().addEffect(new CreateTokenEffect(new WurmWithTrampleToken()));
}
private AdventOfTheWurm(final AdventOfTheWurm card) {
super(card);
}
@Override
public AdventOfTheWurm copy() {
return new AdventOfTheWurm(this);
}
} |
Layout: normal
Name: Adventure Awaits
Mana Cost: {1}{G}
Cmc: 2.0
Type Line: Sorcery
Oracle Text: Look at the top five cards of your library. You may reveal a creature card from among them and put it into your hand. Put the rest on the bottom of your library in a random order. If you didn't put a card into your hand this way, draw a card.
Colors: G
Color Identity: G
Rarity: common | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.Mode;
import mage.abilities.effects.common.LookLibraryAndPickControllerEffect;
import mage.cards.Cards;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.PutCards;
import mage.filter.StaticFilters;
import mage.game.Game;
import mage.players.Player;
import java.util.UUID;
public final class AdventureAwaits extends CardImpl {
public AdventureAwaits(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{1}{G}");
// Look at the top five cards of your library. You may reveal a creature card from among them and put it into your hand.
// Put the rest on the bottom of your library in a random order. If you don't put a card into your hand this way, draw a card.
this.getSpellAbility().addEffect(new AdventureAwaitsEffect());
}
private AdventureAwaits(final AdventureAwaits card) {
super(card);
}
@Override
public AdventureAwaits copy() {
return new AdventureAwaits(this);
}
}
class AdventureAwaitsEffect extends LookLibraryAndPickControllerEffect {
AdventureAwaitsEffect() {
super(5, 1, StaticFilters.FILTER_CARD_CREATURE_A, PutCards.HAND, PutCards.BOTTOM_RANDOM);
}
private AdventureAwaitsEffect(final AdventureAwaitsEffect effect) {
super(effect);
}
@Override
public AdventureAwaitsEffect copy() {
return new AdventureAwaitsEffect(this);
}
@Override
public boolean actionWithPickedCards(Game game, Ability source, Player player, Cards pickedCards, Cards otherCards) {
super.actionWithPickedCards(game, source, player, pickedCards, otherCards);
if (pickedCards.isEmpty()) {
player.drawCards(1, source, game);
}
return true;
}
@Override
public String getText(Mode mode) {
return super.getText(mode).concat(". If you didn't put a card into your hand this way, draw a card");
}
} |
Layout: normal
Name: Adventurers' Guildhouse
Type Line: Land
Oracle Text: Green legendary creatures you control have "bands with other legendary creatures." (Any legendary creatures can attack in a band as long as at least one has "bands with other legendary creatures." Bands are blocked as a group. If at least two legendary creatures you control, one of which has "bands with other legendary creatures," are blocking or being blocked by the same creature, you divide that creature's combat damage, not its controller, among any of the creatures it's being blocked by or is blocking.)
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.ObjectColor;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.common.continuous.GainAbilityControlledEffect;
import mage.abilities.keyword.BandsWithOtherAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.SuperType;
import mage.constants.Zone;
import mage.filter.common.FilterCreaturePermanent;
import mage.filter.predicate.mageobject.ColorPredicate;
public final class AdventurersGuildhouse extends CardImpl {
private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("Green legendary creatures");
static {
filter.add(new ColorPredicate(ObjectColor.GREEN));
filter.add(SuperType.LEGENDARY.getPredicate());
}
public AdventurersGuildhouse(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.LAND}, "");
// Green legendary creatures you control have "bands with other legendary creatures."
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new GainAbilityControlledEffect(new BandsWithOtherAbility(SuperType.LEGENDARY), Duration.WhileOnBattlefield, filter).withForceQuotes()));
}
private AdventurersGuildhouse(final AdventurersGuildhouse card) {
super(card);
}
@Override
public AdventurersGuildhouse copy() {
return new AdventurersGuildhouse(this);
}
} |
Layout: normal
Name: Adventuring Gear
Mana Cost: {1}
Cmc: 1.0
Type Line: Artifact — Equipment
Oracle Text: Landfall — Whenever a land you control enters, equipped creature gets +2/+2 until end of turn.
Equip {1} ({1}: Attach to target creature you control. Equip only as a sorcery.)
Keywords: Equip, Landfall
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.common.LandfallAbility;
import mage.abilities.costs.mana.GenericManaCost;
import mage.abilities.effects.common.continuous.BoostEquippedEffect;
import mage.abilities.keyword.EquipAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.Outcome;
import mage.constants.SubType;
public final class AdventuringGear extends CardImpl {
public AdventuringGear(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.ARTIFACT},"{1}");
this.subtype.add(SubType.EQUIPMENT);
// Landfall — Whenever a land you control enters, equipped creature gets +2/+2 until end of turn.
this.addAbility(new LandfallAbility(new BoostEquippedEffect(2, 2, Duration.EndOfTurn), false));
// Equip {1} ({1}: Attach to target creature you control. Equip only as a sorcery.)
this.addAbility(new EquipAbility(Outcome.BoostCreature, new GenericManaCost(1)));
}
private AdventuringGear(final AdventuringGear card) {
super(card);
}
@Override
public AdventuringGear copy() {
return new AdventuringGear(this);
}
} |
Layout: normal
Name: Adventurous Impulse
Mana Cost: {G}
Cmc: 1.0
Type Line: Sorcery
Oracle Text: Look at the top three cards of your library. You may reveal a creature or land card from among them and put it into your hand. Put the rest on the bottom of your library in any order.
Colors: G
Color Identity: G
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.abilities.effects.common.LookLibraryAndPickControllerEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.PutCards;
import mage.filter.StaticFilters;
public final class AdventurousImpulse extends CardImpl {
public AdventurousImpulse(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.SORCERY},"{G}");
// Look at the top three cards of your library.
// You may reveal a creature or land card from among them and put it into your hand.
// Put the rest on the bottom of your library in any order.
this.getSpellAbility().addEffect(new LookLibraryAndPickControllerEffect(
3, 1, StaticFilters.FILTER_CARD_CREATURE_OR_LAND, PutCards.HAND, PutCards.BOTTOM_ANY));
}
private AdventurousImpulse(final AdventurousImpulse card) {
super(card);
}
@Override
public AdventurousImpulse copy() {
return new AdventurousImpulse(this);
}
} |
Layout: normal
Name: Adverse Conditions
Mana Cost: {3}{U}
Cmc: 4.0
Type Line: Instant
Oracle Text: Devoid (This card has no color.)
Tap up to two target creatures. Those creatures don't untap during their controller's next untap step. Create a 1/1 colorless Eldrazi Scion creature token. It has "Sacrifice this creature: Add {C}."
Color Identity: U
Keywords: Devoid
Produced Mana: C
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.abilities.effects.common.CreateTokenEffect;
import mage.abilities.effects.common.DontUntapInControllersNextUntapStepTargetEffect;
import mage.abilities.effects.common.TapTargetEffect;
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.common.TargetCreaturePermanent;
public final class AdverseConditions extends CardImpl {
public AdverseConditions(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{3}{U}");
// Devoid
this.addAbility(new DevoidAbility(this.color));
// Tap up to two target creatures. Those creatures don't untap during their controller's next untap step.
this.getSpellAbility().addEffect(new TapTargetEffect());
this.getSpellAbility().addTarget(new TargetCreaturePermanent(0, 2));
this.getSpellAbility().addEffect(new DontUntapInControllersNextUntapStepTargetEffect("Those creatures"));
// Create a 1/1 colorless Eldrazi Scion creature token. It has "Sacrifice this creature: Add {C}."
this.getSpellAbility().addEffect(new CreateTokenEffect(new EldraziScionToken()).withTextOptions(true));
}
private AdverseConditions(final AdverseConditions card) {
super(card);
}
@Override
public AdverseConditions copy() {
return new AdverseConditions(this);
}
} |
Layout: normal
Name: Advice from the Fae
Mana Cost: {2/U}{2/U}{2/U}
Cmc: 6.0
Type Line: Sorcery
Oracle Text: ({2/U} can be paid with any two mana or with {U}. This card's mana value is 6.)
Look at the top five cards of your library. If you control more creatures than each other player, put two of those cards into your hand. Otherwise, put one of them into your hand. Then put the rest on the bottom of your library in any order.
Colors: U
Color Identity: U
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.abilities.Ability;
import mage.abilities.condition.Condition;
import mage.abilities.decorator.ConditionalOneShotEffect;
import mage.abilities.effects.common.LookLibraryAndPickControllerEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.PutCards;
import mage.filter.StaticFilters;
import mage.game.Game;
public final class AdviceFromTheFae extends CardImpl {
public AdviceFromTheFae(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.SORCERY},"{2/U}{2/U}{2/U}");
// Look at the top five cards of your library. If you control more creatures than each other player,
// put two of those cards into your hand. Otherwise, put one of them into your hand.
// Then put the rest on the bottom of your library in any order.
this.getSpellAbility().addEffect(new ConditionalOneShotEffect(
new LookLibraryAndPickControllerEffect(5, 2, PutCards.HAND, PutCards.BOTTOM_ANY),
new LookLibraryAndPickControllerEffect(5, 1, PutCards.HAND, PutCards.BOTTOM_ANY),
AdviceFromTheFaeCondition.instance, "Look at the top five cards of your library. " +
"If you control more creatures than each other player, put two of those cards into your hand. " +
"Otherwise, put one of them into your hand. Then put the rest on the bottom of your library in any order."
));
}
private AdviceFromTheFae(final AdviceFromTheFae card) {
super(card);
}
@Override
public AdviceFromTheFae copy() {
return new AdviceFromTheFae(this);
}
}
enum AdviceFromTheFaeCondition implements Condition {
instance;
@Override
public boolean apply(Game game, Ability source) {
int max = 0;
UUID controllerId = source.getControllerId();
for (UUID playerId : game.getState().getPlayersInRange(controllerId, game)) {
if (!playerId.equals(controllerId)) {
max = Math.max(max, game.getBattlefield().countAll(StaticFilters.FILTER_PERMANENT_CREATURE, playerId, game));
}
}
return game.getBattlefield().countAll(StaticFilters.FILTER_PERMANENT_CREATURE, controllerId, game) > max;
}
@Override
public String toString() {
return "you control more creatures than each other player";
}
} |
Layout: normal
Name: Advocate of the Beast
Mana Cost: {2}{G}
Cmc: 3.0
Type Line: Creature — Elf Shaman
Oracle Text: At the beginning of your end step, put a +1/+1 counter on target Beast creature you control.
Power: 2
Toughness: 3
Colors: G
Color Identity: G
Rarity: common | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.BeginningOfEndStepTriggeredAbility;
import mage.abilities.effects.common.counter.AddCountersTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.TargetController;
import mage.counters.CounterType;
import mage.filter.common.FilterCreaturePermanent;
import mage.target.Target;
import mage.target.common.TargetCreaturePermanent;
public final class AdvocateOfTheBeast extends CardImpl {
private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("Beast creature you control");
static {
filter.add(TargetController.YOU.getControllerPredicate());
filter.add(SubType.BEAST.getPredicate());
}
public AdvocateOfTheBeast(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{2}{G}");
this.subtype.add(SubType.ELF);
this.subtype.add(SubType.SHAMAN);
this.power = new MageInt(2);
this.toughness = new MageInt(3);
// At the beginning of your end step, put a +1/+1 counter on target Beast creature you control.
Ability ability = new BeginningOfEndStepTriggeredAbility(new AddCountersTargetEffect(CounterType.P1P1.createInstance()), TargetController.YOU, false);
Target target = new TargetCreaturePermanent(filter);
ability.addTarget(target);
this.addAbility(ability);
}
private AdvocateOfTheBeast(final AdvocateOfTheBeast card) {
super(card);
}
@Override
public AdvocateOfTheBeast copy() {
return new AdvocateOfTheBeast(this);
}
} |
Layout: normal
Name: Aegar, the Freezing Flame
Mana Cost: {1}{U}{R}
Cmc: 3.0
Type Line: Legendary Creature — Giant Wizard
Oracle Text: Whenever a creature or planeswalker an opponent controls is dealt excess damage, if a Giant, Wizard, or spell you controlled dealt damage to it this turn, draw a card.
Power: 3
Toughness: 3
Colors: R, U
Color Identity: R, U
Rarity: uncommon | package mage.cards.a;
import mage.MageInt;
import mage.MageObject;
import mage.MageObjectReference;
import mage.abilities.TriggeredAbilityImpl;
import mage.abilities.effects.common.DrawCardSourceControllerEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.*;
import mage.game.Game;
import mage.game.events.DamagedBatchForOnePermanentEvent;
import mage.game.events.DamagedEvent;
import mage.game.events.GameEvent;
import mage.watchers.Watcher;
import java.util.*;
public final class AegarTheFreezingFlame extends CardImpl {
public AegarTheFreezingFlame(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{1}{U}{R}");
this.supertype.add(SuperType.LEGENDARY);
this.subtype.add(SubType.GIANT);
this.subtype.add(SubType.WIZARD);
this.power = new MageInt(3);
this.toughness = new MageInt(3);
// Whenever a creature or planeswalker an opponent controls is dealt excess damage, if a Giant, Wizard, or spell you controlled dealt damage to it this turn, draw a card.
this.addAbility(new AegarTheFreezingFlameTriggeredAbility());
}
private AegarTheFreezingFlame(final AegarTheFreezingFlame card) {
super(card);
}
@Override
public AegarTheFreezingFlame copy() {
return new AegarTheFreezingFlame(this);
}
}
class AegarTheFreezingFlameTriggeredAbility extends TriggeredAbilityImpl {
AegarTheFreezingFlameTriggeredAbility() {
super(Zone.BATTLEFIELD, new DrawCardSourceControllerEffect(1));
this.addWatcher(new AegarTheFreezingFlameWatcher());
}
private AegarTheFreezingFlameTriggeredAbility(final AegarTheFreezingFlameTriggeredAbility ability) {
super(ability);
}
@Override
public boolean checkEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.DAMAGED_BATCH_FOR_ONE_PERMANENT;
}
@Override
public boolean checkTrigger(GameEvent event, Game game) {
DamagedBatchForOnePermanentEvent dEvent = (DamagedBatchForOnePermanentEvent) event;
int excess = dEvent.getEvents()
.stream()
.mapToInt(DamagedEvent::getExcess)
.sum();
boolean controlledByOpponent =
game.getOpponents(getControllerId()).contains(game.getControllerId(event.getTargetId()));
if (excess < 1 || !controlledByOpponent) {
return false;
}
AegarTheFreezingFlameWatcher watcher = game.getState().getWatcher(AegarTheFreezingFlameWatcher.class);
return watcher != null && watcher.checkDamage(getControllerId(), event.getTargetId(), game);
}
@Override
public AegarTheFreezingFlameTriggeredAbility copy() {
return new AegarTheFreezingFlameTriggeredAbility(this);
}
@Override
public String getRule() {
return "Whenever a creature or planeswalker an opponent controls is dealt excess damage, " +
"if a Giant, Wizard, or spell you controlled dealt damage to it this turn, draw a card.";
}
}
class AegarTheFreezingFlameWatcher extends Watcher {
private final Map<UUID, Set<MageObjectReference>> playerMap = new HashMap<>();
private static final Set<MageObjectReference> emptySet = new HashSet<>();
AegarTheFreezingFlameWatcher() {
super(WatcherScope.GAME);
}
@Override
public void watch(GameEvent event, Game game) {
if (event.getType() != GameEvent.EventType.DAMAGED_PERMANENT) {
return;
}
DamagedEvent dEvent = (DamagedEvent) event;
MageObject sourceObject = game.getObject(event.getSourceId());
if (sourceObject == null) {
return;
}
if (game.getSpellOrLKIStack(event.getSourceId()) == null
&& !sourceObject.hasSubtype(SubType.GIANT, game)
&& !sourceObject.hasSubtype(SubType.WIZARD, game)) {
return;
}
playerMap
.computeIfAbsent(game.getControllerId(event.getSourceId()), x -> new HashSet<>())
.add(new MageObjectReference(event.getTargetId(), game));
}
boolean checkDamage(UUID playerId, UUID targetId, Game game) {
return playerMap.getOrDefault(playerId, emptySet).contains(new MageObjectReference(targetId, game));
}
@Override
public void reset() {
playerMap.clear();
super.reset();
}
} |
Layout: normal
Name: Aegis Angel
Mana Cost: {4}{W}{W}
Cmc: 6.0
Type Line: Creature — Angel
Oracle Text: Flying (This creature can't be blocked except by creatures with flying or reach.)
When Aegis Angel enters, another target permanent gains indestructible for as long as you control Aegis Angel. (Effects that say "destroy" don't destroy it. A creature with indestructible can't be destroyed by damage.)
Power: 5
Toughness: 5
Colors: W
Color Identity: W
Keywords: Flying
Rarity: rare | package mage.cards.a;
import mage.MageInt;
import mage.abilities.Ability;
import mage.abilities.common.EntersBattlefieldTriggeredAbility;
import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.abilities.keyword.IndestructibleAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.SubType;
import mage.filter.FilterPermanent;
import mage.filter.predicate.mageobject.AnotherPredicate;
import mage.target.TargetPermanent;
import java.util.UUID;
public final class AegisAngel extends CardImpl {
private static final FilterPermanent filter = new FilterPermanent("another target permanent");
static {
filter.add(AnotherPredicate.instance);
}
public AegisAngel(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{4}{W}{W}");
this.subtype.add(SubType.ANGEL);
this.power = new MageInt(5);
this.toughness = new MageInt(5);
// Flying
this.addAbility(FlyingAbility.getInstance());
// When Aegis Angel enters the battlefield, another target permanent is indestructible for as long as you control Aegis Angel.
Ability ability = new EntersBattlefieldTriggeredAbility(new GainAbilityTargetEffect(
IndestructibleAbility.getInstance(), Duration.WhileControlled
), false);
ability.addTarget(new TargetPermanent(filter));
this.addAbility(ability);
}
private AegisAngel(final AegisAngel card) {
super(card);
}
@Override
public AegisAngel copy() {
return new AegisAngel(this);
}
} |
Layout: normal
Name: Aegis Automaton
Mana Cost: {2}
Cmc: 2.0
Type Line: Artifact Creature — Construct
Oracle Text: {4}{W}: Return another target creature you control to its owner's hand.
Power: 0
Toughness: 3
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.mana.ManaCostsImpl;
import mage.abilities.effects.common.ReturnToHandTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.Zone;
import mage.filter.StaticFilters;
import mage.target.common.TargetControlledCreaturePermanent;
public final class AegisAutomaton extends CardImpl {
public AegisAutomaton(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{2}");
this.subtype.add(SubType.CONSTRUCT);
this.power = new MageInt(0);
this.toughness = new MageInt(3);
// {4}{W}: Return another target creature you control to its owner's hand.
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new ReturnToHandTargetEffect(), new ManaCostsImpl<>("{4}{W}"));
ability.addTarget(new TargetControlledCreaturePermanent(StaticFilters.FILTER_ANOTHER_TARGET_CREATURE_YOU_CONTROL));
this.addAbility(ability);
}
private AegisAutomaton(final AegisAutomaton card) {
super(card);
}
@Override
public AegisAutomaton copy() {
return new AegisAutomaton(this);
}
} |
Layout: normal
Name: Aegis of Honor
Mana Cost: {W}
Cmc: 1.0
Type Line: Enchantment
Oracle Text: {1}: The next time an instant or sorcery spell would deal damage to you this turn, that spell deals that damage to its controller instead.
Colors: W
Color Identity: W
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.abilities.Ability;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.RedirectionEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.Zone;
import mage.filter.common.FilterInstantOrSorceryCard;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.game.stack.Spell;
import mage.game.stack.StackObject;
import mage.target.TargetPlayer;
public final class AegisOfHonor extends CardImpl {
public AegisOfHonor(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.ENCHANTMENT},"{W}");
// {1}: The next time an instant or sorcery spell would deal damage to you this
//turn, that spell deals that damage to its controller instead.
this.addAbility(new SimpleActivatedAbility(Zone.BATTLEFIELD, new AegisOfHonorEffect(), new ManaCostsImpl<>("{1}")));
}
private AegisOfHonor(final AegisOfHonor card) {
super(card);
}
@Override
public AegisOfHonor copy() {
return new AegisOfHonor(this);
}
}
class AegisOfHonorEffect extends RedirectionEffect {
private static final FilterInstantOrSorceryCard instantOrSorceryfilter = new FilterInstantOrSorceryCard();
public AegisOfHonorEffect() {
super(Duration.EndOfTurn);
staticText = "The next time an instant or sorcery spell would deal "
+ "damage to you this turn, that spell deals that damage to its controller instead";
}
private AegisOfHonorEffect(final AegisOfHonorEffect card) {
super(card);
}
@Override
public boolean checksEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.DAMAGE_PLAYER;
}
@Override
public boolean applies(GameEvent event, Ability source, Game game) {
if (event.getTargetId().equals(source.getControllerId())) { //Checks to see the damage is to Aegis of Honor's controller
Spell spell = null;
StackObject stackObject = game.getStack().getStackObject(event.getSourceId());
if (stackObject == null) {
stackObject = (StackObject) game.getLastKnownInformation(event.getSourceId(), Zone.STACK);
}
if (stackObject instanceof Spell) {
spell = (Spell) stackObject;
}
//Checks if damage is from a sorcery or instants
if (spell != null && instantOrSorceryfilter.match(spell.getCard(), game)) {
TargetPlayer target = new TargetPlayer();
target.add(spell.getControllerId(), game);
redirectTarget = target;
return true;
}
}
return false;
}
@Override
public AegisOfHonorEffect copy() {
return new AegisOfHonorEffect(this);
}
} |
Layout: normal
Name: Aegis of the Gods
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Enchantment Creature — Human Soldier
Oracle Text: You have hexproof. (You can't be the target of spells or abilities your opponents control.)
Power: 2
Toughness: 1
Colors: W
Color Identity: W
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.common.continuous.GainAbilityControllerEffect;
import mage.abilities.keyword.HexproofAbility;
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 AegisOfTheGods extends CardImpl {
public AegisOfTheGods(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.ENCHANTMENT,CardType.CREATURE},"{1}{W}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.SOLDIER);
this.power = new MageInt(2);
this.toughness = new MageInt(1);
// You have hexproof.
this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new GainAbilityControllerEffect(HexproofAbility.getInstance(), Duration.WhileOnBattlefield)));
}
private AegisOfTheGods(final AegisOfTheGods card) {
super(card);
}
@Override
public AegisOfTheGods copy() {
return new AegisOfTheGods(this);
}
} |
Layout: normal
Name: Aegis of the Heavens
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Instant
Oracle Text: Target creature gets +1/+7 until end of turn.
Colors: W
Color Identity: W
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.abilities.effects.common.continuous.BoostTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.target.common.TargetCreaturePermanent;
public final class AegisOfTheHeavens extends CardImpl {
public AegisOfTheHeavens(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{W}");
// Target creature gets +1/+7 until end of turn.
this.getSpellAbility().addEffect(new BoostTargetEffect(1, 7, Duration.EndOfTurn));
this.getSpellAbility().addTarget(new TargetCreaturePermanent());
}
private AegisOfTheHeavens(final AegisOfTheHeavens card) {
super(card);
}
@Override
public AegisOfTheHeavens copy() {
return new AegisOfTheHeavens(this);
}
} |
Layout: normal
Name: Aegis of the Legion
Mana Cost: {R}{W}
Cmc: 2.0
Type Line: Artifact — Equipment
Oracle Text: Equipped creature gets +1/+1 and has mentor. (Whenever it attacks, put a +1/+1 counter on target attacking creature with lesser power.)
Whenever equipped creature mentors a creature, put a shield counter on that creature. (If that creature would be dealt damage or destroyed, remove a shield counter from it instead.)
Equip {3}
Colors: R, W
Color Identity: R, W
Keywords: Equip
Rarity: rare | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.TriggeredAbilityImpl;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.effects.common.continuous.BoostEquippedEffect;
import mage.abilities.effects.common.continuous.GainAbilityAttachedEffect;
import mage.abilities.effects.common.counter.AddCountersTargetEffect;
import mage.abilities.keyword.EquipAbility;
import mage.abilities.keyword.MentorAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.AttachmentType;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.Zone;
import mage.counters.CounterType;
import mage.game.Game;
import mage.game.events.GameEvent;
import mage.game.permanent.Permanent;
import mage.target.targetpointer.FixedTarget;
import java.util.UUID;
public final class AegisOfTheLegion extends CardImpl {
public AegisOfTheLegion(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT}, "{R}{W}");
this.subtype.add(SubType.EQUIPMENT);
// Equipped creature gets +1/+1 and has mentor.
Ability ability = new SimpleStaticAbility(new BoostEquippedEffect(1, 1));
ability.addEffect(new GainAbilityAttachedEffect(new MentorAbility(), AttachmentType.EQUIPMENT)
.setText("and has mentor. <i>(Whenever it attacks, put a +1/+1 counter on target attacking creature with lesser power.)</i>"));
this.addAbility(ability);
// Whenever equipped creature mentors a creature, put a shield counter on that creature.
this.addAbility(new AegisOfTheLegionTriggeredAbility());
// Equip {3}
this.addAbility(new EquipAbility(3, false));
}
private AegisOfTheLegion(final AegisOfTheLegion card) {
super(card);
}
@Override
public AegisOfTheLegion copy() {
return new AegisOfTheLegion(this);
}
}
class AegisOfTheLegionTriggeredAbility extends TriggeredAbilityImpl {
AegisOfTheLegionTriggeredAbility() {
super(Zone.BATTLEFIELD, new AddCountersTargetEffect(CounterType.SHIELD.createInstance()));
setTriggerPhrase("Whenever equipped creature mentors a creature, ");
}
private AegisOfTheLegionTriggeredAbility(final AegisOfTheLegionTriggeredAbility ability) {
super(ability);
}
@Override
public boolean checkEventType(GameEvent event, Game game) {
return event.getType() == GameEvent.EventType.MENTORED_CREATURE;
}
@Override
public boolean checkTrigger(GameEvent event, Game game) {
// 20240202 - 702.134c
// An ability that triggers whenever a creature mentors another creature
// triggers whenever a mentor ability whose source is the first creature and whose target is the second creature resolves.
Permanent attachment = getSourcePermanentOrLKI(game);
Permanent mentoredCreature = game.getPermanent(event.getTargetId());
if (attachment == null || mentoredCreature == null || !event.getSourceId().equals(attachment.getAttachedTo())) {
return false;
}
getEffects().setTargetPointer(new FixedTarget(mentoredCreature, game));
return true;
}
@Override
public AegisOfTheLegionTriggeredAbility copy() {
return new AegisOfTheLegionTriggeredAbility(this);
}
} |
Layout: normal
Name: Aegis of the Meek
Mana Cost: {3}
Cmc: 3.0
Type Line: Artifact
Oracle Text: {1}, {T}: Target 1/1 creature gets +1/+2 until end of turn.
Reserved: True
Rarity: rare | package mage.cards.a;
import java.util.UUID;
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.BoostTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.ComparisonType;
import mage.constants.Duration;
import mage.constants.Zone;
import mage.filter.common.FilterCreaturePermanent;
import mage.filter.predicate.mageobject.PowerPredicate;
import mage.filter.predicate.mageobject.ToughnessPredicate;
import mage.target.common.TargetCreaturePermanent;
public final class AegisOfTheMeek extends CardImpl {
private static final FilterCreaturePermanent filter = new FilterCreaturePermanent("1/1 creature");
static {
filter.add(new PowerPredicate(ComparisonType.EQUAL_TO, 1));
filter.add(new ToughnessPredicate(ComparisonType.EQUAL_TO, 1));
}
public AegisOfTheMeek(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.ARTIFACT},"{3}");
// {1}, {T}: Target 1/1 creature gets +1/+2 until end of turn.
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new BoostTargetEffect(1, 2, Duration.EndOfTurn), new ManaCostsImpl<>("{1}"));
ability.addCost(new TapSourceCost());
ability.addTarget(new TargetCreaturePermanent(filter));
this.addAbility(ability);
}
private AegisOfTheMeek(final AegisOfTheMeek card) {
super(card);
}
@Override
public AegisOfTheMeek copy() {
return new AegisOfTheMeek(this);
}
} |
Layout: normal
Name: Aegis Turtle
Mana Cost: {U}
Cmc: 1.0
Type Line: Creature — Turtle
Power: 0
Toughness: 5
Colors: U
Color Identity: U
Rarity: common | package mage.cards.a;
import mage.MageInt;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import java.util.UUID;
public final class AegisTurtle extends CardImpl {
public AegisTurtle(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{U}");
this.subtype.add(SubType.TURTLE);
this.power = new MageInt(0);
this.toughness = new MageInt(5);
}
private AegisTurtle(final AegisTurtle card) {
super(card);
}
@Override
public AegisTurtle copy() {
return new AegisTurtle(this);
}
} |
Layout: normal
Name: Aeolipile
Mana Cost: {2}
Cmc: 2.0
Type Line: Artifact
Oracle Text: {1}, {T}, Sacrifice Aeolipile: It deals 2 damage to any target.
Reserved: True
Digital: True
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.DamageTargetEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Zone;
import mage.target.common.TargetAnyTarget;
public final class Aeolipile extends CardImpl {
public Aeolipile(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.ARTIFACT},"{2}");
// {1}, {tap}, Sacrifice Aeolipile: Aeolipile deals 2 damage to any target.
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new DamageTargetEffect(2, "it"), new ManaCostsImpl<>("{1}"));
ability.addCost(new TapSourceCost());
ability.addCost(new SacrificeSourceCost());
ability.addTarget(new TargetAnyTarget());
this.addAbility(ability);
}
private Aeolipile(final Aeolipile card) {
super(card);
}
@Override
public Aeolipile copy() {
return new Aeolipile(this);
}
} |
Layout: normal
Name: Aeon Chronicler
Mana Cost: {3}{U}{U}
Cmc: 5.0
Type Line: Creature — Avatar
Oracle Text: Aeon Chronicler's power and toughness are each equal to the number of cards in your hand.
Suspend X—{X}{3}{U}. X can't be 0.
Whenever a time counter is removed from Aeon Chronicler while it's exiled, draw a card.
Power: *
Toughness: *
Colors: U
Color Identity: U
Keywords: Suspend
Rarity: rare | package mage.cards.a;
import mage.MageInt;
import mage.abilities.common.CounterRemovedFromSourceWhileExiledTriggeredAbility;
import mage.abilities.common.SimpleStaticAbility;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.dynamicvalue.common.CardsInControllerHandCount;
import mage.abilities.effects.common.DrawCardSourceControllerEffect;
import mage.abilities.effects.common.continuous.SetBasePowerToughnessSourceEffect;
import mage.abilities.keyword.SuspendAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
import mage.constants.Zone;
import mage.counters.CounterType;
import java.util.UUID;
public final class AeonChronicler extends CardImpl {
public AeonChronicler(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{3}{U}{U}");
this.subtype.add(SubType.AVATAR);
this.power = new MageInt(0);
this.toughness = new MageInt(0);
// Aeon Chronicler's power and toughness are each equal to the number of cards in your hand.
this.addAbility(new SimpleStaticAbility(Zone.ALL, new SetBasePowerToughnessSourceEffect(CardsInControllerHandCount.instance)));
// Suspend X-{X}{3}{U}. X can't be 0.
this.addAbility(new SuspendAbility(Integer.MAX_VALUE, new ManaCostsImpl<>("{3}{U}"), this, true));
// Whenever a time counter is removed from Aeon Chronicler while it's exiled, draw a card.
this.addAbility(new CounterRemovedFromSourceWhileExiledTriggeredAbility(CounterType.TIME, new DrawCardSourceControllerEffect(1)));
}
private AeonChronicler(final AeonChronicler card) {
super(card);
}
@Override
public AeonChronicler copy() {
return new AeonChronicler(this);
}
} |
Layout: normal
Name: Aeon Engine
Mana Cost: {5}
Cmc: 5.0
Type Line: Artifact
Oracle Text: Aeon Engine enters tapped.
{T}, Exile Aeon Engine: Reverse the game's turn order. (For example, if play had proceeded clockwise around the table, it now goes counterclockwise.)
Rarity: rare | package mage.cards.a;
import mage.abilities.Ability;
import mage.abilities.common.EntersBattlefieldTappedAbility;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.common.ExileSourceCost;
import mage.abilities.costs.common.TapSourceCost;
import mage.abilities.effects.OneShotEffect;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Outcome;
import mage.constants.Zone;
import mage.game.Game;
import java.util.UUID;
public final class AeonEngine extends CardImpl {
public AeonEngine(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.ARTIFACT}, "{5}");
// Aeon Engine enters the battlefield tapped.
this.addAbility(new EntersBattlefieldTappedAbility());
// {T}, Exile Aeon Engine: Reverse the gameâs turn order. (For example, if play had proceeded clockwise around the table, it now goes counterclockwise.)
Ability ability = new SimpleActivatedAbility(Zone.BATTLEFIELD, new AeonEngineEffect(), new TapSourceCost());
ability.addCost(new ExileSourceCost());
this.addAbility(ability);
}
private AeonEngine(final AeonEngine card) {
super(card);
}
@Override
public AeonEngine copy() {
return new AeonEngine(this);
}
}
class AeonEngineEffect extends OneShotEffect {
AeonEngineEffect() {
super(Outcome.Benefit);
this.staticText = "Reverse the game's turn order.";
}
private AeonEngineEffect(final AeonEngineEffect effect) {
super(effect);
}
public AeonEngineEffect copy() {
return new AeonEngineEffect(this);
}
public boolean apply(Game game, Ability source) {
game.getState().setReverseTurnOrder(true);
return true;
}
} |
Layout: normal
Name: Aerathi Berserker
Mana Cost: {2}{R}{R}{R}
Cmc: 5.0
Type Line: Creature — Human Berserker
Oracle Text: Rampage 3 (Whenever this creature becomes blocked, it gets +3/+3 until end of turn for each creature blocking it beyond the first.)
Power: 2
Toughness: 4
Colors: R
Color Identity: R
Keywords: Rampage
Rarity: uncommon | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.keyword.RampageAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.SubType;
public final class AerathiBerserker extends CardImpl {
public AerathiBerserker(UUID ownerId, CardSetInfo setInfo) {
super(ownerId,setInfo,new CardType[]{CardType.CREATURE},"{2}{R}{R}{R}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.BERSERKER);
this.power = new MageInt(2);
this.toughness = new MageInt(4);
// Rampage 3
this.addAbility(new RampageAbility(3));
}
private AerathiBerserker(final AerathiBerserker card) {
super(card);
}
@Override
public AerathiBerserker copy() {
return new AerathiBerserker(this);
}
} |
Layout: normal
Name: Aerial Assault
Mana Cost: {2}{W}
Cmc: 3.0
Type Line: Sorcery
Oracle Text: Destroy target tapped creature. You gain 1 life for each creature you control with flying.
Colors: W
Color Identity: W
Rarity: common | package mage.cards.a;
import mage.abilities.dynamicvalue.DynamicValue;
import mage.abilities.dynamicvalue.common.PermanentsOnBattlefieldCount;
import mage.abilities.effects.common.DestroyTargetEffect;
import mage.abilities.effects.common.GainLifeEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.filter.FilterPermanent;
import mage.filter.common.FilterControlledCreaturePermanent;
import mage.filter.common.FilterCreaturePermanent;
import mage.filter.predicate.mageobject.AbilityPredicate;
import mage.filter.predicate.permanent.TappedPredicate;
import mage.target.TargetPermanent;
import java.util.UUID;
public final class AerialAssault extends CardImpl {
private static final FilterPermanent filter
= new FilterCreaturePermanent("tapped creature");
private static final FilterPermanent filter2
= new FilterControlledCreaturePermanent("creature you control with flying");
static {
filter.add(TappedPredicate.TAPPED);
filter2.add(new AbilityPredicate(FlyingAbility.class));
}
private static final DynamicValue xValue = new PermanentsOnBattlefieldCount(filter2);
public AerialAssault(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.SORCERY}, "{2}{W}");
// Destroy target tapped creature. You gain 1 life for each creature you control with flying.
this.getSpellAbility().addEffect(new DestroyTargetEffect());
this.getSpellAbility().addTarget(new TargetPermanent(filter));
this.getSpellAbility().addEffect(new GainLifeEffect(xValue));
}
private AerialAssault(final AerialAssault card) {
super(card);
}
@Override
public AerialAssault copy() {
return new AerialAssault(this);
}
} |
Layout: normal
Name: Aerial Boost
Mana Cost: {1}{W}
Cmc: 2.0
Type Line: Instant
Oracle Text: Convoke (Your creatures can help cast this spell. Each creature you tap while casting this spell pays for {1} or one mana of that creature's color.)
Target creature gets +2/+2 and gains flying until end of turn.
Colors: W
Color Identity: W
Keywords: Convoke
Rarity: common | package mage.cards.a;
import mage.abilities.effects.common.continuous.BoostTargetEffect;
import mage.abilities.effects.common.continuous.GainAbilityTargetEffect;
import mage.abilities.keyword.ConvokeAbility;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.target.common.TargetCreaturePermanent;
import java.util.UUID;
public final class AerialBoost extends CardImpl {
public AerialBoost(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.INSTANT}, "{1}{W}");
// Convoke
this.addAbility(new ConvokeAbility());
// Target creature gets +2/+2 and gains flying until end of turn.
this.getSpellAbility().addEffect(new BoostTargetEffect(2, 2)
.setText("target creature gets +2/+2"));
this.getSpellAbility().addEffect(new GainAbilityTargetEffect(
FlyingAbility.getInstance(), Duration.EndOfTurn
).setText("and gains flying until end of turn"));
this.getSpellAbility().addTarget(new TargetCreaturePermanent());
}
private AerialBoost(final AerialBoost card) {
super(card);
}
@Override
public AerialBoost copy() {
return new AerialBoost(this);
}
} |
Layout: normal
Name: Aerial Caravan
Mana Cost: {4}{U}{U}
Cmc: 6.0
Type Line: Creature — Human Soldier
Oracle Text: Flying
{1}{U}{U}: Exile the top card of your library. Until end of turn, you may play that card. (Reveal the card as you exile it.)
Power: 4
Toughness: 3
Colors: U
Color Identity: U
Keywords: Flying
Rarity: rare | package mage.cards.a;
import java.util.UUID;
import mage.MageInt;
import mage.abilities.common.SimpleActivatedAbility;
import mage.abilities.costs.mana.ManaCostsImpl;
import mage.abilities.effects.common.ExileTopXMayPlayUntilEffect;
import mage.abilities.keyword.FlyingAbility;
import mage.cards.CardImpl;
import mage.cards.CardSetInfo;
import mage.constants.CardType;
import mage.constants.Duration;
import mage.constants.SubType;
public final class AerialCaravan extends CardImpl {
public AerialCaravan(UUID ownerId, CardSetInfo setInfo) {
super(ownerId, setInfo, new CardType[]{CardType.CREATURE}, "{4}{U}{U}");
this.subtype.add(SubType.HUMAN);
this.subtype.add(SubType.SOLDIER);
this.power = new MageInt(4);
this.toughness = new MageInt(3);
// Flying
this.addAbility(FlyingAbility.getInstance());
// {1}{U}{U}: Exile the top card of your library. Until end of turn, you may play that card.
this.addAbility(new SimpleActivatedAbility(
new ExileTopXMayPlayUntilEffect(1, Duration.EndOfTurn)
.withTextOptions("that card. <i>(Reveal the card as you exile it.)</i>", false),
new ManaCostsImpl<>("{1}{U}{U}")));
}
private AerialCaravan(final AerialCaravan card) {
super(card);
}
@Override
public AerialCaravan copy() {
return new AerialCaravan(this);
}
} |