上一章已经排除了飞机、三带等牌型，那么除去炸弹王炸以外，我们只剩下单牌、对牌、三牌以及单顺、双顺、三顺了。


首先说单牌、对牌、三牌。其逻辑基本一样，只是出牌的个数有差别，即：如果该i牌数量满足这种牌型要求，即先打出，计算其剩余价值。

​


  2. //出单牌
  3. if (clsHandCardData.value_aHandCardList[i] > 0)
  4. {
  5. clsHandCardData.value_aHandCardList[i]--;
  6. clsHandCardData.nHandCardCount--;
  7. HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
  8. clsHandCardData.value_aHandCardList[i]++;
  9. clsHandCardData.nHandCardCount++;
  10. if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
  11. {
  12. BestHandCardValue = tmpHandCardValue;
  13. BestCardGroup= get_GroupData(cgSINGLE, i, 1);
  14. }
  15. }
  16. //出对牌
  17. if (clsHandCardData.value_aHandCardList[i] > 1)
  18. {
  19. //尝试打出一对牌，估算剩余手牌价值
  20. clsHandCardData.value_aHandCardList[i] -= 2;
  21. clsHandCardData.nHandCardCount -= 2;
  22. HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
  23. clsHandCardData.value_aHandCardList[i] += 2;
  24. clsHandCardData.nHandCardCount += 2;

  26. //选取总权值-轮次*7值最高的策略 因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
  27. if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
  28. {
  29. BestHandCardValue = tmpHandCardValue;
  30. BestCardGroup = get_GroupData(cgDOUBLE, i, 2);
  31. }
  32. }
  33. //出三牌
  34. if (clsHandCardData.value_aHandCardList[i] > 2)
  35. {
  36. clsHandCardData.value_aHandCardList[i] -= 3;
  37. clsHandCardData.nHandCardCount -= 3;
  38. HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
  39. clsHandCardData.value_aHandCardList[i] += 3;
  40. clsHandCardData.nHandCardCount += 3;

  42. //选取总权值-轮次*7值最高的策略 因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
  43. if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
  44. {
  45. BestHandCardValue = tmpHandCardValue;
  46. BestCardGroup = get_GroupData(cgTHREE, i, 3);
  47. }
  48. }


至于顺子的算法，和被动出牌的有一点点差别，就是因为没有了数量限制，所以需要遍历以i牌为起点可以组成的所有顺子。



  1. //出单顺
  2. if (clsHandCardData.value_aHandCardList[i] > 0)
  3. {
  4. int prov = 0;
  5. for (int j = i; j < 15; j++)
  6. {
  7. if(clsHandCardData.value_aHandCardList[j]>0)
  8. {
  9. prov++;
  10. }
  11. else
  12. {
  13. break;
  14. }
  15. if (prov >= 5)
  16. {

  18. for (int k = i; k <= j; k++)
  19. {
  20. clsHandCardData.value_aHandCardList[k] --;
  21. }
  22. clsHandCardData.nHandCardCount -= prov;
  23. HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
  24. for (int k = i; k <= j; k++)
  25. {
  26. clsHandCardData.value_aHandCardList[k] ++;
  27. }
  28. clsHandCardData.nHandCardCount += prov;

  30. //选取总权值-轮次*7值最高的策略 因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
  31. if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
  32. {
  33. BestHandCardValue = tmpHandCardValue;
  34. BestCardGroup = get_GroupData(cgSINGLE_LINE, j, prov);
  35. }
  36. }
  37. }

  39. }
  40. //出双顺
  41. if (clsHandCardData.value_aHandCardList[i] > 1)
  42. {
  43. int prov = 0;
  44. for (int j = i; j < 15; j++)
    45. 斗地主AI算法——第十四章の主动出牌(3)
  45. {
  46. if (clsHandCardData.value_aHandCardList[j]>1)
  47. {
  48. prov++;
  49. }
  50. else
  51. {
  52. break;
  53. }
  54. if (prov >= 3)
  55. {

  57. for (int k = i; k <= j; k++)
  58. {
  59. clsHandCardData.value_aHandCardList[k] -=2;
  60. }
  61. clsHandCardData.nHandCardCount -= prov*2;
  62. HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
  63. for (int k = i; k <= j; k++)
  64. {
  65. clsHandCardData.value_aHandCardList[k] +=2;
  66. }
  67. clsHandCardData.nHandCardCount += prov*2;

  69. //选取总权值-轮次*7值最高的策略 因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
  70. if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
  71. {
  72. BestHandCardValue = tmpHandCardValue;
  73. BestCardGroup = get_GroupData(cgDOUBLE_LINE, j, prov*2);
  74. }
  75. }
  76. }
  77. }
  78. //出三顺
  79. if(clsHandCardData.value_aHandCardList[i] > 2)
  80. {
  81. int prov = 0;
  82. for (int j = i; j < 15; j++)
  83. {
  84. if (clsHandCardData.value_aHandCardList[j]>2)
  85. {
  86. prov++;
  87. }
  88. else
  89. {
  90. break;
  91. }
  92. if (prov >= 2)
  93. {

  95. for (int k = i; k <= j; k++)
  96. {
  97. clsHandCardData.value_aHandCardList[k] -= 3;
  98. }
  99. clsHandCardData.nHandCardCount -= prov * 3;
  100. HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
  101. for (int k = i; k <= j; k++)
  102. {
  103. clsHandCardData.value_aHandCardList[k] += 3;
  104. }
  105. clsHandCardData.nHandCardCount += prov * 3;

  107. //选取总权值-轮次*7值最高的策略 因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
  108. if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
  109. {
  110. BestHandCardValue = tmpHandCardValue;
  111. BestCardGroup = get_GroupData(cgTHREE_LINE, j, prov * 3);
  112. }
  113. }
  114. }
  115. }



因为本策略是必须解决掉至少一个i牌的，所以出牌操作放在循环内进行，也就是说，只要你不是炸3，若你手牌有3，在处理3时一定会return  就绝对不会再走到4。


​


  2. if (BestCardGroup.cgType == cgERROR)
  3. {

  5. }
  6. else if (BestCardGroup.cgType == cgSINGLE)
  7. {
  8. clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
  9. clsHandCardData.uctPutCardType = BestCardGroup;
  10. }
  11. else if (BestCardGroup.cgType == cgDOUBLE)
  12. {
  13. clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
  14. clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
  15. clsHandCardData.uctPutCardType = BestCardGroup;
  16. }
  17. else if (BestCardGroup.cgType == cgTHREE)
  18. {
  19. clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
  20. clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
  21. clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
  22. clsHandCardData.uctPutCardType = BestCardGroup;
  23. }
  24. else if (BestCardGroup.cgType == cgSINGLE_LINE)
  25. {
  26. for (int j = BestCardGroup.nMaxCard- BestCardGroup.nCount+1; j <= BestCardGroup.nMaxCard; j++)
  27. {
  28. clsHandCardData.value_nPutCardList.push_back(j);
  29. }
  30. clsHandCardData.uctPutCardType = BestCardGroup;
  31. }
  32. else if (BestCardGroup.cgType == cgDOUBLE_LINE)
  33. {
  34. for (int j = BestCardGroup.nMaxCard - (BestCardGroup.nCount/2) + 1; j <= BestCardGroup.nMaxCard; j++)
  35. {
  36. clsHandCardData.value_nPutCardList.push_back(j);
  37. clsHandCardData.value_nPutCardList.push_back(j);
  38. }
  39. clsHandCardData.uctPutCardType = BestCardGroup;
  40. }
  41. else if (BestCardGroup.cgType == cgTHREE_LINE)
  42. {
  43. for (int j = BestCardGroup.nMaxCard - (BestCardGroup.nCount / 3) + 1; j <= BestCardGroup.nMaxCard; j++)
  44. {
  45. clsHandCardData.value_nPutCardList.push_back(j);
  46. clsHandCardData.value_nPutCardList.push_back(j);
  47. clsHandCardData.value_nPutCardList.push_back(j);
  48. }
  49. clsHandCardData.uctPutCardType = BestCardGroup;
  50. }
  51. else if (BestCardGroup.cgType == cgTHREE_TAKE_ONE)
  52. {
  53. clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
  54. clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
  55. clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
  56. clsHandCardData.value_nPutCardList.push_back(tmp_1);
  57. clsHandCardData.uctPutCardType = BestCardGroup;
  58. }
  59. else if (BestCardGroup.cgType == cgTHREE_TAKE_TWO)
  60. {
  61. clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
  62. clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
  63. clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
  64. clsHandCardData.value_nPutCardList.push_back(tmp_1);
  65. clsHandCardData.value_nPutCardList.push_back(tmp_1);
  66. clsHandCardData.uctPutCardType = BestCardGroup;
  67. }
  68. else if (BestCardGroup.cgType == cgTHREE_TAKE_ONE_LINE)
  69. {
  70. for (int j = BestCardGroup.nMaxCard - (BestCardGroup.nCount / 4) + 1; j <= BestCardGroup.nMaxCard; j++)
  71. {
  72. clsHandCardData.value_nPutCardList.push_back(j);
  73. clsHandCardData.value_nPutCardList.push_back(j);
  74. clsHandCardData.value_nPutCardList.push_back(j);
  75. }

  77. if (BestCardGroup.nCount / 4 == 2)
  78. {
  79. clsHandCardData.value_nPutCardList.push_back(tmp_1);
  80. clsHandCardData.value_nPutCardList.push_back(tmp_2);
  81. }
  82. if (BestCardGroup.nCount / 4 == 3)
  83. {
  84. clsHandCardData.value_nPutCardList.push_back(tmp_1);
  85. clsHandCardData.value_nPutCardList.push_back(tmp_2);
  86. clsHandCardData.value_nPutCardList.push_back(tmp_3);
  87. }
  88. if (BestCardGroup.nCount / 4 == 4)
  89. {
  90. clsHandCardData.value_nPutCardList.push_back(tmp_1);
  91. clsHandCardData.value_nPutCardList.push_back(tmp_2);
  92. clsHandCardData.value_nPutCardList.push_back(tmp_3);
  93. clsHandCardData.value_nPutCardList.push_back(tmp_4);
  94. }

  96. clsHandCardData.uctPutCardType = BestCardGroup;
  97. }
  98. else if (BestCardGroup.cgType == cgTHREE_TAKE_TWO_LINE)
  99. {
  100. for (int j = BestCardGroup.nMaxCard - (BestCardGroup.nCount / 5) + 1; j <= BestCardGroup.nMaxCard; j++)
  101. {
  102. clsHandCardData.value_nPutCardList.push_back(j);
  103. clsHandCardData.value_nPutCardList.push_back(j);
  104. clsHandCardData.value_nPutCardList.push_back(j);
  105. }
  106. if (BestCardGroup.nCount / 5 == 2)
  107. {
  108. clsHandCardData.value_nPutCardList.push_back(tmp_1);
  109. clsHandCardData.value_nPutCardList.push_back(tmp_1);
  110. clsHandCardData.value_nPutCardList.push_back(tmp_2);
  111. clsHandCardData.value_nPutCardList.push_back(tmp_2);
  112. }
  113. if (BestCardGroup.nCount / 5 == 3)
  114. {
  115. clsHandCardData.value_nPutCardList.push_back(tmp_1);
  116. clsHandCardData.value_nPutCardList.push_back(tmp_1);
  117. clsHandCardData.value_nPutCardList.push_back(tmp_2);
  118. clsHandCardData.value_nPutCardList.push_back(tmp_2);
  119. clsHandCardData.value_nPutCardList.push_back(tmp_3);
  120. clsHandCardData.value_nPutCardList.push_back(tmp_3);
  121. }
  122. clsHandCardData.uctPutCardType = BestCardGroup;
  123. }
  124. return;




至此，主动出牌的所有逻辑均已实现，同时整个斗地主算法也基本完成了。接下来我们便可写一些测试模块来进行整合联调。


敬请关注下一章：斗地主AI算法——第十五章の测试模块