1. 简介
这个idea插件呢就是 xechat-idea当然也有vscode版本的，vscode可以搜索xechat-vscode,博主本人有相关的笔记链接
说明一下，vscode版本的可以直接在vscode插件市场下载，但是登录的话原有的官方服务器不可用了。现存的有两个地址可用。可用服务器列表的前两个。<br> 其中第二个服务器需要前方qq群754126966找
邪恶鼓励师申请token ,下边的登录命令以第一个服务器为例
- 查询服务器列表
1#showServer
- 登录服务器
1#login {你的名字} -h lesscoding.net -p 1024 2或者 3#login {你的名字} -s 0
- 打开麻将
1#play 12
可以邀请同服务器好友同玩，也可直接开始和ai玩
点击free之后会将游戏页面独立出来一个窗口，该窗口可以调节透明度，摸鱼的时候不容易被发现
2. 开发过程
1. 什么是责任链
我的理解就是每个处理器只处理自己该处理的东西，除非遇到特殊条件，否则就交给下一个处理器来处理
2. 麻将游戏开发。
首先我这里现在只实现了最基本的
平胡和七小对胡牌判断，其他的胡牌类型都写在枚举里边了，有时间的话可以再写<br> 然后 麻将氛围1-9万1-9饼1-9条东南西北中发白<br> 判断顺子的时候需要判断牌的数值是否连续，前边三种万饼条只要数字连续就可以，后边的两种只能组成刻子或者是杠。所以它们的id要隔开。于是就有了下方的这个类
1. 麻将枚举类
1package cn.xeblog.plugin.game.mahjong.enums; 2 3 4import cn.hutool.core.util.StrUtil; 5import lombok.Getter; 6 7import java.util.Arrays; 8 9 10/** 11 * @author eleven 12 * @date 2024/3/20 8:38 13 * @apiNote 14 */ 15@Getter 16public enum MahjongEnum { 17 //🀇 18 YI_WAN(1, "\uD83C\uDC07", "一万"), 19 //🀈 20 ER_WAN(2, "\uD83C\uDC08", "二万"), 21 //🀉 22 SAN_WAN(3, "\uD83C\uDC09", "三万"), 23 //🀊 24 SI_WAN(4, "\uD83C\uDC0A", "四万"), 25 //🀋 26 WU_WAN(5, "\uD83C\uDC0B", "五万"), 27 //🀌 28 LIU_WAN(6, "\uD83C\uDC0C","六万"), 29 //🀍 30 QI_WAN(7, "\uD83C\uDC0D", "七万"), 31 //🀎 32 BA_WAN(8, "\uD83C\uDC0E", "八万"), 33 //🀏 34 JIU_WAN(9, "\uD83C\uDC0F", "九万"), 35 36 //🀐 37 YI_TIAO(11, "\uD83C\uDC10", "一条"), 38 //🀑 39 ER_TIAO(12, "\uD83C\uDC11", "二条"), 40 //🀒 41 SAN_TIAO(13, "\uD83C\uDC12", "三条"), 42 //🀓 43 SI_TIAO(14, "\uD83C\uDC13", "四条"), 44 //🀔 45 WU_TIAO(15, "\uD83C\uDC14", "五条"), 46 //🀕 47 LIU_TIAO(16, "\uD83C\uDC15", "六条"), 48 //🀖 49 QI_TIAO(17, "\uD83C\uDC16", "七条"), 50 //🀗 51 BA_TIAO(18, "\uD83C\uDC17", "八条"), 52 //🀘 53 JIU_TIAO(19, "\uD83C\uDC18", "九条"), 54 55 // 🀙 56 YI_BING(21, "\uD83C\uDC19", "一饼"), 57 //🀚 58 ER_BING(22, "\uD83C\uDC1A", "二饼"), 59 //🀛 60 SAN_BING(23, "\uD83C\uDC1B", "三饼"), 61 //🀜 62 SI_BING(24, "\uD83C\uDC1C", "四饼"), 63 //🀝 64 WU_BING(25, "\uD83C\uDC1D", "五饼"), 65 //🀞 66 LIU_BING(26, "\uD83C\uDC1E", "六饼"), 67 //🀟 68 QI_BING(27, "\uD83C\uDC1F", "七饼"), 69 //🀠 70 BA_BING(28, "\uD83C\uDC20", "八饼"), 71 //🀡 72 JIU_BING(29, "\uD83C\uDC21", "九饼"), 73 74 //🀀 75 DONG_FENG(31, "\uD83C\uDC00", "东风"), 76 //🀁 77 NAN_FENG(33, "\uD83C\uDC01", "南风"), 78 //🀂 79 XI_FENG(35, "\uD83C\uDC02", "西风"), 80 //🀃 81 BEI_FENG(37, "\uD83C\uDC03", "北风"), 82 //🀄 83 HONG_ZHONG(41, "\uD83C\uDC04", "中"), 84 //🀅 85 FA_CAI(43, "\uD83C\uDC05", "发"), 86 //🀆 87 BAI_BAN(45, "\uD83C\uDC06", "白"), 88 89 UNKNOWN(-9527, "\uD83C\uDC22", "暗杠") 90 ; 91 92 private final Integer id; 93 94 private final String value; 95 96 private final String tipsText; 97 98 MahjongEnum(Integer id, String value, String tipsText) { 99 this.id = id; 100 this.value =value; 101 this.tipsText =tipsText; 102 } 103 104 public static MahjongEnum getById(Integer searchId) { 105 return Arrays.stream(MahjongEnum.values()) 106 .filter(item -> item.getId() != null && item.getId().equals(searchId)) 107 .findFirst() 108 .orElse(UNKNOWN); 109 } 110 111 @Override 112 public String toString() { 113 return StrUtil.format("[{}:{}:{}]", id, value, tipsText); 114 } 115}
2. 接着我们写一个判断刻子，顺子，杠，的工具类
这里边的
刻子就是有三个一样的，杠就是四个一样的，顺子就是三个连着的。<br> 一开始的时候没想好怎么写判断顺子，但是后来给枚举加上id之后，只需要判断有没有三个id连续在一起就行了<br> 判断是否能听牌就更加简单粗暴了，如果当前玩家的手牌不能赢，那么就把摸得牌替换完其他所有牌，如果能够胡的话那就是能够听牌。<br> 例如你摸了一个发财没胡，那我就把这个牌替换成1-9万、1-9条、1-9饼、东南西北、中白,只要有一个能胡，那就是听牌了。
- 代码太多了放个链接吧，MahjongUtils.java
3. 胡牌类型枚举
从腾讯麻将里找的规则 完整代码地址
1@Getter 2public enum HuType { 3 TIAN_HU(0, 88, "天胡", "", "庄家发完手牌后直接胡牌"), 4 DI_HU(1, 88, "地胡", "", "发完手牌后，非庄家第一次摸牌就自摸胡牌。如在第一次摸牌前有任意玩家吃碰杠则不算地胡"), 5 SHO_SAN_YAO(2, 88, "十三幺", 6 values(DONG_FENG, NAN_FENG, XI_FENG, BEI_FENG) + 7 values(HONG_ZHONG, FA_CAI, BAI_BAN) + 8 values(YI_WAN, JIU_WAN) + 9 values(YI_TIAO, JIU_TIAO) + 10 values(YI_BING, JIU_BING) + 11 values(YI_WAN), 12 "由3种序数牌的一、九牌，7种字牌及其中一对作将组成的胡牌。不计五门齐、不求人、单钓将、门前清、全带么"); 13}
4. 摸牌类型枚举
1package cn.xeblog.plugin.game.mahjong.enums; 2 3/** 4 * @author eleven 5 * @date 2024/3/20 11:24 6 * @apiNote 7 */ 8public enum TouchType { 9 // 摸 10 TOUCH, 11 // 吃 12 EAT, 13 // 碰 14 BUMP, 15 // 杠 16 BAR, 17 // 测试听牌 18 TEST 19 ; 20}
3. 责任链开发
1. 创建一个责任链的处理对象
1package cn.xeblog.plugin.game.mahjong.model.dto; 2 3import cn.hutool.core.collection.CollUtil; 4import cn.xeblog.plugin.game.mahjong.enums.MahjongEnum; 5import cn.xeblog.plugin.game.mahjong.enums.TouchType; 6import cn.xeblog.plugin.game.mahjong.utils.MahjongUtils; 7import groovy.transform.builder.Builder; 8import lombok.Data; 9 10import java.util.ArrayList; 11import java.util.List; 12import java.util.Optional; 13 14/** 15 * @author eleven 16 * @date 2024/3/20 9:06 17 * @apiNote 18 */ 19@Data 20@Builder 21public class MahjongRequest { 22 // 摸得牌， 可能是 吃碰杠，或者自己摸的 23 private MahjongEnum touchMahjong; 24 // 玩家的手牌 25 private List<MahjongEnum> handMahjong; 26 // 当前轮次，判断天胡，地胡，人胡 27 private Integer round; 28 29 /** 30 * 0 摸排 1吃牌 2碰牌 3杠牌 31 */ 32 private TouchType touchType; 33 // 是否胡牌 34 private Boolean win; 35 // 输出最后的胡牌类型和番数 36 private StringBuilder stringBuilder; 37 /** 38 * 庄家 39 */ 40 private Boolean banker; 41 42 private Long score; 43 // 玩家的刻子，顺子，杠，暗杠 44 private MahjongGroup group; 45 46 // 当前玩家手牌可以听牌的列表 47 private List<MahjongEnum> tingList; 48 49 50 51 public StringBuilder getStringBuilder() { 52 if (stringBuilder == null) { 53 stringBuilder = new StringBuilder(); 54 } 55 return stringBuilder; 56 } 57 58 public void addScore(Long addScore) { 59 Long defaultScore = Optional.ofNullable(score).orElse(0L); 60 this.score = defaultScore + addScore; 61 } 62 63 public Boolean getWin() { 64 return win != null && win; 65 } 66 67 public Boolean getBanker() { 68 return banker != null && banker; 69 } 70 71 public List<MahjongEnum> getAllHandMahjong() { 72 List<MahjongEnum> result = new ArrayList<>(); 73 List<MahjongEnum> handMahjong = getHandMahjong(); 74 if (CollUtil.isNotEmpty(handMahjong)) { 75 result.addAll(handMahjong); 76 } 77 if (null != touchMahjong) { 78 result.add(touchMahjong); 79 } 80 return MahjongUtils.sortById(result); 81 } 82 83 public Integer getRound() { 84 return Optional.ofNullable(round).orElse(0); 85 } 86 87 public MahjongGroup getGroup() { 88 return Optional.ofNullable(group).orElse(new MahjongGroup()); 89 } 90}
2. 首先创建一个抽象类
这个抽象类定义了下一个处理器是谁，公共的处理方法
handler，定义了一个抽象方法isValidWin用来给让每一个实现来判断是否符合自己的胡牌逻辑
1package cn.xeblog.plugin.game.mahjong.handler; 2 3import cn.xeblog.plugin.game.mahjong.model.dto.MahjongRequest; 4import lombok.Data; 5 6/** 7 * @author eleven 8 * @date 2024/3/20 9:04 9 * @apiNote 10 */ 11@Data 12public abstract class HuHandler { 13 14 private HuHandler nextHandler; 15 16 public void handle(MahjongRequest request) { 17 if (nextHandler != null) { 18 nextHandler.handle(request); 19 } 20 } 21 22 public abstract boolean isValidWin(MahjongRequest request); 23 24}
3. 创建一个责任链的构造器
抄的别人的，好像是固定写法
1package cn.xeblog.plugin.game.mahjong.handler; 2 3import cn.xeblog.plugin.game.mahjong.handler.common.*; 4 5import java.util.Arrays; 6 7/** 8 * @author eleven 9 * @date 2024/3/20 13:40 10 * @apiNote 11 */ 12public class HuHandlerBuilder { 13 private HuHandler head; 14 15 private HuHandler tail; 16 17 public HuHandlerBuilder addHandler(HuHandler handler) { 18 if (this.head == null) { 19 this.head = this.tail = handler; 20 return this; 21 } 22 this.tail.setNextHandler(handler); 23 this.tail = handler; 24 return this; 25 } 26 27 public HuHandlerBuilder addHandler(HuHandler... handlers) { 28 if (handlers.length != 0) { 29 Arrays.stream(handlers).forEach(this::addHandler); 30 } 31 return this; 32 } 33 34 public HuHandler build() { 35 return this.head; 36 } 37 38 public static HuHandler fastCommonBuild() { 39 return new HuHandlerBuilder().addHandler( 40 new PingHuHandler(), 41 new SevenPairsHuHandler(), 42 new SelfTouchHuHandler(), 43 new ShiSanYaoHandler(), 44 new TianHuHandler(), 45 new DiHuHandler(), 46 new RenHuHandler() 47 ).build(); 48 } 49 50}
4. 创建一个平胡处理类
具体逻辑自己看看吧，反正就那么回事
1package cn.xeblog.plugin.game.mahjong.handler.common; 2 3import cn.hutool.core.collection.CollUtil; 4import cn.xeblog.plugin.game.mahjong.enums.MahjongEnum; 5import cn.xeblog.plugin.game.mahjong.handler.HuHandler; 6import cn.xeblog.plugin.game.mahjong.model.dto.MahjongGroup; 7import cn.xeblog.plugin.game.mahjong.model.dto.MahjongRequest; 8import cn.xeblog.plugin.game.mahjong.utils.MahjongUtils; 9import org.jetbrains.annotations.Nullable; 10 11import java.util.List; 12import java.util.Map; 13import java.util.Set; 14import java.util.stream.Collectors; 15 16/** 17 * @author eleven 18 * @date 2024/3/20 9:07 19 * @apiNote 20 */ 21public class PingHuHandler extends HuHandler { 22 @Override 23 public void handle(MahjongRequest request) { 24 boolean validWin = isValidWin(request); 25 if (validWin) { 26 request.setWin(true); 27 request.addScore(1L); 28 request.getStringBuilder().append(" 平胡(1)"); 29 } 30 super.handle(request); 31 } 32 33 @Override 34 public boolean isValidWin(MahjongRequest request) { 35 List<MahjongEnum> handMahjong = request.getAllHandMahjong(); 36 Map<Integer, List<MahjongEnum>> map = MahjongUtils.getCountMap(handMahjong); 37 return valid4442(map, request) || valid33332(map, request) || validCommon(handMahjong, request); 38 } 39 40 private boolean validCommon(List<MahjongEnum> handMahjong, MahjongRequest request) { 41 Set<MahjongEnum> gang; 42 //MahjongGroup group = request.getGroup(); 43 MahjongGroup group = new MahjongGroup(); 44 //List<MahjongEnum> pairs = getGroupAndPairsV1(handMahjong, group); 45 List<MahjongEnum> pairs = getGroupAndPairsV2(handMahjong, group); 46 if (pairs == null) return false; 47 request.setGroup(group); 48 int aaaOrAbcNum = group.getGang().size() + 49 group.getKeZi().size() + 50 group.getShunZi().size(); 51 52 return aaaOrAbcNum == 4 && (CollUtil.size(pairs) == 1 || CollUtil.isEmpty(handMahjong)); 53 54 } 55 56 private List<MahjongEnum> getGroupAndPairsV2(List<MahjongEnum> handMahjong, MahjongGroup group) { 57 List<MahjongEnum> pairs = getGroupAndPairsV1(handMahjong, group); 58 Map<Integer, List<MahjongEnum>> map = handMahjong.stream() 59 .collect(Collectors.groupingBy(MahjongEnum::getId)); 60 if (CollUtil.isNotEmpty(pairs)) { 61 boolean doWhileFlag = pairs.stream().anyMatch(item -> map.get(item.getId()).size() > 2); 62 while (pairs.size() > 1 && doWhileFlag) { 63 getGroupAndPairsV1(handMahjong, group); 64 } 65 } 66 return pairs; 67 } 68 69 @Nullable 70 private static List<MahjongEnum> getGroupAndPairsV1(List<MahjongEnum> handMahjong, MahjongGroup group) { 71 Set<MahjongEnum> gang; 72 while (CollUtil.isNotEmpty(gang = MahjongUtils.getGang(handMahjong))) { 73 group.addGang(gang); 74 handMahjong.removeAll(gang); 75 } 76 List<MahjongEnum> pairs = MahjongUtils.getPairs(handMahjong); 77 if (CollUtil.isEmpty(pairs)) { 78 return null; 79 } 80 Set<MahjongEnum> keZi; 81 while (CollUtil.isNotEmpty(keZi = MahjongUtils.getAAA(handMahjong))) { 82 group.addKeZi(keZi); 83 handMahjong.removeAll(keZi); 84 } 85 86 List<MahjongEnum> shunZi; 87 while (CollUtil.isNotEmpty(shunZi = MahjongUtils.getABC(handMahjong))) { 88 group.addShunZi(shunZi); 89 shunZi.forEach(handMahjong::remove); 90 91 } 92 pairs = MahjongUtils.getPairs(handMahjong); 93 94 if (CollUtil.isNotEmpty(pairs)) { 95 group.setPairs(pairs.get(0)); 96 } 97 return pairs; 98 } 99 100 /** 101 * 校验三组四个一样的和一个对子 102 * 103 * @param map 分组数据 104 * @return boolean 105 */ 106 public boolean valid4442(Map<Integer, List<MahjongEnum>> map, MahjongRequest request) { 107 return validSame(map, request); 108 } 109 110 /** 111 * 校验四组三个一样的和一个对子 112 * 113 * @param map 114 * @return 115 */ 116 public boolean valid33332(Map<Integer, List<MahjongEnum>> map, MahjongRequest request) { 117 // todo 现在只校验了四组三个一样 118 return validSame(map, request); 119 } 120 121 122 public boolean validSame(Map<Integer, List<MahjongEnum>> map, MahjongRequest request) { 123 MahjongGroup group = request.getGroup(); 124 for (List<MahjongEnum> value : map.values()) { 125 int size = value.size(); 126 if (size == 4) { 127 group.addGang(Set.copyOf(value)); 128 } 129 if (size == 3) { 130 group.addKeZi(Set.copyOf(value)); 131 } 132 if (size == 2) { 133 group.setPairs(value.get(0)); 134 } 135 } 136 return group.getPairs() != null && 137 (group.getGang().size() == 4 || 138 group.getKeZi().size() == 4); 139 } 140}
5. 创建一个七小对处理器
1package cn.xeblog.plugin.game.mahjong.handler.common; 2 3import cn.xeblog.plugin.game.mahjong.enums.MahjongEnum; 4import cn.xeblog.plugin.game.mahjong.handler.HuHandler; 5import cn.xeblog.plugin.game.mahjong.model.dto.MahjongRequest; 6 7import java.util.List; 8import java.util.Map; 9import java.util.concurrent.atomic.AtomicInteger; 10import java.util.stream.Collectors; 11 12/** 13 * @author eleven 14 * @date 2024/3/20 10:12 15 * @apiNote 七小对 16 */ 17public class SevenPairsHuHandler extends HuHandler { 18 19 @Override 20 public void handle(MahjongRequest request) { 21 boolean validWin = isValidWin(request); 22 if (validWin) { 23 request.setWin(true); 24 request.getStringBuilder().append("七小对"); 25 request.addScore(2L); 26 } 27 super.handle(request); 28 } 29 30 @Override 31 public boolean isValidWin(MahjongRequest request) { 32 List<MahjongEnum> handMahjong = request.getAllHandMahjong(); 33 Map<Integer, List<MahjongEnum>> map = handMahjong.stream() 34 .collect(Collectors.groupingBy(MahjongEnum::getId)); 35 AtomicInteger count = new AtomicInteger(); 36 map.forEach((k, v) -> { 37 if (v.size() % 2 == 0) { 38 count.getAndIncrement(); 39 } 40 }); 41 return count.get() == 7; 42 } 43}
6. 更多类型可以参考HuType这个枚举类自己写
7. 测试
1/** 2 * @author eleven 3 * @date 2024/3/20 11:08 4 * @apiNote 5 */ 6public class MahjongTest { 7 8 9 /** 10 * 七小对 11 */ 12 @Test 13 public void sevenPairs() { 14 List<MahjongEnum> mahjongEnums = MahjongUtils.wan(); 15 mahjongEnums.remove(BA_WAN); 16 mahjongEnums.remove(JIU_WAN); 17 List<MahjongEnum> handMahjong = new ArrayList<>(13); 18 handMahjong.addAll(mahjongEnums); 19 handMahjong.addAll(mahjongEnums); 20 handMahjong.remove(0); 21 MahjongRequest request = new MahjongRequest(); 22 request.setHandMahjong(handMahjong); 23 request.setTouchMahjong(MahjongEnum.YI_WAN); 24 request.setTouchType(TouchType.TOUCH); 25 request.setWin(false); 26 printMahjong(request.getAllHandMahjong()); 27 HuHandler build = HuHandlerBuilder.fastCommonBuild(); 28 build.handle(request); 29 printResponse(request); 30 } 31 32 /** 33 * 前两种情况能够正常判断，后边两种情况判断出错。 34 * 所以需要对特殊牌型进行特殊处理 35 */ 36 @Test 37 public void getPairs() { 38 List<MahjongEnum> handMahjong = new ArrayList<>(); 39 Collections.addAll(handMahjong, 40 YI_BING, YI_BING, 41 YI_BING, ER_BING, SAN_BING, 42 YI_WAN, ER_WAN, SAN_WAN, 43 SI_WAN, WU_WAN, LIU_WAN, 44 QI_WAN, BA_WAN, JIU_WAN 45 ); 46 printMahjong(handMahjong); 47 MahjongUtils.getPairs(handMahjong) 48 .forEach(System.out::println); 49 50 handMahjong.clear(); 51 Collections.addAll(handMahjong, 52 YI_BING, YI_BING, 53 YI_TIAO, ER_TIAO, SAN_TIAO, 54 YI_WAN, ER_WAN, SAN_WAN, 55 SI_WAN, WU_WAN, LIU_WAN, 56 QI_WAN, BA_WAN, JIU_WAN 57 ); 58 printMahjong(handMahjong); 59 MahjongUtils.getPairs(handMahjong) 60 .forEach(System.out::println); 61 62 handMahjong.clear(); 63 Collections.addAll(handMahjong, 64 YI_TIAO, YI_TIAO, YI_TIAO, YI_TIAO, 65 YI_WAN, YI_WAN, YI_WAN, YI_WAN, 66 YI_TIAO, YI_TIAO, YI_TIAO, YI_TIAO, 67 FA_CAI, FA_CAI 68 ); 69 printMahjong(handMahjong); 70 // todo 判断错误应该为 FA_CAI 71 MahjongUtils.getPairs(handMahjong) 72 .forEach(System.out::println); 73 74 handMahjong.clear(); 75 Collections.addAll(handMahjong, 76 YI_TIAO, YI_TIAO, YI_TIAO, 77 YI_WAN, YI_WAN, YI_WAN, 78 YI_TIAO, YI_TIAO, YI_TIAO, 79 DONG_FENG, DONG_FENG, DONG_FENG, 80 FA_CAI, FA_CAI 81 ); 82 printMahjong(handMahjong); 83 MahjongUtils.getPairs(handMahjong) 84 .forEach(System.out::println); 85 } 86 87 @Test 88 public void shiSanYao() { 89 MahjongRequest request = new MahjongRequest(); 90 List<MahjongEnum> handMahjong = new ArrayList<>(14); 91 Collections.addAll(handMahjong, 92 DONG_FENG, NAN_FENG, XI_FENG, BEI_FENG, 93 HONG_ZHONG, FA_CAI, BAI_BAN, 94 YI_WAN, JIU_WAN, 95 YI_TIAO, JIU_TIAO, 96 YI_BING, JIU_BING); 97 request.setHandMahjong(handMahjong); 98 request.setTouchMahjong(JIU_BING); 99 request.setRound(0); 100 request.setBanker(true); 101 request.setTouchType(TouchType.TOUCH); 102 printMahjong(request.getAllHandMahjong()); 103 HuHandlerBuilder.fastCommonBuild().handle(request); 104 printResponse(request); 105 } 106 107 @Test 108 public void pingHuTest() { 109 List<MahjongEnum> handMahjong = new ArrayList<>(); 110 Collections.addAll(handMahjong, 111 YI_WAN, YI_WAN, YI_WAN, YI_WAN, 112 YI_BING, YI_BING, 113 YI_BING, ER_BING, SAN_BING, 114 SI_WAN, SI_WAN, SI_WAN, 115 BAI_BAN, BAI_BAN, BAI_BAN 116 ); 117 MahjongRequest request = new MahjongRequest(); 118 request.setHandMahjong(handMahjong); 119 HuHandler huHandler = HuHandlerBuilder.fastCommonBuild(); 120 huHandler.handle(request); 121 printMahjong(request.getAllHandMahjong()); 122 printResponse(request); 123 } 124 125 @Test 126 public void tingTest() { 127 List<MahjongEnum> list = List.of(SAN_WAN, SI_WAN, WU_WAN, 128 SAN_TIAO, ER_TIAO, 129 WU_WAN, LIU_WAN, QI_WAN, 130 SAN_BING, SI_BING, WU_BING, 131 BAI_BAN, BAI_BAN); 132 System.out.println(MahjongUtils.getTingList(list)); 133 } 134 135 public MahjongRequest getReq(MahjongEnum... enums) { 136 MahjongRequest request = new MahjongRequest(); 137 request.setHandMahjong(List.of(enums)); 138 return request; 139 } 140 141 private void printResponse(MahjongRequest request) { 142 System.out.println(StrUtil.format("当前回合{},身份：{}，得分{}\n胡牌类型{}\n组合{}\n", 143 request.getRound(), 144 request.getBanker() ? "庄" : "闲", 145 request.getScore(), 146 request.getStringBuilder(), 147 request.getGroup())); 148 } 149 150 151 private void printMahjong(List<MahjongEnum> list) { 152 System.out.println("===============当前牌型============"); 153 List<List<MahjongEnum>> partition = Lists.partition(list, 4); 154 partition.forEach(item -> { 155 item.forEach(it -> System.out.print(it + "\t")); 156 System.out.println(); 157 } 158 ); 159 System.out.println("=================================="); 160 } 161}