NPH - Cathedral Membrane, Omen Machine, Unwinding Clock

Mage.Sets/src/mage/sets/newphyrexia/CathedralMembrane.java

@@ -0,0 +1,181 @@
+/*
+ *  Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without modification, are
+ *  permitted provided that the following conditions are met:
+ *
+ *     1. Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *     2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ *  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ *  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ *  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  The views and conclusions contained in the software and documentation are those of the
+ *  authors and should not be interpreted as representing official policies, either expressed
+ *  or implied, of BetaSteward_at_googlemail.com.
+ */
+package mage.sets.newphyrexia;
+
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.UUID;
+import mage.Constants;
+import mage.Constants.CardType;
+import mage.Constants.Rarity;
+import mage.Constants.TurnPhase;
+import mage.Constants.Zone;
+import mage.MageInt;
+import mage.abilities.Ability;
+import mage.abilities.common.ZoneChangeTriggeredAbility;
+import mage.abilities.effects.OneShotEffect;
+import mage.abilities.keyword.DefenderAbility;
+import mage.cards.CardImpl;
+import mage.game.Game;
+import mage.game.events.GameEvent;
+import mage.game.permanent.Permanent;
+import mage.watchers.WatcherImpl;
+
+/**
+ *
+ * @author BetaSteward
+ */
+public class CathedralMembrane extends CardImpl<CathedralMembrane> {
+
+    public CathedralMembrane(UUID ownerId) {
+        super(ownerId, 5, "Cathedral Membrane", Rarity.UNCOMMON, new CardType[]{CardType.ARTIFACT, CardType.CREATURE}, "{1}{WP}");
+        this.expansionSetCode = "NPH";
+        this.subtype.add("Wall");
+
+        this.color.setWhite(true);
+        this.power = new MageInt(0);
+        this.toughness = new MageInt(3);
+
+        // <i>({WP} can be paid with either {W} or 2 life.)</i>
+        this.addAbility(DefenderAbility.getInstance());
+        
+        // When Cathedral Membrane dies during combat, it deals 6 damage to each creature it blocked this combat.
+        this.addWatcher(new CathedralMembraneWatcher());
+        this.addAbility(new CathedralMembraneAbility());
+        
+    }
+
+    public CathedralMembrane(final CathedralMembrane card) {
+        super(card);
+    }
+
+    @Override
+    public CathedralMembrane copy() {
+        return new CathedralMembrane(this);
+    }
+}
+
+class CathedralMembraneAbility extends ZoneChangeTriggeredAbility<CathedralMembraneAbility> {
+
+	public CathedralMembraneAbility() {
+		super(Zone.BATTLEFIELD, Zone.GRAVEYARD, new CathedralMembraneEffect(), "When {this} dies during combat, ", false);
+	}
+
+	public CathedralMembraneAbility(CathedralMembraneAbility ability) {
+		super(ability);
+	}
+
+	@Override
+	public CathedralMembraneAbility copy() {
+		return new CathedralMembraneAbility(this);
+	}
+
+    @Override
+	public boolean checkTrigger(GameEvent event, Game game) {
+        if (super.checkTrigger(event, game)) {
+            if (game.getPhase().getType() == TurnPhase.COMBAT) {
+                return true;            
+            }
+        }
+        return false;
+    }
+
+}
+
+class CathedralMembraneEffect extends OneShotEffect<CathedralMembraneEffect> {
+
+	public CathedralMembraneEffect() {
+		super(Constants.Outcome.Damage);
+		staticText = "it deals 6 damage to each creature it blocked this combat";
+	}
+
+	public CathedralMembraneEffect(final CathedralMembraneEffect effect) {
+		super(effect);
+	}
+
+	@Override
+	public CathedralMembraneEffect copy() {
+		return new CathedralMembraneEffect(this);
+	}
+
+	@Override
+	public boolean apply(Game game, Ability source) {
+		CathedralMembraneWatcher watcher = (CathedralMembraneWatcher) game.getState().getWatchers().get(source.getControllerId(), "CathedralMembraneWatcher");
+		if (watcher != null && watcher.blockedCreatures.containsKey(source.getSourceId())) {
+			Set<UUID> creatures = watcher.blockedCreatures.get(source.getSourceId());
+			for (UUID uuid : creatures) {
+				Permanent permanent = game.getPermanent(uuid);
+                if (permanent != null) {
+                    permanent.damage(6, source.getSourceId(), game, true, false);
+                }
+			}
+		}
+		return true;
+	}
+}
+
+class CathedralMembraneWatcher extends WatcherImpl<CathedralMembraneWatcher> {
+
+	public Map<UUID, Set<UUID>> blockedCreatures = new HashMap<UUID, Set<UUID>>();
+
+	public CathedralMembraneWatcher() {
+		super("CathedralMembraneWatcher");
+	}
+
+	public CathedralMembraneWatcher(final CathedralMembraneWatcher watcher) {
+		super(watcher);
+	}
+
+	@Override
+	public CathedralMembraneWatcher copy() {
+		return new CathedralMembraneWatcher(this);
+	}
+
+	@Override
+	public void watch(GameEvent event, Game game) {
+        if (event.getType() == GameEvent.EventType.BLOCKER_DECLARED && event.getSourceId().equals(sourceId)) {
+            Set<UUID> creatures = blockedCreatures.get(sourceId);
+            if (creatures != null) {
+                creatures.add(event.getTargetId());
+            } else {
+                creatures = new HashSet<UUID>();
+                creatures.add(event.getTargetId());
+                blockedCreatures.put(sourceId, creatures);
+            }
+        }
+	}
+
+	@Override
+	public void reset() {
+		super.reset();
+		blockedCreatures.clear();
+	}
+
+}

Mage.Sets/src/mage/sets/newphyrexia/OmenMachine.java

@@ -0,0 +1,178 @@
+/*
+ *  Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without modification, are
+ *  permitted provided that the following conditions are met:
+ *
+ *     1. Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *     2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ *  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ *  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ *  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  The views and conclusions contained in the software and documentation are those of the
+ *  authors and should not be interpreted as representing official policies, either expressed
+ *  or implied, of BetaSteward_at_googlemail.com.
+ */
+package mage.sets.newphyrexia;
+
+import java.util.UUID;
+import mage.Constants.CardType;
+import mage.Constants.Duration;
+import mage.Constants.Outcome;
+import mage.Constants.Rarity;
+import mage.Constants.Zone;
+import mage.abilities.Ability;
+import mage.abilities.TriggeredAbilityImpl;
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.effects.OneShotEffect;
+import mage.abilities.effects.ReplacementEffectImpl;
+import mage.cards.Card;
+import mage.cards.CardImpl;
+import mage.game.Game;
+import mage.game.events.GameEvent;
+import mage.game.events.GameEvent.EventType;
+import mage.players.Player;
+import mage.target.targetpointer.FixedTarget;
+
+/**
+ *
+ * @author BetaSteward
+ */
+public class OmenMachine extends CardImpl<OmenMachine> {
+
+    public OmenMachine(UUID ownerId) {
+        super(ownerId, 148, "Omen Machine", Rarity.RARE, new CardType[]{CardType.ARTIFACT}, "{6}");
+        this.expansionSetCode = "NPH";
+
+        // Players can't draw cards.
+        this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new OmenMachineEffect()));
+        
+        // At the beginning of each player's draw step, that player exiles the top card of his or her library. If it's a land card, the player puts it onto the battlefield. Otherwise, the player casts it without paying its mana cost if able.
+        this.addAbility(new OmenMachineAbility());
+    }
+
+    public OmenMachine(final OmenMachine card) {
+        super(card);
+    }
+
+    @Override
+    public OmenMachine copy() {
+        return new OmenMachine(this);
+    }
+}
+
+class OmenMachineEffect extends ReplacementEffectImpl<OmenMachineEffect> {
+
+    public OmenMachineEffect() {
+        super(Duration.WhileOnBattlefield, Outcome.Neutral);
+        staticText = "Players can't draw cards";
+    }
+    
+    public OmenMachineEffect(final OmenMachineEffect effect) {
+        super(effect);
+    }
+    
+    @Override
+    public boolean apply(Game game, Ability source) {
+        return true;
+    }
+
+    @Override
+    public OmenMachineEffect copy() {
+        return new OmenMachineEffect(this);
+    }
+
+    @Override
+    public boolean replaceEvent(GameEvent event, Ability source, Game game) {
+        return true;
+    }
+
+    @Override
+    public boolean applies(GameEvent event, Ability source, Game game) {
+        if (event.getType() == EventType.DRAW_CARD) {
+            return true;
+        }
+        return false;
+    }
+    
+}
+
+class OmenMachineAbility extends TriggeredAbilityImpl<OmenMachineAbility> {
+
+	public OmenMachineAbility() {
+		super(Zone.BATTLEFIELD, new OmenMachineEffect2());
+	}
+
+	public OmenMachineAbility(final OmenMachineAbility ability) {
+		super(ability);
+	}
+
+	@Override
+	public OmenMachineAbility copy() {
+		return new OmenMachineAbility(this);
+	}
+
+	@Override
+	public boolean checkTrigger(GameEvent event, Game game) {
+		if (event.getType() == EventType.DRAW_STEP_PRE) {
+            this.getEffects().get(0).setTargetPointer(new FixedTarget(event.getPlayerId()));
+			return true;
+		}
+		return false;
+	}
+
+	@Override
+	public String getRule() {
+		return "At the beginning of each player's draw step, that player exiles the top card of his or her library. If it's a land card, the player puts it onto the battlefield. Otherwise, the player casts it without paying its mana cost if able.";
+	}
+
+}
+
+class OmenMachineEffect2 extends OneShotEffect<OmenMachineEffect2> {
+
+    public OmenMachineEffect2() {
+        super(Outcome.PlayForFree);
+    }
+    
+    public OmenMachineEffect2(final OmenMachineEffect2 effect) {
+        super(effect);
+    }
+    
+    @Override
+    public boolean apply(Game game, Ability source) {
+        Player player = game.getPlayer(targetPointer.getFirst(source));
+        if (player != null) {
+            Card card = player.getLibrary().removeFromTop(game);
+            if (card != null) {
+                card.moveToExile(source.getSourceId(), "Omen Machine Exile", source.getId(), game);
+                if (card.getCardType().contains(CardType.LAND)) {
+                    card.putOntoBattlefield(game, Zone.EXILED, source.getId(), player.getId());
+                    game.getExile().removeCard(card, game);
+                }
+                else {
+                    player.cast(card.getSpellAbility(), game, true);
+                }
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public OmenMachineEffect2 copy() {
+        return new OmenMachineEffect2(this);
+    }
+    
+}

Mage.Sets/src/mage/sets/newphyrexia/UnwindingClock.java

@@ -0,0 +1,123 @@
+/*
+ *  Copyright 2010 BetaSteward_at_googlemail.com. All rights reserved.
+ *
+ *  Redistribution and use in source and binary forms, with or without modification, are
+ *  permitted provided that the following conditions are met:
+ *
+ *     1. Redistributions of source code must retain the above copyright notice, this list of
+ *        conditions and the following disclaimer.
+ *
+ *     2. Redistributions in binary form must reproduce the above copyright notice, this list
+ *        of conditions and the following disclaimer in the documentation and/or other materials
+ *        provided with the distribution.
+ *
+ *  THIS SOFTWARE IS PROVIDED BY BetaSteward_at_googlemail.com ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ *  WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND
+ *  FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL BetaSteward_at_googlemail.com OR
+ *  CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+ *  CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+ *  SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON
+ *  ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+ *  NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ *  ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ *
+ *  The views and conclusions contained in the software and documentation are those of the
+ *  authors and should not be interpreted as representing official policies, either expressed
+ *  or implied, of BetaSteward_at_googlemail.com.
+ */
+package mage.sets.newphyrexia;
+
+import java.util.UUID;
+import mage.Constants.CardType;
+import mage.Constants.Duration;
+import mage.Constants.Layer;
+import mage.Constants.Outcome;
+import mage.Constants.PhaseStep;
+import mage.Constants.Rarity;
+import mage.Constants.SubLayer;
+import mage.Constants.Zone;
+import mage.abilities.Ability;
+import mage.abilities.common.SimpleStaticAbility;
+import mage.abilities.effects.ContinuousEffectImpl;
+import mage.abilities.effects.RestrictionEffect;
+import mage.cards.CardImpl;
+import mage.filter.common.FilterArtifactPermanent;
+import mage.game.Game;
+import mage.game.permanent.Permanent;
+
+/**
+ *
+ * @author BetaSteward
+ */
+public class UnwindingClock extends CardImpl<UnwindingClock> {
+
+    public UnwindingClock(UUID ownerId) {
+        super(ownerId, 164, "Unwinding Clock", Rarity.RARE, new CardType[]{CardType.ARTIFACT}, "{4}");
+        this.expansionSetCode = "NPH";
+
+        // Untap all artifacts you control during each other player's untap step.
+        this.addAbility(new SimpleStaticAbility(Zone.BATTLEFIELD, new UnwindingClockEffect()));        
+    }
+
+    public UnwindingClock(final UnwindingClock card) {
+        super(card);
+    }
+
+    @Override
+    public UnwindingClock copy() {
+        return new UnwindingClock(this);
+    }
+}
+
+class UnwindingClockEffect extends ContinuousEffectImpl<UnwindingClockEffect> {
+
+    private static FilterArtifactPermanent filter = new FilterArtifactPermanent();
+    
+    public UnwindingClockEffect() {
+        super(Duration.WhileOnBattlefield, Outcome.Benefit);
+        staticText = "Untap all artifacts you control during each other player's untap step";
+    }
+
+    public UnwindingClockEffect(final UnwindingClockEffect effect) {
+        super(effect);
+    }
+
+    @Override
+    public UnwindingClockEffect copy() {
+        return new UnwindingClockEffect(this);
+    }
+
+    @Override
+    public boolean apply(Layer layer, SubLayer sublayer, Ability source, Game game) {
+        Boolean applied = (Boolean) game.getState().getValue(source.getSourceId() + "applied");
+        if (applied == null)
+            applied = Boolean.FALSE;
+        if (!applied && layer.equals(Layer.RulesEffects)) {
+            if (!game.getActivePlayerId().equals(source.getControllerId()) && game.getStep().getType() == PhaseStep.UNTAP) {
+                game.getState().setValue(source.getSourceId() + "applied", true);
+                for (Permanent artifact: game.getBattlefield().getAllActivePermanents(filter, source.getControllerId())) {
+                    boolean untap = true;
+                    for (RestrictionEffect effect : game.getContinuousEffects().getApplicableRestrictionEffects(artifact, game)) {
+                        untap &= effect.canBeUntapped(artifact, game);
+                    }
+                    if (untap) artifact.untap(game);
+                }
+            }
+        } else if (applied && layer.equals(Layer.RulesEffects)) {
+            if (game.getStep().getType() == PhaseStep.END_TURN) {
+                game.getState().setValue(source.getSourceId() + "applied", false);
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public boolean apply(Game game, Ability source) {
+        return false;
+    }
+
+    @Override
+    public boolean hasLayer(Layer layer) {
+        return layer == Layer.RulesEffects;
+    }
+}

Mage/src/mage/cards/CardImpl.java

@@ -293,6 +293,9 @@ public abstract class CardImpl<T extends CardImpl<T>> extends MageObjectImpl<T>
                     case LIBRARY:
                         game.getPlayer(ownerId).removeFromLibrary(this, game);
                         break;
+                    case EXILED:
+                        game.getExile().removeCard(this, game);
+                        break;
                     default:
                         //logger.warning("moveToZone, not fully implemented: from="+event.getFromZone() + ", to="+event.getToZone());
                 }

Mage/src/mage/game/GameImpl.java

@@ -556,13 +556,13 @@ public abstract class GameImpl<T extends GameImpl<T>> implements Game, Serializa
                         if (isGameOver()) return;
                         if (allPassed()) {
                             if (!state.getStack().isEmpty()) {
-                                   //20091005 - 115.4
+                               //20091005 - 115.4
-                                    state.getStack().resolve(this);
+                                resolve();
-                                    applyEffects();
+                                applyEffects();
-                                    state.getPlayers().resetPassed();
+                                state.getPlayers().resetPassed();
-                                    fireUpdatePlayersEvent();
+                                fireUpdatePlayersEvent();
-                                    state.getRevealed().reset();
+                                state.getRevealed().reset();
-                                    break;
+                                break;
                             } else {
                                 removeBookmark(bookmark);
                                 return;
@@ -576,8 +576,6 @@ public abstract class GameImpl<T extends GameImpl<T>> implements Game, Serializa
                         bookmark = 0;
                         continue;
                     }
-//                    removeBookmark(bookmark);
-//                    bookmark = 0;
 					state.getPlayerList().getNext();
 				}
                 removeBookmark(bookmark);
@@ -591,7 +589,19 @@ public abstract class GameImpl<T extends GameImpl<T>> implements Game, Serializa
 		}
 	}
 
-	protected boolean allPassed() {
+	//resolve top StackObject
+	protected void resolve() {
+		StackObject top = null;
+		try {
+			top = state.getStack().peek();
+			top.resolve(this);
+		} finally {
+			if (top != null)
+				state.getStack().remove(top);
+		}
+	}
+
+    protected boolean allPassed() {
 		for (Player player: state.getPlayers().values()) {
 			if (!player.isPassed() && !player.hasLost() && !player.hasLeft())
 				return false;

Mage/src/mage/game/events/GameEvent.java

@@ -77,7 +77,7 @@ public class GameEvent {
 
 		//player events
 		ZONE_CHANGE,
-		DREW_CARD,
+		DRAW_CARD, DREW_CARD,
 		DISCARDED_CARD,
 		CYCLE_CARD, CYCLED_CARD,
 		DAMAGE_PLAYER, DAMAGED_PLAYER,

Mage/src/mage/game/stack/SpellStack.java

@@ -68,6 +68,15 @@ public class SpellStack extends Stack<StackObject> {
 		}
 	}
 
+    public void remove(StackObject object) {
+        for (StackObject spell: this) {
+            if (spell.getId().equals(object.getId())) {
+                super.remove(spell);
+                return;
+            }
+        }
+    }
+    
 	public void checkTriggers(GameEvent event, Game game) {
 		for (StackObject stackObject: this) {
 			stackObject.checkTriggers(event, game);

Mage/src/mage/game/turn/UntapStep.java

@@ -59,6 +59,7 @@ public class UntapStep extends Step<UntapStep> {
 		activePlayer.phasing(game);
 		//20091005 - 502.2/703.4b
 		activePlayer.untap(game);
+        game.applyEffects();
 	}
 
 	@Override

Mage/src/mage/players/PlayerImpl.java

@@ -331,12 +331,14 @@ public abstract class PlayerImpl<T extends PlayerImpl<T>> implements Player, Ser
 	}
 
 	protected boolean drawCard(Game game) {
-		Card card = getLibrary().removeFromTop(game);
+		if (!game.replaceEvent(GameEvent.getEvent(GameEvent.EventType.DRAW_CARD, playerId, playerId))) {
-		if (card != null) {
+            Card card = getLibrary().removeFromTop(game);
-			card.moveToZone(Zone.HAND, null, game, false);
+            if (card != null) {
-			game.fireEvent(GameEvent.getEvent(GameEvent.EventType.DREW_CARD, card.getId(), playerId));
+                card.moveToZone(Zone.HAND, null, game, false);
-			return true;
+                game.fireEvent(GameEvent.getEvent(GameEvent.EventType.DREW_CARD, card.getId(), playerId));
-		}
+                return true;
+            }
+        }
 		return false;
 	}