Merge pull request #5644 from hitch17/additional-mulligan-support-5600

Additional mulligan support #5600

Mage/src/main/java/mage/game/Game.java

@@ -25,7 +25,9 @@ import mage.game.events.GameEvent;
 import mage.game.events.Listener;
 import mage.game.events.PlayerQueryEvent;
 import mage.game.events.TableEvent;
+import mage.game.match.Match;
 import mage.game.match.MatchType;
+import mage.game.mulligan.Mulligan;
 import mage.game.permanent.Battlefield;
 import mage.game.permanent.Permanent;
 import mage.game.permanent.PermanentCard;
@@ -472,4 +474,7 @@ public interface Game extends MageItem, Serializable {
     int damagePlayerOrPlaneswalker(UUID playerOrWalker, int damage, UUID sourceId, Game game, boolean combatDamage, boolean preventable);
 
     int damagePlayerOrPlaneswalker(UUID playerOrWalker, int damage, UUID sourceId, Game game, boolean combatDamage, boolean preventable, List<UUID> appliedEffects);
+
+    Mulligan getMulligan();
+
 }

Mage/src/main/java/mage/game/GameCanadianHighlanderImpl.java

@@ -1,20 +1,18 @@
 
 package mage.game;
 
-import java.util.*;
 import mage.constants.MultiplayerAttackOption;
 import mage.constants.PhaseStep;
 import mage.constants.RangeOfInfluence;
+import mage.game.mulligan.Mulligan;
 import mage.game.turn.TurnMod;
-import mage.players.Player;
+
+import java.util.UUID;
 
 public abstract class GameCanadianHighlanderImpl extends GameImpl {
 
-    protected boolean startingPlayerSkipsDraw = true;
-    protected Map<UUID, String> usedMulligans = new LinkedHashMap<>();
-
-    public GameCanadianHighlanderImpl(MultiplayerAttackOption attackOption, RangeOfInfluence range, int freeMulligans, int startLife) {
-        super(attackOption, range, 0, startLife);
+    public GameCanadianHighlanderImpl(MultiplayerAttackOption attackOption, RangeOfInfluence range, Mulligan mulligan, int startLife) {
+        super(attackOption, range, mulligan, startLife);
     }
 
     public GameCanadianHighlanderImpl(final GameCanadianHighlanderImpl game) {
@@ -27,110 +25,4 @@ public abstract class GameCanadianHighlanderImpl extends GameImpl {
         state.getTurnMods().add(new TurnMod(startingPlayerId, PhaseStep.DRAW));
     }
 
-    private String getNextMulligan(String mulligan) {
-        switch (mulligan) {
-            case "7":
-                return "6a";
-            case "6a":
-                return "6b";
-            case "6b":
-                return "5a";
-            case "5a":
-                return "5b";
-            case "5b":
-                return "4a";
-            case "4a":
-                return "4b";
-            case "4b":
-                return "3a";
-            case "3a":
-                return "3b";
-            case "3b":
-                return "2a";
-            case "2a":
-                return "2b";
-            case "2b":
-                return "1a";
-            case "1a":
-                return "1b";
-        }
-        return "0";
-    }
-
-    private int getNextMulliganNum(String mulligan) {
-        switch (mulligan) {
-            case "7":
-                return 6;
-            case "6a":
-                return 6;
-            case "6b":
-                return 5;
-            case "5a":
-                return 5;
-            case "5b":
-                return 4;
-            case "4a":
-                return 4;
-            case "4b":
-                return 3;
-            case "3a":
-                return 3;
-            case "3b":
-                return 2;
-            case "2a":
-                return 2;
-            case "2b":
-                return 1;
-            case "1a":
-                return 1;
-        }
-        return 0;
-    }
-
-    @Override
-    public int mulliganDownTo(UUID playerId) {
-        Player player = getPlayer(playerId);
-        int deduction = 1;
-        int numToMulliganTo = -1;
-        if (usedMulligans != null) {
-            String mulliganCode = "7";
-            if (usedMulligans.containsKey(player.getId())) {
-                mulliganCode = usedMulligans.get(player.getId());
-            }
-            numToMulliganTo = getNextMulliganNum(mulliganCode);
-        }
-        if (numToMulliganTo == -1) {
-            return player.getHand().size() - deduction;
-        }
-        return numToMulliganTo;
-    }
-
-    @Override
-    public void mulligan(UUID playerId) {
-        Player player = getPlayer(playerId);
-        int numCards = player.getHand().size();
-        int numToMulliganTo = numCards;
-        player.getLibrary().addAll(player.getHand().getCards(this), this);
-        player.getHand().clear();
-        player.shuffleLibrary(null, this);
-        if (usedMulligans != null) {
-            String mulliganCode = "7";
-            if (usedMulligans.containsKey(player.getId())) {
-                mulliganCode = usedMulligans.get(player.getId());
-            }
-            numToMulliganTo = getNextMulliganNum(mulliganCode);
-            usedMulligans.put(player.getId(), getNextMulligan(mulliganCode));
-        }
-        fireInformEvent(new StringBuilder(player.getLogName())
-                .append(" mulligans to ")
-                .append(Integer.toString(numToMulliganTo))
-                .append(numToMulliganTo == 1 ? " card" : " cards").toString());
-        player.drawCards(numToMulliganTo, this);
-    }
-
-    @Override
-    public void endMulligan(UUID playerId) {
-        super.endMulligan(playerId);
-    }
-
 }

Mage/src/main/java/mage/game/GameCommanderImpl.java

@@ -1,7 +1,5 @@
 package mage.game;
 
-import java.util.Map;
-import java.util.UUID;
 import mage.abilities.Ability;
 import mage.abilities.common.SimpleStaticAbility;
 import mage.abilities.effects.common.InfoEffect;
@@ -12,10 +10,14 @@ import mage.constants.MultiplayerAttackOption;
 import mage.constants.PhaseStep;
 import mage.constants.RangeOfInfluence;
 import mage.constants.Zone;
+import mage.game.mulligan.Mulligan;
 import mage.game.turn.TurnMod;
 import mage.players.Player;
 import mage.watchers.common.CommanderInfoWatcher;
 
+import java.util.Map;
+import java.util.UUID;
+
 public abstract class GameCommanderImpl extends GameImpl {
 
     // private final Map<UUID, Cards> mulliganedCards = new HashMap<>();
@@ -24,8 +26,8 @@ public abstract class GameCommanderImpl extends GameImpl {
     protected boolean alsoLibrary; // replace commander going to library
     protected boolean startingPlayerSkipsDraw = true;
 
-    public GameCommanderImpl(MultiplayerAttackOption attackOption, RangeOfInfluence range, int freeMulligans, int startLife) {
-        super(attackOption, range, freeMulligans, startLife);
+    public GameCommanderImpl(MultiplayerAttackOption attackOption, RangeOfInfluence range, Mulligan mulligan, int startLife) {
+        super(attackOption, range, mulligan, startLife);
     }
 
     public GameCommanderImpl(final GameCommanderImpl game) {

Mage/src/main/java/mage/game/GameImpl.java

@@ -40,6 +40,8 @@ import mage.game.command.Emblem;
 import mage.game.command.Plane;
 import mage.game.events.*;
 import mage.game.events.TableEvent.EventType;
+import mage.game.mulligan.LondonMulligan;
+import mage.game.mulligan.Mulligan;
 import mage.game.permanent.Battlefield;
 import mage.game.permanent.Permanent;
 import mage.game.permanent.PermanentCard;
@@ -108,8 +110,8 @@ public abstract class GameImpl implements Game, Serializable {
     protected UUID winnerId;
 
     protected RangeOfInfluence range;
-    protected int freeMulligans;
-    protected Map<UUID, Integer> usedFreeMulligans = new LinkedHashMap<>();
+    protected Mulligan mulligan;
+
     protected MultiplayerAttackOption attackOption;
     protected GameOptions gameOptions;
     protected String startMessage;
@@ -139,10 +141,10 @@ public abstract class GameImpl implements Game, Serializable {
     // used to proceed player conceding requests
     private final LinkedList<UUID> concedingPlayers = new LinkedList<>(); // used to handle asynchronous request of a player to leave the game
 
-    public GameImpl(MultiplayerAttackOption attackOption, RangeOfInfluence range, int freeMulligans, int startLife) {
+    public GameImpl(MultiplayerAttackOption attackOption, RangeOfInfluence range, Mulligan mulligan, int startLife) {
         this.id = UUID.randomUUID();
         this.range = range;
-        this.freeMulligans = freeMulligans;
+        this.mulligan = mulligan;
         this.attackOption = attackOption;
         this.state = new GameState();
         this.startLife = startLife;
@@ -156,7 +158,7 @@ public abstract class GameImpl implements Game, Serializable {
         this.startingPlayerId = game.startingPlayerId;
         this.winnerId = game.winnerId;
         this.range = game.range;
-        this.freeMulligans = game.freeMulligans;
+        this.mulligan = game.getMulligan().copy();
         this.attackOption = game.attackOption;
         this.state = game.state.copy();
         this.gameCards = game.gameCards;
@@ -958,50 +960,7 @@ public abstract class GameImpl implements Game, Serializable {
         }
 
         //20091005 - 103.4
-        List<UUID> keepPlayers = new ArrayList<>();
-        List<UUID> mulliganPlayers = new ArrayList<>();
-        do {
-            mulliganPlayers.clear();
-            for (UUID playerId : state.getPlayerList(startingPlayerId)) {
-                if (!keepPlayers.contains(playerId)) {
-                    Player player = getPlayer(playerId);
-                    boolean keep = true;
-                    while (true) {
-                        if (player.getHand().isEmpty()) {
-                            break;
-                        }
-                        GameEvent event = new GameEvent(GameEvent.EventType.CAN_TAKE_MULLIGAN, null, null, playerId);
-                        if (!replaceEvent(event)) {
-                            fireEvent(event);
-                            getState().setChoosingPlayerId(playerId);
-                            if (player.chooseMulligan(this)) {
-                                keep = false;
-                            }
-                            break;
-                        }
-                    }
-                    if (keep) {
-                        endMulligan(player.getId());
-                        keepPlayers.add(playerId);
-                        fireInformEvent(player.getLogName() + " keeps hand");
-                    } else {
-                        mulliganPlayers.add(playerId);
-                        fireInformEvent(player.getLogName() + " decides to take mulligan");
-                    }
-                }
-            }
-            for (UUID mulliganPlayerId : mulliganPlayers) {
-                mulligan(mulliganPlayerId);
-            }
-            saveState(false);
-        } while (!mulliganPlayers.isEmpty());
-        // new scry rule
-        for (UUID playerId : state.getPlayerList(startingPlayerId)) {
-            Player player = getPlayer(playerId);
-            if (player != null && player.getHand().size() < startingHandSize) {
-                player.scry(1, null, this);
-            }
-        }
+        mulligan.executeMulliganPhase(this, startingHandSize);
         getState().setChoosingPlayerId(null);
         state.resetWatchers(); // watcher objects from cards are reused during match so reset all card watchers already added
 
@@ -1159,51 +1118,17 @@ public abstract class GameImpl implements Game, Serializable {
 
     @Override
     public int mulliganDownTo(UUID playerId) {
-        Player player = getPlayer(playerId);
-        int deduction = 1;
-        if (freeMulligans > 0) {
-            if (usedFreeMulligans != null && usedFreeMulligans.containsKey(player.getId())) {
-                int used = usedFreeMulligans.get(player.getId());
-                if (used < freeMulligans) {
-                    deduction = 0;
-                }
-            } else {
-                deduction = 0;
-            }
-        }
-        return player.getHand().size() - deduction;
+        return mulligan.mulliganDownTo(this, playerId);
     }
 
     @Override
     public void endMulligan(UUID playerId) {
+        mulligan.endMulligan(this, playerId);
     }
 
     @Override
     public void mulligan(UUID playerId) {
-        Player player = getPlayer(playerId);
-        int numCards = player.getHand().size();
-        player.getLibrary().addAll(player.getHand().getCards(this), this);
-        player.getHand().clear();
-        player.shuffleLibrary(null, this);
-        int deduction = 1;
-        if (freeMulligans > 0) {
-            if (usedFreeMulligans.containsKey(player.getId())) {
-                int used = usedFreeMulligans.get(player.getId());
-                if (used < freeMulligans) {
-                    deduction = 0;
-                    usedFreeMulligans.put(player.getId(), used + 1);
-                }
-            } else {
-                deduction = 0;
-                usedFreeMulligans.put(player.getId(), 1);
-            }
-        }
-        fireInformEvent(new StringBuilder(player.getLogName())
-                .append(" mulligans")
-                .append(deduction == 0 ? " for free and draws " : " down to ")
-                .append((numCards - deduction))
-                .append(numCards - deduction == 1 ? " card" : " cards").toString());
-        player.drawCards(numCards - deduction, this);
+        mulligan.mulligan(this, playerId);
     }
 
     @Override
@@ -3239,4 +3164,10 @@ public abstract class GameImpl implements Game, Serializable {
         }
         return 0;
     }
+
+    @Override
+    public Mulligan getMulligan() {
+        return mulligan;
+    }
+
 }

Mage/src/main/java/mage/game/GameTinyLeadersImpl.java

@@ -16,6 +16,7 @@ import mage.cards.CardSetInfo;
 import mage.cards.repository.CardInfo;
 import mage.cards.repository.CardRepository;
 import mage.constants.*;
+import mage.game.mulligan.Mulligan;
 import mage.game.turn.TurnMod;
 import mage.players.Player;
 import mage.watchers.common.CommanderInfoWatcher;
@@ -30,8 +31,8 @@ public abstract class GameTinyLeadersImpl extends GameImpl {
     protected boolean alsoLibrary; // replace also commander going to library
     protected boolean startingPlayerSkipsDraw = true;
 
-    public GameTinyLeadersImpl(MultiplayerAttackOption attackOption, RangeOfInfluence range, int freeMulligans, int startLife) {
-        super(attackOption, range, freeMulligans, startLife);
+    public GameTinyLeadersImpl(MultiplayerAttackOption attackOption, RangeOfInfluence range, Mulligan mulligan, int startLife) {
+        super(attackOption, range, mulligan, startLife);
     }
 
     public GameTinyLeadersImpl(final GameTinyLeadersImpl game) {

Mage/src/main/java/mage/game/match/MatchOptions.java

@@ -5,6 +5,7 @@ import mage.constants.MatchTimeLimit;
 import mage.constants.MultiplayerAttackOption;
 import mage.constants.RangeOfInfluence;
 import mage.constants.SkillLevel;
+import mage.game.mulligan.MulliganType;
 import mage.game.result.ResultProtos;
 import mage.players.PlayerType;
 
@@ -47,6 +48,7 @@ public class MatchOptions implements Serializable {
      * Time each player has during the game to play using his\her priority.
      */
     protected MatchTimeLimit matchTimeLimit; // 0 = no priorityTime handling
+    protected MulliganType mulliganType;
 
     /*public MatchOptions(String name, String gameType) {
         this.name = name;
@@ -257,4 +259,16 @@ public class MatchOptions implements Serializable {
 
         return builder.build();
     }
+
+    public void setMullgianType(MulliganType mulliganType) {
+        this.mulliganType = mulliganType;
+    }
+
+    public MulliganType getMulliganType() {
+        if (mulliganType == null) {
+            return MulliganType.GAME_DEFAULT;
+        }
+        return mulliganType;
+    }
+
 }

Mage/src/main/java/mage/game/mulligan/CanadianHighlanderMulligan.java

@@ -0,0 +1,124 @@
+package mage.game.mulligan;
+
+import mage.game.Game;
+import mage.players.Player;
+
+import java.util.LinkedHashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class CanadianHighlanderMulligan extends VancouverMulligan {
+
+    protected Map<UUID, String> usedMulligans = new LinkedHashMap<>();
+
+    public CanadianHighlanderMulligan(int freeMulligans) {
+        super(freeMulligans);
+    }
+
+    @Override
+    public CanadianHighlanderMulligan copy() {
+        return new CanadianHighlanderMulligan(getFreeMulligans());
+    }
+
+    private String getNextMulligan(String mulligan) {
+        switch (mulligan) {
+            case "7":
+                return "6a";
+            case "6a":
+                return "6b";
+            case "6b":
+                return "5a";
+            case "5a":
+                return "5b";
+            case "5b":
+                return "4a";
+            case "4a":
+                return "4b";
+            case "4b":
+                return "3a";
+            case "3a":
+                return "3b";
+            case "3b":
+                return "2a";
+            case "2a":
+                return "2b";
+            case "2b":
+                return "1a";
+            case "1a":
+                return "1b";
+        }
+        return "0";
+    }
+
+    private int getNextMulliganNum(String mulligan) {
+        switch (mulligan) {
+            case "7":
+                return 6;
+            case "6a":
+                return 6;
+            case "6b":
+                return 5;
+            case "5a":
+                return 5;
+            case "5b":
+                return 4;
+            case "4a":
+                return 4;
+            case "4b":
+                return 3;
+            case "3a":
+                return 3;
+            case "3b":
+                return 2;
+            case "2a":
+                return 2;
+            case "2b":
+                return 1;
+            case "1a":
+                return 1;
+        }
+        return 0;
+    }
+
+    @Override
+    public int mulliganDownTo(Game game, UUID playerId) {
+        Player player = game.getPlayer(playerId);
+        int deduction = 1;
+        int numToMulliganTo = -1;
+        if (usedMulligans != null) {
+            String mulliganCode = "7";
+            if (usedMulligans.containsKey(player.getId())) {
+                mulliganCode = usedMulligans.get(player.getId());
+            }
+            numToMulliganTo = getNextMulliganNum(mulliganCode);
+        }
+        if (numToMulliganTo == -1) {
+            return player.getHand().size() - deduction;
+        }
+        return numToMulliganTo;
+    }
+
+    @Override
+    public void mulligan(Game game, UUID playerId) {
+        Player player = game.getPlayer(playerId);
+        int numCards = player.getHand().size();
+        int numToMulliganTo = numCards;
+        player.getLibrary().addAll(player.getHand().getCards(game), game);
+        player.getHand().clear();
+        player.shuffleLibrary(null, game);
+        if (usedMulligans != null) {
+            String mulliganCode = "7";
+            if (usedMulligans.containsKey(player.getId())) {
+                mulliganCode = usedMulligans.get(player.getId());
+            }
+            numToMulliganTo = getNextMulliganNum(mulliganCode);
+            usedMulligans.put(player.getId(), getNextMulligan(mulliganCode));
+        }
+        game.fireInformEvent(new StringBuilder(player.getLogName())
+                .append(" mulligans to ")
+                .append(Integer.toString(numToMulliganTo))
+                .append(numToMulliganTo == 1 ? " card" : " cards").toString());
+        player.drawCards(numToMulliganTo, game);
+    }
+
+}

Mage/src/main/java/mage/game/mulligan/LondonMulligan.java

@@ -0,0 +1,131 @@
+package mage.game.mulligan;
+
+import mage.cards.Cards;
+import mage.cards.CardsImpl;
+import mage.constants.Outcome;
+import mage.constants.Zone;
+import mage.filter.FilterCard;
+import mage.game.Game;
+import mage.players.Player;
+import mage.target.TargetCard;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+public class LondonMulligan extends Mulligan {
+
+    protected Map<UUID, Integer> startingHandSizes = new HashMap<>();
+    protected Map<UUID, Integer> openingHandSizes = new HashMap<>();
+
+    public LondonMulligan(int freeMulligans) {
+        super(freeMulligans);
+    }
+
+    @Override
+    public void executeMulliganPhase(Game game, int startingHandSize) {
+        /*
+         * 103.4. Each player draws a number of cards equal to their starting hand size, which is normally
+         * seven. (Some effects can modify a player’s starting hand size.) A player who is dissatisfied with
+         * their initial hand may take a mulligan. First, the starting player declares whether they will
+         * take a mulligan. Then each other player in turn order does the same. Once each player has made a
+         * declaration, all players who decided to take mulligans do so at the same time. To take a mulligan,
+         * a player shuffles the cards in their hand back into their library, draws a new hand of cards equal
+         * to their starting hand size, then puts a number of those cards onto the bottom of their library in
+         * any order equal to the number of times that player has taken a mulligan. Once a player chooses not
+         * to take a mulligan, the remaining cards become the player’s opening hand, and that player may not
+         * take any further mulligans. This process is then repeated until no player takes a mulligan. A
+         * player can’t take a number of mulligans greater their starting hand size.
+         *
+         * https://magic.wizards.com/en/articles/archive/competitive-gaming/mythic-championship-ii-format-and-london-test-2019-02-21
+         */
+
+        for (UUID playerId : game.getState().getPlayerList(game.getStartingPlayerId())) {
+            openingHandSizes.put(playerId, startingHandSize);
+            startingHandSizes.put(playerId, startingHandSize);
+        }
+
+        super.executeMulliganPhase(game, startingHandSize);
+    }
+
+    @Override
+    public int mulliganDownTo(Game game, UUID playerId) {
+        Player player = game.getPlayer(playerId);
+        int deduction = 1;
+        if (freeMulligans > 0) {
+            if (usedFreeMulligans != null && usedFreeMulligans.containsKey(player.getId())) {
+                int used = usedFreeMulligans.get(player.getId());
+                if (used < freeMulligans) {
+                    deduction = 0;
+                }
+            } else {
+                deduction = 0;
+            }
+        }
+        return openingHandSizes.get(playerId) - deduction;
+    }
+
+    @Override
+    public boolean canTakeMulligan(Game game, Player player) {
+        return super.canTakeMulligan(game, player) && openingHandSizes.get(player.getId()) > 0;
+    }
+
+    @Override
+    public void mulligan(Game game, UUID playerId) {
+        Player player = game.getPlayer(playerId);
+        int numCards = startingHandSizes.get(player.getId());
+        player.getLibrary().addAll(player.getHand().getCards(game), game);
+        player.getHand().clear();
+        player.shuffleLibrary(null, game);
+        int deduction = 1;
+        if (freeMulligans > 0) {
+            if (usedFreeMulligans.containsKey(player.getId())) {
+                int used = usedFreeMulligans.get(player.getId());
+                if (used < freeMulligans) {
+                    deduction = 0;
+                    usedFreeMulligans.put(player.getId(), used + 1);
+                }
+            } else {
+                deduction = 0;
+                usedFreeMulligans.put(player.getId(), 1);
+            }
+        }
+        openingHandSizes.put(playerId, openingHandSizes.get(playerId) - deduction);
+        if (deduction == 0) {
+            game.fireInformEvent(new StringBuilder(player.getLogName())
+                    .append(" mulligans for free.")
+                    .toString());
+        } else {
+            game.fireInformEvent(new StringBuilder(player.getLogName())
+                    .append(" mulligans")
+                    .append(" down to ")
+                    .append((numCards - deduction))
+                    .append(numCards - deduction == 1 ? " card" : " cards").toString());
+        }
+        player.drawCards(numCards, game);
+
+        int handSize = openingHandSizes.get(player.getId());
+        if (player.getHand().size() > handSize) {
+            int cardsToDiscard = player.getHand().size() - handSize;
+            Cards cards = new CardsImpl();
+            cards.addAll(player.getHand());
+            TargetCard target = new TargetCard(cardsToDiscard, cardsToDiscard, Zone.HAND,
+                    new FilterCard("cards to PUT on the BOTTOM of your library (Discard for Mulligan)"));
+            player.chooseTarget(Outcome.Neutral, cards, target, null, game);
+            player.putCardsOnBottomOfLibrary(new CardsImpl(target.getTargets()), game, null, true);
+            cards.removeAll(target.getTargets());
+        }
+    }
+
+    @Override
+    public void endMulligan(Game game, UUID playerId) {}
+
+    @Override
+    public LondonMulligan copy() {
+        LondonMulligan mulligan = new LondonMulligan(getFreeMulligans());
+        mulligan.openingHandSizes.putAll(openingHandSizes);
+        mulligan.startingHandSizes.putAll(startingHandSizes);
+        return mulligan;
+    }
+
+}

Mage/src/main/java/mage/game/mulligan/Mulligan.java

@@ -0,0 +1,87 @@
+package mage.game.mulligan;
+
+import mage.game.Game;
+import mage.game.events.GameEvent;
+import mage.players.Player;
+
+import java.util.*;
+
+public abstract class Mulligan {
+
+    protected final int freeMulligans;
+    protected final Map<UUID, Integer> usedFreeMulligans = new HashMap<>();
+
+    public Mulligan(int freeMulligans) {
+        this.freeMulligans = freeMulligans;
+    }
+
+    public void executeMulliganPhase(Game game, int startingHandSize) {
+        /*
+         * 103.4. Each player draws a number of cards equal to their starting hand size,
+         * which is normally seven. (Some effects can modify a player’s starting hand size.)
+         * A player who is dissatisfied with their initial hand may take a mulligan. First
+         * the starting player declares whether they will take a mulligan. Then each other
+         * player in turn order does the same. Once each player has made a declaration, all
+         * players who decided to take mulligans do so at the same time. To take a mulligan,
+         * a player shuffles their hand back into their library, then draws a new hand of one
+         * fewer cards than they had before. If a player kept their hand of cards, those cards
+         * become the player’s opening hand, and that player may not take any further mulligans.
+         * This process is then repeated until no player takes a mulligan. (Note that if a
+         * player’s hand size reaches zero cards, that player must keep that hand.)
+         */
+        List<UUID> keepPlayers = new ArrayList<>();
+        List<UUID> mulliganPlayers = new ArrayList<>();
+        do {
+            mulliganPlayers.clear();
+            for (UUID playerId : game.getState().getPlayerList(game.getStartingPlayerId())) {
+                if (!keepPlayers.contains(playerId)) {
+                    Player player = game.getPlayer(playerId);
+                    boolean keep = true;
+                    while (true) {
+                        if (!canTakeMulligan(game, player)) {
+                            break;
+                        }
+                        GameEvent event = new GameEvent(GameEvent.EventType.CAN_TAKE_MULLIGAN, null, null, playerId);
+                        if (!game.replaceEvent(event)) {
+                            game.fireEvent(event);
+                            game.getState().setChoosingPlayerId(playerId);
+                            if (player.chooseMulligan(game)) {
+                                keep = false;
+                            }
+                            break;
+                        }
+                    }
+                    if (keep) {
+                        game.endMulligan(player.getId());
+                        keepPlayers.add(playerId);
+                        game.fireInformEvent(player.getLogName() + " keeps hand");
+                    } else {
+                        mulliganPlayers.add(playerId);
+                        game.fireInformEvent(player.getLogName() + " decides to take mulligan");
+                    }
+                }
+            }
+            for (UUID mulliganPlayerId : mulliganPlayers) {
+                mulligan(game, mulliganPlayerId);
+            }
+            game.saveState(false);
+        } while (!mulliganPlayers.isEmpty());
+    }
+
+    public abstract int mulliganDownTo(Game game, UUID playerId);
+
+    public abstract void mulligan(Game game, UUID playerId);
+
+    public abstract void endMulligan(Game game, UUID playerId);
+
+    public abstract Mulligan copy();
+
+    public boolean canTakeMulligan(Game game, Player player) {
+        return !player.getHand().isEmpty();
+    }
+
+    public int getFreeMulligans() {
+        return freeMulligans;
+    }
+
+}

Mage/src/main/java/mage/game/mulligan/MulliganType.java

@@ -0,0 +1,43 @@
+package mage.game.mulligan;
+
+public enum MulliganType {
+
+    GAME_DEFAULT("Game Default"),
+    VANCOUVER("Vancouver"),
+    PARIS("Paris"),
+    LONDON("London"),
+    CANADIAN_HIGHLANDER("Canadian Highlander");
+
+    private final String displayName;
+
+    MulliganType(String displayName) {
+        this.displayName = displayName;
+    }
+
+    public Mulligan getMulligan(int freeMulligans) {
+        switch(this) {
+            case PARIS:
+                return new ParisMulligan(freeMulligans);
+            case CANADIAN_HIGHLANDER:
+                return new CanadianHighlanderMulligan(freeMulligans);
+            case LONDON:
+                return new LondonMulligan(freeMulligans);
+            default:
+            case VANCOUVER:
+                return new VancouverMulligan(freeMulligans);
+        }
+    }
+
+    @Override
+    public String toString() {
+        return displayName;
+    }
+
+    public MulliganType orDefault(MulliganType defaultMulligan) {
+        if (this == GAME_DEFAULT) {
+            return defaultMulligan;
+        }
+        return this;
+    }
+
+}

Mage/src/main/java/mage/game/mulligan/ParisMulligan.java

@@ -0,0 +1,67 @@
+package mage.game.mulligan;
+
+import mage.game.Game;
+import mage.players.Player;
+
+import java.util.UUID;
+
+public class ParisMulligan extends Mulligan {
+
+    public ParisMulligan(int freeMulligans) {
+        super(freeMulligans);
+    }
+
+    @Override
+    public int mulliganDownTo(Game game, UUID playerId) {
+        Player player = game.getPlayer(playerId);
+        int deduction = 1;
+        if (freeMulligans > 0) {
+            if (usedFreeMulligans != null && usedFreeMulligans.containsKey(player.getId())) {
+                int used = usedFreeMulligans.get(player.getId());
+                if (used < freeMulligans) {
+                    deduction = 0;
+                }
+            } else {
+                deduction = 0;
+            }
+        }
+        return player.getHand().size() - deduction;
+    }
+
+    @Override
+    public void mulligan(Game game, UUID playerId) {
+        Player player = game.getPlayer(playerId);
+        int numCards = player.getHand().size();
+        player.getLibrary().addAll(player.getHand().getCards(game), game);
+        player.getHand().clear();
+        player.shuffleLibrary(null, game);
+        int deduction = 1;
+        if (freeMulligans > 0) {
+            if (usedFreeMulligans.containsKey(player.getId())) {
+                int used = usedFreeMulligans.get(player.getId());
+                if (used < freeMulligans) {
+                    deduction = 0;
+                    usedFreeMulligans.put(player.getId(), used + 1);
+                }
+            } else {
+                deduction = 0;
+                usedFreeMulligans.put(player.getId(), 1);
+            }
+        }
+        game.fireInformEvent(new StringBuilder(player.getLogName())
+                .append(" mulligans")
+                .append(deduction == 0 ? " for free and draws " : " down to ")
+                .append((numCards - deduction))
+                .append(numCards - deduction == 1 ? " card" : " cards").toString());
+        player.drawCards(numCards - deduction, game);
+    }
+
+    @Override
+    public void endMulligan(Game game, UUID playerId) {}
+
+    @Override
+    public ParisMulligan copy() {
+        return new ParisMulligan(getFreeMulligans());
+    }
+
+}

Mage/src/main/java/mage/game/mulligan/VancouverMulligan.java

@@ -0,0 +1,36 @@
+package mage.game.mulligan;
+
+import mage.game.Game;
+import mage.players.Player;
+
+import java.util.UUID;
+
+public class VancouverMulligan extends ParisMulligan {
+
+    public VancouverMulligan(int freeMulligans) {
+        super(freeMulligans);
+    }
+
+    @Override
+    public void executeMulliganPhase(Game game, int startingHandSize) {
+        super.executeMulliganPhase(game, startingHandSize);
+        /*
+         * 103.4 (scry rule) - After all players have kept an opening hand, each player in
+         * turn order whose hand contains fewer cards than that player’s starting hand size
+         * may look at the top card of their library. If a player does, that player may put
+         * that card on the bottom of their library.
+         */
+        for (UUID playerId : game.getState().getPlayerList(game.getStartingPlayerId())) {
+            Player player = game.getPlayer(playerId);
+            if (player != null && player.getHand().size() < startingHandSize) {
+                player.scry(1, null, game);
+            }
+        }
+    }
+
+    @Override
+    public VancouverMulligan copy() {
+        return new VancouverMulligan(getFreeMulligans());
+    }
+
+}