斗地主牌型基本算法升级版本

最新推荐文章于 2020-03-27 13:37:08 发布
最新推荐文章于 2020-03-27 13:37:08 发布
阅读量586 收藏
点赞数
文章标签： php
原文链接：http://www.cnblogs.com/gao88/p/11371439.html
版权

       好久没更新博客了，前段时间和朋友一起开了一个公司 做APP，最后失败了。现在又开始做棋牌游戏了，最近在看网狐的源码，发现里面斗地主的基本算法太强大了，现在想想我原来的算法简直是弱爆了，分享一下 希望能对你有一点点帮助。以下主要涉及到判断牌型，牌型大小比较2块，如果你想了解更多关于棋牌游戏的东西请访问我的棋牌游戏专栏

      大家写过游戏都会发现，每一种游戏牌的组成类型不一样的，比如斗地主判断牌型，和德州判断牌型就不一样，最近写德州扑克游戏发现其实所有判断牌型的算法都是一样的。
挑出牌出4张，3张，2张，1张出现的次数，然后各自组合看能出什么样的牌型
，最后就能确定下来具体的牌型。下面是具体的代码实现。。。。
一．判断牌型
定义一个结构来表示每张相同牌的信息。

//分析结构
structtagAnalyseResult
{
    BYTE                         cbFourCount;                      //四张数目
    BYTE                         cbThreeCount;                     //三张数目
    BYTE                         cbDoubleCount;                    //两张数目
    BYTE                         cbSignedCount;                    //单张数目
    BYTE                         cbFourCardData[MAX_COUNT];        //四张克
    BYTE                         cbThreeCardData[MAX_COUNT];       //三张扑克
    BYTE                         cbDoubleCardData[MAX_COUNT];      //两张扑克
    BYTE                         cbSignedCardData[MAX_COUNT];      //单张扑克
};


当我们需要判断牌型的时候，先分析牌把对应的数据存放到上面的结构体。然后根据不同牌型的规则来判断即可。主要通过下面2个函数.话不多说直接上源代码：
1、分析扑克（参数:1将要出牌的数据，出牌的张数,out存放分析的结构体）

void CGameLogic::AnalysebCardData(constBYTE cbCardData[], BYTE cbCardCount, tagAnalyseResult & AnalyseResult)
{
         //设置结果
         ZeroMemory(&AnalyseResult,sizeof(AnalyseResult));
 
         //扑克分析
         for(BYTE i=0;i<cbCardCount;i++)
         {
                   //变量定义
                   BYTE cbSameCount=1,cbCardValueTemp=0;
                   BYTE cbLogicValue=GetCardLogicValue(cbCardData[i]);
                   //搜索同牌
                   for(BYTE j=i+1;j<cbCardCount;j++)
                   {
                            //获取扑克
                            if(GetCardLogicValue(cbCardData[j])!=cbLogicValue) break;
                            //设置变量
                            cbSameCount++;
                   }
                   //设置结果
                   switch(cbSameCount)
                   {
                   case1:    //单张
                            {
                                     BYTE cbIndex=AnalyseResult.cbSignedCount++;
                                     AnalyseResult.cbSignedCardData[cbIndex*cbSameCount]=cbCardData[i];
                                     break;
                            }
                   case2:    //两张
                            {
                                     BYTE cbIndex=AnalyseResult.cbDoubleCount++;
                                     AnalyseResult.cbDoubleCardData[cbIndex*cbSameCount]=cbCardData[i];
                                     AnalyseResult.cbDoubleCardData[cbIndex*cbSameCount+1]=cbCardData[i+1];
                                     break;
                            }
                   case3:    //三张
                            {
                                     BYTE cbIndex=AnalyseResult.cbThreeCount++;
                                     AnalyseResult.cbThreeCardData[cbIndex*cbSameCount]=cbCardData[i];
                                     AnalyseResult.cbThreeCardData[cbIndex*cbSameCount+1]=cbCardData[i+1];
                                     AnalyseResult.cbThreeCardData[cbIndex*cbSameCount+2]=cbCardData[i+2];
                                     break;
                            }
                   case4:    //四张
                            {
                                     BYTE cbIndex=AnalyseResult.cbFourCount++;
                                     AnalyseResult.cbFourCardData[cbIndex*cbSameCount]=cbCardData[i];
                                     AnalyseResult.cbFourCardData[cbIndex*cbSameCount+1]=cbCardData[i+1];
                                     AnalyseResult.cbFourCardData[cbIndex*cbSameCount+2]=cbCardData[i+2];
                                     AnalyseResult.cbFourCardData[cbIndex*cbSameCount+3]=cbCardData[i+3];
                                     break;
                            }
                   }
 
                   //设置索引
                   i+=cbSameCount-1;
         }
 
         return;
}


2.、获取具体牌的类型 （实现原理就是 通过出来的张数 和相同的牌来组合牌型 看是否满足）

//获取类型
BYTE CGameLogic::GetCardType(constBYTE cbCardData[], BYTE cbCardCount)
{
         //简单牌型
         switch(cbCardCount)
         {
         case0:      //空牌
                   {
                            returnCT_ERROR;
                   }
         case1: //单牌
                   {
                            returnCT_SINGLE;
                   }
         case2:      //对牌火箭
                   {
                            //牌型判断
                            if((cbCardData[0]==0x4F)&&(cbCardData[1]==0x4E))returnCT_MISSILE_CARD;
                            if(GetCardLogicValue(cbCardData[0])==GetCardLogicValue(cbCardData[1]))returnCT_DOUBLE;
 
                            returnCT_ERROR;
                   }
         }
 
         //分析扑克
         tagAnalyseResult AnalyseResult;
         AnalysebCardData(cbCardData,cbCardCount,AnalyseResult);
 
         //四牌判断
         if(AnalyseResult.cbFourCount>0)
         {
                   //牌型判断
                   if((AnalyseResult.cbFourCount==1)&&(cbCardCount==4))returnCT_BOMB_CARD;
                   //       if((AnalyseResult.cbFourCount==1)&&(AnalyseResult.cbSignedCount==2)&&(cbCardCount==6))return CT_FOUR_LINE_TAKE_ONE;
                   if((AnalyseResult.cbFourCount==1)&&(AnalyseResult.cbSignedCount==2)&&(cbCardCount==6))returnCT_FOUR_LINE_TAKE_ONE;
                   if((AnalyseResult.cbFourCount==1)&&(AnalyseResult.cbDoubleCount==2)&&(cbCardCount==8))returnCT_FOUR_LINE_TAKE_TWO;
 
                   returnCT_ERROR;
         }
 
         //三牌判断
         if(AnalyseResult.cbThreeCount>0)
         {
                   //三条类型
                   if(AnalyseResult.cbThreeCount==1&& cbCardCount==3) returnCT_THREE ;
 
                   //连牌判断
                   if(AnalyseResult.cbThreeCount>1)
                   {
                            //变量定义
                            BYTE cbCardData=AnalyseResult.cbThreeCardData[0];
                            BYTE cbFirstLogicValue=GetCardLogicValue(cbCardData);
 
                            //错误过虑
                            if(cbFirstLogicValue>=15) return CT_ERROR;
 
                            //连牌判断
                            for(BYTE i=1;i<AnalyseResult.cbThreeCount;i++)
                            {
                                     BYTE cbCardData=AnalyseResult.cbThreeCardData[i*3];
                                     if(cbFirstLogicValue!=(GetCardLogicValue(cbCardData)+i)) returnCT_ERROR;
                            }
                   }
 
                   //牌形判断
                   if(AnalyseResult.cbThreeCount*3==cbCardCount) returnCT_THREE_LINE;
                   if(AnalyseResult.cbThreeCount*4==cbCardCount) returnCT_THREE_LINE_TAKE_ONE;
                   if((AnalyseResult.cbThreeCount*5==cbCardCount)&&(AnalyseResult.cbDoubleCount==AnalyseResult.cbThreeCount))returnCT_THREE_LINE_TAKE_TWO;
 
                   returnCT_ERROR;
         }
 
         //两张类型
         if(AnalyseResult.cbDoubleCount>=3)
         {
                   //变量定义
                   BYTE cbCardData=AnalyseResult.cbDoubleCardData[0];
                   BYTE cbFirstLogicValue=GetCardLogicValue(cbCardData);
 
                   //错误过虑
                   if(cbFirstLogicValue>=15) return CT_ERROR;
 
                   //连牌判断
                   for(BYTE i=1;i<AnalyseResult.cbDoubleCount;i++)
                   {
                            BYTE cbCardData=AnalyseResult.cbDoubleCardData[i*2];
                            if(cbFirstLogicValue!=(GetCardLogicValue(cbCardData)+i)) returnCT_ERROR;
                   }
 
                   //二连判断
                   if((AnalyseResult.cbDoubleCount*2)==cbCardCount)returnCT_DOUBLE_LINE;
 
                   returnCT_ERROR;
         }
 
         //单张判断
         if((AnalyseResult.cbSignedCount>=5)&&(AnalyseResult.cbSignedCount==cbCardCount))
         {
                   //变量定义
                   BYTE cbCardData=AnalyseResult.cbSignedCardData[0];
                   BYTE cbFirstLogicValue=GetCardLogicValue(cbCardData);
 
                   //错误过虑
                   if(cbFirstLogicValue>=15) return CT_ERROR;
 
                   //连牌判断
                   for(BYTE i=1;i<AnalyseResult.cbSignedCount;i++)
                   {
                            BYTE cbCardData=AnalyseResult.cbSignedCardData[i];
                            if(cbFirstLogicValue!=(GetCardLogicValue(cbCardData)+i)) returnCT_ERROR;
                   }
 
                   returnCT_SINGLE_LINE;
         }
 
         returnCT_ERROR;
}

 

转载于:https://www.cnblogs.com/gao88/p/11371439.html

ahyz9638
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
landlord:斗地主牌型验证算法
04-30
斗地主牌型验证算法本项目只是用来验证斗地主的各种牌型的算法，相当于工具类。不包含与客户端的交互以及打牌过程。请自行添加。牌型定义类card.define.EnumCardTypePoker.java牌型验证算法类LandlordsBaseUtil....
扑克斗地主
JunChow
07-24 907
斗地主是起源于湖北的一项棋牌休闲游戏，游戏是根据湖北当地十分流行的棋牌玩法跑得快变化改进创造出来的。 斗地主是根据当时流行的扑克玩法跑得快改编的，最初有一群跑得快的痴迷者，经常在人数不足的情况下玩三个人的跑得快。起初名字并非叫做斗地主，圈内叫做二打一。最初二打一总共54张牌，每个玩家发18张牌，不留三张底牌，只是一个玩家从另外两个玩家手中随机抽取一张牌，被抽牌的玩家共同协作对付抽牌...
地主算法之判断牌型
棋牌游戏开发
05-17 1万+
地主算法之判断牌型                   by  wojiushi3344                       QQ:513670524                  每个游戏都有属于自己的规则，当然地主也不例外，常斗地主的朋友可能知道在斗地主里面一共有13种牌型，你所出的牌必须符合13种的一种才能够出得了牌，这个就叫地主的规则。那么我们下面可以通过一个枚举结构来表
斗地主含赖子的牌型判断算法
qq_41810721的博客
01-03 3010
癞子规则 1、假设有n个癞子，癞子可以单独做成任何牌型。如：假设癞子为3，则4个3可以可以做成任何牌型，可以当4个5，4个6。。。。，还能做成3带一 手牌处理 struct tagCard{int CardVal;int CardNum} ...
最近在写一款斗地主游戏,写了个癞子匹配顺子的算法
xjay_cc的专栏
07-30 7186
在网上看了一些算法 发现似乎没有癞子斗地主的算法 ,于是乎就写了一个, 其他的比如匹配飞机 匹配连对 基本上和这个思路差不多 #include "stdafx.h" #include #include #include #define lai_zi 14 using namespace std; bool find_is_only(std::vector&v) { for
斗地主中的提示出牌算法(Lua)
hyx18775752051的博客
03-27 3824
没有看到别人怎么写的，这个是上家公司老板写的，当时服务器用的js写的，我搬到了客户端上，换成了lua。然后现在工作要用到，一时还想不起来。所以说造过的轮子要记录下来，方便自己，也方便他人。 主要的思路就是根据上家的出牌，先判断出type(单，对，顺子，炸弹等)，然后根据type去寻找该类型的所有牌组合。所以每个类型都要有个对应的方法。可以在找的时候直接传入参数，直接找大于该牌的组合。也可以找出该...
斗地主牌型相关算法
03-02
lua实现斗地主中的牌型判断，牌的比较，出牌提示的算法
斗地主牌型相关算法.rar
10-24
用一个枚举存储牌的大类型（黑红梅方），再用一个枚举存储牌的小类型（A~K,dawang,xaiowang）。 牌的等级：grade 大王等级最高 对牌排序的时候用到
斗地主 牌型 算法
07-15
斗地主 牌型 算法 可以直接使用 希望 对你 有用
斗地主牌型判断和比较.zip
10-18
斗地主的javascript源码，总共200多行，其中牌型判断的代码只有100行，注释详细，用到了一些算法优化技巧，学习价值很高
Jquery斗地主牌型验证插件
06-08
具体介绍或使用说明请查看 http://blog.csdn.net/wz361790599/archive/2010/06/08/5656961.aspx
JS写的斗地主
06-26
用JS实现单机斗地主，有抢地主、简单人工智能，当然还有最主要的斗地主功能，是学习JS的很好案例。
棋牌游戏判断牌型算法---适合所有的棋牌游戏
热门推荐
棋牌游戏开发
04-03 2万+
斗地主牌型基本算法升级版本 好久没更新博客了，前段时间和朋友一起开了一个公司 做APP，最后失败了。现在又开始做棋牌游戏了，最近在看网狐的源码，发现里面斗地主的基本算法太强大了，现在想想我原来的算法简直是弱爆了，分享一下 希望能对你有一点点帮助。以下主要涉及到判断牌型，牌型大小比较2块，如果你想了解更多关于棋牌游戏的东西请访问我的 棋牌游
斗地主算法之点选牌
棋牌游戏开发
05-15 9255
斗地主算法之点选牌                            -------BY wojiushi3344                                      QQ：513670524               PS:最近找了2个朋友主准备把斗地主游戏重写，由于种种原因今天还没有开始，所以先把基本的算法写一写，为以后写项目做准备。如果你对斗地主游戏比较感兴
斗地主系列之牌型判断
hfreeman2008的专栏
07-13 1万+
参考资料： 1.
斗地主之用蚁群算法整理牌型-几个关键点的处理
jxandrew的专栏
07-05 2803
牌型选择和其它问题的差异性分析蚁群算法是由仿生蚂蚁寻食发展而来，所以其很自然的就以寻找最短路径的旅行家问题为研究对象。而旅行家问题有几个特点： 每一步都是从当前所在城市的所有邻接城市中挑选下一步的目标城市 算法的判优指标（即解评分）是总距离最短 单步择优的启发性信息是两邻接城市之间的路径长度 信息素就是本轮次最优解的路径总长度/路径中的城市数 对照我们的牌型选择问题，就存在一定的差异了： 牌型选择的
三带一牌型算法c++
最新发布
11-11
三带一牌型是斗地主中常见的牌型之一，玩家需要根据手中的牌来进行组合出合适的牌型。在算法c中，玩家需要遵循以下几个步骤来判断三带一牌型： 首先，玩家需要检查手中的牌中是否有符合三带一牌型的牌组合，即三张...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值