Update pots throughout hands

game.go

@@ -265,6 +265,50 @@ func (g *Game) updateRoundInfo() {
 		}
 	}
 
+	// Update the pot information
+
+	sort.Slice(allInPlayerNums, func(i, j int) bool {
+		return g.players[allInPlayerNums[i]].TotalBet < g.players[allInPlayerNums[j]].TotalBet
+	}) //here, the whole slice needs to be sorted by the totalBet amount of the players represented
+
+	tmpPlayers := append([]player{}, g.players...)
+	g.pots = []Pot{}
+	for _, ndx := range allInPlayerNums {
+
+		newPot := Pot{}
+		newPot.TopShare = tmpPlayers[ndx].TotalBet
+
+		for i := range tmpPlayers {
+
+			if tmpPlayers[i].TotalBet >= newPot.TopShare {
+				if tmpPlayers[i].In {
+					newPot.EligiblePlayerNums = append(newPot.EligiblePlayerNums, uint(i))
+				}
+				newPot.Amt += newPot.TopShare
+				tmpPlayers[i].TotalBet -= newPot.TopShare
+			} else {
+				newPot.Amt += tmpPlayers[i].TotalBet
+				tmpPlayers[i].TotalBet = 0
+			}
+		}
+
+		g.pots = append(g.pots, newPot)
+	}
+
+	//The above takes care of all the all-in side pots. One last pot for the non-all-in people
+
+	var finalPot Pot
+	finalPot.EligiblePlayerNums = []uint{}
+
+	for i, p := range tmpPlayers {
+		if p.In && !p.allIn() {
+			finalPot.EligiblePlayerNums = append(finalPot.EligiblePlayerNums, uint(i))
+			finalPot.Amt += p.TotalBet
+		}
+	}
+
+	g.pots = append(g.pots, finalPot)
+
 	// If less than two players are still in, the hand has been conceded
 	if len(inPlayerNums) < 2 {
 		//the sole number in the array is the winner by default
@@ -292,8 +336,8 @@ func (g *Game) updateRoundInfo() {
 	//If there are two or more players in, and everybody has either called or is all-in, and at this point we determine that only one player is
 	//in but not all in, we take all the money above and beyond the second highest better (who is all in) and return it to the people who bet it
 	//If the only players in are both all in for the exact same amount of money, nothing happens here
-	//(but we can't skip in the "0 not all in" case because technically before this step happens) a player who after this step may read as not all in
-	//could return true for the isAllIn method
+	//(but we can't skip in the "0 not all in" case because technically before this step happens a player who after this step may read as not all in
+	//could return true for the isAllIn method)
 	if len(inPlayerNums)-len(allInPlayerNums) < 2 {
 		var topBettor1 uint = 0
 		var topBettor2 uint = 0
@@ -313,37 +357,10 @@ func (g *Game) updateRoundInfo() {
 	//If there are two or more players in, and everybody has called or is all in, then end the hand f we've just finished river betting
 	if g.getStage() == River {
 
-		sort.Slice(allInPlayerNums, func(i, j int) bool {
-			return g.players[allInPlayerNums[i]].TotalBet < g.players[allInPlayerNums[j]].TotalBet
-		}) //here, the whole slice needs to be sorted by the totalBet amount of the players represented
-
-		var pots []Pot
-		for _, ndx := range allInPlayerNums {
-
-			newPot := Pot{}
-			newPot.TopShare = g.players[ndx].TotalBet
-
-			for i := range g.players {
-
-				if g.players[i].TotalBet >= newPot.TopShare {
-					if g.players[i].In {
-						newPot.EligiblePlayerNums = append(newPot.EligiblePlayerNums, uint(i))
-					}
-					newPot.Amt += newPot.TopShare
-					g.players[i].TotalBet -= newPot.TopShare
-				} else {
-					newPot.Amt += g.players[i].TotalBet
-					g.players[i].TotalBet = 0
-				}
-			}
-
-			pots = append(pots, newPot)
-		}
-
-		for i := range pots {
-			pots[i].WinningScore = 8000
+		for i := range g.pots {
+			g.pots[i].WinningScore = 8000
 
-			for _, num := range pots[i].EligiblePlayerNums {
+			for _, num := range g.pots[i].EligiblePlayerNums {
 
 				hand, score := BestFiveOfSeven(
 					g.players[num].Cards[0],
@@ -355,62 +372,21 @@ func (g *Game) updateRoundInfo() {
 					g.communityCards[4],
 				)
 				// lower is better for the score
-				if score < pots[i].WinningScore {
-					pots[i].WinningScore = score
-					pots[i].WinningPlayerNums = []uint{num}
-					pots[i].WinningHand = hand
-				} else if score == pots[i].WinningScore {
-					pots[i].WinningPlayerNums = append(pots[i].WinningPlayerNums, num)
+				if score < g.pots[i].WinningScore {
+					g.pots[i].WinningScore = score
+					g.pots[i].WinningPlayerNums = []uint{num}
+					g.pots[i].WinningHand = hand
+				} else if score == g.pots[i].WinningScore {
+					g.pots[i].WinningPlayerNums = append(g.pots[i].WinningPlayerNums, num)
 				}
 			}
 
-			for _, num := range pots[i].WinningPlayerNums {
-				g.players[num].Stack += (pots[i].Amt / uint(len(pots[i].WinningPlayerNums)))
+			for _, num := range g.pots[i].WinningPlayerNums {
+				g.players[num].Stack += (g.pots[i].Amt / uint(len(g.pots[i].WinningPlayerNums)))
 				//TODO: leave the remainder in the middle! (some money will disappear currently)
 			}
 		}
 
-		//The above takes care of all the all-in side pots. One last pot for the non-all-in people
-
-		var finalPot Pot
-		finalPot.EligiblePlayerNums = []uint{}
-
-		finalPot.WinningScore = 8000
-
-		for i, p := range g.players {
-			if p.In && !p.allIn() {
-				finalPot.EligiblePlayerNums = append(finalPot.EligiblePlayerNums, uint(i))
-				finalPot.Amt += p.TotalBet
-				p.TotalBet = 0
-
-				hand, score := BestFiveOfSeven(
-					p.Cards[0],
-					p.Cards[1],
-					g.communityCards[0],
-					g.communityCards[1],
-					g.communityCards[2],
-					g.communityCards[3],
-					g.communityCards[4],
-				)
-				// lower is better for the score
-				if score < finalPot.WinningScore {
-					finalPot.WinningScore = score
-					finalPot.WinningPlayerNums = []uint{uint(i)}
-					finalPot.WinningHand = hand
-				} else if score == finalPot.WinningScore {
-					finalPot.WinningPlayerNums = append(finalPot.WinningPlayerNums, uint(i))
-				}
-			}
-		}
-
-		for _, p := range finalPot.WinningPlayerNums {
-			g.players[p].Stack += (finalPot.Amt / uint(len(finalPot.WinningPlayerNums)))
-		}
-
-		if finalPot.Amt != 0 {
-			g.pots = append(pots, finalPot)
-		}
-
 		g.resetForNextHand()
 
 		// otherwise, just set betting to false so the dealer can deal the next part of the hand