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

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

上一章我们已经搭好了出牌算法的基本框架，本章主要实现优先处理的三带、飞机等牌型。

首先定义一些基本变量：

	//暂存最佳的价值
	HandCardValue BestHandCardValue;
	BestHandCardValue.NeedRound = 20;
	BestHandCardValue.SumValue = MinCardsValue;
	//我们认为不出牌的话会让对手一个轮次，即加一轮（权值减少7）便于后续的对比参考。
	BestHandCardValue.NeedRound += 1;

	//暂存最佳的组合
	CardGroupData BestCardGroup;

	//带出去的牌
	int tmp_1 = 0;
	int tmp_2 = 0;
	int tmp_3 = 0;
	int tmp_4 = 0;

因为枚举了牌型，所以实际和被动出牌逻辑都差不多，且没有nMaxCard的限制，所以我们要从3开始遍历。且上一章我们提到，不考虑炸弹拆分的情况。故value_aHandCardList[i]不能等于4。 

for (int i = 3; i < 16; i++)
	{
		//2.0版本策略主动出牌不拆分炸弹，朕自己从来就不打四带二，因为浪
		if (clsHandCardData.value_aHandCardList[i] != 4)
		{
			//出三带一
			if (clsHandCardData.value_aHandCardList[i] > 2)
			{
				clsHandCardData.value_aHandCardList[i] -= 3;
				for (int j = 3; j < 18; j++)
				{
					if (clsHandCardData.value_aHandCardList[j] > 0 )
					{
						clsHandCardData.value_aHandCardList[j] -= 1;
						clsHandCardData.nHandCardCount -= 4;
						HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
						clsHandCardData.value_aHandCardList[j] += 1;
						clsHandCardData.nHandCardCount += 4;
						//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
						if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
						{
							BestHandCardValue = tmpHandCardValue;
							BestCardGroup = get_GroupData(cgTHREE_TAKE_ONE, i, 4);
							tmp_1 = j;
						}
					}
				}
				clsHandCardData.value_aHandCardList[i] += 3;
			}
			//出三带二
			if (clsHandCardData.value_aHandCardList[i] > 2)
			{
				for (int j = 3; j < 16; j++)
				{
					clsHandCardData.value_aHandCardList[i] -= 3;
					if (clsHandCardData.value_aHandCardList[j] > 1)
					{
						clsHandCardData.value_aHandCardList[j] -= 2;
						clsHandCardData.nHandCardCount -= 5;
						HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
						clsHandCardData.value_aHandCardList[j] += 2;
						clsHandCardData.nHandCardCount += 5;
						//选取总权值-轮次*7值最高的策略  因为我们认为剩余的手牌需要n次控手的机会才能出完，若轮次牌型很大（如炸弹） 则其-7的价值也会为正
						if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
						{
							BestHandCardValue = tmpHandCardValue;
							BestCardGroup = get_GroupData(cgTHREE_TAKE_TWO, i, 5);
							tmp_1 = j;
						}
					}
					clsHandCardData.value_aHandCardList[i] += 3;
				}
			}
			//出四带二单
			if (clsHandCardData.value_aHandCardList[i] > 3)
			{
				//2.0版本策略主动出牌不拆分炸弹，朕自己从来就不打四带二，因为浪
			}
			//出四带二对
			if (clsHandCardData.value_aHandCardList[i] > 3)
			{
				//2.0版本策略主动出牌不拆分炸弹，朕自己从来就不打四带二，因为浪
			}
			//出三带一单连
			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;
					}
					/*本来想做全排列选取带出的牌然后枚举出最高价值的，但考虑到当飞机长度也就是在2-4之间
					所以干脆做三个分支处理算了*/
					//为两连飞机
					if (prov == 2)
					{

						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] -= 3;
						}
						clsHandCardData.nHandCardCount -= prov * 4;
						for (int tmp1 = 3; tmp1 < 18; tmp1++)
						{
							if (clsHandCardData.value_aHandCardList[tmp1] > 0 )
							{
								clsHandCardData.value_aHandCardList[tmp1] -= 1;
								for (int tmp2 = tmp1; tmp2 < 18; tmp2++)
								{
									if (clsHandCardData.value_aHandCardList[tmp2] > 0 )
									{
										clsHandCardData.value_aHandCardList[tmp2] -= 1;
										HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
									
										if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
										{
											BestHandCardValue = tmpHandCardValue;
											BestCardGroup = get_GroupData(cgTHREE_TAKE_ONE_LINE, j, prov * 4);
											tmp_1 = tmp1;
											tmp_2 = tmp2;

										}
										clsHandCardData.value_aHandCardList[tmp2] += 1;
									}
								}
								clsHandCardData.value_aHandCardList[tmp1] += 1;
							}
						}
						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] += 3;
						}
						clsHandCardData.nHandCardCount += prov * 4;
					}
					//为三连飞机
					if (prov == 3)
					{
						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] -= 3;
						}
						clsHandCardData.nHandCardCount -= prov * 4;
						for (int tmp1 = 3; tmp1 < 18; tmp1++)
						{
							if (clsHandCardData.value_aHandCardList[tmp1] > 0 )
							{
								clsHandCardData.value_aHandCardList[tmp1] -= 1;
								for (int tmp2 = tmp1; tmp2 < 18; tmp2++)
								{
									if (clsHandCardData.value_aHandCardList[tmp2] > 0 )
									{
										clsHandCardData.value_aHandCardList[tmp2] -= 1;
										for (int tmp3 = tmp2; tmp3 < 18; tmp3++)
										{
											if (clsHandCardData.value_aHandCardList[tmp3] > 0 )
											{
												clsHandCardData.value_aHandCardList[tmp3] -= 1;

												HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
												if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
												{

													BestHandCardValue = tmpHandCardValue;
													BestCardGroup = get_GroupData(cgTHREE_TAKE_ONE_LINE, j, prov * 4);
													tmp_1 = tmp1;
													tmp_2 = tmp2;
													tmp_3 = tmp3;

												}
												clsHandCardData.value_aHandCardList[tmp3] += 1;
											}

										}
										clsHandCardData.value_aHandCardList[tmp2] += 1;
									}

								}
								clsHandCardData.value_aHandCardList[tmp1] += 1;
							}
						}
						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] += 3;
						}
						clsHandCardData.nHandCardCount += prov * 4;
					}
					//为四连飞机
					if (prov == 4)
					{
						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] -= 3;
						}
						clsHandCardData.nHandCardCount -= prov * 4;
						for (int tmp1 = 3; tmp1 < 18; tmp1++)
						{
							if (clsHandCardData.value_aHandCardList[tmp1] > 0 )
							{
								clsHandCardData.value_aHandCardList[tmp1] -= 1;
								for (int tmp2 = tmp1; tmp2 < 18; tmp2++)
								{
									if (clsHandCardData.value_aHandCardList[tmp2] > 0 )
									{
										clsHandCardData.value_aHandCardList[tmp2] -= 1;
										for (int tmp3 = tmp2; tmp3 < 18; tmp3++)
										{
											if (clsHandCardData.value_aHandCardList[tmp3] > 0 )
											{
												clsHandCardData.value_aHandCardList[tmp3] -= 1;
												for (int tmp4 = tmp3; tmp4 < 18; tmp4++)
												{
													if (clsHandCardData.value_aHandCardList[tmp4] > 0 )
													{
														clsHandCardData.value_aHandCardList[tmp4] -= 1;
														HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
														if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
														{
															BestHandCardValue = tmpHandCardValue;
															BestCardGroup = get_GroupData(cgTHREE_TAKE_ONE_LINE, j, prov * 4);
															tmp_1 = tmp1;
															tmp_2 = tmp2;
															tmp_3 = tmp3;
															tmp_4 = tmp4;
														}
														clsHandCardData.value_aHandCardList[tmp4] += 1;
													}

												}
												clsHandCardData.value_aHandCardList[tmp3] += 1;
											}

										}
										clsHandCardData.value_aHandCardList[tmp2] += 1;
									}

								}
								clsHandCardData.value_aHandCardList[tmp1] += 1;
							}
						}
						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] += 3;
						}
						clsHandCardData.nHandCardCount += prov * 4;
					}
					//若prov==5，则是地主可以直接出去，在剪枝部分已经处理
				}

			}
			//出三带一双连
			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;
					}
					/*本来想做全排列选取带出的牌然后枚举出最高价值的，但考虑到当飞机长度也就是在2-4之间
					所以干脆做三个分支处理算了*/
					//为两连飞机
					if (prov == 2)
					{

						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] -= 3;
						}
						clsHandCardData.nHandCardCount -= prov * 5;
						for (int tmp1 = 3; tmp1 < 16; tmp1++)
						{
							if (clsHandCardData.value_aHandCardList[tmp1] > 1 )
							{
								clsHandCardData.value_aHandCardList[tmp1] -= 2;
								for (int tmp2 = tmp1; tmp2 < 16; tmp2++)
								{
									if (clsHandCardData.value_aHandCardList[tmp2] > 1 )
									{
										clsHandCardData.value_aHandCardList[tmp2] -= 2;
										HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
										if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
										{
											BestHandCardValue = tmpHandCardValue;
											BestCardGroup = get_GroupData(cgTHREE_TAKE_TWO_LINE, j, prov * 5);
											tmp_1 = tmp1;
											tmp_2 = tmp2;
										}
										clsHandCardData.value_aHandCardList[tmp2] += 2;
									}
								}
								clsHandCardData.value_aHandCardList[tmp1] += 2;
							}
						}
						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] += 3;
						}
						clsHandCardData.nHandCardCount += prov * 5;
					}
					//为三连飞机
					if (prov == 3)
					{
						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] -= 3;
						}
						clsHandCardData.nHandCardCount -= prov * 5;
						for (int tmp1 = 3; tmp1 < 16; tmp1++)
						{
							if (clsHandCardData.value_aHandCardList[tmp1] > 1 )
							{
								clsHandCardData.value_aHandCardList[tmp1] -= 2;
								for (int tmp2 = tmp1; tmp2 < 16; tmp2++)
								{
									if (clsHandCardData.value_aHandCardList[tmp2] > 1 )
									{
										clsHandCardData.value_aHandCardList[tmp2] -= 2;
										for (int tmp3 = tmp2; tmp3 < 16; tmp3++)
										{
											if (clsHandCardData.value_aHandCardList[tmp3] > 1 )
											{
												clsHandCardData.value_aHandCardList[tmp3] -= 2;
												HandCardValue tmpHandCardValue = get_HandCardValue(clsHandCardData);
												if ((BestHandCardValue.SumValue - (BestHandCardValue.NeedRound * 7)) <= (tmpHandCardValue.SumValue - (tmpHandCardValue.NeedRound * 7)))
												{
													BestHandCardValue = tmpHandCardValue;
													BestCardGroup = get_GroupData(cgTHREE_TAKE_TWO_LINE, j, prov * 5);
													tmp_1 = tmp1;
													tmp_2 = tmp2;
													tmp_3 = tmp3;
												}
												clsHandCardData.value_aHandCardList[tmp3] += 2;
											}

										}
										clsHandCardData.value_aHandCardList[tmp2] += 2;
									}

								}
								clsHandCardData.value_aHandCardList[tmp1] += 2;
							}
						}
						for (int k = i; k <= j; k++)
						{
							clsHandCardData.value_aHandCardList[k] += 3;
						}
						clsHandCardData.nHandCardCount += prov * 5;
					}
					//若prov==4，则是地主可以直接出去，在剪枝部分已经处理
				}
			}
		}

	}





这个循环结束后，若有好的选择，则BestCardGroup会保留出牌的类型，在循环外进行出牌处理。 

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;
			return;
		}
	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;
			return;
		}
	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;
			return;
		}
	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算法——第十四章の主动出牌(3)

九日王朝
关注
  • 5
    点赞
  • 踩
  • 10
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
斗地主ai机器人出牌叫分算法cpp源码
05-04
自己开发的简单的斗地主陪练机器人出牌算法，c++代码，无需修改，直接使用。 使用方法： https://blog.csdn.net/hhpp526/article/details/103159283 解压密码：hhpp526@hotmail.com
unity开发 斗地主算法—提示AI（提示出牌）
csdn_cjt的博客
11-27 7949
牌型的定义在http://blog.csdn.net/csdn_cjt/article/details/78593140 第一章 这是第四章 下面是代码 #region 提示出牌 public static Dictionary> FindPromptCards(List myCards, List lastCards, DDZ_P
AI 全自动玩斗地主，靠谱吗？Douzero算法教程
腾讯云云开发布道师，慕课网合作讲师
03-05 3万+
就。。。离谱
斗地主机器人AI算法和策略（个人思路总结）
qq_43998763的博客
12-23 8320
一、规则和权值定义 1、斗地主中存在很多种的牌型，比如：单张，对子，三带，顺子，连队，飞机，炸弹等 ，我的机器人主要根据权重去设计的，我给每一种牌型都制定了一个权重，比如3权重是多少，其他牌型的权重有时多少，定义了一个结构体如下： type CardGroup struct{ cgType PattenType //枚举类型 value int //牌的价值 count int //牌的个数 maxCard int
斗地主AI算法——第六章の牌型判断
九日王朝
04-26 9235
本章实现了上一章提到的检查当前是否只是一手牌函数ins_SurCardsType /* 检查剩余的牌是否只是一手牌 是： 返回手牌类型数据 不是：返回错误类型（cgERROR） */ CardGroupData ins_SurCardsType(int arr[]); 输入很简单，就是一个状态数组。输出是手牌类型结构 //牌型组合数据结构 struct CardGr
斗地主老是输？一起用Python做个AI出牌器，欢乐豆蹭蹭涨！
xiangxue666的博客
07-27 2641
斗地主老是输？一起用Python做个AI出牌器，欢乐豆蹭蹭涨！
斗地主AI拆牌核心逻辑源码
05-25
斗地主AI拆牌核心逻辑源码，TS版本，后续更新出牌逻辑，主要算法按手数然后权重对比每组牌型优劣，选出手数最少或者权重最大的牌型，可以调用testMain测试。
Lua脚本的斗地主的提示出牌算法。
03-27
Lua脚本的斗地主的提示出牌算法。 包括： 查找某牌型的算法：查找所有的单牌，查找所有的对子，查找所有的三条，查找所有的单顺，双顺，飞机，飞机带单，飞机带双。 排序算法。 转成花色，转成点数， 比较算法等。
人工智能项目资料-基于权重的斗地主游戏AI算法.zip
02-07
人工智能——模拟人类智能的技术和理论，使其在计算机上展现出类似人类的思考、判断、决策、学习和交流能力。这不仅是一门技术，更是一种前沿的科学探索。 【实战项目与源码分享】 我们深入探讨了深度学习的基本...
斗地主AI 算法
06-04
斗地主机器人模拟打牌 C# 代码 代码能运行，供大家参考
单机斗地主带AI
11-28
单机斗地主完整代码 自带AI “人工智能”（Artificial Intelligence）简称AI。它是研究、开发用于模拟、延伸和扩展人的智能的理论、方法、技术及应用系统的一门新的技术科学。人工智能研究如何用计算机去模拟、延伸和扩展人的智能；如何把计算机用得更聪明；如何设计和建造具有高智能水平的计算机应用系统；如何设计和制造更聪明的计算机以及智能水平更高的智能计算机
c#单机版斗地主，基本功能已实现，有一定的AI，大家可以再AI方面多下功夫
01-19
C#单机版斗地主，基本功能全部实现，有一定的AI，大家可以拿来参考参考，欢迎批评指正~
DouZero: 定制化AI在斗地主游戏中的实战应用与Python实现教程“
m0_57781768的博客
09-19 2573
斗地主，作为中国的经典卡牌游戏，无论在线上还是线下都拥有大量的玩家。近些年，随着AI技术的发展，如何使用AI技术来打败人类玩家已经成为了研究的热点。DouZero是其中的杰出代表，它是一个基于深度强化学习的斗地主AI框架，性能出色，与人类玩家的对弈表现非常接近。DouZero是一个开源的斗地主AI框架，采用了最新的深度强化学习技术。它不仅能够根据当前的牌面决策出最优的出牌策略，还可以根据对手的出牌情况做出相应的应对。深度强化学习结合了深度学习与强化学习的特点。
人工智能入门实战：人工智能在游戏的应用
禅与计算机程序设计艺术
11-26 77
1.背景介绍 游戏（Game） 游戏(game)是人类经过长时间发展、多年开发、改进和迭代形成的一种交互性活动。它不仅仅局限于角色扮演和体育竞技这两种范畴，更是一个复杂的社会生活中对个体及群体的思维、行为和情绪进行深层次表达的载体。游戏不仅仅是娱乐，而更是一种沟通的工具，通过游戏的互动、体验和互动，人们能够
斗地主智能（AI）出牌算法
热门推荐
xdx2ct1314的专栏
01-26 4万+
去年有想写个斗地主的小游戏，自己玩玩。找了很多资料，后来好不容易在网上找到了一个AI算法。转过的的时候是贴在自己电脑的TXT文本上，再次感谢下原作者。现在借花献佛发给你参考下。    我以前写过一个斗地主机器人。思路如下，希望对你有帮助。   斗地主AI设计  一、牌型           1 火箭：大小王在一起的牌型，即双王牌，此牌型最大，什么牌型都可以打。           2 炸弹
一个使用AI斗地主的项目
weixin_42119706的博客
12-14 1087
一个使用AI斗地主的项目
斗地主AI算法——第十四章の主动出牌(3)
九日王朝
04-27 6005
上一章已经排除了飞机、三带等牌型，那么除去炸弹王炸以外，我们只剩下单牌、对牌、三牌以及单顺、双顺、三顺了。 首先说单牌、对牌、三牌。其逻辑基本一样，只是出牌的个数有差别，即：如果该i牌数量满足这种牌型要求，即先打出，计算其剩余价值。 //出单牌 if (clsHandCardData.value_aHandCardList[i] > 0) { clsHandC
十三水摆牌高级智能算法
huangdecai2的专栏
05-02 9975
十三张高级智能算法自动摆牌
13张扑克牌排序算法
Cooper Wu 技术专栏
08-19 2万+
<br />上次写了一篇52张扑克牌的算法，写的将一副扑克（去掉大小王）之后的排序，排序是按照数字和花式排列的。数字从大到小，花式从黑桃，梅花，红心，方块。后来有一个网友回复，还希望看到13张扑克牌的排序算法——这个算法是按照我们打牌的常规排法，把数量多的放前面，数量相同的比大小。可以参考文章的输出结果看。<br /> <br />完整代码如下：<br /> class PokerSorterDemo { static string[] numberArray = { "2
斗地主基于规则的手牌拆分算法
最新发布
03-17
斗地主是一种非常流行的扑克牌游戏，基于规则的手牌拆分算法可以帮助玩家在游戏中更好地分析和拆分手牌，提高胜率。...5. 最后，将所有的拆分结果返回给玩家，玩家可以根据自己的策略选择合适的牌型出牌。

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

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

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值