斗地主AI算法——第十章の被动出牌(4)

上一章已经说明了单顺的实现方法，双顺、三不带顺牌型实现方法与单牌基本类似。改动的地方除了上一章说的枚举牌类型，出牌时value_nPutCardList的处理，回溯时value_aHandCardList和nHandCardCount的变化等几个方面，还有length设置的变化，因为双顺的length是count的1/2，三顺是1/3。

下面给出完整代码：

 

[cpp] view plain copy
 
  1. //对连类型  
  2.     else if (clsGameSituation.uctNowCardGroup.cgType == cgDOUBLE_LINE)  
  3.     {  
  4.         //剪枝：如果能出去最后一手牌直接出  
  5.         CardGroupData SurCardGroupData = ins_SurCardsType(clsHandCardData.value_aHandCardList);  
  6.         if (SurCardGroupData.cgType != cgERROR)  
  7.         {  
  8.             if (SurCardGroupData.cgType == cgDOUBLE_LINE&&SurCardGroupData.nMaxCard>clsGameSituation.uctNowCardGroup.nMaxCard  
  9.                 &&SurCardGroupData.nCount == clsGameSituation.uctNowCardGroup.nCount)  
  10.             {  
  11.                 Put_All_SurCards(clsGameSituation, clsHandCardData, SurCardGroupData);  
  12.                 return;  
  13.             }  
  14.             else if (SurCardGroupData.cgType == cgBOMB_CARD || SurCardGroupData.cgType == cgKING_CARD)  
  15.             {  
  16.                 Put_All_SurCards(clsGameSituation, clsHandCardData, SurCardGroupData);  
  17.                 return;  
  18.             }  
  19.         }  
  20.   
  21.   
  22.         //暂存最佳的价值  
  23.         HandCardValue BestHandCardValue = get_HandCardValue(clsHandCardData);  
  24.   
  25.   
  26.         //我们认为不出牌的话会让对手一个轮次，即加一轮（权值减少7）便于后续的对比参考。  
  27.         BestHandCardValue.NeedRound += 1;  
  28.   
  29.         //暂存最佳的牌号  
  30.         int BestMaxCard = 0;  
  31.         //是否出牌的标志  
  32.         bool PutCards = false;  
  33.         //验证顺子的标志  
  34.         int prov = 0;  
  35.         //顺子起点  
  36.         int start_i = 0;  
  37.         //顺子终点  
  38.         int end_i = 0;  
  39.         //顺子长度  
  40.         int length = clsGameSituation.uctNowCardGroup.nCount/2;  
  41.         //2与王不参与顺子，从当前已打出的顺子最小牌值+1开始遍历  
  42.         for (int i = clsGameSituation.uctNowCardGroup.nMaxCard - length + 2; i < 15; i++)  
  43.         {  
  44.             if (clsHandCardData.value_aHandCardList[i] > 1)  
  45.             {  
  46.                 prov++;  
  47.             }  
  48.             else  
  49.             {  
  50.                 prov = 0;  
  51.             }  
  52.             if (prov >= length)  
  53.             {  
  54.                 end_i = i;  
  55.                 start_i = i - length + 1;  
  56.   
  57.                 for (int j = start_i; j <= end_i; j++)  
  58.                 {  
  59.                     clsHandCardData.value_aHandCardList[j] -=2;  
  60.                 }  
  61.                 clsHandCardData.nHandCardCount -= clsGameSituation.uctNowCardGroup.nCount;  
  62.                 HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);  
  63.                 for (int j = start_i; j <= end_i; j++)  
  64.                 {  
  65.                     clsHandCardData.value_aHandCardList[j] +=2;  
  66.                 }  
  67.                 clsHandCardData.nHandCardCount += clsGameSituation.uctNowCardGroup.nCount;  
  68.   
  69.                 //选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正  
  70.                 if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))  
  71.                 {  
  72.                     BestHandCardValue = tmpHandCardValue;  
  73.                     BestMaxCard = end_i;  
  74.                     PutCards = true;  
  75.                 }  
  76.   
  77.             }  
  78.         }  
  79.   
  80.         if (PutCards)  
  81.         {  
  82.             for (int j = start_i; j <= end_i; j++)  
  83.             {  
  84.                 clsHandCardData.value_nPutCardList.push_back(j);  
  85.                 clsHandCardData.value_nPutCardList.push_back(j);  
  86.             }  
  87.             clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgDOUBLE_LINE, BestMaxCard, clsGameSituation.uctNowCardGroup.nCount);  
  88.             return;  
  89.         }  
  90.   
  91.         //-------------------------------------------炸弹-------------------------------------------  
  92.   
  93.         for (int i = 3; i < 16; i++)  
  94.         {  
  95.             if (clsHandCardData.value_aHandCardList[i] == 4)  
  96.             {  
  97.   
  98.                 //尝试打出炸弹，估算剩余手牌价值,因为炸弹可以参与顺子，不能因为影响顺子而任意出炸  
  99.                 clsHandCardData.value_aHandCardList[i] -= 4;  
  100.                 clsHandCardData.nHandCardCount -= 4;  
  101.                 HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);  
  102.                 clsHandCardData.value_aHandCardList[i] += 4;  
  103.                 clsHandCardData.nHandCardCount += 4;  
  104.   
  105.                 //选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正  
  106.                 if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7))  
  107.                     //如果剩余手牌价值为正，证明出去的几率很大， 那么可以用炸获得先手  
  108.                     || tmpHandCardValue.SumValue > 0)  
  109.                 {  
  110.                     BestHandCardValue = tmpHandCardValue;  
  111.                     BestMaxCard = i;  
  112.                     PutCards = true;  
  113.                 }  
  114.   
  115.             }  
  116.         }  
  117.         if (PutCards)  
  118.         {  
  119.             clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  120.             clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  121.             clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  122.             clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  123.             clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgBOMB_CARD, BestMaxCard, 4);  
  124.             return;  
  125.         }  
  126.   
  127.         //王炸  
  128.         if (clsHandCardData.value_aHandCardList[17] > 0 && clsHandCardData.value_aHandCardList[16] > 0)  
  129.         {  
  130.             //如果剩余手牌价值为正，证明出去的几率很大，那么可以用炸获得先手，王炸20分  
  131.             if (BestHandCardValue.SumValue > 20)  
  132.             {  
  133.                 clsHandCardData.value_nPutCardList.push_back(17);  
  134.                 clsHandCardData.value_nPutCardList.push_back(16);  
  135.                 clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgKING_CARD, 17, 2);  
  136.                 return;  
  137.             }  
  138.         }  
  139.   
  140.   
  141.   
  142.         //管不上  
  143.         clsHandCardData.uctPutCardType = get_GroupData(cgZERO, 0, 0);  
  144.         return;  
  145.   
  146.     }  
  147.     //三连类型  
  148.     else if (clsGameSituation.uctNowCardGroup.cgType == cgTHREE_LINE)  
  149.     {  
  150.         //剪枝：如果能出去最后一手牌直接出  
  151.         CardGroupData SurCardGroupData = ins_SurCardsType(clsHandCardData.value_aHandCardList);  
  152.         if (SurCardGroupData.cgType != cgERROR)  
  153.         {  
  154.             if (SurCardGroupData.cgType == cgTHREE_LINE&&SurCardGroupData.nMaxCard>clsGameSituation.uctNowCardGroup.nMaxCard  
  155.                 &&SurCardGroupData.nCount == clsGameSituation.uctNowCardGroup.nCount)  
  156.             {  
  157.                 Put_All_SurCards(clsGameSituation, clsHandCardData, SurCardGroupData);  
  158.                 return;  
  159.             }  
  160.             else if (SurCardGroupData.cgType == cgBOMB_CARD || SurCardGroupData.cgType == cgKING_CARD)  
  161.             {  
  162.                 Put_All_SurCards(clsGameSituation, clsHandCardData, SurCardGroupData);  
  163.                 return;  
  164.             }  
  165.         }  
  166.   
  167.   
  168.         //暂存最佳的价值  
  169.         HandCardValue BestHandCardValue = get_HandCardValue(clsHandCardData);  
  170.   
  171.   
  172.         //我们认为不出牌的话会让对手一个轮次，即加一轮（权值减少7）便于后续的对比参考。  
  173.         BestHandCardValue.NeedRound += 1;  
  174.   
  175.         //暂存最佳的牌号  
  176.         int BestMaxCard = 0;  
  177.         //是否出牌的标志  
  178.         bool PutCards = false;  
  179.         //验证顺子的标志  
  180.         int prov = 0;  
  181.         //顺子起点  
  182.         int start_i = 0;  
  183.         //顺子终点  
  184.         int end_i = 0;  
  185.         //顺子长度  
  186.         int length = clsGameSituation.uctNowCardGroup.nCount / 3;  
  187.         //2与王不参与顺子，从当前已打出的顺子最小牌值+1开始遍历  
  188.         for (int i = clsGameSituation.uctNowCardGroup.nMaxCard - length + 2; i < 15; i++)  
  189.         {  
  190.             if (clsHandCardData.value_aHandCardList[i] > 2)  
  191.             {  
  192.                 prov++;  
  193.             }  
  194.             else  
  195.             {  
  196.                 prov = 0;  
  197.             }  
  198.             if (prov >= length)  
  199.             {  
  200.                 end_i = i;  
  201.                 start_i = i - length + 1;  
  202.   
  203.                 for (int j = start_i; j <= end_i; j++)  
  204.                 {  
  205.                     clsHandCardData.value_aHandCardList[j] -= 3;  
  206.                 }  
  207.                 clsHandCardData.nHandCardCount -= clsGameSituation.uctNowCardGroup.nCount;  
  208.                 HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);  
  209.                 for (int j = start_i; j <= end_i; j++)  
  210.                 {  
  211.                     clsHandCardData.value_aHandCardList[j] += 3;  
  212.                 }  
  213.                 clsHandCardData.nHandCardCount += clsGameSituation.uctNowCardGroup.nCount;  
  214.   
  215.                 //选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正  
  216.                 if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))  
  217.                 {  
  218.                     BestHandCardValue = tmpHandCardValue;  
  219.                     BestMaxCard = end_i;  
  220.                     PutCards = true;  
  221.                 }  
  222.   
  223.             }  
  224.         }  
  225.   
  226.         if (PutCards)  
  227.         {  
  228.             for (int j = start_i; j <= end_i; j++)  
  229.             {  
  230.                 clsHandCardData.value_nPutCardList.push_back(j);  
  231.                 clsHandCardData.value_nPutCardList.push_back(j);  
  232.                 clsHandCardData.value_nPutCardList.push_back(j);  
  233.             }  
  234.             clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgTHREE_LINE, BestMaxCard, clsGameSituation.uctNowCardGroup.nCount);  
  235.             return;  
  236.         }  
  237.   
  238.         //-------------------------------------------炸弹-------------------------------------------  
  239.   
  240.         for (int i = 3; i < 16; i++)  
  241.         {  
  242.             if (clsHandCardData.value_aHandCardList[i] == 4)  
  243.             {  
  244.   
  245.                 //尝试打出炸弹，估算剩余手牌价值,因为炸弹可以参与顺子，不能因为影响顺子而任意出炸  
  246.                 clsHandCardData.value_aHandCardList[i] -= 4;  
  247.                 clsHandCardData.nHandCardCount -= 4;  
  248.                 HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);  
  249.                 clsHandCardData.value_aHandCardList[i] += 4;  
  250.                 clsHandCardData.nHandCardCount += 4;  
  251.   
  252.                 //选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正  
  253.                 if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7))  
  254.                     //如果剩余手牌价值为正，证明出去的几率很大， 那么可以用炸获得先手  
  255.                     || tmpHandCardValue.SumValue > 0)  
  256.                 {  
  257.                     BestHandCardValue = tmpHandCardValue;  
  258.                     BestMaxCard = i;  
  259.                     PutCards = true;  
  260.                 }  
  261.   
  262.             }  
  263.         }  
  264.         if (PutCards)  
  265.         {  
  266.             clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  267.             clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  268.             clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  269.             clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  270.             clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgBOMB_CARD, BestMaxCard, 4);  
  271.             return;  
  272.         }  
  273.   
  274.         //王炸  
  275.         if (clsHandCardData.value_aHandCardList[17] > 0 && clsHandCardData.value_aHandCardList[16] > 0)  
  276.         {  
  277.             //如果剩余手牌价值为正，证明出去的几率很大，那么可以用炸获得先手，王炸20分  
  278.             if (BestHandCardValue.SumValue > 20)  
  279.             {  
  280.                 clsHandCardData.value_nPutCardList.push_back(17);  
  281.                 clsHandCardData.value_nPutCardList.push_back(16);  
  282.                 clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgKING_CARD, 17, 2);  
  283.                 return;  
  284.             }  
  285.         }  
  286.   
  287.   
  288.   
  289.         //管不上  
  290.         clsHandCardData.uctPutCardType = get_GroupData(cgZERO, 0, 0);  
  291.         return;  
  292.     }  

 

 

接下来我们讲三带一的算法，其实也很简单，无非就是在确定了三牌之后再通过循环枚举出能够返回最佳权值的顺出去的那张牌。

 

三带一单：

 

[cpp] view plain copy
 
  1. //暂存最佳的价值  
  2. HandCardValue BestHandCardValue = get_HandCardValue(clsHandCardData);  
  3. //我们认为不出牌的话会让对手一个轮次，即加一轮（权值减少7）便于后续的对比参考。  
  4. BestHandCardValue.NeedRound += 1;  
  5. //暂存最佳的牌号  
  6. int BestMaxCard = 0;  
  7. //顺带出去的牌  
  8. int tmp_1 = 0;  
  9. //是否出牌的标志  
  10. bool PutCards = false;  
  11. //三带一  
  12. for (int i = clsGameSituation.uctNowCardGroup.nMaxCard + 1; i < 16; i++)  
  13. {  
  14.     if (clsHandCardData.value_aHandCardList[i] >2)  
  15.     {  
  16.         for (int j = 3; j < 18; j++)  
  17.         {  
  18.             //选出一张以上的牌且不是选择三张的那个牌  
  19.             if (clsHandCardData.value_aHandCardList[j] > 0 && j != i)  
  20.             {  
  21.                 clsHandCardData.value_aHandCardList[i] -= 3;  
  22.                 clsHandCardData.value_aHandCardList[j] -= 1;  
  23.                 clsHandCardData.nHandCardCount -= 4;  
  24.                 HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);  
  25.                 clsHandCardData.value_aHandCardList[i] += 3;  
  26.                 clsHandCardData.value_aHandCardList[j] += 1;  
  27.                 clsHandCardData.nHandCardCount += 4;  
  28.                 //选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正  
  29.                 if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))  
  30.                 {  
  31.                     BestHandCardValue = tmpHandCardValue;  
  32.                     BestMaxCard = i;  
  33.                     tmp_1 = j;  
  34.                     PutCards = true;  
  35.                 }  
  36.             }  
  37.         }  
  38.     }  
  39. }  
  40. if (PutCards)  
  41. {  
  42.     clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  43.     clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  44.     clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  45.     clsHandCardData.value_nPutCardList.push_back(tmp_1);  
  46.     clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgTHREE_TAKE_ONE, BestMaxCard, 4);  
  47.     return;  
  48. }  

 

三带一对：

 

[cpp] view plain copy
 
  1. for (int i = clsGameSituation.uctNowCardGroup.nMaxCard + 1; i < 16; i++)  
  2.         {  
  3.             if (clsHandCardData.value_aHandCardList[i] >2)  
  4.             {  
  5.                 for (int j = 3; j < 16; j++)  
  6.                 {  
  7.                     //选出一张以上的牌且不是选择三张的那个牌  
  8.                     if (clsHandCardData.value_aHandCardList[j] > 1 && j != i)  
  9.                     {  
  10.                         clsHandCardData.value_aHandCardList[i] -= 3;  
  11.                         clsHandCardData.value_aHandCardList[j] -= 2;  
  12.                         clsHandCardData.nHandCardCount -= 5;  
  13.                         HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);  
  14.                         clsHandCardData.value_aHandCardList[i] += 3;  
  15.                         clsHandCardData.value_aHandCardList[j] += 2;  
  16.                         clsHandCardData.nHandCardCount += 5;  
  17.                         //选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正  
  18.                         if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))  
  19.                         {  
  20.                             BestHandCardValue = tmpHandCardValue;  
  21.                             BestMaxCard = i;  
  22.                             tmp_1 = j;  
  23.                             PutCards = true;  
  24.                         }  
  25.                     }  
  26.                 }  
  27.             }  
  28.         }  
  29.         if (PutCards)  
  30.         {  
  31.             clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  32.             clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  33.             clsHandCardData.value_nPutCardList.push_back(BestMaxCard);  
  34.             clsHandCardData.value_nPutCardList.push_back(tmp_1);  
  35.             clsHandCardData.value_nPutCardList.push_back(tmp_1);  
  36.             clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgTHREE_TAKE_TWO, BestMaxCard, 5);  
  37.             return;  
  38.         }  


这里我们需要注意的是，因为i和j我们是放在一起减的，所以要保证i和j不能相等。即if (clsHandCardData.value_aHandCardList[j] > 1 && j != i)

 

 

四带二与其类似，无非就是再多一个循环。

 

四带二单：

 

[cpp] view plain copy
 
  1. for (int i = clsGameSituation.uctNowCardGroup.nMaxCard + 1; i < 16; i++)  
  2.         {  
  3.             if (clsHandCardData.value_aHandCardList[i] == 4)  
  4.             {  
  5.                 for (int j = 3; j < 18; j++)  
  6.                 {  
  7.                     //先选出一张以上的牌且不是选择四张的那个牌  
  8.                     if (clsHandCardData.value_aHandCardList[j] > 0 && j != i)  
  9.                     {  
  10.                         //再选出一张以上的牌且不是选择四张的那个牌且不是第一次选的两张内个牌（策略里四带二不允许带一对,还不如炸）  
  11.                         for (int k = j + 1; k < 18; k++)  
  12.                         {  
  13.                             if (clsHandCardData.value_aHandCardList[k] > 0 && k != i)  
  14.                             {  
  15.                                 clsHandCardData.value_aHandCardList[i] -= 4;  
  16.                                 clsHandCardData.value_aHandCardList[j] -= 1;  
  17.                                 clsHandCardData.value_aHandCardList[k] -= 1;  
  18.                                 clsHandCardData.nHandCardCount -= 6;  
  19.                                 HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);  
  20.                                 clsHandCardData.value_aHandCardList[i] += 4;  
  21.                                 clsHandCardData.value_aHandCardList[j] += 1;  
  22.                                 clsHandCardData.value_aHandCardList[k] += 1;  
  23.                                 clsHandCardData.nHandCardCount += 6;  
  24.   
  25.                                 //选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正  
  26.                                 if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))  
  27.                                 {  
  28.                                     BestHandCardValue = tmpHandCardValue;  
  29.                                     BestMaxCard = i;  
  30.                                     tmp_1 = j;  
  31.                                     tmp_2 = k;  
  32.                                     PutCards = true;  
  33.                                 }  
  34.                             }  
  35.                         }  
  36.                     }  
  37.                 }  
  38.             }  
  39.         }  


四带二单的情况时k时从j+1开始算的，因为我们出牌的策略不允许四带二单带出去一个对，这样还不如直接炸了划算。若此处想修改的话，一定要注意判断i j k不能相等。

 

或者可以参考下一章处理飞机的方法，内个相对安全一些。

 

四带二的算法一样，都是修改枚举牌类型，出牌时value_nPutCardList的处理，回溯时value_aHandCardList和nHandCardCount这几处。

 

不过毕竟四带二这种牌型可以拆分出炸弹，所以我在选择四带二出牌前加入了一层判定：

 

[cpp] view plain copy
 
  1. /*本策略对于这种牌型有炸必炸，四带二相比炸弹来说会多带出两手牌，即最多提高14权值的价值 
  2.         若当前手牌价值大于14，即认为我们能炸即炸，不必考虑四带二的收益，就是这么任性。*/  
  3.   
  4.         if (BestHandCardValue.SumValue > 14)  
  5.         {  
  6.             //炸弹——这里直接炸，不考虑拆分后果。因为信仰。  
  7.             for (int i = 3; i < 16; i++)  
  8.             {  
  9.                 if (clsHandCardData.value_aHandCardList[i] == 4)  
  10.                 {  
  11.                     clsHandCardData.value_nPutCardList.push_back(i);  
  12.                     clsHandCardData.value_nPutCardList.push_back(i);  
  13.                     clsHandCardData.value_nPutCardList.push_back(i);  
  14.                     clsHandCardData.value_nPutCardList.push_back(i);  
  15.   
  16.                     clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgBOMB_CARD, i, 4);  
  17.   
  18.                     return;  
  19.                 }  
  20.             }  
  21.             //王炸  
  22.             if (clsHandCardData.value_aHandCardList[17] > 0 && clsHandCardData.value_aHandCardList[16] > 0)  
  23.             {  
  24.   
  25.                 clsHandCardData.value_nPutCardList.push_back(17);  
  26.                 clsHandCardData.value_nPutCardList.push_back(16);  
  27.   
  28.                 clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgKING_CARD, 17, 2);  
  29.   
  30.                 return;  
  31.             }  
  32.         }  


以及最后管不上出炸判断中，直接炸出。

 

 

[cpp] view plain copy
 
  1. //这里是在拍权值较小的情况，且没有选择出良好的四带二牌型，那么也要炸，因为信仰。  
  2.         for (int i = 3; i < 16; i++)  
  3.         {  
  4.             if (clsHandCardData.value_aHandCardList[i] == 4)  
  5.             {  
  6.                 clsHandCardData.value_nPutCardList.push_back(i);  
  7.                 clsHandCardData.value_nPutCardList.push_back(i);  
  8.                 clsHandCardData.value_nPutCardList.push_back(i);  
  9.                 clsHandCardData.value_nPutCardList.push_back(i);  
  10.   
  11.                 clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgBOMB_CARD, i, 4);  
  12.   
  13.                 return;  
  14.             }  
  15.         }  
  16.         //王炸  
  17.         if (clsHandCardData.value_aHandCardList[17] > 0 && clsHandCardData.value_aHandCardList[16] > 0)  
  18.         {  
  19.   
  20.             clsHandCardData.value_nPutCardList.push_back(17);  
  21.             clsHandCardData.value_nPutCardList.push_back(16);  
  22.   
  23.             clsHandCardData.uctPutCardType = clsGameSituation.uctNowCardGroup = get_GroupData(cgKING_CARD, 17, 2);  
  24.   
  25.             return;  
  26.         }  



 

这个纯属个人信仰了，我觉得当对手打出四带二这种牌型，我有炸无论如何都是要炸的。

也就是对于四带二这种牌型我的出牌策略是：先看自己的手牌实力如何，如果较好直接炸。如果不太好，那么再看看以四带二形式管出后实力如何，如果较好，可以四带二管上，如果还是不太好，那么也是要炸，输就输了！！



 

本章我们把三带一、四带二牌型讲完了，下一章我们再完善剩余的飞机、炸弹牌型，也就是被动出牌最后的一部分了。所以~

 

敬请关注下一章：斗地主AI算法——第十一章の被动出牌(5)

posted on 2018-06-12 22:39  &大飞  阅读(275)  评论(0)  编辑  收藏  举报

导航