public class RollDice extends AbstractAction {
    @Override
    public boolean execute(AbstractGameState gs) {
        CantStopGameState state = (CantStopGameState) gs;
        state.rollDice();
        state.setGamePhase(CantStopGamePhase.Allocation);
        return true;
    }

    @Override
    public AbstractAction copy() {
        return this; // immutable
    }

    @Override
    public boolean equals(Object obj) {
        return obj instanceof RollDice;
    }

    @Override
    public int hashCode() {
        return 929134894;
    }

    @Override
    public String getString(AbstractGameState gameState) {
        return toString();
    }

    @Override
    public String toString() {
        return "Roll Dice";
    }
}

/**
 * This is a mini-ForwardModel that takes temporary control of:
 *      i) which player is currently making a decision (the getCurrentPlayer()),
 *      ii) what actions they have (computeAvailableActions()), and
 *      iii) what happens after an action is taken (_afterAction()).
 * These are the three normal responsibilities of ForwardModel.
 *
 * IExtendedSequence is also responsible for tracking all local state necessary for its set of actions, and marking
 * itself as complete. (ForwardModel will then detect this, and remove it from the Stack of open actions.)
 * This means that - unlike ForwardModel - IExtendedSequence is not stateless, and hence must implement a copy() method.
 * Effectively an IExtendedSequence also incorporates a mini-GameState that tracks game progress within the sequence.
 *
 * ForwardModel retains responsibility for applying all actions (via next()).
 * 
 * The GameState stores a Stack of IExtendedSequences, and the current one is always the one at the top of the stack.
 * This stack is deep-copied whenever the GameState is copied, so that the IExtendedSequences are also copied.
 *
 * To trigger an IExtendedSequence, it is added to the stack by calling:
 *      state.setActionInProgress(sequenceObject)
 * The core framework will then trigger delegation from ForwardModel.
 * 
 * There are two common patterns for IExtendedSequence:
 *     i) Extending an Action directly, so that this then controls the later decisions that are part of the action.
 *     ii) A distinct sub-phase of the game, encapsulating a linked series of decisions.
 * In general the current advice is not to extend an Action directly, but to use the second pattern.
 * For example:
 *      - Player chooses Action A that requires a number of other decisions to be made.
 *      - Action A does not extend IExtendedSequence, but created a new Object (let's call it SubPhaseA) that does.
 *      - in execute() of Action A, it adds SubPhaseA to the stack with state.setActionInProgress(SubPhaseA)
 *      - SubPhaseA then controls the next set of decisions. Once the last decision is taken, SubPhaseA marks itself as complete.
 *
 * It does not need to be the Action that puts the IExtendedSequence on the stack. It could be triggered by any event.
 * Another common pattern is for this to be done in the _afterAction() method of the ForwardModel once certain
 * preconditions for SubPhaseA are met.
 * 
 * After every action is taken, the ForwardModel will check the top of the stack to see if it is finished (and will 
 * continue until it finds one that is not). If it is finished, it will remove it from the stack. 
 */
 */
public interface IExtendedSequence {

    /**
     * Forward Model delegates to this from computeAvailableActions() if this Extended Sequence is currently active.
     *
     * @param state The current game state
     * @return the list of possible actions for the currentPlayer
     */
    List<AbstractAction> _computeAvailableActions(AbstractGameState state);

    /**
     * TurnOrder delegates to this from getCurrentPlayer() if this Extended Sequence is currently active.
     *
     * @param state The current game state
     * @return The player Id whose move it is
     */
    int getCurrentPlayer(AbstractGameState state);

    /**
     * This is called by ForwardModel whenever an action has just been taken. It enables the IExtendedSequence
     * to maintain local state in whichever way is most suitable.
     * It is called as well as (and before) the _afterAction method on the ForwardModel.
     * This means that ForwardModel._afterAction() may need check to see if an action is in progress and skip
     * its own logic in this case:
     *          if (state.isActionInProgress()) continue;
     * This line of code has not yet been incorporated into the framework due to a couple of older games.
     *
     * After this call, the state of IExtendedSequence should be correct ahead of the next decision to be made.
     * In some cases there is no need to implement anything in this method - if for example you can tell if all
     * actions are complete from the state directly, then that can be implemented purely in executionComplete()
     *
     *
     * @param state The current game state
     * @param action The action just taken 
     */
    void _afterAction(AbstractGameState state, AbstractAction action);

    /**
     * Return true if this extended sequence has now completed and there is nothing left to do.
     *
     * @param state The current game state
     * @return True if all decisions are now complete
     */
    boolean executionComplete(AbstractGameState state);

    /**
     * Usual copy() standards apply.
     * NO REFERENCES TO COMPONENTS TO BE KEPT, PRIMITIVE TYPES ONLY.
     *
     * @return a copy of the Object
     */
    IExtendedSequence copy();
}

public class Artisan extends DominionAction implements IExtendedSequence {
    public Artisan(int playerId) {
        super(CardType.ARTISAN, playerId);
    }
    public Artisan(int playerId, boolean dummy) {
        super(CardType.ARTISAN, playerId, dummy);
    }

    public final int MAX_COST_OF_GAINED_CARD = 5;

    public boolean gainedCard;
    public boolean putCardOnDeck;

    @Override
    boolean _execute(DominionGameState state) {
        state.setActionInProgress(this);
        return true;
    }

    @Override
    public List<AbstractAction> _computeAvailableActions(AbstractGameState gs) {
        DominionGameState state = (DominionGameState) gs;
        if (!gainedCard) {
            return state.cardsToBuy().stream()
                    .filter(c -> c.cost <= MAX_COST_OF_GAINED_CARD)
                    .map(c -> new GainCard(c, player, DeckType.HAND))
                    .collect(toList());
        } else {
            return state.getDeck(DeckType.HAND, player).stream()
                    .map(c -> new MoveCard(c.cardType(), player, DeckType.HAND, player, DeckType.DRAW, false))
                    .distinct()
                    .collect(toList());
        }
    }

    @Override
    public int getCurrentPlayer(AbstractGameState state) {
        return player;
    }

    @Override
    public void _afterAction(AbstractGameState state, AbstractAction action) {
        if (action instanceof GainCard && ((GainCard) action).buyingPlayer == player)
            gainedCard = true;
        if (action instanceof MoveCard && ((MoveCard) action).playerFrom == player)
            putCardOnDeck = true;
    }

    @Override
    public boolean executionComplete(AbstractGameState state) {
        return gainedCard && putCardOnDeck;
    }

    @Override
    public Artisan copy() {
        Artisan retValue = new Artisan(player, dummyAction);
        retValue.putCardOnDeck = putCardOnDeck;
        retValue.gainedCard = gainedCard;
        return retValue;
    }

    @Override
    public boolean equals(Object obj) {
        if (obj instanceof Artisan) {
            Artisan other = (Artisan) obj;
            return other.gainedCard == gainedCard && other.putCardOnDeck == putCardOnDeck && super.equals(obj);
        }
        return false;
    }

    @Override
    public int hashCode() {
        return Objects.hash(gainedCard, putCardOnDeck) + 31 * super.hashCode();
    }
}

Stack<IExtendedSequence> actionsInProgress = new Stack<>();

protected List<AbstractAction> _computeAvailableActions(AbstractGameState state) {

    if (state.isActionInProgress()) {
    	return state.actionsInProgress.peek().followOnActions(state);
    }
    ...

    protected void _next(AbstractGameState currentState, AbstractAction action) {
        _beforeAction(currentState, action);
        if (action != null) {
            action.execute(currentState);
        } else {
            throw new AssertionError("No action selected by current player");
        }
        // We then register the action with the top of the stack ... unless the top of the stack is this action
        // in which case go to the next action
        // We can't just register with all items in the Stack, as this may represent some complex dependency
        // For example in Dominion where one can Throne Room a Throne Room, which then Thrones a Smithy
        if (currentState.actionsInProgress.size() > 0) {
            IExtendedSequence topOfStack = currentState.actionsInProgress.peek();
            if (!topOfStack.equals(action)) {
                topOfStack._afterAction(currentState, action);
            } else {
                if (currentState.actionsInProgress.size() > 1) {
                    IExtendedSequence nextOnStack = currentState.actionsInProgress.get(currentState.actionsInProgress.size() - 2);
                    nextOnStack._afterAction(currentState, action);
                }
            }
        }
        _afterAction(currentState, action);
    }