3734 lines
129 KiB
Java
3734 lines
129 KiB
Java
package taurus.util;
|
||
|
||
import com.taurus.core.util.Logger;
|
||
import hunan.HandAnalysis;
|
||
import hunan.HuNanChangSha;
|
||
|
||
import java.util.*;
|
||
import java.util.stream.Collectors;
|
||
|
||
public class ChangShaSuanFaTest {
|
||
public int drawnCards; //摸牌
|
||
public static List<Integer> tinCards = new ArrayList<>();
|
||
public static boolean isTin = false;
|
||
|
||
public static boolean isChi =false;
|
||
|
||
public static boolean isPeng=false;
|
||
|
||
public static List<Integer> chuguodepai = new ArrayList<>();
|
||
|
||
|
||
// 长沙麻将特殊规则：二五八将
|
||
private static final Set<Integer> JIANG_PAIS;
|
||
|
||
static {
|
||
Set<Integer> jiangSet = new HashSet<>();
|
||
jiangSet.add(2);
|
||
jiangSet.add(5);
|
||
jiangSet.add(8);
|
||
JIANG_PAIS = Collections.unmodifiableSet(jiangSet);
|
||
}
|
||
|
||
|
||
/**
|
||
* 统一日志输出方法
|
||
*/
|
||
private void logInfo(String message) {
|
||
// 注释掉日志输出，减少测试时的信息干扰
|
||
// System.out.println(message);
|
||
}
|
||
|
||
private final static Logger log;
|
||
|
||
static {
|
||
log = Logger.getLogger(ChangShaSuanFaTest.class);
|
||
}
|
||
|
||
/**
|
||
* 主算法入口：在摸牌后、打牌前进行全面分析，确定最优出牌策略
|
||
* 核心流程：摸牌分析 -> 听牌检测 -> 策略制定 -> 出牌选择
|
||
*/
|
||
public String outCardSuanFa(List<Integer> cardInhand, List<Integer> pengCard, List<Integer> chowGroup, List<Integer> resultList) {
|
||
List<Integer> handCards = new ArrayList<>(cardInhand);
|
||
|
||
List<Integer> pinghuhandCards = new ArrayList<>(cardInhand);
|
||
|
||
chuguodepai.addAll(resultList);
|
||
|
||
handCards.addAll(chowGroup);
|
||
handCards.addAll(pengCard);
|
||
|
||
handCards.sort(Integer::compareTo);
|
||
logInfo("排序后机器人手牌: " + handCards);
|
||
int i = countPengGroups(handCards, pengCard); //刻子的数量
|
||
int pisCardsCount = countPairs(handCards);//分析七小对
|
||
//将将胡
|
||
boolean jiangHu = isJiangHu(handCards);
|
||
boolean isPengPengHu = hasThreeKeziAndTwoPairs(handCards, pengCard);
|
||
//清一色碰碰胡
|
||
boolean hasBigSuit = isAllSameSuit(handCards, pengCard); // 分析是否有可能的清一色花色
|
||
System.out.println("resultList +++++++++++++++++++++++================" + resultList);
|
||
|
||
|
||
//六对
|
||
if (pisCardsCount >= 6 && pengCard.size() == 0 && chowGroup.size() == 0) {
|
||
|
||
System.out.println("七小对数量大于等于6+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++");
|
||
//单张牌
|
||
List<Integer> danzhang = danzhang(handCards);
|
||
isTin = true;
|
||
|
||
|
||
Map<Integer, Integer> danzhangCountMap = new HashMap<>();
|
||
|
||
for (Integer card2 : danzhang) {
|
||
danzhangCountMap.put(card2, 0);
|
||
|
||
tinCards.add(card2);
|
||
}
|
||
|
||
|
||
for (Integer card3 : resultList) {
|
||
if (danzhangCountMap.containsKey(card3)) {
|
||
danzhangCountMap.put(card3, danzhangCountMap.get(card3) + 1);
|
||
}
|
||
}
|
||
|
||
// 找到最大的出现次数
|
||
Integer maxCount = danzhangCountMap.values().stream()
|
||
.max(Integer::compareTo)
|
||
.orElse(0);
|
||
|
||
// 找出出现次数等于最大次数的牌
|
||
List<Integer> maxCards = danzhangCountMap.entrySet().stream()
|
||
.filter(entry -> entry.getValue().equals(maxCount))
|
||
.map(Map.Entry::getKey)
|
||
.collect(Collectors.toList());
|
||
|
||
|
||
//102/106
|
||
// 找出maxCards中那些在handCards中出现3次的牌
|
||
List<Integer> threeCardsFromMax = maxCards.stream()
|
||
.filter(card3 -> Collections.frequency(handCards, card3) == 3)
|
||
.collect(Collectors.toList());
|
||
|
||
|
||
if (threeCardsFromMax.size() > 0) {
|
||
List<Integer> zeroCountCards = threeCardsFromMax.stream()
|
||
.filter(card3 -> danzhangCountMap.getOrDefault(card3, 0) == 0)
|
||
.collect(Collectors.toList());
|
||
System.out.println("出现次数为0的牌: " + zeroCountCards);
|
||
// 从maxCards中移除
|
||
if (!zeroCountCards.isEmpty()) {
|
||
maxCards.removeAll(zeroCountCards);
|
||
System.out.println("移除后maxCards: " + maxCards);
|
||
}
|
||
}
|
||
|
||
System.out.println("maxCards中出现3次的牌: " + threeCardsFromMax);
|
||
if (threeCardsFromMax.size() > 0) {
|
||
return String.valueOf(threeCardsFromMax.get(0));
|
||
}
|
||
|
||
Integer maxCard = maxCards.isEmpty() ? null : maxCards.get(0);
|
||
System.out.println("maxCard++++++++++++++++++++++++++++++" + maxCard);
|
||
return String.valueOf(maxCard);
|
||
|
||
}
|
||
|
||
// if (isTin) {
|
||
// System.out.println(" ");
|
||
// System.out.println("==============听牌牌组-=-==========" + tinCards);
|
||
// System.out.println("=========================drawnCards +++++++++++++++++++++++================" + drawnCards);
|
||
// List<Integer> tin = new ArrayList<>(tinCards);
|
||
// System.out.println(" ");
|
||
// System.out.println("---------------tin--------------"+tin);
|
||
// ai ai1 = new ai();
|
||
//// ChangshaMahjongAI ai = new ChangshaMahjongAI();
|
||
// PlayerState playerState = new PlayerState();
|
||
// playerState.handCards = pinghuhandCards;
|
||
//
|
||
//
|
||
// for (int j = 0; j < chowGroup.size(); j += 3) {
|
||
// List<Integer> chigroup = new ArrayList<>(chowGroup.subList(j, Math.min(j + 3, chowGroup.size())));
|
||
// if (chigroup.size() == 3) {
|
||
// playerState.addChiGroup(chigroup);
|
||
// }
|
||
// }
|
||
//
|
||
//
|
||
// for (int h = 0; h < pengCard.size(); h += 3) {
|
||
// List<Integer> penggroup = new ArrayList<>(pengCard.subList(h, Math.min(h + 3, pengCard.size())));
|
||
// if (penggroup.size() == 3) {
|
||
// playerState.addPongGroup(penggroup);
|
||
// }
|
||
// }
|
||
//
|
||
//
|
||
// int bestDiscard = ai1.findBestDiscard(playerState);
|
||
//
|
||
//
|
||
// if (bestDiscard != 0) {
|
||
// if (ai1.isTinAi) {
|
||
// isTin = true;
|
||
// }
|
||
// if (tin.size()<tinCards.size()){
|
||
// System.out.println("----------听牌走ai出牌了-----");
|
||
// return String.valueOf(bestDiscard);
|
||
// }else if (!tinCards.equals(tin)){
|
||
// tinCards.addAll(tin);
|
||
// }
|
||
// }
|
||
//
|
||
//
|
||
//
|
||
// String tinOutCard = isTinOutCard(tinCards, resultList);
|
||
// System.out.println(" ");
|
||
// System.out.println("tinCards-----------" + tinCards);
|
||
// System.out.println("tinOutCard-----------" + tinOutCard);
|
||
// if (tinOutCard.equals("1")) {
|
||
// // 1. 手牌分析 - 识别刻子、顺子、对子等牌型
|
||
// HandAnalysis analysis = analyzeHand(handCards);
|
||
//
|
||
// //最终出的牌
|
||
// int outcard = selectCardToDiscard(pinghuhandCards, analysis);
|
||
// return String.valueOf(outcard);
|
||
// } else {
|
||
// return tinOutCard;
|
||
// }
|
||
//
|
||
//
|
||
// }
|
||
//
|
||
// if (isChi){
|
||
// System.out.println("-----------吃牌听牌中-------");
|
||
// ai ai1 = new ai();
|
||
//// ChangshaMahjongAI ai = new ChangshaMahjongAI();
|
||
// PlayerState playerState = new PlayerState();
|
||
// playerState.handCards = handCards;
|
||
// System.out.println("吃牌听牌chowGroup +++++++++++++++++++++++" + chowGroup);
|
||
// System.out.println("吃牌听牌pengCard +++++++++++++++++++++++" + pengCard);
|
||
//
|
||
// for (int j = 0; j < chowGroup.size(); j += 3) {
|
||
// List<Integer> chigroup = new ArrayList<>(chowGroup.subList(j, Math.min(j + 3, chowGroup.size())));
|
||
// if (chigroup.size() == 3) {
|
||
// playerState.addChiGroup(chigroup);
|
||
// }
|
||
// }
|
||
//
|
||
// System.out.println("吃牌听牌playerState.chiGroups +++++++++++++++++++ " + playerState.chiGroups);
|
||
// System.out.println("吃牌听牌最新 ai出牌--------------------================");
|
||
// for (int h = 0; h < pengCard.size(); h += 3) {
|
||
// List<Integer> penggroup = new ArrayList<>(pengCard.subList(h, Math.min(h + 3, pengCard.size())));
|
||
// if (penggroup.size() == 3) {
|
||
// playerState.addPongGroup(penggroup);
|
||
// }
|
||
// }
|
||
//
|
||
//
|
||
// int bestDiscard = ai1.findBestDiscard(playerState);
|
||
//
|
||
//
|
||
// if (bestDiscard != 0) {
|
||
// if (ai1.isTinAi) {
|
||
// isTin = true;
|
||
// isChi =false;
|
||
// }
|
||
// System.out.println("吃牌听牌出牌长麻 ++++++++++++++++++++++++++++++++++++++");
|
||
// log.info("吃牌听牌出牌长麻==============================="+bestDiscard);
|
||
// return String.valueOf(bestDiscard);
|
||
// }
|
||
// }
|
||
//
|
||
// if (isPeng){
|
||
// System.out.println("-----------碰牌听牌中-------");
|
||
// ai ai1 = new ai();
|
||
//// ChangshaMahjongAI ai = new ChangshaMahjongAI();
|
||
// PlayerState playerState = new PlayerState();
|
||
// playerState.handCards = handCards;
|
||
// System.out.println("碰牌听牌中chowGroup +++++++++++++++++++++++" + chowGroup);
|
||
// System.out.println("碰牌听牌中pengCard +++++++++++++++++++++++" + pengCard);
|
||
//
|
||
// for (int j = 0; j < chowGroup.size(); j += 3) {
|
||
// List<Integer> chigroup = new ArrayList<>(chowGroup.subList(j, Math.min(j + 3, chowGroup.size())));
|
||
// if (chigroup.size() == 3) {
|
||
// playerState.addChiGroup(chigroup);
|
||
// }
|
||
// }
|
||
//
|
||
// System.out.println("碰牌听牌中playerState.chiGroups +++++++++++++++++++ " + playerState.chiGroups);
|
||
// System.out.println("碰牌听牌中最新 ai出牌--------------------================");
|
||
// for (int h = 0; h < pengCard.size(); h += 3) {
|
||
// List<Integer> penggroup = new ArrayList<>(pengCard.subList(h, Math.min(h + 3, pengCard.size())));
|
||
// if (penggroup.size() == 3) {
|
||
// playerState.addPongGroup(penggroup);
|
||
// }
|
||
// }
|
||
//
|
||
//
|
||
// int bestDiscard = ai1.findBestDiscard(playerState);
|
||
//
|
||
//
|
||
// if (bestDiscard != 0) {
|
||
// if (ai1.isTinAi) {
|
||
// isTin = true;
|
||
// isPeng =false;
|
||
// }
|
||
// System.out.println("碰牌听牌中出牌长麻 ++++++++++++++++++++++++++++++++++++++");
|
||
// log.info("碰牌听牌中出牌长麻==============================="+bestDiscard);
|
||
// return String.valueOf(bestDiscard);
|
||
// }
|
||
// }
|
||
|
||
|
||
|
||
//将将胡
|
||
if (jiangHu && chowGroup.size() == 0) {
|
||
logInfo("将将胡");
|
||
int outcard = selectCardToDiscardJiangHu(pinghuhandCards);
|
||
return String.valueOf(outcard);
|
||
}
|
||
|
||
|
||
//打出牌可以听牌了就不要走七对换牌了
|
||
List<Integer> checktingpai = TinHuChi.checktingpai(cardInhand);
|
||
if (pisCardsCount >= 5 && pengCard.size() == 0 && chowGroup.size() == 0 && checktingpai.size() == 0) {
|
||
// ai ai1 = new ai();
|
||
// PlayerState playerState = new PlayerState();
|
||
// playerState.handCards = pinghuhandCards;
|
||
//
|
||
//
|
||
// for (int j = 0; j < chowGroup.size(); j += 3) {
|
||
// List<Integer> chigroup = new ArrayList<>(chowGroup.subList(j, Math.min(j + 3, chowGroup.size())));
|
||
// if (chigroup.size() == 3) {
|
||
// playerState.addChiGroup(chigroup);
|
||
// }
|
||
// }
|
||
//
|
||
//
|
||
// for (int h = 0; h < pengCard.size(); h += 3) {
|
||
// List<Integer> penggroup = new ArrayList<>(pengCard.subList(h, Math.min(h + 3, pengCard.size())));
|
||
// if (penggroup.size() == 3) {
|
||
// playerState.addPongGroup(penggroup);
|
||
// }
|
||
// }
|
||
//
|
||
//
|
||
// int bestDiscard = ai1.findBestDiscard(playerState);
|
||
//
|
||
// if (ai1.isTingpai) {
|
||
// System.out.println("七小对五对，但是出别的牌可以优先听牌，就先走ai出牌---------");
|
||
// //七小对五对，但是出别的牌可以优先听牌，就先走ai出牌
|
||
// return String.valueOf(bestDiscard);
|
||
// }
|
||
|
||
//大胡出牌逻辑 - 七小对
|
||
int outcard = selectCardToDiscardBig(handCards, pisCardsCount);
|
||
return String.valueOf(outcard);
|
||
}
|
||
|
||
|
||
//碰碰胡
|
||
List<Integer> checktingpai1 = TinHuChi.checktingpai(cardInhand);
|
||
|
||
if (i >= 3 && chowGroup.size() == 0 && checktingpai1.size() == 0) {
|
||
if (i == 4) {
|
||
Map<String, List<?>> stringListMap = separateKeziAndRemaining(pinghuhandCards);
|
||
List<?> remaining = stringListMap.get("remaining");
|
||
Map<Integer, Integer> danzhangCountMap = new HashMap<>();
|
||
//循环获取剩余的牌
|
||
for (Object remaining1 : remaining) {
|
||
danzhangCountMap.put((Integer) remaining1, 0);
|
||
}
|
||
|
||
for (Integer card3 : resultList) {
|
||
if (danzhangCountMap.containsKey(card3)) {
|
||
danzhangCountMap.put(card3, danzhangCountMap.get(card3) + 1);
|
||
}
|
||
}
|
||
|
||
Integer maxCount = danzhangCountMap.values().stream()
|
||
.max(Integer::compareTo)
|
||
.orElse(0);
|
||
|
||
|
||
List<Integer> maxCards = danzhangCountMap.entrySet().stream()
|
||
.filter(entry -> entry.getValue().equals(maxCount))
|
||
.map(Map.Entry::getKey)
|
||
.collect(Collectors.toList());
|
||
|
||
Integer maxCard = maxCards.isEmpty() ? null : maxCards.get(0);
|
||
return String.valueOf(maxCard);
|
||
|
||
}
|
||
|
||
// if (isPengPengHu) {
|
||
// return selectCardToDiscardPengPengHu(pinghuhandCards);
|
||
//// System.out.println("--------------------------------碰碰胡 3刻子 ，2对子----==========================");
|
||
//// Map<String, List<?>> stringListMap = separateKeziAndRemaining(handCards);
|
||
//// List<?> remaining = stringListMap.get("remaining");
|
||
//// Map<Integer, Integer> danzhangCountMap = new HashMap<>();
|
||
//// //循环获取剩余的牌
|
||
//// for (Object remaining1 : remaining) {
|
||
//// danzhangCountMap.put((Integer) remaining1, 0);
|
||
//// }
|
||
////
|
||
//// for (Integer card3 : resultList) {
|
||
//// if (danzhangCountMap.containsKey(card3)) {
|
||
//// danzhangCountMap.put(card3, danzhangCountMap.get(card3) + 1);
|
||
//// }
|
||
//// }
|
||
////
|
||
//// Integer maxCount = danzhangCountMap.values().stream()
|
||
//// .max(Integer::compareTo)
|
||
//// .orElse(0);
|
||
////
|
||
////
|
||
//// List<Integer> maxCards = danzhangCountMap.entrySet().stream()
|
||
//// .filter(entry -> entry.getValue().equals(maxCount))
|
||
//// .map(Map.Entry::getKey)
|
||
//// .collect(Collectors.toList());
|
||
////
|
||
//// Integer maxCard = maxCards.isEmpty() ? null : maxCards.get(0);
|
||
//// System.out.println("==========碰碰胡----====maxCard++++++++++++++++++++++++++++++" + maxCard);
|
||
//// return String.valueOf(maxCard);
|
||
// }
|
||
}
|
||
|
||
|
||
|
||
|
||
|
||
//七小对清一色
|
||
List<Integer> qixiaoduiqingyise = qixiaoduiqingyise(handCards);
|
||
boolean isqingyiseqixiaodui = hasFourOrMorePairs(qixiaoduiqingyise);
|
||
if (isqingyiseqixiaodui && pengCard.size() == 0 && chowGroup.size() == 0) {
|
||
logInfo("执行清一色七小对策略，尝试优化七小对分布");
|
||
// 调用花色分析的清一色七小对出牌策略
|
||
String discardCard = selectCardToDiscardAllSameSuitQiXiaoDuiBySuit(handCards);
|
||
if (discardCard != null) {
|
||
return discardCard;
|
||
}
|
||
}
|
||
|
||
|
||
if (hasBigSuit && i >= 3 && chowGroup.size() == 0) {
|
||
logInfo("清一色碰碰胡");
|
||
String discardCard = selectCardToDiscardPengPeng(pinghuhandCards);
|
||
if (discardCard != null) {
|
||
return discardCard;
|
||
}
|
||
}
|
||
|
||
|
||
if (hasBigSuit) {
|
||
logInfo("执行清一色策略，尝试优化花色分布");
|
||
|
||
//满足清一色,但是平胡可以快速听牌，就走平胡 ，两手听牌
|
||
//如果可以快速听牌，就走平胡
|
||
//首先分析是否听牌，如果为听牌就去分析差几手牌听牌，差两手就走平胡
|
||
|
||
List<Integer> integers = ChangshaWinSplitCard.analyzeBestDiscard(pinghuhandCards);
|
||
Integer integer = 0;
|
||
|
||
integer = selectBestCardByPriority(integers);
|
||
|
||
|
||
if (integers.size()>1){
|
||
integer = selectBestCardRemove258(integers);
|
||
}
|
||
|
||
|
||
if (integers.size() > 0) {
|
||
System.out.println("清一色 平胡最新出牌策略=============================================== 666 " + integer);
|
||
return String.valueOf(integer);
|
||
}
|
||
|
||
|
||
ai ai2 = new ai();
|
||
PlayerState playerState1 = new PlayerState();
|
||
playerState1.handCards = pinghuhandCards;
|
||
|
||
|
||
for (int j = 0; j < chowGroup.size(); j += 3) {
|
||
List<Integer> chigroup = new ArrayList<>(chowGroup.subList(j, Math.min(j + 3, chowGroup.size())));
|
||
if (chigroup.size() == 3) {
|
||
playerState1.addChiGroup(chigroup);
|
||
}
|
||
}
|
||
|
||
|
||
for (int h = 0; h < pengCard.size(); h += 3) {
|
||
List<Integer> penggroup = new ArrayList<>(pengCard.subList(h, Math.min(h + 3, pengCard.size())));
|
||
if (penggroup.size() == 3) {
|
||
playerState1.addPongGroup(penggroup);
|
||
}
|
||
}
|
||
|
||
|
||
int bestDiscard1 = ai2.findBestDiscard(playerState1);
|
||
|
||
if (ai2.isTingpai) {
|
||
return String.valueOf(bestDiscard1);
|
||
}
|
||
|
||
|
||
TingPaiChecker.TingResult tingResult = TingPaiChecker.checkTingPai(handCards);
|
||
if (tingResult.isTingPai()){
|
||
isTin = true;
|
||
return String.valueOf(drawnCards);
|
||
}
|
||
int num =analyzeHandCards(handCards);
|
||
System.out.println("0000000000000000000000000000000 ----"+num);
|
||
if (num>=3){
|
||
System.out.println("----------num 3333 ---------------"+num);
|
||
ai ai1 = new ai();
|
||
// ChangshaMahjongAI ai = new ChangshaMahjongAI();
|
||
PlayerState playerState = new PlayerState();
|
||
playerState.handCards = pinghuhandCards;
|
||
|
||
|
||
for (int j = 0; j < chowGroup.size(); j += 3) {
|
||
List<Integer> chigroup = new ArrayList<>(chowGroup.subList(j, Math.min(j + 3, chowGroup.size())));
|
||
if (chigroup.size() == 3) {
|
||
playerState.addChiGroup(chigroup);
|
||
}
|
||
}
|
||
|
||
|
||
for (int h = 0; h < pengCard.size(); h += 3) {
|
||
List<Integer> penggroup = new ArrayList<>(pengCard.subList(h, Math.min(h + 3, pengCard.size())));
|
||
if (penggroup.size() == 3) {
|
||
playerState.addPongGroup(penggroup);
|
||
}
|
||
}
|
||
|
||
|
||
int bestDiscard = ai1.findBestDiscard(playerState);
|
||
|
||
|
||
if (bestDiscard != 0) {
|
||
if (ai1.isTinAi) {
|
||
isTin = true;
|
||
}
|
||
|
||
return String.valueOf(bestDiscard);
|
||
}
|
||
}
|
||
|
||
// 调用清一色特定出牌策略
|
||
int outcard = selectCardToDiscardForAllSameSuit(pinghuhandCards, chowGroup, pengCard);
|
||
if (outcard != -1) {
|
||
return String.valueOf(outcard);
|
||
}
|
||
}
|
||
|
||
System.out.println("00000000000000000000000000000000000000000000000000000000000000000000000");
|
||
|
||
|
||
// List<Integer> hands = new ArrayList<>();
|
||
// hands.addAll(pinghuhandCards);
|
||
// if (chowGroup.size() > 0){
|
||
// hands.addAll(chowGroup);
|
||
// }
|
||
//
|
||
// if (pengCard.size() > 0){
|
||
// hands.addAll(pengCard);
|
||
//
|
||
// }
|
||
|
||
// System.out.println("平胡最新hands=================================" +hands);
|
||
List<Integer> integers = ChangshaWinSplitCard.analyzeBestDiscard(pinghuhandCards);
|
||
Integer integer = 0;
|
||
|
||
integer = selectBestCardByPriority(integers);
|
||
|
||
|
||
if (integers.size()>1){
|
||
integer = selectBestCardRemove258(integers);
|
||
}
|
||
|
||
|
||
if (integers.size() > 0) {
|
||
System.out.println("平胡最新出牌策略=============================================== 666 " + integer);
|
||
return String.valueOf(integer);
|
||
}
|
||
|
||
|
||
ai ai1 = new ai();
|
||
// ChangshaMahjongAI ai = new ChangshaMahjongAI();
|
||
PlayerState playerState = new PlayerState();
|
||
playerState.handCards = pinghuhandCards;
|
||
System.out.println("chowGroup +++++++++++++++++++++++" + chowGroup);
|
||
System.out.println("pengCard +++++++++++++++++++++++" + pengCard);
|
||
|
||
for (int j = 0; j < chowGroup.size(); j += 3) {
|
||
List<Integer> chigroup = new ArrayList<>(chowGroup.subList(j, Math.min(j + 3, chowGroup.size())));
|
||
if (chigroup.size() == 3) {
|
||
playerState.addChiGroup(chigroup);
|
||
}
|
||
}
|
||
|
||
System.out.println("playerState.chiGroups +++++++++++++++++++ " + playerState.chiGroups);
|
||
System.out.println("最新 ai出牌--------------------================");
|
||
for (int h = 0; h < pengCard.size(); h += 3) {
|
||
List<Integer> penggroup = new ArrayList<>(pengCard.subList(h, Math.min(h + 3, pengCard.size())));
|
||
if (penggroup.size() == 3) {
|
||
playerState.addPongGroup(penggroup);
|
||
}
|
||
}
|
||
|
||
|
||
int bestDiscard = ai1.findBestDiscard(playerState);
|
||
|
||
|
||
if (bestDiscard != 0) {
|
||
if (ai1.isTinAi) {
|
||
isTin = true;
|
||
}
|
||
System.out.println("Ai出牌长麻 ++++++++++++++++++++++++++++++++++++++");
|
||
log.info("Ai出牌长麻===============================");
|
||
return String.valueOf(bestDiscard);
|
||
}
|
||
|
||
|
||
|
||
|
||
// 1. 手牌分析 - 识别刻子、顺子、对子等牌型
|
||
HandAnalysis analysis = analyzeHand(handCards);
|
||
|
||
//最终出的牌
|
||
int outcard = selectCardToDiscard(handCards, analysis);
|
||
|
||
|
||
logInfo("\n===== 手牌分析结果 =====");
|
||
logInfo("按花色分组的牌: " + analysis.cardsBySuit);
|
||
logInfo("已完成的刻子/顺子: " + analysis.completedMelds);
|
||
logInfo("对子: " + analysis.pairs);
|
||
logInfo("孤张牌: " + analysis.isolatedCards);
|
||
logInfo("面子数量: " + analysis.meldCount);
|
||
logInfo("对子数量: " + analysis.pairCount);
|
||
logInfo("听牌状态: " + analysis.isTingPai);
|
||
if (analysis.isTingPai) {
|
||
logInfo("可胡牌: " + analysis.tingCards);
|
||
}
|
||
logInfo("向听数: " + analysis.shantenCount);
|
||
logInfo("有龙七对潜力: " + analysis.hasLongQiDuiPotential);
|
||
logInfo("有碰碰胡潜力: " + analysis.hasPengPengHu);
|
||
logInfo("剩余需要分析的牌: " + analysis.remainingCards);
|
||
|
||
//如果已经是听牌状态的情况
|
||
if (analysis.isTingPai) {
|
||
System.out.println("已经是听牌状态----" + drawnCards);
|
||
return String.valueOf(drawnCards);
|
||
}
|
||
|
||
System.out.println("最终出的牌------" + outcard);
|
||
return String.valueOf(outcard);
|
||
|
||
|
||
}
|
||
|
||
// 从候选牌中选出最优的一张牌，优先去除258将牌
|
||
public static Integer selectBestCardRemove258(List<Integer> cards) {
|
||
if (cards == null || cards.isEmpty()) {
|
||
return null;
|
||
}
|
||
|
||
// 如果只有一张牌，直接返回
|
||
if (cards.size() == 1) {
|
||
return cards.get(0);
|
||
}
|
||
|
||
// 创建非258牌的列表
|
||
List<Integer> non258Cards = new ArrayList<>();
|
||
List<Integer> is258Cards = new ArrayList<>();
|
||
|
||
// 分类：258牌和非258牌
|
||
for (Integer card : cards) {
|
||
if (is258Jiang(card)) {
|
||
is258Cards.add(card);
|
||
} else {
|
||
non258Cards.add(card);
|
||
}
|
||
}
|
||
|
||
System.out.println("258将牌: " + is258Cards);
|
||
System.out.println("非258牌: " + non258Cards);
|
||
|
||
// 优先从非258牌中选
|
||
if (!non258Cards.isEmpty()) {
|
||
return selectBestSingleCard(non258Cards);
|
||
}
|
||
|
||
// 如果没有非258牌，从258牌中选
|
||
if (!is258Cards.isEmpty()) {
|
||
return selectBestSingleCard(is258Cards);
|
||
}
|
||
|
||
return null;
|
||
}
|
||
|
||
// 检测是否满足258做将的条件
|
||
private static boolean is258Jiang(int card) {
|
||
// 提取牌的类型和值
|
||
int type = card / 100; // 百位数：1-万，2-筒，3-条，4-风，5-箭
|
||
int value = card % 100; // 个位数：牌面值
|
||
|
||
// 只有万、筒、条有258做将的限制
|
||
if (type >= 1 && type <= 3) {
|
||
// 258做将：二万(102)、五万(105)、八万(108)
|
||
// 二筒(202)、五筒(205)、八筒(208)
|
||
// 二条(302)、五条(305)、八条(308)
|
||
return value == 2 || value == 5 || value == 8;
|
||
}
|
||
return false;
|
||
}
|
||
|
||
// 从候选牌中选出最优的一张牌（优先边张1或9）
|
||
public static Integer selectBestSingleCard(List<Integer> cards) {
|
||
if (cards == null || cards.isEmpty()) {
|
||
return null;
|
||
}
|
||
|
||
// 优先找边张（1或9）
|
||
for (Integer card : cards) {
|
||
int value = card % 100;
|
||
if (value == 1 || value == 9) {
|
||
return card;
|
||
}
|
||
}
|
||
|
||
// 没有边张，找靠近边张的牌（2或8）- 注意这里2是258将牌，但我们已经去除了258
|
||
for (Integer card : cards) {
|
||
int value = card % 100;
|
||
if (value == 2 || value == 8) {
|
||
return card;
|
||
}
|
||
}
|
||
|
||
// 都没有，返回第一张
|
||
return cards.get(0);
|
||
}
|
||
|
||
public static Integer selectBestCardByPriority(List<Integer> cards) {
|
||
if (cards == null || cards.isEmpty()) {
|
||
return null;
|
||
}
|
||
|
||
Integer bestCard = null;
|
||
int bestPriority = Integer.MAX_VALUE;
|
||
|
||
for (Integer card : cards) {
|
||
int value = card % 100;
|
||
int priority = getCardPriority(value);
|
||
|
||
if (priority < bestPriority) {
|
||
bestPriority = priority;
|
||
bestCard = card;
|
||
} else if (priority == bestPriority) {
|
||
// 优先级相同，比较牌值（小的优先）
|
||
if (bestCard == null || value < (bestCard % 100)) {
|
||
bestCard = card;
|
||
}
|
||
}
|
||
}
|
||
|
||
return bestCard;
|
||
}
|
||
|
||
// 牌的优先级（数字越小优先级越高）
|
||
private static int getCardPriority(int value) {
|
||
if (value == 9) return 1;
|
||
if (value == 1) return 2;
|
||
if (value == 2 || value == 8) return 3; // 靠近边张
|
||
if (value >= 3 && value <= 7) return 4; // 中间牌
|
||
return 5; // 其他
|
||
}
|
||
//听牌之后去分析出牌
|
||
|
||
private String isTinOutCard(List<Integer> tinCards, List<Integer> resultList) {
|
||
// 统计听牌组中每张牌在牌桌上的出现次数
|
||
Map<Integer, Integer> tinCardCountMap = new HashMap<>();
|
||
|
||
// 初始化听牌组中所有牌的出现次数为0
|
||
for (Integer card : tinCards) {
|
||
tinCardCountMap.put(card, 0);
|
||
}
|
||
|
||
// 统计听牌组中每张牌在牌桌上的实际出现次数
|
||
for (Integer card : resultList) {
|
||
if (tinCardCountMap.containsKey(card)) {
|
||
tinCardCountMap.put(card, tinCardCountMap.get(card) + 1);
|
||
}
|
||
}
|
||
|
||
// 找到最大的出现次数
|
||
Integer maxCount = tinCardCountMap.values().stream()
|
||
.max(Integer::compareTo)
|
||
.orElse(0);
|
||
|
||
// 判断所有听牌是否都大于等于3次
|
||
boolean allGreaterOrEqualThree = !tinCardCountMap.isEmpty() &&
|
||
tinCardCountMap.values().stream().allMatch(count -> count >= 3);
|
||
|
||
if (allGreaterOrEqualThree) {
|
||
isTin = false;
|
||
// 如果所有听牌都出现大于等于3次，则随机出一张听牌
|
||
Integer randomCard = tinCards.get(new Random().nextInt(tinCards.size()));
|
||
System.out.println("所有听牌出现次数都>=3，随机出牌: " + randomCard);
|
||
tinCards.remove(randomCard);
|
||
return "1";
|
||
|
||
|
||
}
|
||
|
||
if (maxCount > 0 && maxCount < 3 && tinCards.size() > 1) {
|
||
// 出现次数大于0但小于3，也直接出次数最多的牌
|
||
List<Integer> maxCards = tinCardCountMap.entrySet().stream()
|
||
.filter(entry -> entry.getValue().equals(maxCount))
|
||
.map(Map.Entry::getKey)
|
||
.collect(Collectors.toList());
|
||
|
||
if (!maxCards.isEmpty()) {
|
||
isTin = false;
|
||
Integer maxCard = Collections.max(maxCards);
|
||
System.out.println("出现次数大于0，直接出牌: " + maxCard);
|
||
tinCards.remove(maxCard);
|
||
return "1";
|
||
}
|
||
} else {
|
||
return String.valueOf(drawnCards);
|
||
}
|
||
|
||
// 如果所有听牌在牌桌上都没出现过（maxCount为0），或者需要调整听牌状态
|
||
if (maxCount == 0) {
|
||
//将tinCards转成map格式
|
||
return String.valueOf(drawnCards);
|
||
}
|
||
|
||
|
||
// 返回一个默认值或处理逻辑（根据您的实际需求调整）
|
||
return "0";
|
||
}
|
||
|
||
private List<Integer> danzhang(List<Integer> handCards) {
|
||
// 统计每张牌出现的次数
|
||
Map<Integer, Integer> cardCountMap = new HashMap<>();
|
||
for (Integer card : handCards) {
|
||
cardCountMap.put(card, cardCountMap.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
System.out.println("统计结果: " + cardCountMap);
|
||
|
||
List<Integer> singleCards = new ArrayList<>();
|
||
|
||
// 遍历手牌，计算哪些是单张
|
||
for (Map.Entry<Integer, Integer> entry : cardCountMap.entrySet()) {
|
||
int card = entry.getKey();
|
||
int count = entry.getValue();
|
||
|
||
// 计算剩余单张的数量
|
||
int remainder = count % 2; // 取模2，奇数就有一个单张
|
||
if (remainder == 1) {
|
||
singleCards.add(card);
|
||
}
|
||
|
||
}
|
||
return singleCards;
|
||
}
|
||
|
||
private int selectCardToDiscardJiangHu(List<Integer> handCards) {
|
||
List<Integer> tempHand = new ArrayList<>(handCards);
|
||
|
||
|
||
// 1. 统计牌型
|
||
Map<Integer, Integer> countMap = new HashMap<>();
|
||
for (int c : tempHand) {
|
||
countMap.put(c, countMap.getOrDefault(c, 0) + 1);
|
||
}
|
||
|
||
// 2. 找出所有258对子（候选将牌）
|
||
List<Integer> jiangCandidates = new ArrayList<>();
|
||
for (Map.Entry<Integer, Integer> entry : countMap.entrySet()) {
|
||
if (entry.getValue() >= 2 && isCard(entry.getKey())) {
|
||
jiangCandidates.add(entry.getKey());
|
||
}
|
||
}
|
||
|
||
// 3. 选择最优将牌（优先选择数量多的258对子）
|
||
Integer bestJiang = selectBestJiang(jiangCandidates, countMap);
|
||
|
||
// 4. 构建需要保留的牌（将牌 + 所有258牌）
|
||
Set<Integer> keepCards = new HashSet<>();
|
||
|
||
// 保留所有258牌（包括将牌）
|
||
for (int c : tempHand) {
|
||
if (is258Card(c)) {
|
||
keepCards.add(c);
|
||
}
|
||
}
|
||
|
||
// 5. 找出需要打出的牌（非258牌）
|
||
List<Integer> discardCandidates = new ArrayList<>();
|
||
for (int c : tempHand) {
|
||
if (!isCard(c)) {
|
||
discardCandidates.add(c);
|
||
}
|
||
}
|
||
|
||
// 6. 如果有非258牌，优先打出
|
||
if (!discardCandidates.isEmpty()) {
|
||
return discardCandidates.get(0); // 可以优化选择策略
|
||
}
|
||
|
||
// 7. 如果全是258牌，但还没有将牌，需要拆牌做将
|
||
if (bestJiang == null) {
|
||
return selectCardToMakeJiang(tempHand, countMap);
|
||
}
|
||
|
||
// 8. 如果全是258牌且有将牌，打出多余的258牌
|
||
return selectRedundant258Card(tempHand, countMap, bestJiang);
|
||
}
|
||
|
||
/**
|
||
* 选择最优的将牌
|
||
*/
|
||
private Integer selectBestJiang(List<Integer> jiangCandidates, Map<Integer, Integer> countMap) {
|
||
if (jiangCandidates.isEmpty()) {
|
||
return null;
|
||
}
|
||
|
||
// 策略：优先选择数量多的258对子（更容易碰成刻子）
|
||
Integer bestJiang = null;
|
||
int maxCount = 0;
|
||
|
||
for (int candidate : jiangCandidates) {
|
||
int count = countMap.get(candidate);
|
||
if (count > maxCount) {
|
||
maxCount = count;
|
||
bestJiang = candidate;
|
||
}
|
||
}
|
||
|
||
return bestJiang;
|
||
}
|
||
|
||
/**
|
||
* 当没有将牌时，选择一张牌来促成将牌
|
||
*/
|
||
private int selectCardToMakeJiang(List<Integer> handCards, Map<Integer, Integer> countMap) {
|
||
// 策略：打出手牌中数量最少的258孤张
|
||
for (int c : handCards) {
|
||
if (countMap.get(c) == 1) {
|
||
return c;
|
||
}
|
||
}
|
||
|
||
// 如果没有孤张，打出手牌中数量最少的258
|
||
int minCount = Integer.MAX_VALUE;
|
||
int worstCard = handCards.get(0);
|
||
|
||
for (int c : handCards) {
|
||
int count = countMap.get(c);
|
||
if (count < minCount) {
|
||
minCount = count;
|
||
worstCard = c;
|
||
}
|
||
}
|
||
|
||
return worstCard;
|
||
}
|
||
|
||
/**
|
||
* 选择多余的258牌打出
|
||
*/
|
||
private int selectRedundant258Card(List<Integer> handCards, Map<Integer, Integer> countMap, int bestJiang) {
|
||
// 策略：保留将牌，打出非将牌的258孤张
|
||
|
||
// 1. 先找非将牌的孤张
|
||
for (int c : handCards) {
|
||
if (c != bestJiang && countMap.get(c) == 1) {
|
||
return c;
|
||
}
|
||
}
|
||
|
||
// 2. 找数量最少的非将牌
|
||
int minCount = Integer.MAX_VALUE;
|
||
int worstCard = handCards.get(0);
|
||
|
||
for (int c : handCards) {
|
||
if (c != bestJiang) {
|
||
int count = countMap.get(c);
|
||
if (count < minCount) {
|
||
minCount = count;
|
||
worstCard = c;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 3. 如果所有牌都是将牌，只能拆将牌（这种情况很少）
|
||
if (worstCard == bestJiang) {
|
||
// 选择一张将牌打出（保留另一张）
|
||
return bestJiang;
|
||
}
|
||
|
||
return worstCard;
|
||
}
|
||
|
||
/**
|
||
* 判断是否是258牌
|
||
*/
|
||
private boolean isCard(int card) {
|
||
int cardValue = card % 10;
|
||
int cardType = card / 100;
|
||
|
||
if (cardValue == 2 || cardValue == 5 || cardValue == 8) {
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
|
||
/**
|
||
* 判断手牌中是否有碰牌（刻子）
|
||
* 刻子定义：三张花色相同且点数相同的牌
|
||
* 长沙麻将中碰牌需要满足至少三组刻子
|
||
*/
|
||
/**
|
||
* 统计手牌中的刻子数量
|
||
* 刻子定义：三张花色相同且点数相同的牌
|
||
*
|
||
* @param handCards 手牌列表
|
||
* @return 刻子数量
|
||
*/
|
||
private int countPengGroups(List<Integer> handCards, List<Integer> pengCard) {
|
||
List<Integer> handCards2 = new ArrayList<>();
|
||
handCards2.addAll(handCards);
|
||
// handCards2.addAll(pengCard);
|
||
System.out.println("碰碰胡 handCards2 ++++++++++++++++" + handCards2);
|
||
|
||
// 按花色分组
|
||
Map<Integer, List<Integer>> suitGroupMap = new HashMap<>();
|
||
for (Integer card : handCards2) {
|
||
int suit = card / 100;
|
||
suitGroupMap.computeIfAbsent(suit, k -> new ArrayList<>()).add(card);
|
||
}
|
||
|
||
logInfo("手牌花色分组: " + suitGroupMap.keySet().size() + " 种花色");
|
||
|
||
int keziCount = 0;
|
||
|
||
// 对每个花色分别统计刻子
|
||
for (Map.Entry<Integer, List<Integer>> entry : suitGroupMap.entrySet()) {
|
||
int suit = entry.getKey();
|
||
List<Integer> suitCards = entry.getValue();
|
||
|
||
// 统计该花色下每张牌的数量
|
||
Map<Integer, Integer> valueCountMap = new HashMap<>();
|
||
for (Integer card : suitCards) {
|
||
int value = card % 100;
|
||
valueCountMap.put(value, valueCountMap.getOrDefault(value, 0) + 1);
|
||
}
|
||
|
||
// 找出该花色的刻子
|
||
for (Map.Entry<Integer, Integer> valueEntry : valueCountMap.entrySet()) {
|
||
if (valueEntry.getValue() >= 3) {
|
||
keziCount++;
|
||
int cardValue = suit * 100 + valueEntry.getKey();
|
||
logInfo("找到刻子: " + getCardName(cardValue) + " (花色:" + getSuitName(suit) +
|
||
", 点数:" + valueEntry.getKey() + ", 数量:" + valueEntry.getValue() + ")");
|
||
}
|
||
}
|
||
}
|
||
|
||
logInfo("手牌中共找到 " + keziCount + " 组刻子");
|
||
return keziCount;
|
||
}
|
||
|
||
|
||
//分析碰碰胡是否听牌
|
||
public boolean hasThreeKeziAndTwoPairs(List<Integer> handCards, List<Integer> pengCard) {
|
||
List<Integer> handCards2 = new ArrayList<>();
|
||
handCards2.addAll(handCards);
|
||
// handCards2.addAll(pengCard);
|
||
|
||
// 统计每张牌出现的次数
|
||
Map<Integer, Integer> cardCountMap = new HashMap<>();
|
||
for (Integer card : handCards2) {
|
||
cardCountMap.put(card, cardCountMap.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
int keziCount = 0; // 刻子数（三张相同）
|
||
int pairCount = 0; // 对子数（两张相同）
|
||
|
||
// 统计刻子和对子
|
||
for (int count : cardCountMap.values()) {
|
||
if (count >= 3) {
|
||
// 如果有3张或以上，可以算作一个刻子
|
||
keziCount++;
|
||
// 如果有4张，剩余的1张不能算对子，但可能算单张
|
||
if (count >= 4) {
|
||
// 4张可以看作1个刻子+1张单牌，或者如果有需要可以调整
|
||
// 这里暂时不额外处理
|
||
}
|
||
} else if (count == 2) {
|
||
pairCount++;
|
||
}
|
||
}
|
||
|
||
// 检查是否有至少3个刻子和至少2个对子
|
||
return keziCount >= 3 && pairCount >= 2;
|
||
}
|
||
|
||
|
||
//拿出剩余牌
|
||
private static Map<String, List<?>> separateKeziAndRemaining(List<Integer> handCards) {
|
||
List<List<Integer>> keziList = new ArrayList<>();
|
||
Set<Integer> remainingCardsSet = new HashSet<>(); // 使用Set去重
|
||
|
||
if (handCards == null || handCards.isEmpty()) {
|
||
Map<String, List<?>> result = new HashMap<>();
|
||
result.put("kezi", keziList);
|
||
result.put("remaining", new ArrayList<>());
|
||
return result;
|
||
}
|
||
|
||
// 统计每张牌的数量
|
||
Map<Integer, Integer> countMap = new HashMap<>();
|
||
for (Integer card : handCards) {
|
||
countMap.put(card, countMap.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
// 分离刻子
|
||
for (Map.Entry<Integer, Integer> entry : countMap.entrySet()) {
|
||
int card = entry.getKey();
|
||
int count = entry.getValue();
|
||
|
||
if (count >= 3) {
|
||
// 添加刻子
|
||
List<Integer> kezi = new ArrayList<>();
|
||
for (int i = 0; i < 3; i++) {
|
||
kezi.add(card);
|
||
}
|
||
keziList.add(kezi);
|
||
|
||
// 如果还有剩余，加入Set去重
|
||
if (count > 3) {
|
||
remainingCardsSet.add(card);
|
||
}
|
||
} else {
|
||
// 全部加入剩余牌Set
|
||
remainingCardsSet.add(card);
|
||
}
|
||
}
|
||
|
||
// 将Set转换为List
|
||
List<Integer> remainingCards = new ArrayList<>(remainingCardsSet);
|
||
|
||
Map<String, List<?>> result = new HashMap<>();
|
||
result.put("kezi", keziList);
|
||
result.put("remaining", remainingCards);
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 辅助方法：获取牌的名称
|
||
*/
|
||
private String getCardName(int card) {
|
||
int suit = card / 100;
|
||
int value = card % 100;
|
||
String suitName = getSuitName(suit);
|
||
return suitName + value;
|
||
}
|
||
|
||
private boolean isJiangHu(List<Integer> handCards) {
|
||
// 统计手牌中258牌的数量
|
||
int count258 = 0;
|
||
|
||
for (Integer card : handCards) {
|
||
if (is258Card(card)) {
|
||
count258++;
|
||
}
|
||
}
|
||
|
||
// 判断258牌是否大于7张
|
||
return count258 >= 10;
|
||
}
|
||
|
||
/**
|
||
* 判断一张牌是否是258牌
|
||
*/
|
||
private boolean is258Card(int card) {
|
||
// 假设牌型编码规则：
|
||
// 101-109: 一万到九万
|
||
// 201-209: 一筒到九筒
|
||
// 301-309: 一条到九条
|
||
|
||
// 获取牌的数字（个位数）
|
||
int cardValue = card % 10;
|
||
|
||
// 258牌的数字必须是2、5、8
|
||
if (cardValue == 2 || cardValue == 5 || cardValue == 8) {
|
||
// 确保是万、筒、条（排除风牌等）
|
||
int cardType = card / 100;
|
||
return true;
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 七小对大胡策略出牌
|
||
* 当有5对以上时，按照七小对胡牌牌型进行出牌
|
||
*/
|
||
public int selectCardToDiscardBig(List<Integer> handCards, int pisCardsCount) {
|
||
if (pisCardsCount >= 5) {
|
||
logInfo("执行七小对大胡策略，当前对子数量: " + pisCardsCount);
|
||
|
||
// 统计每张牌的数量
|
||
Map<Integer, Integer> cardCounts = new HashMap<>();
|
||
for (int card : handCards) {
|
||
cardCounts.put(card, cardCounts.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
// 收集单张牌（数量为1的牌）
|
||
List<Integer> singleCards = new ArrayList<>();
|
||
for (int card : handCards) {
|
||
if (cardCounts.get(card) == 1) {
|
||
singleCards.add(card);
|
||
}
|
||
}
|
||
|
||
// 如果有单张牌，优先打出这些牌
|
||
if (!singleCards.isEmpty()) {
|
||
// 优先打出边张（1和9）
|
||
for (int card : singleCards) {
|
||
int value = card % 100;
|
||
if (value == 1 || value == 9) {
|
||
logInfo("打出七小对策略边张单牌: " + card);
|
||
return card;
|
||
}
|
||
}
|
||
|
||
// 其次打出中间不相关的牌（避开容易形成对子的中间牌）
|
||
for (int card : singleCards) {
|
||
int value = card % 100;
|
||
if (value == 2 || value == 8) {
|
||
logInfo("打出七小对策略边张单牌: " + card);
|
||
return card;
|
||
}
|
||
}
|
||
|
||
// 最后随便选一张单牌
|
||
logInfo("打出七小对策略单牌: " + singleCards.get(0));
|
||
return singleCards.get(0);
|
||
}
|
||
|
||
// 如果没有单张牌（所有牌都是对子或刻子），需要拆牌
|
||
// 优先拆刻子（保留对子）
|
||
List<Integer> tripleCards = new ArrayList<>();
|
||
for (int card : handCards) {
|
||
if (cardCounts.get(card) >= 3) {
|
||
tripleCards.add(card);
|
||
// 只需要一张来代表这个刻子
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (!tripleCards.isEmpty()) {
|
||
logInfo("七小对策略拆刻子: " + tripleCards.get(0));
|
||
return tripleCards.get(0);
|
||
}
|
||
|
||
// 如果所有都是对子，理论上已经是七小对听牌状态
|
||
// 但为了保险，随便选一张
|
||
logInfo("七小对策略，所有牌都是对子，随便打出一张: " + handCards.get(0));
|
||
return handCards.get(0);
|
||
}
|
||
|
||
// 不满足七小对条件时的默认返回
|
||
return handCards.get(0);
|
||
}
|
||
|
||
|
||
private String selectCardToDiscardPengPengHu(List<Integer> handCards) {
|
||
logInfo("开始执行碰碰胡出牌策略");
|
||
// 1. 复制手牌，避免修改原始数据
|
||
List<Integer> remainingCards = new ArrayList<>(handCards);
|
||
|
||
// 2. 找出所有刻子（三张相同的牌），不重复利用
|
||
List<Integer> keziList = extractAllKezi(remainingCards);
|
||
int keziCount = keziList.size() / 3;
|
||
logInfo("找到刻子: " + keziCount + "组 - " + getKeziNames(keziList));
|
||
|
||
|
||
//去除刻子后的牌
|
||
List<Integer> feiCandidates = findFeiJiangCandidates5(remainingCards);
|
||
logInfo("去除刻子后的牌: " + (feiCandidates));
|
||
int i = selectFromFeiCandidates4(feiCandidates);
|
||
return String.valueOf(i);
|
||
}
|
||
|
||
/**
|
||
* 找出非将牌候选（除了258将牌和刻子之外的牌）
|
||
*/
|
||
private List<Integer> findFeiJiangCandidates5(List<Integer> cards) {
|
||
Map<Integer, Integer> cardCount = new HashMap<>();
|
||
List<Integer> feiJiangCandidates = new ArrayList<>();
|
||
|
||
// 统计剩余牌的数量
|
||
for (Integer card : cards) {
|
||
cardCount.put(card, cardCount.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
|
||
for (Map.Entry<Integer, Integer> entry : cardCount.entrySet()) {
|
||
int card = entry.getKey();
|
||
int count = entry.getValue();
|
||
int value = card % 100;
|
||
|
||
for (int i = 0; i < count; i++) {
|
||
feiJiangCandidates.add(card);
|
||
}
|
||
}
|
||
|
||
return feiJiangCandidates;
|
||
}
|
||
|
||
/**
|
||
* 从非将牌候选中选择要打出的牌
|
||
* 优先打孤张，否则再拆牌
|
||
*/
|
||
private int selectFromFeiCandidates4(List<Integer> feiCandidates) {
|
||
if (feiCandidates.isEmpty()) {
|
||
return -1; // 或者抛出异常，根据实际情况处理
|
||
}
|
||
|
||
// 1. 优先找出非对子的牌
|
||
Integer isolatedCard = findIsolatedCardInFei6(feiCandidates);
|
||
logInfo("策略: 打出孤张牌 " + getCardName(isolatedCard));
|
||
return isolatedCard;
|
||
}
|
||
|
||
private Integer findIsolatedCardInFei6(List<Integer> feiCandidates) {
|
||
// 统计每张牌的出现次数
|
||
Map<Integer, Integer> countMap = new HashMap<>();
|
||
for (int card : feiCandidates) {
|
||
countMap.put(card, countMap.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
// 寻找出现次数为 1 的牌（非对子）
|
||
for (int card : feiCandidates) {
|
||
if (countMap.get(card) == 1) {
|
||
return card;
|
||
}
|
||
}
|
||
|
||
// 如果没有非对子的牌，返回 null 或选择第一张牌等策略
|
||
return feiCandidates.get(0);
|
||
}
|
||
|
||
|
||
private String getKeziNames(List<Integer> keziList) {
|
||
if (keziList.isEmpty()) return "无";
|
||
|
||
Set<String> keziNames = new HashSet<>();
|
||
for (int i = 0; i < keziList.size(); i += 3) {
|
||
keziNames.add(getCardName(keziList.get(i)));
|
||
}
|
||
return String.join(", ", keziNames);
|
||
}
|
||
|
||
/**
|
||
* 提取所有刻子（三张相同的牌），不重复利用
|
||
*/
|
||
private List<Integer> extractAllKezi(List<Integer> cards) {
|
||
List<Integer> keziList = new ArrayList<>();
|
||
Map<Integer, Integer> cardCount = new HashMap<>();
|
||
|
||
// 统计每张牌的数量
|
||
for (Integer card : cards) {
|
||
cardCount.put(card, cardCount.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
// 找出所有数量>=3的牌，提取刻子
|
||
List<Integer> cardsToRemove = new ArrayList<>();
|
||
for (Map.Entry<Integer, Integer> entry : cardCount.entrySet()) {
|
||
int card = entry.getKey();
|
||
int count = entry.getValue();
|
||
|
||
if (count >= 3) {
|
||
// 计算可以组成几个刻子（比如4张相同的牌可以组成1个刻子+1张单牌）
|
||
int keziGroups = count / 3;
|
||
for (int i = 0; i < keziGroups; i++) {
|
||
// 添加3次相同的牌表示一个刻子
|
||
keziList.add(card);
|
||
keziList.add(card);
|
||
keziList.add(card);
|
||
}
|
||
// 标记需要从剩余牌中移除的牌（只移除刻子部分）
|
||
for (int i = 0; i < keziGroups * 3; i++) {
|
||
cardsToRemove.add(card);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 从剩余牌中移除刻子
|
||
for (Integer card : cardsToRemove) {
|
||
cards.remove(card);
|
||
}
|
||
|
||
return keziList;
|
||
}
|
||
|
||
|
||
/**
|
||
* 最终出的牌
|
||
* 优化后的分析逻辑：
|
||
* 1. 分析剩余牌的搭子和卡隆情况
|
||
* 2. 优先打出边张且不是将的牌
|
||
* 3. 如果没有，优先打边张1、2，其次2、8，最后随便打
|
||
*/
|
||
public int selectCardToDiscard(List<Integer> cardInhand, HandAnalysis analysis) {
|
||
logInfo("\n===== 开始选择出牌策略 =====");
|
||
int discardCard = 0;
|
||
// 如果analysis为null，自动分析手牌
|
||
if (analysis == null) {
|
||
analysis = analyzeHand(cardInhand);
|
||
}
|
||
|
||
// 获取剩余牌
|
||
List<Integer> remainingCards = new ArrayList<>(analysis.isolatedCards);
|
||
logInfo("剩余需要分析的牌: " + remainingCards);
|
||
|
||
// 识别搭子和卡隆
|
||
List<List<Integer>> daAndKa = identifydaka(remainingCards);
|
||
logInfo("识别到的搭子和卡隆: " + daAndKa);
|
||
|
||
// 将搭子和卡隆中的牌收集起来
|
||
Set<Integer> daka = new HashSet<>();
|
||
for (List<Integer> card : daAndKa) {
|
||
daka.addAll(card);
|
||
}
|
||
logInfo("搭子和卡隆中的牌: " + daka);
|
||
|
||
// 找出所有可能的出牌候选，排除搭子和卡隆中的牌
|
||
Set<Integer> candidates = new HashSet<>(remainingCards);
|
||
candidates.removeAll(daka);
|
||
logInfo("排除搭子和卡隆后的候选牌: " + candidates);
|
||
|
||
// 1. 优先打出边张且不是将的牌
|
||
List<Integer> ban = new ArrayList<>();
|
||
for (int card : candidates) {
|
||
int rank = card % 100;
|
||
// 且不是将牌
|
||
if ((rank != 5 && rank != 2 && rank != 8)) {
|
||
ban.add(card);
|
||
}
|
||
}
|
||
|
||
|
||
for (int card : candidates) {
|
||
int rank = card % 100;
|
||
// 边张是1或9，且不是将牌
|
||
if ((rank == 1 || rank == 9) && !analysis.usedInPairs.contains(card)) {
|
||
ban.add(card);
|
||
}
|
||
}
|
||
|
||
if (!ban.isEmpty()) {
|
||
if (ban.get(0) != 5 && ban.get(0) != 2 && ban.get(0) != 8) {
|
||
return ban.get(0);
|
||
}
|
||
}
|
||
|
||
|
||
// 4. 如果以上情况都没有，打出剩余随便哪张
|
||
if (!candidates.isEmpty()) {
|
||
discardCard = candidates.iterator().next();
|
||
|
||
logInfo("最后选择任意剩余牌: " + discardCard);
|
||
if (discardCard != 5 && discardCard != 2 && discardCard != 8) {
|
||
return discardCard;
|
||
}
|
||
|
||
}
|
||
|
||
|
||
// 检查已完成的牌组中是否有带有将的牌
|
||
for (Integer meld : analysis.isolatedCards) {
|
||
|
||
// 检查该牌组中是否有牌是将牌
|
||
if (analysis.usedInPairs.contains(meld)) {
|
||
if (meld == 5 || meld == 2 || meld == 8) {
|
||
return meld;
|
||
}
|
||
}
|
||
}
|
||
|
||
// 如果没有带有将的牌组，选择第一个牌组的第一张牌
|
||
if (!analysis.pairs.isEmpty()) {
|
||
int pcard = 0;
|
||
for (Integer pair : analysis.pairs) {
|
||
int card = pair % 100;
|
||
if (card != 5 && card != 2 && card != 8) {
|
||
pcard = pair;
|
||
}
|
||
}
|
||
if (pcard != 0) {
|
||
return pcard;
|
||
} else {
|
||
return analysis.pairs.get(0);
|
||
}
|
||
}
|
||
|
||
if (!analysis.remainingCards.isEmpty()) {
|
||
for (Integer pair : analysis.remainingCards) {
|
||
int card = pair % 100;
|
||
if (card != 5 && card != 2 && card != 8) {
|
||
return pair;
|
||
}
|
||
}
|
||
}
|
||
|
||
if (!analysis.completedMelds.isEmpty()) {
|
||
List<Integer> validMelds = new ArrayList<>();
|
||
|
||
for (List<Integer> meld : analysis.completedMelds) {
|
||
// 检查整个组合中是否包含要排除的牌
|
||
boolean containsExcluded = false;
|
||
for (Integer card : meld) {
|
||
int cardValue = card % 100;
|
||
if (cardValue == 5 || cardValue == 2 || cardValue == 8) {
|
||
containsExcluded = true;
|
||
break;
|
||
}
|
||
}
|
||
// 如果整个组合都不包含排除的牌，记录下来
|
||
if (!containsExcluded && !meld.isEmpty()) {
|
||
validMelds.add(meld.get(0));
|
||
}
|
||
}
|
||
|
||
// 如果有有效的组合，返回第一个
|
||
if (!validMelds.isEmpty()) {
|
||
return validMelds.get(0);
|
||
}
|
||
|
||
// 如果所有组合都包含排除牌，返回第一个组合的第一张牌作为备选
|
||
return analysis.completedMelds.get(0).get(0);
|
||
}
|
||
|
||
|
||
if (!analysis.remainingCards.isEmpty()) {
|
||
for (Integer pair : analysis.remainingCards) {
|
||
int card = pair % 100;
|
||
if (card == 5 || card == 2 || card == 8) {
|
||
return pair;
|
||
}
|
||
}
|
||
}
|
||
|
||
return discardCard;
|
||
}
|
||
|
||
/**
|
||
* 识别搭子和卡隆
|
||
* 搭子：两张连续的牌，例如1-2，2-3等
|
||
* 卡隆：两张中间缺一张的牌，例如1-3（缺2），2-4（缺3）等
|
||
*/
|
||
private List<List<Integer>> identifydaka(List<Integer> cards) {
|
||
List<List<Integer>> daka = new ArrayList<>();
|
||
|
||
// 按花色分组
|
||
Map<Integer, List<Integer>> cardsBySuit = new HashMap<>();
|
||
for (int card : cards) {
|
||
int suit = card / 100;
|
||
cardsBySuit.computeIfAbsent(suit, k -> new ArrayList<>()).add(card);
|
||
}
|
||
|
||
// 记录已经使用过的牌
|
||
Set<Integer> usedCards = new HashSet<>();
|
||
|
||
// 分析每个花色
|
||
for (List<Integer> suitCards : cardsBySuit.values()) {
|
||
Collections.sort(suitCards);
|
||
|
||
// 优先找搭子（连续两张）
|
||
for (int i = 0; i < suitCards.size() - 1; i++) {
|
||
int card1 = suitCards.get(i);
|
||
int card2 = suitCards.get(i + 1);
|
||
|
||
if (usedCards.contains(card1) || usedCards.contains(card2)) {
|
||
continue; // 牌已被使用
|
||
}
|
||
|
||
int rank1 = card1 % 100;
|
||
int rank2 = card2 % 100;
|
||
|
||
// 搭子：连续两张牌
|
||
if (rank2 - rank1 == 1) {
|
||
daka.add(Arrays.asList(card1, card2));
|
||
usedCards.add(card1);
|
||
usedCards.add(card2);
|
||
i++; // 跳过下一张牌
|
||
}
|
||
}
|
||
|
||
// 再找卡隆（中间差一张）
|
||
for (int i = 0; i < suitCards.size() - 1; i++) {
|
||
int card1 = suitCards.get(i);
|
||
|
||
if (usedCards.contains(card1)) {
|
||
continue;
|
||
}
|
||
|
||
for (int j = i + 1; j < suitCards.size(); j++) {
|
||
int card2 = suitCards.get(j);
|
||
|
||
if (usedCards.contains(card2)) {
|
||
continue;
|
||
}
|
||
|
||
int rank1 = card1 % 100;
|
||
int rank2 = card2 % 100;
|
||
int rankDiff = rank2 - rank1;
|
||
|
||
// 卡隆：中间差一张
|
||
if (rankDiff == 2) {
|
||
daka.add(Arrays.asList(card1, card2));
|
||
usedCards.add(card1);
|
||
usedCards.add(card2);
|
||
break;
|
||
} else if (rankDiff > 2) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return daka;
|
||
}
|
||
|
||
|
||
/**
|
||
* 碰牌判断方法
|
||
*
|
||
* @param opcard 要碰的牌
|
||
* @param handCards 当前手牌
|
||
* @return 是否允许碰牌
|
||
*/
|
||
public boolean shouldPong(int opcard, List<Integer> handCards) {
|
||
// 1. 判断是否有至少两张相同的牌可以碰
|
||
int count = 0;
|
||
for (int card : handCards) {
|
||
if (card == opcard) {
|
||
count++;
|
||
}
|
||
}
|
||
if (count < 2) {
|
||
return false;
|
||
}
|
||
|
||
// 2. 如果是清一色花色，只能碰相同花色的牌
|
||
if (isAllSameSuit1(handCards)) {
|
||
Integer mainSuit = getMainSuit(handCards);
|
||
int opcardSuit = opcard / 100;
|
||
if (mainSuit != null && mainSuit != opcardSuit) {
|
||
logInfo("清一色模式：不能碰不同花色的牌。目标牌花色：" + getSuitName(opcardSuit) + ", 主花色：" + getSuitName(mainSuit));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 2. 复制手牌并模拟去掉要碰的两张牌
|
||
List<Integer> tempHand = new ArrayList<>(handCards);
|
||
tempHand.remove(Integer.valueOf(opcard));
|
||
tempHand.remove(Integer.valueOf(opcard));
|
||
|
||
// 3. 检查该牌是否是听牌组中的牌
|
||
List<Integer> tingCards = calculateTingCards(tempHand);
|
||
if (tingCards.contains(opcard)) {
|
||
return false;
|
||
}
|
||
|
||
// 4. 检查该牌是否是顺子的一部分
|
||
if (isPartOfSequence(opcard, handCards)) {
|
||
return false;
|
||
}
|
||
|
||
// 5. 检查该牌是否是唯一的将牌
|
||
if (isOnlyPair(tempHand, opcard)) {
|
||
return false;
|
||
}
|
||
|
||
// 其他情况允许碰牌
|
||
return true;
|
||
}
|
||
|
||
/**
|
||
* 吃牌判断方法
|
||
*
|
||
* @param opcard 要吃的牌
|
||
* @param handCards 当前手牌
|
||
* @return 是否允许吃牌
|
||
*/
|
||
public boolean shouldChow(int opcard, List<Integer> handCards) {
|
||
logInfo("吃牌判断开始, 目标牌: " + opcard + ", 当前手牌: " + handCards);
|
||
|
||
// 1. 如果是清一色花色，只能吃相同花色的牌
|
||
if (isAllSameSuit1(handCards)) {
|
||
Integer mainSuit = getMainSuit(handCards);
|
||
int opcardSuit = opcard / 100;
|
||
if (mainSuit != null && mainSuit != opcardSuit) {
|
||
logInfo("清一色模式：不能吃不同花色的牌。目标牌花色：" + getSuitName(opcardSuit) + ", 主花色：" + getSuitName(mainSuit));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 创建手牌的副本，避免修改原手牌
|
||
List<Integer> handCopy = new ArrayList<>(handCards);
|
||
|
||
// 分析手牌，识别刻子和顺子
|
||
HandAnalysis analysis = analyzeHand(handCopy);
|
||
|
||
// 获取剩余牌（未用于刻子或顺子的牌）
|
||
List<Integer> remainingCards = analysis.remainingCards;
|
||
|
||
// 检查剩余牌是否能与其他两张牌组成包含opcard的顺子
|
||
boolean canChow = canFormChow(opcard, remainingCards);
|
||
|
||
logInfo("吃牌判断结束, 结果: " + canChow);
|
||
return canChow;
|
||
}
|
||
|
||
/**
|
||
* 检查是否能形成包含目标牌的顺子
|
||
* @param targetCard 目标牌
|
||
* @param handCards 手牌
|
||
* @return 是否能吃牌
|
||
*/
|
||
|
||
/**
|
||
* 判断是否应该杠牌（补牌）
|
||
*
|
||
* @param proposedCard 要杠的牌
|
||
* @param currentHand 当前手牌
|
||
* @param （1:暗杠, 2:明杠, 3:加杠, 4:补杠等）
|
||
* @return 是否应该杠牌
|
||
*/
|
||
public boolean shouldGang(int proposedCard, List<Integer> currentHand) {
|
||
logInfo("判断是否应该杠牌: " + proposedCard);
|
||
|
||
// 1. 如果是清一色花色，只能杠相同花色的牌
|
||
if (isAllSameSuit1(currentHand)) {
|
||
Integer mainSuit = getMainSuit(currentHand);
|
||
int proposedCardSuit = proposedCard / 100;
|
||
if (mainSuit != null && mainSuit != proposedCardSuit) {
|
||
logInfo("清一色模式：不能杠不同花色的牌。目标牌花色：" + getSuitName(proposedCardSuit) + ", 主花色：" + getSuitName(mainSuit));
|
||
return false;
|
||
}
|
||
}
|
||
|
||
// 基础杠牌条件：手牌中至少有3张相同的牌
|
||
int count = 0;
|
||
for (int card : currentHand) {
|
||
if (card == proposedCard) {
|
||
count++;
|
||
}
|
||
}
|
||
|
||
if (count < 3) {
|
||
logInfo("手牌中没有足够的相同牌来杠");
|
||
return false;
|
||
}
|
||
|
||
// 这里可以添加更多杠牌决策逻辑，目前只实现清一色优化
|
||
return true;
|
||
}
|
||
|
||
|
||
private boolean canFormChow(int targetCard, List<Integer> handCards) {
|
||
// 检查是否是字牌（风牌或箭牌），字牌不能组成顺子
|
||
int suit = targetCard / 100;
|
||
if (suit == 4 || suit == 5) { // 4是风牌，5是箭牌
|
||
return false;
|
||
}
|
||
|
||
// 获取目标牌的点数
|
||
int targetPoint = targetCard % 100;
|
||
|
||
// 统计手牌中每张牌的数量
|
||
Map<Integer, Integer> cardCounts = new HashMap<>();
|
||
for (int card : handCards) {
|
||
cardCounts.put(card, cardCounts.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
// 检查三种可能的顺子组合
|
||
// 1. targetCard-2, targetCard-1, targetCard
|
||
if (targetPoint >= 3) {
|
||
int card1 = suit * 100 + (targetPoint - 2);
|
||
int card2 = suit * 100 + (targetPoint - 1);
|
||
if (cardCounts.containsKey(card1) && cardCounts.containsKey(card2)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
// 2. targetCard-1, targetCard, targetCard+1
|
||
if (targetPoint >= 2 && targetPoint <= 8) {
|
||
int card1 = suit * 100 + (targetPoint - 1);
|
||
int card2 = suit * 100 + (targetPoint + 1);
|
||
if (cardCounts.containsKey(card1) && cardCounts.containsKey(card2)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
// 3. targetCard, targetCard+1, targetCard+2
|
||
if (targetPoint <= 7) {
|
||
int card1 = suit * 100 + (targetPoint + 1);
|
||
int card2 = suit * 100 + (targetPoint + 2);
|
||
if (cardCounts.containsKey(card1) && cardCounts.containsKey(card2)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
|
||
/**
|
||
* 计算听牌
|
||
*
|
||
* @param handCards 手牌
|
||
* @return 听牌列表
|
||
*/
|
||
private List<Integer> calculateTingCards(List<Integer> handCards) {
|
||
List<Integer> tingCards = new ArrayList<>();
|
||
Map<Integer, Integer> cardCount = countCards(handCards);
|
||
|
||
// 检查每种花色的牌
|
||
for (int suit = 1; suit <= 3; suit++) { // 1:万, 2:筒, 3:索
|
||
List<Integer> sameSuitCards = new ArrayList<>();
|
||
for (int rank = 1; rank <= 9; rank++) {
|
||
int card = suit * 100 + rank;
|
||
int count = cardCount.getOrDefault(card, 0);
|
||
for (int i = 0; i < count; i++) {
|
||
sameSuitCards.add(rank);
|
||
}
|
||
}
|
||
|
||
// 检查是否有搭子需要补牌
|
||
if (sameSuitCards.size() > 0) {
|
||
// 简单检查：如果有单张牌，可能听它的相邻牌或相同牌
|
||
Map<Integer, Integer> rankCount = new HashMap<>();
|
||
for (int rank : sameSuitCards) {
|
||
rankCount.put(rank, rankCount.getOrDefault(rank, 0) + 1);
|
||
}
|
||
|
||
for (Map.Entry<Integer, Integer> entry : rankCount.entrySet()) {
|
||
int rank = entry.getKey();
|
||
int count = entry.getValue();
|
||
|
||
// 如果是单张或对子，可能需要补牌
|
||
if (count == 1 || count == 2) {
|
||
// 添加当前牌（可能组成刻子）
|
||
tingCards.add(suit * 100 + rank);
|
||
|
||
// 添加相邻牌（可能组成顺子）
|
||
if (rank > 1) {
|
||
tingCards.add(suit * 100 + (rank - 1));
|
||
}
|
||
if (rank < 9) {
|
||
tingCards.add(suit * 100 + (rank + 1));
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return tingCards;
|
||
}
|
||
|
||
/**
|
||
* 判断是否是顺子的一部分
|
||
*
|
||
* @param card 要判断的牌
|
||
* @param handCards 手牌
|
||
* @return 是否是顺子的一部分
|
||
*/
|
||
private boolean isPartOfSequence(int card, List<Integer> handCards) {
|
||
int suit = card / 100;
|
||
int rank = card % 100;
|
||
|
||
// 检查是否存在顺子
|
||
// 顺子是三个连续的牌，比如1-2-3，2-3-4等
|
||
boolean hasPrevPrev = handCards.contains(suit * 100 + rank - 2);
|
||
boolean hasPrev = handCards.contains(suit * 100 + rank - 1);
|
||
boolean hasNext = handCards.contains(suit * 100 + rank + 1);
|
||
boolean hasNextNext = handCards.contains(suit * 100 + rank + 2);
|
||
|
||
// 检查是否是顺子的中间牌或边牌
|
||
return (hasPrev && hasNext) || (hasPrevPrev && hasPrev) || (hasNext && hasNextNext);
|
||
}
|
||
|
||
/**
|
||
* 判断是否是唯一的将牌
|
||
*
|
||
* @param tempHand 去掉两张要碰的牌后的手牌
|
||
* @param opcard 要碰的牌
|
||
* @return 是否是唯一的将牌
|
||
*/
|
||
public boolean isOnlyPair(List<Integer> tempHand, int opcard) {
|
||
Map<Integer, Integer> cardCount = countCards(tempHand);
|
||
int pairCount = 0;
|
||
|
||
for (Map.Entry<Integer, Integer> entry : cardCount.entrySet()) {
|
||
if (entry.getValue() == 2) {
|
||
pairCount++;
|
||
}
|
||
}
|
||
|
||
// 如果去掉要碰的牌后没有对子，说明原来的牌是唯一的将牌
|
||
return pairCount == 0;
|
||
}
|
||
|
||
/**
|
||
* 统计每张牌的数量
|
||
*
|
||
* @param handCards 手牌
|
||
* @return 牌的数量映射
|
||
*/
|
||
private Map<Integer, Integer> countCards(List<Integer> handCards) {
|
||
Map<Integer, Integer> cardCount = new HashMap<>();
|
||
for (int card : handCards) {
|
||
cardCount.put(card, cardCount.getOrDefault(card, 0) + 1);
|
||
}
|
||
return cardCount;
|
||
}
|
||
|
||
|
||
//大胡分析七小对
|
||
public int countPairs(List<Integer> handCards) {
|
||
// 1. 先根据花色和点数排序
|
||
List<Integer> sortedCards = new ArrayList<>(handCards);
|
||
sortedCards.sort((a, b) -> {
|
||
int suitA = a / 100;
|
||
int suitB = b / 100;
|
||
int rankA = a % 100;
|
||
int rankB = b % 100;
|
||
|
||
// 先按花色排序，再按点数排序
|
||
if (suitA != suitB) {
|
||
return suitA - suitB;
|
||
}
|
||
return rankA - rankB;
|
||
});
|
||
|
||
// 2. 统计对子
|
||
int pairCount = 0;
|
||
for (int i = 0; i < sortedCards.size() - 1; i++) {
|
||
if (sortedCards.get(i).equals(sortedCards.get(i + 1))) {
|
||
pairCount++;
|
||
i++; // 跳过下一张
|
||
}
|
||
}
|
||
|
||
return pairCount;
|
||
}
|
||
|
||
|
||
//分析七小对清一色
|
||
public List<Integer> qixiaoduiqingyise(List<Integer> handCards) {
|
||
// 合并所有牌
|
||
List<Integer> allCards = new ArrayList<>();
|
||
allCards.addAll(handCards);
|
||
|
||
// 按花色分组
|
||
List<Integer> wanCards = new ArrayList<>(); // 万: 101-109
|
||
List<Integer> tongCards = new ArrayList<>(); // 筒: 201-209
|
||
List<Integer> tiaoCards = new ArrayList<>(); // 条: 301-309
|
||
|
||
for (Integer card : allCards) {
|
||
if (card >= 101 && card <= 109) {
|
||
wanCards.add(card);
|
||
} else if (card >= 201 && card <= 209) {
|
||
tongCards.add(card);
|
||
} else if (card >= 301 && card <= 309) {
|
||
tiaoCards.add(card);
|
||
}
|
||
}
|
||
|
||
// 检查各花色数量
|
||
if (wanCards.size() >= 8) {
|
||
Collections.sort(wanCards);
|
||
logInfo("检测到清一色花色: 万, 数量: " + wanCards.size());
|
||
return wanCards;
|
||
}
|
||
|
||
if (tongCards.size() >= 8) {
|
||
Collections.sort(tongCards);
|
||
logInfo("检测到清一色花色: 筒, 数量: " + tongCards.size());
|
||
return tongCards;
|
||
}
|
||
|
||
if (tiaoCards.size() >= 8) {
|
||
Collections.sort(tiaoCards);
|
||
logInfo("检测到清一色花色: 条, 数量: " + tiaoCards.size());
|
||
return tiaoCards;
|
||
}
|
||
|
||
return new ArrayList<>();
|
||
}
|
||
|
||
public boolean hasFourOrMorePairs(List<Integer> qixiaoduiqingyise) {
|
||
if (qixiaoduiqingyise == null || qixiaoduiqingyise.size() < 8) {
|
||
return false; // 至少需要8张牌才能有4对
|
||
}
|
||
|
||
// 对牌进行排序
|
||
List<Integer> sortedCards = new ArrayList<>(qixiaoduiqingyise);
|
||
Collections.sort(sortedCards);
|
||
|
||
// 统计对子数量
|
||
int pairCount = 0;
|
||
int i = 0;
|
||
int n = sortedCards.size();
|
||
|
||
while (i < n - 1) {
|
||
if (sortedCards.get(i).equals(sortedCards.get(i + 1))) {
|
||
// 找到一对对子
|
||
pairCount++;
|
||
i += 2; // 跳过这对对子
|
||
} else {
|
||
i += 1; // 继续检查下一张牌
|
||
}
|
||
}
|
||
|
||
logInfo("清一色手牌中对子数量: " + pairCount);
|
||
return pairCount >= 4;
|
||
}
|
||
|
||
//分析清一色
|
||
public boolean isAllSameSuit(List<Integer> handCards, List<Integer> pengCard) {
|
||
// 统计各花色的牌数量
|
||
Map<Integer, Integer> suitCountMap = new HashMap<>();
|
||
List<Integer> handCards2 = new ArrayList<>();
|
||
handCards2.addAll(handCards);
|
||
// handCards2.addAll(pengCard);
|
||
|
||
for (Integer card : handCards2) {
|
||
int suit = card / 100; // 获取花色，100=万，200=筒，300=条
|
||
suitCountMap.put(suit, suitCountMap.getOrDefault(suit, 0) + 1);
|
||
}
|
||
|
||
// 检查是否有花色的牌数量超过8张
|
||
for (Map.Entry<Integer, Integer> entry : suitCountMap.entrySet()) {
|
||
int suit = entry.getKey();
|
||
|
||
int count = entry.getValue();
|
||
|
||
if (count >= 10) {
|
||
String suitName = getSuitName(suit);
|
||
logInfo("检测到可能的清一色花色: " + suitName + ", 数量: " + count);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
//分析清一色
|
||
public boolean isAllSameSuit1(List<Integer> handCards) {
|
||
// 统计各花色的牌数量
|
||
Map<Integer, Integer> suitCountMap = new HashMap<>();
|
||
|
||
for (Integer card : handCards) {
|
||
int suit = card / 100; // 获取花色，100=万，200=筒，300=条
|
||
suitCountMap.put(suit, suitCountMap.getOrDefault(suit, 0) + 1);
|
||
}
|
||
|
||
|
||
for (Map.Entry<Integer, Integer> entry : suitCountMap.entrySet()) {
|
||
int suit = entry.getKey();
|
||
|
||
int count = entry.getValue();
|
||
|
||
|
||
if (count >= 11) {
|
||
String suitName = getSuitName(suit);
|
||
logInfo("检测到可能的清一色花色: " + suitName + ", 数量: " + count);
|
||
return true;
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
|
||
// 获取主要花色（数量最多且≥9张的花色）
|
||
public Integer getMainSuit(List<Integer> handCards) {
|
||
Map<Integer, Integer> suitCountMap = new HashMap<>();
|
||
|
||
for (Integer card : handCards) {
|
||
int suit = card / 100;
|
||
suitCountMap.put(suit, suitCountMap.getOrDefault(suit, 0) + 1);
|
||
}
|
||
|
||
Integer mainSuit = null;
|
||
int maxCount = 0;
|
||
|
||
for (Map.Entry<Integer, Integer> entry : suitCountMap.entrySet()) {
|
||
int suit = entry.getKey();
|
||
int count = entry.getValue();
|
||
|
||
if (count >= 10 && count > maxCount) {
|
||
maxCount = count;
|
||
mainSuit = suit;
|
||
}
|
||
}
|
||
|
||
return mainSuit;
|
||
}
|
||
|
||
// 清一色特定出牌策略
|
||
|
||
/**
|
||
* 基于花色分析的清一色七小对出牌策略
|
||
* 优先打出花色最少的牌，以优化七小对的形成
|
||
*
|
||
* @param handCards 当前手牌
|
||
* @return 最优打出的牌
|
||
*/
|
||
private String selectCardToDiscardAllSameSuitQiXiaoDuiBySuit(List<Integer> handCards) {
|
||
// 1. 分析每个花色的牌数量
|
||
Map<Integer, Integer> suitCount = new HashMap<>();
|
||
Map<Integer, List<Integer>> cardsBySuit = new HashMap<>();
|
||
|
||
for (int card : handCards) {
|
||
int suit = card / 10; // 计算花色
|
||
suitCount.put(suit, suitCount.getOrDefault(suit, 0) + 1);
|
||
|
||
// 按花色分组存储牌
|
||
cardsBySuit.computeIfAbsent(suit, k -> new ArrayList<>()).add(card);
|
||
}
|
||
|
||
logInfo("花色分布统计: " + suitCount);
|
||
|
||
// 2. 找出花色数量最少的花色（排除主花色）
|
||
Integer mainSuit = getMainSuit(handCards);
|
||
Integer leastSuit = null;
|
||
int minCount = Integer.MAX_VALUE;
|
||
|
||
for (Map.Entry<Integer, Integer> entry : suitCount.entrySet()) {
|
||
int suit = entry.getKey();
|
||
int count = entry.getValue();
|
||
|
||
// 如果不是主花色，且数量更少
|
||
if ((mainSuit == null || suit != mainSuit) && count < minCount) {
|
||
minCount = count;
|
||
leastSuit = suit;
|
||
}
|
||
}
|
||
|
||
// 3. 从最少花色中选择要打出的牌
|
||
if (leastSuit != null && cardsBySuit.containsKey(leastSuit)) {
|
||
List<Integer> leastSuitCards = cardsBySuit.get(leastSuit);
|
||
logInfo("优先从最少花色 " + getSuitName(leastSuit) + " 中选择打出的牌: " + leastSuitCards);
|
||
|
||
// 统计最少花色中各牌的出现次数
|
||
Map<Integer, Integer> cardCountsInLeastSuit = new HashMap<>();
|
||
for (int card : leastSuitCards) {
|
||
cardCountsInLeastSuit.put(card, cardCountsInLeastSuit.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
// 优先打出单张牌（出现次数为1）
|
||
for (Map.Entry<Integer, Integer> entry : cardCountsInLeastSuit.entrySet()) {
|
||
if (entry.getValue() == 1) {
|
||
logInfo("选择打出最少花色中的单张牌: " + entry.getKey());
|
||
return String.valueOf(entry.getKey());
|
||
}
|
||
}
|
||
|
||
// 如果没有单张，优先打对子的，优先保留刻子或四张一样的
|
||
for (Map.Entry<Integer, Integer> entry : cardCountsInLeastSuit.entrySet()) {
|
||
if (entry.getValue() == 2) {
|
||
return String.valueOf(entry.getKey());
|
||
}
|
||
}
|
||
}
|
||
|
||
// 4. 如果没有找到合适的牌（可能所有牌都是同一花色），使用七小对大胡策略
|
||
logInfo("使用默认七小对大胡策略");
|
||
int outcard = selectCardToDiscardBig(handCards, countPairs(handCards));
|
||
return String.valueOf(outcard);
|
||
}
|
||
|
||
private String selectCardToDiscardPengPeng(List<Integer> handCards) {
|
||
logInfo("开始执行清一色碰碰胡出牌策略");
|
||
|
||
// 1. 分析每个花色的牌数量
|
||
Map<Integer, Integer> suitCount = new HashMap<>();
|
||
Map<Integer, List<Integer>> cardsBySuit = new HashMap<>();
|
||
|
||
for (int card : handCards) {
|
||
int suit = card / 100; // 计算花色（修正为除以100）
|
||
suitCount.put(suit, suitCount.getOrDefault(suit, 0) + 1);
|
||
|
||
// 按花色分组存储牌
|
||
cardsBySuit.computeIfAbsent(suit, k -> new ArrayList<>()).add(card);
|
||
}
|
||
|
||
// 2. 找出主要花色（牌数量最多的花色）
|
||
int mainSuit = findMainSuit(suitCount);
|
||
logInfo("主要花色: " + getSuitName(mainSuit) + ", 数量: " + suitCount.get(mainSuit));
|
||
|
||
// 3. 如果有非主要花色的牌，优先打出
|
||
if (hasNonMainSuitCards(suitCount, mainSuit)) {
|
||
logInfo("存在非主要花色牌，优先打出");
|
||
return discardNonMainSuitCard(handCards, mainSuit);
|
||
}
|
||
|
||
// 4. 所有牌都是主要花色，使用清一色碰碰胡策略
|
||
logInfo("所有牌都是主要花色，使用清一色碰碰胡策略");
|
||
return discardFromSameSuitPengPeng(handCards, mainSuit);
|
||
}
|
||
|
||
/**
|
||
* 打出非主要花色的牌
|
||
*/
|
||
private String discardNonMainSuitCard(List<Integer> handCards, int mainSuit) {
|
||
// 优先打出数量最少的非主要花色牌
|
||
List<Integer> nonMainSuitCards = new ArrayList<>();
|
||
for (int card : handCards) {
|
||
int suit = card / 100;
|
||
if (suit != mainSuit) {
|
||
nonMainSuitCards.add(card);
|
||
}
|
||
}
|
||
|
||
// 按数量排序，优先打出手牌数量少的牌
|
||
Map<Integer, Integer> cardCount = countCardOccurrences(nonMainSuitCards);
|
||
nonMainSuitCards.sort((a, b) -> {
|
||
int countA = cardCount.get(a);
|
||
int countB = cardCount.get(b);
|
||
return Integer.compare(countA, countB);
|
||
});
|
||
|
||
int discardCard = nonMainSuitCards.get(0);
|
||
logInfo("打出非主要花色牌: " + getCardName(discardCard));
|
||
return String.valueOf(discardCard);
|
||
}
|
||
|
||
|
||
/**
|
||
* 统计每张牌的出现次数
|
||
*/
|
||
private Map<Integer, Integer> countCardOccurrences(List<Integer> cards) {
|
||
Map<Integer, Integer> countMap = new HashMap<>();
|
||
for (int card : cards) {
|
||
countMap.put(card, countMap.getOrDefault(card, 0) + 1);
|
||
}
|
||
return countMap;
|
||
}
|
||
|
||
/**
|
||
* 找出主要花色（牌数量最多的花色）
|
||
*/
|
||
private int findMainSuit(Map<Integer, Integer> suitCount) {
|
||
int mainSuit = -1;
|
||
int maxCount = 0;
|
||
|
||
for (Map.Entry<Integer, Integer> entry : suitCount.entrySet()) {
|
||
if (entry.getValue() > maxCount) {
|
||
maxCount = entry.getValue();
|
||
mainSuit = entry.getKey();
|
||
}
|
||
}
|
||
|
||
return mainSuit;
|
||
}
|
||
|
||
/**
|
||
* 判断是否有非主要花色的牌
|
||
*/
|
||
private boolean hasNonMainSuitCards(Map<Integer, Integer> suitCount, int mainSuit) {
|
||
for (Map.Entry<Integer, Integer> entry : suitCount.entrySet()) {
|
||
if (entry.getKey() != mainSuit && entry.getValue() > 0) {
|
||
return true;
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 从同花色牌中选择要打出的牌（清一色碰碰胡策略）
|
||
*/
|
||
private String discardFromSameSuitPengPeng(List<Integer> handCards, int mainSuit) {
|
||
// 统计每张牌的数量
|
||
Map<Integer, Integer> cardCount = countCardOccurrences(handCards);
|
||
|
||
// 找出刻子、将牌候选和剩余牌
|
||
List<Integer> keziCards = new ArrayList<>();
|
||
List<Integer> jiangCandidates = new ArrayList<>(); // 258将牌候选
|
||
List<Integer> otherJiangCandidates = new ArrayList<>(); // 其他将牌候选
|
||
List<Integer> remainingCards = new ArrayList<>(handCards);
|
||
|
||
// 1. 先找出刻子（三张相同的牌）
|
||
findAndRemoveKezi(remainingCards, cardCount, keziCards);
|
||
|
||
|
||
findJiangCandidates(remainingCards, jiangCandidates, otherJiangCandidates);
|
||
|
||
// 3. 选择要打出的牌
|
||
int discardCard = selectDiscardCardPengPeng(remainingCards, otherJiangCandidates, cardCount, handCards);
|
||
|
||
logInfo("清一色碰碰胡策略打出: " + getCardName(discardCard));
|
||
return String.valueOf(discardCard);
|
||
}
|
||
|
||
/**
|
||
* 找出将牌候选
|
||
*/
|
||
private void findJiangCandidates(List<Integer> cards, List<Integer> jiangCandidates, List<Integer> otherJiangCandidates) {
|
||
Map<Integer, Integer> cardCount = countCardOccurrences(cards);
|
||
|
||
for (int card : cards) {
|
||
|
||
int count = cardCount.get(card);
|
||
if (count >= 2) {
|
||
otherJiangCandidates.add(card);
|
||
} else if (count == 1) {
|
||
otherJiangCandidates.add(card);
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 选择要打出的牌（清一色碰碰胡策略）
|
||
*/
|
||
private int selectDiscardCardPengPeng(List<Integer> remainingCards,
|
||
List<Integer> otherJiangCandidates,
|
||
Map<Integer, Integer> cardCount
|
||
, List<Integer> handCards) {
|
||
|
||
// 如果还有剩余牌，优先从剩余牌中选择
|
||
if (!remainingCards.isEmpty()) {
|
||
// 策略1: 优先打出孤张（没有相邻牌的牌）
|
||
Integer isolatedCard = findIsolatedCard(remainingCards, cardCount);
|
||
if (isolatedCard != null) {
|
||
return isolatedCard;
|
||
}
|
||
|
||
// 策略2: 优先打出非258的牌
|
||
Integer non258Card = findNon258Card(remainingCards);
|
||
if (non258Card != null) {
|
||
return non258Card;
|
||
}
|
||
|
||
// 策略3: 打出手牌数量最少的牌
|
||
return findLeastCountCard(remainingCards, cardCount);
|
||
}
|
||
|
||
|
||
if (!otherJiangCandidates.isEmpty()) {
|
||
return otherJiangCandidates.get(0);
|
||
}
|
||
|
||
|
||
// 默认情况（理论上不会执行到这里）
|
||
logInfo("警告：无法选择出牌，使用默认策略");
|
||
return remainingCards.isEmpty() ? handCards.get(0) : remainingCards.get(0);
|
||
}
|
||
|
||
/**
|
||
* 查找手牌数量最少的牌
|
||
*/
|
||
private int findLeastCountCard(List<Integer> cards, Map<Integer, Integer> cardCount) {
|
||
int minCount = Integer.MAX_VALUE;
|
||
int resultCard = cards.get(0);
|
||
|
||
for (int card : cards) {
|
||
int count = cardCount.get(card);
|
||
if (count < minCount) {
|
||
minCount = count;
|
||
resultCard = card;
|
||
}
|
||
}
|
||
|
||
return resultCard;
|
||
}
|
||
|
||
/**
|
||
* 查找非258的牌
|
||
*/
|
||
private Integer findNon258Card(List<Integer> cards) {
|
||
for (int card : cards) {
|
||
int value = card % 100;
|
||
if (value != 2 && value != 5 && value != 8) {
|
||
return card;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
public int selectCardToDiscardForAllSameSuit(List<Integer> handCards, List<Integer> chowGroup, List<Integer> pengGroup) {
|
||
Integer mainSuit = getMainSuit(handCards);
|
||
if (mainSuit == null) {
|
||
logInfo("未找到主要花色，使用默认策略");
|
||
return -1;
|
||
}
|
||
//如果吃和碰的牌 包含主要花色的牌，放弃走清一色
|
||
if (chowGroup != null && pengGroup != null && chowGroup.size() > 0 && pengGroup.size() > 0) {
|
||
chowGroup.addAll(pengGroup);
|
||
for (Integer integer : chowGroup) {
|
||
String str = integer.toString();
|
||
if (!str.isEmpty()) {
|
||
int firstDigit = Character.getNumericValue(str.charAt(0));
|
||
if (mainSuit.equals(firstDigit)) {
|
||
return -1;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// boolean allSameSuit = isAllSameSuit(handCards, mainSuit);
|
||
|
||
String mainSuitName = getSuitName(mainSuit);
|
||
logInfo("执行清一色策略，主要花色: " + mainSuitName);
|
||
|
||
// 统计每张牌的数量
|
||
Map<Integer, Integer> cardCountMap = new HashMap<>();
|
||
for (Integer card : handCards) {
|
||
cardCountMap.put(card, cardCountMap.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
// 收集非主要花色的牌
|
||
List<Integer> nonMainSuitCards = new ArrayList<>();
|
||
for (Integer card : handCards) {
|
||
int suit = card / 100;
|
||
if (suit != mainSuit) {
|
||
nonMainSuitCards.add(card);
|
||
}
|
||
}
|
||
|
||
// 如果有非主要花色的牌，优先打出这些牌
|
||
if (!nonMainSuitCards.isEmpty()) {
|
||
logInfo("有非主要花色牌，优先打出");
|
||
|
||
// 按优先级打出非主要花色牌
|
||
Integer cardToDiscard = selectNonMainSuitCard(nonMainSuitCards, cardCountMap);
|
||
if (cardToDiscard != null) {
|
||
return cardToDiscard;
|
||
}
|
||
}
|
||
|
||
// 如果所有牌都是主要花色，使用清一色优化策略
|
||
logInfo("所有牌都是主要花色，使用清一色优化策略");
|
||
return selectCardFromSameSuit(handCards, cardCountMap, mainSuit);
|
||
}
|
||
|
||
|
||
public boolean isAllSameSuit(List<Integer> handCards, Integer mainSuit) {
|
||
// 提取主花色牌
|
||
List<Integer> mainSuitCards = new ArrayList<>();
|
||
for (Integer card : handCards) {
|
||
int suit = card / 100;
|
||
if (suit == mainSuit) {
|
||
mainSuitCards.add(card);
|
||
}
|
||
}
|
||
|
||
Map<String, List<List<Integer>>> stringListMap = analyzeMainSuitPatterns(mainSuitCards);
|
||
|
||
List<List<Integer>> sequences = stringListMap.get("sequences"); // 顺子列表
|
||
List<List<Integer>> triplets = stringListMap.get("triplets"); // 刻子列表
|
||
List<List<Integer>> pairs = stringListMap.get("pairs"); // 对子列表
|
||
|
||
// 获取数量
|
||
int sequenceCount = sequences.size();
|
||
int tripletCount = triplets.size();
|
||
|
||
|
||
// 判断顺子加上刻子的数量是否大于6
|
||
boolean isSequenceAndTripletGreaterThan6 = (sequenceCount + tripletCount) > 6;
|
||
|
||
return isSequenceAndTripletGreaterThan6;
|
||
}
|
||
|
||
|
||
/**
|
||
* 分析主花色牌组中的顺子、刻子、对子
|
||
*
|
||
* @param mainSuitCards 主花色牌组
|
||
* @return 包含顺子、刻子、对子信息的Map
|
||
*/
|
||
private Map<String, List<List<Integer>>> analyzeMainSuitPatterns(List<Integer> mainSuitCards) {
|
||
Map<String, List<List<Integer>>> patterns = new HashMap<>();
|
||
patterns.put("sequences", new ArrayList<>()); // 顺子
|
||
patterns.put("triplets", new ArrayList<>()); // 刻子
|
||
patterns.put("pairs", new ArrayList<>()); // 对子
|
||
|
||
if (mainSuitCards == null || mainSuitCards.isEmpty()) {
|
||
return patterns;
|
||
}
|
||
|
||
// 提取所有点数
|
||
List<Integer> points = new ArrayList<>();
|
||
for (Integer card : mainSuitCards) {
|
||
int point = card % 100;
|
||
points.add(point);
|
||
}
|
||
Collections.sort(points);
|
||
|
||
// 统计每个点数的数量
|
||
Map<Integer, Integer> pointCountMap = new HashMap<>();
|
||
for (Integer point : points) {
|
||
pointCountMap.put(point, pointCountMap.getOrDefault(point, 0) + 1);
|
||
}
|
||
|
||
// 找出刻子（三张相同的牌）
|
||
for (Map.Entry<Integer, Integer> entry : pointCountMap.entrySet()) {
|
||
if (entry.getValue() >= 3) {
|
||
List<Integer> triplet = new ArrayList<>();
|
||
for (int i = 0; i < 3; i++) {
|
||
triplet.add(entry.getKey());
|
||
}
|
||
patterns.get("triplets").add(triplet);
|
||
}
|
||
}
|
||
|
||
// 找出对子
|
||
for (Map.Entry<Integer, Integer> entry : pointCountMap.entrySet()) {
|
||
if (entry.getValue() >= 2) {
|
||
List<Integer> pair = new ArrayList<>();
|
||
for (int i = 0; i < 2; i++) {
|
||
pair.add(entry.getKey());
|
||
}
|
||
patterns.get("pairs").add(pair);
|
||
}
|
||
}
|
||
|
||
// 找出顺子（需要从剩余牌中找）
|
||
// 先复制一份牌用于顺子检测（避免刻子/对子使用的牌影响顺子检测）
|
||
List<Integer> remainingPoints = new ArrayList<>(points);
|
||
|
||
// 移除刻子使用的牌（如果有的话）
|
||
for (List<Integer> triplet : patterns.get("triplets")) {
|
||
int point = triplet.get(0);
|
||
for (int i = 0; i < 3; i++) {
|
||
remainingPoints.remove((Integer) point);
|
||
}
|
||
}
|
||
|
||
// 检查顺子
|
||
for (int start = 1; start <= 7; start++) {
|
||
boolean canFormSequence = true;
|
||
List<Integer> tempPoints = new ArrayList<>(remainingPoints);
|
||
List<Integer> sequence = new ArrayList<>();
|
||
|
||
// 检查是否有连续的3个点数
|
||
for (int i = 0; i < 3; i++) {
|
||
int currentPoint = start + i;
|
||
if (!tempPoints.remove((Integer) currentPoint)) {
|
||
canFormSequence = false;
|
||
break;
|
||
}
|
||
sequence.add(currentPoint);
|
||
}
|
||
|
||
if (canFormSequence) {
|
||
patterns.get("sequences").add(sequence);
|
||
// 从剩余牌中移除这三个点数
|
||
for (int i = 0; i < 3; i++) {
|
||
remainingPoints.remove((Integer) (start + i));
|
||
}
|
||
}
|
||
}
|
||
|
||
return patterns;
|
||
}
|
||
|
||
|
||
/**
|
||
* 选择非主要花色牌打出
|
||
*/
|
||
private Integer selectNonMainSuitCard(List<Integer> nonMainSuitCards, Map<Integer, Integer> cardCountMap) {
|
||
|
||
// TODO: 2026/1/1 待测试 如果走清一色 ，打出非同花色的牌也要优先打出孤张，如果没有再走之前的其他逻辑
|
||
// // 新增：找出真正的孤张（不能组成顺子或刻子的单张）
|
||
// List<Integer> realSingleCards = new ArrayList<>();
|
||
//
|
||
// // 按牌的类型分组
|
||
// Map<Integer, List<Integer>> cardsByType = new HashMap<>();
|
||
// for (Integer card : nonMainSuitCards) {
|
||
// int type = card / 100; // 牌的类型
|
||
// cardsByType.putIfAbsent(type, new ArrayList<>());
|
||
// cardsByType.get(type).add(card % 100); // 只存牌值
|
||
// }
|
||
//
|
||
// // 分析每种类型的牌，找出真正的孤张
|
||
// for (Map.Entry<Integer, List<Integer>> entry : cardsByType.entrySet()) {
|
||
// int type = entry.getKey();
|
||
// List<Integer> values = entry.getValue();
|
||
// Collections.sort(values);
|
||
//
|
||
// // 标记哪些牌是顺子或刻子的一部分
|
||
// boolean[] usedInMeld = new boolean[values.size()];
|
||
//
|
||
// // 检查刻子（三张相同）
|
||
// for (int i = 0; i <= values.size() - 3; i++) {
|
||
// if (values.get(i).equals(values.get(i + 1)) &&
|
||
// values.get(i).equals(values.get(i + 2))) {
|
||
// usedInMeld[i] = usedInMeld[i + 1] = usedInMeld[i + 2] = true;
|
||
// i += 2; // 跳过这三张
|
||
// }
|
||
// }
|
||
//
|
||
// // 检查顺子（三张连续）
|
||
// for (int i = 0; i <= values.size() - 3; i++) {
|
||
// if (!usedInMeld[i] && !usedInMeld[i + 1] && !usedInMeld[i + 2]) {
|
||
// int v1 = values.get(i);
|
||
// int v2 = values.get(i + 1);
|
||
// int v3 = values.get(i + 2);
|
||
//
|
||
// // 检查是否连续（注意麻将的1和9不连续）
|
||
// if (v2 - v1 == 1 && v3 - v2 == 1) {
|
||
// // 排除1-9这样的不连续情况
|
||
// if (!(v1 == 1 && v3 == 9)) { // 1和9不连续
|
||
// usedInMeld[i] = usedInMeld[i + 1] = usedInMeld[i + 2] = true;
|
||
// i += 2; // 跳过这三张
|
||
// }
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// // 找出真正的孤张（没有被顺子或刻子使用的牌）
|
||
// for (int i = 0; i < values.size(); i++) {
|
||
// if (!usedInMeld[i] && cardCountMap.get(type * 100 + values.get(i)) == 1) {
|
||
// realSingleCards.add(type * 100 + values.get(i));
|
||
// }
|
||
// }
|
||
// }
|
||
//
|
||
// // 1. 优先打出手牌中真正的孤张牌
|
||
// if (!realSingleCards.isEmpty()) {
|
||
// // 在真正的孤张中优先打边张(1和9)
|
||
// Integer edgeCard = findEdgeCard(realSingleCards);
|
||
// if (edgeCard != null) {
|
||
// logInfo("打出非主要花色的边张孤牌: " + edgeCard);
|
||
// return edgeCard;
|
||
// }
|
||
// // 没有边张就打任意孤张
|
||
// logInfo("打出非主要花色的孤张牌: " + realSingleCards.get(0));
|
||
// return realSingleCards.get(0);
|
||
// }
|
||
|
||
|
||
|
||
|
||
// 1. 优先打出手牌中数量最少的单张牌
|
||
List<Integer> singleCards = new ArrayList<>();
|
||
for (Integer card : nonMainSuitCards) {
|
||
if (cardCountMap.get(card) == 1) {
|
||
singleCards.add(card);
|
||
}
|
||
}
|
||
|
||
if (!singleCards.isEmpty()) {
|
||
// 在单张牌中优先打边张(1和9)
|
||
Integer edgeCard = findEdgeCard(singleCards);
|
||
if (edgeCard != null) {
|
||
logInfo("打出非主要花色的边张单牌: " + edgeCard);
|
||
return edgeCard;
|
||
}
|
||
// 没有边张就打任意单张
|
||
logInfo("打出非主要花色的单张牌: " + singleCards.get(0));
|
||
return singleCards.get(0);
|
||
}
|
||
|
||
// 2. 拆数量最少的对子
|
||
for (Integer card : nonMainSuitCards) {
|
||
if (cardCountMap.get(card) == 2) {
|
||
logInfo("拆非主要花色的对子: " + card);
|
||
return card;
|
||
}
|
||
}
|
||
|
||
// 3. 最后随便选一张非主要花色的牌
|
||
logInfo("打出非主要花色的牌: " + nonMainSuitCards.get(0));
|
||
return nonMainSuitCards.get(0);
|
||
}
|
||
|
||
/**
|
||
* 从同花色牌中选择要打出的牌
|
||
*/
|
||
private int selectCardFromSameSuit(List<Integer> handCards, Map<Integer, Integer> cardCountMap, int mainSuit) {
|
||
// 分离出刻子、顺子、将牌和剩余牌
|
||
List<Integer> kezi = new ArrayList<>();
|
||
List<Integer> shunzi = new ArrayList<>();
|
||
List<Integer> jiang = new ArrayList<>();
|
||
List<Integer> remainingCards = new ArrayList<>(handCards);
|
||
|
||
// 先找出刻子(三张相同的牌)
|
||
findAndRemoveKezi(remainingCards, cardCountMap, kezi);
|
||
|
||
// 再找出顺子
|
||
findAndRemoveShunzi(remainingCards, mainSuit, shunzi);
|
||
|
||
|
||
// 找出将牌(258对子)
|
||
// findAndRemoveJiang(remainingCards, jiang);
|
||
|
||
|
||
// 如果还有剩余牌，从剩余牌中选择要打出的牌
|
||
if (!remainingCards.isEmpty()) {
|
||
return selectFromRemainingCards(remainingCards, cardCountMap);
|
||
}
|
||
|
||
// 如果没有剩余牌，说明牌型很好，考虑拆散一组来优化
|
||
return selectCardFromFormedGroups(handCards, cardCountMap, mainSuit);
|
||
}
|
||
|
||
/**
|
||
* 找出并移除刻子
|
||
*/
|
||
private void findAndRemoveKezi(List<Integer> cards, Map<Integer, Integer> cardCountMap, List<Integer> kezi) {
|
||
// 创建临时副本避免修改遍历中的列表
|
||
List<Integer> tempCards = new ArrayList<>(cards);
|
||
Set<Integer> processedCards = new HashSet<>(); // 记录已处理的牌
|
||
|
||
for (Integer card : tempCards) {
|
||
// 如果这张牌已经处理过，或者数量不足3张，跳过
|
||
if (processedCards.contains(card) || cardCountMap.get(card) < 3) {
|
||
continue;
|
||
}
|
||
|
||
// 找到刻子，从原始cards列表中移除3张相同的牌
|
||
int removeCount = 0;
|
||
Iterator<Integer> iterator = cards.iterator();
|
||
while (iterator.hasNext() && removeCount < 3) {
|
||
Integer currentCard = iterator.next();
|
||
if (currentCard.equals(card)) {
|
||
iterator.remove();
|
||
removeCount++;
|
||
}
|
||
}
|
||
|
||
// 将刻子添加到结果列表（3次）
|
||
kezi.add(card);
|
||
kezi.add(card);
|
||
kezi.add(card);
|
||
|
||
// 标记这张牌已处理
|
||
processedCards.add(card);
|
||
|
||
logInfo("找到刻子: " + getCardName(card) + " (数量: " + cardCountMap.get(card) + ")");
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 找出并移除顺子
|
||
*/
|
||
private void findAndRemoveShunzi(List<Integer> cards, int mainSuit, List<Integer> shunzi) {
|
||
List<Integer> sortedCards = new ArrayList<>(cards);
|
||
Collections.sort(sortedCards);
|
||
|
||
for (int i = 0; i <= sortedCards.size() - 3; i++) {
|
||
int card1 = sortedCards.get(i);
|
||
int card2 = sortedCards.get(i + 1);
|
||
int card3 = sortedCards.get(i + 2);
|
||
|
||
// 检查是否构成顺子
|
||
if (isShunzi(card1, card2, card3, mainSuit)) {
|
||
// 移除顺子
|
||
cards.remove((Integer) card1);
|
||
cards.remove((Integer) card2);
|
||
cards.remove((Integer) card3);
|
||
shunzi.add(card1);
|
||
shunzi.add(card2);
|
||
shunzi.add(card3);
|
||
i += 2; // 跳过已处理的牌
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 判断三张牌是否构成顺子
|
||
*/
|
||
private boolean isShunzi(int card1, int card2, int card3, int mainSuit) {
|
||
int value1 = card1 % 100;
|
||
int value2 = card2 % 100;
|
||
int value3 = card3 % 100;
|
||
|
||
return value2 == value1 + 1 && value3 == value2 + 1;
|
||
}
|
||
|
||
/**
|
||
* 找出并移除将牌(258对子)
|
||
*/
|
||
private void findAndRemoveJiang(List<Integer> cards, List<Integer> jiang) {
|
||
Map<Integer, Integer> tempCount = new HashMap<>();
|
||
for (Integer card : cards) {
|
||
tempCount.put(card, tempCount.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
// 优先找258对子作为将牌
|
||
for (Integer card : cards) {
|
||
int value = card % 100;
|
||
if ((value == 2 || value == 5 || value == 8) && tempCount.get(card) >= 2) {
|
||
// 找到将牌
|
||
jiang.add(card);
|
||
jiang.add(card);
|
||
cards.remove(card);
|
||
cards.remove(card);
|
||
return;
|
||
}
|
||
}
|
||
|
||
// 如果没有258对子，找任意对子作为将牌
|
||
for (Integer card : cards) {
|
||
if (tempCount.get(card) >= 2) {
|
||
jiang.add(card);
|
||
jiang.add(card);
|
||
cards.remove(card);
|
||
cards.remove(card);
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 从剩余牌中选择要打出的牌
|
||
*/
|
||
private int selectFromRemainingCards(List<Integer> remainingCards, Map<Integer, Integer> cardCountMap) {
|
||
// 优先打出孤张(没有相邻牌的牌)
|
||
Integer isolatedCard = findIsolatedCard(remainingCards, cardCountMap);
|
||
if (isolatedCard != null) {
|
||
logInfo("打出孤张: " + isolatedCard);
|
||
return isolatedCard;
|
||
}
|
||
|
||
// 其次打出手牌数量最多的牌(保留单张和刻子胚子)
|
||
Integer mostCountCard = findMostCountCard(remainingCards, cardCountMap);
|
||
if (mostCountCard != null) {
|
||
logInfo("打出手牌数量多的牌: " + mostCountCard);
|
||
return mostCountCard;
|
||
}
|
||
|
||
// 最后打边张(1和9)
|
||
Integer edgeCard = findEdgeCard(remainingCards);
|
||
if (edgeCard != null) {
|
||
logInfo("打出边张: " + edgeCard);
|
||
return edgeCard;
|
||
}
|
||
|
||
// 默认打出第一张
|
||
logInfo("打出默认牌: " + remainingCards.get(0));
|
||
return remainingCards.get(0);
|
||
}
|
||
|
||
/**
|
||
* 从已组成的牌组中选择要拆打的牌
|
||
*/
|
||
private int selectCardFromFormedGroups(List<Integer> handCards, Map<Integer, Integer> cardCountMap, int mainSuit) {
|
||
// 这里可以实现更复杂的策略，比如拆散效率最低的顺子或刻子
|
||
// 简单实现：打出手牌数量最少的牌
|
||
int minCount = Integer.MAX_VALUE;
|
||
Integer cardToDiscard = null;
|
||
|
||
for (Integer card : handCards) {
|
||
int count = cardCountMap.get(card);
|
||
if (count < minCount) {
|
||
minCount = count;
|
||
cardToDiscard = card;
|
||
}
|
||
}
|
||
|
||
logInfo("从已组成牌组中打出: " + cardToDiscard);
|
||
return cardToDiscard;
|
||
}
|
||
|
||
/**
|
||
* 查找孤张(没有相邻牌的牌)
|
||
*/
|
||
private Integer findIsolatedCard(List<Integer> cards, Map<Integer, Integer> cardCountMap) {
|
||
// 统计每张牌的出现次数
|
||
Map<Integer, Integer> countMap = new HashMap<>();
|
||
for (int card : cards) {
|
||
countMap.put(card, countMap.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
// 寻找出现次数为 1 的牌（非对子）
|
||
for (int card : cards) {
|
||
if (countMap.get(card) == 1) {
|
||
return card;
|
||
}
|
||
}
|
||
|
||
// 如果没有非对子的牌，返回 null 或选择第一张牌等策略
|
||
return cards.get(0);
|
||
}
|
||
|
||
/**
|
||
* 查找手牌数量最多的牌
|
||
*/
|
||
private Integer findMostCountCard(List<Integer> cards, Map<Integer, Integer> cardCountMap) {
|
||
int maxCount = 0;
|
||
Integer result = null;
|
||
|
||
for (Integer card : cards) {
|
||
int count = cardCountMap.get(card);
|
||
if (count > maxCount) {
|
||
maxCount = count;
|
||
result = card;
|
||
}
|
||
}
|
||
|
||
return result;
|
||
}
|
||
|
||
/**
|
||
* 查找边张(1和9)
|
||
*/
|
||
private Integer findEdgeCard(List<Integer> cards) {
|
||
for (Integer card : cards) {
|
||
int value = card % 100;
|
||
if (value == 1 || value == 9) {
|
||
return card;
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
/**
|
||
* handCards :摸牌后的手牌
|
||
* 分析手牌，将顺子，刻子，将 另存
|
||
*/
|
||
public HandAnalysis analyzeHand(List<Integer> handCards) {
|
||
logInfo("\n===== 开始手牌分析 =====");
|
||
logInfo("待分析手牌: " + handCards);
|
||
|
||
|
||
// 创建分析结果对象
|
||
HandAnalysis analysis = new HandAnalysis();
|
||
|
||
|
||
// 1. 统计每张牌的数量并按花色分组
|
||
countCardsAndGroupBySuit(handCards, analysis);
|
||
|
||
// 2. 识别刻子（三张相同）
|
||
identifyTriplets(analysis);
|
||
|
||
// 4. 识别顺子（三张连续，仅分析剩余的牌）
|
||
identifySequences(analysis);
|
||
|
||
// 3. 优先识别对子（两张相同）
|
||
identifyPairs(analysis);
|
||
|
||
|
||
// 5. 识别孤张牌
|
||
identifyIsolatedCards(analysis);
|
||
|
||
// 6. 检测听牌状态
|
||
detectTingPai(analysis);
|
||
|
||
return analysis;
|
||
}
|
||
|
||
|
||
/**
|
||
* 统计每张牌的数量并按花色分组
|
||
*/
|
||
private void countCardsAndGroupBySuit(List<Integer> handCards, HandAnalysis analysis) {
|
||
Map<Integer, Integer> counts = new HashMap<>();
|
||
Map<Integer, List<Integer>> bySuit = new HashMap<>();
|
||
|
||
// 初始化花色分组（1:万, 2:筒, 3:条）
|
||
bySuit.put(1, new ArrayList<>());
|
||
bySuit.put(2, new ArrayList<>());
|
||
bySuit.put(3, new ArrayList<>());
|
||
|
||
// 统计数量并按花色分组
|
||
for (int card : handCards) {
|
||
counts.put(card, counts.getOrDefault(card, 0) + 1);
|
||
|
||
int suit = card / 100;
|
||
if (bySuit.containsKey(suit)) {
|
||
bySuit.get(suit).add(card);
|
||
}
|
||
}
|
||
|
||
// 对每个花色的牌进行排序
|
||
for (List<Integer> suitCards : bySuit.values()) {
|
||
suitCards.sort(Integer::compareTo);
|
||
}
|
||
|
||
analysis.cardCounts = counts;
|
||
analysis.cardsBySuit = bySuit;
|
||
analysis.remainingCards = new ArrayList<>(handCards);
|
||
analysis.remainingCards.sort(Integer::compareTo);
|
||
}
|
||
|
||
/**
|
||
* 识别刻子（三张相同的牌）
|
||
*/
|
||
private void identifyTriplets(HandAnalysis analysis) {
|
||
List<Integer> cardsToRemove = new ArrayList<>();
|
||
|
||
for (Map.Entry<Integer, Integer> entry : analysis.cardCounts.entrySet()) {
|
||
int card = entry.getKey();
|
||
int count = entry.getValue();
|
||
|
||
// 如果某张牌有3张或以上，识别为刻子
|
||
if (count >= 3) {
|
||
// 添加刻子
|
||
List<Integer> triplet = Arrays.asList(card, card, card);
|
||
analysis.completedMelds.add(triplet);
|
||
analysis.meldCount++;
|
||
|
||
// 标记为已使用
|
||
for (int i = 0; i < 3; i++) {
|
||
analysis.usedInMelds.add(card);
|
||
}
|
||
|
||
// 记录需要从剩余牌中移除的牌
|
||
for (int i = 0; i < 3; i++) {
|
||
cardsToRemove.add(card);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 从剩余牌中移除已识别为刻子的牌
|
||
for (int card : cardsToRemove) {
|
||
analysis.remainingCards.remove(Integer.valueOf(card));
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 识别顺子（三张连续的牌，同一花色）
|
||
*/
|
||
private void identifySequences(HandAnalysis analysis) {
|
||
// 按花色分析顺子，只使用剩余的牌
|
||
Map<Integer, List<Integer>> remainingCardsBySuit = new HashMap<>();
|
||
for (int card : analysis.remainingCards) {
|
||
if (!analysis.usedInMelds.contains(card)) {
|
||
int suit = card / 100;
|
||
remainingCardsBySuit.computeIfAbsent(suit, k -> new ArrayList<>()).add(card);
|
||
}
|
||
}
|
||
|
||
for (Map.Entry<Integer, List<Integer>> entry : remainingCardsBySuit.entrySet()) {
|
||
int suit = entry.getKey();
|
||
List<Integer> suitCards = entry.getValue();
|
||
|
||
if (suitCards.size() < 3) continue;
|
||
|
||
suitCards.sort(Integer::compareTo);
|
||
|
||
// 创建牌的计数映射，用于跟踪每张牌的数量
|
||
Map<Integer, Integer> cardCount = new HashMap<>();
|
||
for (int card : suitCards) {
|
||
cardCount.put(card, cardCount.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
// 遍历所有可能的顺子起始点
|
||
for (int startCard : suitCards) {
|
||
int secondCard = startCard + 1;
|
||
int thirdCard = startCard + 2;
|
||
|
||
// 检查是否同一花色且连续
|
||
if (secondCard / 100 == suit && thirdCard / 100 == suit &&
|
||
cardCount.getOrDefault(startCard, 0) > 0 &&
|
||
cardCount.getOrDefault(secondCard, 0) > 0 &&
|
||
cardCount.getOrDefault(thirdCard, 0) > 0) {
|
||
|
||
// 添加顺子
|
||
List<Integer> sequence = Arrays.asList(startCard, secondCard, thirdCard);
|
||
analysis.completedMelds.add(sequence);
|
||
analysis.meldCount++;
|
||
|
||
// 从计数中移除（每张牌只用一次）
|
||
cardCount.put(startCard, cardCount.get(startCard) - 1);
|
||
cardCount.put(secondCard, cardCount.get(secondCard) - 1);
|
||
cardCount.put(thirdCard, cardCount.get(thirdCard) - 1);
|
||
|
||
// 更新剩余牌和已用牌
|
||
analysis.remainingCards.remove(Integer.valueOf(startCard));
|
||
analysis.remainingCards.remove(Integer.valueOf(secondCard));
|
||
analysis.remainingCards.remove(Integer.valueOf(thirdCard));
|
||
analysis.usedInMelds.add(startCard);
|
||
analysis.usedInMelds.add(secondCard);
|
||
analysis.usedInMelds.add(thirdCard);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 识别对子（两张相同的牌）
|
||
*/
|
||
private void identifyPairs(HandAnalysis analysis) {
|
||
// 统计剩余牌中每张牌的数量
|
||
Map<Integer, Integer> remainingCounts = new HashMap<>();
|
||
for (int card : analysis.remainingCards) {
|
||
if (!analysis.usedInMelds.contains(card)) {
|
||
remainingCounts.put(card, remainingCounts.getOrDefault(card, 0) + 1);
|
||
}
|
||
}
|
||
|
||
// 识别对子
|
||
for (Map.Entry<Integer, Integer> entry : remainingCounts.entrySet()) {
|
||
int card = entry.getKey();
|
||
int count = entry.getValue();
|
||
|
||
if (count >= 2) {
|
||
analysis.pairs.add(card);
|
||
analysis.pairCount++;
|
||
|
||
// 标记为已使用
|
||
analysis.usedInPairs.add(card);
|
||
|
||
// 将对子的牌从剩余牌中移除
|
||
for (int i = 0; i < 2; i++) {
|
||
analysis.remainingCards.remove(Integer.valueOf(card));
|
||
}
|
||
|
||
// 检查是否为特殊对子（最后一位数字为2、5、8）
|
||
int lastDigit = card % 10;
|
||
if (lastDigit == 2 || lastDigit == 5 || lastDigit == 8) {
|
||
int suit = card / 100;
|
||
String suitName = getSuitName(suit);
|
||
logInfo("识别到特殊对子: " + card + " (" + suitName + lastDigit + ")");
|
||
}
|
||
}
|
||
}
|
||
|
||
// 检测是否有碰碰胡潜力（如果大部分牌都是刻子或对子）
|
||
if (analysis.meldCount >= 3 && analysis.pairCount >= 1) {
|
||
analysis.hasPengPengHu = true;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 获取花色名称
|
||
*/
|
||
private String getSuitName(int suit) {
|
||
switch (suit) {
|
||
case 1:
|
||
return "万";
|
||
case 2:
|
||
return "筒";
|
||
case 3:
|
||
return "条";
|
||
default:
|
||
return "未知";
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 识别孤张牌（未组成任何牌型的单张牌）
|
||
*/
|
||
private void identifyIsolatedCards(HandAnalysis analysis) {
|
||
// 统计剩余牌中每张牌的数量
|
||
Map<Integer, Integer> remainingCounts = new HashMap<>();
|
||
for (int card : analysis.remainingCards) {
|
||
remainingCounts.put(card, remainingCounts.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
// 识别孤张牌
|
||
for (Map.Entry<Integer, Integer> entry : remainingCounts.entrySet()) {
|
||
int card = entry.getKey();
|
||
int count = entry.getValue();
|
||
|
||
// 如果牌未用于刻子或顺子，且不是对子，则为孤张
|
||
if (!analysis.usedInPairs.contains(card)) {
|
||
for (int i = 0; i < count; i++) {
|
||
analysis.isolatedCards.add(card);
|
||
}
|
||
}
|
||
}
|
||
|
||
// 检测是否有龙七对潜力（如果有多个对子和孤张）
|
||
if (analysis.pairCount >= 4) {
|
||
analysis.hasLongQiDuiPotential = true;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 检测听牌状态
|
||
*/
|
||
private void detectTingPai(HandAnalysis analysis) {
|
||
// 创建完整手牌列表
|
||
List<Integer> fullHand = new ArrayList<>(analysis.remainingCards);
|
||
for (int card : analysis.usedInMelds) {
|
||
fullHand.add(card);
|
||
}
|
||
for (int card : analysis.usedInPairs) {
|
||
fullHand.add(card);
|
||
fullHand.add(card);
|
||
}
|
||
|
||
int totalCards = fullHand.size();
|
||
|
||
// 对于14张牌的情况，需要去掉一张牌后检查是否为和牌牌型
|
||
if (totalCards == 14) {
|
||
// 尝试去掉每张牌，检查是否可以和牌
|
||
for (int card : new HashSet<>(fullHand)) {
|
||
List<Integer> tempHand = new ArrayList<>(fullHand);
|
||
tempHand.remove(Integer.valueOf(card));
|
||
|
||
if (canHu(tempHand, analysis)) {
|
||
analysis.tingCards.add(card);
|
||
}
|
||
}
|
||
}
|
||
// 对于13张牌的情况，检查摸到哪些牌可以和牌
|
||
else if (totalCards == 13) {
|
||
// 尝试添加每张可能的牌，检查是否可以和牌
|
||
for (int suit = 1; suit <= 3; suit++) { // 1:万, 2:筒, 3:条
|
||
for (int rank = 1; rank <= 9; rank++) {
|
||
int card = suit * 100 + rank;
|
||
|
||
// 检查这张牌是否已经在手中有4张（麻将中每种牌最多4张）
|
||
int count = 0;
|
||
for (int c : fullHand) {
|
||
if (c == card) {
|
||
count++;
|
||
}
|
||
}
|
||
if (count >= 4) continue;
|
||
|
||
List<Integer> tempHand = new ArrayList<>(fullHand);
|
||
tempHand.add(card);
|
||
|
||
if (canHu(tempHand, analysis)) {
|
||
analysis.tingCards.add(card);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
// 如果有可胡的牌，则为听牌状态
|
||
analysis.isTingPai = !analysis.tingCards.isEmpty();
|
||
|
||
// 计算向听数
|
||
calculateShanten(analysis);
|
||
}
|
||
|
||
/**
|
||
* 判断手牌是否符合和牌条件（基本牌型：四组合一对将）
|
||
*/
|
||
private boolean canHu(List<Integer> hand, HandAnalysis analysis) {
|
||
// 统计牌的数量
|
||
Map<Integer, Integer> tempCounts = new HashMap<>();
|
||
for (int card : hand) {
|
||
tempCounts.put(card, tempCounts.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
// 尝试找出一对将牌
|
||
for (Map.Entry<Integer, Integer> entry : tempCounts.entrySet()) {
|
||
int card = entry.getKey();
|
||
int count = entry.getValue();
|
||
|
||
if (count >= 2) {
|
||
// 假设这对牌作为将牌
|
||
Map<Integer, Integer> copyCounts = new HashMap<>(tempCounts);
|
||
copyCounts.put(card, count - 2);
|
||
|
||
// 检查剩余的牌是否可以组成四组合（刻子或顺子）
|
||
if (checkAllMelds(copyCounts)) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 检查剩余的牌是否可以全部组成刻子或顺子
|
||
*/
|
||
private boolean checkAllMelds(Map<Integer, Integer> counts) {
|
||
// 创建剩余牌的列表（排除数量为0的牌）
|
||
List<Integer> remainingCards = new ArrayList<>();
|
||
for (Map.Entry<Integer, Integer> entry : counts.entrySet()) {
|
||
int card = entry.getKey();
|
||
int count = entry.getValue();
|
||
for (int i = 0; i < count; i++) {
|
||
remainingCards.add(card);
|
||
}
|
||
}
|
||
|
||
// 排序以便分析
|
||
remainingCards.sort(Integer::compareTo);
|
||
|
||
// 递归检查是否可以组成全部的刻子或顺子
|
||
return checkMeldsRecursive(remainingCards);
|
||
}
|
||
|
||
/**
|
||
* 递归检查是否可以组成刻子或顺子
|
||
*/
|
||
private boolean checkMeldsRecursive(List<Integer> cards) {
|
||
if (cards.isEmpty()) {
|
||
return true; // 所有牌都已组成合法牌型
|
||
}
|
||
|
||
int firstCard = cards.get(0);
|
||
|
||
// 尝试组成刻子（三张相同）
|
||
if (cards.size() >= 3 && firstCard == cards.get(1) && firstCard == cards.get(2)) {
|
||
List<Integer> newCards = new ArrayList<>(cards.subList(3, cards.size()));
|
||
if (checkMeldsRecursive(newCards)) {
|
||
return true;
|
||
}
|
||
}
|
||
|
||
// 尝试组成顺子（三张连续）
|
||
if (cards.size() >= 3) {
|
||
int secondCard = firstCard + 1;
|
||
int thirdCard = firstCard + 2;
|
||
|
||
// 确保是同一花色
|
||
int suit = firstCard / 100;
|
||
if (suit == secondCard / 100 && suit == thirdCard / 100) {
|
||
List<Integer> tempCards = new ArrayList<>(cards);
|
||
tempCards.remove(Integer.valueOf(firstCard));
|
||
|
||
// 查找第二张牌
|
||
boolean foundSecond = false;
|
||
for (int i = 0; i < tempCards.size(); i++) {
|
||
if (tempCards.get(i) == secondCard) {
|
||
tempCards.remove(i);
|
||
foundSecond = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (foundSecond) {
|
||
// 查找第三张牌
|
||
boolean foundThird = false;
|
||
for (int i = 0; i < tempCards.size(); i++) {
|
||
if (tempCards.get(i) == thirdCard) {
|
||
tempCards.remove(i);
|
||
foundThird = true;
|
||
break;
|
||
}
|
||
}
|
||
|
||
if (foundThird && checkMeldsRecursive(tempCards)) {
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 计算向听数（距离听牌还有几张牌）
|
||
* 优化的向听数计算算法，考虑了面子、对子和搭子的组合
|
||
*/
|
||
private void calculateShanten(HandAnalysis analysis) {
|
||
// 如果已经听牌，向听数为0
|
||
if (analysis.isTingPai) {
|
||
analysis.shantenCount = 0;
|
||
return;
|
||
}
|
||
|
||
// 创建完整手牌列表
|
||
List<Integer> fullHand = new ArrayList<>(analysis.remainingCards);
|
||
for (int card : analysis.usedInMelds) {
|
||
fullHand.add(card);
|
||
}
|
||
for (int card : analysis.usedInPairs) {
|
||
fullHand.add(card);
|
||
fullHand.add(card);
|
||
}
|
||
|
||
int totalCards = fullHand.size();
|
||
if (totalCards != 13 && totalCards != 14) {
|
||
analysis.shantenCount = Integer.MAX_VALUE;
|
||
return;
|
||
}
|
||
|
||
// 统计每种牌的数量
|
||
Map<Integer, Integer> counts = new HashMap<>();
|
||
for (int card : fullHand) {
|
||
counts.put(card, counts.getOrDefault(card, 0) + 1);
|
||
}
|
||
|
||
// 计算最小向听数
|
||
int minShanten = Integer.MAX_VALUE;
|
||
|
||
// 尝试每种可能的将牌（对子）
|
||
Set<Integer> possiblePairs = new HashSet<>(counts.keySet());
|
||
|
||
// 添加没有对子的情况（需要摸一张牌形成对子）
|
||
possiblePairs.add(-1);
|
||
|
||
for (int pairCard : possiblePairs) {
|
||
Map<Integer, Integer> tempCounts = new HashMap<>(counts);
|
||
int pairShanten = 0;
|
||
|
||
// 如果选择了具体的将牌
|
||
if (pairCard != -1) {
|
||
int pairCount = tempCounts.get(pairCard);
|
||
if (pairCount >= 2) {
|
||
tempCounts.put(pairCard, pairCount - 2);
|
||
} else {
|
||
// 需要摸一张牌形成对子
|
||
pairShanten = 1;
|
||
tempCounts.put(pairCard, tempCounts.getOrDefault(pairCard, 0) + 1 - 2);
|
||
}
|
||
} else {
|
||
// 需要摸一张牌形成对子
|
||
pairShanten = 1;
|
||
}
|
||
|
||
// 计算剩余牌的向听数
|
||
int meldShanten = calculateMeldShanten(tempCounts);
|
||
int totalShanten = pairShanten + meldShanten;
|
||
|
||
// 更新最小向听数
|
||
if (totalShanten < minShanten) {
|
||
minShanten = totalShanten;
|
||
}
|
||
}
|
||
|
||
// 确保向听数不为负数
|
||
analysis.shantenCount = Math.max(0, minShanten);
|
||
}
|
||
|
||
/**
|
||
* 计算剩余牌（排除将牌后）的面子向听数
|
||
*/
|
||
private int calculateMeldShanten(Map<Integer, Integer> counts) {
|
||
// 创建剩余牌的列表
|
||
List<Integer> cards = new ArrayList<>();
|
||
for (Map.Entry<Integer, Integer> entry : counts.entrySet()) {
|
||
int card = entry.getKey();
|
||
int count = entry.getValue();
|
||
for (int i = 0; i < count; i++) {
|
||
cards.add(card);
|
||
}
|
||
}
|
||
|
||
if (cards.isEmpty()) {
|
||
return 0;
|
||
}
|
||
|
||
// 按花色和数值排序
|
||
cards.sort(Comparator.comparingInt(card -> {
|
||
int suit = card / 100;
|
||
int rank = card % 100;
|
||
return suit * 10 + rank;
|
||
}));
|
||
|
||
// 使用动态规划计算最小向听数
|
||
return calculateMeldShantenRecursive(cards, 0);
|
||
}
|
||
|
||
/**
|
||
* 递归计算面子向听数
|
||
*/
|
||
private int calculateMeldShantenRecursive(List<Integer> cards, int index) {
|
||
if (index >= cards.size()) {
|
||
return 0;
|
||
}
|
||
|
||
int minShanten = Integer.MAX_VALUE;
|
||
int currentCard = cards.get(index);
|
||
|
||
// 尝试作为刻子
|
||
if (index + 2 < cards.size() && currentCard == cards.get(index + 1) && currentCard == cards.get(index + 2)) {
|
||
int shanten = calculateMeldShantenRecursive(cards, index + 3);
|
||
if (shanten < minShanten) {
|
||
minShanten = shanten;
|
||
}
|
||
} else if (index + 1 < cards.size() && currentCard == cards.get(index + 1)) {
|
||
// 有对子，可以考虑刻子（需要摸一张）
|
||
int shanten = 1 + calculateMeldShantenRecursive(cards, index + 2);
|
||
if (shanten < minShanten) {
|
||
minShanten = shanten;
|
||
}
|
||
} else {
|
||
// 单张，可以考虑刻子（需要摸两张）
|
||
int shanten = 2 + calculateMeldShantenRecursive(cards, index + 1);
|
||
if (shanten < minShanten) {
|
||
minShanten = shanten;
|
||
}
|
||
}
|
||
|
||
// 尝试作为顺子
|
||
if (index + 2 < cards.size()) {
|
||
int secondCard = currentCard + 1;
|
||
int thirdCard = currentCard + 2;
|
||
|
||
// 检查是否同一花色
|
||
int suit = currentCard / 100;
|
||
if (secondCard / 100 == suit && thirdCard / 100 == suit) {
|
||
// 检查后两张牌是否存在
|
||
boolean hasSecond = false;
|
||
boolean hasThird = false;
|
||
int secondIndex = -1;
|
||
int thirdIndex = -1;
|
||
|
||
for (int i = index + 1; i < cards.size(); i++) {
|
||
if (cards.get(i) == secondCard && !hasSecond) {
|
||
hasSecond = true;
|
||
secondIndex = i;
|
||
} else if (cards.get(i) == thirdCard && !hasThird) {
|
||
hasThird = true;
|
||
thirdIndex = i;
|
||
}
|
||
}
|
||
|
||
if (hasSecond && hasThird) {
|
||
// 创建新的牌列表，移除组成顺子的三张牌
|
||
List<Integer> newCards = new ArrayList<>();
|
||
for (int i = 0; i < cards.size(); i++) {
|
||
if (i != index && i != secondIndex && i != thirdIndex) {
|
||
newCards.add(cards.get(i));
|
||
}
|
||
}
|
||
|
||
int shanten = calculateMeldShantenRecursive(newCards, 0);
|
||
if (shanten < minShanten) {
|
||
minShanten = shanten;
|
||
}
|
||
} else {
|
||
// 缺少牌，需要计算所需的牌数
|
||
int needed = 0;
|
||
if (!hasSecond) needed++;
|
||
if (!hasThird) needed++;
|
||
|
||
// 创建新的牌列表，移除已有的牌
|
||
List<Integer> newCards = new ArrayList<>();
|
||
for (int i = 0; i < cards.size(); i++) {
|
||
if (i != index) {
|
||
if (hasSecond && i == secondIndex) continue;
|
||
if (hasThird && i == thirdIndex) continue;
|
||
newCards.add(cards.get(i));
|
||
}
|
||
}
|
||
|
||
int shanten = needed + calculateMeldShantenRecursive(newCards, 0);
|
||
if (shanten < minShanten) {
|
||
minShanten = shanten;
|
||
}
|
||
}
|
||
}
|
||
} else if (index + 1 < cards.size()) {
|
||
// 只有两张连续牌，需要一张牌组成顺子
|
||
int nextCard = cards.get(index + 1);
|
||
if (nextCard - currentCard == 1 && (currentCard / 100) == (nextCard / 100)) {
|
||
List<Integer> newCards = new ArrayList<>(cards);
|
||
newCards.remove(index);
|
||
newCards.remove(index); // 移除第二张牌
|
||
|
||
int shanten = 1 + calculateMeldShantenRecursive(newCards, 0);
|
||
if (shanten < minShanten) {
|
||
minShanten = shanten;
|
||
}
|
||
}
|
||
}
|
||
|
||
return minShanten;
|
||
}
|
||
|
||
public static int analyzeHandCards(List<Integer> handCards) {
|
||
if (handCards == null || handCards.size() != 14) {
|
||
System.out.println("错误：手牌必须是14张");
|
||
return 0;
|
||
}
|
||
|
||
System.out.println("当前手牌(14张): " + convertToReadable(handCards));
|
||
System.out.println("======================================");
|
||
|
||
|
||
|
||
// 2. 分析手牌结构
|
||
List<Integer> sortedHand = new ArrayList<>(handCards);
|
||
Collections.sort(sortedHand);
|
||
|
||
System.out.println("\n=== 手牌结构分析 ===");
|
||
|
||
// 找出所有刻子
|
||
List<List<Integer>> kezis = findKezis(sortedHand);
|
||
System.out.println("刻子(" + kezis.size() + "组):");
|
||
for (List<Integer> kezi : kezis) {
|
||
System.out.println(" " + convertToReadable(kezi));
|
||
}
|
||
|
||
// 找出所有顺子
|
||
List<List<Integer>> shunzis = findShunzis(sortedHand);
|
||
System.out.println("\n顺子(" + shunzis.size() + "组):");
|
||
for (List<Integer> shunzi : shunzis) {
|
||
System.out.println(" " + convertToReadable(shunzi));
|
||
}
|
||
|
||
// 找出所有258将牌
|
||
List<Integer> jiangCandidates = findJiangCandidates(sortedHand);
|
||
System.out.println("\n258将牌候选(" + jiangCandidates.size() + "张):");
|
||
System.out.println(" " + convertToReadable(jiangCandidates));
|
||
|
||
if (kezis.size()>0 || shunzis.size()>0 || jiangCandidates.size()>0){
|
||
return kezis.size()+shunzis.size();
|
||
}
|
||
|
||
return 0;
|
||
|
||
}
|
||
|
||
|
||
|
||
/**
|
||
* 找出所有刻子
|
||
*/
|
||
private static List<List<Integer>> findKezis(List<Integer> handCards) {
|
||
List<List<Integer>> kezis = new ArrayList<>();
|
||
List<Integer> temp = new ArrayList<>(handCards);
|
||
|
||
while (!temp.isEmpty()) {
|
||
int card = temp.get(0);
|
||
int count = Collections.frequency(temp, card);
|
||
|
||
if (count >= 3) {
|
||
List<Integer> kezi = new ArrayList<>();
|
||
kezi.add(card);
|
||
kezi.add(card);
|
||
kezi.add(card);
|
||
kezis.add(kezi);
|
||
|
||
// 移除这3张牌
|
||
for (int i = 0; i < 3; i++) {
|
||
temp.remove(Integer.valueOf(card));
|
||
}
|
||
} else {
|
||
temp.remove(Integer.valueOf(card));
|
||
}
|
||
}
|
||
|
||
return kezis;
|
||
}
|
||
|
||
/**
|
||
* 找出所有顺子
|
||
*/
|
||
private static List<List<Integer>> findShunzis(List<Integer> handCards) {
|
||
List<List<Integer>> shunzis = new ArrayList<>();
|
||
List<Integer> temp = new ArrayList<>(handCards);
|
||
|
||
// 先移除已找到的刻子
|
||
List<List<Integer>> kezis = findKezis(handCards);
|
||
for (List<Integer> kezi : kezis) {
|
||
for (int i = 0; i < 3; i++) {
|
||
temp.remove(Integer.valueOf(kezi.get(0)));
|
||
}
|
||
}
|
||
|
||
// 找顺子
|
||
Collections.sort(temp);
|
||
|
||
for (int i = 0; i < temp.size(); i++) {
|
||
int card1 = temp.get(i);
|
||
int type = getCardType(card1);
|
||
int value = getCardValue(card1);
|
||
|
||
if (type <= 3 && value <= 7) {
|
||
int card2 = card1 + 1;
|
||
int card3 = card1 + 2;
|
||
|
||
if (temp.contains(card2) && temp.contains(card3)) {
|
||
List<Integer> shunzi = new ArrayList<>();
|
||
shunzi.add(card1);
|
||
shunzi.add(card2);
|
||
shunzi.add(card3);
|
||
shunzis.add(shunzi);
|
||
|
||
// 移除这3张牌
|
||
temp.remove(Integer.valueOf(card1));
|
||
temp.remove(Integer.valueOf(card2));
|
||
temp.remove(Integer.valueOf(card3));
|
||
i--; // 因为移除了元素
|
||
}
|
||
}
|
||
}
|
||
|
||
return shunzis;
|
||
}
|
||
|
||
/**
|
||
* 找出258将牌候选
|
||
*/
|
||
private static List<Integer> findJiangCandidates(List<Integer> handCards) {
|
||
List<Integer> jiangs = new ArrayList<>();
|
||
|
||
for (int card : handCards) {
|
||
int value = getCardValue(card);
|
||
if (JIANG_PAIS.contains(value)) {
|
||
jiangs.add(card);
|
||
}
|
||
}
|
||
|
||
return jiangs;
|
||
}
|
||
|
||
|
||
/**
|
||
* 获取牌值
|
||
*/
|
||
private static int getCardValue(int card) {
|
||
return card % 10;
|
||
}
|
||
|
||
/**
|
||
* 获取牌类型
|
||
*/
|
||
private static int getCardType(int card) {
|
||
return card / 100;
|
||
}
|
||
|
||
/**
|
||
* 格式化单张牌
|
||
*/
|
||
private static String formatCard(int card) {
|
||
int type = getCardType(card);
|
||
int value = getCardValue(card);
|
||
switch (type) {
|
||
case 1:
|
||
return value + "万";
|
||
case 2:
|
||
return value + "筒";
|
||
case 3:
|
||
return value + "条";
|
||
default:
|
||
return "字牌" + value;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 转换为可读格式
|
||
*/
|
||
private static String convertToReadable(List<Integer> cards) {
|
||
if (cards == null || cards.isEmpty()) {
|
||
return "空";
|
||
}
|
||
|
||
List<String> cardStrs = new ArrayList<>();
|
||
for (int card : cards) {
|
||
cardStrs.add(formatCard(card));
|
||
}
|
||
return String.join(" ", cardStrs);
|
||
}
|
||
|
||
|
||
public List<Integer> chuguodepai() {
|
||
return chuguodepai;
|
||
}
|
||
}
|