Work in progress on simplifying turn procedure and allowing the Skirmish phase to pop up, out of a sudden.

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/effects/ResolveSkirmishEffect.java

@@ -15,16 +15,10 @@ import java.util.List;
 import java.util.Set;
 
 public class ResolveSkirmishEffect extends AbstractEffect {
-    private Skirmish _skirmish;
-
     public enum Result {
         FELLOWSHIP_OVERWHELMED, FELLOWSHIP_LOSES, SHADOW_LOSES, SHADOW_OVERWHELMED
     }
 
-    public ResolveSkirmishEffect(Skirmish skirmish) {
-        _skirmish = skirmish;
-    }
-
     @Override
     public String getText(LotroGame game) {
         return "Resolve skirmish";
@@ -44,7 +38,7 @@ public class ResolveSkirmishEffect extends AbstractEffect {
         int fpStrength = RuleUtils.getFellowshipSkirmishStrength(game);
         int shadowStrength = RuleUtils.getShadowSkirmishStrength(game);
 
-        final PhysicalCard fellowshipCharacter = _skirmish.getFellowshipCharacter();
+        final PhysicalCard fellowshipCharacter = game.getGameState().getSkirmish().getFellowshipCharacter();
 
         int multiplier = 2;
         if (fellowshipCharacter != null)
@@ -63,21 +57,23 @@ public class ResolveSkirmishEffect extends AbstractEffect {
 
     @Override
     protected FullEffectResult playEffectReturningResult(LotroGame game) {
+        Skirmish skirmish = game.getGameState().getSkirmish();
+
         Result result = getUpcomingResult(game);
         Set<EffectResult> results = new HashSet<EffectResult>();
 
         if (result == Result.FELLOWSHIP_LOSES) {
             game.getGameState().sendMessage("Skirmish finishes with a normal win");
-            results.add(new NormalSkirmishResult(_skirmish.getShadowCharacters(), fpList(_skirmish.getFellowshipCharacter()), _skirmish.getRemovedFromSkirmish()));
+            results.add(new NormalSkirmishResult(skirmish.getShadowCharacters(), fpList(skirmish.getFellowshipCharacter()), skirmish.getRemovedFromSkirmish()));
         } else if (result == Result.SHADOW_LOSES) {
             game.getGameState().sendMessage("Skirmish finishes with a normal win");
-            results.add(new NormalSkirmishResult(fpList(_skirmish.getFellowshipCharacter()), _skirmish.getShadowCharacters(), _skirmish.getRemovedFromSkirmish()));
+            results.add(new NormalSkirmishResult(fpList(skirmish.getFellowshipCharacter()), skirmish.getShadowCharacters(), skirmish.getRemovedFromSkirmish()));
         } else if (result == Result.FELLOWSHIP_OVERWHELMED) {
             game.getGameState().sendMessage("Skirmish finishes with an overwhelm");
-            results.add(new OverwhelmSkirmishResult(_skirmish.getShadowCharacters(), fpList(_skirmish.getFellowshipCharacter()), _skirmish.getRemovedFromSkirmish()));
+            results.add(new OverwhelmSkirmishResult(skirmish.getShadowCharacters(), fpList(skirmish.getFellowshipCharacter()), skirmish.getRemovedFromSkirmish()));
         } else {
             game.getGameState().sendMessage("Skirmish finishes with an overwhelm");
-            results.add(new OverwhelmSkirmishResult(fpList(_skirmish.getFellowshipCharacter()), _skirmish.getShadowCharacters(), _skirmish.getRemovedFromSkirmish()));
+            results.add(new OverwhelmSkirmishResult(fpList(skirmish.getFellowshipCharacter()), skirmish.getShadowCharacters(), skirmish.getRemovedFromSkirmish()));
         }
 
         return new FullEffectResult(results, true, true);

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/effects/StackActionEffect.java

@@ -0,0 +1,18 @@
+package com.gempukku.lotro.logic.effects;
+
+import com.gempukku.lotro.game.state.LotroGame;
+import com.gempukku.lotro.logic.timing.Action;
+import com.gempukku.lotro.logic.timing.UnrespondableEffect;
+
+public class StackActionEffect extends UnrespondableEffect {
+    private Action _action;
+
+    public StackActionEffect(Action action) {
+        _action = action;
+    }
+
+    @Override
+    protected void doPlayEffect(LotroGame game) {
+        game.getActionsEnvironment().addActionToStack(_action);
+    }
+}

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/actions/ResolveSkirmishAction.java

@@ -3,12 +3,10 @@ package com.gempukku.lotro.logic.timing.actions;
 import com.gempukku.lotro.common.Phase;
 import com.gempukku.lotro.game.PhysicalCard;
 import com.gempukku.lotro.game.state.LotroGame;
-import com.gempukku.lotro.game.state.Skirmish;
 import com.gempukku.lotro.logic.effects.ResolveSkirmishEffect;
 import com.gempukku.lotro.logic.effects.TriggeringResultEffect;
 import com.gempukku.lotro.logic.timing.Action;
 import com.gempukku.lotro.logic.timing.Effect;
-import com.gempukku.lotro.logic.timing.UnrespondableEffect;
 import com.gempukku.lotro.logic.timing.results.SkirmishAboutToEndResult;
 
 import java.util.Iterator;
@@ -16,16 +14,8 @@ import java.util.LinkedList;
 import java.util.List;
 
 public class ResolveSkirmishAction implements Action {
-    private LotroGame _game;
-    private Skirmish _skirmish;
-
     Iterator<Effect> _effects;
 
-    public ResolveSkirmishAction(LotroGame game, Skirmish skirmish) {
-        _game = game;
-        _skirmish = skirmish;
-    }
-
     @Override
     public Phase getActionTimeword() {
         return null;
@@ -74,17 +64,10 @@ public class ResolveSkirmishAction implements Action {
     private Iterator<Effect> resolveSkirmish() {
         List<Effect> effects = new LinkedList<Effect>();
 
-        effects.add(new ResolveSkirmishEffect(_skirmish));
+        effects.add(new ResolveSkirmishEffect());
 
         effects.add(new TriggeringResultEffect(new SkirmishAboutToEndResult(), "Skirmish about to end"));
 
-        effects.add(new UnrespondableEffect() {
-            @Override
-            public void doPlayEffect(LotroGame game) {
-                game.getGameState().finishSkirmish();
-            }
-        });
-
         return effects.iterator();
     }
 }

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/actions/SkirmishActionProcedureAction.java

@@ -0,0 +1,88 @@
+package com.gempukku.lotro.logic.timing.actions;
+
+import com.gempukku.lotro.game.state.LotroGame;
+import com.gempukku.lotro.game.state.Skirmish;
+import com.gempukku.lotro.logic.PlayOrder;
+import com.gempukku.lotro.logic.actions.SystemQueueAction;
+import com.gempukku.lotro.logic.decisions.CardActionSelectionDecision;
+import com.gempukku.lotro.logic.decisions.DecisionResultInvalidException;
+import com.gempukku.lotro.logic.timing.Action;
+import com.gempukku.lotro.logic.timing.UnrespondableEffect;
+
+import java.util.List;
+
+public class SkirmishActionProcedureAction extends SystemQueueAction {
+    public SkirmishActionProcedureAction() {
+        appendEffect(
+                new StartPlayingActionsEffect());
+    }
+
+    private class StartPlayingActionsEffect extends UnrespondableEffect {
+        @Override
+        protected void doPlayEffect(LotroGame game) {
+            PlayOrder playOrder = game.getGameState().getPlayerOrder().getCounterClockwisePlayOrder(game.getGameState().getCurrentPlayerId(), true);
+            appendEffect(
+                    new CheckIfSkirmishFinishedEffect(playOrder, 0));
+        }
+    }
+
+    private class CheckIfSkirmishFinishedEffect extends UnrespondableEffect {
+        private PlayOrder _playOrder;
+        private int _consecutivePasses;
+
+        private CheckIfSkirmishFinishedEffect(PlayOrder playOrder, int consecutivePasses) {
+            _playOrder = playOrder;
+            _consecutivePasses = consecutivePasses;
+        }
+
+        @Override
+        protected void doPlayEffect(LotroGame game) {
+            Skirmish skirmish = game.getGameState().getSkirmish();
+            if (!game.getGameState().getSkirmish().isCancelled()
+                    && skirmish.getFellowshipCharacter() != null && skirmish.getShadowCharacters().size() > 0) {
+                appendEffect(
+                        new PlayerPlaysNextActionEffect(_playOrder, _consecutivePasses));
+            }
+        }
+    }
+
+    private class PlayerPlaysNextActionEffect extends UnrespondableEffect {
+        private PlayOrder _playOrder;
+        private int _consecutivePasses;
+
+        private PlayerPlaysNextActionEffect(PlayOrder playOrder, int consecutivePasses) {
+            _playOrder = playOrder;
+            _consecutivePasses = consecutivePasses;
+        }
+
+        @Override
+        protected void doPlayEffect(final LotroGame game) {
+            String playerId;
+            if (game.getGameState().isConsecutiveAction()) {
+                playerId = _playOrder.getLastPlayer();
+                game.getGameState().setConsecutiveAction(false);
+            } else {
+                playerId = _playOrder.getNextPlayer();
+            }
+
+            final List<Action> playableActions = game.getActionsEnvironment().getPhaseActions(playerId);
+
+            game.getUserFeedback().sendAwaitingDecision(playerId,
+                    new CardActionSelectionDecision(game, 1, "Choose action to play or Pass", playableActions, true) {
+                        @Override
+                        public void decisionMade(String result) throws DecisionResultInvalidException {
+                            Action action = getSelectedAction(result);
+                            if (action != null) {
+                                appendEffect(
+                                        new CheckIfSkirmishFinishedEffect(_playOrder, 0));
+                                game.getActionsEnvironment().addActionToStack(action);
+                            } else {
+                                if (_consecutivePasses + 1 < _playOrder.getPlayerCount())
+                                    appendEffect(
+                                            new PlayerPlaysNextActionEffect(_playOrder, _consecutivePasses + 1));
+                            }
+                        }
+                    });
+        }
+    }
+}

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/actions/SkirmishPhaseAction.java

@@ -0,0 +1,63 @@
+package com.gempukku.lotro.logic.timing.actions;
+
+import com.gempukku.lotro.common.Phase;
+import com.gempukku.lotro.game.PhysicalCard;
+import com.gempukku.lotro.game.state.LotroGame;
+import com.gempukku.lotro.game.state.actions.DefaultActionsEnvironment;
+import com.gempukku.lotro.logic.actions.SystemQueueAction;
+import com.gempukku.lotro.logic.effects.ResolveSkirmishEffect;
+import com.gempukku.lotro.logic.effects.StackActionEffect;
+import com.gempukku.lotro.logic.effects.TriggeringResultEffect;
+import com.gempukku.lotro.logic.modifiers.ModifiersLogic;
+import com.gempukku.lotro.logic.timing.UnrespondableEffect;
+import com.gempukku.lotro.logic.timing.results.EndOfPhaseResult;
+import com.gempukku.lotro.logic.timing.results.SkirmishAboutToEndResult;
+import com.gempukku.lotro.logic.timing.results.StartOfPhaseResult;
+
+public class SkirmishPhaseAction extends SystemQueueAction {
+    public SkirmishPhaseAction(final PhysicalCard character) {
+        appendEffect(
+                new UnrespondableEffect() {
+                    @Override
+                    protected void doPlayEffect(LotroGame game) {
+                        game.getGameState().startSkirmish(character);
+                        ((ModifiersLogic) game.getModifiersEnvironment()).removeStartOfPhase(Phase.SKIRMISH);
+                        ((DefaultActionsEnvironment) game.getActionsEnvironment()).removeStartOfPhaseActionProxies(Phase.SKIRMISH);
+                    }
+                });
+        appendEffect(
+                new TriggeringResultEffect(null, new StartOfPhaseResult(Phase.SKIRMISH), "Start of skirmish phase"));
+        appendEffect(
+                new StackActionEffect(
+                        new SkirmishActionProcedureAction()));
+        appendEffect(
+                new UnrespondableEffect() {
+                    @Override
+                    protected void doPlayEffect(LotroGame game) {
+                        if (!game.getGameState().getSkirmish().isCancelled()) {
+                            insertEffect(
+                                    new ResolveSkirmishEffect(),
+                                    new TriggeringResultEffect(new SkirmishAboutToEndResult(), "Skirmish about to end"));
+                        }
+                    }
+                });
+        appendEffect(
+                new UnrespondableEffect() {
+                    @Override
+                    protected void doPlayEffect(LotroGame game) {
+                        game.getGameState().finishSkirmish();
+                    }
+                });
+
+        appendEffect(
+                new TriggeringResultEffect(null, new EndOfPhaseResult(Phase.SKIRMISH), "End of skirmish phase"));
+        appendEffect(
+                new UnrespondableEffect() {
+                    @Override
+                    protected void doPlayEffect(LotroGame game) {
+                        ((ModifiersLogic) game.getModifiersEnvironment()).removeEndOfPhase(Phase.SKIRMISH);
+                        ((DefaultActionsEnvironment) game.getActionsEnvironment()).removeEndOfPhaseActionProxies(Phase.SKIRMISH);
+                    }
+                });
+    }
+}

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/processes/turn/SkirmishGameProcess.java

@@ -1,32 +0,0 @@
-package com.gempukku.lotro.logic.timing.processes.turn;
-
-import com.gempukku.lotro.common.Phase;
-import com.gempukku.lotro.game.state.LotroGame;
-import com.gempukku.lotro.logic.timing.processes.GameProcess;
-import com.gempukku.lotro.logic.timing.processes.turn.general.EndOfPhaseGameProcess;
-import com.gempukku.lotro.logic.timing.processes.turn.general.PlayersPlayPhaseActionsInOrderGameProcess;
-import com.gempukku.lotro.logic.timing.processes.turn.general.StartOfPhaseGameProcess;
-import com.gempukku.lotro.logic.timing.processes.turn.skirmish.ResolveSkirmishGameProcess;
-
-public class SkirmishGameProcess implements GameProcess {
-    private LotroGame _game;
-    private GameProcess _followingGameProcess;
-
-    public SkirmishGameProcess(LotroGame game, GameProcess followingGameProcess) {
-        _game = game;
-        _followingGameProcess = followingGameProcess;
-    }
-
-    @Override
-    public void process(LotroGame game) {
-
-    }
-
-    @Override
-    public GameProcess getNextProcess() {
-        return new StartOfPhaseGameProcess(_game, Phase.SKIRMISH,
-                new PlayersPlayPhaseActionsInOrderGameProcess(_game, _game.getGameState().getPlayerOrder().getCounterClockwisePlayOrder(_game.getGameState().getCurrentPlayerId(), true), 0,
-                        new ResolveSkirmishGameProcess(_game,
-                                new EndOfPhaseGameProcess(_game, Phase.SKIRMISH, _followingGameProcess))));
-    }
-}

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/processes/turn/skirmish/PlayoutSkirmishesGameProcess.java

@@ -9,8 +9,8 @@ import com.gempukku.lotro.game.state.LotroGame;
 import com.gempukku.lotro.logic.actions.SystemQueueAction;
 import com.gempukku.lotro.logic.effects.ChooseActiveCardEffect;
 import com.gempukku.lotro.logic.modifiers.ModifierFlag;
+import com.gempukku.lotro.logic.timing.actions.SkirmishPhaseAction;
 import com.gempukku.lotro.logic.timing.processes.GameProcess;
-import com.gempukku.lotro.logic.timing.processes.turn.SkirmishGameProcess;
 
 import java.util.HashSet;
 import java.util.List;
@@ -49,9 +49,8 @@ public class PlayoutSkirmishesGameProcess implements GameProcess {
                 ChooseActiveCardEffect chooseNextSkirmish = new ChooseActiveCardEffect(null, playerChoosingSkirmishOrder, "Choose next skirmish to resolve", Filters.in(fps)) {
                     @Override
                     protected void cardSelected(LotroGame game, PhysicalCard card) {
-                        gameState.startSkirmish(card);
-
-                        _nextProcess = new SkirmishGameProcess(_game, new PlayoutSkirmishesGameProcess(_game, _followingGameProcess));
+                        game.getActionsEnvironment().addActionToStack(
+                                new SkirmishPhaseAction(card));
                     }
                 };
                 chooseNextSkirmish.setUseShortcut(false);
@@ -59,6 +58,7 @@ public class PlayoutSkirmishesGameProcess implements GameProcess {
                 chooseNextSkirmishAction.appendEffect(chooseNextSkirmish);
 
                 _game.getActionsEnvironment().addActionToStack(chooseNextSkirmishAction);
+                _nextProcess = this;
             } else {
                 _nextProcess = _followingGameProcess;
             }

gemp-lotr/gemp-lotr-logic/src/main/java/com/gempukku/lotro/logic/timing/processes/turn/skirmish/ResolveSkirmishGameProcess.java

@@ -1,30 +0,0 @@
-package com.gempukku.lotro.logic.timing.processes.turn.skirmish;
-
-import com.gempukku.lotro.game.state.LotroGame;
-import com.gempukku.lotro.game.state.Skirmish;
-import com.gempukku.lotro.logic.timing.actions.ResolveSkirmishAction;
-import com.gempukku.lotro.logic.timing.processes.GameProcess;
-
-public class ResolveSkirmishGameProcess implements GameProcess {
-    private LotroGame _game;
-    private GameProcess _followingGameProcess;
-
-    public ResolveSkirmishGameProcess(LotroGame game, GameProcess followingGameProcess) {
-        _game = game;
-        _followingGameProcess = followingGameProcess;
-    }
-
-    @Override
-    public void process(LotroGame game) {
-        Skirmish skirmish = _game.getGameState().getSkirmish();
-        if (!skirmish.isCancelled())
-            _game.getActionsEnvironment().addActionToStack(new ResolveSkirmishAction(_game, skirmish));
-        else
-            _game.getGameState().finishSkirmish();
-    }
-
-    @Override
-    public GameProcess getNextProcess() {
-        return _followingGameProcess;
-    }
-}