"The Tale of the Great Ring"

gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/modifiers/CantBeOverwhelmedModifier.java

@@ -0,0 +1,25 @@
+package com.gempukku.lotro.cards.modifiers;
+
+import com.gempukku.lotro.common.Filterable;
+import com.gempukku.lotro.game.PhysicalCard;
+import com.gempukku.lotro.game.state.GameState;
+import com.gempukku.lotro.logic.modifiers.AbstractModifier;
+import com.gempukku.lotro.logic.modifiers.Condition;
+import com.gempukku.lotro.logic.modifiers.ModifierEffect;
+import com.gempukku.lotro.logic.modifiers.ModifiersQuerying;
+
+public class CantBeOverwhelmedModifier extends AbstractModifier {
+
+    public CantBeOverwhelmedModifier(PhysicalCard source, Filterable affectFilter) {
+        this(source, affectFilter, null);
+    }
+
+    public CantBeOverwhelmedModifier(PhysicalCard source, Filterable affectFilter, Condition condition) {
+        super(source, "Cannot be overwhelmed", affectFilter, condition, ModifierEffect.OVERWHELM_MODIFIER);
+    }
+
+    @Override
+    public int getOverwhelmMultiplier(GameState gameState, ModifiersQuerying modifiersQuerying, PhysicalCard physicalCard) {
+        return Integer.MAX_VALUE;
+    }
+}

gemp-lotr/gemp-lotr-cards/src/main/java/com/gempukku/lotro/cards/set10/shire/Card10_116.java

@@ -0,0 +1,62 @@
+package com.gempukku.lotro.cards.set10.shire;
+
+import com.gempukku.lotro.cards.AbstractPermanent;
+import com.gempukku.lotro.cards.PlayConditions;
+import com.gempukku.lotro.cards.effects.AddUntilEndOfPhaseModifierEffect;
+import com.gempukku.lotro.cards.modifiers.CantBeOverwhelmedModifier;
+import com.gempukku.lotro.common.*;
+import com.gempukku.lotro.filters.Filters;
+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.actions.ActivateCardAction;
+import com.gempukku.lotro.logic.effects.ChooseActiveCardEffect;
+import com.gempukku.lotro.logic.effects.DiscardCardsFromPlayEffect;
+import com.gempukku.lotro.logic.modifiers.Condition;
+import com.gempukku.lotro.logic.modifiers.ModifiersQuerying;
+import com.gempukku.lotro.logic.timing.Action;
+
+import java.util.Collections;
+import java.util.List;
+
+/**
+ * Set: Mount Doom
+ * Side: Free
+ * Culture: Shire
+ * Twilight Cost: 0
+ * Type: Condition • Support Area
+ * Game Text: Tale. Skirmish: Prevent a Hobbit from being overwhelmed unless a Shadow event is (or was) played during
+ * this skirmish. Discard this condition.
+ */
+public class Card10_116 extends AbstractPermanent {
+    public Card10_116() {
+        super(Side.FREE_PEOPLE, 0, CardType.CONDITION, Culture.SHIRE, Zone.SUPPORT, "The Tale of the Great Ring", true);
+        addKeyword(Keyword.TALE);
+    }
+
+    @Override
+    protected List<? extends Action> getExtraPhaseActions(String playerId, LotroGame game, final PhysicalCard self) {
+        if (PlayConditions.canUseFPCardDuringPhase(game, Phase.SKIRMISH, self)) {
+            final ActivateCardAction action = new ActivateCardAction(self);
+            action.appendEffect(
+                    new ChooseActiveCardEffect(self, playerId, "Choose a Hobbit", Race.HOBBIT) {
+                        @Override
+                        protected void cardSelected(final LotroGame game, PhysicalCard card) {
+                            action.insertEffect(
+                                    new AddUntilEndOfPhaseModifierEffect(
+                                            new CantBeOverwhelmedModifier(self, card,
+                                                    new Condition() {
+                                                        @Override
+                                                        public boolean isFullfilled(GameState gameState, ModifiersQuerying modifiersQuerying) {
+                                                            return Filters.filter(game.getActionsEnvironment().getPlayedCardsInCurrentPhase(), gameState, modifiersQuerying, Side.SHADOW, CardType.EVENT).size() == 0;
+                                                        }
+                                                    }), Phase.SKIRMISH));
+                        }
+                    });
+            action.appendEffect(
+                    new DiscardCardsFromPlayEffect(self, self));
+            return Collections.singletonList(action);
+        }
+        return null;
+    }
+}

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/game/ActionsEnvironment.java

@@ -32,4 +32,6 @@ public interface ActionsEnvironment {
     public void addActionToStack(Action action);
 
     public <T extends Action> T findTopmostActionOfType(Class<T> clazz);
+
+    public List<PhysicalCard> getPlayedCardsInCurrentPhase();
 }

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/game/state/actions/DefaultActionsEnvironment.java

@@ -1,10 +1,7 @@
 package com.gempukku.lotro.game.state.actions;
 
 import com.gempukku.lotro.common.Phase;
-import com.gempukku.lotro.game.ActionProxy;
-import com.gempukku.lotro.game.ActionsEnvironment;
-import com.gempukku.lotro.game.CompletePhysicalCardVisitor;
-import com.gempukku.lotro.game.PhysicalCard;
+import com.gempukku.lotro.game.*;
 import com.gempukku.lotro.game.state.LotroGame;
 import com.gempukku.lotro.logic.actions.ActivateCardAction;
 import com.gempukku.lotro.logic.actions.RequiredTriggerAction;
@@ -14,6 +11,7 @@ import com.gempukku.lotro.logic.timing.Effect;
 import com.gempukku.lotro.logic.timing.EffectResult;
 import com.gempukku.lotro.logic.timing.processes.GatherPlayableActionsFromDiscardVisitor;
 import com.gempukku.lotro.logic.timing.processes.GatherPlayableActionsFromStackedVisitor;
+import com.gempukku.lotro.logic.timing.results.PlayCardResult;
 import com.gempukku.lotro.logic.timing.rules.CharacterDeathRule;
 
 import java.util.*;
@@ -26,9 +24,23 @@ public class DefaultActionsEnvironment implements ActionsEnvironment {
     private Map<Phase, List<ActionProxy>> _untilEndOfPhaseActionProxies = new HashMap<Phase, List<ActionProxy>>();
     private List<ActionProxy> _untilEndOfTurnActionProxies = new LinkedList<ActionProxy>();
 
+    private List<PhysicalCard> _playedCardsInPhase = new LinkedList<PhysicalCard>();
+
     public DefaultActionsEnvironment(LotroGame lotroGame, ActionStack actionStack) {
         _lotroGame = lotroGame;
         _actionStack = actionStack;
+
+        addAlwaysOnActionProxy(
+                new AbstractActionProxy() {
+                    @Override
+                    public List<? extends Action> getRequiredAfterTriggers(LotroGame lotroGame, EffectResult effectResults) {
+                        if (effectResults.getType() == EffectResult.Type.PLAY) {
+                            PlayCardResult playResult = (PlayCardResult) effectResults;
+                            _playedCardsInPhase.add(playResult.getPlayedCard());
+                        }
+                        return null;
+                    }
+                });
     }
 
     public void addAlwaysOnActionProxy(ActionProxy actionProxy) {
@@ -49,6 +61,7 @@ public class DefaultActionsEnvironment implements ActionsEnvironment {
             _actionProxies.removeAll(list);
             list.clear();
         }
+        _playedCardsInPhase.clear();
     }
 
     public void removeEndOfTurnActionProxies() {
@@ -237,6 +250,11 @@ public class DefaultActionsEnvironment implements ActionsEnvironment {
         return _actionStack.findTopmostActionOfType(clazz);
     }
 
+    @Override
+    public List<PhysicalCard> getPlayedCardsInCurrentPhase() {
+        return Collections.unmodifiableList(_playedCardsInPhase);
+    }
+
     private class GatherRequiredAfterTriggers extends CompletePhysicalCardVisitor {
         private Collection<? extends EffectResult> _effectResults;
         private List<Action> _actions = new LinkedList<Action>();