From c7554a22698a2b35244d34f3c753d934e045251c Mon Sep 17 00:00:00 2001 From: "marcin.sciesinski" Date: Mon, 15 Jul 2019 23:50:57 -0700 Subject: [PATCH] Finished Dwarven cards --- .../lotro/cards/set40/dwarven/Card40_021.java | 48 +++++++++++ .../lotro/cards/set40/dwarven/Card40_022.java | 52 ++++++++++++ .../lotro/cards/set40/dwarven/Card40_023.java | 60 ++++++++++++++ .../lotro/cards/set40/dwarven/Card40_024.java | 51 ++++++++++++ .../lotro/cards/set40/dwarven/Card40_025.java | 67 ++++++++++++++++ .../lotro/cards/set40/dwarven/Card40_026.java | 71 +++++++++++++++++ .../lotro/cards/set40/dwarven/Card40_027.java | 46 +++++++++++ .../lotro/cards/set40/dwarven/Card40_028.java | 79 +++++++++++++++++++ .../lotro/cards/set40/dwarven/Card40_029.java | 36 +++++++++ .../lotro/cards/set40/dwarven/Card40_030.java | 55 +++++++++++++ .../lotro/cards/set40/dwarven/Card40_031.java | 43 ++++++++++ .../lotro/cards/set40/dwarven/Card40_032.java | 47 +++++++++++ 12 files changed, 655 insertions(+) create mode 100644 gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_021.java create mode 100644 gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_022.java create mode 100644 gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_023.java create mode 100644 gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_024.java create mode 100644 gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_025.java create mode 100644 gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_026.java create mode 100644 gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_027.java create mode 100644 gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_028.java create mode 100644 gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_029.java create mode 100644 gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_030.java create mode 100644 gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_031.java create mode 100644 gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_032.java diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_021.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_021.java new file mode 100644 index 000000000..6e6cdd05d --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_021.java @@ -0,0 +1,48 @@ +package com.gempukku.lotro.cards.set40.dwarven; + +import com.gempukku.lotro.cards.AbstractEvent; +import com.gempukku.lotro.cards.actions.PlayEventAction; +import com.gempukku.lotro.cards.effects.AddUntilEndOfPhaseModifierEffect; +import com.gempukku.lotro.common.*; +import com.gempukku.lotro.filters.Filters; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.effects.ChooseActiveCardEffect; +import com.gempukku.lotro.logic.modifiers.KeywordModifier; +import com.gempukku.lotro.logic.modifiers.StrengthModifier; + +/** + * Title: Killing Blow + * Set: Second Edition + * Side: Free + * Culture: Dwarven + * Twilight Cost: 2 + * Type: Event - Skirmish + * Card Number: 1C21 + * Game Text: Make a Dwarf strength +2 (and damage +1 if you can spot a card stacked on a [DWARVEN] condition). + */ +public class Card40_021 extends AbstractEvent{ + public Card40_021() { + super(Side.FREE_PEOPLE, 2, Culture.DWARVEN, "Killing Blow", Phase.SKIRMISH); + } + + @Override + public PlayEventAction getPlayCardAction(String playerId, LotroGame game, final PhysicalCard self, int twilightModifier, boolean ignoreRoamingPenalty) { + final PlayEventAction action = new PlayEventAction(self); + action.appendEffect( + new ChooseActiveCardEffect(self, playerId, "Choose a Dwarf", Race.DWARF) { + @Override + protected void cardSelected(LotroGame game, PhysicalCard card) { + action.appendEffect( + new AddUntilEndOfPhaseModifierEffect( + new StrengthModifier(self, card, 2))); + if (Filters.canSpot(game.getGameState(), game.getModifiersQuerying(), Culture.DWARVEN, CardType.CONDITION, Filters.hasStacked(Filters.any))) { + action.appendEffect( + new AddUntilEndOfPhaseModifierEffect( + new KeywordModifier(self, card, Keyword.DAMAGE, 1))); + } + } + }); + return action; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_022.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_022.java new file mode 100644 index 000000000..ff8002c18 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_022.java @@ -0,0 +1,52 @@ +package com.gempukku.lotro.cards.set40.dwarven; + +import com.gempukku.lotro.cards.AbstractEvent; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.actions.PlayEventAction; +import com.gempukku.lotro.cards.effects.AddUntilEndOfPhaseModifierEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndExertCharactersEffect; +import com.gempukku.lotro.common.*; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.modifiers.KeywordModifier; +import com.gempukku.lotro.logic.modifiers.StrengthModifier; + +/** + * Title: Lethal Strike + * Set: Second Edition + * Side: Free + * Culture: Dwarven + * Twilight Cost: 1 + * Type: Event - Skirmish + * Card Number: 1C22 + * Game Text: Exert a Dwarf to make him strength +3 and damage +1. + */ +public class Card40_022 extends AbstractEvent{ + public Card40_022() { + super(Side.FREE_PEOPLE, 1, Culture.DWARVEN, "Lethal Strike", Phase.SKIRMISH); + } + + @Override + public boolean checkPlayRequirements(String playerId, LotroGame game, PhysicalCard self, int withTwilightRemoved, int twilightModifier, boolean ignoreRoamingPenalty, boolean ignoreCheckingDeadPile) { + return super.checkPlayRequirements(playerId, game, self, withTwilightRemoved, twilightModifier, ignoreRoamingPenalty, ignoreCheckingDeadPile) + && PlayConditions.canExert(self, game, Race.DWARF); + } + + @Override + public PlayEventAction getPlayCardAction(String playerId, LotroGame game, final PhysicalCard self, int twilightModifier, boolean ignoreRoamingPenalty) { + final PlayEventAction action = new PlayEventAction(self); + action.appendCost( + new ChooseAndExertCharactersEffect(action, playerId, 1, 1, Race.DWARF) { + @Override + protected void forEachCardExertedCallback(PhysicalCard character) { + action.appendEffect( + new AddUntilEndOfPhaseModifierEffect( + new StrengthModifier(self, character, 3))); + action.appendEffect( + new AddUntilEndOfPhaseModifierEffect( + new KeywordModifier(self, character, Keyword.DAMAGE, 1))); + } + }); + return action; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_023.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_023.java new file mode 100644 index 000000000..ea38511dd --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_023.java @@ -0,0 +1,60 @@ +package com.gempukku.lotro.cards.set40.dwarven; + +import com.gempukku.lotro.cards.AbstractPermanent; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.TriggerConditions; +import com.gempukku.lotro.cards.effects.StackTopCardsFromDeckEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndAddUntilEOPStrengthBonusEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndDiscardStackedCardsEffect; +import com.gempukku.lotro.common.*; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.actions.ActivateCardAction; +import com.gempukku.lotro.logic.actions.RequiredTriggerAction; +import com.gempukku.lotro.logic.timing.Action; +import com.gempukku.lotro.logic.timing.EffectResult; + +import java.util.Collections; +import java.util.List; + +/** + * Title: Memories of Khazad-dum + * Set: Second Edition + * Side: Free + * Culture: Dwarven + * Twilight Cost: 2 + * Type: Condition - Support Area + * Card Number: 1C23 + * Game Text: When you play this condition, stack the top two cards of your draw deck here. + * Skirmish: Discard a Free Peoples card stacked here to make a Dwarf strength +1. + */ +public class Card40_023 extends AbstractPermanent{ + public Card40_023() { + super(Side.FREE_PEOPLE, 2, CardType.CONDITION, Culture.DWARVEN, Zone.SUPPORT, "Memories of Khazad-dum"); + } + + @Override + public List getRequiredAfterTriggers(LotroGame game, EffectResult effectResult, PhysicalCard self) { + if (TriggerConditions.played(game, effectResult, self)) { + RequiredTriggerAction action = new RequiredTriggerAction(self); + action.appendEffect( + new StackTopCardsFromDeckEffect(self, self.getOwner(), 2, self)); + return Collections.singletonList(action); + } + return null; + } + + @Override + protected List getExtraPhaseActions(String playerId, LotroGame game, PhysicalCard self) { + if (PlayConditions.canUseFPCardDuringPhase(game, Phase.SKIRMISH, self) + && PlayConditions.canDiscardFromStacked(self, game, playerId, 1, self, Side.FREE_PEOPLE)) { + ActivateCardAction action = new ActivateCardAction(self); + action.appendCost( + new ChooseAndDiscardStackedCardsEffect(action, playerId, 1, 1, self, Side.FREE_PEOPLE)); + action.appendEffect( + new ChooseAndAddUntilEOPStrengthBonusEffect(action, self, playerId, 1, Race.DWARF)); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_024.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_024.java new file mode 100644 index 000000000..0e2ecd4b6 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_024.java @@ -0,0 +1,51 @@ +package com.gempukku.lotro.cards.set40.dwarven; + +import com.gempukku.lotro.cards.AbstractEvent; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.actions.PlayEventAction; +import com.gempukku.lotro.cards.effects.choose.ChooseAndStackCardsFromHandEffect; +import com.gempukku.lotro.common.*; +import com.gempukku.lotro.filters.Filters; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.effects.ChooseActiveCardEffect; +import com.gempukku.lotro.logic.effects.DrawCardsEffect; + +/** + * Title: Miners of Mithril + * Set: Second Edition + * Side: Free + * Culture: Dwarven + * Twilight Cost: 0 + * Type: Event - Fellowship + * Card Number: 1C24 + * Game Text: Stack a Free Peoples card from hand on a [DWARVEN] support area condition to draw a card. + */ +public class Card40_024 extends AbstractEvent { + public Card40_024() { + super(Side.FREE_PEOPLE, 0, Culture.DWARVEN, "Miners of Mithril", Phase.FELLOWSHIP); + } + + @Override + public boolean checkPlayRequirements(String playerId, LotroGame game, PhysicalCard self, int withTwilightRemoved, int twilightModifier, boolean ignoreRoamingPenalty, boolean ignoreCheckingDeadPile) { + return super.checkPlayRequirements(playerId, game, self, withTwilightRemoved, twilightModifier, ignoreRoamingPenalty, ignoreCheckingDeadPile) + && PlayConditions.canStackCardFromHand(self, game, playerId, 1, Filters.and(Culture.DWARVEN, CardType.CONDITION, Zone.SUPPORT), Side.FREE_PEOPLE); + } + + @Override + public PlayEventAction getPlayCardAction(final String playerId, LotroGame game, PhysicalCard self, int twilightModifier, boolean ignoreRoamingPenalty) { + final PlayEventAction action = new PlayEventAction(self); + action.appendCost( + new ChooseActiveCardEffect(self, playerId, "Choose a condition to stack on", Culture.DWARVEN, CardType.CONDITION, Zone.SUPPORT) { + @Override + protected void cardSelected(LotroGame game, PhysicalCard card) { + action.appendCost( + new ChooseAndStackCardsFromHandEffect(action, playerId, 1, 1, card, + Side.FREE_PEOPLE)); + } + }); + action.appendEffect( + new DrawCardsEffect(action, playerId, 1)); + return action; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_025.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_025.java new file mode 100644 index 000000000..bf79fc6a3 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_025.java @@ -0,0 +1,67 @@ +package com.gempukku.lotro.cards.set40.dwarven; + +import com.gempukku.lotro.cards.AbstractEvent; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.TriggerConditions; +import com.gempukku.lotro.cards.actions.PlayEventAction; +import com.gempukku.lotro.cards.effects.AddUntilStartOfPhaseActionProxyEffect; +import com.gempukku.lotro.cards.effects.StackPlayedEventOnACardEffect; +import com.gempukku.lotro.cards.results.PlayEventResult; +import com.gempukku.lotro.common.*; +import com.gempukku.lotro.game.AbstractActionProxy; +import com.gempukku.lotro.game.ActionProxy; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.actions.OptionalTriggerAction; +import com.gempukku.lotro.logic.actions.RequiredTriggerAction; +import com.gempukku.lotro.logic.effects.ChooseActiveCardEffect; +import com.gempukku.lotro.logic.timing.Effect; +import com.gempukku.lotro.logic.timing.EffectResult; + +import java.util.Collections; +import java.util.List; + +/** + * Title: Resourcefulness + * Set: Second Edition + * Side: Free + * Culture: Dwarven + * Twilight Cost: 2 + * Type: Event - Maneuver + * Card Number: 1U25 + * Game Text: Until the start of the regroup phase, each time you play a [DWARVEN] skirmish event, + * stack that event on a [DWARVEN] support area condition. + */ +public class Card40_025 extends AbstractEvent { + public Card40_025() { + super(Side.FREE_PEOPLE, 2, Culture.DWARVEN, "Resourcefulness", Phase.MANEUVER); + } + + @Override + public PlayEventAction getPlayCardAction(final String playerId, final LotroGame game, final PhysicalCard self, int twilightModifier, boolean ignoreRoamingPenalty) { + PlayEventAction action = new PlayEventAction(self); + action.appendEffect( + new AddUntilStartOfPhaseActionProxyEffect( + new AbstractActionProxy() { + public List getRequiredAfterTriggers(LotroGame lotroGame, final EffectResult effectResults) { + if (TriggerConditions.played(lotroGame, effectResults, Culture.DWARVEN, CardType.EVENT, Keyword.SKIRMISH) + && PlayConditions.canSpot(lotroGame, 1, Culture.DWARVEN, CardType.CONDITION, Zone.SUPPORT)) { + final RequiredTriggerAction action = new RequiredTriggerAction(self); + action.setVirtualCardAction(true); + action.appendEffect( + new ChooseActiveCardEffect(self, playerId, "Choose condition to stack the played event on", Culture.DWARVEN, CardType.CONDITION, Zone.SUPPORT) { + @Override + protected void cardSelected(LotroGame game, PhysicalCard card) { + final PlayEventResult playEventResult = (PlayEventResult) effectResults; + action.appendEffect( + new StackPlayedEventOnACardEffect(playEventResult.getPlayEventAction(), card)); + } + }); + return Collections.singletonList(action); + } + return null; + } + }, Phase.REGROUP)); + return action; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_026.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_026.java new file mode 100644 index 000000000..aaf4a5550 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_026.java @@ -0,0 +1,71 @@ +package com.gempukku.lotro.cards.set40.dwarven; + +import com.gempukku.lotro.cards.AbstractEvent; +import com.gempukku.lotro.cards.TriggerConditions; +import com.gempukku.lotro.cards.actions.PlayEventAction; +import com.gempukku.lotro.cards.effects.AddUntilEndOfPhaseActionProxyEffect; +import com.gempukku.lotro.cards.effects.AddUntilEndOfPhaseModifierEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndDiscardCardsFromPlayEffect; +import com.gempukku.lotro.common.CardType; +import com.gempukku.lotro.common.Culture; +import com.gempukku.lotro.common.Phase; +import com.gempukku.lotro.common.Side; +import com.gempukku.lotro.filters.Filters; +import com.gempukku.lotro.game.AbstractActionProxy; +import com.gempukku.lotro.game.ActionProxy; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.actions.OptionalTriggerAction; +import com.gempukku.lotro.logic.effects.ChooseActiveCardEffect; +import com.gempukku.lotro.logic.modifiers.StrengthModifier; +import com.gempukku.lotro.logic.timing.EffectResult; + +import java.util.Collections; +import java.util.List; + +/** + * Title: Retribution + * Set: Second Edition + * Side: Free + * Culture: Dwarven + * Twilight Cost: 0 + * Type: Event - Skirmish + * Card Number: 1R26 + * Game Text: Make a Dwarf strength +1. If that Dwarf wins this skirmish, you may discard any combination of 2 Shadow conditions or possessions. + */ +public class Card40_026 extends AbstractEvent { + public Card40_026() { + super(Side.FREE_PEOPLE, 0, Culture.DWARVEN, "Retribution", Phase.SKIRMISH); + } + + @Override + public PlayEventAction getPlayCardAction(String playerId, LotroGame game, final PhysicalCard self, int twilightModifier, boolean ignoreRoamingPenalty) { + final PlayEventAction action = new PlayEventAction(self); + action.appendEffect( + new ChooseActiveCardEffect(self, playerId, "Choose a Dwarf") { + @Override + protected void cardSelected(LotroGame game, final PhysicalCard dwarf) { + action.appendEffect( + new AddUntilEndOfPhaseModifierEffect( + new StrengthModifier(self, dwarf, 1))); + action.appendEffect( + new AddUntilEndOfPhaseActionProxyEffect( + new AbstractActionProxy() { + @Override + public List getOptionalAfterTriggers(String playerId, LotroGame game, EffectResult effectResult) { + if (TriggerConditions.winsSkirmish(game, effectResult, dwarf) + && playerId.equals(dwarf.getOwner())) { + OptionalTriggerAction action = new OptionalTriggerAction(self); + action.setVirtualCardAction(true); + action.appendEffect( + new ChooseAndDiscardCardsFromPlayEffect(action, playerId, 2, 2, Side.SHADOW, Filters.or(CardType.CONDITION, CardType.POSSESSION))); + return Collections.singletonList(action); + } + return null; + } + })); + } + }); + return action; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_027.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_027.java new file mode 100644 index 000000000..d4bd26484 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_027.java @@ -0,0 +1,46 @@ +package com.gempukku.lotro.cards.set40.dwarven; + +import com.gempukku.lotro.cards.AbstractPermanent; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.TriggerConditions; +import com.gempukku.lotro.cards.effects.choose.ChooseAndDiscardStackedCardsEffect; +import com.gempukku.lotro.common.*; +import com.gempukku.lotro.filters.Filters; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.actions.OptionalTriggerAction; +import com.gempukku.lotro.logic.effects.ChooseAndHealCharactersEffect; +import com.gempukku.lotro.logic.timing.EffectResult; + +import java.util.Collections; +import java.util.List; + +/** + * Title: *Second Wind + * Set: Second Edition + * Side: Free + * Culture: Dwarven + * Twilight Cost: 2 + * Type: Condition - Support Area + * Card Number: 1C27 + * Game Text: At the beginning of the maneuver phase, you may discard a card stacked on this condition to heal a Dwarf companion. + */ +public class Card40_027 extends AbstractPermanent{ + public Card40_027() { + super(Side.FREE_PEOPLE, 2, CardType.CONDITION, Culture.DWARVEN, Zone.SUPPORT, "Second Wind", null, true); + } + + @Override + public List getOptionalAfterTriggers(String playerId, LotroGame game, EffectResult effectResult, PhysicalCard self) { + if (TriggerConditions.startOfPhase(game, effectResult, Phase.MANEUVER) + && PlayConditions.canDiscardFromStacked(self, game, playerId, 1, self, Filters.any)) { + OptionalTriggerAction action = new OptionalTriggerAction(self); + action.appendCost( + new ChooseAndDiscardStackedCardsEffect(action, playerId, 1, 1, self, Filters.any)); + action.appendEffect( + new ChooseAndHealCharactersEffect(action, playerId, Race.DWARF, CardType.COMPANION)); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_028.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_028.java new file mode 100644 index 000000000..7db4bba49 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_028.java @@ -0,0 +1,79 @@ +package com.gempukku.lotro.cards.set40.dwarven; + +import com.gempukku.lotro.cards.AbstractPermanent; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.effects.CheckPhaseLimitEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndDiscardStackedCardsEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndExertCharactersEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndPlayCardFromDiscardEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndStackCardsFromHandEffect; +import com.gempukku.lotro.common.*; +import com.gempukku.lotro.filters.Filters; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.actions.ActivateCardAction; +import com.gempukku.lotro.logic.effects.DrawCardsEffect; +import com.gempukku.lotro.logic.timing.Action; + +import java.util.Collections; +import java.util.List; + +/** + * Title: *Seven for the Dwarf-lords + * Set: Second Edition + * Side: Free + * Culture: Dwarven + * Twilight Cost: 0 + * Type: Artifact - Support Area + * Card Number: 1R28 + * Game Text: Fellowship: Stack a [DWARVEN] card here from hand. + * Skirmish: Discard 2 cards stacked here to play a [DWARVEN] skirmish event from your discard pile. + * Regroup: Discard 3 cards stacked here and exert a Dwarf twice who is damage +X to draw X cards (limit once per phase). + */ +public class Card40_028 extends AbstractPermanent{ + public Card40_028() { + super(Side.FREE_PEOPLE, 0, CardType.ARTIFACT, Culture.DWARVEN, Zone.SUPPORT, "Seven for the Dwarf-lords", null, true); + } + + @Override + protected List getExtraPhaseActions(final String playerId, final LotroGame game, final PhysicalCard self) { + if (PlayConditions.canUseFPCardDuringPhase(game, Phase.FELLOWSHIP, self) + && PlayConditions.canStackCardFromHand(self, game, playerId, 1, self, Culture.DWARVEN)) { + ActivateCardAction action = new ActivateCardAction(self); + action.appendEffect( + new ChooseAndStackCardsFromHandEffect(action, playerId, 1, 1, self, Culture.DWARVEN)); + return Collections.singletonList(action); + } + if (PlayConditions.canUseFPCardDuringPhase(game, Phase.SKIRMISH, self) + && PlayConditions.canDiscardFromStacked(self, game, playerId, 2, self, Filters.any) + && PlayConditions.canPlayFromDiscard(playerId, game, Culture.DWARVEN, Keyword.SKIRMISH, CardType.EVENT)) { + ActivateCardAction action = new ActivateCardAction(self); + action.appendCost( + new ChooseAndDiscardStackedCardsEffect(action, playerId, 2, 2, self, Filters.any)); + action.appendEffect( + new ChooseAndPlayCardFromDiscardEffect(playerId, game, Culture.DWARVEN, Keyword.SKIRMISH, CardType.EVENT)); + return Collections.singletonList(action); + } + if (PlayConditions.canUseFPCardDuringPhase(game, Phase.REGROUP, self) + && PlayConditions.canDiscardFromStacked(self, game, playerId, 3, self, Filters.any) + && PlayConditions.canExert(self, game, 2, Race.DWARF)) { + final ActivateCardAction action = new ActivateCardAction(self); + action.appendCost( + new ChooseAndDiscardStackedCardsEffect(action, playerId, 3, 3, self, Filters.any)); + action.appendCost( + new ChooseAndExertCharactersEffect(action, playerId, 1, 1, 2, Race.DWARF) { + @Override + protected void forEachCardExertedCallback(PhysicalCard character) { + int damageCount = game.getModifiersQuerying().getKeywordCount(game.getGameState(), character, Keyword.DAMAGE); + if (damageCount>0) { + action.appendEffect( + new CheckPhaseLimitEffect(action, self, 1, + new DrawCardsEffect(action, playerId, damageCount))); + } + } + }); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_029.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_029.java new file mode 100644 index 000000000..4cfef8612 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_029.java @@ -0,0 +1,36 @@ +package com.gempukku.lotro.cards.set40.dwarven; + +import com.gempukku.lotro.cards.AbstractPermanent; +import com.gempukku.lotro.cards.modifiers.CantExertWithCardModifier; +import com.gempukku.lotro.common.*; +import com.gempukku.lotro.filters.Filters; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.modifiers.Modifier; +import com.gempukku.lotro.logic.modifiers.condition.CardStackedCondition; + +import java.util.Collections; +import java.util.List; + +/** + * Title: *Staunch Defenders + * Set: Second Edition + * Side: Free + * Culture: Dwarven + * Twilight Cost: 2 + * Type: Condition - Support Area + * Card Number: 1C29 + * Game Text: While you can spot 3 cards stacked on this condition, Dwarves may not be exerted by Shadow cards. + */ +public class Card40_029 extends AbstractPermanent{ + public Card40_029() { + super(Side.FREE_PEOPLE, 2, CardType.CONDITION, Culture.DWARVEN, Zone.SUPPORT, "Staunch Defenders", null, true); + } + + @Override + public List getAlwaysOnModifiers(LotroGame game, PhysicalCard self) { + CantExertWithCardModifier modifier = new CantExertWithCardModifier( + self, Side.SHADOW, new CardStackedCondition(3, self, Filters.any), Race.DWARF); + return Collections.singletonList(modifier); + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_030.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_030.java new file mode 100644 index 000000000..ad5a39a6a --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_030.java @@ -0,0 +1,55 @@ +package com.gempukku.lotro.cards.set40.dwarven; + +import com.gempukku.lotro.cards.AbstractEvent; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.actions.PlayEventAction; +import com.gempukku.lotro.cards.effects.AddUntilEndOfPhaseModifierEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndDiscardCardsFromPlayEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndDiscardStackedCardsEffect; +import com.gempukku.lotro.cards.modifiers.ArcheryTotalModifier; +import com.gempukku.lotro.common.CardType; +import com.gempukku.lotro.common.Culture; +import com.gempukku.lotro.common.Phase; +import com.gempukku.lotro.common.Side; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; + +import java.util.Collection; + +/** + * Title: Take Cover! + * Set: Second Edition + * Side: Free + * Culture: Dwarven + * Twilight Cost: 2 + * Type: Event - Archery + * Card Number: 1U30 + * Game Text: Discard a [DWARVEN] condition to make the minion archery total -X, where X is the number of cards that were stacked on that condition. + */ +public class Card40_030 extends AbstractEvent{ + public Card40_030() { + super(Side.FREE_PEOPLE, 2, Culture.DWARVEN, "Take Cover!", Phase.ARCHERY); + } + + @Override + public boolean checkPlayRequirements(String playerId, LotroGame game, PhysicalCard self, int withTwilightRemoved, int twilightModifier, boolean ignoreRoamingPenalty, boolean ignoreCheckingDeadPile) { + return super.checkPlayRequirements(playerId, game, self, withTwilightRemoved, twilightModifier, ignoreRoamingPenalty, ignoreCheckingDeadPile) + && PlayConditions.canDiscardFromPlay(self, game, Culture.DWARVEN, CardType.CONDITION); + } + + @Override + public PlayEventAction getPlayCardAction(String playerId, final LotroGame game, final PhysicalCard self, int twilightModifier, boolean ignoreRoamingPenalty) { + final PlayEventAction action = new PlayEventAction(self); + action.appendCost( + new ChooseAndDiscardCardsFromPlayEffect(action, playerId, 1, 1, Culture.DWARVEN, CardType.CONDITION) { + @Override + protected void cardsToBeDiscardedCallback(Collection cards) { + int total = game.getGameState().getStackedCards(cards.iterator().next()).size(); + action.appendEffect( + new AddUntilEndOfPhaseModifierEffect( + new ArcheryTotalModifier(self, Side.SHADOW, -total))); + } + }); + return action; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_031.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_031.java new file mode 100644 index 000000000..800560897 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_031.java @@ -0,0 +1,43 @@ +package com.gempukku.lotro.cards.set40.dwarven; + +import com.gempukku.lotro.cards.AbstractCompanion; +import com.gempukku.lotro.common.CardType; +import com.gempukku.lotro.common.Culture; +import com.gempukku.lotro.common.Keyword; +import com.gempukku.lotro.common.Race; +import com.gempukku.lotro.filters.Filters; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.modifiers.Modifier; +import com.gempukku.lotro.logic.modifiers.SpotCondition; +import com.gempukku.lotro.logic.modifiers.StrengthModifier; + +import java.util.Collections; +import java.util.List; + +/** + * Title: *Thorin III, Lord of the Longbeards + * Set: Second Edition + * Side: Free + * Culture: Dwarven + * Twilight Cost: 2 + * Type: Companion - Dwarf + * Strength: 6 + * Vitality: 3 + * Resistance: 6 + * Card Number: 1R31 + * Game Text: Damage +1. While you can spot 3 [DWARVEN] cards stacked on a [DWARVEN] condition, Thorin III is strength +2. + */ +public class Card40_031 extends AbstractCompanion{ + public Card40_031() { + super(2, 6, 3, 6, Culture.DWARVEN, Race.DWARF, null, "Thorin III", "Lord of the Longbeards", true); + addKeyword(Keyword.DAMAGE, 1); + } + + @Override + public List getAlwaysOnModifiers(LotroGame game, PhysicalCard self) { + StrengthModifier modifier = new StrengthModifier(self, self, + new SpotCondition(Culture.DWARVEN, CardType.CONDITION, Filters.hasStacked(3, Culture.DWARVEN)), 2); + return Collections.singletonList(modifier); + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_032.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_032.java new file mode 100644 index 000000000..4c3a18a15 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/dwarven/Card40_032.java @@ -0,0 +1,47 @@ +package com.gempukku.lotro.cards.set40.dwarven; + +import com.gempukku.lotro.cards.AbstractPermanent; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.TriggerConditions; +import com.gempukku.lotro.cards.effects.choose.ChooseAndExertCharactersEffect; +import com.gempukku.lotro.cards.results.PlayEventResult; +import com.gempukku.lotro.common.CardType; +import com.gempukku.lotro.common.Culture; +import com.gempukku.lotro.common.Side; +import com.gempukku.lotro.common.Zone; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.actions.RequiredTriggerAction; +import com.gempukku.lotro.logic.timing.EffectResult; + +import java.util.Collections; +import java.util.List; + +/** + * Title: *Well Prepared + * Set: Second Edition + * Side: Free + * Culture: Dwarven + * Twilight Cost: 1 + * Type: Condition - Support Area + * Card Number: 1R32 + * Game Text: While you can spot 3 cards stacked on this condition, each time a Shadow event is played, the Shadow player must exert a minion. + */ +public class Card40_032 extends AbstractPermanent{ + public Card40_032() { + super(Side.FREE_PEOPLE, 1, CardType.CONDITION, Culture.DWARVEN, Zone.SUPPORT, "Well Prepared", null, true); + } + + @Override + public List getRequiredAfterTriggers(LotroGame game, EffectResult effectResult, PhysicalCard self) { + if (TriggerConditions.played(game, effectResult, Side.SHADOW, CardType.EVENT) + && game.getGameState().getStackedCards(self).size()>=3) { + PlayEventResult playEventResult = (PlayEventResult) effectResult; + RequiredTriggerAction action = new RequiredTriggerAction(self); + action.appendEffect( + new ChooseAndExertCharactersEffect(action, playEventResult.getPlayEventAction().getPerformingPlayer(), 1, 1, CardType.MINION)); + return Collections.singletonList(action); + } + return null; + } +}