德州扑克分池算法 思路及lua实现

这里主要就德州扑克如何进行分池做分析

主池:当轮次下注数相同的部分进入主池

分池:当轮次下注不足时,多出的部分

分池出现的原因就是有人allin啦,当allin的人数逐渐增多,allin数值又不相同的情况下,就会出现多个分池啦!

分池思路:

根据allin的玩家数来分池,如果allin玩家只有一位,那么当轮只有一个主池.下一轮有玩家下注时开始出现边池,接下来所有玩家的注都进入第一个边池. 依次类推,直到游戏结束.

根据玩家进行的分池分析(这里只考虑出现allin玩家的情况):

--弃牌玩家:   弃牌玩家的注根据allin玩家的下注数进池

--跟注玩家:  跟注玩家一定是当轮下注最多的,所以每一个池内都会有跟注玩家下的注

--allin玩家 : alin最小的玩家只参与主池, alin最大的玩家判断是否与下注最大相同,  相同:从主池参与到最后出现的池  不相同:参与到倒数第二个出现的池

首先将allin的玩家数进行排序,

allin玩家为n位,当n>=2时,alin最小的玩家只参与主池,判断allin最大值是否与小于注玩家下注数,小于则有n+1个池,相等则有n个池.  此时对应的池中的注为:  allin[n]*参与该池下注的非弃牌玩家数+(弃牌玩家下注-allin[n-1])     ,没有allin[n-1]时为0

赢家拿走参与过的池,赢家未参与的池退回给多下注的玩家

local function FlytoWhere(allin,normal,abandon)
    --对玩家进行排序  
    --allinplayer{{allin玩家索引，allin数值}} normalplayer{{跟注玩家索引，下注数值}} abandonplayer{{弃牌玩家索引,弃牌数值}}    
    local  allinplayer={} 
    local  normalplayer={}
    local  abandonplayer={}
    if not (allin and #allin>0) then
			allinplayer=nil
    else
        for n=1,#allin do
            if allin[n] and allin[n][2]>0 then
                table.insert(allinplayer,{allin[n][1],allin[n][2]})
            end
        end
	end
	if not (normal and #normal>0) then
		normalplayer=nil
    else
        for n=1,#normal do
            if normal[n] and normal[n][2]>0 then
                table.insert(normalplayer,{normal[n][1],normal[n][2]})
            end
        end
	end
   
    if not (abandon and #abandon>0) then
		abandonplayer=nil
    else
        print("abandon :"..#abandon)
        for n=1,#abandon do
            if abandon[n] and abandon[n][2]>0 then
                table.insert(abandonplayer,{abandon[n][1],abandon[n][2]})
            end
        end
	end

--排序完毕  计算池的数量

if not (allinplayer and #allinplayer>0) then
        allinplayer=nil
    end
    if not (abandonplayer and #abandonplayer>0) then
        abandonplayer=nil
    end
    if not (normalplayer and #normalplayer>0) then
        normalplayer=nil
    end

if allinplayer and abandonplayer then
        --根据allin筹码计算出每池最低进入筹码 
        local Cmtab={} 
        if normalplayer then
            if normalplayer[1][2]>allinplayer[#allinplayer][2] then
                table.insert(Cmtab,normalplayer[1][2])
            end
        end

            for n=2,#allinplayer do 
				if allinplayer[n-1][2]~=allinplayer[n][2] then  --Allin的值不同，分池
					table.insert(Cmtab,allinplayer[n-1][2])
				end
		    end

        table.insert(Cmtab,allinplayer[#allinplayer][2])--加入最后最小的池
            for x=1,#abandonplayer do
                if abandonplayer[x][2]>0 then
                    --判断弃牌有注玩家进入哪一个池中
                    for m=1,#Cmtab do
                        if abandonplayer[x][2]>=Cmtab[m] then --allin是由大到小排序的,所以Cmtab中也是由大到小排序
                            if abandonplayer[x][2]==Cmtab[m] then --判断到底是大于还是等于
                                print("玩家:"..abandonplayer[x],"下注进入池"..(#Cmtab-m+1).."  一共产生了"..#Cmtab.."个池")
                            else
                                print("玩家:"..abandonplayer[x],"下注进入池"..(#Cmtab-m+2).."  一共产生了"..#Cmtab.."个池")   
                            end 
                           break
                        elseif m==#Cmtab then
                            print("玩家:"..abandonplayer[x],"下注进入池"..1.."  一共产生了"..#Cmtab.."个池")
                            --弃牌但有注,但为最小注,直接进底池
                        end
                    end    
                end
            end
    end