dkforest

commit bd884d173c6c7dca2eb31dcf76b9119641a6f047
parent 18bd51b4e0b9431a9f0249cac82f13af366fd3ed
Author: n0tr1v <n0tr1v@protonmail.com>
Date:   Thu,  7 Dec 2023 17:46:21 -0500

fix split pot

Diffstat:
M
pkg/web/handlers/poker/poker.go
 | 
28
+++++++++++++++++++---------
M
pkg/web/handlers/poker/poker_test.go
 | 
30
++++++++++++++++++++++++++++++

2 files changed, 49 insertions(+), 9 deletions(-)
diff --git a/pkg/web/handlers/poker/poker.go b/pkg/web/handlers/poker/poker.go
@@ -712,7 +712,10 @@ END:
 	mainPot := g.Ongoing.MainPot
 	g.Ongoing.MainPotMtx.RUnlock()
 
-	winnersStr, winnerHand := processPot(winners, len(g.Players), mainPot)
+	winnersStr, winnerHand, playersGain := processPot(winners, len(g.Players), mainPot)
+	for _, el := range playersGain {
+		el.Player.Cash += el.Gain
+	}
 
 	g.Ongoing.MainPotMtx.Lock()
 	g.Ongoing.MainPot = 0
@@ -740,14 +743,19 @@ END:
 	g.IsGameStarted.Store(false)
 }
 
-func processPot(winners []GameResult, nbPlayers, mainPot int) (winnersStr, winnerHand string) {
+type PlayerGain struct {
+	Player *PokerPlayer
+	Gain   int
+}
+
+func processPot(winners []GameResult, nbPlayers, mainPot int) (winnersStr, winnerHand string, res []PlayerGain) {
 	if len(winners) == 0 {
 		logrus.Error("winners has len 0")
 	} else if len(winners) == 1 && len(winners[0].Players) == 1 {
 		// Everyone fold but 1 player
 		player := winners[0].Players[0]
 		winnerHand = "Only player alive"
-		player.Cash += mainPot
+		res = append(res, PlayerGain{player, mainPot})
 		winnersStr += player.Username
 	} else {
 		isDone := true
@@ -757,27 +765,29 @@ func processPot(winners []GameResult, nbPlayers, mainPot int) (winnersStr, winne
 				// Only 1 player win and is not all-in
 				player := group.Players[0]
 				winnerHand = poker.RankString(group.HandScore)
-				player.Cash += mainPot
+				res = append(res, PlayerGain{player, mainPot})
 				winnersStr += player.Username
 			} else if len(group.Players) == 1 && group.Players[0].Cash == 0 {
 				// Only 1 player win but is all-in
 				player := group.Players[0]
 				maxGain := player.RoundTotalBet * nbPlayers
-				player.Cash += maxGain
+				res = append(res, PlayerGain{player, maxGain})
 				mainPot -= maxGain
 				isDone = false
 			} else if len(group.Players) > 1 {
 				// Multiple winners, split pot
 				nbPlayersInGroup := len(group.Players)
+				expectedSplit := mainPot / nbPlayersInGroup
 				allInCount := 0
 				for _, p := range group.Players {
 					if p.Cash == 0 { // all-in
 						allInCount++
 						maxGain := p.RoundTotalBet * nbPlayers
-						piece := maxGain / nbPlayersInGroup
-						p.Cash += piece
+						piece := min(maxGain, expectedSplit)
+						res = append(res, PlayerGain{p, piece})
 						mainPot -= piece
 						winnersStr += p.Username
+						expectedSplit = mainPot / (nbPlayersInGroup - allInCount)
 					}
 				}
 				if allInCount == nbPlayersInGroup {
@@ -787,7 +797,7 @@ func processPot(winners []GameResult, nbPlayers, mainPot int) (winnersStr, winne
 				piece := mainPot / (nbPlayersInGroup - allInCount) // TODO: fix this
 				for _, p := range group.Players {
 					if p.Cash > 0 {
-						p.Cash += piece
+						res = append(res, PlayerGain{p, piece})
 						winnersStr += p.Username
 					}
 				}
@@ -798,7 +808,7 @@ func processPot(winners []GameResult, nbPlayers, mainPot int) (winnersStr, winne
 			}
 		}
 	}
-	return winnersStr, winnerHand
+	return winnersStr, winnerHand, res
 }
 
 func cardToPokerCard(name string) string {
diff --git a/pkg/web/handlers/poker/poker_test.go b/pkg/web/handlers/poker/poker_test.go
@@ -44,3 +44,33 @@ func Test_sortGameResults(t *testing.T) {
 	assert.Equal(t, "p3", arr[0].Players[2].Username)
 	assert.Equal(t, "p4", arr[0].Players[3].Username)
 }
+
+func Test_processPot(t *testing.T) {
+	p1 := &PokerPlayer{Cash: 0, RoundTotalBet: 100, Username: "p1"}
+	p2 := &PokerPlayer{Cash: 0, RoundTotalBet: 200, Username: "p2"}
+	p3 := &PokerPlayer{Cash: 0, RoundTotalBet: 300, Username: "p3"}
+	p4 := &PokerPlayer{Cash: 1, RoundTotalBet: 400, Username: "p4"}
+	arr := []GameResult{
+		{1, []*PokerPlayer{p2, p4, p1, p3}},
+	}
+	sortGameResults(arr)
+	_, _, res := processPot(arr, 4, 1000)
+	assert.Equal(t, 250, res[0].Gain)
+	assert.Equal(t, 250, res[1].Gain)
+	assert.Equal(t, 250, res[2].Gain)
+	assert.Equal(t, 250, res[3].Gain)
+
+	p1 = &PokerPlayer{Cash: 0, RoundTotalBet: 10, Username: "p1"}
+	p2 = &PokerPlayer{Cash: 0, RoundTotalBet: 20, Username: "p2"}
+	p3 = &PokerPlayer{Cash: 0, RoundTotalBet: 300, Username: "p3"}
+	p4 = &PokerPlayer{Cash: 1, RoundTotalBet: 400, Username: "p4"}
+	arr = []GameResult{
+		{1, []*PokerPlayer{p2, p4, p1, p3}},
+	}
+	sortGameResults(arr)
+	_, _, res = processPot(arr, 4, 1000)
+	assert.Equal(t, 40, res[0].Gain)
+	assert.Equal(t, 80, res[1].Gain)
+	assert.Equal(t, 440, res[2].Gain)
+	assert.Equal(t, 440, res[3].Gain)
+}