diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/TriggerConditions.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/TriggerConditions.java index 1978e8681..1dad49a96 100644 --- a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/TriggerConditions.java +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/TriggerConditions.java @@ -418,4 +418,12 @@ public class TriggerConditions { } return false; } + + public static boolean skirmishCancelled(LotroGame game, EffectResult effectResult, Filterable ... fpCharacterFilter) { + if (effectResult.getType() == EffectResult.Type.SKIRMISH_CANCELLED) { + SkirmishCancelledResult cancelledResult = (SkirmishCancelledResult) effectResult; + return Filters.and(fpCharacterFilter).accepts(game.getGameState(), game.getModifiersQuerying(), cancelledResult.getFpCharacter()); + } + return false; + } } diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/effects/CancelSkirmishEffect.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/effects/CancelSkirmishEffect.java index 8e9fe2af0..007fb0db2 100644 --- a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/effects/CancelSkirmishEffect.java +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/effects/CancelSkirmishEffect.java @@ -1,46 +1,52 @@ -package com.gempukku.lotro.cards.effects; - -import com.gempukku.lotro.common.Filterable; -import com.gempukku.lotro.filters.Filters; -import com.gempukku.lotro.game.state.LotroGame; -import com.gempukku.lotro.logic.timing.AbstractEffect; -import com.gempukku.lotro.logic.timing.Effect; - -public class CancelSkirmishEffect extends AbstractEffect { - private Filterable[] _involvementFilter; - - public CancelSkirmishEffect() { - } - - public CancelSkirmishEffect(Filterable... involvementFilter) { - _involvementFilter = involvementFilter; - } - - @Override - public String getText(LotroGame game) { - return "Cancel skirmish"; - } - - @Override - public Effect.Type getType() { - return null; - } - - @Override - public boolean isPlayableInFull(LotroGame game) { - return game.getGameState().getSkirmish() != null - && !game.getGameState().getSkirmish().isCancelled() - && (_involvementFilter == null || Filters.countActive(game.getGameState(), game.getModifiersQuerying(), Filters.and(_involvementFilter, Filters.inSkirmish)) > 0) - && (game.getFormat().canCancelRingBearerSkirmish() || Filters.countActive(game.getGameState(), game.getModifiersQuerying(), Filters.ringBearer, Filters.inSkirmish)==0); - } - - @Override - protected FullEffectResult playEffectReturningResult(LotroGame game) { - if (isPlayableInFull(game)) { - game.getGameState().sendMessage("Skirmish is cancelled"); - game.getGameState().getSkirmish().cancel(); - return new FullEffectResult(true); - } - return new FullEffectResult(false); - } -} +package com.gempukku.lotro.cards.effects; + +import com.gempukku.lotro.common.Filterable; +import com.gempukku.lotro.filters.Filters; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.timing.AbstractEffect; +import com.gempukku.lotro.logic.timing.Effect; +import com.gempukku.lotro.logic.timing.results.SkirmishCancelledResult; + +public class CancelSkirmishEffect extends AbstractEffect { + private Filterable[] _involvementFilter; + + public CancelSkirmishEffect() { + } + + public CancelSkirmishEffect(Filterable... involvementFilter) { + _involvementFilter = involvementFilter; + } + + @Override + public String getText(LotroGame game) { + return "Cancel skirmish"; + } + + @Override + public Effect.Type getType() { + return null; + } + + @Override + public boolean isPlayableInFull(LotroGame game) { + return game.getGameState().getSkirmish() != null + && !game.getGameState().getSkirmish().isCancelled() + && (_involvementFilter == null || Filters.countActive(game.getGameState(), game.getModifiersQuerying(), Filters.and(_involvementFilter, Filters.inSkirmish)) > 0) + && (game.getFormat().canCancelRingBearerSkirmish() || Filters.countActive(game.getGameState(), game.getModifiersQuerying(), Filters.ringBearer, Filters.inSkirmish) == 0); + } + + @Override + protected FullEffectResult playEffectReturningResult(LotroGame game) { + if (isPlayableInFull(game)) { + final PhysicalCard fellowshipCharacter = game.getGameState().getSkirmish().getFellowshipCharacter(); + if (fellowshipCharacter != null) + game.getActionsEnvironment().emitEffectResult( + new SkirmishCancelledResult(fellowshipCharacter)); + game.getGameState().sendMessage("Skirmish is cancelled"); + game.getGameState().getSkirmish().cancel(); + return new FullEffectResult(true); + } + return new FullEffectResult(false); + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/isengard/Card40_143.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/isengard/Card40_143.java index 402e8873f..13dc7a803 100644 --- a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/isengard/Card40_143.java +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/isengard/Card40_143.java @@ -37,13 +37,14 @@ public class Card40_143 extends AbstractResponseEvent { @Override public List getOptionalAfterActions(String playerId, LotroGame game, EffectResult effectResult, PhysicalCard self) { if (TriggerConditions.forEachWounded(game, effectResult, self) - && PlayConditions.canExert(self, game, Filters.saruman)) { + && PlayConditions.canExert(self, game, Filters.saruman) + && checkPlayRequirements(playerId, game, self, 0, 0, false, false)) { WoundResult woundResult = (WoundResult) effectResult; final PhysicalCard woundedCard = woundResult.getWoundedCard(); PlayEventAction action = new PlayEventAction(self); action.appendCost( new ChooseAndExertCharactersEffect(action, playerId, 1, 1, Filters.saruman)); - action.setText("Wound "+ GameUtils.getFullName(woundedCard)); + action.setText("Wound " + GameUtils.getFullName(woundedCard)); action.appendEffect( new WoundCharactersEffect(self, woundedCard)); return Collections.singletonList(action); diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/isengard/Card40_152.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/isengard/Card40_152.java index 85ec5c4e2..6367b3b90 100644 --- a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/isengard/Card40_152.java +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/isengard/Card40_152.java @@ -37,7 +37,8 @@ public class Card40_152 extends AbstractResponseEvent { @Override public List getOptionalAfterActions(String playerId, LotroGame game, EffectResult effectResult, PhysicalCard self) { if (TriggerConditions.winsSkirmish(game, effectResult, Filters.saruman) - && PlayConditions.canExert(self, game, Filters.saruman)) { + && PlayConditions.canExert(self, game, Filters.saruman) + && checkPlayRequirements(playerId, game, self, 0, 0, false, false)) { PlayEventAction action = new PlayEventAction(self); action.appendCost( new ChooseAndExertCharactersEffect(action, playerId, 1, 1, Filters.saruman)); diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_184.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_184.java new file mode 100644 index 000000000..85437de49 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_184.java @@ -0,0 +1,40 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractAttachable; +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.StrengthModifier; + +import java.util.Collections; +import java.util.List; + +/** + * Title: Black Steed, Bred to Serve + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 1 + * Type: Possession - Mount + * Strength: +2 + * Card Number: 1R184 + * Game Text: Bearer must be a Nazgul. While skirmishing a companion with 3 or less resistance, bearer is strength +2. + */ +public class Card40_184 extends AbstractAttachable { + public Card40_184() { + super(Side.SHADOW, CardType.POSSESSION, 1, Culture.WRAITH, PossessionClass.MOUNT, "Black Steed", "Bred to Serve", false); + } + + @Override + protected Filterable getValidTargetFilter(String playerId, LotroGame game, PhysicalCard self) { + return Race.NAZGUL; + } + + @Override + public List getAlwaysOnModifiers(LotroGame game, PhysicalCard self) { + StrengthModifier modifier = new StrengthModifier(self, Filters.and(Filters.hasAttached(self), Filters.inSkirmishAgainst(CardType.COMPANION, Filters.maxResistance(3))), 2); + return Collections.singletonList(modifier); + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_187.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_187.java new file mode 100644 index 000000000..b0c771e27 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_187.java @@ -0,0 +1,45 @@ +package com.gempukku.lotro.cards.set40.wraith; + +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.AddBurdenEffect; +import com.gempukku.lotro.cards.modifiers.evaluator.ConditionEvaluator; +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.SpotCondition; + +/** + * Title: Darkly Swift + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 1 + * Type: Event - Regroup + * Card Number: 1U187 + * Game Text: Discard a Nazgul and spot a companion with 3 or less resistance to add a burden (or two burdens + * if you can spot a companion with 0 or less resistance.) + */ +public class Card40_187 extends AbstractEvent { + public Card40_187() { + super(Side.SHADOW, 1, Culture.WRAITH, "Darkly Swift", Phase.REGROUP); + } + + @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, Race.NAZGUL) + && PlayConditions.canSpot(game, CardType.COMPANION, Filters.maxResistance(3)); + } + + @Override + public PlayEventAction getPlayCardAction(String playerId, LotroGame game, PhysicalCard self, int twilightModifier, boolean ignoreRoamingPenalty) { + PlayEventAction action = new PlayEventAction(self); + action.appendEffect( + new AddBurdenEffect(playerId, self, + new ConditionEvaluator(1, 2, new SpotCondition(CardType.COMPANION, Filters.maxResistance(0))))); + return action; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_188.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_188.java new file mode 100644 index 000000000..5894d79d0 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_188.java @@ -0,0 +1,69 @@ +package com.gempukku.lotro.cards.set40.wraith; + +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.AddBurdenEffect; +import com.gempukku.lotro.cards.effects.PreventableEffect; +import com.gempukku.lotro.cards.effects.TakeOffTheOneRingEffect; +import com.gempukku.lotro.common.Culture; +import com.gempukku.lotro.common.Phase; +import com.gempukku.lotro.common.Race; +import com.gempukku.lotro.common.Side; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.GameState; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.GameUtils; +import com.gempukku.lotro.logic.actions.SubAction; +import com.gempukku.lotro.logic.effects.CorruptRingBearerEffect; +import com.gempukku.lotro.logic.modifiers.ModifiersQuerying; +import com.gempukku.lotro.logic.timing.Effect; + +import java.util.Collections; + +/** + * Title: Its Master's Call + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 8 + * Type: Event - Maneuver + * Card Number: 1R188 + * Game Text: The twilight cost of this event is -1 for each burden you can spot. + * To play, spot a Nazgul and the Ring-bearer wearing The One Ring. + * Corrupt the Ring-bearer; the Free Peoples player may add 3 burden to prevent this and take off The One Ring. + */ +public class Card40_188 extends AbstractEvent { + public Card40_188() { + super(Side.SHADOW, 8, Culture.WRAITH, "Its Master's Call", Phase.MANEUVER); + } + + @Override + public int getTwilightCostModifier(GameState gameState, ModifiersQuerying modifiersQuerying, PhysicalCard self) { + return -gameState.getBurdens(); + } + + @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.canSpot(game, Race.NAZGUL) + && game.getGameState().isWearingRing(); + } + + @Override + public PlayEventAction getPlayCardAction(String playerId, final LotroGame game, final PhysicalCard self, int twilightModifier, boolean ignoreRoamingPenalty) { + PlayEventAction action = new PlayEventAction(self); + action.appendEffect( + new PreventableEffect(action, + new CorruptRingBearerEffect(), + GameUtils.getFreePeoplePlayer(game), + new PreventableEffect.PreventionCost() { + @Override + public Effect createPreventionCostForPlayer(SubAction subAction, String playerId) { + return new AddBurdenEffect(GameUtils.getFreePeoplePlayer(game), self, 3); + } + })); + action.appendEffect(new TakeOffTheOneRingEffect()); + return action; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_193.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_193.java new file mode 100644 index 000000000..c73e9b960 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_193.java @@ -0,0 +1,75 @@ +package com.gempukku.lotro.cards.set40.wraith; + +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.cards.effects.choose.ChooseAndPreventCardEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndPutCardFromDiscardIntoHandEffect; +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.WoundCharactersEffect; +import com.gempukku.lotro.logic.timing.Action; +import com.gempukku.lotro.logic.timing.Effect; + +import java.util.Collections; +import java.util.List; + +/** + * Title: *Nine for Mortal Men + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 0 + * Type: Artifact - Support Area + * Card Number: 1R193 + * Game Text: Shadow: Spot a Nazgul to stack a [RINGWRAITH] card here. + * Response: If a Nazgul is about to take a wound, discard 2 cards stacked here to prevent that wound. + * Regroup: Discard 3 cards stacked here to take a [RINGWRAITH] card from your discard pile into hand. + */ +public class Card40_193 extends AbstractPermanent { + public Card40_193() { + super(Side.SHADOW, 0, CardType.ARTIFACT, Culture.WRAITH, Zone.SUPPORT, "Nine for Mortal Men", null, true); + } + + @Override + protected List getExtraPhaseActions(String playerId, LotroGame game, PhysicalCard self) { + if (PlayConditions.canUseShadowCardDuringPhase(game, Phase.SHADOW, self, 0) + && PlayConditions.canSpot(game, Race.NAZGUL)) { + ActivateCardAction action = new ActivateCardAction(self); + action.appendEffect( + new ChooseAndStackCardsFromHandEffect(action, playerId, 1, 1, self, Culture.WRAITH)); + return Collections.singletonList(action); + } + if (PlayConditions.canUseShadowCardDuringPhase(game, Phase.REGROUP, self, 0) + && PlayConditions.canDiscardFromStacked(self, game, playerId, 3, self, Filters.any)) { + ActivateCardAction action = new ActivateCardAction(self); + action.appendCost( + new ChooseAndDiscardStackedCardsEffect(action, playerId, 3, 3, self, Filters.any)); + action.appendEffect( + new ChooseAndPutCardFromDiscardIntoHandEffect(action, playerId, 1, 1, Culture.WRAITH)); + return Collections.singletonList(action); + } + return null; + } + + @Override + public List getOptionalInPlayBeforeActions(String playerId, LotroGame game, Effect effect, PhysicalCard self) { + if (TriggerConditions.isGettingWounded(effect, game, Race.NAZGUL) + && PlayConditions.canDiscardFromStacked(self, game, playerId, 2, self, Filters.any)) { + WoundCharactersEffect woundEffect = (WoundCharactersEffect) effect; + + ActivateCardAction action = new ActivateCardAction(self); + action.appendCost( + new ChooseAndDiscardStackedCardsEffect(action, playerId, 2, 2, self, Filters.any)); + action.appendEffect( + new ChooseAndPreventCardEffect(self, woundEffect, playerId, "Choose Nazgul to prevent wound to", Race.NAZGUL)); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_194.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_194.java new file mode 100644 index 000000000..baf9c33df --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_194.java @@ -0,0 +1,64 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractPermanent; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.TriggerConditions; +import com.gempukku.lotro.cards.actions.PlayPermanentAction; +import com.gempukku.lotro.cards.effects.SelfDiscardEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndExertCharactersEffect; +import com.gempukku.lotro.cards.modifiers.ResistanceModifier; +import com.gempukku.lotro.common.*; +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.modifiers.Modifier; +import com.gempukku.lotro.logic.timing.EffectResult; + +import java.util.Collections; +import java.util.List; + +/** + * Title: *Ominous Landscape + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 0 + * Type: Condition - Support Area + * Card Number: 1U194 + * Game Text: To play, exert a Nazgul. Each companion is resistance -1. Discard this condition at the beginning of the regroup phase. + */ +public class Card40_194 extends AbstractPermanent { + public Card40_194() { + super(Side.SHADOW, 0, CardType.CONDITION, Culture.WRAITH, Zone.SUPPORT, "Ominous Landscape", null, true); + } + + @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.NAZGUL); + } + + @Override + public PlayPermanentAction getPlayCardAction(String playerId, LotroGame game, PhysicalCard self, int twilightModifier, boolean ignoreRoamingPenalty) { + final PlayPermanentAction action = super.getPlayCardAction(playerId, game, self, twilightModifier, ignoreRoamingPenalty); + action.appendCost( + new ChooseAndExertCharactersEffect(action, playerId, 1, 1, Race.NAZGUL)); + return action; + } + + @Override + public List getAlwaysOnModifiers(LotroGame game, PhysicalCard self) { + ResistanceModifier modifier = new ResistanceModifier(self, CardType.COMPANION, -1); + return Collections.singletonList(modifier); + } + + @Override + public List getRequiredAfterTriggers(LotroGame game, EffectResult effectResult, PhysicalCard self) { + if (TriggerConditions.startOfPhase(game, effectResult, Phase.REGROUP)) { + RequiredTriggerAction action = new RequiredTriggerAction(self); + action.appendEffect(new SelfDiscardEffect(self)); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_195.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_195.java new file mode 100644 index 000000000..b410330e5 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_195.java @@ -0,0 +1,59 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractAttachable; +import com.gempukku.lotro.cards.TriggerConditions; +import com.gempukku.lotro.cards.effects.choose.ChooseAndDiscardCardsFromPlayEffect; +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.modifiers.KeywordModifier; +import com.gempukku.lotro.logic.modifiers.Modifier; +import com.gempukku.lotro.logic.modifiers.StrengthModifier; +import com.gempukku.lotro.logic.timing.EffectResult; + +import java.util.Arrays; +import java.util.Collections; +import java.util.List; + +/** + * Title: *The Pale Blade, Weapon of Woe + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 2 + * Type: Possession - Hand Weapon + * Strength: +3 + * Card Number: 1R195 + * Game Text: Bearer must be a Nazgul. If bearer is The Witch-king, he is damage +1. + * Each time The Witch-king wins a skirmish, you may discard a Free Peoples condition. + */ +public class Card40_195 extends AbstractAttachable { + public Card40_195() { + super(Side.SHADOW, CardType.POSSESSION, 2, Culture.WRAITH, PossessionClass.HAND_WEAPON, "The Pale Blade", "Weapon of Woe", true); + } + + @Override + protected Filterable getValidTargetFilter(String playerId, LotroGame game, PhysicalCard self) { + return Race.NAZGUL; + } + + @Override + public List getAlwaysOnModifiers(LotroGame game, PhysicalCard self) { + StrengthModifier strength = new StrengthModifier(self, Filters.hasAttached(self), 3); + KeywordModifier damage = new KeywordModifier(self, Filters.and(Filters.hasAttached(self), Filters.witchKing), Keyword.DAMAGE, 1); + return Arrays.asList(strength, damage); + } + + @Override + public List getOptionalAfterTriggers(String playerId, LotroGame game, EffectResult effectResult, PhysicalCard self) { + if (TriggerConditions.winsSkirmish(game, effectResult, Filters.witchKing)) { + OptionalTriggerAction action = new OptionalTriggerAction(self); + action.appendEffect( + new ChooseAndDiscardCardsFromPlayEffect(action, playerId, 1, 1, Side.FREE_PEOPLE, CardType.CONDITION)); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_196.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_196.java new file mode 100644 index 000000000..5950aaa6d --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_196.java @@ -0,0 +1,72 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractPermanent; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.actions.PlayPermanentAction; +import com.gempukku.lotro.cards.effects.SelfDiscardEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndExertCharactersEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndPlayCardFromDiscardEffect; +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.modifiers.KeywordModifier; +import com.gempukku.lotro.logic.modifiers.Modifier; +import com.gempukku.lotro.logic.timing.Action; + +import java.util.Collections; +import java.util.List; + +/** + * Title: Relentless Pursuit + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 2 + * Type: Condition - Support Area + * Card Number: 1R196 + * Game Text: To play, exert a Nazgul. Each site in the current region is a forest. + * Shadow: Spot a Nazgul and discad this condition to play a Nazgul from your discard pile. + */ +public class Card40_196 extends AbstractPermanent { + public Card40_196() { + super(Side.SHADOW, 2, CardType.CONDITION, Culture.WRAITH, Zone.SUPPORT, "Relentless Pursuit"); + } + + @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.NAZGUL); + } + + @Override + public PlayPermanentAction getPlayCardAction(String playerId, LotroGame game, PhysicalCard self, int twilightModifier, boolean ignoreRoamingPenalty) { + final PlayPermanentAction action = super.getPlayCardAction(playerId, game, self, twilightModifier, ignoreRoamingPenalty); + action.appendCost( + new ChooseAndExertCharactersEffect(action, playerId, 1, 1, Race.NAZGUL)); + return action; + } + + @Override + public List getAlwaysOnModifiers(LotroGame game, PhysicalCard self) { + KeywordModifier modifier = new KeywordModifier(self, Filters.and(CardType.SITE, Filters.siteInCurrentRegion), Keyword.FOREST); + return Collections.singletonList(modifier); + } + + @Override + protected List getExtraPhaseActions(String playerId, LotroGame game, PhysicalCard self) { + if (PlayConditions.canUseShadowCardDuringPhase(game, Phase.SHADOW, self, 0) + && PlayConditions.canSpot(game, Race.NAZGUL) + && PlayConditions.canSelfDiscard(self, game) + && PlayConditions.canPlayFromDiscard(playerId, game, Race.NAZGUL)) { + ActivateCardAction action = new ActivateCardAction(self); + action.appendCost( + new SelfDiscardEffect(self)); + action.appendEffect( + new ChooseAndPlayCardFromDiscardEffect(playerId, game, Race.NAZGUL)); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_197.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_197.java new file mode 100644 index 000000000..7d11c01fb --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_197.java @@ -0,0 +1,58 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractEvent; +import com.gempukku.lotro.cards.actions.PlayEventAction; +import com.gempukku.lotro.cards.effects.PreventableEffect; +import com.gempukku.lotro.cards.effects.PutOnTheOneRingEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndExertCharactersEffect; +import com.gempukku.lotro.common.Culture; +import com.gempukku.lotro.common.Phase; +import com.gempukku.lotro.common.Race; +import com.gempukku.lotro.common.Side; +import com.gempukku.lotro.filters.Filters; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.GameUtils; +import com.gempukku.lotro.logic.actions.SubAction; +import com.gempukku.lotro.logic.timing.Effect; + +import java.util.Collection; + +/** + * Title: The Ring's Compulsion + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 1 + * Type: Event - Maneuver + * Card Number: 1U197 + * Game Text: Exert X Nazgul to make the Ring-bearer wear The One Ring until the regroup phase. + * The Free Peoples player may exert the Ring-bearer X times to prevent this. + */ +public class Card40_197 extends AbstractEvent { + public Card40_197() { + super(Side.SHADOW, 1, Culture.WRAITH, "The Ring's Compulsion", Phase.MANEUVER); + } + + @Override + public PlayEventAction getPlayCardAction(final String playerId, final LotroGame game, PhysicalCard self, int twilightModifier, boolean ignoreRoamingPenalty) { + final PlayEventAction action = new PlayEventAction(self); + action.appendCost( + new ChooseAndExertCharactersEffect(action, playerId, 1, Integer.MAX_VALUE, Race.NAZGUL) { + @Override + protected void cardsToBeExertedCallback(Collection characters) { + final int exertCount = characters.size(); + action.appendEffect( + new PreventableEffect(action, + new PutOnTheOneRingEffect(), GameUtils.getFreePeoplePlayer(game), + new PreventableEffect.PreventionCost() { + @Override + public Effect createPreventionCostForPlayer(SubAction subAction, String playerId) { + return new ChooseAndExertCharactersEffect(subAction, playerId, 1, 1, exertCount, Filters.ringBearer); + } + })); + } + }); + return action; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_198.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_198.java new file mode 100644 index 000000000..ad9749c7a --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_198.java @@ -0,0 +1,47 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractResponseEvent; +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.choose.ChooseAndPlayCardFromDiscardEffect; +import com.gempukku.lotro.common.Culture; +import com.gempukku.lotro.common.Phase; +import com.gempukku.lotro.common.Race; +import com.gempukku.lotro.common.Side; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.timing.EffectResult; + +import java.util.Collections; +import java.util.List; + +/** + * Title: Shadowy Pursuit + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 0 + * Type: Event - Response + * Card Number: 1U198 + * Game Text: If the Free Peoples player moves during the regroup phase, play a Nazgul from your discard pile. + */ +public class Card40_198 extends AbstractResponseEvent { + public Card40_198() { + super(Side.SHADOW, 0, Culture.WRAITH, "Shadowy Pursuit"); + } + + @Override + public List getOptionalAfterActions(String playerId, LotroGame game, EffectResult effectResult, PhysicalCard self) { + if (TriggerConditions.moves(game, effectResult) + && PlayConditions.isPhase(game, Phase.REGROUP) + && PlayConditions.canPlayFromDiscard(playerId, game, Race.NAZGUL) + && checkPlayRequirements(playerId, game, self, 0, 0, false, false)) { + PlayEventAction action = new PlayEventAction(self); + action.appendEffect( + new ChooseAndPlayCardFromDiscardEffect(playerId, game, Race.NAZGUL)); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_199.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_199.java new file mode 100644 index 000000000..c0f728076 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_199.java @@ -0,0 +1,67 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractResponseEvent; +import com.gempukku.lotro.cards.TriggerConditions; +import com.gempukku.lotro.cards.actions.PlayEventAction; +import com.gempukku.lotro.cards.effects.AddBurdenEffect; +import com.gempukku.lotro.cards.effects.AddUntilStartOfPhaseActionProxyEffect; +import com.gempukku.lotro.cards.effects.ExertCharactersEffect; +import com.gempukku.lotro.common.Culture; +import com.gempukku.lotro.common.Phase; +import com.gempukku.lotro.common.Race; +import com.gempukku.lotro.common.Side; +import com.gempukku.lotro.filters.Filters; +import com.gempukku.lotro.game.AbstractActionProxy; +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 com.gempukku.lotro.logic.timing.results.AssignAgainstResult; + +import java.util.Collections; +import java.util.List; + +/** + * Title: Shire! Baggins! + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 1 + * Type: Event - Response + * Card Number: 1U199 + * Game Text: If the Free Peoples player assigns a Nazgul to skirmish a Hobbit, exert that Nazgul. + * If the Free Peoples player cancels this skirmish, add a burden. + */ +public class Card40_199 extends AbstractResponseEvent { + public Card40_199() { + super(Side.SHADOW, 1, Culture.WRAITH, "Shire! Baggins!"); + } + + @Override + public List getOptionalAfterActions(final String playerId, LotroGame game, EffectResult effectResult, final PhysicalCard self) { + if (TriggerConditions.assignedAgainst(game, effectResult, Side.FREE_PEOPLE, Race.NAZGUL, Race.HOBBIT) + && checkPlayRequirements(playerId, game, self, 0, 0, false, false)) { + final AssignAgainstResult assignResult = (AssignAgainstResult) effectResult; + PlayEventAction action = new PlayEventAction(self); + action.appendEffect( + new ExertCharactersEffect(action, self, Race.NAZGUL, Filters.in(assignResult.getAgainst()))); + action.appendEffect( + new AddUntilStartOfPhaseActionProxyEffect( + new AbstractActionProxy() { + @Override + public List getRequiredAfterTriggers(LotroGame game, EffectResult effectResult) { + if (TriggerConditions.skirmishCancelled(game, effectResult, assignResult.getAssignedCard())) { + RequiredTriggerAction action = new RequiredTriggerAction(self); + action.setVirtualCardAction(true); + action.appendEffect( + new AddBurdenEffect(self.getOwner(), self, 1)); + return Collections.singletonList(action); + } + return null; + } + }, Phase.REGROUP)); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_201.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_201.java new file mode 100644 index 000000000..ea5c4e1d0 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_201.java @@ -0,0 +1,62 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractResponseEvent; +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.choose.ChooseAndExertCharactersEffect; +import com.gempukku.lotro.common.CardType; +import com.gempukku.lotro.common.Culture; +import com.gempukku.lotro.common.Race; +import com.gempukku.lotro.common.Side; +import com.gempukku.lotro.filters.Filters; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.GameUtils; +import com.gempukku.lotro.logic.effects.KillEffect; +import com.gempukku.lotro.logic.timing.EffectResult; +import com.gempukku.lotro.logic.timing.results.CharacterWonSkirmishResult; + +import java.util.Collection; +import java.util.Collections; +import java.util.List; +import java.util.Set; + +/** + * Title: Succumb to Despair + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 0 + * Type: Event - Response + * Card Number: 1R201 + * Game Text: If a Nazgul wins a skirmish against a companion with 0 resistance or less, exert that Nazgul twice + * to place that companion in the dead pile. + */ +public class Card40_201 extends AbstractResponseEvent { + public Card40_201() { + super(Side.SHADOW, 0, Culture.WRAITH, "Succumb to Despair"); + } + + @Override + public List getOptionalAfterActions(String playerId, LotroGame game, EffectResult effectResult, PhysicalCard self) { + if (TriggerConditions.winsSkirmishInvolving(game, effectResult, Race.NAZGUL, Filters.and(CardType.COMPANION, Filters.maxResistance(0))) + && checkPlayRequirements(playerId, game, self, 0, 0, false, false)) { + CharacterWonSkirmishResult wonSkirmishResult = (CharacterWonSkirmishResult) effectResult; + final PhysicalCard winner = wonSkirmishResult.getWinner(); + if (PlayConditions.canExert(self, game, 2, winner)) { + final Set involving = wonSkirmishResult.getInvolving(); + final Collection toKill = Filters.filter(involving, game.getGameState(), game.getModifiersQuerying(), CardType.COMPANION, Filters.maxResistance(0)); + + PlayEventAction action = new PlayEventAction(self); + action.setText("Play exerting " + GameUtils.getFullName(winner)); + action.appendCost( + new ChooseAndExertCharactersEffect(action, playerId, 1, 1, 2, winner)); + action.appendEffect( + new KillEffect(toKill, KillEffect.Cause.CARD_EFFECT)); + return Collections.singletonList(action); + } + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_202.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_202.java new file mode 100644 index 000000000..6d47813c6 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_202.java @@ -0,0 +1,74 @@ +package com.gempukku.lotro.cards.set40.wraith; + +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.*; +import com.gempukku.lotro.cards.effects.choose.ChooseAndAddUntilEOPStrengthBonusEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndExertCharactersEffect; +import com.gempukku.lotro.common.Culture; +import com.gempukku.lotro.common.Phase; +import com.gempukku.lotro.common.Race; +import com.gempukku.lotro.common.Side; +import com.gempukku.lotro.filters.Filters; +import com.gempukku.lotro.game.AbstractActionProxy; +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.GameUtils; +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.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * Title: To Mordor We Will Take You! + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 2 + * Type: Event - Skirmish + * Card Number: 1U202 + * Game Text: Make a Nazgul strength +2. If that Nazgul wins this skirmish, the Free Peoples player must exert the Ring-bearer or add a burden. + */ +public class Card40_202 extends AbstractEvent { + public Card40_202() { + super(Side.SHADOW, 2, Culture.WRAITH, "To Mordor We Will Take You!", 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 ChooseAndAddUntilEOPStrengthBonusEffect(action, self, playerId, 2, Race.NAZGUL) { + @Override + protected void selectedCharacterCallback(final PhysicalCard selectedCharacter) { + action.appendEffect( + new AddUntilEndOfPhaseActionProxyEffect( + new AbstractActionProxy() { + @Override + public List getRequiredAfterTriggers(LotroGame game, EffectResult effectResult) { + if (TriggerConditions.winsSkirmish(game, effectResult, selectedCharacter)) { + RequiredTriggerAction action = new RequiredTriggerAction(self); + action.setVirtualCardAction(true); + List possibleEffects = new ArrayList(2); + final String freePeoplePlayer = GameUtils.getFreePeoplePlayer(game); + possibleEffects.add( + new AddBurdenEffect(freePeoplePlayer, self, 1)); + possibleEffects.add( + new ExertCharactersEffect(action, self, Filters.ringBearer)); + action.appendEffect( + new ChoiceEffect(action, freePeoplePlayer, possibleEffects)); + return Collections.singletonList(action); + } + return null; + } + })); + } + }); + return action; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_203.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_203.java new file mode 100644 index 000000000..6b3c7631d --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_203.java @@ -0,0 +1,45 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractMinion; +import com.gempukku.lotro.cards.TriggerConditions; +import com.gempukku.lotro.cards.effects.choose.ChooseAndExertCharactersEffect; +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.timing.EffectResult; + +import java.util.Collections; +import java.util.List; + +/** + * Title: *Ulaire Attea, Fallen King of Men + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 6 + * Type: Minion - Nazgul + * Strength: 12 + * Vitality: 3 + * Home: 3 + * Card Number: 1R203 + * Game Text: Fierce. Each time Ulaire Attea wins a skirmish, you may exert a companion bearing a [RINGWRAITH] condition. + */ +public class Card40_203 extends AbstractMinion { + public Card40_203() { + super(6, 12, 3, 3, Race.NAZGUL, Culture.WRAITH, Names.attea, "Fallen King of Men", true); + addKeyword(Keyword.FIERCE); + } + + @Override + public List getOptionalAfterTriggers(String playerId, LotroGame game, EffectResult effectResult, PhysicalCard self) { + if (TriggerConditions.winsSkirmish(game, effectResult, self)) { + OptionalTriggerAction action = new OptionalTriggerAction(self); + action.appendEffect( + new ChooseAndExertCharactersEffect(action, playerId, 1, 1, CardType.COMPANION, Filters.hasAttached(Culture.WRAITH, CardType.CONDITION))); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_204.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_204.java new file mode 100644 index 000000000..54be7a5d6 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_204.java @@ -0,0 +1,53 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractMinion; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.TriggerConditions; +import com.gempukku.lotro.cards.effects.SelfExertEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndDiscardCardsFromPlayEffect; +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.timing.EffectResult; + +import java.util.Collections; +import java.util.List; + +/** + * Title: *Ulaire Cantea, Morgul Predator + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 5 + * Type: Minion - Nazgul + * Strength: 10 + * Vitality: 3 + * Home: 3 + * Card Number: 1R204 + * Game Text: Fierce. At the start of each skirmish involving Ulaire Cantea, you may exert him and spot another Nazgul + * to discard a possession borne by a companion Ulaire Cantea is skirmishing. + */ +public class Card40_204 extends AbstractMinion { + public Card40_204() { + super(5, 10, 3, 3, Race.NAZGUL, Culture.WRAITH, Names.cantea, "Morgul Predator", true); + addKeyword(Keyword.FIERCE); + } + + @Override + public List getOptionalAfterTriggers(String playerId, LotroGame game, EffectResult effectResult, PhysicalCard self) { + if (TriggerConditions.startOfPhase(game, effectResult, Phase.SKIRMISH) + && PlayConditions.canExert(self, game, self, Filters.inSkirmish) + && PlayConditions.canSpot(game, Race.NAZGUL, Filters.not(self))) { + OptionalTriggerAction action = new OptionalTriggerAction(self); + action.appendCost( + new SelfExertEffect(action, self)); + action.appendEffect( + new ChooseAndDiscardCardsFromPlayEffect(action, playerId, 1, 1, + CardType.POSSESSION, Filters.attachedTo(CardType.COMPANION, Filters.inSkirmishAgainst(self)))); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_205.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_205.java new file mode 100644 index 000000000..53be51b6d --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_205.java @@ -0,0 +1,53 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractMinion; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.effects.SelfExertEffect; +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.ChooseAndWoundCharactersEffect; +import com.gempukku.lotro.logic.timing.Action; + +import java.util.Collections; +import java.util.List; + +/** + * Title: *Ulaire Enquea, Morgul Assassin + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 6 + * Type: Minion - Nazgul + * Strength: 11 + * Vitality: 4 + * Home: 3 + * Card Number: 1U205 + * Game Text: Fierce. + * Maneuver: Spot 6 companions (or 5 burdens) and another [RINGWRAITH] minion and exert Ulaire Enquea to wound + * a companion (except the Ring-bearer). + */ +public class Card40_205 extends AbstractMinion { + public Card40_205() { + super(6, 11, 4, 3, Race.NAZGUL, Culture.WRAITH, Names.enquea, "Morgul Assassin", true); + addKeyword(Keyword.FIERCE); + } + + @Override + protected List getExtraPhaseActions(String playerId, LotroGame game, PhysicalCard self) { + if (PlayConditions.canUseShadowCardDuringPhase(game, Phase.MANEUVER, self, 0) + && (PlayConditions.canSpot(game, 6, CardType.COMPANION) || game.getGameState().getBurdens() >= 5) + && PlayConditions.canSpot(game, Culture.WRAITH, CardType.MINION, Filters.not(self)) + && PlayConditions.canSelfExert(self, game)) { + ActivateCardAction action = new ActivateCardAction(self); + action.appendCost( + new SelfExertEffect(action, self)); + action.appendEffect( + new ChooseAndWoundCharactersEffect(action, playerId, 1, 1, CardType.COMPANION, Filters.not(Filters.ringBearer))); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_206.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_206.java new file mode 100644 index 000000000..cb3dbe702 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_206.java @@ -0,0 +1,61 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.*; +import com.gempukku.lotro.cards.effects.ShuffleDeckEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndPlayCardFromDeckEffect; +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.ChooseArbitraryCardsEffect; +import com.gempukku.lotro.logic.timing.EffectResult; + +import java.util.Collection; +import java.util.Collections; +import java.util.List; + +/** + * Title: *Ulaire Lemenya, Shadowy Wraith + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 4 + * Type: Minion - Nazgul + * Strength: 9 + * Vitality: 2 + * Home: 3 + * Card Number: 1U206 + * Game Text: When you play Ulaire Lemenya, you may spot a companion with 3 or less resistance to play a mount from your draw deck on a Nazgul. + */ +public class Card40_206 extends AbstractMinion { + public Card40_206() { + super(4, 9, 2, 3, Race.NAZGUL, Culture.WRAITH, Names.lemenya, "Shadowy Wraith", true); + } + + @Override + public List getOptionalAfterTriggers(final String playerId, LotroGame game, EffectResult effectResult, PhysicalCard self) { + if (TriggerConditions.played(game, effectResult, self) + && PlayConditions.canSpot(game, CardType.COMPANION, Filters.maxResistance(3)) + && PlayConditions.canPlayFromDeck(playerId, game, PossessionClass.MOUNT, ExtraFilters.attachableTo(game, Race.NAZGUL))) { + OptionalTriggerAction action = new OptionalTriggerAction(self); + action.appendEffect( + new ChooseArbitraryCardsEffect(playerId, "Choose card to play", game.getGameState().getDeck(playerId), + Filters.and( + PossessionClass.MOUNT, + ExtraFilters.attachableTo(game, Race.NAZGUL)), 1, 1, true) { + @Override + protected void cardsSelected(LotroGame game, Collection selectedCards) { + if (selectedCards.size() > 0) { + PhysicalCard selectedCard = selectedCards.iterator().next(); + game.getActionsEnvironment().addActionToStack(((AbstractAttachable) selectedCard.getBlueprint()).getPlayCardAction(playerId, game, selectedCard, Race.NAZGUL, 0)); + } + } + }); + action.appendEffect( + new ShuffleDeckEffect(playerId)); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_207.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_207.java new file mode 100644 index 000000000..8be5a6652 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_207.java @@ -0,0 +1,49 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractMinion; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.effects.choose.ChooseAndAssignCharacterToMinionEffect; +import com.gempukku.lotro.cards.effects.choose.ChooseAndAssignMinionToCompanionEffect; +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.timing.Action; + +import java.util.Collections; +import java.util.List; + +/** + * Title: *Ulaire Nelya, Drawn to the Ring + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 5 + * Type: Minion - Nazgul + * Strength: 10 + * Vitality: 3 + * Home: 3 + * Card Number: 1R207 + * Game Text: Fierce. + * Assignment: Spot a companion with 2 or less resistance (except the Ring-bearer) to assign Ulaire Nelya to skirmish that companion. + */ +public class Card40_207 extends AbstractMinion { + public Card40_207() { + super(5, 10, 3, 3, Race.NAZGUL, Culture.WRAITH, Names.nelya, "Drawn to the Ring", true); + addKeyword(Keyword.FIERCE); + } + + @Override + protected List getExtraPhaseActions(String playerId, LotroGame game, PhysicalCard self) { + if (PlayConditions.canUseShadowCardDuringPhase(game, Phase.ASSIGNMENT, self, 0) + && PlayConditions.canSpot(game, self, Filters.notAssignedToSkirmish) + && PlayConditions.canSpot(game, CardType.COMPANION, Filters.maxResistance(2), Filters.not(Filters.ringBearer))) { + ActivateCardAction action = new ActivateCardAction(self); + action.appendEffect( + new ChooseAndAssignCharacterToMinionEffect(action, playerId, self, CardType.COMPANION, Filters.maxResistance(2), Filters.not(Filters.ringBearer))); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_208.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_208.java new file mode 100644 index 000000000..cc5268f36 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_208.java @@ -0,0 +1,59 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractMinion; +import com.gempukku.lotro.cards.PlayConditions; +import com.gempukku.lotro.cards.effects.AddUntilEndOfPhaseModifierEffect; +import com.gempukku.lotro.cards.effects.SelfExertEffect; +import com.gempukku.lotro.cards.modifiers.FpSkirmishResistanceStrengthOverrideModifier; +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.ChooseActiveCardEffect; +import com.gempukku.lotro.logic.timing.Action; + +import java.util.Collections; +import java.util.List; + +/** + * Title: *Ulaire Nertea, Morgul Fiend + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 4 + * Type: Minion - Nazgul + * Strength: 9 + * Vitality: 2 + * Home: 3 + * Card Number: 1U208 + * Game Text: Skirmish: Exert Ulaire Nertea at a forest site to make a character he is skirmishing use resistance + * instead of strength to resolve this skirmish. + */ +public class Card40_208 extends AbstractMinion { + public Card40_208() { + super(4, 9, 2, 3, Race.NAZGUL, Culture.WRAITH, Names.nertea, "Morgul Fiend", true); + } + + @Override + protected List getExtraPhaseActions(String playerId, LotroGame game, final PhysicalCard self) { + if (PlayConditions.canUseShadowCardDuringPhase(game, Phase.SKIRMISH, self, 0) + && PlayConditions.canSelfExert(self, game) + && PlayConditions.location(game, Keyword.FOREST)) { + final ActivateCardAction action = new ActivateCardAction(self); + action.appendCost( + new SelfExertEffect(action, self)); + action.appendEffect( + new ChooseActiveCardEffect(self, playerId, "Choose a character", Filters.character, Filters.inSkirmishAgainst(self)) { + @Override + protected void cardSelected(LotroGame game, PhysicalCard card) { + action.appendEffect( + new AddUntilEndOfPhaseModifierEffect( + new FpSkirmishResistanceStrengthOverrideModifier(self, card, null))); + } + }); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_209.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_209.java new file mode 100644 index 000000000..36ab44df8 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_209.java @@ -0,0 +1,40 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractMinion; +import com.gempukku.lotro.cards.modifiers.ResistanceModifier; +import com.gempukku.lotro.common.CardType; +import com.gempukku.lotro.common.Culture; +import com.gempukku.lotro.common.Names; +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 java.util.Collections; +import java.util.List; + +/** + * Title: *Ulaire Otsea, Shadowy Servent + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 4 + * Type: Minion - Nazgul + * Strength: 9 + * Vitality: 2 + * Home: 3 + * Card Number: 1U209 + * Game Text: Each companion bearing a [RINGRWAITH] condition is resistance -2. + */ +public class Card40_209 extends AbstractMinion { + public Card40_209() { + super(4, 9, 2, 3, Race.NAZGUL, Culture.WRAITH, Names.otsea, "Shadowy Servent", true); + } + + @Override + public List getAlwaysOnModifiers(LotroGame game, PhysicalCard self) { + ResistanceModifier modifier = new ResistanceModifier(self, Filters.and(CardType.COMPANION, Filters.hasAttached(Culture.WRAITH, CardType.CONDITION)), -2); + return Collections.singletonList(modifier); + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_210.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_210.java new file mode 100644 index 000000000..ed86706fc --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_210.java @@ -0,0 +1,45 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractMinion; +import com.gempukku.lotro.cards.TriggerConditions; +import com.gempukku.lotro.cards.effects.choose.ChooseAndExertCharactersEffect; +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.timing.EffectResult; + +import java.util.Collections; +import java.util.List; + +/** + * Title: *Ulaire Toldea, Rider in Black + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 6 + * Type: Minion - Nazgul + * Strength: 12 + * Vitality: 3 + * Home: 3 + * Card Number: 1R210 + * Game Text: Fierce. Each time Ulaire Toldea wins a skirmish, you may exert a companion with 3 or less resistance. + */ +public class Card40_210 extends AbstractMinion { + public Card40_210() { + super(6, 12, 3, 3, Race.NAZGUL, Culture.WRAITH, Names.toldea, "Rider in Black", true); + addKeyword(Keyword.FIERCE); + } + + @Override + public List getOptionalAfterTriggers(String playerId, LotroGame game, EffectResult effectResult, PhysicalCard self) { + if (TriggerConditions.winsSkirmish(game, effectResult, self)) { + OptionalTriggerAction action = new OptionalTriggerAction(self); + action.appendEffect( + new ChooseAndExertCharactersEffect(action, playerId, 1, 1, CardType.COMPANION, Filters.maxResistance(3))); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_211.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_211.java new file mode 100644 index 000000000..3228339c4 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_211.java @@ -0,0 +1,60 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractMinion; +import com.gempukku.lotro.cards.TriggerConditions; +import com.gempukku.lotro.cards.effects.AddBurdenEffect; +import com.gempukku.lotro.cards.effects.ChoiceEffect; +import com.gempukku.lotro.cards.effects.ExertCharactersEffect; +import com.gempukku.lotro.common.Culture; +import com.gempukku.lotro.common.Keyword; +import com.gempukku.lotro.common.Names; +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.GameUtils; +import com.gempukku.lotro.logic.actions.RequiredTriggerAction; +import com.gempukku.lotro.logic.timing.Effect; +import com.gempukku.lotro.logic.timing.EffectResult; + +import java.util.ArrayList; +import java.util.Collections; +import java.util.List; + +/** + * Title: *The Witch-king, Greatest of the Nine + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 8 + * Type: Minion - Nazgul + * Strength: 14 + * Vitality: 4 + * Home: 3 + * Card Number: 1R211 + * Game Text: Fierce. Each time The Witch-king wins a skirmish, the Free Peoples player must exert the Ring-bearer or add a burden. + */ +public class Card40_211 extends AbstractMinion { + public Card40_211() { + super(8, 14, 4, 3, Race.NAZGUL, Culture.WRAITH, Names.witchKing, "Greatest of the Nine", true); + addKeyword(Keyword.FIERCE); + } + + @Override + public List getRequiredAfterTriggers(LotroGame game, EffectResult effectResult, PhysicalCard self) { + if (TriggerConditions.winsSkirmish(game, effectResult, self)) { + final String freePeoplePlayer = GameUtils.getFreePeoplePlayer(game); + + RequiredTriggerAction action = new RequiredTriggerAction(self); + List possibleEffects = new ArrayList(2); + possibleEffects.add( + new AddBurdenEffect(freePeoplePlayer, self, 1)); + possibleEffects.add( + new ExertCharactersEffect(action, self, Filters.ringBearer)); + action.appendEffect( + new ChoiceEffect(action, freePeoplePlayer, possibleEffects)); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_212.java b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_212.java new file mode 100644 index 000000000..6e7078e82 --- /dev/null +++ b/gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set40/wraith/Card40_212.java @@ -0,0 +1,48 @@ +package com.gempukku.lotro.cards.set40.wraith; + +import com.gempukku.lotro.cards.AbstractResponseEvent; +import com.gempukku.lotro.cards.TriggerConditions; +import com.gempukku.lotro.cards.actions.PlayEventAction; +import com.gempukku.lotro.cards.effects.choose.ChooseAndReturnCardsToHandEffect; +import com.gempukku.lotro.common.Culture; +import com.gempukku.lotro.common.Race; +import com.gempukku.lotro.common.Side; +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.KillEffect; +import com.gempukku.lotro.logic.timing.Effect; + +import java.util.Collections; +import java.util.List; + +import static com.gempukku.lotro.common.Race.NAZGUL; + +/** + * Title: You Cannot Kill Them + * Set: Second Edition + * Side: Shadow + * Culture: Ringwraith + * Twilight Cost: 1 + * Type: Event - Response + * Card Number: 1U212 + * Game Text: If a Nazgul is about to be killed, return that Nazgul to your hand. + */ +public class Card40_212 extends AbstractResponseEvent { + public Card40_212() { + super(Side.SHADOW, 1, Culture.WRAITH, "You Cannot Kill Them"); + } + + @Override + public List getOptionalBeforeActions(String playerId, LotroGame game, Effect effect, PhysicalCard self) { + if (TriggerConditions.isGettingKilled(effect, game, NAZGUL) + && checkPlayRequirements(playerId, game, self, 0, 0, false, false)) { + KillEffect killEffect = (KillEffect) effect; + PlayEventAction action = new PlayEventAction(self); + action.appendEffect( + new ChooseAndReturnCardsToHandEffect(action, playerId, 1, 1, Filters.in(killEffect.getCharactersToBeKilled()), NAZGUL)); + return Collections.singletonList(action); + } + return null; + } +} diff --git a/gemp-lotr/gemp-lotr-cards/src/main/resources/blueprintMapping.txt b/gemp-lotr/gemp-lotr-cards/src/main/resources/blueprintMapping.txt index 793fee7d6..51ed85e0e 100644 --- a/gemp-lotr/gemp-lotr-cards/src/main/resources/blueprintMapping.txt +++ b/gemp-lotr/gemp-lotr-cards/src/main/resources/blueprintMapping.txt @@ -244,4 +244,12 @@ gl_theOneRing,1_2 40_119,1_114 40_136,1_133 40_158,1_166 -40_159,2_59 \ No newline at end of file +40_159,2_59 +40_183,1_207 +40_185,1_209 +40_186,1_210 +40_189,11_212 +40_190,1_216 +40_191,1_217 +40_192,1_218 +40_200,2_80 \ No newline at end of file diff --git a/gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/effects/CorruptRingBearerEffect.java b/gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/effects/CorruptRingBearerEffect.java index 0f0d5a882..3a4443ff8 100644 --- a/gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/effects/CorruptRingBearerEffect.java +++ b/gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/effects/CorruptRingBearerEffect.java @@ -1,11 +1,16 @@ -package com.gempukku.lotro.logic.effects; - -import com.gempukku.lotro.game.state.LotroGame; -import com.gempukku.lotro.logic.timing.UnrespondableEffect; - -public class CorruptRingBearerEffect extends UnrespondableEffect { - @Override - public void doPlayEffect(LotroGame game) { - game.playerLost(game.getGameState().getCurrentPlayerId(), "The Ring-Bearer is corrupted by a card effect"); - } -} +package com.gempukku.lotro.logic.effects; + +import com.gempukku.lotro.game.state.LotroGame; +import com.gempukku.lotro.logic.timing.UnrespondableEffect; + +public class CorruptRingBearerEffect extends UnrespondableEffect { + @Override + public void doPlayEffect(LotroGame game) { + game.playerLost(game.getGameState().getCurrentPlayerId(), "The Ring-Bearer is corrupted by a card effect"); + } + + @Override + public String getText(LotroGame game) { + return "Corrupt the Ring-Bearer"; + } +} diff --git a/gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/EffectResult.java b/gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/EffectResult.java index d285b5107..793389bff 100644 --- a/gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/EffectResult.java +++ b/gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/EffectResult.java @@ -1,75 +1,77 @@ -package com.gempukku.lotro.logic.timing; - -import com.gempukku.lotro.logic.actions.OptionalTriggerAction; - -import java.util.HashSet; -import java.util.Set; - -public abstract class EffectResult { - private Set _optionalTriggersUsed = new HashSet(); - - public enum Type { - // Translated to new format - ANY_NUMBER_KILLED, FOR_EACH_KILLED, FOR_EACH_HEALED, - FOR_EACH_WOUNDED, FOR_EACH_EXERTED, FOR_EACH_DISCARDED_FROM_PLAY, - FOR_EACH_RETURNED_TO_HAND, - - FOR_EACH_DISCARDED_FROM_HAND, - - FREE_PEOPLE_PLAYER_STARTS_ASSIGNING, - SKIRMISH_ABOUT_TO_END, - THREAT_WOUND_TRIGGER, - - INITIATIVE_CHANGE, - - WHEN_MOVE_FROM, WHEN_FELLOWSHIP_MOVES, WHEN_MOVE_TO, - - START_OF_PHASE, - END_OF_PHASE, - - START_OF_TURN, - END_OF_TURN, - - AFTER_ALL_SKIRMISHES, - - RECONCILE, - - ZERO_VITALITY, - - PLAY, ACTIVATE, - - DRAW_CARD_OR_PUT_INTO_HAND, - - PUT_ON_THE_ONE_RING, - - REMOVE_BURDEN, ADD_BURDEN, ADD_THREAT, - - REVEAL_CARDS_FROM_HAND, REVEAL_CARDS_FROM_TOP_OF_DECK, - - SKIRMISH_FINISHED_WITH_OVERWHELM, SKIRMISH_FINISHED_NORMALLY, - - CHARACTER_WON_SKIRMISH, CHARACTER_LOST_SKIRMISH, - - ASSIGNED_AGAINST, ASSIGNED_TO_SKIRMISH, CARD_TRANSFERRED, - - REPLACE_SITE, TAKE_CONTROL_OF_SITE - } - - private Type _type; - - protected EffectResult(Type type) { - _type = type; - } - - public Type getType() { - return _type; - } - - public void optionalTriggerUsed(OptionalTriggerAction action) { - _optionalTriggersUsed.add(action.getTriggerIdentifier()); - } - - public boolean wasOptionalTriggerUsed(OptionalTriggerAction action) { - return _optionalTriggersUsed.contains(action.getTriggerIdentifier()); - } -} +package com.gempukku.lotro.logic.timing; + +import com.gempukku.lotro.logic.actions.OptionalTriggerAction; + +import java.util.HashSet; +import java.util.Set; + +public abstract class EffectResult { + private Set _optionalTriggersUsed = new HashSet(); + + public enum Type { + // Translated to new format + ANY_NUMBER_KILLED, FOR_EACH_KILLED, FOR_EACH_HEALED, + FOR_EACH_WOUNDED, FOR_EACH_EXERTED, FOR_EACH_DISCARDED_FROM_PLAY, + FOR_EACH_RETURNED_TO_HAND, + + FOR_EACH_DISCARDED_FROM_HAND, + + FREE_PEOPLE_PLAYER_STARTS_ASSIGNING, + SKIRMISH_ABOUT_TO_END, + THREAT_WOUND_TRIGGER, + + INITIATIVE_CHANGE, + + WHEN_MOVE_FROM, WHEN_FELLOWSHIP_MOVES, WHEN_MOVE_TO, + + START_OF_PHASE, + END_OF_PHASE, + + START_OF_TURN, + END_OF_TURN, + + AFTER_ALL_SKIRMISHES, + + RECONCILE, + + SKIRMISH_CANCELLED, + + ZERO_VITALITY, + + PLAY, ACTIVATE, + + DRAW_CARD_OR_PUT_INTO_HAND, + + PUT_ON_THE_ONE_RING, + + REMOVE_BURDEN, ADD_BURDEN, ADD_THREAT, + + REVEAL_CARDS_FROM_HAND, REVEAL_CARDS_FROM_TOP_OF_DECK, + + SKIRMISH_FINISHED_WITH_OVERWHELM, SKIRMISH_FINISHED_NORMALLY, + + CHARACTER_WON_SKIRMISH, CHARACTER_LOST_SKIRMISH, + + ASSIGNED_AGAINST, ASSIGNED_TO_SKIRMISH, CARD_TRANSFERRED, + + REPLACE_SITE, TAKE_CONTROL_OF_SITE + } + + private Type _type; + + protected EffectResult(Type type) { + _type = type; + } + + public Type getType() { + return _type; + } + + public void optionalTriggerUsed(OptionalTriggerAction action) { + _optionalTriggersUsed.add(action.getTriggerIdentifier()); + } + + public boolean wasOptionalTriggerUsed(OptionalTriggerAction action) { + return _optionalTriggersUsed.contains(action.getTriggerIdentifier()); + } +} diff --git a/gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/results/SkirmishCancelledResult.java b/gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/results/SkirmishCancelledResult.java new file mode 100644 index 000000000..9b1043a91 --- /dev/null +++ b/gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/results/SkirmishCancelledResult.java @@ -0,0 +1,17 @@ +package com.gempukku.lotro.logic.timing.results; + +import com.gempukku.lotro.game.PhysicalCard; +import com.gempukku.lotro.logic.timing.EffectResult; + +public class SkirmishCancelledResult extends EffectResult { + public PhysicalCard fpCharacter; + + public SkirmishCancelledResult(PhysicalCard fpCharacter) { + super(Type.SKIRMISH_CANCELLED); + this.fpCharacter = fpCharacter; + } + + public PhysicalCard getFpCharacter() { + return fpCharacter; + } +}