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

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


上一章已经排除了飞机、三带等牌型，那么除去炸弹王炸以外，我们只剩下单牌、对牌、三牌以及单顺、双顺、三顺了。


首先说单牌、对牌、三牌。其逻辑基本一样，只是出牌的个数有差别，即：如果该i牌数量满足这种牌型要求，即先打出，计算其剩余价值。

			//出单牌
			if (clsHandCardData.value_aHandCardList[i] > 0)
			{
				clsHandCardData.value_aHandCardList[i]--;
				clsHandCardData.nHandCardCount--;
				HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
				clsHandCardData.value_aHandCardList[i]++;
				clsHandCardData.nHandCardCount++;
				if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
				{
					BestHandCardValue = tmpHandCardValue;
					BestCardGroup= get_GroupData(cgSINGLE, i, 1);
				}
			}
			//出对牌
			if (clsHandCardData.value_aHandCardList[i] > 1)
			{
				//尝试打出一对牌，估算剩余手牌价值
				clsHandCardData.value_aHandCardList[i] -= 2;
				clsHandCardData.nHandCardCount -= 2;
				HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
				clsHandCardData.value_aHandCardList[i] += 2;
				clsHandCardData.nHandCardCount += 2;

				//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
				if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
				{
					BestHandCardValue = tmpHandCardValue;
					BestCardGroup = get_GroupData(cgDOUBLE, i, 2);
				}
			}
			//出三牌
			if (clsHandCardData.value_aHandCardList[i] > 2)
			{
				clsHandCardData.value_aHandCardList[i] -= 3;
				clsHandCardData.nHandCardCount -= 3;
				HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
				clsHandCardData.value_aHandCardList[i] += 3;
				clsHandCardData.nHandCardCount += 3;

				//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
				if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
				{
					BestHandCardValue = tmpHandCardValue;
					BestCardGroup = get_GroupData(cgTHREE, i, 3);
				}
			}

至于顺子的算法，和被动出牌的有一点点差别，就是因为没有了数量限制，所以需要遍历以i牌为起点可以组成的所有顺子。 

//出单顺
			if (clsHandCardData.value_aHandCardList[i] > 0)
			{
				int prov = 0;
				for (int j = i; j < 15; j++)
				{
					if(clsHandCardData.value_aHandCardList[j]>0)
					{
						prov++;
					}
					else
					{
						break;
					}
					if (prov >= 5)
					{

						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] --;
						}
						clsHandCardData.nHandCardCount -= prov;
						HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] ++;
						}
						clsHandCardData.nHandCardCount += prov;

						//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
						if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
						{
							BestHandCardValue = tmpHandCardValue;
							BestCardGroup = get_GroupData(cgSINGLE_LINE, j, prov);
						}
					}
				}
				
			}
			//出双顺
			if (clsHandCardData.value_aHandCardList[i] > 1)
			{
				int prov = 0;
				for (int j = i; j < 15; j++)
				{
					if (clsHandCardData.value_aHandCardList[j]>1)
					{
						prov++;
					}
					else
					{
						break;
					}
					if (prov >= 3)
					{

						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] -=2;
						}
						clsHandCardData.nHandCardCount -= prov*2;
						HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] +=2;
						}
						clsHandCardData.nHandCardCount += prov*2;

						//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
						if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
						{
							BestHandCardValue = tmpHandCardValue;
							BestCardGroup = get_GroupData(cgDOUBLE_LINE, j, prov*2);
						}
					}
				}
			}
			//出三顺
			if(clsHandCardData.value_aHandCardList[i] > 2)
			{
				int prov = 0;
				for (int j = i; j < 15; j++)
				{
					if (clsHandCardData.value_aHandCardList[j]>2)
					{
						prov++;
					}
					else
					{
						break;
					}
					if (prov >= 2)
					{

						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] -= 3;
						}
						clsHandCardData.nHandCardCount -= prov * 3;
						HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] += 3;
						}
						clsHandCardData.nHandCardCount += prov * 3;

						//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
						if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
						{
							BestHandCardValue = tmpHandCardValue;
							BestCardGroup = get_GroupData(cgTHREE_LINE, j, prov * 3);
						}
					}
				}
			}

因为本策略是必须解决掉至少一个i牌的，所以出牌操作放在循环内进行，也就是说，只要你不是炸3，若你手牌有3，在处理3时一定会return  就绝对不会再走到4。 


if (BestCardGroup.cgType == cgERROR)
			{

			}
			else if (BestCardGroup.cgType == cgSINGLE)
			{
				clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
				clsHandCardData.uctPutCardType = BestCardGroup;
			}
			else if (BestCardGroup.cgType == cgDOUBLE)
			{
				clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
				clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
				clsHandCardData.uctPutCardType = BestCardGroup;
			}
			else if (BestCardGroup.cgType == cgTHREE)
			{
				clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
				clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
				clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
				clsHandCardData.uctPutCardType = BestCardGroup;
			}
			else if (BestCardGroup.cgType == cgSINGLE_LINE)
			{
				for (int j = BestCardGroup.nMaxCard- BestCardGroup.nCount+1; j <= BestCardGroup.nMaxCard; j++)
				{
					clsHandCardData.value_nPutCardList.push_back(j);
				}
				clsHandCardData.uctPutCardType = BestCardGroup;
			}
			else if (BestCardGroup.cgType == cgDOUBLE_LINE)
			{
				for (int j = BestCardGroup.nMaxCard - (BestCardGroup.nCount/2) + 1; j <= BestCardGroup.nMaxCard; j++)
				{
					clsHandCardData.value_nPutCardList.push_back(j);
					clsHandCardData.value_nPutCardList.push_back(j);
				}
				clsHandCardData.uctPutCardType = BestCardGroup;
			}
			else if (BestCardGroup.cgType == cgTHREE_LINE)
			{
				for (int j = BestCardGroup.nMaxCard - (BestCardGroup.nCount / 3) + 1; j <= BestCardGroup.nMaxCard; j++)
				{
					clsHandCardData.value_nPutCardList.push_back(j);
					clsHandCardData.value_nPutCardList.push_back(j);
					clsHandCardData.value_nPutCardList.push_back(j);
				}
				clsHandCardData.uctPutCardType = BestCardGroup;
			}
			else if (BestCardGroup.cgType == cgTHREE_TAKE_ONE)
			{
				clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
				clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
				clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
				clsHandCardData.value_nPutCardList.push_back(tmp_1);
				clsHandCardData.uctPutCardType = BestCardGroup;
			}
			else if (BestCardGroup.cgType == cgTHREE_TAKE_TWO)
			{
				clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
				clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
				clsHandCardData.value_nPutCardList.push_back(BestCardGroup.nMaxCard);
				clsHandCardData.value_nPutCardList.push_back(tmp_1);
				clsHandCardData.value_nPutCardList.push_back(tmp_1);
				clsHandCardData.uctPutCardType = BestCardGroup;
			}
			else if (BestCardGroup.cgType == cgTHREE_TAKE_ONE_LINE)
			{
				for (int j = BestCardGroup.nMaxCard - (BestCardGroup.nCount / 4) + 1; j <= BestCardGroup.nMaxCard; j++)
				{
					clsHandCardData.value_nPutCardList.push_back(j);
					clsHandCardData.value_nPutCardList.push_back(j);
					clsHandCardData.value_nPutCardList.push_back(j);
				}

				if (BestCardGroup.nCount / 4 == 2)
				{
					clsHandCardData.value_nPutCardList.push_back(tmp_1);
					clsHandCardData.value_nPutCardList.push_back(tmp_2);
				}
				if (BestCardGroup.nCount / 4 == 3)
				{
					clsHandCardData.value_nPutCardList.push_back(tmp_1);
					clsHandCardData.value_nPutCardList.push_back(tmp_2);
					clsHandCardData.value_nPutCardList.push_back(tmp_3);
				}
				if (BestCardGroup.nCount / 4 == 4)
				{
					clsHandCardData.value_nPutCardList.push_back(tmp_1);
					clsHandCardData.value_nPutCardList.push_back(tmp_2);
					clsHandCardData.value_nPutCardList.push_back(tmp_3);
					clsHandCardData.value_nPutCardList.push_back(tmp_4);
				}

				clsHandCardData.uctPutCardType = BestCardGroup;
			}
			else if (BestCardGroup.cgType == cgTHREE_TAKE_TWO_LINE)
			{
				for (int j = BestCardGroup.nMaxCard - (BestCardGroup.nCount / 5) + 1; j <= BestCardGroup.nMaxCard; j++)
				{
					clsHandCardData.value_nPutCardList.push_back(j);
					clsHandCardData.value_nPutCardList.push_back(j);
					clsHandCardData.value_nPutCardList.push_back(j);
				}
				if (BestCardGroup.nCount / 5 == 2)
				{
					clsHandCardData.value_nPutCardList.push_back(tmp_1);
					clsHandCardData.value_nPutCardList.push_back(tmp_1);
					clsHandCardData.value_nPutCardList.push_back(tmp_2);
					clsHandCardData.value_nPutCardList.push_back(tmp_2);
				}
				if (BestCardGroup.nCount / 5 == 3)
				{
					clsHandCardData.value_nPutCardList.push_back(tmp_1);
					clsHandCardData.value_nPutCardList.push_back(tmp_1);
					clsHandCardData.value_nPutCardList.push_back(tmp_2);
					clsHandCardData.value_nPutCardList.push_back(tmp_2);
					clsHandCardData.value_nPutCardList.push_back(tmp_3);
					clsHandCardData.value_nPutCardList.push_back(tmp_3);
				}
				clsHandCardData.uctPutCardType = BestCardGroup;
			}
			return;

至此，主动出牌的所有逻辑均已实现，同时整个斗地主算法也基本完成了。接下来我们便可写一些测试模块来进行整合联调。


敬请关注下一章：斗地主AI算法——第十五章の测试模块

九日王朝
关注
专栏目录
2024 华为OD机试（JavaScript）真题【E卷+A卷+B卷+C卷+D卷】目录
MISAYAONE的博客
02-10 6万+
华为OD机试真题（JavaScript）
斗地主AI 算法
06-04
斗地主机器人模拟打牌 C# 代码 代码能运行，供大家参考
斗地主算法之点选牌
棋牌游戏开发
05-15 9285
斗地主算法之点选牌                            -------BY wojiushi3344                                      QQ：513670524               PS:最近找了2个朋友主准备把斗地主游戏重写，由于种种原因今天还没有开始，所以先把基本的算法写一写，为以后写项目做准备。如果你对斗地主游戏比较感兴
DouZero+:通过对手建模和教练引导学习改进斗地主AI
最新发布
步子哥的博客
06-28 935
作者:赵友鹏、赵健、胡训涵、周文罡、李厚强摘要: 近年来,深度强化学习在各种完全信息和不完全信息游戏中取得了重大突破。在这些游戏中,斗地主作为中国流行的纸牌游戏,由于其不完全信息、庞大的状态空间、合作元素以及每回合大量可能的行动,非常具有挑战性。最近,一个名为DouZero的斗地主AI系统被提出。DouZero使用传统的蒙特卡洛方法结合深度神经网络和自我对弈程序进行训练,无需抽象人类先验知识,已经超越了所有现有的斗地主AI程序。在本工作中,我们提出通过引入对手建模来增强DouZero。此外,我们提出了一种新
斗地主AI算法——第十六章の样例分析
九日王朝
04-27 6029
上一章，我们已经完成了测试模块的开发。至此我们已经可以进行整体测试了。本章主要内容就是随机生成了一些样例并进行分析。 实际上整个开发过程绝大部分时间都是用在样例分析上，通过样例给出的返回操作分析自己设计的策略是否合理，然后不断的调整策略，调整权值等等。 这个过程持续了蛮久的，而且很多地方都反复的修改，感觉git都快要被我玩坏了。 下面具体拿出一组测试数据进行简单的分析 发牌
斗地主ai机器人算法分析
12-15
人机对战，可以对手牌分析，叫地主，出牌，出牌分析。
斗地主AI算法——第七章の被动出牌(1)
九日王朝
04-26 9398
哎，之前扯了那么多蛋，重要讲出牌了！ 本章开始讲被动出牌的逻辑算法。首先我们先把架子搭起来，被动出牌我们肯定是要知道场上目前打出的是什么牌型。 在第二章数据结构里我们定义过，游戏全局类里面有一个存放当前牌型结构的成员，即 //当前打出牌的类型数据，被动出牌时玩家根据这里做出筛选 CardGroupData uctNowCardGroup; 我们即将通过他进行类型的筛选，所以整个
斗地主老是输？一起用Python做个AI出牌器！
m0_51491785的博客
09-25 961
前言 最近在网上看到一个有意思的开源项目，基于快手团队开发的开源AI斗地主——DouZero做的一个“成熟”的AI，项目开源地址【https://github.com/tianqiraf/DouZero_For_HappyDouDiZhu – tianqiraf】。 今天我们就一起来学习下是如何制作一个基于DouZero的出牌器，看看AI是如何来帮助斗地主的！ 一、核心功能设计 首先这款出牌器是基于DouZero开发的，核心是需要利用训练好的AI模型来帮住我们，给出最优出牌方案。 其次关于出牌器，先要
扑克牌游戏程序——人机对抗
m0_62205773的博客
05-05 4028
编写扑克牌游戏程序，初步设定玩家是人机对抗，每人各抓12张牌，游戏规则是每次只能出一张牌，投骰子决定谁先出牌。点数大的管住点数小的。如果管不住对方时就不出牌,让对方出牌。先出完牌的一方为赢。权值大小规定如下（从大到小）：13，12，11，10，9，8，7，6，5，4，3，2，1。花色：方片，红桃，黑桃，梅花。 总体流程图如下： 轮流出牌流程图如下： 全局变量如下： jk=[] #一副扑克牌 cp=[] #计算机手中的牌 ps=[] #人手中的牌 d...
Java写的斗地主游戏源码
weixin_34190136的博客
11-04 6046
源码下载在最后我们的前年的课设要求做一个斗地主程序，当时正在愁如何做界面，当时刚好在学习C#，于是就用C#完成了这个程序。一方面，当时我C#功底还很差（其实现在也不怎么样），很多地方用了“笨办法”，实现的比较幼稚，程序效率很低，另一方面感觉很对不起老师，因为做这个程序的本意是研究斗地主程序的AI出牌等等算法相关的东西，而我却几乎忽略了这些内容。（我会好好学习算法的……^-^）最可怕的是，由于当时时...
博弈论
weixin_45743707的博客
10-07 1831
博弈论SG函数SG函数的定义SG函数的和定理get_GS SG函数 SG函数的定义 先定义mex(minimal excludant)运算，这是施加于一个集合的运算，表最小的不属于这个集合的非负整数。例如mex{0,1,2,4}=3、mex{2,3,5}=0、mex{}=0。 SG函数的和 游戏的和的SG函数值等于他包含的各个子游戏SG函数值的异或和 定理 游戏的某个局面必胜，当且仅当该局面对应节点的SG函数值大于0 游戏的某个局面必败，当且仅当该局面对应节点的SG函数值等于0 get_GS ...
c++ SDK 斗地主 AI 算法
12-20
C++ DX制作的小游戏->斗地主写的不是很好，问题多多，如果你有什么异议请联系我:piont_s21@163.com
斗地主AI程序
03-22
斗地主AI程序, 单机测试版本, 欢迎大家提出建议
斗地主AI，斗地主机器人
11-28
实现斗地主AI算法，已经测试逻辑的一些接口，程序用MFC实现了一个单机版的都地主，效果还不错
斗地主核心算法
03-09
斗地主的核心相关算法，机器人和出牌提示可以在此基础上继续完善
斗地主ai算法
daoer_sofu的专栏
05-18 1187
牌的识别 出牌分为主动出牌和被动出牌，主动出牌只要比对方大就行，算法比较简单，被动出牌，则需要帅选出牌的组合，计算出最快的出牌策略，以最小的步长获取胜利 sequence = ['3', '4', '5', '6', '7', '8', '9', '10', 'j', 'q', 'k', '1', '2', 'xw', 'dw'] card = ['单牌', '对牌', '三张', '三带一', '单顺', '双顺', '三顺', '飞机','炸弹','四带二'] def to_
评论 7
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值