Poker split / side pots

Ecco un codice funzionante per creare e distribuire le vincite dai side-pot.

class Player:
    def __init__(self, l, i, hs):
        self.live = l #False
        self.invested = i #0
        self.hand_strength = hs #100
        self.result = 0

def distribute(pot, players):
    for p in players:
        p.result= -p.invested # invested money is lost originally

    # while there are still players with money
    # we build a side-pot matching the lowest stack and distribute money to winners
    while len(players)>1 :
        min_stack = min([p.invested for p in players])
        pot += min_stack * len(players)
        for p in players:
            p.invested -= min_stack
        max_hand = max([p.hand_strength for p in players if p.live])
        winners = [p for p in players if p.hand_strength == max_hand if p.live]
        for p in winners:
            p.result += pot / len(winners)
        players = [p for p in players if p.invested > 0]
        pot = 0
    if len(players) == 1:
        p = players[0]
        # return uncalled bet
        p.result += p.invested

Questo esempio mostra un caso in cui ci sono 5 giocatori e il piatto iniziale è 100. Il piatto principale è diviso tra giocatori che sono allin per 20 e 80. Un giocatore ha foldato dopo aver investito 50 e la sua mano migliore è stata sprecata. Un giocatore ha sorpassato tutti gli altri e la sua scommessa gli viene restituita mentre perde solo l'importo corrispondente dagli altri giocatori (80)

players = [Player(True, 20, 100),  Player(False, 50, 200),  Player(True, 80, 90),  Player(True, 80, 100), Player(True, 1000, 0)]
distribute(100, players)
for p in players:
    print(p.result)
#80.0
#-50
#-80
#230.0
#-80    

Nel mio codice, dopo che ogni giocatore ha parlato, per ogni puntata nel set delle puntate dei giocatori che sono ancora in gioco, creo un piatto. Poi ordino i piatti dal più piccolo (quello che sarà il piatto principale) al più alto (vasi laterali). I vasi laterali sono rappresentati come una lista, in questo formato: [quota necessaria, importo del piatto].

Per il piatto principale, la "quantità del piatto" sarà uguale a: "puntata necessaria" * numero di giocatori (inclusi quelli che hanno foldato) con una puntata uguale o superiore alla "puntata necessaria".

Per i rimanenti piatti, la "quantità del piatto" sarà uguale a: ("necessaria scommessa" - necessaria puntata del piatto che precede questa nella lista) * numero di giocatori con una puntata uguale o superiore alla "puntata necessaria"

L'algoritmo di base è il dead chips (fold) + i chip minimi impegnati sono distribuiti tra i vincitori della mano (piatto principale). Se dopo questo, ci sono ancora chip rimasti nel piatto, il processo viene ripetuto (per ogni piatto secondario).

Diciamo che alla fine di una mano c'erano tre giocatori all-in e $ 300 in gettoni morti:

P1 ha spinto $ 50, P2 ha spinto $ 100 e P3 ha spinto $ 150.

Scenario 1

Se le mani fossero uguali (piatto a 3 vie), tutti otterrebbero $ 150 nella prima iterazione.

Nel prossimo, P2 & P3 raccoglierebbe altri $ 50. Nell'ultima versione, P3 raccoglierà altri $ 50.

Quindi le vincite sarebbero:

P1 $ 150

P2 $ 200

P3 $ 250

Scenario 2

Supponiamo che vinca P1.

P1 raccoglie $ 450 (i suoi $ 50 e $ 50 ciascuno da P2 e P3 + $ 300 gettoni morti).

Nella prossima iterazione, diciamo che nessuna mano vince a titolo definitivo (a livello di bordo). P2 raccoglierà il piatto laterale 1 ($ 50) e P3 raccoglierà il piatto laterale 2 ($ 100).

Traccia solo la puntata totale per giocatore e se sono piegati o meno

1) determinare la puntata minima da parte di tutti i giocatori nel piatto     e giocatore non piegato

2) rimuovi quella somma da ogni scommessa di ogni giocatore (anche piegato)     e sommarlo in un vaso laterale

3) basato sulla forza della mano divaga su quel piatto laterale per i giocatori stack     se uno split (pareggio) e ci sono chips dispari, allora assegna la mia posizione alla mano

4) ripristina il side-pot a zero (più a sinistra)

5) vai a 1) se a qualsiasi giocatore qualsiasi giocatore ha qualche scommessa a sinistra     (una mano non può finire con ogni mano piegata)