From 537700ad22eae34149e14df28bd1bb0a40528a6d Mon Sep 17 00:00:00 2001 From: LevelX2 Date: Thu, 15 Jan 2015 18:19:14 +0100 Subject: [PATCH 1/2] * Hellfire Mongrel - Fixed that the condition was also checked during resolution. --- .../mage/sets/zendikar/HellfireMongrel.java | 54 +++++++------------ 1 file changed, 18 insertions(+), 36 deletions(-) diff --git a/Mage.Sets/src/mage/sets/zendikar/HellfireMongrel.java b/Mage.Sets/src/mage/sets/zendikar/HellfireMongrel.java index e6affb47200..a4a5ba090ba 100644 --- a/Mage.Sets/src/mage/sets/zendikar/HellfireMongrel.java +++ b/Mage.Sets/src/mage/sets/zendikar/HellfireMongrel.java @@ -28,13 +28,19 @@ package mage.sets.zendikar; import java.util.UUID; -import mage.constants.CardType; -import mage.constants.Rarity; -import mage.constants.Zone; import mage.MageInt; +import mage.abilities.Ability; import mage.abilities.TriggeredAbilityImpl; +import mage.abilities.common.BeginningOfUpkeepTriggeredAbility; +import mage.abilities.condition.Condition; +import mage.abilities.decorator.ConditionalTriggeredAbility; +import mage.abilities.effects.Effect; import mage.abilities.effects.common.DamageTargetEffect; import mage.cards.CardImpl; +import mage.constants.CardType; +import mage.constants.Rarity; +import mage.constants.TargetController; +import mage.constants.Zone; import mage.game.Game; import mage.game.events.GameEvent; import mage.players.Player; @@ -52,12 +58,15 @@ public class HellfireMongrel extends CardImpl { this.subtype.add("Elemental"); this.subtype.add("Hound"); - this.color.setRed(true); this.power = new MageInt(2); this.toughness = new MageInt(2); // At the beginning of each opponent's upkeep, if that player has two or fewer cards in hand, Hellfire Mongrel deals 2 damage to him or her. - this.addAbility(new HellfireMongrelTriggeredAbility()); + this.addAbility(new ConditionalTriggeredAbility( + new BeginningOfUpkeepTriggeredAbility(Zone.BATTLEFIELD, new DamageTargetEffect(2), TargetController.OPPONENT, false, true), + new CardsInActivePlayersHandCondition(), + "At the beginning of each opponent's upkeep, if that player has two or fewer cards in hand, {this} deals 2 damage to him or her.", + false)); } public HellfireMongrel(final HellfireMongrel card) { @@ -70,38 +79,11 @@ public class HellfireMongrel extends CardImpl { } } -class HellfireMongrelTriggeredAbility extends TriggeredAbilityImpl { - - public HellfireMongrelTriggeredAbility() { - super(Zone.BATTLEFIELD, null); - } - - public HellfireMongrelTriggeredAbility(final HellfireMongrelTriggeredAbility ability) { - super(ability); - } +class CardsInActivePlayersHandCondition implements Condition { @Override - public HellfireMongrelTriggeredAbility copy() { - return new HellfireMongrelTriggeredAbility(this); - } - - @Override - public boolean checkTrigger(GameEvent event, Game game) { - if (event.getType() == GameEvent.EventType.UPKEEP_STEP_PRE && game.getOpponents(controllerId).contains(event.getPlayerId())) { - Player player = game.getPlayer(event.getPlayerId()); - if (player != null && player.getHand().size() < 3) { - this.getEffects().clear(); - DamageTargetEffect effect = new DamageTargetEffect(2); - effect.setTargetPointer(new FixedTarget(player.getId())); - this.addEffect(effect); - return true; - } - } - return false; - } - - @Override - public String getRule() { - return "At the beginning of each opponent's upkeep, if that player has two or fewer cards in hand, {this} deals 2 damage to him or her."; + public boolean apply(Game game, Ability source) { + Player player = game.getPlayer(game.getActivePlayerId()); + return player != null && player.getHand().size() <= 2; } } From caa2012e80914ed991647259c611cf40f4c7558d Mon Sep 17 00:00:00 2001 From: Jeff Date: Thu, 15 Jan 2015 11:31:35 -0600 Subject: [PATCH 2/2] - Fixed Domineering Will. --- .../sets/commander2014/DomineeringWill.java | 167 ++++++++++++++++-- 1 file changed, 156 insertions(+), 11 deletions(-) diff --git a/Mage.Sets/src/mage/sets/commander2014/DomineeringWill.java b/Mage.Sets/src/mage/sets/commander2014/DomineeringWill.java index 147aa03c711..33926bb2480 100644 --- a/Mage.Sets/src/mage/sets/commander2014/DomineeringWill.java +++ b/Mage.Sets/src/mage/sets/commander2014/DomineeringWill.java @@ -28,17 +28,26 @@ package mage.sets.commander2014; import java.util.UUID; +import mage.abilities.Ability; +import mage.abilities.effects.ContinuousEffect; +import mage.abilities.effects.ContinuousEffectImpl; import mage.abilities.effects.Effect; -import mage.abilities.effects.common.UntapTargetEffect; -import mage.abilities.effects.common.combat.BlocksIfAbleTargetEffect; -import mage.abilities.effects.common.continious.GainControlTargetEffect; +import mage.abilities.effects.OneShotEffect; +import mage.abilities.effects.RequirementEffect; import mage.cards.CardImpl; import mage.constants.CardType; import mage.constants.Duration; +import mage.constants.Layer; +import mage.constants.Outcome; import mage.constants.Rarity; +import mage.constants.SubLayer; import mage.filter.common.FilterCreaturePermanent; import mage.filter.predicate.Predicates; import mage.filter.predicate.permanent.AttackingPredicate; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.players.Player; +import mage.target.TargetPlayer; import mage.target.common.TargetCreaturePermanent; /** @@ -60,14 +69,10 @@ public class DomineeringWill extends CardImpl { this.color.setBlue(true); // Target player gains control of up to three target nonattacking creatures until end of turn. Untap those creatures. They block this turn if able. - this.getSpellAbility().addEffect(new GainControlTargetEffect(Duration.EndOfTurn)); - Effect effect = new UntapTargetEffect(); - effect.setText("Untap those creatures"); - this.getSpellAbility().addEffect(effect); - effect = new BlocksIfAbleTargetEffect(Duration.EndOfTurn); - effect.setText("They block this turn if able"); - this.getSpellAbility().addEffect(effect); - this.getSpellAbility().addTarget(new TargetCreaturePermanent(0,3, filter, false)); + this.getSpellAbility().addEffect(new DomineeringWillEffect()); + this.getSpellAbility().addTarget(new TargetPlayer()); + this.getSpellAbility().addTarget(new TargetCreaturePermanent(0, 3, filter, false)); + } public DomineeringWill(final DomineeringWill card) { @@ -79,3 +84,143 @@ public class DomineeringWill extends CardImpl { return new DomineeringWill(this); } } + +class DomineeringWillEffect extends OneShotEffect { + + public DomineeringWillEffect() { + super(Outcome.Benefit); + staticText = "Target player gains control of up to three target nonattacking creatures until end of turn. Untap those creatures. They block this turn if able"; + } + + public DomineeringWillEffect(final DomineeringWillEffect effect) { + super(effect); + } + + @Override + public DomineeringWillEffect copy() { + return new DomineeringWillEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + Player targetPlayer = game.getPlayer(targetPointer.getFirst(game, source)); + if (targetPlayer != null) { + ContinuousEffect effect = new DomineeringWillControlEffect(); + game.addEffect(effect, source); + Effect effect2 = new DomineeringWillUntapTargetEffect(); + effect2.setText("Untap those creatures"); + effect2.apply(game, source); + RequirementEffect effect3 = new DomineeringWillBlocksIfAbleTargetEffect(Duration.EndOfTurn); + effect3.setText("They block this turn if able"); + game.addEffect(effect3, source); + return true; + } + return false; + } +} + +class DomineeringWillControlEffect extends ContinuousEffectImpl { + + public DomineeringWillControlEffect() { + super(Duration.EndOfTurn, Layer.ControlChangingEffects_2, SubLayer.NA, Outcome.GainControl); + } + + public DomineeringWillControlEffect(final DomineeringWillControlEffect effect) { + super(effect); + } + + @Override + public DomineeringWillControlEffect copy() { + return new DomineeringWillControlEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + Player targetPlayer = game.getPlayer(targetPointer.getFirst(game, source)); + if (targetPlayer != null) { + boolean targetStillExists = false; + for (UUID permanentId : source.getTargets().get(1).getTargets()) { + Permanent permanent = game.getPermanent(permanentId); + if (permanent != null) { + targetStillExists = true; + if (targetPlayer != null) { + permanent.changeControllerId(targetPlayer.getId(), game); + permanent.getAbilities().setControllerId(targetPlayer.getId()); + } else { + permanent.changeControllerId(source.getControllerId(), game); + permanent.getAbilities().setControllerId(source.getControllerId()); + } + } + } + if (!targetStillExists) { + // no valid target exists, effect can be discarded + discard(); + } + return true; + } + return false; + } +} + +class DomineeringWillUntapTargetEffect extends OneShotEffect { + + public DomineeringWillUntapTargetEffect() { + super(Outcome.Untap); + } + + public DomineeringWillUntapTargetEffect(final DomineeringWillUntapTargetEffect effect) { + super(effect); + } + + @Override + public DomineeringWillUntapTargetEffect copy() { + return new DomineeringWillUntapTargetEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + for (UUID target : source.getTargets().get(1).getTargets()) { + Permanent permanent = game.getPermanent(target); + if (permanent != null) { + permanent.untap(game); + } + } + return true; + } +} + +class DomineeringWillBlocksIfAbleTargetEffect extends RequirementEffect { + + public DomineeringWillBlocksIfAbleTargetEffect(Duration duration) { + super(duration); + } + + public DomineeringWillBlocksIfAbleTargetEffect(final DomineeringWillBlocksIfAbleTargetEffect effect) { + super(effect); + } + + @Override + public DomineeringWillBlocksIfAbleTargetEffect copy() { + return new DomineeringWillBlocksIfAbleTargetEffect(this); + } + + @Override + public boolean applies(Permanent permanent, Ability source, Game game) { + return source.getTargets().get(1).getTargets().contains(permanent.getId()); + } + + @Override + public boolean mustAttack(Game game) { + return false; + } + + @Override + public boolean mustBlock(Game game) { + return false; + } + + @Override + public boolean mustBlockAny(Game game) { + return true; + } +}