5057 lines
174 KiB
Java
5057 lines
174 KiB
Java
package taurus.util;
|
||
|
||
import com.game.Util;
|
||
import com.taurus.core.entity.ITArray;
|
||
import com.taurus.core.entity.ITObject;
|
||
import com.taurus.core.entity.TArray;
|
||
import com.taurus.core.entity.TObject;
|
||
import com.taurus.core.util.Logger;
|
||
import hunan.HandAnalysis;
|
||
import hunan.HuNanChangSha;
|
||
import org.w3c.dom.html.HTMLDOMImplementation;
|
||
|
||
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 teshuXuanPai(List<Integer> cardInhand, List<Integer> pengCard, List<Integer> chowGroup,List<Integer> gangdepai){
|
||
String outcard = "";
|
||
//特殊牌型处理
|
||
//判断是否6对，是否快满足清一色
|
||
//判断清一色
|
||
//查询吃碰杠是否是同一色
|
||
List<Integer> checkcpg = new ArrayList<>();
|
||
checkcpg.addAll(pengCard);
|
||
checkcpg.addAll(chowGroup);
|
||
checkcpg.addAll(gangdepai);
|
||
|
||
boolean qys = false;
|
||
if (checkcpg.size()>0){
|
||
int tmp1 = 0;
|
||
int tmp2 = 0;
|
||
for (int i=0;i<checkcpg.size()-1;i++) {
|
||
tmp1 = checkcpg.get(i);
|
||
tmp2 = checkcpg.get(i+1);
|
||
if (Math.abs(tmp2-tmp1)>10){
|
||
//落地已经有了不同色，所以可以进行
|
||
qys = true;
|
||
}
|
||
}
|
||
|
||
Map<String,List<Integer>> cardst2 = new HashMap<>();
|
||
collectionCardse(cardInhand,cardst2);
|
||
//检测手牌
|
||
if (!qys){
|
||
//检测同色牌有多少张
|
||
for (Map.Entry<String,List<Integer>> entry : cardst2.entrySet()) {
|
||
List<Integer> values = entry.getValue();
|
||
if (values.size() > 0 && values.size() <= 2){
|
||
//如果只有一张同色，那就打这一张
|
||
return entry.getValue().get(0).toString();
|
||
}
|
||
}
|
||
}
|
||
}else{
|
||
//检测手牌
|
||
if (cardInhand.size()==14){
|
||
//检测同色牌有多少张
|
||
Map<String,List<Integer>> cardst = new HashMap<>();
|
||
collectionCardse(cardInhand,cardst);
|
||
for (Map.Entry<String,List<Integer>> entry : cardst.entrySet()) {
|
||
if (entry.getValue().size()==1){
|
||
//如果只有一张同色，那就打这一张
|
||
return entry.getValue().get(0).toString();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
public void collectionCardse(List<Integer> cardInhand,Map<String,List<Integer>>cardst){
|
||
Map<Integer,List<Integer>> se = new HashMap<>();
|
||
int wanzi = 0;
|
||
int tongzi = 0;
|
||
List<Integer> wanzicards = new ArrayList<>();
|
||
List<Integer> tongzicards = new ArrayList<>();
|
||
for (int i=0;i<cardInhand.size();i++){
|
||
|
||
if (cardInhand.get(i)/100==1){
|
||
wanzi++;
|
||
wanzicards.add(cardInhand.get(i));
|
||
}
|
||
if (cardInhand.get(i)/100==2){
|
||
tongzi++;
|
||
tongzicards.add(cardInhand.get(i));
|
||
}
|
||
}
|
||
cardst.put("wanzi",wanzicards);
|
||
cardst.put("tongzi",tongzicards);
|
||
}
|
||
|
||
|
||
/**
|
||
* 主算法入口：在摸牌后、打牌前进行全面分析，确定最优出牌策略
|
||
* 核心流程：摸牌分析 -> 听牌检测 -> 策略制定 -> 出牌选择
|
||
*/
|
||
public String outCardSuanFa(List<Integer> cardInhand, List<Integer> pengCard, List<Integer> chowGroup,List<Integer> gangdepai, List<Integer> resultList) {
|
||
List<Integer> handCards = new ArrayList<>(cardInhand);
|
||
|
||
List<Integer> pinghuhandCards = new ArrayList<>(cardInhand);
|
||
|
||
|
||
List<Integer> pinghuhandCards1 = new ArrayList<>(cardInhand);
|
||
|
||
|
||
chuguodepai.addAll(resultList);
|
||
log.info("cardInhand:"+cardInhand);
|
||
log.info("pengCard:"+pengCard);
|
||
log.info("chowGroup:"+chowGroup);
|
||
log.info("gangdepai:"+gangdepai);
|
||
log.info("resultList:"+resultList);
|
||
|
||
|
||
handCards.addAll(chowGroup);
|
||
handCards.addAll(pengCard);
|
||
|
||
handCards.sort(Integer::compareTo);
|
||
|
||
int i = countPengGroups(handCards, pengCard); //刻子的数量
|
||
int pisCardsCount = countPairs(handCards);//分析七小对
|
||
//将将胡
|
||
boolean jiangHu = isJiangHu(handCards);
|
||
boolean isPengPengHu = hasThreeKeziAndTwoPairs(handCards, pengCard);
|
||
//清一色碰碰胡
|
||
// boolean hasBigSuit = isAllSameSuit(handCards, pengCard); // 分析是否有可能的清一色花色
|
||
int hasBigSuit = checkDahu(handCards,chowGroup,pengCard,gangdepai);
|
||
|
||
System.out.println("resultList22 +++++++++++++++++++++++================" + hasBigSuit);
|
||
|
||
|
||
//特殊牌型处理
|
||
String tscard = teshuXuanPai(cardInhand, pengCard, chowGroup, gangdepai);
|
||
if (tscard!=null){
|
||
System.out.printf("特殊牌型处理111 +++++++++++++++++++++++++++++++++++");
|
||
return tscard;
|
||
}
|
||
|
||
|
||
//循环去一张是否能大胡听牌
|
||
Map<Integer,List<Integer>> afterDahuOp = quyizhangDahuTingPai(cardInhand,chowGroup,pengCard,gangdepai);
|
||
System.out.println("afterDahuOp:"+afterDahuOp);
|
||
|
||
if (afterDahuOp.size()>0){
|
||
//执行
|
||
int xuanzecard1 = 0;
|
||
int caozuonum1 = 0;
|
||
List<Integer> tmpres = new ArrayList<>();
|
||
tmpres.addAll(resultList);
|
||
tmpres.addAll(cardInhand);
|
||
for (Map.Entry<Integer, List<Integer>> entry : afterDahuOp.entrySet()) {
|
||
if (caozuonum1==0){
|
||
caozuonum1 = getTingPainum(entry.getValue(),tmpres);
|
||
xuanzecard1 = entry.getKey();
|
||
}
|
||
if (caozuonum1 < getTingPainum(entry.getValue(),tmpres)){
|
||
caozuonum1 = getTingPainum(entry.getValue(),tmpres);
|
||
xuanzecard1 = entry.getKey();
|
||
}
|
||
}
|
||
//判断是否绝听
|
||
if(caozuonum1>0){
|
||
System.out.printf("大胡222 +++++++++++++++++++++++++++++++++++"+caozuonum1);
|
||
return String.valueOf(xuanzecard1);
|
||
}
|
||
|
||
}
|
||
|
||
//循环去一张还能听多牌
|
||
Map<Integer,List<Integer>> afterOp = quyizhangTingPai(cardInhand);
|
||
System.out.println("afterOp:"+afterOp);
|
||
|
||
if (afterOp.size()>0){
|
||
//执行
|
||
int xuanzecard = 0;
|
||
int caozuonum = 0;
|
||
List<Integer> tmpres = new ArrayList<>();
|
||
tmpres.addAll(resultList);
|
||
tmpres.addAll(cardInhand);
|
||
for (Map.Entry<Integer, List<Integer>> entry : afterOp.entrySet()) {
|
||
if (caozuonum==0){
|
||
caozuonum = getTingPainum(entry.getValue(),tmpres);
|
||
xuanzecard = entry.getKey();
|
||
}
|
||
if (caozuonum < getTingPainum(entry.getValue(),tmpres)){
|
||
caozuonum = getTingPainum(entry.getValue(),tmpres);
|
||
xuanzecard = entry.getKey();
|
||
}
|
||
}
|
||
if(caozuonum>0){
|
||
//绝听要换牌
|
||
System.out.printf("特殊牌型处理222 +++++++++++++++++++++++++++++++++++");
|
||
return String.valueOf(xuanzecard);
|
||
}
|
||
}
|
||
|
||
|
||
//六对
|
||
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);
|
||
System.out.printf("特殊牌型处理444 +++++++++++++++++++++++++++++++++++");
|
||
|
||
return String.valueOf(outcard);
|
||
}
|
||
|
||
|
||
|
||
if (pisCardsCount >= 5 && pengCard.size() == 0 && chowGroup.size() == 0) {
|
||
|
||
//大胡出牌逻辑 - 七小对
|
||
int outcard = selectCardToDiscardBig(handCards, pisCardsCount);
|
||
System.out.printf("特殊牌型处理666 +++++++++++++++++++++++++++++++++++");
|
||
|
||
return String.valueOf(outcard);
|
||
}
|
||
|
||
System.out.println(hasBigSuit);
|
||
if (hasBigSuit>0) {
|
||
logInfo("执行清一色策略，尝试优化花色分布");
|
||
// 调用清一色特定出牌策略
|
||
int outcard = selectCardToDiscardForAllSameSuit(pinghuhandCards, chowGroup, pengCard);
|
||
if (outcard != -1) {
|
||
System.out.printf("特殊牌型处理555 +++++++++++++++++++++++++++++++++++");
|
||
|
||
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);
|
||
|
||
}
|
||
|
||
}
|
||
|
||
|
||
|
||
//七小对清一色
|
||
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) {
|
||
System.out.printf("特殊牌型处理888 +++++++++++++++++++++++++++++++++++");
|
||
|
||
return discardCard;
|
||
}
|
||
}
|
||
|
||
|
||
if (hasBigSuit>0 && i >= 3 && chowGroup.size() == 0) {
|
||
logInfo("清一色碰碰胡");
|
||
String discardCard = selectCardToDiscardPengPeng(pinghuhandCards);
|
||
if (discardCard != null) {
|
||
System.out.printf("特殊牌型处理999 +++++++++++++++++++++++++++++++++++");
|
||
|
||
return discardCard;
|
||
}
|
||
}
|
||
|
||
//调平胡递归
|
||
List<Integer> integers = ChangshaWinSplitCard.analyzeBestDiscard(pinghuhandCards);
|
||
System.out.println("integers:"+integers);
|
||
if(integers.size()>0) {
|
||
int integer = 0;
|
||
|
||
integer = selectBestCardByPriority(integers);
|
||
|
||
Map<String, List<Integer>> mapduijiang = new HashMap<>();
|
||
|
||
int duijiangnum = checkduijiang(pinghuhandCards);
|
||
|
||
if (integers.size() > 1 && duijiangnum == 0) {
|
||
integer = selectBestCardRemove258(integers);
|
||
}
|
||
|
||
//判断是否可以开杠
|
||
int cardnum = 0;
|
||
if (integer > 0) {
|
||
cardnum = Util.cardNum(integer, cardInhand);
|
||
}
|
||
|
||
|
||
if (integers.size() > 0 && cardnum < 4) {
|
||
System.out.println("平胡最新出牌策略=============================================== 666 " + integer);
|
||
|
||
List<Integer> guzhangc = new ArrayList<>();
|
||
|
||
for(int k : pinghuhandCards){
|
||
if(integer-1==k||integer+1==k||integer-2==k||integer+2==k){
|
||
//门子
|
||
guzhangc.add(integer);
|
||
}
|
||
}
|
||
//没有孤章门子
|
||
if(guzhangc.size()==0) {
|
||
return String.valueOf(integer);
|
||
}
|
||
|
||
|
||
//处理拆对子问题
|
||
//如果手牌没有对将则拆对子，等将下听
|
||
//1、判断是否有对将
|
||
int duijiangnum2 = checkduijiang(pinghuhandCards);
|
||
//2拆对子
|
||
//获取对子
|
||
if(duijiangnum2==0) {
|
||
// 1. 统计牌型
|
||
Map<Integer, Integer> countMap = new HashMap<>();
|
||
for (int c : pinghuhandCards) {
|
||
countMap.put(c, countMap.getOrDefault(c, 0) + 1);
|
||
}
|
||
List<Integer> chaiduizi = new ArrayList<>();
|
||
for (Map.Entry<Integer, Integer> entry : countMap.entrySet()) {
|
||
if (entry.getValue() == 2) {
|
||
if (entry.getKey()%100==2||entry.getKey()%100==5||entry.getKey()%100==8){
|
||
}else{
|
||
chaiduizi.add(entry.getKey());
|
||
}
|
||
}
|
||
}
|
||
|
||
System.out.println("chaiduizi:" + chaiduizi);
|
||
List<Integer> kydongduizi = new ArrayList<>();
|
||
|
||
List<Integer> tmps = new ArrayList<>();
|
||
tmps.addAll(chaiduizi);
|
||
|
||
for (int c : chaiduizi) {
|
||
if(c%100!=2&&c%100!=5&&c%100!=8){
|
||
for(int k : pinghuhandCards){
|
||
if(c-1==k||c+1==k){
|
||
//门子
|
||
kydongduizi.add(c);
|
||
}
|
||
}
|
||
}
|
||
|
||
}
|
||
chaiduizi.removeAll(kydongduizi);
|
||
System.out.println("kydongduizi:" + chaiduizi);
|
||
|
||
if(chaiduizi.size()>0) {
|
||
return String.valueOf(chaiduizi.get(0));
|
||
}else{
|
||
if (tmps.size() > 0) {
|
||
for (int a : tmps) {
|
||
if (a%100==9||a%100==1){
|
||
return String.valueOf(a);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
}else if(duijiangnum2==1){
|
||
int jiangcards = 0;
|
||
// 1. 统计牌型
|
||
Map<Integer, Integer> countMap = new HashMap<>();
|
||
for (int c : pinghuhandCards) {
|
||
countMap.put(c, countMap.getOrDefault(c, 0) + 1);
|
||
}
|
||
List<Integer> chaiduizi = new ArrayList<>();
|
||
for (Map.Entry<Integer, Integer> entry : countMap.entrySet()) {
|
||
if (entry.getValue() == 2) {
|
||
if (entry.getKey()%100==2||entry.getKey()%100==5||entry.getKey()%100==8){
|
||
jiangcards = entry.getKey();
|
||
}else{
|
||
chaiduizi.add(entry.getKey());
|
||
}
|
||
}
|
||
}
|
||
|
||
System.out.println("jiangcards:" + jiangcards);
|
||
if (jiangcards > 0&&chaiduizi.size()<2) {
|
||
//
|
||
//去掉将判断孤章
|
||
List<Integer> qudiaohou = new ArrayList<>();
|
||
qudiaohou.addAll(cardInhand);
|
||
Util.removeCard(qudiaohou,jiangcards,2);
|
||
|
||
Map<String, Object> map3 = new HashMap<>();
|
||
ChangshaWinSplitCard.checkNormalHu(qudiaohou, map3);
|
||
List<Integer> outs =(List<Integer>) map3.get("cardResiue");
|
||
if (outs.size()>0){
|
||
return String.valueOf(outs.get(0));
|
||
}
|
||
|
||
}
|
||
//先过滤2，5，8
|
||
|
||
List<Integer> kydongduizi = new ArrayList<>();
|
||
for (int c : chaiduizi) {
|
||
for(int k : pinghuhandCards){
|
||
if(c-1==k||c+1==k){
|
||
//门子
|
||
if(!kydongduizi.contains(c)){
|
||
kydongduizi.add(c);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if(kydongduizi.size()==chaiduizi.size()&&chaiduizi.size()>0) {
|
||
return String.valueOf(chaiduizi.get(0));
|
||
}
|
||
chaiduizi.removeAll(kydongduizi);
|
||
|
||
if(chaiduizi.size()>0) {
|
||
return String.valueOf(chaiduizi.get(0));
|
||
}else{
|
||
|
||
return String.valueOf(integer);
|
||
}
|
||
}else{
|
||
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);
|
||
// System.out.println("bestDiscard:"+bestDiscard);
|
||
|
||
/* if (bestDiscard != 0) {
|
||
if (ai1.isTinAi) {
|
||
isTin = true;
|
||
}
|
||
System.out.println("Ai出牌长麻 ++++++++++++++++++++++++++++++++++++++");
|
||
log.info("Ai出牌长麻===============================");
|
||
return String.valueOf(bestDiscard);
|
||
}*/
|
||
|
||
|
||
|
||
|
||
// 1. 手牌分析 - 识别刻子、顺子、对子等牌型
|
||
HandAnalysis analysis = analyzeHand(pinghuhandCards1);
|
||
|
||
//最终出的牌
|
||
int outcard = selectCardToDiscard(pinghuhandCards1, 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);
|
||
}
|
||
|
||
|
||
if (isJiangPai(outcard)&&integers.size()>0){
|
||
return String.valueOf(integers.get(0));
|
||
}
|
||
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==5||value==8) {
|
||
return 5;
|
||
}
|
||
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 static 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 static 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;
|
||
}
|
||
|
||
/**
|
||
* 检测当前牌 是否符合清一色
|
||
* @param card
|
||
* @param handCards
|
||
* @param pengguopai
|
||
* @param chipai
|
||
* @param gangpai
|
||
* @return
|
||
*/
|
||
public static boolean checkAllSameSuitAll(int card, List<Integer> handCards, List<Integer> pengguopai, List<Integer> chipai, List<Integer> gangpai) {
|
||
//判断 peng，chi ，gang是否有不同色
|
||
//true 为可以 false 为不能
|
||
List<Integer> cpg = new ArrayList<>();
|
||
cpg.addAll(pengguopai);
|
||
cpg.addAll(chipai);
|
||
cpg.addAll(gangpai);
|
||
if (cpg.size()>0){
|
||
int tmp1 = 0;
|
||
int tmp2 = 0;
|
||
for (int i=0;i<cpg.size()-1;i++) {
|
||
tmp1 = cpg.get(i);
|
||
tmp2 = cpg.get(i+1);
|
||
if (Math.abs(tmp2-tmp1)>10){
|
||
//落地已经有了不同色，所以可以进行
|
||
return true;
|
||
|
||
}
|
||
}
|
||
}
|
||
//加入之后
|
||
cpg.add(card);
|
||
if (cpg.size()>1){
|
||
int tmp3 = 0;
|
||
int tmp4 = 0;
|
||
for (int i=0;i<cpg.size()-1;i++) {
|
||
tmp3 = cpg.get(i);
|
||
tmp4 = cpg.get(i+1);
|
||
if (Math.abs(tmp4-tmp3)>10){
|
||
//牌 加入已经破坏手牌
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
cpg.clear();
|
||
//判断手牌
|
||
if(handCards.size()>3){
|
||
//手牌判断
|
||
// 统计各花色的牌数量
|
||
Map<Integer, Integer> suitCountMap = new HashMap<>();
|
||
for (Integer cards : handCards) {
|
||
int suit = cards / 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 (handCards.size()==4){
|
||
//手牌只有4张
|
||
if (count >= 2) {
|
||
//当手牌已经剩下4张时候，可以进行
|
||
return true;
|
||
}
|
||
}
|
||
|
||
if (count >= handCards.size()-3) {
|
||
int tmpsuit = card / 100;
|
||
if (suit == tmpsuit){
|
||
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;
|
||
}
|
||
List<Integer> chi = new ArrayList<>();
|
||
chi.addAll(chowGroup);
|
||
//如果吃和碰的牌 包含主要花色的牌，放弃走清一色
|
||
if (chowGroup != null && pengGroup != null && chowGroup.size() > 0 && pengGroup.size() > 0) {
|
||
chi.addAll(pengGroup);
|
||
for (Integer integer : chi) {
|
||
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) {
|
||
// 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;
|
||
}
|
||
|
||
public static boolean isJiangPai(int card) {
|
||
if (card % 100 == 2 || card % 100 == 5 || card % 100 == 8) {
|
||
return true;
|
||
}
|
||
return false;
|
||
}
|
||
public static int checkduijiang(List<Integer> cardInHand) {
|
||
Map<Integer, Integer> countMap = new HashMap<>();
|
||
for (Integer item : cardInHand) {
|
||
countMap.put(item, countMap.getOrDefault(item, 0) + 1);
|
||
}
|
||
System.out.println("countMap: " + countMap);
|
||
int jiangnum = 0;
|
||
for (int key : countMap.keySet()) {
|
||
if (isJiangPai(key) && countMap.get(key) == 2) {
|
||
jiangnum++;
|
||
}
|
||
}
|
||
return jiangnum;
|
||
}
|
||
|
||
public static int checkChiTingAction(int card,List<Integer> changShaCardInhand){
|
||
//判断吃之后能否下听
|
||
List<List<Integer>> lists = new ArrayList<>();
|
||
lists.addAll(TinHuChi.checkChi(changShaCardInhand, card));
|
||
int index = 0;
|
||
int flag = 0;
|
||
for (List<Integer> list : lists) {
|
||
List<Integer> temphand = new ArrayList<>();
|
||
temphand.addAll(changShaCardInhand);
|
||
temphand.add(card);
|
||
Util.removeCard(temphand, list.get(0), 1);
|
||
Util.removeCard(temphand, list.get(1), 1);
|
||
Util.removeCard(temphand, list.get(2), 1);
|
||
List<Integer> checktingpai1 = TinHuChi.checktingpai(temphand);
|
||
if (checktingpai1.size() > 0) {
|
||
flag = index + 1;
|
||
}
|
||
index++;
|
||
System.out.println("checktingpai1 吃牌 " + checktingpai1);
|
||
}
|
||
|
||
|
||
// TODO: 2026/1/1
|
||
// 1.需要补充 没听牌也可以吃 但是吃之后要比吃之前的手牌强 也就是可听数量变多
|
||
// 2.听牌后也能吃牌，要比吃之前的牌强
|
||
// 3.碰也一样要加
|
||
//吃之后不下听
|
||
if (flag>0){
|
||
return flag;
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
|
||
|
||
public static int checkCanChiAction(int card,List<Integer> changShaCardInhand){
|
||
//吃之后也不能听
|
||
Map<String, Object> map = new HashMap<>();
|
||
Map<String, Object> map2 = new HashMap<>();
|
||
//吃之前的逻辑
|
||
List<List<Integer>> lists1 = TinHuChi.checkChi(changShaCardInhand, card);
|
||
|
||
int jiangnum = checkduijiang(changShaCardInhand);
|
||
List<Integer> tmpChangSch = new ArrayList<>();
|
||
tmpChangSch.addAll(changShaCardInhand);
|
||
tmpChangSch.add(card);
|
||
ChangshaWinSplitCard.checkNormalHu(tmpChangSch, map);
|
||
|
||
System.out.println("checkNormalHu" + map.get("cardResiue"));
|
||
System.out.println("checktingpai1" + lists1);
|
||
|
||
int index1 = 0;
|
||
int flag1 = 0;
|
||
for (List<Integer> list : lists1) {
|
||
List<Integer> temphand = new ArrayList<>();
|
||
temphand.addAll(tmpChangSch);
|
||
Util.removeCard(temphand, list.get(0), 1);
|
||
Util.removeCard(temphand, list.get(1), 1);
|
||
Util.removeCard(temphand, list.get(2), 1);
|
||
ChangshaWinSplitCard.checkNormalHu(temphand, map2);
|
||
//判断两个map是否找到更优
|
||
System.out.println("map1:" + Integer.parseInt(map.get("remainingMelds").toString()));
|
||
System.out.println("map2:" + Integer.parseInt(map2.get("remainingMelds").toString()));
|
||
if (Integer.parseInt(map2.get("remainingMelds").toString()) < Integer.parseInt(map.get("remainingMelds").toString())) {
|
||
flag1 = index1 + 1;
|
||
} else if (Integer.parseInt(map2.get("remainingMelds").toString()) == Integer.parseInt(map.get("remainingMelds").toString())) {
|
||
int size2 = ((List<Integer>) map2.get("cardResiue")).size();
|
||
System.out.println("size2" + size2);
|
||
int size1 = ((List<Integer>) map.get("cardResiue")).size();
|
||
System.out.println("size1" + size1);
|
||
if (size2 < size1) {
|
||
flag1 = index1 + 1;
|
||
}
|
||
//如果手里没有将，则可以吃
|
||
if (jiangnum > 0) {
|
||
int chihoujiangnum = checkduijiang(temphand);
|
||
if (chihoujiangnum > 0) {
|
||
//吃之后还有将
|
||
flag1 = index1 + 1;
|
||
}
|
||
} else {
|
||
System.out.println("没队将");
|
||
//孤章1张 差一手 不是将 而且card不是将
|
||
if (Integer.parseInt(map.get("remainingMelds").toString()) == 1 && size1 == 1 && !isJiangPai(((List<Integer>) map.get("cardResiue")).get(0)) && !isJiangPai(card)) {
|
||
//吃
|
||
break;
|
||
}
|
||
flag1 = index1 + 1;
|
||
// break;
|
||
}
|
||
}
|
||
index1++;
|
||
}
|
||
|
||
if (flag1 > 0) {
|
||
return flag1;
|
||
}
|
||
return 0;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param handcards
|
||
* @param chowGrop
|
||
* @param pengGrop
|
||
* @param gangGrop
|
||
* @return
|
||
* 1,清一色，2，7小对，3，碰碰胡，4，将将胡，5，门清
|
||
*/
|
||
public static int checkDahu(List<Integer> handcards,List<Integer> chowGrop,List<Integer>pengGrop,List<Integer>gangGrop){
|
||
//检测是否可以是大胡
|
||
//1、青一色
|
||
boolean qys = checkHandsQingYiSe(handcards,chowGrop,pengGrop,gangGrop);
|
||
if (qys){
|
||
return 1;
|
||
}
|
||
//2、7小对
|
||
int cpairs = countPairs(handcards);
|
||
if (cpairs>4){
|
||
return 2;
|
||
}
|
||
boolean pph = false;
|
||
//3、碰碰胡
|
||
if (pengGrop.size()==3&&chowGrop.size()==0){
|
||
if (cpairs>3){
|
||
return 3;
|
||
}
|
||
}else if (pengGrop.size()==6&&chowGrop.size()==0){
|
||
if (cpairs>2){
|
||
return 3;
|
||
}
|
||
}else if (pengGrop.size()==9&&chowGrop.size()==0){
|
||
if (cpairs>1){
|
||
return 3;
|
||
}
|
||
}
|
||
//4、将将胡
|
||
boolean jjh = false;
|
||
if (pengGrop.size() == 0){
|
||
int count258 = 0;
|
||
for (Integer card : handcards) {
|
||
if (is258Card(card)) {
|
||
count258++;
|
||
}
|
||
}
|
||
if (count258>=9){
|
||
return 4;
|
||
}
|
||
}
|
||
if (pengGrop.size() == 3){
|
||
//碰都是将
|
||
boolean tmpj = isJiangPai(pengGrop.get(0));
|
||
if (tmpj){
|
||
int count258 = 0;
|
||
for (Integer card : handcards) {
|
||
if (is258Card(card)) {
|
||
count258++;
|
||
}
|
||
}
|
||
if (count258>6){
|
||
return 4;
|
||
}
|
||
}
|
||
}
|
||
if (pengGrop.size() == 6){
|
||
//碰都是将
|
||
boolean tmpj2 = isJiangPai(pengGrop.get(0));
|
||
if (tmpj2){
|
||
int count258 = 0;
|
||
for (Integer card : handcards) {
|
||
if (is258Card(card)) {
|
||
count258++;
|
||
}
|
||
}
|
||
if (count258>3){
|
||
return 4;
|
||
}
|
||
}
|
||
}
|
||
|
||
return 0;
|
||
}
|
||
|
||
public static boolean checkHandsQingYiSe(List<Integer> handcards,List<Integer> chowGrop,List<Integer>pengGrop,List<Integer>gangGrop){
|
||
//true 为可以 false 为不能
|
||
List<Integer> cpg = new ArrayList<>();
|
||
cpg.addAll(chowGrop);
|
||
cpg.addAll(pengGrop);
|
||
cpg.addAll(gangGrop);
|
||
if (cpg.size()>0){
|
||
int tmp1 = 0;
|
||
int tmp2 = 0;
|
||
for (int i=0;i<cpg.size()-1;i++) {
|
||
tmp1 = cpg.get(i);
|
||
tmp2 = cpg.get(i+1);
|
||
if (Math.abs(tmp2-tmp1)>10){
|
||
//落地已经有了不同色，所以可以进行
|
||
return false;
|
||
}
|
||
}
|
||
}
|
||
|
||
|
||
|
||
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 (handcards.size()==13){
|
||
if (count >= 10) {
|
||
return true;
|
||
}
|
||
}else if (handcards.size()==10){
|
||
if (count >= 7) {
|
||
List<Integer> cpg2 = new ArrayList<>();
|
||
cpg2.addAll(chowGrop);
|
||
cpg2.addAll(pengGrop);
|
||
cpg2.addAll(gangGrop);
|
||
if (cpg2.size()>0){
|
||
if(cpg2.get(0)/100!=suit){
|
||
return false;
|
||
}
|
||
}
|
||
|
||
|
||
return true;
|
||
}
|
||
} else if (handcards.size()==7) {
|
||
if (count >= 4) {
|
||
List<Integer> cpg3 = new ArrayList<>();
|
||
cpg3.addAll(chowGrop);
|
||
cpg3.addAll(pengGrop);
|
||
cpg3.addAll(gangGrop);
|
||
if (cpg3.size()>0){
|
||
if(cpg3.get(0)/100!=suit){
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
}else if (handcards.size()==4) {
|
||
if (count >= 2) {
|
||
List<Integer> cpg3 = new ArrayList<>();
|
||
cpg3.addAll(chowGrop);
|
||
cpg3.addAll(pengGrop);
|
||
cpg3.addAll(gangGrop);
|
||
if (cpg3.size()>0){
|
||
if(cpg3.get(0)/100!=suit){
|
||
return false;
|
||
}
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
}
|
||
return false;
|
||
}
|
||
|
||
/**
|
||
* 通过结果计算最优分数并返回对应的选择id
|
||
* @param map
|
||
* @return
|
||
*/
|
||
public static int suanfen(Map<Integer,ITObject>map){
|
||
System.out.println("suanfen"+map);
|
||
if (map.size()==0){
|
||
return 0;
|
||
}
|
||
Map<Integer,Integer> fell = new HashMap<>();
|
||
for (Map.Entry<Integer,ITObject> entry : map.entrySet()) {
|
||
int tmp = 0;
|
||
/*if (entry.getValue().getBoolean("isTing")){
|
||
tmp= tmp+30;
|
||
}*/
|
||
if (entry.getValue().getBoolean("xiaoDahu")){
|
||
tmp= tmp-20;
|
||
}
|
||
/* if (entry.getValue().getInt("isDaHu")>0){
|
||
tmp= tmp-10;
|
||
}*/
|
||
if (entry.getValue().getBoolean("xiaoJiang")){
|
||
tmp= tmp-13;
|
||
}
|
||
if (entry.getValue().getInt("tingNum")!=0){
|
||
tmp= tmp+entry.getValue().getInt("tingNum")*4;
|
||
}
|
||
if (entry.getValue().getBoolean("sanTing")){
|
||
tmp= tmp-50;
|
||
}
|
||
|
||
if (entry.getValue().getBoolean("canTing")&&!entry.getValue().getBoolean("isTing")){
|
||
//从不能听牌到听牌，
|
||
tmp= tmp+20;
|
||
}
|
||
if (entry.getValue().getInt("teshu")>0){
|
||
tmp= tmp+entry.getValue().getInt("teshu")*1;
|
||
}
|
||
if (entry.getValue().getInt("lastHands")>0){
|
||
tmp= tmp+entry.getValue().getInt("lastHands")*5;
|
||
}
|
||
if (entry.getValue().getInt("guzhang")>0){
|
||
tmp= tmp+entry.getValue().getInt("guzhang")*1;
|
||
}
|
||
System.out.println("tmp:"+tmp);
|
||
fell.put(entry.getKey(), tmp);
|
||
}
|
||
|
||
//找分数最高的id
|
||
int dangqianfen = 0;
|
||
int dangqianid = 0;
|
||
for (Map.Entry<Integer, Integer> entry : fell.entrySet()) {
|
||
if (dangqianid==0){
|
||
dangqianid = entry.getKey();
|
||
dangqianfen = entry.getValue();
|
||
}
|
||
if (entry.getValue()>dangqianfen){
|
||
dangqianfen = entry.getValue();
|
||
dangqianid = entry.getKey();
|
||
}
|
||
}
|
||
if (dangqianfen>4){
|
||
return dangqianid;
|
||
}else{
|
||
dangqianid = 0;
|
||
}
|
||
return dangqianid;
|
||
}
|
||
|
||
/**
|
||
* 检测碰之后的结果
|
||
* @param beforelisten
|
||
* @param card
|
||
* @param opcard
|
||
* @param yupanhandcard
|
||
* @param beforeIsDahu
|
||
* @param allSeeCard
|
||
* @param chowGroup
|
||
* @param pengGrop
|
||
* @param gangGrop
|
||
* @return
|
||
*
|
||
* boolean isTing 是否听牌
|
||
* * boolean canTing 能否听牌
|
||
* * boolean sanTing 是否散听
|
||
* * int tingNum 听多少张
|
||
* * int isDaHu 是否大胡
|
||
* * boolean xiaoDahu 是否消掉大胡
|
||
* *
|
||
* * int guzhang 有多少孤章 相差
|
||
* * int lastHands 差多少手 相差
|
||
* * boolean xiaoJiang 是否把将去没了
|
||
* int teshu 特殊加分减分
|
||
*
|
||
* * int id tiplist id
|
||
* * List<Integer> opcard
|
||
* * int weight tiplist weight
|
||
* * int card tiplist card
|
||
* * int type tiplist type
|
||
*
|
||
*/
|
||
public static ITObject pingguPeng(boolean beforelisten, int card, ITArray opcard, List<Integer> yupanhandcard, int beforeIsDahu, List<Integer> allSeeCard ,List<Integer>chowGroup,List<Integer>pengGrop,List<Integer>gangGrop,List<Integer>changShachuguopai){
|
||
ITObject chiob = new TObject();
|
||
chiob.putBoolean("isTing",beforelisten);
|
||
chiob.putInt("isDaHu",beforeIsDahu);
|
||
List checkCards = new ArrayList();
|
||
checkCards.addAll(yupanhandcard);
|
||
System.out.println("checkCards"+checkCards);
|
||
//去掉三张牌是否还能听牌
|
||
List<Integer> npeng = new ArrayList<>();
|
||
|
||
for (int i=0;i<opcard.size();i++){
|
||
Util.removeCard(checkCards,opcard.getInt(i),2);
|
||
}
|
||
npeng.add(card);
|
||
npeng.add(card);
|
||
npeng.add(card);
|
||
npeng.addAll(pengGrop);
|
||
|
||
// 操作之前和操作后有没有从有对将
|
||
int beforedj = checkduijiang(yupanhandcard);
|
||
System.out.println("beforedj:"+beforedj);
|
||
if (beforedj>=1){
|
||
int afterdj = checkduijiang(checkCards);
|
||
System.out.println(checkCards);
|
||
if (afterdj==0){
|
||
chiob.putBoolean("xiaoJiang",true);
|
||
}else{
|
||
chiob.putBoolean("xiaoJiang",false);
|
||
}
|
||
}else{
|
||
chiob.putBoolean("xiaoJiang",false);
|
||
}
|
||
|
||
//循环去三张还能听牌
|
||
|
||
Map<Integer,List<Integer>> afterdaHuOp = quyizhangDahuTingPai(checkCards,chowGroup,npeng,gangGrop);
|
||
if (afterdaHuOp.size()>0){
|
||
chiob.putBoolean("canTing", true);
|
||
chiob.putBoolean("sanTing", false);
|
||
}else {
|
||
|
||
Map<Integer, List<Integer>> afterOp = quyizhangTingPai(checkCards);
|
||
|
||
if (afterOp.size() == 0 && beforelisten) {
|
||
chiob.putBoolean("sanTing", true);
|
||
chiob.putBoolean("canTing", false);
|
||
}
|
||
if (afterOp.size() > 0) {
|
||
chiob.putBoolean("canTing", true);
|
||
chiob.putBoolean("sanTing", false);
|
||
} else {
|
||
chiob.putBoolean("canTing", false);
|
||
chiob.putBoolean("sanTing", false);
|
||
}
|
||
}
|
||
|
||
//循环之后还能是大胡吗？1,清一色，2，7小对，3，碰碰胡，4，将将胡，5，门清
|
||
if(beforeIsDahu>0){
|
||
if (beforeIsDahu==2){
|
||
chiob.putBoolean("xiaoDahu",true);
|
||
chiob.putInt("teshu",0);
|
||
}
|
||
if (beforeIsDahu==3){
|
||
//碰碰胡
|
||
chiob.putBoolean("xiaoDahu",false);
|
||
chiob.putInt("teshu",10);
|
||
}else if (beforeIsDahu==4){
|
||
//判断被碰的牌是否将
|
||
if(!isJiangPai(card)){
|
||
chiob.putBoolean("xiaoDahu",true);
|
||
}else{
|
||
chiob.putBoolean("xiaoDahu",false);
|
||
chiob.putInt("teshu",10);
|
||
}
|
||
}else if(beforeIsDahu==5){
|
||
//门清
|
||
chiob.putBoolean("xiaoDahu",true);
|
||
chiob.putInt("teshu",0);
|
||
}else{
|
||
//毁掉清一色
|
||
List<Integer> tmpchi = new ArrayList<>();
|
||
List<Integer> chi = new ArrayList<>(); //新new 吃的牌 todo
|
||
tmpchi.addAll(chowGroup);
|
||
chi.addAll(chowGroup);
|
||
List<Integer>pongGroup = new ArrayList<>();
|
||
List<Integer> gangdepai = new ArrayList<>();
|
||
gangdepai.addAll(gangGrop);
|
||
pongGroup.add(card);
|
||
for (int i=0;i<opcard.size();i++){
|
||
chi.add(opcard.getInt(i));
|
||
}
|
||
int afterdh = checkDahu(checkCards,chi,pongGroup,gangdepai);
|
||
if (afterdh!=1){
|
||
chiob.putBoolean("xiaoDahu",true);
|
||
chiob.putInt("teshu",0);
|
||
}else{
|
||
chiob.putBoolean("xiaoDahu",false);
|
||
chiob.putInt("teshu",0);
|
||
}
|
||
}
|
||
}else{
|
||
chiob.putBoolean("xiaoDahu",false);
|
||
chiob.putInt("teshu",0);
|
||
}
|
||
|
||
//操作之前的孤章差手情况
|
||
Map<String, Object> map = new HashMap<>();
|
||
List<Integer> tmpChangSch = new ArrayList<>();
|
||
tmpChangSch.addAll(yupanhandcard);
|
||
ChangshaWinSplitCard.checkNormalHu(tmpChangSch, map);
|
||
System.out.println("map:"+map);
|
||
|
||
//操作后，去一张牌，分析求最优
|
||
Map<String, Object> map2 = new HashMap<>();
|
||
System.out.println(checkCards);
|
||
Map<Integer,List<Integer>> xiatingList = new HashMap<>();
|
||
List<Integer> peng = new ArrayList<>(); //新new
|
||
peng.add(card);
|
||
peng.add(card);
|
||
peng.add(card);
|
||
map2 = quyizhangChayou(checkCards,chowGroup,peng,gangGrop,xiatingList);
|
||
Util.removeCard(peng,card,3);
|
||
|
||
peng.add(card);
|
||
peng.add(card);
|
||
System.out.println("map2:"+map2);
|
||
System.out.println("xiatingList:"+xiatingList);
|
||
//比对
|
||
if (map2.size()>0){
|
||
//可以下听
|
||
chiob.putInt("guzhang",((List<Integer>)map.get("cardResiue")).size()-((List<Integer>)map2.get("cardResiue")).size());
|
||
chiob.putInt("lastHands",Integer.parseInt(map.get("remainingMelds").toString())-Integer.parseInt(map.get("remainingMelds").toString()));
|
||
}else{
|
||
chiob.putInt("guzhang",((List<Integer>)map.get("cardResiue")).size());
|
||
chiob.putInt("lastHands",Integer.parseInt(map.get("remainingMelds").toString()));
|
||
}
|
||
|
||
|
||
//听多张问题：
|
||
List<Integer> caozuoqian = handscardshifoutingpai(yupanhandcard,chowGroup,pengGrop,gangGrop);
|
||
int caozuoqiannum = 0;//操作之前听牌张数
|
||
List<Integer> allpai = new ArrayList<>();
|
||
allpai.addAll(yupanhandcard);
|
||
allpai.addAll(changShachuguopai);
|
||
if (caozuoqian.size()>0){
|
||
caozuoqiannum = getTingPainum(caozuoqian,allpai);
|
||
}
|
||
int caozuohounum = 0;
|
||
if (xiatingList.size()>0){
|
||
//获取能听牌数最多的
|
||
for (Map.Entry<Integer, List<Integer>> entry : xiatingList.entrySet()) {
|
||
if (caozuohounum==0){
|
||
caozuohounum = getTingPainum(entry.getValue(),allpai);
|
||
}
|
||
if (caozuohounum < getTingPainum(entry.getValue(),allpai)){
|
||
caozuohounum = getTingPainum(entry.getValue(),allpai);
|
||
}
|
||
}
|
||
}
|
||
|
||
chiob.putInt("tingNum",caozuohounum - caozuoqiannum);
|
||
//先评分
|
||
int tmp = 0;
|
||
/*if (entry.getValue().getBoolean("isTing")){
|
||
tmp= tmp+30;
|
||
}*/
|
||
if (chiob.getBoolean("xiaoDahu")){
|
||
tmp= tmp-20;
|
||
}
|
||
/* if (entry.getValue().getInt("isDaHu")>0){
|
||
tmp= tmp-10;
|
||
}*/
|
||
if (chiob.getBoolean("xiaoJiang")){
|
||
tmp= tmp-13;
|
||
}
|
||
if (chiob.getInt("tingNum")>0){
|
||
tmp= tmp+chiob.getInt("tingNum")*4;
|
||
}
|
||
|
||
if (chiob.getBoolean("sanTing")){
|
||
tmp= tmp-50;
|
||
}
|
||
|
||
if (chiob.getBoolean("canTing")&&!chiob.getBoolean("isTing")){
|
||
//从不能听牌到听牌，
|
||
tmp= tmp+25;
|
||
}
|
||
if (chiob.getInt("teshu")>0){
|
||
tmp= tmp+chiob.getInt("teshu")*1;
|
||
}
|
||
if (chiob.getInt("lastHands")>0){
|
||
tmp= tmp+chiob.getInt("lastHands")*5;
|
||
}
|
||
if (chiob.getInt("guzhang")>0){
|
||
tmp= tmp+chiob.getInt("guzhang")*2;
|
||
}
|
||
//如果评分大于0，且小于5
|
||
if (tmp>0&&tmp<=5){
|
||
//去掉将时候
|
||
//判断是否有对将
|
||
if(card%100==9||card%100==1){
|
||
chiob.putInt("teshu",5);
|
||
}
|
||
}
|
||
//检测是否有4对
|
||
int duizi = countPairs(yupanhandcard);
|
||
System.out.println("duizi:"+duizi);
|
||
System.out.println(pengGrop);
|
||
|
||
if (duizi==4&&pengGrop.size()>=0){
|
||
chiob.putInt("teshu",5);
|
||
}
|
||
if (duizi==3&&pengGrop.size()>=2){
|
||
chiob.putInt("teshu",8);
|
||
}
|
||
System.out.println(pengGrop.size());
|
||
if (duizi>=2&&pengGrop.size()>=6){
|
||
chiob.putInt("teshu",12);
|
||
}
|
||
|
||
|
||
System.out.println("peng:"+chiob);
|
||
return chiob;
|
||
}
|
||
|
||
/**
|
||
*
|
||
* @param beforelisten
|
||
* @param card
|
||
* @param opcard
|
||
* @param yupanhandcard
|
||
* @param beforeIsDahu
|
||
* @param allSeeCard
|
||
* @return
|
||
* boolean isTing 是否听牌
|
||
* boolean canTing 能否听牌
|
||
* boolean sanTing 是否散听
|
||
* int tingNum 听多少张
|
||
* int isDaHu 是否大胡
|
||
* boolean xiaoDahu 是否消掉大胡
|
||
*
|
||
* int guzhang 有多少孤章 相差
|
||
* int lastHands 差多少手 相差
|
||
* boolean xiaoJiang 是否把将去没了
|
||
*
|
||
* int id tiplist id
|
||
* List<Integer> opcard
|
||
* int weight tiplist weight
|
||
* int card tiplist card
|
||
* int type tiplist type
|
||
*/
|
||
public static ITObject pingguChi(boolean beforelisten, int card, ITArray opcard, List<Integer> yupanhandcard, int beforeIsDahu, List<Integer> allSeeCard ,List<Integer>chowGroup,List<Integer>pengGrop,List<Integer>gangGrop,List<Integer>changShachuguopai){
|
||
ITObject chiob = new TObject();
|
||
chiob.putBoolean("isTing",beforelisten);
|
||
chiob.putInt("isDaHu",beforeIsDahu);
|
||
chiob.putInt("teshu",0);
|
||
List checkCards = new ArrayList();
|
||
checkCards.addAll(yupanhandcard);
|
||
System.out.println("运行之前："+checkCards);
|
||
//去掉三张牌是否还能听牌
|
||
List<Integer> nchi = new ArrayList();
|
||
|
||
for (int i=0;i<opcard.size();i++){
|
||
Util.removeCard(checkCards,opcard.getInt(i),1);
|
||
nchi.add(opcard.getInt(i));
|
||
}
|
||
nchi.add(card);
|
||
nchi.addAll(chowGroup);
|
||
// 操作之前和操作后有没有从有对将
|
||
int beforedj = checkduijiang(yupanhandcard);
|
||
if (beforedj>=1){
|
||
int afterdj = checkduijiang(checkCards);
|
||
if (afterdj==0){
|
||
chiob.putBoolean("xiaoJiang",true);
|
||
}else{
|
||
chiob.putBoolean("xiaoJiang",false);
|
||
}
|
||
}else{
|
||
chiob.putBoolean("xiaoJiang",false);
|
||
}
|
||
|
||
|
||
Map<Integer,List<Integer>> afterdaHuOp = quyizhangDahuTingPai(checkCards,nchi,pengGrop,gangGrop);
|
||
if (afterdaHuOp.size()>0){
|
||
|
||
chiob.putBoolean("canTing",true);
|
||
chiob.putBoolean("sanTing",false);
|
||
}else {
|
||
//循环去一张还能听牌
|
||
Map<Integer, List<Integer>> afterOp = quyizhangTingPai(checkCards);
|
||
|
||
if (afterOp.size() == 0 && beforelisten) {
|
||
chiob.putBoolean("sanTing", true);
|
||
chiob.putBoolean("canTing", false);
|
||
}
|
||
if (afterOp.size() > 0) {
|
||
chiob.putBoolean("canTing", true);
|
||
chiob.putBoolean("sanTing", false);
|
||
} else {
|
||
chiob.putBoolean("canTing", false);
|
||
chiob.putBoolean("sanTing", false);
|
||
}
|
||
}
|
||
|
||
//循环之后还能是大胡吗？1,清一色，2，7小对，3，碰碰胡，4，将将胡，5，门清
|
||
if(beforeIsDahu>0){
|
||
if (beforeIsDahu>1){
|
||
chiob.putBoolean("xiaoDahu",true);
|
||
}else{
|
||
//毁掉清一色
|
||
List<Integer> tmpchi = new ArrayList<>();
|
||
tmpchi.addAll(chowGroup);
|
||
List<Integer>pongGroup = new ArrayList<>();
|
||
List<Integer> gangdepai = new ArrayList<>();
|
||
List<Integer> chi = new ArrayList<>(); // 新new
|
||
|
||
chi.add(card);
|
||
chi.addAll(chowGroup);
|
||
for (int i=0;i<opcard.size();i++){
|
||
chi.add(opcard.getInt(i));
|
||
}
|
||
int afterdh = checkDahu(checkCards,chi,pongGroup,gangdepai);
|
||
if (afterdh!=1){
|
||
chiob.putBoolean("xiaoDahu",true);
|
||
}else{
|
||
chiob.putBoolean("xiaoDahu",false);
|
||
}
|
||
}
|
||
}else{
|
||
chiob.putBoolean("xiaoDahu",false);
|
||
}
|
||
//操作之前的孤章差手情况
|
||
Map<String, Object> map = new HashMap<>();
|
||
|
||
List<Integer> tmpChangSch = new ArrayList<>();
|
||
tmpChangSch.addAll(yupanhandcard);
|
||
ChangshaWinSplitCard.checkNormalHu(tmpChangSch, map);
|
||
System.out.println("map:"+map);
|
||
|
||
//操作后，去一张牌，分析求最优
|
||
Map<String, Object> map2 = new HashMap<>();
|
||
System.out.println(checkCards);
|
||
Map<Integer,List<Integer>> xiatingList = new HashMap<>();
|
||
List<Integer> chi = new ArrayList<>(); //新new
|
||
chi.addAll(chowGroup);
|
||
chi.add(card);
|
||
for (int i=0;i<opcard.size();i++){
|
||
chi.add(opcard.getInt(i));
|
||
}
|
||
map2 = quyizhangChayou(checkCards,chi,pengGrop,gangGrop,xiatingList);
|
||
Util.removeCard(chi,card,1);
|
||
for (int i=0;i<opcard.size();i++){
|
||
Util.removeCard(chi,opcard.getInt(i),1);
|
||
}
|
||
|
||
|
||
System.out.println("map2:"+map2);
|
||
System.out.println("xiatingList:"+xiatingList);
|
||
//比对
|
||
if (map2.size()>0){
|
||
//可以下听
|
||
chiob.putInt("guzhang",((List<Integer>)map.get("cardResiue")).size()-((List<Integer>)map2.get("cardResiue")).size());
|
||
chiob.putInt("lastHands",Integer.parseInt(map.get("remainingMelds").toString())-Integer.parseInt(map2.get("remainingMelds").toString()));
|
||
}else{
|
||
chiob.putInt("guzhang",((List<Integer>)map.get("cardResiue")).size());
|
||
chiob.putInt("lastHands",Integer.parseInt(map.get("remainingMelds").toString()));
|
||
}
|
||
|
||
//听多张问题：
|
||
List<Integer> caozuoqian = handscardshifoutingpai(yupanhandcard,chowGroup,pengGrop,gangGrop);
|
||
|
||
int caozuoqiannum = 0;//操作之前听牌张数
|
||
List<Integer> allpai = new ArrayList<>();
|
||
allpai.addAll(yupanhandcard);
|
||
allpai.addAll(changShachuguopai);
|
||
if (caozuoqian.size()>0){
|
||
caozuoqiannum = getTingPainum(caozuoqian,allpai);
|
||
}
|
||
int caozuohounum = 0;
|
||
if (xiatingList.size()>0){
|
||
//获取能听牌数最多的
|
||
for (Map.Entry<Integer, List<Integer>> entry : xiatingList.entrySet()) {
|
||
if (caozuohounum==0){
|
||
caozuohounum = getTingPainum(entry.getValue(),allpai);
|
||
}
|
||
if (caozuohounum < getTingPainum(entry.getValue(),allpai)){
|
||
caozuohounum = getTingPainum(entry.getValue(),allpai);
|
||
}
|
||
}
|
||
}
|
||
chiob.putInt("tingNum",caozuohounum - caozuoqiannum);
|
||
|
||
System.out.println("chiob:"+chiob);
|
||
return chiob;
|
||
}
|
||
|
||
public static boolean shiFouJieTing(List<Integer> tingList,List<Integer> changShachuguopai ){
|
||
|
||
|
||
return false;
|
||
}
|
||
|
||
public static int getTingPainum(List<Integer> caozq, List<Integer> changShachuguopai){
|
||
int num = 0;
|
||
for (int i=0;i<caozq.size();i++){
|
||
int js = 4;
|
||
for (int j=0;j<changShachuguopai.size();j++){
|
||
if ((int)caozq.get(i) == (int)changShachuguopai.get(j)){
|
||
js = js-1;
|
||
}
|
||
}
|
||
num = js+num;
|
||
}
|
||
return num;
|
||
}
|
||
|
||
|
||
|
||
/**
|
||
* 判断手牌是否能听牌
|
||
* @param cardhand
|
||
* @return
|
||
*/
|
||
public static List<Integer> handscardshifoutingpai(List<Integer> cardhand,List<Integer>chowGroup,List<Integer> pongGroup,List<Integer> gangdepai) {
|
||
List<Integer> tpcards = new ArrayList<>();
|
||
List<Integer> tmphc = new ArrayList<>();
|
||
tmphc.addAll(cardhand);
|
||
for (int j = 101; j <= 109; j++) {
|
||
WinCard win = new WinCard(tmphc, j);
|
||
if (win.tryWin()) {
|
||
if (!tpcards.contains(j)) {
|
||
tpcards.add(j);
|
||
}
|
||
}
|
||
|
||
Paixing px = new Paixing();
|
||
List<Integer> pxc = new ArrayList<>();
|
||
pxc.addAll(tmphc);
|
||
//pxc.add(j);
|
||
if(px.tingCheck(pxc,chowGroup,pongGroup,gangdepai)){
|
||
if (!tpcards.contains(j)) {
|
||
tpcards.add(j);
|
||
}
|
||
}
|
||
}
|
||
for (int k = 201; k<= 209; k++) {
|
||
WinCard win = new WinCard(tmphc, k);
|
||
|
||
if (win.tryWin()) {
|
||
if (!tpcards.contains(k)) {
|
||
tpcards.add(k);
|
||
}
|
||
}
|
||
|
||
Paixing px = new Paixing();
|
||
List<Integer> pxc2 = new ArrayList<>();
|
||
pxc2.addAll(tmphc);
|
||
// pxc2.add(k);
|
||
if(px.tingCheck(pxc2,chowGroup,pongGroup,gangdepai)){
|
||
if (!tpcards.contains(k)) {
|
||
tpcards.add(k);
|
||
}
|
||
}
|
||
}
|
||
//如果没有则检测大胡
|
||
return tpcards;
|
||
}
|
||
|
||
public static Map<Integer,List<Integer>> quyizhangDahuTingPai(List<Integer> cardhand,List<Integer> chowGroup,List<Integer> pongGroup,List<Integer> gangdepai){
|
||
Map<Integer,List<Integer>> map = new HashMap<>();
|
||
List<Integer> tmphc = new ArrayList<>();
|
||
tmphc.addAll(cardhand);
|
||
// List<Integer> tmphc = cardhand; //问题111
|
||
|
||
|
||
for (int i = 0; i < cardhand.size(); i++) {
|
||
int tmpcard = tmphc.get(0);
|
||
tmphc.remove(0);
|
||
List<Integer> huziting = new ArrayList<>();
|
||
for (int j = 101; j <= 109; j++) {
|
||
Paixing px = new Paixing();
|
||
List<Integer> pxc = new ArrayList<>();
|
||
pxc.add(j);
|
||
pxc.addAll(tmphc);
|
||
if(px.tingCheck(pxc,chowGroup,pongGroup,gangdepai)){
|
||
if (!huziting.contains(j)) {
|
||
huziting.add(j);
|
||
}
|
||
}
|
||
}
|
||
for (int k = 201; k <= 209; k++) {
|
||
Paixing px2 = new Paixing();
|
||
List<Integer> pxc2 = new ArrayList<>();
|
||
pxc2.add(k);
|
||
pxc2.addAll(tmphc);
|
||
if(px2.tingCheck(pxc2,chowGroup,pongGroup,gangdepai)){
|
||
if (!huziting.contains(k)) {
|
||
huziting.add(k);
|
||
}
|
||
}
|
||
}
|
||
if (huziting.size()>0){
|
||
map.put(tmpcard,huziting);
|
||
}
|
||
tmphc.add(tmpcard);
|
||
|
||
}
|
||
return map;
|
||
}
|
||
|
||
public static Map<Integer, List<Integer>> quyizhangTingPai(List<Integer> cardhand) {
|
||
Map<Integer, List<Integer>> quxiatingmap = new HashMap<>();
|
||
List<Integer> tmphc = new ArrayList<>();
|
||
tmphc.addAll(cardhand);
|
||
// List<Integer> tmphc = cardhand; //问题111
|
||
|
||
for (int i = 0; i < cardhand.size(); i++) {
|
||
int tmpcard = tmphc.get(0);
|
||
tmphc.remove(0);
|
||
List<Integer> huziting = new ArrayList<>();
|
||
for (int j = 101; j <= 109; j++) {
|
||
WinCard win = new WinCard(tmphc, j);
|
||
if (win.tryWin()) {
|
||
if (!huziting.contains(j)) {
|
||
huziting.add(j);
|
||
}
|
||
}
|
||
}
|
||
for (int k = 201; k <= 209; k++) {
|
||
WinCard win = new WinCard(tmphc, k);
|
||
if (win.tryWin()) {
|
||
if (!huziting.contains(k)) {
|
||
huziting.add(k);
|
||
}
|
||
}
|
||
}
|
||
if (huziting.size()>0){
|
||
quxiatingmap.put(tmpcard,huziting);
|
||
}
|
||
tmphc.add(tmpcard);
|
||
|
||
}
|
||
return quxiatingmap;
|
||
}
|
||
|
||
public static Map<String, Object> quyizhangChayou(List<Integer> cardhand,List<Integer>chowGroup,List<Integer> pongGroup,List<Integer> gangdepai,Map<Integer,List<Integer>> xiatingList) {
|
||
Map<String, Object> map = new HashMap<>();
|
||
Map<Integer,Map<String, Object>> bigMap = new HashMap<>();
|
||
|
||
List<Integer> tmphc = new ArrayList<>();
|
||
tmphc.addAll(cardhand);
|
||
System.out.println("tmphc1:"+tmphc);
|
||
for (int i = 0; i < cardhand.size(); i++) {
|
||
int tmpcard = tmphc.get(0);
|
||
tmphc.remove(0);
|
||
|
||
Map<String, Object> tmap = new HashMap<>();
|
||
int res = ChangshaWinSplitCard.checkNormalHu(tmphc,tmap);
|
||
bigMap.put(tmpcard,tmap);
|
||
|
||
//检查是否能下听
|
||
List<Integer> tmxt = new ArrayList<>();
|
||
tmxt = handscardshifoutingpai(tmphc,chowGroup,pongGroup,gangdepai);
|
||
if (tmxt.size()>0){
|
||
xiatingList.put(tmpcard,tmxt);
|
||
}
|
||
|
||
tmphc.add(tmpcard);
|
||
}
|
||
System.out.println(bigMap);
|
||
System.out.println("吃之后");
|
||
//遍历找最优解
|
||
if (bigMap.size()==0){
|
||
return map;
|
||
}
|
||
|
||
Map<String, Object> bestmap = gaiBestCardInMap(bigMap);
|
||
|
||
return bestmap;
|
||
}
|
||
private static Map<String, Object> gaiBestCardInMap(Map<Integer,Map<String, Object>> map){
|
||
Map<String, Object> tmpmap = new HashMap<>();
|
||
int bestcard = 0;
|
||
for (Map.Entry<Integer, Map<String, Object>> entry : map.entrySet()) {
|
||
if (tmpmap.isEmpty()){
|
||
tmpmap = entry.getValue();
|
||
bestcard = entry.getKey();
|
||
}else{
|
||
int tmpr = Integer.parseInt( tmpmap.get("remainingMelds").toString());
|
||
int entr = Integer.parseInt( entry.getValue().get("remainingMelds").toString());
|
||
if (tmpr>entr){
|
||
tmpmap = entry.getValue();
|
||
}else if (tmpr==entr){
|
||
List<Integer> tl = (List<Integer>)tmpmap.get("cardResiue");
|
||
List<Integer> enl = (List<Integer>)entry.getValue().get("cardResiue");
|
||
|
||
if (tl.size()>enl.size()){
|
||
tmpmap = entry.getValue();
|
||
}
|
||
if(tl.size()==enl.size()){
|
||
//寻找是否有边张
|
||
for (int i=0;i<tl.size();i++){
|
||
if (tl.get(i)%100==9||tl.get(i)%100==1){
|
||
}else{
|
||
//不要取有边张
|
||
tmpmap = entry.getValue();
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
|
||
return tmpmap;
|
||
}
|
||
|
||
public static void main(String[] args) {
|
||
// 测试用例：没有258将牌的情况
|
||
List<Integer> test1 = new ArrayList<Integer>();
|
||
|
||
test1.add(205);
|
||
test1.add(204);
|
||
test1.add(204);
|
||
test1.add(203);
|
||
|
||
test1.add(202);
|
||
test1.add(201);
|
||
test1.add(108);
|
||
|
||
test1.add(107);
|
||
test1.add(103);
|
||
test1.add(103);
|
||
|
||
// test1.add(106);
|
||
//test1.add(104);
|
||
// test1.add(103);
|
||
|
||
int lg = countPairs(test1);
|
||
System.out.println(lg);
|
||
//int card = 206;
|
||
//int flag = checkChiTingAction(card,test1);
|
||
//System.out.println(flag);
|
||
|
||
//测试吃：
|
||
List<Integer> allcard = new ArrayList<>();
|
||
allcard.add(105);
|
||
allcard.add(101);
|
||
allcard.add(209);
|
||
allcard.add(209);
|
||
allcard.add(104);
|
||
allcard.add(104);
|
||
allcard.add(104);
|
||
//allcard.add(104);
|
||
/*ITArray opcard = TArray.newInstance();
|
||
opcard.addInt(209);
|
||
opcard.addInt(208);*/
|
||
|
||
List<Integer> chipai = new ArrayList<>();
|
||
chipai.add(207);
|
||
chipai.add(208);
|
||
chipai.add(209);
|
||
|
||
|
||
// chipai.add(101);
|
||
// chipai.add(102);
|
||
// chipai.add(103);
|
||
// int card = 202;
|
||
|
||
List<Integer>changShachuguopai = new ArrayList<>();
|
||
//changShachuguopai.add(101);
|
||
changShachuguopai.add(202);
|
||
changShachuguopai.add(201);
|
||
changShachuguopai.add(203);
|
||
changShachuguopai.add(105);
|
||
changShachuguopai.add(105);
|
||
changShachuguopai.add(105);
|
||
changShachuguopai.addAll(allcard);
|
||
|
||
List<Integer> gangguopai = new ArrayList<>();
|
||
|
||
// gangguopai.add(108);0
|
||
|
||
int card = 103;
|
||
List<Integer>pengCard = new ArrayList<>();
|
||
/*pengCard.add(203);
|
||
pengCard.add(203);
|
||
pengCard.add(203);
|
||
|
||
pengCard.add(101);
|
||
pengCard.add(101);
|
||
pengCard.add(101);*/
|
||
|
||
//出牌求优
|
||
ChangShaSuanFaTest ct = new ChangShaSuanFaTest();
|
||
test1.add(card);
|
||
String outcard = ct.outCardSuanFa(test1,pengCard,chipai,gangguopai,changShachuguopai);
|
||
|
||
System.out.println("outcard:"+outcard);
|
||
|
||
// pingguChi(false,card,opcard,test1,0,allcard,chipai,changShachuguopai);
|
||
|
||
//测试碰
|
||
// int card = 102;
|
||
ITArray opcardpeng = TArray.newInstance();
|
||
opcardpeng.addInt(203);
|
||
|
||
List<Integer> pengpai = new ArrayList<>();
|
||
List<Integer> gangpai = new ArrayList<>();
|
||
|
||
//pingguPeng(true,card,opcardpeng,test1,0,allcard,chipai,pengpai,gangpai,changShachuguopai);
|
||
/*
|
||
//List<Integer>tf = handscardshifoutingpai(test1);
|
||
// System.out.println(tf);
|
||
//Map<String, Object> map = new HashMap<>();
|
||
//map = quyizhangChayou(test1);
|
||
// System.out.println(map);
|
||
|
||
/*Map<Integer,List<Integer>> maps = new HashMap<>();
|
||
maps = quyizhangTingPai(test1);
|
||
System.out.println(maps);*/
|
||
// test1.add(202);
|
||
// test1.add(209);
|
||
// test1.add(201);
|
||
|
||
// test1.add(208);
|
||
// test1.add(207);
|
||
// test1.add(209);
|
||
|
||
// test1.add(104);
|
||
|
||
// test1.add(203);
|
||
// test1.add(202);
|
||
// test1.add(201);
|
||
// test1.add(103);
|
||
// test1.add(102);
|
||
|
||
/*
|
||
int card = 201;
|
||
List<Integer> pengguopai = new ArrayList<>();
|
||
pengguopai.add(204);
|
||
pengguopai.add(204);
|
||
pengguopai.add(204);
|
||
List<Integer> chipai = new ArrayList<>();
|
||
chipai.add(203);
|
||
chipai.add(202);
|
||
chipai.add(201);
|
||
List<Integer> gangguopai = new ArrayList<>();
|
||
gangguopai.add(206);
|
||
gangguopai.add(206);
|
||
gangguopai.add(206);
|
||
gangguopai.add(206);
|
||
|
||
System.out.println("手牌：" + test1);
|
||
boolean c = checkAllSameSuitAll(card,test1,pengguopai,chipai,gangguopai);
|
||
System.out.println(c);
|
||
*/
|
||
|
||
// if (!bestDiscard.isEmpty()) {
|
||
// System.out.println("建议出牌：" + bestDiscard.get(0));
|
||
// } else {
|
||
// System.out.println("没有出牌建议");
|
||
// }
|
||
}
|
||
}
|