修改已知问题

robots/puke/robot_pk_pdk/src/main/java/taurus/util/test_smart.java

@@ -594,10 +594,17 @@ public class test_smart {
     /** 通用决策 - 改进版：解决先打大牌问题 */
     private static ITArray makeUniversalDecision(List<CardObj> handCards, HandAnalysis analysis) {
         System.out.println("[通用策略] 基于手牌分析的智能选择");
-        System.out.println("[重要提醒] 当前采用渐进式出牌策略，优先出小牌，保留大牌");
+        System.out.println("[重要提醒] 优先考虑组合牌型，避免拆分有价值的牌组");
         
         List<CardObj> outCards;
         
+        // 首轮出牌优先级调整：组合牌型 > 连续结构 > 单牌
+        outCards = findBestComboMove(handCards, analysis);
+        if (!outCards.isEmpty()) {
+            System.out.println("[组合优先] 出组合牌型: " + outCards.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.toList()));
+            return CardUtil.toTArray(outCards);
+        }
+        
         // 根据平衡度和大牌比例决定策略
         if (analysis.bigCardRatio > 0.4) {
             // 大牌过多，优先出小牌
@@ -724,6 +731,86 @@ public class test_smart {
         return bestCombo;
     }
     
+    /** 首轮组合牌型优先决策 */
+    private static List<CardObj> findBestComboMove(List<CardObj> handCards, HandAnalysis analysis) {
+        System.out.println("[组合优先] 分析可出的组合牌型");
+        
+        List<CardObj> bestCombo = new ArrayList<>();
+        int bestScore = 0;
+        
+        // 按价值优先级评估组合牌型
+        
+        // 1. 飞机带牌（最高优先级）
+        List<CardObj> airplane = findSmallestAirplaneWithCards(handCards);
+        if (!airplane.isEmpty()) {
+            System.out.println("[组合优先] 发现飞机: " + airplane.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.joining("")));
+            return airplane;
+        }
+        
+        // 2. 炸弹
+        List<CardObj> bomb = findSmallestBomb(handCards);
+        if (!bomb.isEmpty()) {
+            System.out.println("[组合优先] 发现炸弹: " + bomb.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.joining("")));
+            return bomb;
+        }
+        
+        // 3. 四带二
+        List<CardObj> fourWithTwo = findSmallestFourWithTwo(handCards);
+        if (!fourWithTwo.isEmpty() && fourWithTwo.size() > bestScore) {
+            bestCombo = fourWithTwo;
+            bestScore = fourWithTwo.size();
+            System.out.println("[组合优先] 发现四带二: " + fourWithTwo.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.joining("")));
+        }
+        
+        // 4. 三带二
+        List<CardObj> trioWithTwo = findSmallestTrioWithTwo(handCards);
+        if (!trioWithTwo.isEmpty() && trioWithTwo.size() > bestScore) {
+            bestCombo = trioWithTwo;
+            bestScore = trioWithTwo.size();
+            System.out.println("[组合优先] 发现三带二: " + trioWithTwo.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.joining("")));
+        }
+        
+        // 5. 连对
+        List<CardObj> consecutivePair = findSmallestConsecutivePair(handCards);
+        if (!consecutivePair.isEmpty() && consecutivePair.size() > bestScore) {
+            bestCombo = consecutivePair;
+            bestScore = consecutivePair.size();
+            System.out.println("[组合优先] 发现连对: " + consecutivePair.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.joining("")));
+        }
+        
+        // 6. 顺子
+        List<CardObj> straight = findSmallestStraight(handCards);
+        if (!straight.isEmpty() && straight.size() > bestScore) {
+            bestCombo = straight;
+            bestScore = straight.size();
+            System.out.println("[组合优先] 发现顺子: " + straight.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.joining("")));
+        }
+        
+        // 7. 三张
+        List<CardObj> trio = findSmallestTrio(handCards);
+        if (!trio.isEmpty() && trio.size() > bestScore) {
+            bestCombo = trio;
+            bestScore = trio.size();
+            System.out.println("[组合优先] 发现三张: " + trio.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.joining("")));
+        }
+        
+        // 8. 对子
+        List<CardObj> pair = findSmallestPair(handCards);
+        if (!pair.isEmpty() && pair.size() > bestScore) {
+            bestCombo = pair;
+            bestScore = pair.size();
+            System.out.println("[组合优先] 发现对子: " + pair.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.joining("")));
+        }
+        
+        if (bestScore > 0) {
+            System.out.println("[组合优先] 选择最佳组合: " + bestCombo.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.joining("")));
+        } else {
+            System.out.println("[组合优先] 无合适组合牌型");
+        }
+        
+        return bestCombo;
+    }
+    
     /** 兜底决策 */
     private static ITArray fallbackDecision(List<CardObj> handCards) {
         System.out.println("[兜底策略] 无合适组合，智能选择最小损失");
@@ -1562,6 +1649,15 @@ public class test_smart {
         
         System.out.println("[连对响应] 寻找" + pairCount + "连对(共" + (pairCount*2) + "张牌)，最小起始牌:" + getCardName(minCard));
         
+        // 手牌分析
+        Map<Integer, List<CardObj>> groups = CardUtil.getCardListMap(handCards);
+        System.out.println("[连对响应] 手牌中的对子情况:");
+        groups.forEach((k, v) -> {
+            if (v.size() >= 2) {
+                System.out.println("  " + getCardName(k) + ": " + v.size() + "张");
+            }
+        });
+
         if (pairCount < MIN_CONSECUTIVE_PAIR_COUNT) {
             System.out.println("对手连对数" + pairCount + "<" + MIN_CONSECUTIVE_PAIR_COUNT + "，不符合规则，无法响应");
             return new ArrayList<>();
@@ -1570,6 +1666,10 @@ public class test_smart {
         List<List<CardObj>> allConsecutivePairs = findAllConsecutivePairs(handCards, pairCount);
         
         System.out.println("[连对响应] 找到" + allConsecutivePairs.size() + "个符合条件的连对");
+        for (int i = 0; i < allConsecutivePairs.size(); i++) {
+            List<CardObj> pair = allConsecutivePairs.get(i);
+            System.out.println("  连对" + (i+1) + ": " + pair.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.joining("")));
+        }
 
         List<List<CardObj>> validPairs = allConsecutivePairs.stream()
                 .filter(p -> p.get(0).cardMod > minCard)
@@ -1683,13 +1783,32 @@ public class test_smart {
     }
 
     private static List<CardObj> findBombResponse(List<CardObj> handCards, int minCard) {
+        System.out.println("[炸弹响应] 寻找大于" + getCardName(minCard) + "的炸弹");
+        
         Map<Integer, List<CardObj>> valueGroups = CardUtil.getCardListMap(handCards);
-        return valueGroups.entrySet().stream()
+        
+        // 调试信息
+        System.out.println("[炸弹响应] 手牌中的炸弹候选:");
+        valueGroups.forEach((k, v) -> {
+            if (v.size() >= 4) {
+                System.out.println("  " + getCardName(k) + ": " + v.size() + "张");
+            }
+        });
+        
+        List<CardObj> result = valueGroups.entrySet().stream()
                 .filter(e -> e.getKey() > minCard && e.getValue().size() >= 4)
                 .sorted(Map.Entry.comparingByKey())
                 .map(e -> e.getValue().subList(0, 4))
                 .findFirst()
                 .orElse(new ArrayList<>());
+                
+        if (!result.isEmpty()) {
+            System.out.println("[炸弹响应] 找到炸弹: " + result.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.joining("")));
+        } else {
+            System.out.println("[炸弹响应] 未找到可压制的炸弹");
+        }
+        
+        return result;
     }
 
     private static List<CardObj> findAirplaneWithCardsResponse(List<CardObj> handCards, int minCard, int len) {
@@ -1808,11 +1927,21 @@ public class test_smart {
     }
 
     private static List<CardObj> findSmallestConsecutivePair(List<CardObj> handCards) {
+        System.out.println("[最小连对] 寻找最小的连对");
         List<List<CardObj>> allPairs = findAllConsecutivePairs(handCards, MIN_CONSECUTIVE_PAIR_COUNT);
-        return allPairs.stream()
+        
+        if (allPairs.isEmpty()) {
+            System.out.println("[最小连对] 未找到连对");
+            return new ArrayList<>();
+        }
+        
+        List<CardObj> result = allPairs.stream()
                 .sorted(Comparator.comparingInt(p -> p.get(0).cardMod))
                 .findFirst()
                 .orElse(new ArrayList<>());
+                
+        System.out.println("[最小连对] 选择: " + result.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.joining("")));
+        return result;
     }
 
     private static List<List<CardObj>> findAllConsecutivePairs(List<CardObj> handCards, int pairCount) {
@@ -1826,6 +1955,9 @@ public class test_smart {
                 .sorted()
                 .collect(Collectors.toList());
         
+        System.out.println("[连对查找] 可用对子牌值: " + pairValues.stream().map(v -> getCardName(v)).collect(Collectors.joining(",")));
+        System.out.println("[连对查找] 寻找" + pairCount + "连对");
+
         for (int i = 0; i <= pairValues.size() - pairCount; i++) {
             boolean isConsecutive = true;
             List<Integer> currentSequence = new ArrayList<>();
@@ -1835,6 +1967,7 @@ public class test_smart {
                 if (j < pairCount - 1) {
                     if (pairValues.get(i + j + 1) - pairValues.get(i + j) != 1) {
                         isConsecutive = false;
+                        System.out.println("[连对查找] 序列中断: " + getCardName(pairValues.get(i + j)) + " -> " + getCardName(pairValues.get(i + j + 1)));
                         break;
                     }
                 }
@@ -1846,6 +1979,7 @@ public class test_smart {
                     pairs.addAll(groups.get(pairValues.get(i + j)).subList(0, 2));
                 }
                 consecutivePairs.add(pairs);
+                System.out.println("[连对查找] 找到连对: " + pairs.stream().map(c -> getCardName(c.cardMod)).collect(Collectors.joining("")));
             }
         }