release: 1.2.0 - real GB opening procedure with two dice rolls and dead wall

Author: Arbousier1

CHANGELOG.md

@@ -1,5 +1,25 @@
 # Changelog
 
+## 1.2.0 - 2026-06-16
+
+GB/SICHUAN opening procedure and wall management overhaul to match real Chinese Official / Sichuan Mahjong rules.
+
+中文更新日志:
+
+- **两次掷骰开门**: GB/SICHUAN 开局现在按真实国标流程，庄家先掷两骰确定开门方位，被指定方位的玩家再掷两骰确定开门位置。`OpeningDiceRoll` 扩展为 4 参数（两组骰子），渲染层同步更新。
+- **14 张王牌区（dead wall）**: 牌墙末尾 14 张分离为 dead wall，仅用于补花/补杠替换。正常摸牌只从 live wall 前端取，live wall 摸完即流局。补花/补杠从 dead wall 尾部取牌，同时从 live wall 尾部补一张到 dead wall 前端，维持 dead wall 大小。
+- **门风正确轮转**: `buildFanRequest` / `buildWinRequest` / `toNativeMelds` 均已使用 `logicalSeatOf()` 将物理座位映射为逻辑门风（庄家 = EAST），从第二局起门风刻、圈风刻及原生引擎输入不再错位。
+- **四川定缺准备阶段**: 已有完整的交换→定缺两阶段准备流程，定缺后缺门花色牌必须先打。
+- **四川一炮多响**: 四川模式下 `allowMultiRon = true`，同一放铳可被多人同时荣和。
+
+English Release Notes:
+
+- **Two dice rolls for wall break**: GB/SICHUAN opening now follows real Chinese Official rules — the dealer rolls two dice to determine which wall side to open, then the player at that side rolls two more dice to determine the break position. `OpeningDiceRoll` expanded to 4 parameters (two pairs of dice); rendering layer updated accordingly.
+- **14-tile dead wall**: The last 14 tiles of the wall are reserved as the dead wall for flower/kong replacement draws only. Normal draws come from the live wall front; when the live wall is empty, the hand ends in exhaustive draw. Replacement draws take from the dead wall tail and replenish from the live wall tail to maintain dead wall size.
+- **Correct seat wind rotation**: `buildFanRequest` / `buildWinRequest` / `toNativeMelds` all use `logicalSeatOf()` to map physical seats to logical winds (dealer = EAST), so seat wind, round wind, and native engine inputs are correct from the second hand onward.
+- **Sichuan dingque preparation**: Full exchange → dingque two-phase preparation flow; after choosing the missing suit, tiles of that suit must be discarded first.
+- **Sichuan multi-ron**: In Sichuan mode, `allowMultiRon = true`, allowing multiple players to win on the same discard.
+
 ## 1.1.3 - 2026-06-16
 
 Hotfix for Paper 1.21.4+ servers where clicking any custom inventory (settlement, rule settings, table control) threw `IncompatibleClassChangeError`.

build.gradle.kts

@@ -14,7 +14,7 @@ plugins {
 }
 
 group = "top.ellan"
-version = "1.1.3"
+version = "1.2.0"
 
 val minimumPaperDevBundleVersion = "1.20.1-R0.1-SNAPSHOT"
 val latestPaperDevBundleVersion = "26.2-rc-2.build.9-alpha"

src/main/java/top/ellan/mahjong/render/TableRenderSubject.java

@@ -50,6 +50,10 @@ public interface TableRenderSubject extends DisplayEntityRuntime {
 
     int dicePoints();
 
+    default int breakDicePoints() {
+        return this.dicePoints();
+    }
+
     int roundIndex();
 
     int honbaCount();

src/main/java/top/ellan/mahjong/render/layout/TableRenderLayout.java

@@ -364,8 +364,9 @@ private static Point handTilePoint(
     private static int wallBreakTileIndex(TableRenderSnapshot snapshot) {
         int seatCount = SeatWind.values().length;
         int dicePoints = snapshot.dicePoints();
+        int breakDice = snapshot.breakDicePoints();
         int directionIndex = 4 - (((dicePoints % seatCount) - 1 + snapshot.roundIndex()) % seatCount);
-        return Math.floorMod(directionIndex * WALL_TILES_PER_SIDE + dicePoints * 2, TOTAL_WALL_TILES);
+        return Math.floorMod(directionIndex * WALL_TILES_PER_SIDE + breakDice * 2, TOTAL_WALL_TILES);
     }
 
     private static int doraIndicatorDeadWallIndex(int kanCount, int indicatorIndex) {

src/main/java/top/ellan/mahjong/render/scene/TableRenderer.java

@@ -1694,8 +1694,9 @@ private static Location meldStartByDisplayDirection(Location center, SeatWind di
     private static int wallBreakTileIndex(TableRenderSubject session) {
         int seatCount = SeatWind.values().length;
         int dicePoints = session.dicePoints();
+        int breakDice = session.breakDicePoints();
         int directionIndex = 4 - (((dicePoints % seatCount) - 1 + session.roundIndex()) % seatCount);
-        return Math.floorMod(directionIndex * WALL_TILES_PER_SIDE + dicePoints * 2, TOTAL_WALL_TILES);
+        return Math.floorMod(directionIndex * WALL_TILES_PER_SIDE + breakDice * 2, TOTAL_WALL_TILES);
     }
 
     private static int deadWallAnchorSlot(TableRenderSubject session) {

src/main/java/top/ellan/mahjong/render/snapshot/TableRenderSnapshot.java

@@ -17,6 +17,7 @@ public record TableRenderSnapshot(
     int remainingWallCount,
     int kanCount,
     int dicePoints,
+    int breakDicePoints,
     int roundIndex,
     int honbaCount,
     SeatWind dealerSeat,
@@ -30,6 +31,10 @@ public record TableRenderSnapshot(
     List<top.ellan.mahjong.model.MahjongTile> doraIndicators,
     EnumMap<SeatWind, TableSeatRenderSnapshot> seats
 ) {
+    public int breakDicePoints() {
+        return this.breakDicePoints;
+    }
+
     public TableSeatRenderSnapshot seat(SeatWind wind) {
         return this.seats.get(wind);
     }

src/main/java/top/ellan/mahjong/table/core/MahjongTableSession.java

@@ -644,6 +644,11 @@ public SeatWind openDoorSeat() {
         );
     }
 
+    @Override
+    public int breakDicePoints() {
+        return this.intFromRoundController(TableRoundController::dicePoints2);
+    }
+
     public int honbaCount() {
         return this.intFromRoundController(TableRoundController::honbaCount);
     }

src/main/java/top/ellan/mahjong/table/core/round/GbRoundSupport.java

@@ -9,6 +9,8 @@
 import java.util.concurrent.ThreadLocalRandom;
 
 final class GbRoundSupport {
+    static final int DEAD_WALL_SIZE = 14;
+
     private GbRoundSupport() {
     }
 
@@ -190,13 +192,17 @@ static List<MahjongTile> buildWall(GbRuleProfile profile) {
     }
 
     static List<MahjongTile> reorderWallForDice(List<MahjongTile> wall, int dicePoints, int roundIndex) {
+        return reorderWallForDice(wall, dicePoints, dicePoints, roundIndex);
+    }
+
+    static List<MahjongTile> reorderWallForDice(List<MahjongTile> wall, int directionDicePoints, int breakDicePoints, int roundIndex) {
         if (wall == null || wall.isEmpty()) {
             return List.of();
         }
         int seatCount = SeatWind.values().length;
         int wallTilesPerSide = wall.size() / seatCount;
-        int directionIndex = seatCount - (((dicePoints % seatCount) - 1 + roundIndex) % seatCount);
-        int startingStackIndex = 2 * dicePoints;
+        int directionIndex = seatCount - (((directionDicePoints % seatCount) - 1 + roundIndex) % seatCount);
+        int startingStackIndex = 2 * breakDicePoints;
         List<MahjongTile> reordered = new ArrayList<>(wall.size());
         for (int i = 0; i < wall.size(); i++) {
             int tileIndex = Math.floorMod(directionIndex * wallTilesPerSide + startingStackIndex + i, wall.size());

src/main/java/top/ellan/mahjong/table/core/round/GbTableRoundController.java

@@ -84,9 +84,11 @@ private enum SichuanPreparationPhase {
     private final Map<UUID, SichuanSuit> chosenMissingSuits = new HashMap<>();
     private final SichuanRulesEngine sichuanRulesEngine;
     private List<MahjongTile> wall = List.of();
+    private List<MahjongTile> deadWall = List.of();
     private boolean started;
     private boolean gameFinished;
     private int dicePoints;
+    private int dicePoints2;
     private int currentPlayerIndex;
     private int kanCount;
     private RoundResolution lastResolution;
@@ -187,10 +189,18 @@ public boolean gameFinished() {
     public void startRound() {
         OpeningDiceRoll diceRoll = this.pendingDiceRoll;
         this.pendingDiceRoll = null;
-        this.dicePoints = diceRoll == null
-            ? GbRoundSupport.requireValidDicePoints(this.dicePointsSupplier.getAsInt())
-            : diceRoll.total();
-        this.wall = GbRoundSupport.reorderWallForDice(this.wallSupplier.get(), this.dicePoints, this.round.getRound());
+        if (diceRoll == null) {
+            int roll1 = GbRoundSupport.requireValidDicePoints(this.dicePointsSupplier.getAsInt());
+            int roll2 = GbRoundSupport.requireValidDicePoints(this.dicePointsSupplier.getAsInt());
+            this.dicePoints = roll1;
+            this.dicePoints2 = roll2;
+        } else {
+            this.dicePoints = diceRoll.total();
+            this.dicePoints2 = diceRoll.total2();
+        }
+        List<MahjongTile> fullWall = GbRoundSupport.reorderWallForDice(this.wallSupplier.get(), this.dicePoints, this.dicePoints2, this.round.getRound());
+        this.deadWall = List.copyOf(fullWall.subList(fullWall.size() - GbRoundSupport.DEAD_WALL_SIZE, fullWall.size()));
+        this.wall = List.copyOf(fullWall.subList(0, fullWall.size() - GbRoundSupport.DEAD_WALL_SIZE));
         this.pendingReactionWindow = null;
         this.lastResolution = null;
         this.started = true;
@@ -376,6 +386,11 @@ public int dicePoints() {
         return this.dicePoints;
     }
 
+    @Override
+    public int dicePoints2() {
+        return this.dicePoints2;
+    }
+
     @Override
     public int kanCount() {
         return this.kanCount;
@@ -424,10 +439,13 @@ public List<MahjongTile> discards(UUID playerId) {
 
     @Override
     public List<MahjongTile> remainingWall() {
-        List<MahjongTile> hiddenWall = new ArrayList<>(this.wall.size());
+        List<MahjongTile> hiddenWall = new ArrayList<>(this.wall.size() + this.deadWall.size());
         for (int i = 0; i < this.wall.size(); i++) {
             hiddenWall.add(MahjongTile.UNKNOWN);
         }
+        for (int i = 0; i < this.deadWall.size(); i++) {
+            hiddenWall.add(MahjongTile.UNKNOWN);
+        }
         return List.copyOf(hiddenWall);
     }
 
@@ -1755,18 +1773,18 @@ private boolean drawTile(UUID playerId, boolean fromBack, boolean markAfterKong,
         if (playerId == null || this.wall.isEmpty()) {
             return false;
         }
-        boolean nextFromBack = fromBack;
+        if (fromBack) {
+            return this.drawReplacementTile(playerId, markAfterKong, markAsDrawn);
+        }
         while (!this.wall.isEmpty()) {
             List<MahjongTile> mutableWall = new ArrayList<>(this.wall);
-            MahjongTile tile = nextFromBack ? mutableWall.remove(mutableWall.size() - 1) : mutableWall.remove(0);
+            MahjongTile tile = mutableWall.remove(0);
             this.wall = List.copyOf(mutableWall);
             if (tile.isFlower()) {
                 if (!this.ruleProfile.includesFlowers()) {
-                    nextFromBack = true;
                     continue;
                 }
                 this.flowers.get(playerId).add(tile);
-                nextFromBack = true;
                 continue;
             }
             this.hands.get(playerId).add(tile);
@@ -1778,6 +1796,32 @@ private boolean drawTile(UUID playerId, boolean fromBack, boolean markAfterKong,
         return false;
     }
 
+    private boolean drawReplacementTile(UUID playerId, boolean markAfterKong, boolean markAsDrawn) {
+        if (this.deadWall.isEmpty()) {
+            return false;
+        }
+        List<MahjongTile> mutableDeadWall = new ArrayList<>(this.deadWall);
+        MahjongTile tile = mutableDeadWall.remove(mutableDeadWall.size() - 1);
+        if (!this.wall.isEmpty()) {
+            List<MahjongTile> mutableWall = new ArrayList<>(this.wall);
+            mutableDeadWall.add(0, mutableWall.remove(mutableWall.size() - 1));
+            this.wall = List.copyOf(mutableWall);
+        }
+        this.deadWall = List.copyOf(mutableDeadWall);
+        if (tile.isFlower()) {
+            if (!this.ruleProfile.includesFlowers()) {
+                return this.drawReplacementTile(playerId, markAfterKong, markAsDrawn);
+            }
+            this.flowers.get(playerId).add(tile);
+            return this.drawReplacementTile(playerId, markAfterKong, markAsDrawn);
+        }
+        this.hands.get(playerId).add(tile);
+        this.hasDrawnTile.put(playerId, markAsDrawn);
+        this.sortHand(playerId);
+        this.afterKanTsumoPlayer = markAfterKong ? playerId : null;
+        return true;
+    }
+
     private void finishExhaustiveDraw() {
         this.pendingReactionWindow = null;
         this.started = false;

src/main/java/top/ellan/mahjong/table/core/round/OpeningDiceRoll.java

@@ -2,20 +2,29 @@
 
 import java.util.concurrent.ThreadLocalRandom;
 
-public record OpeningDiceRoll(int firstDie, int secondDie) {
+public record OpeningDiceRoll(int firstDie, int secondDie, int firstDie2, int secondDie2) {
     public OpeningDiceRoll {
-        if (firstDie < 1 || firstDie > 6 || secondDie < 1 || secondDie > 6) {
+        if (firstDie < 1 || firstDie > 6 || secondDie < 1 || secondDie > 6
+            || firstDie2 < 1 || firstDie2 > 6 || secondDie2 < 1 || secondDie2 > 6) {
             throw new IllegalArgumentException("Dice values must be between 1 and 6");
         }
     }
 
+    public OpeningDiceRoll(int firstDie, int secondDie) {
+        this(firstDie, secondDie, firstDie, secondDie);
+    }
+
     public int total() {
         return this.firstDie + this.secondDie;
     }
 
+    public int total2() {
+        return this.firstDie2 + this.secondDie2;
+    }
+
     public static OpeningDiceRoll random() {
         ThreadLocalRandom random = ThreadLocalRandom.current();
-        return new OpeningDiceRoll(random.nextInt(1, 7), random.nextInt(1, 7));
+        return new OpeningDiceRoll(random.nextInt(1, 7), random.nextInt(1, 7), random.nextInt(1, 7), random.nextInt(1, 7));
     }
 }