斗地主AI算法——第六章の牌型判断

最新推荐文章于 2021-03-07 12:52:34 发布
最新推荐文章于 2021-03-07 12:52:34 发布
阅读量9.2k 收藏 16
点赞数 8
分类专栏： C/C++ 游戏算法 文章标签： ai 算法 斗地主 C++ 棋牌算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/sm9sun/article/details/70821453
版权

本章实现了上一章提到的检查当前是否只是一手牌函数ins_SurCardsType


/*
检查剩余的牌是否只是一手牌

是：  返回手牌类型数据
不是：返回错误类型（cgERROR）
*/
CardGroupData ins_SurCardsType(int arr[]);


输入很简单，就是一个状态数组。输出是手牌类型结构

//牌型组合数据结构
struct CardGroupData
{
	//枚举类型
	CardGroupType cgType=cgERROR;
	//该牌的价值
	int  nValue=0;
	//含牌的个数
	int  nCount=0;
	//牌中决定大小的牌值，用于对比
	int nMaxCard=0;

};


其中  cgType通过枚举获取，nValue计算规则参考第四章权值定义，nCount可以通过引入数组算出，nMaxCard是用于比大小的那个牌值。

首先我们要计算出剩余手牌个数，因为这样便于快速筛选分支。


	int nCount = 0;
	for (int i = 3; i < 18; i++)
	{
		nCount += arr[i];
	}

	CardGroupData retCardGroupData;
	retCardGroupData.nCount = nCount;

以单牌为例，若该牌型满足单牌，则nCount==1，然后我们再找出那张牌。 

	//单牌类型
	if (nCount == 1)
	{
		//用于验证的变量
		int prov = 0;
		int SumValue = 0;
		for (int i = 3; i < 18; i++)
		{
			if (arr[i] == 1)
			{
				SumValue = i - 10;
				prov++;
				retCardGroupData.nMaxCard = i;
			}
		}
		if (prov == 1)
		{
			retCardGroupData.cgType = cgSINGLE;
			retCardGroupData.nValue= SumValue;
			return retCardGroupData;
		}
	}

对牌，三牌，炸弹同理。


三带一的话需要设置两个验证变量，例如三带一单

if (nCount == 4)
	{
		//用于验证的变量
		int prov1 = 0;
		int prov2 = 0;
		int SumValue = 0;
		for (int i = 3; i < 18; i++)
		{
			if (arr[i] == 3)
			{
				SumValue = i - 10;
				prov1++;
				retCardGroupData.nMaxCard = i;

			}
			if (arr[i] == 1)
			{
				prov2++;
			}

		}
		if (prov1 == 1 && prov2 == 1)
		{
			retCardGroupData.cgType = cgTHREE_TAKE_ONE;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}

三带一对 

	if (nCount == 5)
	{
		//用于验证的变量
		int prov1 = 0;
		int prov2 = 0;
		int SumValue = 0;
		for (int i = 3; i < 16; i++)
		{
			if (arr[i] == 3)
			{
				SumValue = i - 10;
				prov1++;
				retCardGroupData.nMaxCard = i;

			}
			if (arr[i] == 2)
			{
				prov2++;

			}
		}


这里我们看，循环改为3~15，因为三牌、对牌是不包括王的。


四带二同理，不过四带二要考虑到带出去的那两张牌型是不是相同

	if (nCount == 6)
	{
		//用于验证的变量
		int prov1 = 0;
		int prov2 = 0;
		int SumValue = 0;
		for (int i = 3; i < 18; i++)
		{
			if (arr[i] == 4)
			{
				SumValue = (i - 3) / 2;
				prov1++;
				retCardGroupData.nMaxCard = i;

			}
			if (arr[i] == 1|| arr[i] == 2)
			{
				prov2+= arr[i];
			}
		}

		if (prov1 == 1 && prov2 == 2)
		{
			retCardGroupData.cgType = cgFOUR_TAKE_ONE;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}

判断顺子的话用一个变量记录长度，若当前i值等于0并且之前存在i大于0的情况下，即这个长度就是顺子的长度

例如单连：

	if (nCount >= 5)
	{
		//用于验证的变量
		int prov = 0;
		int SumValue = 0;
		int i;
		for (i = 3; i < 15; i++)
		{
			if (arr[i] == 1)
			{
				prov++;
			}
			else
			{
				if (prov != 0)
				{
					break;
				}

			}
		}
		SumValue = i - 10;

		if (prov == nCount)
		{
			retCardGroupData.nMaxCard = i-1;
			retCardGroupData.cgType = cgSINGLE_LINE;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}


王炸就更好判断了，直接判断arr[17]和arr[16]就好了


下面贴出完整代码：


/*
检查剩余的牌是否只是一手牌

是：  返回手牌类型数据
不是：返回错误类型（cgERROR）
*/
CardGroupData ins_SurCardsType(int arr[])
{

	int nCount = 0;
	for (int i = 3; i < 18; i++)
	{
		nCount += arr[i];
	}

	CardGroupData retCardGroupData;
	retCardGroupData.nCount = nCount;


	//单牌类型
	if (nCount == 1)
	{
		//用于验证的变量
		int prov = 0;
		int SumValue = 0;
		for (int i = 3; i < 18; i++)
		{
			if (arr[i] == 1)
			{
				SumValue = i - 10;
				prov++;
				retCardGroupData.nMaxCard = i;
			}
		}
		if (prov == 1)
		{
			retCardGroupData.cgType = cgSINGLE;
			retCardGroupData.nValue= SumValue;
			return retCardGroupData;
		}
	}
	//对牌类型
	if (nCount == 2)
	{
		//用于验证的变量
		int prov = 0;
		int SumValue = 0;
		int i = 0;
		for (i = 3; i < 16; i++)
		{
			if (arr[i] == 2)
			{
				SumValue = i - 10;
				prov++;
				retCardGroupData.nMaxCard = i;
			}
		}
		if (prov == 1)
		{
			retCardGroupData.cgType = cgDOUBLE;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}
	//三条类型
	if (nCount == 3)
	{
		//用于验证的变量
		int prov = 0;
		int SumValue = 0;
		int i = 0;
		for (i = 3; i < 16; i++)
		{
			if (arr[i] == 3)
			{
				SumValue = i - 10;
				prov++;
				retCardGroupData.nMaxCard = i;
			}
		}
		if (prov == 1)
		{
			retCardGroupData.cgType = cgTHREE;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}
	//三带一单
	if (nCount == 4)
	{
		//用于验证的变量
		int prov1 = 0;
		int prov2 = 0;
		int SumValue = 0;
		for (int i = 3; i < 18; i++)
		{
			if (arr[i] == 3)
			{
				SumValue = i - 10;
				prov1++;
				retCardGroupData.nMaxCard = i;

			}
			if (arr[i] == 1)
			{
				prov2++;
			}

		}
		if (prov1 == 1 && prov2 == 1)
		{
			retCardGroupData.cgType = cgTHREE_TAKE_ONE;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}
	//三带一对
	if (nCount == 5)
	{
		//用于验证的变量
		int prov1 = 0;
		int prov2 = 0;
		int SumValue = 0;
		for (int i = 3; i < 16; i++)
		{
			if (arr[i] == 3)
			{
				SumValue = i - 10;
				prov1++;
				retCardGroupData.nMaxCard = i;

			}
			if (arr[i] == 2)
			{
				prov2++;

			}
		}
		if (prov1 == 1 && prov2 == 1)
		{
			retCardGroupData.cgType = cgTHREE_TAKE_TWO;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}
	//四带两单
	if (nCount == 6)
	{
		//用于验证的变量
		int prov1 = 0;
		int prov2 = 0;
		int SumValue = 0;
		for (int i = 3; i < 18; i++)
		{
			if (arr[i] == 4)
			{
				SumValue = (i - 3) / 2;
				prov1++;
				retCardGroupData.nMaxCard = i;

			}
			if (arr[i] == 1|| arr[i] == 2)
			{
				prov2+= arr[i];
			}
		}

		if (prov1 == 1 && prov2 == 2)
		{
			retCardGroupData.cgType = cgFOUR_TAKE_ONE;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}
	//四带两对
	if (nCount == 8)
	{
		//用于验证的变量
		int prov1 = 0;
		int prov2 = 0;
		int SumValue = 0;
		for (int i = 3; i < 16; i++)
		{
			if (arr[i] == 4)
			{
				SumValue = (i - 3) / 2;

				prov1++;
				retCardGroupData.nMaxCard = i;
			}
			if (arr[i] == 2|| arr[i] == 4)
			{
				prov2+= arr[i]/2;

			}
		}
               //注意这里prov2==4因为四牌也是两个对
		if (prov1 == 1 && prov2 == 4)
		{
			retCardGroupData.cgType = cgFOUR_TAKE_TWO;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}
	//炸弹类型
	if (nCount == 4)
	{
		//用于验证的变量
		int prov = 0;
		int SumValue = 0;
		for (int i = 3; i < 16; i++)
		{
			if (arr[i] == 4)
			{
				SumValue += i - 3 + 7;
				prov++;
				retCardGroupData.nMaxCard = i;
			}
		}
		if (prov == 1)
		{
			retCardGroupData.cgType = cgBOMB_CARD;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}
	//王炸类型
	if (nCount == 2)
	{
		int SumValue = 0;
		if (arr[17] > 0 && arr[16] > 0)
		{
			SumValue = 20;
			retCardGroupData.nMaxCard = 17;
			retCardGroupData.cgType = cgKING_CARD;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}
	//单连类型
	if (nCount >= 5)
	{
		//用于验证的变量
		int prov = 0;
		int SumValue = 0;
		int i;
		for (i = 3; i < 15; i++)
		{
			if (arr[i] == 1)
			{
				prov++;
			}
			else
			{
				if (prov != 0)
				{
					break;
				}

			}
		}
		SumValue = i - 10;

		if (prov == nCount)
		{
			retCardGroupData.nMaxCard = i-1;
			retCardGroupData.cgType = cgSINGLE_LINE;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}
	//对连类型
	if (nCount >= 6)
	{
		//用于验证的变量
		int prov = 0;
		int SumValue = 0;
		int i;
		for (i = 3; i < 15; i++)
		{
			if (arr[i] == 2)
			{
				prov++;
			}
			else
			{
				if (prov != 0)
				{
					break;
				}

			}
		}
		SumValue = i - 10;

		if (prov * 2 == nCount)
		{
			retCardGroupData.nMaxCard = i - 1;
			retCardGroupData.cgType = cgDOUBLE_LINE;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}
	//三连类型
	if (nCount >= 6)
	{
		//用于验证的变量
		int prov = 0;

		int SumValue = 0;
		int i;
		for (i = 3; i < 15; i++)
		{
			if (arr[i] == 3)
			{
				prov++;
			}
			else
			{
				if (prov != 0)
				{
					break;
				}

			}
		}
		SumValue = (i - 3) / 2;

		if (prov * 3 == nCount)
		{
			retCardGroupData.nMaxCard = i - 1;
			retCardGroupData.cgType = cgTHREE_LINE;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}
	//三带一连类型
	if (nCount >= 8)
	{
		//用于验证的变量
		int prov1 = 0;
		int SumValue = 0;
		int i, j;
		for (i = 3; i < 15; i++)
		{
			if (arr[i] >= 3)
			{
				prov1++;
			}
			else
			{
				if (prov1 != 0)
				{
					break;
				}

			}
		}
		SumValue = (i - 3)/2;
		if (prov1 * 4 == nCount)
		{
			retCardGroupData.nMaxCard = i - 1;
			retCardGroupData.cgType = cgTHREE_TAKE_ONE_LINE;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}

	}
	//三带二连类型
	if (nCount >= 10)
	{
		//用于验证的变量
		int prov1 = 0;
		int prov2 = 0;
		int SumValue = 0;
		int i, j;
		for (i = 3; i < 15; i++)
		{
			if (arr[i] == 3)
			{
				prov1++;
			}
			else
			{
				if (prov1 != 0)
				{
					break;
				}
			}
		}
		for (j = 3; j < 16; j++)
		{
			if (arr[j] == 2|| arr[j] == 4)
			{
				prov2+= arr[j]/2;
			}
		}
		SumValue = (i - 3) / 2;
		if (prov1 == prov2&&prov1 * 5 == nCount)
		{
			retCardGroupData.nMaxCard = i - 1;
			retCardGroupData.cgType = cgTHREE_TAKE_TWO_LINE;
			retCardGroupData.nValue = SumValue;
			return retCardGroupData;
		}
	}

	retCardGroupData.cgType = cgERROR;
	return retCardGroupData;
}

/*
检查剩余的牌是否只是一手牌（vector重载）

是：  返回手牌类型数据
不是：返回错误类型（cgERROR）
*/
CardGroupData ins_SurCardsType(vector<int>list)
{
	int arr[18];
	memset(arr, 0, sizeof(arr));
	for (vector<int>::iterator iter = list.begin(); iter != list.end(); iter++)
	{
		arr[*iter]++;
	}
	return ins_SurCardsType(arr);
}

怎么样，这么多牌型枚举是不是很头疼？放心吧，接下来的主动出牌算法、被动出牌算法的枚举会更头疼！


所以~从下一章开始我们就要讲出牌的策略了，首先是被动出牌。


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

九日王朝
关注
专栏目录
unity开发 斗地主算法—判断手里的牌是否有大于上家的牌（是否显示要不起按钮）
csdn_cjt的博客
11-27 2008
牌型的定义在http://blog.csdn.net/csdn_cjt/article/details/78593140 第一章 这是第二章 下面是代码 #region isShowOutCardBtn public static bool isShowOutCardBtn(List myCards, List lastCards, DD
DouZero+:通过对手建模和教练引导学习改进斗地主AI
最新发布
步子哥的博客
06-28 935
作者:赵友鹏、赵健、胡训涵、周文罡、李厚强摘要: 近年来,深度强化学习在各种完全信息和不完全信息游戏中取得了重大突破。在这些游戏中,斗地主作为中国流行的纸牌游戏,由于其不完全信息、庞大的状态空间、合作元素以及每回合大量可能的行动,非常具有挑战性。最近,一个名为DouZero的斗地主AI系统被提出。DouZero使用传统的蒙特卡洛方法结合深度神经网络和自我对弈程序进行训练,无需抽象人类先验知识,已经超越了所有现有的斗地主AI程序。在本工作中,我们提出通过引入对手建模来增强DouZero。此外,我们提出了一种新
斗地主系列之牌型判断
热门推荐
hfreeman2008的专栏
07-13 1万+
参考资料： 1.
斗地主基本牌型判定
随风的博客
10-15 490
斗地主基本牌型判定
斗地主算法1判断牌型
GA博客
04-07 2847
using UnityEngine; using System.Collections.Generic; /// &lt;summary&gt; /// 牌型 3 4 5 6 7 8 9 10 11(J) 12(Q) 13(K) 14(A) 15(2) 16(小王) 17(大王) /// &lt;/summary&gt; public class DDZ_CardType { public...
java 斗地主出牌算法_斗地主AI算法——第七章の被动出牌(1)
weixin_35361243的博客
03-07 639
哎，之前扯了那么多蛋，终于讲出牌了！本章开始讲被动出牌的逻辑算法。首先我们先把架子搭起来，被动出牌我们肯定是要知道场上目前打出的是什么牌型。在第二章数据结构里我们定义过，游戏全局类里面有一个存放当前牌型结构的成员，即//当前打出牌的类型数据，被动出牌时玩家根据这里做出筛选CardGroupDatauctNowCardGroup;我们即将通过他进行类型的筛选，所以肯定是要枚举各类牌型的，也就是这个...
易语言-new斗地主牌型判断5易语言
07-01
《易语言-new斗地主牌型判断5易语言》是一个基于易语言开发的程序，用于实现斗地主游戏中的牌型判断功能。易语言是一种中国本土的编程语言，旨在降低编程难度，让更多人能参与到软件开发中来。在这个源码例程中，...
易语言源码斗地主游戏牌型判断易语言源码.rar
02-16
易语言源码斗地主游戏牌型判断易语言源码.rar 易语言源码斗地主游戏牌型判断易语言源码.rar 易语言源码斗地主游戏牌型判断易语言源码.rar 易语言源码斗地主游戏牌型判断易语言源码.rar 易语言源码斗地主游戏牌型...
斗地主牌型判断和比较.zip
10-18
本项目提供了一个使用JavaScript编写的斗地主牌型判断和比较的源码，通过深入分析这段代码，我们可以学习到如何在编程中实现复杂的逻辑判断以及一些算法优化技巧。 首先，让我们来看看"ddz.html"这个文件。在HTML...
斗地主AI 算法
06-04
【斗地主AI算法】是一种在计算机程序中实现人工智能，使其能够模拟人类玩家在斗地主游戏中的策略和决策过程的技术。在这个C#项目中，开发者已经创建了一个斗地主机器人，它能够根据预设的规则和算法进行智能打牌。...
斗地主牌型相关算法
03-02
lua实现斗地主中的牌型判断，牌的比较，出牌提示的算法
斗地主AI，斗地主机器人
11-28
实现斗地主AI算法，已经测试逻辑的一些接口，程序用MFC实现了一个单机版的都地主，效果还不错
斗地主AI程序
03-22
斗地主AI程序, 单机测试版本, 欢迎大家提出建议
单机斗地主带AI
11-28
单机斗地主完整代码 自带AI “人工智能”（Artificial Intelligence）简称AI。它是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。人工智能研究如何用计算机去模拟、延伸和扩展人的智能；如何把计算机用得更聪明；如何设计和建造具有高智能水平的计算机应用系统；如何设计和制造更聪明的计算机以及智能水平更高的智能计算机
地主AI算法实现
棋牌游戏开发
06-08 1万+
斗地主AI算法实现 一（拆牌）               by   wojiushi3344                QQ: 513670524                                  转载请说明出处                    源代码下载                   ps: 前面已经写了几篇地主游戏的基本算法实现，今天来讲讲单机地
斗地主AI
追求卓越
03-22 1786
下载: https://download.csdn.net/download/larry_zeng1/11992337 （旧版本：https://download.csdn.net/download/larry_zeng1/11049219）
斗地主AI研究
BraidTim的博客
01-07 582
斗地主AI研究 最近在研究斗地主的AI程序，看了一些别人的帖子，大部分都是尝试给牌一个主动定权值来作为主要判断依据 基于只要是人为给的参数调起来就麻烦的原则，自己设计了一套以牌型和当前该牌型大小在所有该牌型组合中的位置为基础的判断标准，希望能提供一种不一样的思路。 第一次写csdn，不太会，先写个开头，剩下的后面补，也算再次理清自己的思路。 ...
斗地主AI算法解析
斗地主AI算法是一种在计算机科学领域，特别是游戏人工智能中的一个重要研究课题。它涉及到人工智能、博弈论、概率论、搜索算法等多个方面的知识。斗地主是一种三人对战的扑克游戏，AI在其中的目标是通过模拟人类玩家...
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值