0

嗨，我正在开发一个扑克应用程序，但在分配边池时遇到了一些麻烦。

主要问题是我不知道如何分配弃牌玩家的筹码（死筹码）。

现在我的代码执行以下操作：

  1. 获得全押玩家的最低赌注。
  2. 将其乘以下注超过该金额的玩家数量。
  3. 将底池交给下注超过金额的玩家之间的赢家。
  4. 将全押减去以下边池。
  5. 重复第 1 点，直到没有更多的花盆可供分配。

当所有玩家全押时，这是有效的，但如果有人弃牌，事情就会变得棘手。

例如：

A bet(200). 

B all-in (80). 

C all-in (400). 

A folds. 

B wins the hand.

所以第一个底池将是 B(80) + C(80)，剩下的将给 C。

答：+0。

乙：+80。

C：+520。

显然这里做错了什么，因为 B 有权争取 A 下注的 80 个筹码。

4

2 回答 2

2

考虑每个玩家下注的第 n 个筹码。有资格获得该筹码的玩家是那些没有弃牌并且至少下注 n 的玩家。将筹码分配给持有最佳手牌的合格玩家。

在您的示例中：

A 200 fold
B 80  call  [best hand]
C 400 call
  • A 的筹码 1-80 有 2 名符合条件的玩家（B 和 C），B 拥有最好的牌。所以 B 取 80。
  • 来自 A 的筹码 81-200 有 1 名符合条件的玩家 (C)。C 需要 120。
  • B 的筹码 1-80 有 2 名符合条件的玩家（B 和 C），B 拥有最好的牌。所以 B 取 80。
  • C 的筹码 1-80 有 2 名符合条件的玩家（B 和 C），B 拥有最好的牌。所以 B 取 80。
  • 来自 C 的筹码 81-400 有 1 名符合条件的玩家 (C)。C 需要 320。

总体而言，B 需要 240，C 需要 440。

我把描述写成一个个工作的筹码，但是你可以优化（就像我在工作示例中所做的那样），考虑所有没有弃牌的玩家的下注大小（即：在你的 80 和 400例子）。

于 2020-07-01T08:54:24.043 回答
1

此代码应处理所有情况，并处理将筹码分配给弃牌玩家。我猜你的代码已经完成了很长时间，但是当我处理这个扑克边锅问题时，我无法在 StackOverflow 上找到有意义的代码示例，所以我分享我自己的......

using System;
using System.Collections.Generic;

public class Player
{
    public ulong potCommitment;
    public uint handStrength;
    public ulong chipsRemaining;
    public bool folded = false;
    public Player(ulong pc, uint hs, ulong chipsBehind, bool isFolded): this(pc, hs, chipsBehind)
    {
        folded = isFolded;
    }

    public Player(ulong pc, uint hs, ulong chipsBehind)
    {
        potCommitment = pc;
        handStrength = hs;
        chipsRemaining = chipsBehind;
    }
}

public class Program
{
    public static List<Player> winners = new List<Player>();
    public static List<Player> players = new List<Player>();
    public static void Main()
    {
        players.Add(new Player(200, 60, 0, true));
        players.Add(new Player(80, 100, 0));
        players.Add(new Player(400, 85, 0, false));
        
        // Loop through players until no unclaimed chips in pot.
        while (PotChipsRemaining(players) > 0)
            PayOutWinners(CalculateAndSortWinners(players), players);

        // Refund players if remaining chips in pot (bigger/folded stacks)
        foreach (var player in players)
        {
            player.chipsRemaining += player.potCommitment;
            player.potCommitment = 0;
        }

        Console.WriteLine($"***********************\nFinal results:");
        PotChipsRemaining(players);
    }

    public static List<Player> CalculateAndSortWinners(List<Player> playersInHand)
    {
        uint highHand = 0;
        // Get highHand, skipping folded and empty pots
        foreach (var player in players) if (player.potCommitment > 0 && !player.folded)
        {
            if (player.handStrength > highHand)
            {
                winners.Clear();
                highHand = player.handStrength;
                winners.Add(player);
            }
            else if (player.handStrength == highHand)
            {
                winners.Add(player);
            }
        }

        winners.Sort((x, y) => x.potCommitment.CompareTo(y.potCommitment));
        return winners;
    }

    public static void PayOutWinners(List<Player> winners, List<Player> playersInHand)
    {
        ulong collectedSidePot;
        ulong currentCommitment, collectionAmount;
        List<Player> paidWinners = new List<Player>();
        foreach (var playerPot in winners)
        {
            collectedSidePot = 0;
            currentCommitment = playerPot.potCommitment;
            // Collect from all players who have money in pot
            foreach (var player in playersInHand) if (player.potCommitment > 0)
                {
                    collectionAmount = Math.Min(currentCommitment, player.potCommitment);
                    player.potCommitment -= collectionAmount;
                    collectedSidePot += collectionAmount;
                }

            int winnersToPay = 0;
            Console.WriteLine($"winners.count {winners.Count}");
            
            foreach (var player in winners) if (paidWinners.IndexOf(player) == -1) winnersToPay++;

            Console.WriteLine($"collectedSidePot: {collectedSidePot}  winnersToPay: {winnersToPay}");
            
            // Pay unpaid winners, tip dealer with remainders...
            foreach (var player in winners) if (paidWinners.IndexOf(player) == -1)
            {
                player.chipsRemaining += collectedSidePot / (ulong)winnersToPay;
                if (player.potCommitment <= 0)
                {
                    paidWinners.Add(player);
                    Console.WriteLine($"Player {players.IndexOf(player)} paid out.");
                }
            }
        }
        winners.Clear();
    }

    // Only count potchips for unfolded players. Also prints status to Console.
    public static ulong PotChipsRemaining(List<Player> playersInHand)
    {
        ulong tally = 0;
        foreach (var player in playersInHand) if (!player.folded)
            {
                Console.WriteLine($"Player {players.IndexOf(player)} chips: {player.chipsRemaining}  Commitment: {player.potCommitment} \tHandStrength: {player.handStrength}\tFolded: {player.folded}");
                tally += player.potCommitment;
            }

        foreach (var player in playersInHand) if (player.folded)
                Console.WriteLine($"Player {players.IndexOf(player)} chips: {player.chipsRemaining}  Commitment: {player.potCommitment} \tHandStrength: {player.handStrength}\tFolded: {player.folded}");

        return tally;
    }
}

根据您的示例，我得到以下结果：

Final results:
Player A chips: 0      HandStrength: 60    Folded: True
Player B chips: 240    HandStrength: 100   Folded: False
Player C chips: 440    HandStrength: 85    Folded: False

如果您有任何问题，请告诉我。

这是小提琴，所以可以测试场景： https ://dotnetfiddle.net/P0wgR5

于 2021-10-12T00:30:17.480 回答