public AnotherCreatureEntersTheBattlefield(GameState state) {
super(
state,
"Whenever another creature enters the battlefield under your control, if you control both that creature and this one and both are unpaired, you may pair that creature with this creature for as long as both remain creatures on the battlefield under your control.");
SetGenerator thisCreature = ABILITY_SOURCE_OF_THIS;
SetGenerator otherCreatures =
RelativeComplement.instance(CreaturePermanents.instance(), thisCreature);
this.addPattern(
new SimpleZoneChangePattern(
null, Battlefield.instance(), otherCreatures, You.instance(), false));
SetGenerator thatCreature = NewObjectOf.instance(TriggerZoneChange.instance(This.instance()));
SetGenerator youControl = ControlledBy.instance(You.instance());
SetGenerator youControlUnpairedThis =
Intersect.instance(youControl, Unpaired.instance(), thisCreature);
SetGenerator youControlUnpairedThat =
Intersect.instance(youControl, Unpaired.instance(), thatCreature);
this.interveningIf = Both.instance(youControlUnpairedThis, youControlUnpairedThat);
ContinuousEffect.Part part = new ContinuousEffect.Part(ContinuousEffectType.PAIR);
part.parameters.put(
ContinuousEffectType.Parameter.OBJECT, Union.instance(thisCreature, thatCreature));
SetGenerator youControlCreatureThis = Intersect.instance(CREATURES_YOU_CONTROL, thisCreature);
SetGenerator youControlCreatureThat = Intersect.instance(CREATURES_YOU_CONTROL, thatCreature);
SetGenerator expires =
Not.instance(Both.instance(youControlCreatureThis, youControlCreatureThat));
EventFactory floatingEffect =
createFloatingEffect(expires, "Pair this creature with that creature", part);
this.addEffect(youMay(floatingEffect));
}
public Pyroblast(GameState state) {
super(state);
{
Target target = this.addTarget(1, Spells.instance(), "target spell");
EventFactory counter =
new EventFactory(EventType.IF_CONDITION_THEN_ELSE, "Counter target spell if it's blue.");
counter.parameters.put(
EventType.Parameter.IF,
Intersect.instance(targetedBy(target), HasColor.instance(Color.BLUE)));
counter.parameters.put(
EventType.Parameter.THEN,
Identity.instance(counter(targetedBy(target), "Counter target spell.")));
this.addEffect(1, counter);
}
{
Target target = this.addTarget(2, Permanents.instance(), "target permanent");
EventFactory destroy =
new EventFactory(
EventType.IF_CONDITION_THEN_ELSE, "Destroy target permanent if it's blue.");
destroy.parameters.put(
EventType.Parameter.IF,
Intersect.instance(targetedBy(target), HasColor.instance(Color.BLUE)));
destroy.parameters.put(
EventType.Parameter.THEN,
Identity.instance(destroy(targetedBy(target), "Destroy target permanent.")));
this.addEffect(2, destroy);
}
}
public AgadeemOccultistAbility0(GameState state) {
super(
state,
"(T): Put target creature card from an opponent's graveyard onto the battlefield under your control if its converted mana cost is less than or equal to the number of Allies you control.");
this.costsTap = true;
SetGenerator creatureCards = HasType.instance(Type.CREATURE);
SetGenerator inOpponentsYard =
InZone.instance(GraveyardOf.instance(OpponentsOf.instance(You.instance())));
Target t =
this.addTarget(
Intersect.instance(creatureCards, inOpponentsYard),
"target creature card from an opponent's graveyard");
EventFactory move =
new EventFactory(
EventType.PUT_ONTO_BATTLEFIELD,
"Put target creature card from an opponent's graveyard onto the battlefield under your control");
move.parameters.put(EventType.Parameter.CAUSE, This.instance());
move.parameters.put(EventType.Parameter.CONTROLLER, You.instance());
move.parameters.put(EventType.Parameter.OBJECT, targetedBy(t));
SetGenerator lessThanOrEqualNumAllies =
Between.instance(null, Count.instance(ALLIES_YOU_CONTROL));
SetGenerator condition =
Intersect.instance(ConvertedManaCostOf.instance(targetedBy(t)), lessThanOrEqualNumAllies);
EventFactory effect =
new EventFactory(
EventType.IF_CONDITION_THEN_ELSE,
"Put target creature card from an opponent's graveyard onto the battlefield under your control if its converted mana cost is less than or equal to the number of Allies you control.");
effect.parameters.put(EventType.Parameter.IF, condition);
effect.parameters.put(EventType.Parameter.THEN, Identity.instance(move));
this.addEffect(effect);
}
public EvolutionCharm(GameState state) {
super(state);
// Choose one
// Search your library for a basic land card, reveal it, put it into
// your hand, then shuffle your library
{
EventType.ParameterMap searchParameters = new EventType.ParameterMap();
searchParameters.put(EventType.Parameter.CAUSE, This.instance());
searchParameters.put(EventType.Parameter.PLAYER, You.instance());
searchParameters.put(EventType.Parameter.NUMBER, numberGenerator(1));
searchParameters.put(
EventType.Parameter.TYPE,
Identity.instance(
Intersect.instance(
HasSuperType.instance(SuperType.BASIC), HasType.instance(Type.LAND))));
searchParameters.put(EventType.Parameter.TO, HandOf.instance(You.instance()));
this.addEffect(
1,
new EventFactory(
EventType.SEARCH_LIBRARY_AND_PUT_INTO,
searchParameters,
"Search your library for a basic land card, reveal it, put it into your hand, then shuffle your library."));
}
// Return target creature card from your graveyard to your hand
{
SetGenerator graveyard = GraveyardOf.instance(You.instance());
Target target =
this.addTarget(
2,
Intersect.instance(HasType.instance(Type.CREATURE), InZone.instance(graveyard)),
"target creature from your graveyard");
EventType.ParameterMap moveParameters = new EventType.ParameterMap();
moveParameters.put(EventType.Parameter.CAUSE, This.instance());
moveParameters.put(EventType.Parameter.TO, HandOf.instance(You.instance()));
moveParameters.put(EventType.Parameter.OBJECT, targetedBy(target));
this.addEffect(
2,
new EventFactory(
EventType.MOVE_OBJECTS,
moveParameters,
"Return target creature card from your graveyard to your hand."));
}
// Target creature gains flying until end of turn.
{
Target target = this.addTarget(3, CreaturePermanents.instance(), "target creature");
this.addEffect(
3,
addAbilityUntilEndOfTurn(
targetedBy(target),
org.rnd.jmagic.abilities.keywords.Flying.class,
"Target creature gains flying until end of turn."));
}
}
public OgreJailbreakerAbility1(GameState state) {
super(
state,
"Ogre Jailbreaker can attack as though it didn't have defender as long as you control a Gate.");
ContinuousEffect.Part part =
new ContinuousEffect.Part(ContinuousEffectType.ATTACK_AS_THOUGH_DOESNT_HAVE_DEFENDER);
part.parameters.put(ContinuousEffectType.Parameter.OBJECT, This.instance());
this.addEffectPart(part);
SetGenerator youControlAGate =
Intersect.instance(
ControlledBy.instance(You.instance()), HasSubType.instance(SubType.GATE));
this.canApply = Intersect.instance(this.canApply, youControlAGate);
}
@Override
public boolean perform(Game game, Event event, Map<Parameter, MagicSet> parameters) {
MagicSet cause = parameters.get(Parameter.CAUSE);
event.setResult(Empty.set);
Set<Color> choices = parameters.get(Parameter.CHOICE).getAll(Color.class);
Player player = parameters.get(Parameter.PLAYER).getOne(Player.class);
PlayerInterface.ChooseParameters<Color> chooseParameters =
new PlayerInterface.ChooseParameters<Color>(
1,
1,
new LinkedList<Color>(choices),
PlayerInterface.ChoiceType.COLOR,
PlayerInterface.ChooseReason.CHOOSE_COLOR);
chooseParameters.thisID = cause.getOne(GameObject.class).ID;
List<Color> chosenList = player.choose(chooseParameters);
if (chosenList.isEmpty()) return false;
Color color = chosenList.get(0);
Class<? extends Protection> ability = Protection.from(color);
ContinuousEffect.Part part =
new ContinuousEffect.Part(ContinuousEffectType.ADD_ABILITY_TO_OBJECT);
part.parameters.put(
ContinuousEffectType.Parameter.OBJECT,
Intersect.instance(
HasColor.instance(Color.WHITE),
Intersect.instance(
HasType.instance(Type.CREATURE), ControlledBy.instance(You.instance()))));
part.parameters.put(
ContinuousEffectType.Parameter.ABILITY,
Identity.instance(new SimpleAbilityFactory(ability)));
Map<Parameter, MagicSet> fceParameters = new HashMap<Parameter, MagicSet>();
fceParameters.put(Parameter.CAUSE, cause);
fceParameters.put(Parameter.EFFECT, new MagicSet(part));
Event protection =
createEvent(
game,
"White creatures you control gain protection from the chosen color until end of turn.",
EventType.CREATE_FLOATING_CONTINUOUS_EFFECT,
fceParameters);
protection.perform(event, false);
return true;
}
public MnemonicWallAbility1(GameState state) {
super(
state,
"When Mnemonic Wall enters the battlefield, you may return target instant or sorcery card from your graveyard to your hand.");
this.addPattern(whenThisEntersTheBattlefield());
SetGenerator yourGraveyard = GraveyardOf.instance(You.instance());
SetGenerator spellsInYard =
Intersect.instance(
HasType.instance(Type.INSTANT, Type.SORCERY), InZone.instance(yourGraveyard));
SetGenerator target =
targetedBy(
this.addTarget(spellsInYard, "target instant or sorcery card from your graveyard"));
EventFactory move =
new EventFactory(
EventType.MOVE_OBJECTS,
"Return target instant or sorcery card from your graveyard to your hand");
move.parameters.put(EventType.Parameter.CAUSE, This.instance());
move.parameters.put(EventType.Parameter.TO, HandOf.instance(You.instance()));
move.parameters.put(EventType.Parameter.OBJECT, target);
this.addEffect(
youMay(
move,
"You may return target instant or sorcery card from your graveyard to your hand."));
}
public DearlyDepartedAbility1(GameState state) {
super(
state,
"As long as Dearly Departed is in your graveyard, each Human creature you control enters the battlefield with an additional +1/+1 counter on it.");
this.canApply = THIS_IS_IN_A_GRAVEYARD;
SetGenerator humanCreatures =
Intersect.instance(HasSubType.instance(SubType.HUMAN), HasType.instance(Type.CREATURE));
ZoneChangeReplacementEffect replacement =
new ZoneChangeReplacementEffect(this.game, this.getName());
replacement.addPattern(
new SimpleZoneChangePattern(
null, Battlefield.instance(), humanCreatures, You.instance(), false));
SetGenerator zoneChange = ReplacedBy.instance(Identity.instance(replacement));
EventFactory factory = new EventFactory(EventType.PUT_COUNTERS, this.getName());
factory.parameters.put(EventType.Parameter.CAUSE, CauseOf.instance(zoneChange));
factory.parameters.put(
EventType.Parameter.COUNTER, Identity.instance(Counter.CounterType.PLUS_ONE_PLUS_ONE));
factory.parameters.put(EventType.Parameter.OBJECT, NewObjectOf.instance(zoneChange));
replacement.addEffect(factory);
this.addEffectPart(replacementEffectPart(replacement));
}
public IndestructibleChaos(GameState state) {
super(
state,
"Whenever you roll (C), put a divinity counter on target green, white, or blue creature. That creature is indestructible as long as it has a divinity counter on it.");
this.addPattern(Planechase.wheneverYouRollChaos());
Target target =
this.addTarget(
Intersect.instance(
CreaturePermanents.instance(),
HasColor.instance(Color.GREEN, Color.WHITE, Color.BLUE)),
"target green, white, or blue creature");
this.addEffect(
putCounters(
1,
Counter.CounterType.DIVINITY,
targetedBy(target),
"Put a divinity counter on target green, white, or blue creature."));
this.addEffect(
createFloatingEffect(
CountersOn.instance(targetedBy(target), Counter.CounterType.DIVINITY),
"That creature is indestructible as long as it has a divinity counter on it.",
indestructible(targetedBy(target))));
this.canTrigger = Planechase.triggeredAbilityCanTrigger;
}
public ArrowVolleyTrap(GameState state) {
super(state);
SetGenerator trapCondition =
Intersect.instance(Between.instance(4, null), Count.instance(Attacking.instance()));
this.addAbility(
new org.rnd.jmagic.abilities.Trap(
state,
this.getName(),
trapCondition,
"If four or more creatures are attacking",
"(1)(W)"));
Target target = this.addTarget(Attacking.instance(), "up to five target attacking creatures");
target.setNumber(1, 5);
this.setDivision(Union.instance(numberGenerator(5), Identity.instance("damage")));
EventType.ParameterMap damageParameters = new EventType.ParameterMap();
damageParameters.put(EventType.Parameter.SOURCE, This.instance());
damageParameters.put(
EventType.Parameter.TAKER,
ChosenTargetsFor.instance(Identity.instance(target), This.instance()));
this.addEffect(
new EventFactory(
EventType.DISTRIBUTE_DAMAGE,
damageParameters,
"Arrow Volley Trap deals 5 damage divided as you choose among any number of target attacking creatures."));
}
public IncreasingSavagery(GameState state) {
super(state);
// Put five +1/+1 counters on target creature. If Increasing Savagery
// was cast from a graveyard, put ten +1/+1 counters on that creature
// instead.
SetGenerator target =
targetedBy(this.addTarget(CreaturePermanents.instance(), "target creature"));
SetGenerator number =
IfThenElse.instance(
Intersect.instance(
ZoneCastFrom.instance(This.instance()), GraveyardOf.instance(Players.instance())),
numberGenerator(10),
numberGenerator(5));
this.addEffect(
putCounters(
number,
Counter.CounterType.PLUS_ONE_PLUS_ONE,
target,
"Put five +1/+1 counters on target creature. If Increasing Savagery was cast from a graveyard, put ten +1/+1 counters on that creature instead."));
// Flashback (5)(G)(G) (You may cast this card from your graveyard for
// its flashback cost. Then exile it.)
this.addAbility(new Flashback(state, "(5)(G)(G)"));
}
public MotherofRunesAbility0(GameState state) {
super(
state,
"(T): Target creature you control gains protection from the color of your choice until end of turn.");
this.costsTap = true;
SetGenerator target =
targetedBy(
this.addTarget(
Intersect.instance(
CreaturePermanents.instance(), ControlledBy.instance(You.instance())),
"target creature you control"));
EventFactory chooseColor =
playerChoose(
You.instance(),
1,
Identity.fromCollection(Color.allColors()),
PlayerInterface.ChoiceType.COLOR,
PlayerInterface.ChooseReason.CHOOSE_COLOR,
"");
this.addEffect(chooseColor);
SetGenerator color = EffectResult.instance(chooseColor);
this.addEffect(
addProtectionUntilEndOfTurn(
target,
color,
"Target creature gains protection from the color of your choice until end of turn."));
}
public CellarDoorAbility0(GameState state) {
super(
state,
"(3), (T): Target player puts the bottom card of his or her library into his or her graveyard. If it's a creature card, you put a 2/2 black Zombie creature token onto the battlefield.");
this.setManaCost(new ManaPool("(3)"));
this.costsTap = true;
SetGenerator target = targetedBy(this.addTarget(Players.instance(), "target player"));
SetGenerator library = LibraryOf.instance(target);
EventFactory putIntoGraveyard =
new EventFactory(
EventType.MOVE_OBJECTS,
"Target player puts the bottom card of his or her library into his or her graveyard.");
putIntoGraveyard.parameters.put(EventType.Parameter.CAUSE, This.instance());
putIntoGraveyard.parameters.put(EventType.Parameter.TO, GraveyardOf.instance(target));
putIntoGraveyard.parameters.put(EventType.Parameter.OBJECT, BottomCards.instance(1, library));
this.addEffect(putIntoGraveyard);
SetGenerator object = NewObjectOf.instance(EffectResult.instance(putIntoGraveyard));
SetGenerator isCreature = Intersect.instance(object, HasType.instance(Type.CREATURE));
CreateTokensFactory token =
new CreateTokensFactory(
1, 2, 2, "you put a 2/2 black Zombie creature token onto the battlefield.");
token.setColors(Color.BLACK);
token.setSubTypes(SubType.ZOMBIE);
this.addEffect(
ifThen(
isCreature,
token.getEventFactory(),
"If it's a creature card, you put a 2/2 black Zombie creature token onto the battlefield."));
}
public SurgicalExtraction(GameState state) {
super(state);
// Choose target card in a graveyard other than a basic land card.
SetGenerator inGraveyards = InZone.instance(GraveyardOf.instance(Players.instance()));
SetGenerator basicLands =
Intersect.instance(HasSuperType.instance(SuperType.BASIC), HasType.instance(Type.LAND));
SetGenerator legalTargets = RelativeComplement.instance(inGraveyards, basicLands);
Target t =
this.addTarget(legalTargets, "target card in a graveyard other than a basic land card");
// Search its owner's graveyard, hand, and library for all cards with
// the same name as that card and exile them.
SetGenerator itsOwner = OwnerOf.instance(targetedBy(t));
SetGenerator graveyard = GraveyardOf.instance(itsOwner);
SetGenerator hand = HandOf.instance(itsOwner);
SetGenerator library = LibraryOf.instance(itsOwner);
SetGenerator zones = Union.instance(graveyard, hand, library);
EventFactory effect =
new EventFactory(
EventType.SEARCH_FOR_ALL_AND_PUT_INTO,
"Choose target card in a graveyard other than a basic land card. Search its owner's graveyard, hand, and library for all cards with the same name as that card and exile them.");
effect.parameters.put(EventType.Parameter.CAUSE, This.instance());
effect.parameters.put(EventType.Parameter.PLAYER, You.instance());
effect.parameters.put(EventType.Parameter.ZONE, zones);
effect.parameters.put(
EventType.Parameter.TYPE,
Identity.instance(HasName.instance(NameOf.instance(targetedBy(t)))));
effect.parameters.put(EventType.Parameter.TO, ExileZone.instance());
this.addEffect(effect);
// Then that player shuffles his or her library.
this.addEffect(shuffleLibrary(targetedBy(t), "Then that player shuffles his or her library."));
}
public RuthlessRipper(GameState state) {
super(state);
this.setPower(1);
this.setToughness(1);
// Deathtouch
this.addAbility(new org.rnd.jmagic.abilities.keywords.Deathtouch(state));
// Morph\u2014Reveal a black card in your hand. (You may cast this card
// face down as a 2/2 creature for (3). Turn it face up any time for its
// morph cost.)
SetGenerator blueStuff =
Intersect.instance(
HasColor.instance(Color.BLACK), InZone.instance(HandOf.instance(You.instance())));
EventFactory reveal =
new EventFactory(EventType.REVEAL_CHOICE, "Reveal a black card in your hand");
reveal.parameters.put(EventType.Parameter.CAUSE, This.instance());
reveal.parameters.put(EventType.Parameter.OBJECT, blueStuff);
reveal.parameters.put(EventType.Parameter.PLAYER, You.instance());
CostCollection morphCost =
new CostCollection(org.rnd.jmagic.abilities.keywords.Morph.COST_TYPE, reveal);
this.addAbility(
new org.rnd.jmagic.abilities.keywords.Morph(
state, "Morph\u2014Reveal a black card in your hand.", morphCost));
// When Ruthless Ripper is turned face up, target player loses 2 life.
this.addAbility(new RuthlessRipperAbility2(state));
}
public CountrysideCrusherAbility0(GameState state) {
super(
state,
"At the beginning of your upkeep, reveal the top card of your library. If it's a land card, put it into your graveyard and repeat this process.");
this.addPattern(atTheBeginningOfYourUpkeep());
SetGenerator yourLibrary = LibraryOf.instance(You.instance());
SetGenerator toReveal =
TopMost.instance(
yourLibrary,
numberGenerator(1),
RelativeComplement.instance(
InZone.instance(yourLibrary), HasType.instance(Type.LAND)));
EventFactory reveal =
new EventFactory(
EventType.REVEAL,
"Reveal cards from the top of your library until you reveal a nonland card.");
reveal.parameters.put(EventType.Parameter.CAUSE, This.instance());
reveal.parameters.put(EventType.Parameter.OBJECT, toReveal);
this.addEffect(reveal);
SetGenerator landsRevealed = Intersect.instance(toReveal, HasType.instance(Type.LAND));
EventFactory pitch =
new EventFactory(
EventType.PUT_INTO_GRAVEYARD, "Put all revealed nonland cards into your graveyard.");
pitch.parameters.put(EventType.Parameter.CAUSE, This.instance());
pitch.parameters.put(EventType.Parameter.OBJECT, landsRevealed);
this.addEffect(pitch);
}
public PermafrostTrap(GameState state) {
super(state);
// If an opponent had a green creature enter the battlefield under his
// or her control this turn, you may pay (U) rather than pay Permafrost
// Trap's mana cost.
state.ensureTracker(new GreenCreaturesPutOntoTheBattlefieldThisTurnCounter());
SetGenerator opponents = OpponentsOf.instance(You.instance());
SetGenerator maxPerOpponent =
MaximumPerPlayer.instance(
GreenCreaturesPutOntoTheBattlefieldThisTurnCounter.class, opponents);
SetGenerator trapCondition = Intersect.instance(Between.instance(2, null), maxPerOpponent);
this.addAbility(
new org.rnd.jmagic.abilities.Trap(
state,
this.getName(),
trapCondition,
"If an opponent had a green creature enter the battlefield under his or her control this turn",
"(U)"));
Target target = this.addTarget(CreaturePermanents.instance(), "up to two target creatures");
target.setNumber(0, 2);
// Tap up to two target creatures. Those creatures don't untap during
// their controller's next untap step.
EventFactory tap =
new EventFactory(
EventType.TAP_HARD,
"Tap up to two target creatures. Those creatures don't untap during their controller's next untap step.");
tap.parameters.put(EventType.Parameter.CAUSE, This.instance());
tap.parameters.put(EventType.Parameter.OBJECT, targetedBy(target));
this.addEffect(tap);
}
public SnapcasterMageAbility1(GameState state) {
super(
state,
"When Snapcaster Mage enters the battlefield, target instant or sorcery card in your graveyard gains flashback until end of turn. The flashback cost is equal to its mana cost.");
this.addPattern(whenThisEntersTheBattlefield());
SetGenerator target =
targetedBy(
this.addTarget(
Intersect.instance(
HasType.instance(Type.INSTANT, Type.SORCERY),
InZone.instance(GraveyardOf.instance(You.instance()))),
"target instant or sorcery card in your graveyard"));
ContinuousEffect.Part part =
new ContinuousEffect.Part(ContinuousEffectType.GRANT_COSTED_KEYWORD);
part.parameters.put(
ContinuousEffectType.Parameter.ABILITY,
Identity.instance(org.rnd.jmagic.abilities.keywords.Flashback.class));
part.parameters.put(ContinuousEffectType.Parameter.OBJECT, target);
this.addEffect(
createFloatingEffect(
"Target instant or sorcery card in your graveyard gains flashback until end of turn. The flashback cost is equal to its mana cost.",
part));
}
public RitualoftheReturned(GameState state) {
super(state);
// Exile target creature card from your graveyard.
SetGenerator deadThings =
Intersect.instance(
HasType.instance(Type.CREATURE), InZone.instance(GraveyardOf.instance(You.instance())));
SetGenerator target =
targetedBy(
this.addTarget(
deadThings,
"Put a black Zombie creature token onto the battlefield. Its power is equal to that card's power and its toughness is equal to that card's toughness."));
EventFactory exile = exile(target, "Exile target creature card from your graveyard.");
this.addEffect(exile);
// Put a black Zombie creature token onto the battlefield. Its power is
// equal to that card's power and its toughness is equal to that card's
// toughness.
SetGenerator thatCard = NewObjectOf.instance(EffectResult.instance(exile));
SetGenerator power = PowerOf.instance(thatCard);
SetGenerator toughness = ToughnessOf.instance(thatCard);
CreateTokensFactory zombie =
new CreateTokensFactory(
numberGenerator(1),
power,
toughness,
"Put a black Zombie creature token onto the battlefield. Its power is equal to that card's power and its toughness is equal to that card's toughness.");
zombie.setColors(Color.BLACK);
zombie.setSubTypes(SubType.ZOMBIE);
this.addEffect(zombie.getEventFactory());
}
public RuneflareTrap(GameState state) {
super(state);
// If an opponent drew three or more cards this turn, you may pay (R)
// rather than pay Runeflare Trap's mana cost.
state.ensureTracker(new CardsDrawn());
SetGenerator opponents = OpponentsOf.instance(You.instance());
SetGenerator cardsDrawn = MaximumPerPlayer.instance(CardsDrawn.class, opponents);
SetGenerator trapCondition = Intersect.instance(cardsDrawn, Between.instance(3, null));
this.addAbility(
new Trap(
state,
this.getName(),
trapCondition,
"If an opponent drew three or more cards this turn",
"(R)"));
// Runeflare Trap deals damage to target player equal to the number of
// cards in that player's hand.
Target target = this.addTarget(Players.instance(), "target player");
SetGenerator amount = Count.instance(InZone.instance(HandOf.instance(targetedBy(target))));
this.addEffect(
spellDealDamage(
amount,
targetedBy(target),
"Runeflare Trap deals damage to target player equal to the number of cards in that player's hand."));
}
public GrantShroud(GameState state) {
super(state, "Other Faeries you control have shroud.");
SetGenerator faeries =
Intersect.instance(HasSubType.instance(SubType.FAERIE), CREATURES_YOU_CONTROL);
SetGenerator who = RelativeComplement.instance(faeries, This.instance());
this.addEffectPart(addAbilityToObject(who, org.rnd.jmagic.abilities.keywords.Shroud.class));
}
public EveryoneTapsForTwoGreen(GameState state) {
super(state, "Elves you control have \"(T): Add (G)(G) to your mana pool.\"");
SetGenerator elvesYouControl =
Intersect.instance(
HasSubType.instance(SubType.ELF), ControlledBy.instance(You.instance()));
this.addEffectPart(addAbilityToObject(elvesYouControl, TapForTwoGreen.class));
}
public PrizedElephantAbility0(GameState state) {
super(state, "Prized Elephant gets +1/+1 as long as you control a Forest.");
this.addEffectPart(modifyPowerAndToughness(This.instance(), +1, +1));
this.canApply =
Both.instance(
this.canApply,
Intersect.instance(
ControlledBy.instance(You.instance()), HasSubType.instance(SubType.FOREST)));
}
public MasterChief(GameState state) {
super(state, "When Halo Hunter enters the battlefield, destroy target Angel.");
this.addPattern(whenThisEntersTheBattlefield());
Target target =
this.addTarget(
Intersect.instance(HasSubType.instance(SubType.ANGEL), Permanents.instance()),
"target Angel");
this.addEffect(destroy(targetedBy(target), "Destroy target Angel."));
}
public FinishHim(GameState state) {
super(
state,
"At the beginning of your upkeep, if twenty or more creature cards are in your graveyard, you win the game.");
SetGenerator numCreatures =
Count.instance(
Intersect.instance(
HasType.instance(Type.CREATURE),
InZone.instance(
GraveyardOf.instance(ControllerOf.instance(ABILITY_SOURCE_OF_THIS)))));
this.addPattern(atTheBeginningOfYourUpkeep());
this.interveningIf = Intersect.instance(numCreatures, Between.instance(20, null));
this.addEffect(youWinTheGame());
}
public KrakenoftheStraitsAbility0(GameState state) {
super(
state,
"Creatures with power less than the number of Islands you control can't block Kraken of the Straits.");
SetGenerator yourIslands =
Intersect.instance(
ControlledBy.instance(You.instance()), HasSubType.instance(SubType.ISLAND));
SetGenerator weak =
HasPower.instance(Between.instance(numberGenerator(0), Count.instance(yourIslands)));
SetGenerator restriction = Intersect.instance(weak, Blocking.instance(This.instance()));
ContinuousEffect.Part part =
new ContinuousEffect.Part(ContinuousEffectType.BLOCKING_RESTRICTION);
part.parameters.put(
ContinuousEffectType.Parameter.RESTRICTION, Identity.instance(restriction));
this.addEffectPart(part);
}
public FirstStrikeForAll(GameState state) {
super(state, "Creatures you control have first strike.");
SetGenerator creaturesYouControl =
Intersect.instance(
ControlledBy.instance(You.instance()), HasType.instance(Type.CREATURE));
this.addEffectPart(addAbilityToObject(creaturesYouControl, FirstStrike.class));
}
public EntomberExarchAbility0(GameState state) {
super(
state,
"When Entomber Exarch enters the battlefield, choose one \u2014\n\u2022 Return target creature card from your graveyard to your hand.\n\u2022 Target opponent reveals his or her hand, you choose a noncreature card from it, then that player discards that card.");
this.addPattern(whenThisEntersTheBattlefield());
// Return target creature card from your graveyard to your hand
{
SetGenerator yourYard = GraveyardOf.instance(You.instance());
SetGenerator target =
targetedBy(
this.addTarget(
1,
Intersect.instance(HasType.instance(Type.CREATURE), InZone.instance(yourYard)),
"target creature card in your graveyard"));
EventFactory move =
new EventFactory(
EventType.MOVE_OBJECTS,
"Return target creature card from your graveyard to your hand");
move.parameters.put(EventType.Parameter.CAUSE, This.instance());
move.parameters.put(EventType.Parameter.TO, HandOf.instance(You.instance()));
move.parameters.put(EventType.Parameter.OBJECT, target);
this.addEffect(1, move);
}
// target opponent reveals his or her hand, you choose a noncreature
// card from it, then that player discards that card
{
SetGenerator target =
targetedBy(this.addTarget(2, OpponentsOf.instance(You.instance()), "target opponent"));
SetGenerator cards = InZone.instance(HandOf.instance(target));
EventType.ParameterMap revealParameters = new EventType.ParameterMap();
revealParameters.put(EventType.Parameter.CAUSE, This.instance());
revealParameters.put(EventType.Parameter.OBJECT, cards);
this.addEffect(
2,
new EventFactory(
EventType.REVEAL, revealParameters, "Target opponent reveals his or her hand."));
SetGenerator choices = RelativeComplement.instance(cards, HasType.instance(Type.CREATURE));
EventType.ParameterMap parameters = new EventType.ParameterMap();
parameters.put(EventType.Parameter.CAUSE, This.instance());
parameters.put(EventType.Parameter.PLAYER, You.instance());
parameters.put(EventType.Parameter.TARGET, target);
parameters.put(EventType.Parameter.CHOICE, Identity.instance(choices));
this.addEffect(
2,
new EventFactory(
EventType.DISCARD_FORCE,
parameters,
"You choose a noncreature card from it, then that player discards that card."));
}
}
public ThisEntersTheBattlefield(GameState state) {
super(
state,
"When this creature enters the battlefield, if you control both this creature and another creature and both are unpaired, you may pair this creature with another unpaired creature you control for as long as both remain creatures on the battlefield under your control.");
SetGenerator thisCreature = ABILITY_SOURCE_OF_THIS;
this.addPattern(
new SimpleZoneChangePattern(null, Battlefield.instance(), thisCreature, false));
SetGenerator otherCreaturesYouControl =
RelativeComplement.instance(CREATURES_YOU_CONTROL, thisCreature);
SetGenerator youControl = ControlledBy.instance(You.instance());
SetGenerator youControlUnpairedThis =
Intersect.instance(youControl, Unpaired.instance(), thisCreature);
SetGenerator youControlUnpairedOtherCreatures =
Intersect.instance(Unpaired.instance(), otherCreaturesYouControl);
this.interveningIf = Both.instance(youControlUnpairedThis, youControlUnpairedOtherCreatures);
EventFactory choose =
playerChoose(
You.instance(),
1,
youControlUnpairedOtherCreatures,
PlayerInterface.ChoiceType.OBJECTS,
REASON,
"Choose another unpaired creature you control");
SetGenerator thatCreature = EffectResult.instance(choose);
ContinuousEffect.Part part = new ContinuousEffect.Part(ContinuousEffectType.PAIR);
part.parameters.put(
ContinuousEffectType.Parameter.OBJECT, Union.instance(thisCreature, thatCreature));
SetGenerator youControlCreatureThis = Intersect.instance(CREATURES_YOU_CONTROL, thisCreature);
SetGenerator youControlCreatureThat = Intersect.instance(CREATURES_YOU_CONTROL, thatCreature);
SetGenerator expires =
Not.instance(Both.instance(youControlCreatureThis, youControlCreatureThat));
EventFactory floatingEffect =
createFloatingEffect(expires, "and pair this creature with the chosen creature.", part);
this.addEffect(
youMay(
sequence(choose, floatingEffect),
"You may pair this creature with another unpaired creature you control for as long as both remain creatures on the battlefield under your control."));
}
public AngelofGlorysRiseAbility1(GameState state) {
super(
state,
"When Angel of Glory's Rise enters the battlefield, exile all Zombies, then return all Human creature cards from your graveyard to the battlefield.");
this.addPattern(whenThisEntersTheBattlefield());
this.addEffect(
exile(
Intersect.instance(Permanents.instance(), HasSubType.instance(SubType.ZOMBIE)),
"Exile all Zombies."));
this.addEffect(
putOntoBattlefield(
Intersect.instance(
InZone.instance(GraveyardOf.instance(You.instance())),
HasSubType.instance(SubType.HUMAN),
HasType.instance(Type.CREATURE)),
"Return all Human creature cards from your graveyard to the battlefield."));
}
