feat: integrate Sichuan Mahjong core flow

Author: Arbousier1

src/main/java/top/ellan/mahjong/command/MahjongCommand.java

@@ -526,7 +526,7 @@ private List<String> visibleRootCommands(CommandSender sender) {
             : ROOT_COMMANDS.stream().filter(command -> !this.isAdminRootCommand(command)).collect(java.util.stream.Collectors.toCollection(ArrayList::new));
         if (sender instanceof Player player) {
             MahjongTableSession table = this.tableManager.tableFor(player.getUniqueId());
-            if (table != null && table.currentVariant() == MahjongVariant.GB) {
+            if (table != null && table.currentVariant() != MahjongVariant.RIICHI) {
                 commands.remove("riichi");
                 commands.remove("kyuushu");
             }

src/main/java/top/ellan/mahjong/config/PluginSettings.java

@@ -132,7 +132,7 @@ public String craftEngineGbTileItemIdPrefix() {
     }
 
     public String craftEngineTileItemIdPrefix(MahjongVariant variant) {
-        if (variant == MahjongVariant.GB) {
+        if (variant != MahjongVariant.RIICHI) {
             return this.craftEngineGbTileItemIdPrefix;
         }
         return this.craftEngineRiichiTileItemIdPrefix;

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

@@ -14,6 +14,7 @@
 import top.ellan.mahjong.riichi.model.MahjongSoulScoring;
 import top.ellan.mahjong.riichi.model.ScoringStick;
 import top.ellan.mahjong.table.core.round.GbTableRoundController;
+import top.ellan.mahjong.table.core.round.GbRuleProfile;
 import top.ellan.mahjong.table.core.round.OpeningDiceRoll;
 import top.ellan.mahjong.table.core.round.RiichiTableRoundController;
 import top.ellan.mahjong.table.core.round.TableRoundController;
@@ -912,8 +913,14 @@ private TableRoundController createRoundController() {
             seats.put(wind, playerId);
             displayNames.put(playerId, this.displayName(playerId));
         }
-        if (this.currentVariant() == MahjongVariant.GB) {
-            return new GbTableRoundController(this.copyRule(), seats, displayNames, new GbNativeRulesGateway());
+        if (this.currentVariant() != MahjongVariant.RIICHI) {
+            return new GbTableRoundController(
+                this.copyRule(),
+                seats,
+                displayNames,
+                new GbNativeRulesGateway(),
+                GbRuleProfile.forVariant(this.currentVariant())
+            );
         }
         List<RiichiPlayerState> players = new ArrayList<>(SeatWind.values().length);
         for (SeatWind wind : SeatWind.values()) {

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

@@ -4,7 +4,8 @@
 
 public enum MahjongVariant {
     RIICHI,
-    GB;
+    GB,
+    SICHUAN;
 
     public String translationKey() {
         return "rule.variant." + this.name().toLowerCase(Locale.ROOT);

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

@@ -65,8 +65,8 @@ List<String> ruleKeys() {
 
     List<String> ruleValues(String key) {
         return switch (key.toLowerCase(Locale.ROOT)) {
-            case "preset", "mode" -> List.of("MAJSOUL_TONPUU", "MAJSOUL_HANCHAN", "GB");
-            case "variant", "ruleset" -> List.of("RIICHI", "GB");
+            case "preset", "mode" -> List.of("MAJSOUL_TONPUU", "MAJSOUL_HANCHAN", "GB", "SICHUAN");
+            case "variant", "ruleset" -> List.of("RIICHI", "GB", "SICHUAN");
             case "length" -> List.of("ONE_GAME", "EAST", "SOUTH", "TWO_WIND");
             case "thinkingtime", "thinking" -> List.of("VERY_SHORT", "SHORT", "NORMAL", "LONG", "VERY_LONG");
             case "minimumhan", "minhan" -> List.of("ONE", "TWO", "FOUR", "YAKUMAN");

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

@@ -18,12 +18,14 @@ static Preset resolve(String rawValue) {
                 new Preset(MahjongVariant.RIICHI, majsoulRule(MahjongRule.GameLength.TWO_WIND));
             case "GB", "GUOBIAO", "ZHONGGUO", "CHINESE_OFFICIAL" ->
                 new Preset(MahjongVariant.GB, gbRule());
+            case "SICHUAN", "SCMJ", "SICHUAN_MAHJONG", "SICHUAN_TOURNAMENT" ->
+                new Preset(MahjongVariant.SICHUAN, sichuanRule());
             default -> null;
         };
     }
 
     static MahjongRule defaultRuleFor(MahjongVariant variant) {
-        return variant == MahjongVariant.GB ? gbRule() : majsoulRule(MahjongRule.GameLength.TWO_WIND);
+        return variant == MahjongVariant.RIICHI ? majsoulRule(MahjongRule.GameLength.TWO_WIND) : gbRule();
     }
 
     static MahjongRule majsoulRule(MahjongRule.GameLength length) {
@@ -54,6 +56,10 @@ static MahjongRule gbRule() {
         );
     }
 
+    static MahjongRule sichuanRule() {
+        return gbRule();
+    }
+
     record Preset(MahjongVariant variant, MahjongRule rule) {
     }
 }

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

@@ -163,11 +163,23 @@ static int rollDicePoints() {
     }
 
     static List<MahjongTile> buildWall() {
-        List<MahjongTile> wall = new ArrayList<>(144);
+        return buildWall(GbRuleProfile.GB);
+    }
+
+    static List<MahjongTile> buildWall(GbRuleProfile profile) {
+        GbRuleProfile safeProfile = profile == null ? GbRuleProfile.GB : profile;
+        int initialCapacity = safeProfile.includesHonors() && safeProfile.includesFlowers() ? 144 : 108;
+        List<MahjongTile> wall = new ArrayList<>(initialCapacity);
         for (MahjongTile tile : MahjongTile.values()) {
             if (tile == MahjongTile.UNKNOWN || tile.isRedFive()) {
                 continue;
             }
+            if (!safeProfile.includesHonors() && isHonor(tile)) {
+                continue;
+            }
+            if (!safeProfile.includesFlowers() && tile.isFlower()) {
+                continue;
+            }
             int copies = tile.isFlower() ? 1 : 4;
             for (int i = 0; i < copies; i++) {
                 wall.add(tile);

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

@@ -0,0 +1,62 @@
+package top.ellan.mahjong.table.core.round;
+
+import top.ellan.mahjong.table.core.MahjongVariant;
+
+public enum GbRuleProfile {
+    GB(MahjongVariant.GB, "GB_MAHJONG", 8, true, true, false),
+    SICHUAN(MahjongVariant.SICHUAN, "SICHUAN_MAHJONG", 0, false, false, true);
+
+    private final MahjongVariant variant;
+    private final String nativeRuleProfile;
+    private final int minimumFan;
+    private final boolean includesHonors;
+    private final boolean includesFlowers;
+    private final boolean useSichuanHuEvaluator;
+
+    GbRuleProfile(
+        MahjongVariant variant,
+        String nativeRuleProfile,
+        int minimumFan,
+        boolean includesHonors,
+        boolean includesFlowers,
+        boolean useSichuanHuEvaluator
+    ) {
+        this.variant = variant;
+        this.nativeRuleProfile = nativeRuleProfile;
+        this.minimumFan = minimumFan;
+        this.includesHonors = includesHonors;
+        this.includesFlowers = includesFlowers;
+        this.useSichuanHuEvaluator = useSichuanHuEvaluator;
+    }
+
+    public MahjongVariant variant() {
+        return this.variant;
+    }
+
+    public String nativeRuleProfile() {
+        return this.nativeRuleProfile;
+    }
+
+    public int minimumFan() {
+        return this.minimumFan;
+    }
+
+    public boolean includesHonors() {
+        return this.includesHonors;
+    }
+
+    public boolean includesFlowers() {
+        return this.includesFlowers;
+    }
+
+    public boolean useSichuanHuEvaluator() {
+        return this.useSichuanHuEvaluator;
+    }
+
+    public static GbRuleProfile forVariant(MahjongVariant variant) {
+        if (variant == MahjongVariant.SICHUAN) {
+            return SICHUAN;
+        }
+        return GB;
+    }
+}