From 3a5e45cc87e9cf5c1273c1602659c0febfbcadfb Mon Sep 17 00:00:00 2001 From: emerald000 Date: Mon, 14 Jul 2014 00:58:54 -0400 Subject: [PATCH] [NEW] Added Gemstone Caverns. --- .../mage/sets/timespiral/GemstoneCaverns.java | 81 ++++++++++++++ .../common/GemstoneCavernsAbility.java | 104 ++++++++++++++++++ Mage/src/mage/counters/CounterType.java | 1 + Mage/src/mage/game/GameImpl.java | 35 ++++-- 4 files changed, 210 insertions(+), 11 deletions(-) create mode 100644 Mage.Sets/src/mage/sets/timespiral/GemstoneCaverns.java create mode 100644 Mage/src/mage/abilities/common/GemstoneCavernsAbility.java diff --git a/Mage.Sets/src/mage/sets/timespiral/GemstoneCaverns.java b/Mage.Sets/src/mage/sets/timespiral/GemstoneCaverns.java new file mode 100644 index 00000000000..2e17dc04e97 --- /dev/null +++ b/Mage.Sets/src/mage/sets/timespiral/GemstoneCaverns.java @@ -0,0 +1,81 @@ +/* + * 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.timespiral; + +import java.util.UUID; +import mage.Mana; +import mage.abilities.Ability; +import mage.abilities.common.GemstoneCavernsAbility; +import mage.abilities.condition.common.SourceHasCounterCondition; +import mage.abilities.costs.common.TapSourceCost; +import mage.abilities.decorator.ConditionalManaEffect; +import mage.abilities.effects.common.AddManaOfAnyColorEffect; +import mage.abilities.effects.common.BasicManaEffect; +import mage.abilities.mana.SimpleManaAbility; +import mage.cards.CardImpl; +import mage.choices.ChoiceColor; +import mage.constants.CardType; +import mage.constants.Rarity; +import mage.constants.Zone; +import mage.counters.CounterType; + +/** + * + * @author emerald000 + */ +public class GemstoneCaverns extends CardImpl { + + public GemstoneCaverns(UUID ownerId) { + super(ownerId, 274, "Gemstone Caverns", Rarity.RARE, new CardType[]{CardType.LAND}, ""); + this.expansionSetCode = "TSP"; + this.supertype.add("Legendary"); + + // If Gemstone Caverns is in your opening hand and you're not playing first, you may begin the game with Gemstone Caverns on the battlefield with a luck counter on it. If you do, exile a card from your hand. + this.addAbility(new GemstoneCavernsAbility()); + + // {tap}: Add {1} to your mana pool. If Gemstone Caverns has a luck counter on it, instead add one mana of any color to your mana pool. + Ability ability = new SimpleManaAbility(Zone.BATTLEFIELD, + new ConditionalManaEffect( + new AddManaOfAnyColorEffect(), + new BasicManaEffect(Mana.ColorlessMana), + new SourceHasCounterCondition(CounterType.LUCK), + "Add {1} to your mana pool. If Gemstone Caverns has a luck counter on it, instead add one mana of any color to your mana pool."), + new TapSourceCost()); + ability.addChoice(new ChoiceColor()); + this.addAbility(ability); + } + + public GemstoneCaverns(final GemstoneCaverns card) { + super(card); + } + + @Override + public GemstoneCaverns copy() { + return new GemstoneCaverns(this); + } +} diff --git a/Mage/src/mage/abilities/common/GemstoneCavernsAbility.java b/Mage/src/mage/abilities/common/GemstoneCavernsAbility.java new file mode 100644 index 00000000000..ce74a9decc7 --- /dev/null +++ b/Mage/src/mage/abilities/common/GemstoneCavernsAbility.java @@ -0,0 +1,104 @@ +/* + * 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.abilities.common; + +/** + * + * @author emerald000 + */ +import mage.abilities.Ability; +import mage.abilities.StaticAbility; +import mage.abilities.costs.Cost; +import mage.abilities.costs.common.ExileFromHandCost; +import mage.abilities.effects.OneShotEffect; +import mage.cards.Card; +import mage.constants.Outcome; +import mage.constants.Zone; +import mage.counters.CounterType; +import mage.game.Game; +import mage.game.permanent.Permanent; +import mage.players.Player; +import mage.target.common.TargetCardInHand; + +public class GemstoneCavernsAbility extends StaticAbility { + public GemstoneCavernsAbility() { + super(Zone.HAND, new GemstoneCavernsEffect()); + } + + public GemstoneCavernsAbility(final GemstoneCavernsAbility ability) { + super(ability); + } + + @Override + public GemstoneCavernsAbility copy() { + return new GemstoneCavernsAbility(this); + } + + @Override + public String getRule() { + return "If {this} is in your opening hand and you're not playing first, you may begin the game with {this} on the battlefield with a luck counter on it. If you do, exile a card from your hand."; + } +} + +class GemstoneCavernsEffect extends OneShotEffect { + + GemstoneCavernsEffect() { + super(Outcome.PutCardInPlay); + this.staticText = "you may begin the game with {this} on the battlefield with a luck counter on it. If you do, exile a card from your hand."; + } + + GemstoneCavernsEffect(final GemstoneCavernsEffect effect) { + super(effect); + } + + @Override + public GemstoneCavernsEffect copy() { + return new GemstoneCavernsEffect(this); + } + + @Override + public boolean apply(Game game, Ability source) { + Player player = game.getPlayer(source.getControllerId()); + if (player != null) { + Card card = game.getCard(source.getSourceId()); + if (card != null) { + if (card.putOntoBattlefield(game, Zone.HAND, source.getSourceId(), source.getControllerId())) { + Permanent permanent = game.getPermanent(card.getId()); + if (permanent != null) { + permanent.addCounters(CounterType.LUCK.createInstance(), game); + Cost cost = new ExileFromHandCost(new TargetCardInHand()); + if (cost.canPay(source.getSourceId(), source.getControllerId(), game)) { + cost.pay(source, game, source.getSourceId(), source.getControllerId(), true); + } + } + } + } + } + return false; + } +} \ No newline at end of file diff --git a/Mage/src/mage/counters/CounterType.java b/Mage/src/mage/counters/CounterType.java index 8ba14e9dfc7..9ba59ff33dc 100644 --- a/Mage/src/mage/counters/CounterType.java +++ b/Mage/src/mage/counters/CounterType.java @@ -59,6 +59,7 @@ public enum CounterType { KI("Ki"), LEVEL("Level"), LORE("Lore"), + LUCK("Luck"), LOYALTY("Loyalty"), M1M1(new BoostCounter(-1, -1).name), MINING("Mining"), diff --git a/Mage/src/mage/game/GameImpl.java b/Mage/src/mage/game/GameImpl.java index db09699d250..6167ce72c75 100644 --- a/Mage/src/mage/game/GameImpl.java +++ b/Mage/src/mage/game/GameImpl.java @@ -51,6 +51,7 @@ import mage.abilities.ActivatedAbility; import mage.abilities.DelayedTriggeredAbility; import mage.abilities.TriggeredAbility; import mage.abilities.common.ChancellorAbility; +import mage.abilities.common.GemstoneCavernsAbility; import mage.abilities.effects.ContinuousEffect; import mage.abilities.effects.ContinuousEffects; import mage.abilities.effects.Effect; @@ -813,18 +814,30 @@ public abstract class GameImpl implements Game, Serializable { for (UUID playerId: state.getPlayerList(startingPlayerId)) { Player player = getPlayer(playerId); for (Card card: player.getHand().getCards(this)) { - if (card.getAbilities().containsKey(LeylineAbility.getInstance().getId())) { - if (player.chooseUse(Outcome.PutCardInPlay, "Do you wish to put " + card.getName() + " on the battlefield?", this)) { - card.putOntoBattlefield(this, Zone.HAND, null, player.getId()); + if (player.getHand().contains(card.getId())) { + if (card.getAbilities().containsKey(LeylineAbility.getInstance().getId())) { + if (player.chooseUse(Outcome.PutCardInPlay, "Do you wish to put " + card.getName() + " on the battlefield?", this)) { + card.putOntoBattlefield(this, Zone.HAND, null, player.getId()); + } } - } - for (Ability ability: card.getAbilities()) { - if (ability instanceof ChancellorAbility) { - if (player.chooseUse(Outcome.PutCardInPlay, "Do you wish to reveal " + card.getName() + "?", this)) { - Cards cards = new CardsImpl(); - cards.add(card); - player.revealCards("Revealed", cards, this); - ability.resolve(this); + for (Ability ability: card.getAbilities()) { + if (ability instanceof ChancellorAbility) { + if (player.chooseUse(Outcome.PutCardInPlay, "Do you wish to reveal " + card.getName() + "?", this)) { + Cards cards = new CardsImpl(); + cards.add(card); + player.revealCards("Revealed", cards, this); + ability.resolve(this); + } + } + if (ability instanceof GemstoneCavernsAbility) { + if (!playerId.equals(startingPlayerId)) { + if (player.chooseUse(Outcome.PutCardInPlay, "Do you wish to put " + card.getName() + " into play?", this)) { + Cards cards = new CardsImpl(); + cards.add(card); + player.revealCards("Revealed", cards, this); + ability.resolve(this); + } + } } } }