斗地主中的提示出牌算法(Lua)

最新推荐文章于 2023-02-08 18:09:50 发布
最新推荐文章于 2023-02-08 18:09:50 发布
阅读量4.1k 收藏 10
点赞数 2
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/hyx18775752051/article/details/105134380
版权

没有看到别人怎么写的，这个是上家公司老板写的，当时服务器用的js写的，我搬到了客户端上，换成了lua。然后现在工作要用到，一时还想不起来。所以说造过的轮子要记录下来，方便自己，也方便他人。

主要的思路就是根据上家的出牌，先判断出type(单，对，顺子，炸弹等)，然后根据type去寻找该类型的所有牌组合。所以每个类型都要有个对应的方法。可以在找的时候直接传入参数，直接找大于该牌的组合。也可以找出该类型的所有组合后再对比剔除小于它的组合。最后加上炸弹，基本就是所有能出的牌型了。

找每个牌型的组合时，这里用的方法是：先根据牌等级（或者牌数字）将所有手牌合并成一个哈希表，然后根据这个哈希表来算。这里的牌的数据结构是1-13,17-29,33-45,49-61,78,79。1-13(A,2,3,4....J,Q,K)后面依次类推。

--扑克管理类
-- PokerManager = class("PokerManager")
PokerManager = {}
local PokerAB = nil
local Pokers = {}

CardType = {}

--空牌 1, // 非法牌型
CardType.CT_ERROR = 1
--单张 1张牌
CardType.CT_SINGLE = 2
--对子 2张牌
CardType.CT_DOUBLE =3
--顺子
CardType.CT_SINGLE_LINE = 4
--连对
CardType.CT_DOUBLE_LINE = 5
--三条 3张牌
CardType.CT_THREE =6
--3带1 4张牌
CardType.CT_THREE_TAKE_ONE  = 7
--3带2 5张牌
CardType.CT_THREE_TAKE_TWO  = 8
--4带2单 6张牌
CardType.CT_FOUR_TAKE_ONE = 9
--4带2对 8张牌
CardType.CT_FOUR_TAKE_TWO  = 10
--飞机 3顺
CardType.CT_THREE_LINE = 11
--飞机带小翼 3顺+ 同数量单牌
CardType.CT_THREE_LINE_S = 12
--飞机带大翼 3顺+ 同数量双牌
CardType.CT_THREE_LINE_B = 13
--4张同号的炸弹 4张牌
CardType.CT_BOMB_CARD = 14
--双王火箭
CardType.CT_MISSILE_CARD = 15

function PokerManager:ctor()
    PokerAB = nil

    self.PokerABName = "poker"
    ABManager.getBundle(
        self.PokerABName,
        function(ab)
            PokerAB = ab
            print(PokerAB.name)
        end
    )
    self.Joker = {"black_joker", "red_joker"}
    self.PokersName = {"01", "02", "03", "04", "05", "06", "07", "08", "09", "10", "11", "12", "13"}
    --黑桃、红心、梅花、方块
    self.PokersType = {"spade_", "heart_", "club_", "diamond_"}
end

--设置贴图
function PokerManager:setPoker(target, serverIndex, fuc)
    local index = tonumber(serverIndex)
    if PokerAB then
        if index == 78 then --如果id编号在扑克资源表中
            target.sprite = PokerAB:LoadAsset(self.Joker[1], typeof(U3D.Sprite))
        elseif index == 79 then
            target.sprite = PokerAB:LoadAsset(self.Joker[2], typeof(U3D.Sprite))
        else
            target.sprite = PokerAB:LoadAsset(self.PokersType[self:GetColor(index)] .. self.PokersName[self:GetNumber(index)], typeof(U3D.Sprite))
        end
        fuc()
    end
end
--设置扑克牌背景
function PokerManager:setPokerBG(target, name, fuc)
    if PokerAB then
        if target then
            target.sprite = PokerAB:LoadAsset(name, typeof(U3D.Sprite))
        end
        fuc()
    end
end
--获取花色名称 lua的table从1开始，因此除值后需要加1
function PokerManager:GetColor(serverIndex)
    if serverIndex ~= 79 and serverIndex ~= 78 then
        return math.modf(serverIndex / 16) + 1
    else
        return serverIndex
    end
end
--获取数字
function PokerManager:GetNumber(serverIndex)
    if serverIndex ~= 79 and serverIndex ~= 78 then
        return serverIndex % 16
    else
        return serverIndex
    end
end
--获取卡牌优先级 15 ~ 1（王、2、1、K、Q、J、10 ~ 3）
function PokerManager:GetGrad(serverIndex)
    -- body
    local num = serverIndex % 16
    if num == 1 then
        return 12
    elseif num == 2 then
        return 13
    elseif num > 2 and num < 14 then
        return num - 2
    else
        return num
    end
end

--排序
function PokerManager:SortCards(cardsData)
    -- body
    --卡牌排序(先优先级，后花色)
    local cachePos = #cardsData - 1
    while cachePos > 0 do
        local pos = 0
        for i = 1, cachePos do
            if self:GetGrad(cardsData[i]) < self:GetGrad(cardsData[i + 1]) then --判断优先级
                pos = i
                local tmp = cardsData[i] --缓存小值
                cardsData[i] = cardsData[i + 1]
                cardsData[i + 1] = tmp
            end
            if self:GetGrad(cardsData[i]) == self:GetGrad(cardsData[i + 1]) then --判断花色
                if self:GetColor(cardsData[i]) > self:GetColor(cardsData[i + 1]) then
                    pos = i
                    local tmp = cardsData[i]
                    cardsData[i] = cardsData[i + 1]
                    cardsData[i + 1] = tmp
                end
            end
            cachePos = pos
        end
    end
    return cardsData
end

--排序 从小到大
function PokerManager:SortCardsSmallToBig(cardsData)
    -- body
    --卡牌排序(先优先级，后花色)
    local cachePos = #cardsData - 1
    while cachePos > 0 do
        local pos = 0
        for i = 1, cachePos do
            if self:GetGrad(cardsData[i]) > self:GetGrad(cardsData[i + 1]) then --判断优先级
                pos = i
                cardsData[i],cardsData[i+1] = cardsData[i+1],cardsData[i]
            end
            if self:GetGrad(cardsData[i]) == self:GetGrad(cardsData[i + 1]) then --判断花色
                if self:GetColor(cardsData[i]) > self:GetColor(cardsData[i + 1]) then
                    pos = i
                    cardsData[i],cardsData[i+1] = cardsData[i+1],cardsData[i]
                end
            end
            cachePos = pos
        end
    end
    return cardsData
end

--获取牌型
function PokerManager:GetCardType(cardsData)
    cardsData = self:SortCards(cardsData)
    -- body
    local cardsCount = #cardsData --卡牌数量
    if cardsCount == 0 then --空牌
        return CardType.CT_ERROR
    elseif cardsCount == 1 then --单张
        return CardType.CT_SINGLE
    elseif cardsCount == 2 then --对子、火箭
        if self:IsMissile(cardsData) then
            return CardType.CT_MISSILE_CARD
        end
        if self:IsDouble(cardsData) then
            return CardType.CT_DOUBLE
        end
        return CardType.CT_ERROR
    elseif cardsCount == 3 then --三条
        if self:IsThree(cardsData) then
            return CardType.CT_THREE
        end
    elseif cardsCount == 4 then --炸弹、三带一
        if self:IsBomb(cardsData) then
            return CardType.CT_BOMB_CARD
        end
        if self:IsThreeTakeOne(cardsData) then
            return CardType.CT_THREE_TAKE_ONE
        end
    elseif cardsCount >= 5 then --三带二，连对，飞机，顺子
        if cardsCount == 5 then --三带二
            if self:IsThreeTakeTwo(cardsData) then
                return CardType.CT_THREE_TAKE_TWO
            end
        elseif cardsCount == 6 then --四带两单
            if self:IsFourTakeTwo(cardsData) then
                return CardType.CT_FOUR_TAKE_ONE
            end
        elseif cardsCount == 8 then --四带两对
            if self:IsFourTakeTwoDouble(cardsData) then
                return CardType.CT_FOUR_TAKE_TWO
            end
        end

        if cardsCount >= 8 then --飞机
            if self:IsThreeLine(cardsData) then
                return CardType.CT_THREE_LINE
            elseif self:IsThreeLineAndSWing(cardsData) then
                return CardType.CT_THREE_LINE_S
            elseif self:IsThreeLineAndBWing(cardsData) then
                return CardType.CT_THREE_LINE_B
            end
        end
        if cardsCount > 5 and cardsCount % 2 == 0 then --连对
            if self:IsDoubleLine(cardsData) then
                return CardType.CT_DOUBLE_LINE
            end
        end
        if self:IsSingleLine(cardsData) then --顺子
            return CardType.CT_SINGLE_LINE
        end
    end
    return CardType.CT_ERROR
end
--能出牌与否
function PokerManager:CanShow(selfPokers, showPokers)
    if #selfPokers < #showPokers then
        return nil
    end
    local type = self:GetCardType(showPokers)
    print("type=============>" .. type)
    local show = {}
    if #show > 0 then
        return show
    else
        return nil
    end
end
--对子
function PokerManager:IsDouble(cardsData)
    -- body
    if self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[2]) then
        return true
    end
    return false
end

--火箭(王炸)
function PokerManager:IsMissile(cardsData)
    -- body
    if (cardsData[1] == 78 or cardsData[1] == 79) and (cardsData[2] == 78 or cardsData[2] == 79) then
        return true
    end
    return false
end

--三条
function PokerManager:IsThree(cardsData)
    -- body
    if self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[2]) and self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[3]) then
        return true
    end
    return false
end

--炸弹
function PokerManager:IsBomb(cardsData)
    -- body
    if #cardsData == 4 then
        if self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[2]) and self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[3]) and self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[4]) then
            return true
        end
    end
    return false
end

--三带一
function PokerManager:IsThreeTakeOne(cardsData)
    -- body
    if self:IsBomb(cardsData) then
        return false
    end
    if self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[2]) and self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[3]) then
        return true
    end
    if self:GetGrad(cardsData[2]) == self:GetGrad(cardsData[3]) and self:GetGrad(cardsData[2]) == self:GetGrad(cardsData[4]) then
        return true
    end
    return false
end

--三带二
function PokerManager:IsThreeTakeTwo(cardsData)
    -- body
    if self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[2]) and self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[3]) then
        if self:GetGrad(cardsData[4]) == self:GetGrad(cardsData[5]) then
            return true
        end
    end
    if self:GetGrad(cardsData[3]) == self:GetGrad(cardsData[4]) and self:GetGrad(cardsData[3]) == self:GetGrad(cardsData[5]) then
        if self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[2]) then
            return true
        end
    end
    return false
end

--四带二
function PokerManager:IsFourTakeTwo(cardsData)
    -- body
    if self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[2]) and self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[3]) and self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[4]) then
        return true
    end
    if self:GetGrad(cardsData[3]) == self:GetGrad(cardsData[4]) and self:GetGrad(cardsData[3]) == self:GetGrad(cardsData[5]) and self:GetGrad(cardsData[3]) == self:GetGrad(cardsData[6]) then
        return true
    end
    return false
end

--四带两对
function PokerManager:IsFourTakeTwoDouble(cardsData)
    -- body
    if self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[2]) and self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[3]) and self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[4]) then
        if self:GetGrad(cardsData[5]) == self:GetGrad(cardsData[6]) and self:GetGrad(cardsData[7]) == self:GetGrad(cardsData[8]) then
            return true
        end
    end
    if self:GetGrad(cardsData[3]) == self:GetGrad(cardsData[4]) and self:GetGrad(cardsData[3]) == self:GetGrad(cardsData[5]) and self:GetGrad(cardsData[3]) == self:GetGrad(cardsData[6]) then
        if self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[2]) and self:GetGrad(cardsData[7]) == self:GetGrad(cardsData[8]) then
            return true
        end
    end
    if self:GetGrad(cardsData[5]) == self:GetGrad(cardsData[6]) and self:GetGrad(cardsData[5]) == self:GetGrad(cardsData[7]) and self:GetGrad(cardsData[5]) == self:GetGrad(cardsData[8]) then
        if self:GetGrad(cardsData[1]) == self:GetGrad(cardsData[2]) and self:GetGrad(cardsData[3]) == self:GetGrad(cardsData[4]) then
            return true
        end
    end
    return false
end

--顺子
function PokerManager:IsSingleLine(cardsData)
    -- body
    local length = #cardsData
    for i = 1, length do
        if cardsData[i] == 78 or cardsData[i] == 79 or self:GetGrad(cardsData[i]) == 13 then --顺子不包括大小王 and 2
            return false
        end
        if i + 1 < length then
            if self:GetGrad(cardsData[i]) - self:GetGrad(cardsData[i + 1]) ~= 1 then
                return false
            end
        end
    end
    return true
end

--连对
function PokerManager:IsDoubleLine(cardsData)
    -- body
    local length = #cardsData
    for i = 1, length do
        if cardsData[i] == 78 or cardsData[i] == 79 or self:GetGrad(cardsData[i]) == 13 then --连对不包括大小王 and 2
            return false
        end
    end
    for i = 1, length, 2 do
        if self:GetGrad(cardsData[i]) ~= self:GetGrad(cardsData[i + 1]) then
            return false
        end
        if i + 2 < length then
            if self:GetGrad(cardsData[i]) - self:GetGrad(cardsData[i + 2]) ~= 1 then
                return false
            end
        end
    end
    return true
end
--飞机 （3顺）
function PokerManager:IsThreeLine(cardsData)
    local length = #cardsData
    --找出连续三张，并且连续三张不能是 2
    local threeCache = {}
    for i = 1, length do
        if i + 2 <= length then
            if self:GetGrad(cardsData[i]) == self:GetGrad(cardsData[i + 1]) and self:GetGrad(cardsData[i]) == self:GetGrad(cardsData[i + 2]) then
                if self:IsContainGrad(threeCache, cardsData[i]) == false then
                    threeCache[#threeCache + 1] = cardsData[i]
                end
            end
        else
            break
        end
    end
    if #threeCache * 3 == length then
        return true
    else
        return false
    end
end

--飞机带小翅膀
function PokerManager:IsThreeLineAndSWing(cardsData)
    -- body
    local length = #cardsData
    --找出连续三张，并且连续三张不能是 2
    local threeCache = {}
    for i = 1, length do
        if i + 2 <= length then
            if self:GetGrad(cardsData[i]) == self:GetGrad(cardsData[i + 1]) and self:GetGrad(cardsData[i]) == self:GetGrad(cardsData[i + 2]) then
                if self:IsContainGrad(threeCache, cardsData[i]) == false then
                    threeCache[#threeCache + 1] = cardsData[i]
                end
            end
        else
            break
        end
    end

    --查找三张是否连续
    local threeCacheLength = #threeCache
    if threeCacheLength > 1 then
        for i = 1, threeCacheLength do
            if i + 1 < threeCacheLength then
                if self:GetGrad(threeCache[i]) - self:GetGrad(threeCache[i + 1]) ~= 1 then
                    return false
                end
            end
        end
    else
        return false
    end
    --只能是带一个或是带一对
    --计算带牌数量
    if threeCacheLength * (3 + 1) == length then
        return true
    else
        return false
    end
end

--飞机带大翅膀
function PokerManager:IsThreeLineAndBWing(cardsData)
    -- body
    local length = #cardsData
    --找出连续三张，并且连续三张不能是 2
    local threeCache = {}
    for i = 1, length do
        if i + 2 <= length then
            if self:GetGrad(cardsData[i]) == self:GetGrad(cardsData[i + 1]) and self:GetGrad(cardsData[i]) == self:GetGrad(cardsData[i + 2]) then
                if self:IsContainGrad(threeCache, cardsData[i]) == false then
                    threeCache[#threeCache + 1] = cardsData[i]
                end
            end
        else
            break
        end
    end

    --查找三张是否连续
    local threeCacheLength = #threeCache
    if threeCacheLength > 1 then
        for i = 1, threeCacheLength do
            if i + 1 < threeCacheLength then
                if self:GetGrad(threeCache[i]) - self:GetGrad(threeCache[i + 1]) ~= 1 then
                    return false
                end
            end
        end
    else
        return false
    end

    local doubleCache = {}
    if threeCacheLength * (3 + 2) == length then
        --找对子，对子数量 = 三条的数量
        for i = 1, length, 2 do
            if i + 2 < length then
                if self:GetGrad(cardsData[i]) == self:GetGrad(cardsData[i + 1]) then
                    for j = 1, threeCacheLength do
                        if self:IsContainGrad(threeCache, cardsData[i]) == false and self:IsContainGrad(doubleCache, cardsData[i]) == false then
                            doubleCache[#doubleCache + 1] = cardsData[i]
                        end
                    end
                end
            end
        end
        if #doubleCache == threeCacheLength then
            return true
        end
    end
    return false
end
--是否包含同级牌
function PokerManager:IsContainGrad(data, value)
    -- body
    local length = #data
    if length == 0 then
        return false
    end
    for i = 1, length do
        if self:GetGrad(data[i]) == self:GetGrad(value) then
            return true
        end
    end
    return false
end
--比较牌型和大小
function PokerManager:ComparePokers(type, _pokes, _targetpokers)
    _pokes = self:SortCards(_pokes)
    _targetpokers = self:SortCards(_targetpokers)
    --判断对手牌型是否是王炸
    if type == CardType.CT_MISSILE_CARD then
        return false
    end
    --如果自己出的牌是王炸
    if self:IsMissile(_pokes) then
        print("自己出的牌是王炸")
        return true
    end
    --如果对手牌型是炸弹
    if type == CardType.CT_BOMB_CARD then
        if self:IsBomb(_pokes) then
            if self:GetGrad(_pokes[1]) > self:GetGrad(_targetpokers[1]) then
                return true
            else
                print("Bomb is low")
                return false
            end
        else
            --自己出的不是炸弹
            return false
        end
    else
        --对手出的牌型非炸弹
        
        --如果自己出的是炸弹
        if self:IsBomb(_pokes) then
            return true
        end

        if #_pokes == #_targetpokers then
            if type == self:GetCardType(_pokes) then
                if self:GetGrad(_pokes[1]) > self:GetGrad(_targetpokers[1]) then
                    return true
                else
                    --首张牌优先级不够对手高
                    print("first is low")
                    return false
                end
            else
                --牌型不一致
                print("type is not the same")
                return false
            end
        else
            --出的牌数量不一致
            print("count is not the same")
            return false
        end
    end
end
--提示出牌
function PokerManager:TipsSendPokers(prepokers, selfpokers)
    --获取牌的牌型
    local t = PokerManager:GetCardType(prepokers)
    if t == CardType.CT_ERROR then
        --如果不成牌型
        return {}
    elseif  t == CardType.CT_BOMB_CARD then
        --如果是炸弹
        local minNum = self:SortCardsSmallToBig(prepokers)[1]
        local resultArr = self:FindAllBombAndMissile(selfpokers,self:GetGrad(minNum))
        if resultArr and #resultArr > 0 then
            return resultArr
        else
            return {}
        end
    else
        --其他所有牌型
        local resultArr = {}

        local minNum = self:SortCardsSmallToBig(prepokers)[1]
        --获取当前牌型的牌
        if t == CardType.CT_SINGLE then
            resultArr = self:FindAllSingle(selfpokers,minNum)
        elseif t == CardType.CT_DOUBLE then
            resultArr = self:FindAllDouble(selfpokers,minNum)
        elseif t == CardType.CT_THREE then
            resultArr = self:FindAllThree(selfpokers,minNum)
        elseif t == CardType.CT_SINGLE_LINE then
            resultArr = self:FindAllSingleLine(selfpokers,minNum,#prepokers)
        elseif t == CardType.CT_DOUBLE_LINE then
            resultArr = self:FindAllDoubleLine(selfpokers,minNum,#prepokers/2)
        elseif t == CardType.CT_THREE_TAKE_ONE then
            resultArr = self:FindAllThreeTakeOne(selfpokers,minNum)
        elseif t == CardType.CT_THREE_TAKE_TWO then
            resultArr = self:FindAllThreeTakeTwo(selfpokers,minNum)
        elseif t == CardType.CT_FOUR_TAKE_ONE then
            resultArr = self:FindAllFourTakeOne(selfpokers,minNum)
        elseif t == CardType.CT_FOUR_TAKE_TWO then
            resultArr = self:FindAllFourTakeTwo(selfpokers,minNum)
        elseif t == CardType.CT_THREE_LINE then
            resultArr = self:FindAllThreeLine(selfpokers,minNum,#prepokers/3)
        elseif t == CardType.CT_THREE_LINE_S then
            resultArr = self:FindAllThreeLineS(selfpokers,minNum,#prepokers/4)
        elseif t == CardType.CT_THREE_LINE_B then
            resultArr = self:FindAllThreeLineB(selfpokers,minNum,#prepokers/5)
        end

        --获取所有的炸弹和王炸
        for k,v in pairs(self:FindAllBombAndMissile(selfpokers)) do
            table.insert(resultArr,v)
        end
        return resultArr
    end
end

--根据牌优先级合并成一个哈希表
function PokerManager:TOHashTable(selfPoker)
    local hashTable = {}
    for i=1,16 do
        hashTable[i] = {}
    end
    for k,v in pairs(selfPoker) do
        if v < 78 then
            table.insert(hashTable[self:GetGrad(v)],v)
        elseif v == 78 then
            hashTable[-1] = v
        elseif v == 79 then
            hashTable[-2] = v
        end
    end
    return hashTable
end

--找出所有符合条件的炸弹和王炸
function PokerManager:FindAllBombAndMissile(selfPokers,min)
    if min then
        if min == 16 then
            return false
        end
    else
        min = 0
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}
    for i=min+1,#hashTable do
        if #hashTable[i] == 4 then
            table.insert(resultArr,hashTable[i])
        end
    end
    if hashTable[-1] and hashTable[-2] then
        table.insert(resultArr,{hashTable[-1],hashTable[-2]})
    end
    return resultArr
end

--找出所有符合条件的炸弹
function PokerManager:FindAllBomb(selfPokers,min)
    if min then
        if min == 16 then
            return false
        end
    else
        min = 0
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}
    for i=min+1,#hashTable do
        if #hashTable[i] == 4 then
            table.insert(resultArr,hashTable[i])
        end
    end
    return resultArr
end

--找出所有符合条件的单牌
function PokerManager:FindSingles(selfPokers,min)
    if min then
        if min == 16 then
            return false
        end
    else
        min = 0
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}

    for i=min+1,#hashTable do
        if #hashTable[i] == 1 then
            table.insert(resultArr,hashTable[i])
        end
    end
    return resultArr
end

--找出所有符合条件的单牌
function PokerManager:FindAllSingle(selfPokers,min)
    if min then
        if min == 16 then
            return false
        end
    else
        min = 0
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}

    for i=min+1,#hashTable do
        if #hashTable[i] == 1 then
            table.insert(resultArr,hashTable[i])
        end
    end

    for i=min+1,#hashTable do
        if #hashTable[i] == 2 then
            table.insert(resultArr,{hashTable[i][1]})
            table.insert(resultArr,{hashTable[i][2]})
        end
    end

    for i=min+1,#hashTable do
        if #hashTable[i] == 3 then
            table.insert(resultArr,{hashTable[i][1]})
            table.insert(resultArr,{hashTable[i][2]})
            table.insert(resultArr,{hashTable[i][3]})
        end
    end

    return resultArr
end

--找出所有符合条件的对子
function PokerManager:FindAllDouble(selfPokers,min)
    if min then
        if min == 16 then
            return false
        end
    else
        min = 0
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}
    for i=min+1,#hashTable do
        if #hashTable[i] == 2 then
            table.insert(resultArr,hashTable[i])
        end
    end
    return resultArr
end

--找出所有符合条件的三条
function PokerManager:FindAllThree(selfPokers,min)
    if min then
        if min == 16 then
            return false
        end
    else
        min = 0
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}
    for i=1,#hashTable do
        if #hashTable[i] == 3 then
            table.insert(resultArr,hashTable[i])
        end
    end
    return resultArr
end

--找出所有符合条件的顺子
function PokerManager:FindAllSingleLine(selfPokers,min,count)
    -- print("min,count:",min,count)
    if min then
        if min == 16 then
            return {}
        end
    else
        min = 0
    end

    if count then
        if count == 13 then
            return {}
        end
        if count > #selfPokers then
            return {}
        end
    else
        count = 5
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}

    for i=min+1,16-count do
        local tempArr = {}
        for j=0,count-1 do
            if #hashTable[i+j] > 0 then
                table.insert(tempArr,hashTable[i+j][1])
            else
                break
            end
        end
        if #tempArr == count then
            table.insert(resultArr,tempArr)
        end
    end
    return resultArr
end

--找出所有符合条件的连对
function PokerManager:FindAllDoubleLine(selfPokers,min,count)
    -- print("min,count:",min,count)
    if min then
        if min == 16 then
            return {}
        end
    else
        min = 0
    end

    if count then
        if count == 13 then
            return {}
        end
        if count > #selfPokers then
            return {}
        end
    else
        count = 3
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}

    for i=min+1,16-count do
        local tempArr = {}
        for j=0,count-1 do
            if #hashTable[i+j] > 1 then
                table.insert(tempArr,hashTable[i+j][1])
                table.insert(tempArr,hashTable[i+j][2])
            else
                break
            end
        end
        if #tempArr == count*2 then
            table.insert(resultArr,tempArr)
        end
    end
    return resultArr
end

--找出所有符合条件的三带一
function PokerManager:FindAllThreeTakeOne(selfPokers,min)
    if min then
        if min == 16 then
            return {}
        end
        if #selfPokers < 4 then
            return {}
        end
    else
        min = 0
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}

    local threeArr = self:FindAllThree(selfPokers,min)
    if #threeArr > 0 then
        --找一个要带的单牌
        local singleCard = nil
        local singleArr = self:FindSingles(selfPokers)
        if #singleArr > 0 then
            singleCard = singleArr[1][1]
        else
            --没有单牌，优先从对子里找一个
            for i=1,#hashTable do
                if #hashTable[i]==2 then
                    singleCard = hashTable[i][1]
                    break
                end
            end
            --没有对子，从3条里找一个
            if singleCard == nil then
                for i=1,#hashTable do
                    if #hashTable[i]==3 and i ~= min then
                        singleCard = hashTable[i][1]
                        break
                    end
                end
            end
        end
        if singleCard then
            for i=1,#threeArr do
                table.insert(threeArr[i],singleCard)
                table.insert(resultArr,threeArr[i])
            end
            return resultArr
        else
            return {}
        end
    else
        return {}
    end
end

--找出所有符合条件的三带二
function PokerManager:FindAllThreeTakeTwo(selfPokers,min)
    if min then
        if min == 16 then
            return {}
        end
        if #selfPokers < 5 then
            return {}
        end
    else
        min = 0
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}

    local threeArr = self:FindAllThree(selfPokers,min)
    if #threeArr > 0 then
        --找一对要带的对子
        local doubleCardArr = {}
        local doubleArr = self:FindAllDouble(selfPokers)
        if #doubleArr > 0 then
            doubleCardArr = doubleArr[1]
        else
            for i=1,#hashTable do
                if #hashTable[i]==3 and i ~= min then
                    doubleCardArr = hashTable[i]
                    table.insert(doubleCardArr,hashTable[i][1])
                    table.insert(doubleCardArr,hashTable[i][2])
                    break
                end
            end
        end
        if #doubleCardArr == 2 then
            for i=1,#threeArr do
                table.insert(threeArr[i],doubleCardArr[1])
                table.insert(threeArr[i],doubleCardArr[2])
                table.insert(resultArr,threeArr[i])
            end
            return resultArr
        else
            return {}
        end
    else
        return {}
    end
end

--找出所有符合条件的四带两单
function PokerManager:FindAllFourTakeOne(selfPokers,min)
    if min then
        if min == 16 then
            return {}
        end
        if #selfPokers < 6 then
            return {}
        end
    else
        min = 0
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}

    local fourArr = self:FindAllBomb(selfPokers,min)
    if #fourArr > 0 then
        --找2个要带的单牌
        local singleCardArr = {}
        local singleArr = self:FindSingles(selfPokers)
        if #singleArr > 0 then
            for i=1,#singleArr do
                table.insert(singleCardArr,singleArr[i][1])
                if #singleCardArr == 2 then
                    break
                end
            end
        end
        if #singleCardArr < 2 then
            --没有2张单牌，优先从对子里找
            for i=1,#hashTable do
                if #hashTable[i]==2 then
                    if #singleCardArr == 0 then
                        singleCardArr = hashTable[i]
                    else
                        table.insert(singleCardArr,hashTable[i][1])
                    end
                    break
                end
            end
            --没有对子，从3条里找
            if #singleCardArr == 0 then
                for i=1,#hashTable do
                    if #hashTable[i]==3 and i ~= min then
                        table.insert(singleCardArr,hashTable[i][1])
                        if #singleCardArr == 0 then
                            table.insert(singleCardArr,hashTable[i][2])
                        end
                        break
                    end
                end
            end
        end
        if #singleCardArr == 2 then
            for i=1,#fourArr do
                table.insert(fourArr[i],singleCardArr[1])
                table.insert(fourArr[i],singleCardArr[2])
                table.insert(resultArr,fourArr[i])
            end
            return resultArr
        else
            return {}
        end
    else
        return {}
    end
end

--找出所有符合条件的四带两对
function PokerManager:FindAllFourTakeTwo(selfPokers,min)
    if min then
        if min == 16 then
            return {}
        end
        if #selfPokers < 8 then
            return {}
        end
    else
        min = 0
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}

    local fourArr = self:FindAllBomb(selfPokers,min)
    if #fourArr > 0 then
        --找2个要带的对子
        local doubleCardArr = {}
        local doubleArr = self:FindAllDouble(selfPokers)
        if #doubleArr == 2 then
            table.insert(doubleCardArr,doubleArr[1][1])
            table.insert(doubleCardArr,doubleArr[1][2])
            table.insert(doubleCardArr,doubleArr[2][1])
            table.insert(doubleCardArr,doubleArr[2][2])
        else
            if #doubleArr == 1 then
                table.insert(doubleCardArr,doubleArr[1][1])
                table.insert(doubleCardArr,doubleArr[1][2])
            end
            --不够2个对子，从3条里找2个
            if #doubleCardArr < 4 then
                for i=1,#hashTable do
                    if #hashTable[i]==3 and i ~= min then
                        table.insert(doubleCardArr,hashTable[i][1])
                        table.insert(doubleCardArr,hashTable[i][2])
                        if #doubleCardArr == 4 then
                            break
                        end
                    end
                end
            end
        end
        if #doubleCardArr == 4 then
            for i=1,#fourArr do
                table.insert(fourArr[i],doubleCardArr[1])
                table.insert(fourArr[i],doubleCardArr[2])
                table.insert(fourArr[i],doubleCardArr[3])
                table.insert(fourArr[i],doubleCardArr[4])
                table.insert(resultArr,fourArr[i])
            end
            return resultArr
        else
            return {}
        end
    else
        return {}
    end
end

--找出所有符合条件的飞机(三顺)
function PokerManager:FindAllThreeLine(selfPokers,min,count)
    if min then
        if min == 16 then
            return {}
        end
    else
        min = 0
    end

    if count then
        if count == 13 then
            return {}
        end
        if count > #selfPokers then
            return {}
        end
    else
        count = 3
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}

    for i=min+1,16-count do
        local tempArr = {}
        for j=0,count-1 do
            if #hashTable[i+j] > 2 then
                table.insert(tempArr,hashTable[i+j][1])
                table.insert(tempArr,hashTable[i+j][2])
                table.insert(tempArr,hashTable[i+j][3])
            else
                break
            end
        end
        if #tempArr == count*3 then
            table.insert(resultArr,tempArr)
        end
    end
    return resultArr
end

--找出所有符合条件的飞机带小翼(三顺+同数量单牌)
function PokerManager:FindAllThreeLineS(selfPokers,min,count)
    if min then
        if min == 16 then
            return {}
        end
        if #selfPokers < 12 then
            return {}
        end
    else
        min = 0
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}

    local threeArr = self:FindAllThreeLine(selfPokers,min,count)
    if #threeArr > 0 then
        --找count个要带的单牌
        local singleCardArr = {}
        local singleArr = self:FindSingles(selfPokers)
        if #singleArr > 0 then
            for i=1,#singleArr do
                table.insert(singleCardArr,singleArr[i][1])
                if #singleCardArr >= count then
                    break
                end
            end
        end

        if #singleCardArr<count then
            --不够单牌，优先从对子里找
            for i=1,#hashTable do
                if #hashTable[i]==2 then
                    table.insert(singleCardArr,hashTable[i][1])
                    if #singleCardArr<count then
                        table.insert(singleCardArr,hashTable[i][2])
                    else
                        break
                    end
                end
            end
        end
        if #singleCardArr<count then
            --不够单牌，从3条里找
            for i=1,#hashTable do
                if #hashTable[i]==3 and i ~= min then
                    -- singleCardArr = hashTable[i][1]
                    -- break
                    for j=1,#hashTable[i] do
                        table.insert(singleCardArr,hashTable[i][j])
                        if #singleCardArr >= count then
                            break
                        end
                    end
                    if #singleCardArr >= count then
                        break
                    end
                end
            end
        end
        if #singleCardArr == count then
            for i=1,#threeArr do
                for j=1,#singleCardArr do
                    table.insert(threeArr[i],singleCardArr[j])
                end
                table.insert(resultArr,threeArr[i])
            end
            return resultArr
        else
            return {}
        end
    else
        return {}
    end
end

--找出所有符合条件的飞机带大翼(三顺+同数量对子)
function PokerManager:FindAllThreeLineB(selfPokers,min,count)
    if min then
        if min == 16 then
            return {}
        end
        if #selfPokers < 15 then
            return {}
        end
    else
        min = 0
    end

    local hashTable = self:TOHashTable(selfPokers)
    local resultArr = {}

    local threeArr = self:FindAllThreeLine(selfPokers,min,count)
    if #threeArr > 0 then
        --找count个要带的对子
        local doubleCardArr = {}
        local doubleArr = self:FindAllDouble(selfPokers)
        if #doubleArr > 0 then
            for i=1,#doubleArr do
                table.insert(doubleCardArr,doubleArr[i][1])
                table.insert(doubleCardArr,doubleArr[i][2])
                if #doubleCardArr >= count*2 then
                    break
                end
            end
        end

        if #doubleCardArr<count*2 then
            --不够对子，从3条里找
            for i=1,#hashTable do
                if #hashTable[i]==3 and i ~= min then
                    table.insert(doubleCardArr,hashTable[i][1])
                    table.insert(doubleCardArr,hashTable[i][2])
                    if #doubleCardArr >= count*2 then
                        break
                    end
                end
            end
        end
        if #doubleCardArr == count*2 then
            for i=1,#threeArr do
                for j=1,#doubleCardArr do
                    table.insert(threeArr[i],doubleCardArr[j])
                end
                table.insert(resultArr,threeArr[i])
            end
            return resultArr
        else
            return {}
        end
    else
        return {}
    end
end

local myPoker = {22,38,54,23,39,55,24,40,56,9,10,26,11,27,12,28}

local r = PokerManager:TipsSendPokers({3,19,35,4,20,36,5,21,37,6,22,7,23,8,24},myPoker)
print("count:",#r)
print("\n")
for i=1,#r do
    if #r[i] == 1 then
        print("value:",r[i][1])
    else
        for k,v in pairs(r[i]) do
            io.write(v," ")
        end
    end
    print("\n")
end

 

夜雨成溪
关注
斗地主出牌算法(as版)
08-21
本算法采用ActionScript3.0动态脚本语言编写,是网页FLASH版斗地主客户端的核心程序!
二人斗地主-cocs2d-lua
10-15
用cocos2d-lua写的二人斗地主，以前运营过的，可用，有图片资源和csb文件等
Lua脚本的斗地主的提示出牌算法。
03-27
Lua脚本的斗地主的提示出牌算法。 包括： 查找某牌型的算法：查找所有的单牌，查找所有的对子，查找所有的三条，查找所有的单顺，双顺，飞机，飞机带单，飞机带双。 排序算法。 转成花色，转成点数， 比较算法等。
一种初级通用高度提炼的斗地主提示算法
最新发布
weixin_45043548的博客
02-08 635
一种初级通用高度提炼的斗地主提示算法
斗地主出牌算法(java版)
08-21
本算法采用Java语言编写,是网页FLASH版斗地主客户端的核心程序!
斗地主出牌算法
shaogeiwojijiwaiwai的博客
03-16 1600
根据斗地主出牌规则.对玩家出的牌进行检验.判断是否符合出牌规则. (关于斗地主的出牌规则网上有很多) 思路:将玩家的牌按升序排序.然后将牌进行拆分,分存在4个数组中.拆分规则如下: 假设有牌:333\444\555\789 则拆分后数组中的数据如下 arr[0]:345789 arr[1]:345 arr[2]:345 arr[3]:null ...
斗地主智能（AI）出牌算法
热门推荐
xdx2ct1314的专栏
01-26 4万+
去年有想写个斗地主的小游戏，自己玩玩。找了很多资料，后来好不容易在网上找到了一个AI算法。转过的的时候是贴在自己电脑的TXT文本上，再次感谢下原作者。现在借花献佛发给你参考下。    我以前写过一个斗地主机器人。思路如下，希望对你有帮助。   斗地主AI设计  一、牌型           1 火箭：大小王在一起的牌型，即双王牌，此牌型最大，什么牌型都可以打。           2 炸弹
斗地主提示牌
liang106415718的博客
09-18 590
斗地主提示牌 获取快速组合牌； 1、取王炸 2、取顺子组合 3、取炸弹飞机三张连对 4、给炸弹飞机三张配料如3带1,3 不过应该是不是先取连对特别的策略 //获取连对4455666 445566 6 44666 55 // 4455666 999 445566 6999 or 44666 55999 rule // 3个农民 /// </summary> typedef enum...
斗地主牌型相关算法
03-02
lua实现斗地主中的牌型判断，牌的比较，出牌提示的算法
斗地主服务端源码(含客户端程序)lua c# python
03-28
1. 游戏逻辑：执行游戏规则，判断胜负，处理玩家出牌、弃牌等操作。 2. 网络通信：接收并处理客户端的请求，将响应数据发送回客户端，确保游戏数据的实时同步。 3. 数据存储：保存用户信息、游戏记录、排行榜等数据...
斗地主 出牌大小判断算法 （无AI出牌功能）
10-05
用遍历的思想实现的算法，只实现了判断出牌是否符合规则，没有实现电脑的AI智能出牌（试过用hash队列实现，但颇有点复杂，写不下去了），再有也没有做全面的测试，希望有兴趣的朋友们如果测出了其中的bug请务必通知本人，先谢过了。第一 次传东西，请大家多支持 :))
斗地主出牌算法(cs版)
08-21
本算法采用C#(C Sharp)语言编写,是网页FLASH版斗地主客户端的核心程序!
斗地主算法(洗牌,发牌,出牌)flash
09-24
斗地主算法(洗牌,发牌,出牌)flash
斗地主核心算法
03-09
斗地主的核心相关算法，机器人和出牌提示可以在此基础上继续完善
斗地主ai机器人出牌叫分算法cpp源码
05-04
自己开发的简单的斗地主陪练机器人出牌算法，c++代码，无需修改，直接使用。 使用方法： https://blog.csdn.net/hhpp526/article/details/103159283 解压密码：hhpp526@hotmail.com
Lua实现欢乐斗地主游戏逻辑与癞子处理
在斗地主中，玩家需要根据手上的牌和已出的牌来决定最佳的出牌策略。这个函数可能涉及到对各种牌型的判断，包括单牌、对子、三张、顺子等，并且在有癞子的情况下，还需要考虑癞子牌如何与其他牌组合。例如，如果手中...
unity开发 斗地主算法—提示AI（提示出牌）
csdn_cjt的博客
11-27 8230
牌型的定义在http://blog.csdn.net/csdn_cjt/article/details/78593140 第一章 这是第四章 下面是代码 #region 提示出牌 public static Dictionary> FindPromptCards(List myCards, List lastCards, DDZ_P
java 斗地主出牌算法_斗地主AI算法——第七章の被动出牌(1)
weixin_35361243的博客
03-07 661
哎，之前扯了那么多蛋，终于讲出牌了！本章开始讲被动出牌的逻辑算法。首先我们先把架子搭起来，被动出牌我们肯定是要知道场上目前打出的是什么牌型。在第二章数据结构里我们定义过，游戏全局类里面有一个存放当前牌型结构的成员，即//当前打出牌的类型数据，被动出牌时玩家根据这里做出筛选CardGroupDatauctNowCardGroup;我们即将通过他进行类型的筛选，所以肯定是要枚举各类牌型的，也就是这个...
斗地主AI算法——第八章の被动出牌(2)
九日王朝
04-27 7827
上一章我们已经搭好了被动出牌的基本架子，本章我们主要解决面对不同牌型分支的出牌策略问题。 在这里我把出牌逻辑分为四个阶段，也就是策略的优先级。分别是：【直接打光手牌】→【同类型牌压制】→【炸弹王炸压制】→【不出】 第一阶段【直接打光手牌】就是说如果我们可以一次性把手牌打出，那就不用考虑接下来价值之类的问题了，因为已经赢了。这种情况可能是对方打出的牌型和你一样且你比他大，或者你剩的牌是炸
评论 5
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值