unity3d + lua + 斗地主 系列 （2） 创建扑克规则

最新推荐文章于 2024-01-23 10:21:01 发布
最新推荐文章于 2024-01-23 10:21:01 发布
阅读量680 收藏 1
点赞数
分类专栏： unity3d 文章标签： lua 游戏 unity3d
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/Tui_GuiGe/article/details/105898999
版权

创建扑克规则

mvc框架

我们把我们的项目改造成mvc的机构，上一篇文章
创建的那两个基本模型，我们放入了Model文件夹里面，记得修改require 时的路径哦。
这篇文章我们来一起实现 扑克的一些规则，主要是斗地主的规则，这个是比较通用的，所以我们放入了工具文件夹 Utils里面。
目录结构

  • PokerRule： 斗地主的一些规则
  • PokerType： 斗地主的出牌类型

PokerType.lua

PokerType = {}

PokerType.p_A = 0  ---单张
PokerType.p_AA = 1  ---对子
PokerType.p_KK = 2  ---王炸
PokerType.p_AAA = 3  ---三 不带
PokerType.p_AAAA = 4  --- 炸弹
PokerType.p_n = 5   ---顺子
PokerType.p_AAAB = 6  ---三带一
PokerType.p_AAABC = 7  --- 三带二
PokerType.p_AABB = 8   --- 连对
PokerType.p_AAABBB = 9 --- 飞机
PokerType.p_AAABBBCD  = 10 ---飞机带单牌
PokerType.p_AAABBBCCDD = 11 ---飞机带对子
--- 四带二 ？ 有的地方没有这个牌型, 需要的可以自行添加
PokerType.p_can_not_put = 12      ---不能出牌


---- 扑克牌编码
-- 大小王
PokerType.BigKing = 17
PokerType.SmallKing = 18

---斗地主玩法，我们可以按照从大到小 排序, 方便我们判断 顺子等牌型
PokerType.Poker_2 =		19    --- 2
PokerType.Poker_A =		20
PokerType.Poker_K =		21
PokerType.Poker_Q =		22
PokerType.Poker_J =		23
PokerType.Poker_10 =	24
PokerType.Poker_9 =		25
PokerType.Poker_8 =		26
PokerType.Poker_7 =		27
PokerType.Poker_6 =		28
PokerType.Poker_5 =		29
PokerType.Poker_4 =		30
PokerType.Poker_3 =		31

-- 广告牌？ ，没玩过带广告牌的斗地主，我们可以不需要
PokerType.Poker_AD =		32


return PokerType

PokerRule.lua

-- 扑克规则模块，主要用于判断玩家出牌的时候符不符合规则

PokerRule = {}

function table_leng(t)
  local leng=0
  for k, v in pairs(t) do
    leng=leng+1
  end
  return leng;
end

deepcopy = function(object)
    local lookup_table = {}
    local function _copy(object)
        if type(object) ~= "table" then
            return object
        elseif lookup_table[object] then
            return lookup_table[object]
        end
        local new_table = {}
        lookup_table[object] = new_table
        for index, value in pairs(object) do
            new_table[_copy(index)] = _copy(value)
        end
        return setmetatable(new_table, getmetatable(object))
    end

    return _copy(object)
end

--- 判断是否是王炸
function PokerRule.IsWangZha( pokerList )

	if ( (pokerList[1]:getNum() == PokerType.BigKing and pokerList[2]:getNum() == PokerType.SmallKing)
		or (pokerList[1]:getNum() == PokerType.SmallKing and pokerList[2]:getNum() == PokerType.BigKing))
	then
		return true
	end
	return false
end


--- 判断 list 里面是否有相同的牌,
--  @param count 表示连续count张
--  @return true:表示连续count一样，false：表示不一样
function PokerRule.IsHaveSame(pokerList, count)

	--- 从 count 变化到 1， 每次变化 -1的步长
	for i = count, 2, -1 do
		local p1_name = pokerList[i]:getNum()
		local p2_name = pokerList[i - 1]:getNum()

		if (p1_name ~= p2_name)
		then
			return false
		end
	end
	return true
end

-- 判断是否是 三带一
-- 因为我们的扑克牌是已经排序好的，所以判断 是不是 3带1，
-- 是要判断这2种类型就可以了：  1. AAAB  2. ABBB
function PokerRule.Is3DaiYi(pokerList)

	--- 先判断 AAAB 的类型
	if (PokerRule.IsHaveSame(pokerList, 3))
	then
		return true
	end

	--- 如果不是，则判断 是不是 ABBB , 我们可以先把 A 删掉
	local tmpList = deepcopy(pokerList)
	table.remove(tmpList, 1)

	if (PokerRule.IsHaveSame(tmpList, 3))
	then
		return true
	end

	-- 不是 三带一 
	return false

end


-- 判断是否是 三带一对
-- 因为我们的扑克牌是已经排序好的，所以判断三带一对，
-- 是要判断这2种类型就可以了：  1. AAABB  2. AABBB
function PokerRule.Is3DaiDui(pokerList)

	local tmpList = deepcopy(pokerList)

	
	local table_len = table_leng(tmpList)

	if (table_len == 5)
	then
		--- 先判断 AAABB 的类型
		if (PokerRule.IsHaveSame(tmpList, 3))
		then
			table.remove(tmpList, 1)
			table.remove(tmpList, 1)
			table.remove(tmpList, 1)
			
			if (PokerRule.IsHaveSame(tmpList, 2))
			then
				return true
			end

			return false
		end

		-- 判断 AABBB
		if (PokerRule.IsHaveSame(tmpList, 2))
		then
			table.remove(tmpList, 1)
			table.remove(tmpList, 1)
			
			if (PokerRule.IsHaveSame(tmpList, 3))
			then
				return true
			end

			return false
		end


	end

	-- 不是 三带一对
	return false

end


--- 判断是不是顺子
-- 因为我们的扑克牌已经从大到小排序好了，所以可以相减判断
function  PokerRule.IsShunZi(pokerList)

	--- local table_len = table_leng(pokerList)

	for k, v in pairs(pokerList) do

		local p1 = v
		local p2 = pokerList[k+1]
		if ( p1 ~= nil and p2 ~= nil and (p1:getNum() - p2:getNum() ~= 1))
		then
			return false
		end

	end

	return true

end


-------判断是不是连对
function PokerRule.IsLianDui(pokerList)

	local index = 1
	for k, v in pairs(pokerList) do

		local p1 = pokerList[index]
		local p2 = pokerList[index+1]
		if ( p1 ~= nil and p2 ~= nil and (p1:getNum() ~= p2:getNum()) )
		then
			return false
		end
		index = index + 1
	end

end

--- 获取三个头的有几个, 即飞机头有几个
-- @return 返回值是一个table，里面装了 飞机头的牌 例如  KKK3QQQ4, 则返回 talbe {K, Q}
function PokerRule.GetFeiJiTouCount(pokerList)

	count_table = {}

	local index = 1

	for k, v in pairs(pokerList) do
		local p1 = pokerList[index]
		local p2 = pokerList[index+1]
		local p3 = pokerList[index+2]

		if (p1 ~= nil and p2 ~= nil and p3 ~= nil and ((p1:getNum() == p2:getNum()) and (p2:getNum() == p3:getNum()))  )
		then
			table.insert(count_table, p1)
		end
		index = index + 1
	end

	return count_table

end

-- 获取飞机中的单张有几个
function PokerRule.GetDanZhangCountInFeiJi( pokerList , feijiList)

	local tmpList = deepcopy(pokerList)
	local count = 0;

	for k, v in pairs(tmpList) do

		for feiji_k, feiji_v in pairs(feijiList) do
			local feiji_p1 = feiji_v
			local p1 = v
			if (p1 ~= nil and feiji_p1 ~= nil and (feiji_p1:getNum() == p1:getNum()) )
			then
				table.remove(tmpList, 1)
			end
		end
	end

	local len = table_leng(tmpList)

	if (len > 0)
	then
		local index = 1
		for k, v in pairs(tmpList) do
			local p1 = tmpList[index]
			local p2 = tmpList[index + 1]

			if (p1 ~= nil and p2 ~= nil and (p1:getNum() ~= p2:getNum()) )
			then
				count = count + 1
			end
		end
	end

	return count

end




-- 获取 飞机中的对子 有几个
-- 把飞机头删掉，留下了的就是翅膀了，例如 KKK33QQQ44 ， 飞机头就是 K ,Q, 返回值就是 33， 44 的个数，为2个
function PokerRule.GetDuiZiCountInFeiJi(pokerList, feijiList)

	local tmpList = deepcopy(pokerList)

	local count = 0;

	for k, v in pairs(tmpList) do

		for feiji_k, feiji_v in pairs(feijiList) do
			local feiji_p1 = feiji_v
			local p1 = v
			if (p1 ~= nil and feiji_p1 ~= nil and (feiji_p1:getNum() == p1:getNum()) )
			then
				table.remove(tmpList, 1)
			end
		end
	end

	-- 剩下的都是 对子
	local len = table_leng(tmpList)

	if (len > 0 and len % 2 == 0 )
	then
		local index = 1
		for k, v in pairs(tmpList) do
			local p1 = tmpList[index]
			local p2 = tmpList[index + 1]

			if (p1 ~= nil and p2 ~= nil and (p1:getNum() == p2:getNum()) )
			then
				count = count + 1
			end
		end
	end

	return count

end

-- 判断是不是 双飞
function PokerRule.IsShuangFei(pokerList)

	local tmp_table = PokerRule.GetFeiJiTouCount(pokerList)

	if (tmp_table == nil)
	then
		return false
	end

	local len = table_leng(tmp_table)

	if (len >= 2)
	then
		local index = 1
		for k, v in pairs(tmp_table) do
			local p1 = tmp_table[index]
			local p2 = tmp_table[index + 1]

			if ( p1 ~= nil and p2 ~= nil and (p1:getNum() - p2:getNum() ~= 1))
			then
				return false
			end

			index = index + 1

		end

		local dui_count = GetDuiZiCountInFeiJi(pokerList, tmp_table)

		if (dui_count == 0)
		then
			return true
		end

	end

	return false

end

-- 判断是不是飞机带翅膀  一般表现形式为： KKK34QQQ56  当然还有很多种
function PokerRule.IsFeiJiDaiChiBang2( pokerList )
	
	local feiji_table = PokerRule.GetFeiJiTouCount(pokerList)
	
	if (feiji_table == nil)
	then
		return false
	end

	local len = table_leng(feiji_table)

	if (len >= 2)
	then
		local index = 1
		for k, v in pairs(tmp_table) do
			local p1 = tmp_table[index]
			local p2 = tmp_table[index + 1]

			if ( p1 ~= nil and p2 ~= nil and (p1:getNum() - p2:getNum() ~= 1))
			then
				return false
			end

			index = index + 1

		end
		
		local dui = GetDuiZiCountInFeiJi(pokerList, feiji_table)
		local feiji_table_len = table_leng(feiji_table)
		if (dui == feiji_table_len)
		then
			return true
		end

	end

	return false
end

-- 判断是不是飞机带翅膀  一般表现形式为： KKK3QQQ4  当然还有很多种
function PokerRule.IsFeiJiDaiChiBang1( pokerList )
	
	local feiji_table = PokerRule.GetFeiJiTouCount(pokerList)
	
	if (feiji_table == nil)
	then
		return false
	end

	local len = table_leng(feiji_table)

	if (len >= 2)
	then
		local index = 1
		for k, v in pairs(tmp_table) do
			local p1 = tmp_table[index]
			local p2 = tmp_table[index + 1]

			if ( p1 ~= nil and p2 ~= nil and (p1:getNum() - p2:getNum() ~= 1))
			then
				return false
			end

			index = index + 1

		end
		
		-- 获取单张
		local danzhang_cnt = GetDanZhangCountInFeiJi(pokerList, feiji_table)
		local feiji_table_len = table_leng(feiji_table)
		if (danzhang_cnt == feiji_table_len)
		then
			return true
		end

	end

	return false
end

-- 获取牌型
function PokerRule.GetPokerType( pokerList )

	local tmpList = deepcopy(pokerList)

	table.sort(tmpList, function(a,b) return a:getNum() < b:getNum() end)
	
	local len = table_leng(tmpList)

	if ( len == 1)
	then
		return PokerType.p_A
	elseif ( len == 2)
	then

		if (PokerRule.IsHaveSame(tmpList, len))
		then
			return PokerType.p_AA
		end

		if (PokerRule.IsWangZha(tmpList))
		then
			return PokerType.p_KK
		end

		-- 不符合规则
		return PokerType.p_can_not_put

	elseif (len == 3)
	then
		-- 三张
		if (PokerRule.IsHaveSame(tmpList, len))
		then
			return PokerType.p_AAA
		end
		
		-- 不符合规则
		return PokerType.p_can_not_put
	elseif (len == 4)
	then
		-- 炸弹
		if (PokerRule.IsHaveSame(tmpList, len))
		then
			return PokerType.p_AAAA
		end
		
		-- 三带一
		if (PokerRule.Is3DaiYi(tmpList))
		then
			return PokerType.p_AAAB
		end

		-- 不符合规则
		return PokerType.p_can_not_put
	elseif (len >= 5)
	then
		-- 顺子
		if (PokerRule.IsShunZi(tmpList))
		then
			return PokerType.p_n

		-- 三带一对
		elseif (PokerRule.Is3DaiDui(tmpList))
		then
			return PokerType.p_AAABC
		-- 连对
		elseif (PokerRule.IsLianDui(tmpList))
		then
			return PokerType.p_AABB
		-- 双飞 或者 双飞双带
		elseif (PokerRule.IsShuangFei(tmpList))
		then
			return PokerType.p_AAABBB
		-- 飞机带单牌
		elseif (PokerRule.IsFeiJiDaiChiBang1(tmpList))
		then
			return PokerType.p_AAABBBCD

		-- 飞机带对子
		elseif (PokerRule.IsFeiJiDaiChiBang2(tmpList))
		then
			return PokerType.p_AAABBBCCDD		
		end

		-- 不符合规则
		return PokerType.p_can_not_put
	end
	
end

-- 比较最后一张牌
-- @param  prePokerList:上一个牌  currentPokerList：当前要出的牌
-- @return true:表示当前出的牌比上一个出的牌大
function PokerRule.CompareLast( prePokerList, currentPokerList )

	local pre_len = table_leng(prePokerList)
	local current_len = table_leng(currentPokerList)

	-- 因为我们设置的num 是 num越小，牌越大
	if (prePokerList[pre_len]:getNum() > currentPokerList[current_len]:getNum())
	then
		return true
	end

	return false
	
end

-- 获取飞机头
function PokerRule.GetFeiJiTou( pokerList )

	local index = 1
	for k, v in pairs(pokerList) do
		local p1 = pokerList[index]
		local p2 = pokerList[index + 1]
		local p3 = pokerList[index + 2]

		if (p1 ~= nil and p2 ~= nil and p3 ~= nil )
		then
			
			if (p1:getNum() == p2:getNum() and p2:getNum() == p3:getNum())
			then
				return p1:getNum()
			end
		end

	end
	
	return -1

end

--- 比较大小飞机头大小
function PokerRule.Compare( prePokerList, currentPokerList )
	
	local pre_tou = PokerRule.GetFeiJiTou(prePokerList)
	local current_tou = PokerRule.GetFeiJiTou(currentPokerList)

	if (pre_tou == -1 or current_tou == -1)
	then
		return false
	end

	if (pre_tou > current_tou)
	then
		return true
	end

	return false

end



-- 比较大小
function PokerRule.IsBigger( prePokerList, currentPokerList )

	-- 获取上一个出牌的牌型
	local pre_poker_type = PokerRule.GetPokerType(prePokerList)

	-- 获取当前出牌的牌型
	local current_poker_type = PokerRule.GetPokerType(currentPokerList)

	if (pre_poker_type == current_poker_type)
	then
		
		-- 单张
		if (pre_poker_type == PokerType.p_A)
		then
			
			if (PokerRule.CompareLast(prePokerList, currentPokerList))
			then
				return true
			end

			return false

		-- 王炸
		elseif (pre_poker_type == PokerType.p_KK)
		then
			return false
		
		-- 对子
		elseif (pre_poker_type == PokerType.p_AA)
		then
			if (PokerRule.CompareLast(prePokerList, currentPokerList))
			then
				return true
			end
			return false
		
		-- 三张
		elseif (pre_poker_type == PokerType.p_AAA)
		then
			if (PokerRule.CompareLast(prePokerList, currentPokerList))
			then
				return true
			end
			return false

		-- 三带一
		elseif (pre_poker_type == PokerType.p_AAAB)
		then
			if (PokerRule.CompareLast(prePokerList, currentPokerList))
			then
				return true
			end
			return false

		-- 三带二
		elseif (pre_poker_type == PokerType.p_AAABC)
		then
			if (PokerRule.Compare(prePokerList, currentPokerList))
			then
				return true
			end
			return false

		-- 炸弹
		elseif (pre_poker_type == PokerType.p_AAAA)
		then
			if (PokerRule.CompareLast(prePokerList, currentPokerList))
			then
				return true
			end
			return false

		-- 顺子
		elseif (pre_poker_type == PokerType.p_n)
		then
			if (PokerRule.CompareLast(prePokerList, currentPokerList))
			then
				return true
			end
			return false

		-- 连对
		elseif (pre_poker_type == PokerType.p_AABB)
		then
			if (PokerRule.CompareLast(prePokerList, currentPokerList))
			then
				return true
			end
			return false

		-- 双飞
		elseif (pre_poker_type == PokerType.p_AAABBB)
		then
			if (PokerRule.Compare(prePokerList, currentPokerList))
			then
				return true
			end
			return false

		-- 飞机带一
		elseif (pre_poker_type == PokerType.p_AAABBBCD)
		then
			if (PokerRule.Compare(prePokerList, currentPokerList))
			then
				return true
			end
			return false

		-- 飞机带二
		elseif (pre_poker_type == PokerType.p_AAABBBCCDD)
		then
			if (PokerRule.Compare(prePokerList, currentPokerList))
			then
				return true
			end
			return false


		end

	-- 如果牌型不相同

	
	elseif (current_poker_type == PokerType.p_KK)
	then
		-- 判断当前出的牌是不是王炸
		if (PokerRule.IsWangZha(currentPokerList))
		then
			return true
		end

		return false

	elseif (current_poker_type == PokerType.p_AAAA)
	then
		
		--- 判断当前出的牌是不是炸弹
		if (PokerRule.IsHaveSame(currentPokerList, 4))
		then
			return true
		end

		return false

	end

	return false

end

ps 注意事项

上面写的代码，需要优化几个地方：

  1. 重复的代码比较多，需要优化一下。
  2. 还有我们的 PokerType.num 是从小到大，而牌的大小是从大到小，这样看起来比较难看，需要调整成一致的。
  3. 最好写一个单元测试样例来测试这些规则
Tui_GuiGe
关注
  • 0
    点赞
  • 踩
  • 1
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
斗地主完整算法包含天地癞子
12-18
斗地主算法完整版，包含二人三人四人玩法天地癞子玩法，如有修改意见，一起学习交流进步
用unity先来个一副牌的单机斗地主
热门推荐
百锦再的博客
12-27 1万+
从发完牌的玩家开始，按照顺时针方向，每位玩家可以选择叫地主或不叫地主。请注意，这只是一个基本的洗牌示例，实际应用中还可能考虑到更复杂的需求，例如需要与玩家配合交互、维护游戏状态等。在此示例中，我们添加了判断牌型是否一致以及手牌中的牌是否比已出的牌大的逻辑。结束条件：游戏继续直到有一名玩家先出完手中的牌，或其他两名玩家同时不出牌。玩家可以出一手比上家大的牌、相同牌型但更大的牌，或者不出牌。底牌：地主在游戏开始后可以查看底牌，并将其添加到自己的牌中。方法中，创建一副牌，然后进行洗牌并打印出洗好的牌的顺序。
【unity3D】记忆翻牌小游戏教程
zirconium95的博客
10-09 1385
游戏两两翻牌，一样则记成功一对；不一样，则两张都恢复初始状态。当所有卡牌配对成功后即获得胜利。游戏流程：1、玩家点击开始游戏后进入游戏；2、系统初始化一组卡牌显示到界面上；3、玩家点击卡牌将卡牌翻开；4、系统检测到当翻开的卡牌为两张时进行评判，若相同则增加计数并判断是否达到指定数量，若不同则两张卡牌均恢复为原始状态。(当有两张卡牌被翻开时，需等待2秒后才能对其他卡牌进行点击，在2秒内对其他卡牌的点击都是无效的。
斗地主中的提示出牌算法(Lua)
hyx18775752051的博客
03-27 3961
没有看到别人怎么写的，这个是上家公司老板写的，当时服务器用的js写的，我搬到了客户端上，换成了lua。然后现在工作要用到，一时还想不起来。所以说造过的轮子要记录下来，方便自己，也方便他人。 主要的思路就是根据上家的出牌，先判断出type(单，对，顺子，炸弹等)，然后根据type去寻找该类型的所有牌组合。所以每个类型都要有个对应的方法。可以在找的时候直接传入参数，直接找大于该牌的组合。也可以找出该...
斗地主洗牌+发牌+排序
幻想无价值！
11-03 5327
主要打乱牌顺序 void Shuffle() { for (int i = 0 ; i < iAllCardNum ; i ++)//iAllCardNum=54 { int p = (int)UnityEngine.Random.Range(1,iAllCardNum); GameObject tempCard = CardList[i]; CardList[i] = Ca
lua实战斗地主思路
最新发布
yydsadasd的博客
01-23 357
print("剩下三张牌 = ", GetCardDetail(value) )4.分发牌到3个玩家手里。[10]="黑桃10",[23]="红桃10",[36]="梅花10",[49]="方片10",--初始化牌，0~54到list。[11]="黑桃J",[12]="黑桃Q",[13]="黑桃K",[14]="红桃A",[15]="红桃2",[16]="红桃3",[17]="红桃4",[18]="红桃5",[19]="红桃6",[20]="红桃7",
vscode+unity+Emmylua+CS调试使用教程.zip
04-19
2. **Unity集成**：Unity是业界广泛使用的跨平台游戏开发引擎，支持C#编程。在Unity中，你可以设置VSCode作为默认的脚本编辑器。打开Unity的“Preferences”（首选项）-> “External Tools”（外部工具），在...
高并发Nginx+lua是如何抗住的
02-24
提到高并发或者抗压力，有这种高qps经验的同学第一反应大都是Nginx+lua+Redis，网上也满天非那种高并发架构方案大都是这种，但是Nginx+lua来做接入层到底是怎么抗住压力的呢？本篇顺序：1、Nginx如何抗住的高并发，...
nginx+lua+redis 集群 连接插件和脚本
12-09
本资源包“nginx+lua+redis集群 连接插件和脚本”正是为了解决这三者之间的协同工作，特别是针对原插件没有密码功能的问题进行了改进，使得安全性得到了提升。 首先，Nginx是一款轻量级的Web服务器/反向代理服务器...
Nginx+Lua+Redis构建高并发Web应用
09-10
总结起来，Nginx+Lua+Redis的组合提供了一种强大的工具集，能够有效地处理高并发Web应用的需求。通过在Nginx中集成Lua，我们可以处理复杂的业务逻辑，而Redis则作为快速数据存储和访问的后端。这种架构不仅提高了...
Lua脚本的斗地主的提示出牌算法。
03-27
Lua脚本的斗地主的提示出牌算法。 包括： 查找某牌型的算法：查找所有的单牌，查找所有的对子，查找所有的三条，查找所有的单顺，双顺，飞机，飞机带单，飞机带双。 排序算法。 转成花色，转成点数， 比较算法等。
unity xlua 麻将棋牌游戏
10-22
unity xlua框架源码 ，麻将，棋牌类游戏，包含客户端服务器
斗地主服务端源码(含客户端程序)lua c# python
03-28
斗地主服务端源码(含客户端程序)lua c# python。 斗地主服务端源码(含客户端程序)仅供学习参考 lua c# python
lua模拟斗地主洗牌发牌排序等过程
12-21
lua模拟斗地主洗牌发牌，对牌排序，比较两副牌大小以及冒泡、选择、插入排序的lua实现
斗地主牌型相关算法
03-02
lua实现斗地主中的牌型判断，牌的比较，出牌提示的算法
2 OpenResty+Lua+Redis 高性能后端接口.docx
06-17
OpenResty+Lua+Redis 高性能后端接口 OpenResty 是基于 Nginx 的高性能 web 服务器，它使用 Lua 语言作为脚本语言来实现动态内容生成和处理。 Lua 是一种轻量级的脚本语言，广泛应用于游戏、嵌入式系统和 web 开发...
Unity3D手机斗地主游戏开发实战（04）_出牌判断大小
weixin_33912453的博客
12-04 336
之前我们实现了叫地主、玩家和电脑自动出牌主要功能，但是还有个问题，出牌的时候，没有有效性检查和比较牌力大小。比如说，出牌3,4,5，目前是可以出牌的，然后下家可以出任何牌如3,6,9。 问题1：出牌检查有效性，就是出牌类型判断，像单张、对子、顺子、炸弹等等类型； 问题2：上家出牌后，下家再出牌的时候，要判断当前牌力是否大于上家的牌力； 那本篇我们主要...
Lua 斗地主算法实现
Momo_Da的博客
04-20 3135
--服务器定义的牌值 16进 Cards = { 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,0x...
lua 的斗地主逻辑算法
yejian2011的专栏
06-30 1339
  --region *.lua--Date--此文件由[BabeLua]插件自动生成--add by lfplocal CURRENT_MODULE_NAME = ...local LandGameLogic = class("LandGameLogic")--排序类型ST_ORDER                                         =  1           ...
Nginx+Lua开发指南：集成优势与实战教程
2. 基于事件的响应：Lua作为Nginx的一部分，继承了Nginx的事件驱动架构，如select或epoll，这使得在处理请求时能实现高效的并发处理和响应，从而提升整体性能。 文章作者建议使用OpenResty，一个基于Nginx的套装，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

Tui_GuiGe

鼓励一下作者吧，请他喝一瓶啤酒

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值