斗地主必胜秘诀_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
斗地主必胜秘诀
上传于|0|0|文档简介
&&斗地主必胜秘诀
阅读已结束，如果下载本文需要使用2下载券
想免费下载本文？
定制HR最喜欢的简历
下载文档到电脑，查找使用更方便
还剩1页未读，继续阅读
定制HR最喜欢的简历
你可能喜欢cocos2dx（80）
#include &StdAfx.h&
#include &GameLogic.h&
//////////////////////////////////////////////////////////////////////////////////
//静态变量
//索引变量
const BYTE cbIndexCount=5;
//扑克数据
const BYTE CGameLogic::m_cbCardData[FULL_COUNT]=
0x01,0x02,0x03,0x04,0x05,0x06,0x07,0x08,0x09,0x0A,0x0B,0x0C,0x0D, //方块 A - K
0x11,0x12,0x13,0x14,0x15,0x16,0x17,0x18,0x19,0x1A,0x1B,0x1C,0x1D, //梅花 A - K
0x21,0x22,0x23,0x24,0x25,0x26,0x27,0x28,0x29,0x2A,0x2B,0x2C,0x2D, //红桃 A - K
0x31,0x32,0x33,0x34,0x35,0x36,0x37,0x38,0x39,0x3A,0x3B,0x3C,0x3D, //黑桃 A - K
0x4E,0x4F,
//////////////////////////////////////////////////////////////////////////////////
//构造函数
CGameLogic::CGameLogic()
//析构函数
CGameLogic::~CGameLogic()
//获取类型
BYTE CGameLogic::GetCardType(const BYTE cbCardData[], BYTE cbCardCount)
//简单牌型
switch (cbCardCount)
case 0: //空牌
return CT_ERROR;
case 1: //单牌
return CT_SINGLE;
case 2: //对牌火箭
//牌型判断
if ((cbCardData[0]==0x4F)&&(cbCardData[1]==0x4E)) return CT_MISSILE_CARD;
if (GetCardLogicValue(cbCardData[0])==GetCardLogicValue(cbCardData[1])) return CT_DOUBLE;
return CT_ERROR;
//分析扑克
tagAnalyseResult AnalyseR
AnalysebCardData(cbCardData,cbCardCount,AnalyseResult);
//四牌判断
if (AnalyseResult.cbBlockCount[3]&0)
//牌型判断
if ((AnalyseResult.cbBlockCount[3]==1)&&(cbCardCount==4)) return CT_BOMB_CARD;
if ((AnalyseResult.cbBlockCount[3]==1)&&(cbCardCount==6)) return CT_FOUR_TAKE_ONE;
if ((AnalyseResult.cbBlockCount[3]==1)&&(cbCardCount==8)&&(AnalyseResult.cbBlockCount[1]==2)) return CT_FOUR_TAKE_TWO;
return CT_ERROR;
//三牌判断
if (AnalyseResult.cbBlockCount[2]&0)
//连牌判断
if (AnalyseResult.cbBlockCount[2]&1)
//变量定义
BYTE cbCardData=AnalyseResult.cbCardData[2][0];
BYTE cbFirstLogicValue=GetCardLogicValue(cbCardData);
//错误过虑
if (cbFirstLogicValue&=15) return CT_ERROR;
//连牌判断
for (BYTE i=1;i&AnalyseResult.cbBlockCount[2];i++)
BYTE cbCardData=AnalyseResult.cbCardData[2][i*3];
if (cbFirstLogicValue!=(GetCardLogicValue(cbCardData)+i)) return CT_ERROR;
else if( cbCardCount == 3 ) return CT_THREE;
//牌形判断
if (AnalyseResult.cbBlockCount[2]*3==cbCardCount) return CT_THREE_LINE;
if (AnalyseResult.cbBlockCount[2]*4==cbCardCount) return CT_THREE_TAKE_ONE;
if ((AnalyseResult.cbBlockCount[2]*5==cbCardCount)&&(AnalyseResult.cbBlockCount[1]==AnalyseResult.cbBlockCount[2])) return CT_THREE_TAKE_TWO;
return CT_ERROR;
//两张类型
if (AnalyseResult.cbBlockCount[1]&=3)
//变量定义
BYTE cbCardData=AnalyseResult.cbCardData[1][0];
BYTE cbFirstLogicValue=GetCardLogicValue(cbCardData);
//错误过虑
if (cbFirstLogicValue&=15) return CT_ERROR;
//连牌判断
for (BYTE i=1;i&AnalyseResult.cbBlockCount[1];i++)
BYTE cbCardData=AnalyseResult.cbCardData[1][i*2];
if (cbFirstLogicValue!=(GetCardLogicValue(cbCardData)+i)) return CT_ERROR;
//二连判断
if ((AnalyseResult.cbBlockCount[1]*2)==cbCardCount) return CT_DOUBLE_LINE;
return CT_ERROR;
//单张判断
if ((AnalyseResult.cbBlockCount[0]&=5)&&(AnalyseResult.cbBlockCount[0]==cbCardCount))
//变量定义
BYTE cbCardData=AnalyseResult.cbCardData[0][0];
BYTE cbFirstLogicValue=GetCardLogicValue(cbCardData);
//错误过虑
if (cbFirstLogicValue&=15) return CT_ERROR;
//连牌判断
for (BYTE i=1;i&AnalyseResult.cbBlockCount[0];i++)
BYTE cbCardData=AnalyseResult.cbCardData[0][i];
if (cbFirstLogicValue!=(GetCardLogicValue(cbCardData)+i)) return CT_ERROR;
return CT_SINGLE_LINE;
return CT_ERROR;
//排列扑克
VOID CGameLogic::SortCardList(BYTE cbCardData[], BYTE cbCardCount, BYTE cbSortType)
//数目过虑
if (cbCardCount==0)
if (cbSortType==ST_CUSTOM)
//转换数值
BYTE cbSortValue[MAX_COUNT];
for (BYTE i=0;i&cbCardCi++) cbSortValue[i]=GetCardLogicValue(cbCardData[i]);
//排序操作
bool bSorted=
BYTE cbSwitchData=0,cbLast=cbCardCount-1;
for (BYTE i=0;i&cbLi++)
if ((cbSortValue[i]&cbSortValue[i+1])||
((cbSortValue[i]==cbSortValue[i+1])&&(cbCardData[i]&cbCardData[i+1])))
//设置标志
//扑克数据
cbSwitchData=cbCardData[i];
cbCardData[i]=cbCardData[i+1];
cbCardData[i+1]=cbSwitchD
//排序权位
cbSwitchData=cbSortValue[i];
cbSortValue[i]=cbSortValue[i+1];
cbSortValue[i+1]=cbSwitchD
} while(bSorted==false);
//数目排序
if (cbSortType==ST_COUNT)
//变量定义
BYTE cbCardIndex=0;
//分析扑克
tagAnalyseResult AnalyseR
AnalysebCardData(&cbCardData[cbCardIndex],cbCardCount-cbCardIndex,AnalyseResult);
//提取扑克
for (BYTE i=0;i&CountArray(AnalyseResult.cbBlockCount);i++)
//拷贝扑克
BYTE cbIndex=CountArray(AnalyseResult.cbBlockCount)-i-1;
CopyMemory(&cbCardData[cbCardIndex],AnalyseResult.cbCardData[cbIndex],AnalyseResult.cbBlockCount[cbIndex]*(cbIndex+1)*sizeof(BYTE));
//设置索引
cbCardIndex+=AnalyseResult.cbBlockCount[cbIndex]*(cbIndex+1)*sizeof(BYTE);
//混乱扑克
VOID CGameLogic::RandCardList(BYTE cbCardBuffer[], BYTE cbBufferCount)
//混乱准备
BYTE cbCardData[CountArray(m_cbCardData)];
CopyMemory(cbCardData,m_cbCardData,sizeof(m_cbCardData));
//混乱扑克
BYTE cbRandCount=0,cbPosition=0;
cbPosition=rand()%(cbBufferCount-cbRandCount);
cbCardBuffer[cbRandCount++]=cbCardData[cbPosition];
cbCardData[cbPosition]=cbCardData[cbBufferCount-cbRandCount];
} while (cbRandCount&cbBufferCount);
//删除扑克
bool CGameLogic::RemoveCardList(const BYTE cbRemoveCard[], BYTE cbRemoveCount, BYTE cbCardData[], BYTE cbCardCount)
//检验数据
ASSERT(cbRemoveCount&=cbCardCount);
//定义变量
BYTE cbDeleteCount=0,cbTempCardData[MAX_COUNT];
if (cbCardCount&CountArray(cbTempCardData))
CopyMemory(cbTempCardData,cbCardData,cbCardCount*sizeof(cbCardData[0]));
//置零扑克
for (BYTE i=0;i&cbRemoveCi++)
for (BYTE j=0;j&cbCardCj++)
if (cbRemoveCard[i]==cbTempCardData[j])
cbDeleteCount++;
cbTempCardData[j]=0;
if (cbDeleteCount!=cbRemoveCount)
//清理扑克
BYTE cbCardPos=0;
for (BYTE i=0;i&cbCardCi++)
if (cbTempCardData[i]!=0) cbCardData[cbCardPos++]=cbTempCardData[i];
//逻辑数值
BYTE CGameLogic::GetCardLogicValue(BYTE cbCardData)
//扑克属性
BYTE cbCardColor=GetCardColor(cbCardData);
BYTE cbCardValue=GetCardValue(cbCardData);
//转换数值
if (cbCardColor==0x40) return cbCardValue+2;
return (cbCardValue&=2)?(cbCardValue+13):cbCardV
//对比扑克
bool CGameLogic::CompareCard(const BYTE cbFirstCard[], const BYTE cbNextCard[], BYTE cbFirstCount, BYTE cbNextCount)
//获取类型
BYTE cbNextType=GetCardType(cbNextCard,cbNextCount);
BYTE cbFirstType=GetCardType(cbFirstCard,cbFirstCount);
//类型判断
if (cbNextType==CT_ERROR)
if (cbNextType==CT_MISSILE_CARD)
//炸弹判断
if ((cbFirstType!=CT_BOMB_CARD)&&(cbNextType==CT_BOMB_CARD))
if ((cbFirstType==CT_BOMB_CARD)&&(cbNextType!=CT_BOMB_CARD))
//规则判断
if ((cbFirstType!=cbNextType)||(cbFirstCount!=cbNextCount))
//开始对比
switch (cbNextType)
case CT_SINGLE:
case CT_DOUBLE:
case CT_THREE:
case CT_SINGLE_LINE:
case CT_DOUBLE_LINE:
case CT_THREE_LINE:
case CT_BOMB_CARD:
//获取数值
BYTE cbNextLogicValue=GetCardLogicValue(cbNextCard[0]);
BYTE cbFirstLogicValue=GetCardLogicValue(cbFirstCard[0]);
//对比扑克
return cbNextLogicValue&cbFirstLogicV
case CT_THREE_TAKE_ONE:
case CT_THREE_TAKE_TWO:
//分析扑克
tagAnalyseResult NextR
tagAnalyseResult FirstR
AnalysebCardData(cbNextCard,cbNextCount,NextResult);
AnalysebCardData(cbFirstCard,cbFirstCount,FirstResult);
//获取数值
BYTE cbNextLogicValue=GetCardLogicValue(NextResult.cbCardData[2][0]);
BYTE cbFirstLogicValue=GetCardLogicValue(FirstResult.cbCardData[2][0]);
//对比扑克
return cbNextLogicValue&cbFirstLogicV
case CT_FOUR_TAKE_ONE:
case CT_FOUR_TAKE_TWO:
//分析扑克
tagAnalyseResult NextR
tagAnalyseResult FirstR
AnalysebCardData(cbNextCard,cbNextCount,NextResult);
AnalysebCardData(cbFirstCard,cbFirstCount,FirstResult);
//获取数值
BYTE cbNextLogicValue=GetCardLogicValue(NextResult.cbCardData[3][0]);
BYTE cbFirstLogicValue=GetCardLogicValue(FirstResult.cbCardData[3][0]);
//对比扑克
return cbNextLogicValue&cbFirstLogicV
//构造扑克
BYTE CGameLogic::MakeCardData(BYTE cbValueIndex, BYTE cbColorIndex)
return (cbColorIndex&&4)|(cbValueIndex+1);
//分析扑克
VOID CGameLogic::AnalysebCardData(const BYTE cbCardData[], BYTE cbCardCount, tagAnalyseResult & AnalyseResult)
//设置结果
ZeroMemory(&AnalyseResult,sizeof(AnalyseResult));
//扑克分析
for (BYTE i=0;i&cbCardCi++)
//变量定义
BYTE cbSameCount=1,cbCardValueTemp=0;
BYTE cbLogicValue=GetCardLogicValue(cbCardData[i]);
//搜索同牌
for (BYTE j=i+1;j&cbCardCj++)
//获取扑克
if (GetCardLogicValue(cbCardData[j])!=cbLogicValue)
//设置变量
cbSameCount++;
//设置结果
BYTE cbIndex=AnalyseResult.cbBlockCount[cbSameCount-1]++;
for (BYTE j=0;j&cbSameCj++) AnalyseResult.cbCardData[cbSameCount-1][cbIndex*cbSameCount+j]=cbCardData[i+j];
//设置索引
i+=cbSameCount-1;
//分析分布
VOID CGameLogic::AnalysebDistributing(const BYTE cbCardData[], BYTE cbCardCount, tagDistributing & Distributing)
//设置变量
ZeroMemory(&Distributing,sizeof(Distributing));
//设置变量
for (BYTE i=0;i&cbCardCi++)
if (cbCardData[i]==0)
//获取属性
BYTE cbCardColor=GetCardColor(cbCardData[i]);
BYTE cbCardValue=GetCardValue(cbCardData[i]);
//分布信息
Distributing.cbCardCount++;
Distributing.cbDistributing[cbCardValue-1][cbIndexCount]++;
Distributing.cbDistributing[cbCardValue-1][cbCardColor&&4]++;
//////////////////////////////////////////////////////////////////////////////////
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：58675次
积分：1301
积分：1301
排名：千里之外
原创：56篇
转载：115篇
(2)(7)(3)(3)(3)(10)(1)(1)(7)(7)(3)(3)(13)(6)(6)(7)(1)(1)(4)(3)(7)(6)(4)(13)(14)(18)(9)(9)判断：斗地主_庆安吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：57,593贴子：
判断：斗地主收藏
农民：A、A、9地主：2、Q、Q、10、10、7、7、5、5、3据说这是网上争执不下的斗地主，地主先出，谁赢？　◇◇◇Girl's elegant demeanor◇◇◇
2017年在职研究生有没有取消，具体的政策有什么变化
这还能玩出花来吗？
我也觉得是地主赢啊。先出3，然后农民出9，地主10
看出来了 农民赢
&别太理会人家背后怎么说你，因为那些比你强的人，根本懒得提起你。诋毁， 本身就是一种仰望。&
出完3? 不要
农民赢，不服来辨，实在不行现场真人实验，赢钱的
2017年在职研究生专科报考条件、本科报考条件
就是明牌和不明牌的问题不要纠结谁赢了
谁先出谁赢
先3，他要9咱拆Q他要拆A2上，打对！他不拆A接着出Q！一个个出！太简单了
地主赢，地主3，农民9，地主10，农民A，地主2，农民pass，地主顺序出对牌，农民pass ，最后地主一张10胜利
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或如何对一件事情做出正确的判断_安利吧_百度贴吧
&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&&签到排名：今日本吧第个签到，本吧因你更精彩，明天继续来努力！
本吧签到人数：0成为超级会员，使用一键签到本月漏签0次！成为超级会员，赠送8张补签卡连续签到：天&&累计签到：天超级会员单次开通12个月以上，赠送连续签到卡3张
关注：97,439贴子：
如何对一件事情做出正确的判断收藏
1全面了解2拥有丰富的知识3客观的推理4正确的分析
登录百度帐号推荐应用
为兴趣而生，贴吧更懂你。或7076人阅读
c++基础（14）
棋牌游戏算法（7）
& &地主算法之判断牌型
& & & & & & & & &&by &wojiushi3344
&&&&&&&&&&&&&&&&&&&&& QQ:
扫描二维码，添加好友，获取更多的斗地主编程技术
& & & & & & & &&&每个游戏都有属于自己的规则，当然地主也不例外，常斗地主的朋友可能知道在斗地主里面一共有13种牌型，你所出的牌必须符合13种的一种才能够出得了牌，这个就叫地主的规则。那么我们下面可以通过一个枚举结构来表示每一种的牌型，在这里我们把错误的牌型也当成是一种牌型。
SINGLE_CARD =1， //单牌
DOUBLE_CARD， //对子
THREE_CARD
BOMB_CARD,//炸弹
THREE_ONE_CARD,//3带1
THREE_TEO_CARD,//3带2
BOMB_TWO_CARD,//四个带2张单牌
BOMB_TWOOO_CARD,//四个带2对
CONNECT_CARD,//连牌
COMPANY_CARD,//连队
AIRCRAFT_CARD,//飞机不带
AIRCRAFT_SINGLE_CARD,//飞机带单牌
AIRCRAFT_DOUBLE_CARD,//飞机带对子
ERROR_CARD
//错误的牌型
& & & & & & & & &那么在编程中我们该怎么来判断一组牌到底该属于哪一种牌型了？？
& & & & & & & &这就是接下来我们将解决的问题，本文中可能有些判断牌型的方法不是很好，如果你有更好的方法，欢迎留言指导！~(@^_^@)~！！
& & & & & & & &首先我们可以根据穷举的方式来罗列一下。在我以前写斗地主的时候我是根据出牌的张数来罗列牌型的，下面我也将使用这种方法，因为没有找到什么更好的方法，嘿嘿！！那就让我们开始吧！
牌的张数 & 可能的牌型
1张牌 & & & & 单牌
2张牌 & & & & 对子（排除对鬼，因为这个在出牌中出现的次数比较少）
3张牌 & & & &3不带
4张牌 & & & 3带一 &炸弹
5张牌 & & & 连牌，3带1对
6,7,8,9.........
这里我们可以用出牌张数5作为分界线，因为5刚好是连牌的起始数并且出牌张数大于5之后就比较的复杂了。
我们首先定义一个数组来存放即将出牌的牌值。
在判断牌型之前将数组排序，排序规则：如果每张牌出现的次数一样，由小到大，如果不一样就将出现次数比较多的牌放在前面。比如（7,7,3,7)排序之后就变为（7,7,7,3），这样便于我们后面的判断。
出牌张数&5
& & & & 我们只需判断第一张和最后一张牌的牌值时候相等（因为我们数组已经按照我们事先的规则排序了），如果相等则直接返回牌的张数，这里牌的张数刚好对应我们前面定义的枚举结构值。如果不相等这里要分情况，当出牌的张数等于4时，判断第一张的牌值是否等于倒数第2张，如果相等我们可以直接返回THREE_ONE_CARD牌型，其余的情况可以直接返回ERROR_CARD 。
JudgeCardTpye(int * pArray,int lenght)
单牌，对子，3不带,炸弹通用算法
if(lenght&5) //小于5张牌
if(intArray[0]==intArray[lengh-1])
if (intArray[0]==intArray[lengh-2]&&lengh==4)
return THREE_ONE_CARD;
出牌张数&=5
当出牌张数大于5张时，所组成的牌型就比较的复杂了，可以有连牌，连对，飞机，4带2等一系列牌型。
我们先来分析一下每种牌型组成的情况
连牌：由所有的单牌组成&
连队：由所有的对子组成
飞机：由3个+对子，或者3个，或者3个+单张
4带2:4个+2张单牌，4个+2对牌，4个+1对牌
写一个计算数组中所有值是否为连续的方法。我们假设这个函数名叫做CheckContinuous，如果全连续返回true，否则返回false
下面是没种牌型的具体检查方法。
连牌牌型：if(CheckContinuous（出牌数组）==true）出牌数组中所有牌的牌值必须小于2
连队牌型：将出牌数组中的对子，挨个抽出，看是否还有剩余的牌，如果有剩余的牌就说明不能组成连队，则进行下面牌型的判断。如果没有剩余的牌，再根据判断连牌的方法来判断。（筛选条件：张数&=6张&&张数%2==0）
飞机和4带2就比较的复杂了，因为这2种牌型不像上面2种那样组成的牌比较单一，这2种牌型可以由很多种牌来组成。
接下来我们就可以定义一个结构体，来记录每种牌（单个，对子，3个，4个）出现的次数。最后我们只要根据结构体中每种牌出现的数量就很容易判断出到底是什么牌了。
struct &CRAD_INDEX
vector &int & &single_//记录单张的牌
vector&int& doble_ //记录对子的牌
vector&int &three_//记录3张
vector&int& four_//记录张
飞机牌型：
我们把能组成飞机的所有牌型列举出来：&,
通过一个遍历记录方法，上面结构体的值就变成这样了。
333444 & & & & & & & & & &&
single_index & & & & & & &空
doble_index & & & & & & &&空
three_index & & & & & & & 3,4
four_index & & & & & & & & &空
& & & & & & & & & & & &
single_index & & & & & & 5,6
doble_index & & & & & &&&空
three_index & & & & & & & 3,4
four_index & & & & & & & & 空
& & & & & & & & & & & &
single_index & & & & & & &空
doble_index & & & & & & &5,6
three_index & & & & & & & 3,4
four_index & & & & & & & & 空
这3种飞机牌型都有一个共同点，three_index 中的数据必须为连续的并且four_index 必须为空。这个也是最开始筛选的条件之一，如果这个条件都不满足则直接返回。
如果上面个条件满足，接下来计算一下牌的数量就OK了
飞机不带：three_index .sziz()*3==出牌的数量&&single_index+doble_index &==0
飞机带1张 ：three_index .sziz()*3+single_index.size()==出牌的数量&&doble_index.size()==0
飞机带1对：three_index .sziz()*3+doble_index.size()*2==出牌的数量&&single_index.size()==0
同样4带2也可以这样来分析
4带2牌型（牌张数%2==0）
还是像上面一样来列举出具体的牌型来判断
single_index & & & & & & &2,3
doble_index & & & & & & 空
three_index & & & & & & & 空
four_index & & & & & & & & 4
single_index & & & & & & 空
doble_index & & & & & & 2
three_index & & & & & & & 空
four_index & & & & & & & & 4
single_index & & & & & & 空
doble_index & & & & & & 2，3
three_index & & & & & & & 空
four_index & & & & & & & & 4
首先找出必须满足的条件：four_index .size()必须等于1，并且出牌张数%2==0，并且three_index.size（）==0
如果这个条件不满足则直接进行下面牌型的判断
如果满足就计算牌的张数
第一种情况： 带2张单牌
（(four_index.size()==1&&single_index.size()==2）||（four_index.size()+single_index.size()*4==出牌的张数））
第二种情况 ：带2对牌
（(four_index.size()==1&&doble_index.size()==1）||（four_index.size()*2+single_index.size()*4==出牌的张数））
（(four_index.size()==1&&doble_index.size()==2）||（four_index.size()*2+single_index.size()*4==出牌的张数））
至此所有的牌型就判断完毕了！！如果一副牌上面所有的牌型都不满足则是错误的牌型！！！小弟技术有限，如果你有更好的方法欢迎留言指导。
参考知识库
* 以上用户言论只代表其个人观点，不代表CSDN网站的观点或立场
访问：142262次
积分：1856
积分：1856
排名：第17699名
原创：26篇
转载：12篇
评论：115条
棋牌游戏开发公司 QQ： 电话：
&&大话设计模式&&
阅读：57017
(1)(2)(2)(1)(3)(1)(1)(1)(1)(1)(4)(1)(2)(5)(13)