• 设为首页
  • 点击收藏
  • 手机版
    手机扫一扫访问
    迪恩网络手机版
  • 关注官方公众号
    微信扫一扫关注
    迪恩网络公众号
登陆 注册
描述文字

lua——赢三张牌型处理相关算法（中）——牌型判定

原作者: [db:作者] 来自: [db:来源] 收藏 邀请

赢三张的牌型大题分为6种：单牌<对子<顺子<同花<同花顺<豹子。

 

[plain] view plain copy
 
  1. CardType =  
  2. {  
  3.     UNDEFINE=0,        --单牌  
  4.     DUI_ZI  =1,          --对子  
  5.     SHUN_ZI =2,         --顺子  
  6.     TONG_HUA=3,   --同花  
  7.     TONG_HUA_SHUN = 4, --同花顺  
  8.     BAO_ZI = 5,        --豹子  
  9. }  


首先为了方便我们的牌型判定逻辑，我们先将3张牌数据cards按牌值大小进行排序

 

 

[plain] view plain copy
 
  1. function compByCardsValue(a, b)  
  2.   
  3.     return a.card_value < b.card_value  
  4.      
  5. end  
  6.   
  7.   
  8. function cardTool.sortByLaiziAsc(cards)  
  9.     table.sort(cards, compByCardsValue);  
  10. end  

 

 

接下来我们从大到小的写出各牌型的判断逻辑

豹子：三张牌值相同的牌型，由于是有序的，故只需判断第一张与第三张牌值是否相等即可

 

[plain] view plain copy
 
  1. function cardTool.isBaozi( cards)  
  2.   
  3.     if cards[1].card_value==cards[3].card_value then  
  4.         return true  
  5.     else  
  6.         return false  
  7.     end  
  8.   
  9. end  


同花顺：即满足同花又满足顺子的牌型

 

 

 

[plain] view plain copy
 
  1. function cardTool.isTongHuaShun(cards)  
  2.    
  3.     local TagTongHua  
  4.     local TagShunZi  
  5.     TagTongHua = cardTool.isTongHua(cards)  
  6.     TagShunZi  = cardTool.isShunZi(cards)  
  7.     if TagTongHua and TagShunZi then --既满足同花也满足顺子的时候，就是同花顺，包含23A  
  8.         return true  
  9.     else  
  10.         return false  
  11.     end  
  12.   
  13. end  


同花：三张牌花色相同

 

 

[plain] view plain copy
 
  1. function cardTool.isTongHua (cards)  
  2.    
  3.     if cards[1].card_Color==cards[2].card_Color and cards[1].card_Color==cards[3].card_Color then  
  4.         return true  
  5.     else  
  6.         return false  
  7.     end  
  8.   
  9. end  


顺子：三张牌牌值依次递增1，同时还包括A23特殊牌型

 

 

[plain] view plain copy
 
  1. function cardTool.isShunZi(cards)  
  2.   
  3.     if isA32(cards) then  
  4.         return true  
  5.     end  
  6.   
  7.     if cards[3].card_value - cards[2].card_value == 1 and cards[2].card_value - cards[1].card_value == 1 then  
  8.         return true  
  9.     else  
  10.         return false  
  11.     end  
  12. end  


对子：两张牌牌值相等，但第一张与第三张不能相等，否则就是豹子了

 

 

[plain] view plain copy
 
  1. function cardTool.isDuiZi(cards)  
  2.      
  3.     if cards[1].card_value ~= cards[3].card_value then  
  4.         if cards[1].card_value == cards[2].card_value then  
  5.             return true  
  6.         end  
  7.   
  8.         if cards[2].card_value == cards[3].card_value then  
  9.             return true  
  10.         end  
  11.         return false  
  12.     else  
  13.         return false  
  14.     end  
  15.   
  16. end  

 

 

若以上牌型都不满足，即为单牌牌型。

 

封装获取牌型函数：

 

[plain] view plain copy
 
  1. function cardTool.getCardType(cards)  
  2.     cardTool.sortByCardsValue(cards)  
  3.   
  4.     local card_type = CardType.UNDEFINE  
  5.     local ret  
  6.   
  7.     if (cards) then  
  8.         --《豹子  
  9.         ret = cardTool.isBaozi(cards)  
  10.         if ret == true then  
  11.             card_type = CardType.BAO_ZI  
  12.             return card_type   
  13.         end  
  14.   
  15.         --《同花顺  
  16.         ret = cardTool.isTongHuaShun(cards)  
  17.         if (ret == true) then  
  18.             card_type = CardType.TONG_HUA_SHUN;  
  19.             return card_type  
  20.   
  21.         end  
  22.   
  23.         --《同花  
  24.         ret = cardTool.isTongHua(cards)  
  25.         if (ret == true) then  
  26.             card_type = CardType.TONG_HUA;  
  27.             return card_type  
  28.         end  
  29.   
  30.         --《顺子  
  31.         ret = cardTool.isShunZi(cards)  
  32.         if (ret == true) then  
  33.             card_type = CardType.SHUN_ZI;  
  34.             return card_type  
  35.         end  
  36.           
  37.         -- 《对子  
  38.         ret = cardTool.isDuiZi(cards)  
  39.         if (ret == true) then  
  40.             card_type = CardType.DUI_ZI;  
  41.             return card_type  
  42.         end  
  43.     end  
  44.   
  45.     return card_type  --UNDEFINE=0,--初始单牌  
  46. end  



另外存在特殊牌型，A23及235（A23算最小的顺子，非同花的235可以管豹子）

 

 

[plain] view plain copy
 
  1. --》A23  
  2. function isA32(cards)  
  3.     if cards[1].card_value == 2 and cards[2].card_value == 3 and cards[3].card_value == 14 then  
  4.         return true  
  5.     else  
  6.         return false  
  7.     end  
  8. end  
  9.   
  10. --》235  
  11. function is235(cards)  
  12.     if cards[1].card_value == 2 and cards[2].card_value == 3 and cards[3].card_value == 5 then  
  13.         return true  
  14.     else  
  15.         return false  
  16.     end  
  17. end  


翻译函数：

 

 

[plain] view plain copy
 
  1. function cardTool.getCardTypeNamebyType(CardType)  
  2.     if CardType==0 then  
  3.         return "单牌"  
  4.     end  
  5.     if CardType==1 then  
  6.         return "对子"  
  7.     end  
  8.     if CardType==2 then  
  9.         return "顺子"  
  10.     end  
  11.     if CardType==3 then  
  12.         return "同花"  
  13.     end  
  14.     if CardType==4 then  
  15.         return "同花顺"  
  16.     end  
  17.     if CardType==5 then  
  18.         return "豹子"  
  19.     end  
  20.     return "异常牌型"  
  21.   
  22. end  


按照上一章的测试函数，我们输出一下牌的类型

 

 

[plain] view plain copy
 
  1. local cardBuffer =cardTool.RandCardList()  
  2.   
  3.   
  4. --cardBuffer[1]=6  
  5. --cardBuffer[2]=7+16  
  6. --cardBuffer[3]=7  
  7.   
  8. --cardBuffer[4]=5+16  
  9. --cardBuffer[5]=7+32  
  10. --cardBuffer[6]=7+48  
  11.   
  12.   
  13. local cards1={}  
  14. local cards2={}  
  15.   
  16. for i=1,6,1 do  
  17.     local cardColor = luabit.band(cardBuffer[i] , 0xF0)  
  18.     local cardValue = luabit.band(cardBuffer[i] , 0x0F)  
  19.   
  20.   
  21.     local cardinfo =  
  22.     {  
  23.         card_value = cardValue;  
  24.         card_Color = cardColor;  
  25.     }  
  26.     if i >3 then  
  27.         cards2[i-3] = cardinfo  
  28.     else  
  29.         cards1[i] = cardinfo  
  30.     end  
  31.   
  32.   
  33. end  
  34.   
  35.   
  36. print_t(cardTool.getCardTypeNamebyType(cardTool.getCardType(cards1)))  
  37. print_t(cardTool.getCardNamebyCards(cards1))  
  38.   
  39. print_t(cardTool.getCardTypeNamebyType(cardTool.getCardType(cards2)))  
  40. print_t(cardTool.getCardNamebyCards(cards2))  


PS：print_t是我自己写的实现输出table类型的输出函数

 

输出：

 

[plain] view plain copy
 
  1. 对子  
  2.   
  3. 方块9红桃K梅花K  
  4.   
  5. 单牌  
  6.   
  7. 方块3黑桃J红桃Q  



 

以上就是牌型判定相关的处理函数，下一章我们实现牌型比较的相关逻辑。

 

鲜花
握手
雷人
路过
鸡蛋
该文章已有0人参与评论

请发表评论

全部评论

专题导读
More+
上一篇：
SpringBoot通过RedisTemplate执行Lua脚本的方法步骤发布时间：2022-07-22
下一篇：
Lua数据结构—TValue（一）发布时间：2022-07-22
热门推荐
More+
热门话题
More+
阅读排行榜

扫描微信二维码

查看手机版网站

随时了解更新最新资讯

139-2527-9053

在线客服（服务时间 9:00～18:00）

在线QQ客服
地址：深圳市南山区西丽大学城创智工业园
电邮：jeky_zhao#qq.com
移动电话：139-2527-9053

Powered by 互联科技 X3.4© 2001-2213 极客世界.|Sitemap