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";
    }
}

/**
 * An Action (usually) that entails a sequence of linked actions/decisions. This takes temporary control of deciding
 * which player is currently making a decision (the currentPlayer) from TurnOrder, and of what actions they have
 * available from ForwardModel.
 *
 * ForwardModel will register all actions taken and the current state just before execution of each action in next().
 *
 * IExtendedSequence is then 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.)
 *
 * Assuming this interface is used by an Action, then the execute(AbstractGameState state) method should call:
 *      state.setActionInProgress(this)
 * The core framework will then trigger delegation from ForwardModel and TurnOrder.
 */
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.
     *
     * 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);
    }