From b37ddc5ace00dd1e49c0bd8f7b7f586d636edf33 Mon Sep 17 00:00:00 2001 From: Matt Turnbull Date: Fri, 19 Dec 2008 03:01:45 +0000 Subject: [PATCH] So close, yet so far. Need to calculate rake to output the side pots line correctly. --- pyfpdb/Hand.py | 152 +++++++++++++++++++++++++++++++++++++++++++++++-- 1 file changed, 148 insertions(+), 4 deletions(-) diff --git a/pyfpdb/Hand.py b/pyfpdb/Hand.py index f4a7bec7..f06a7926 100644 --- a/pyfpdb/Hand.py +++ b/pyfpdb/Hand.py @@ -307,8 +307,13 @@ Add a raise on [street] by [player] to [amountTo] self.totalpot = 0 + #print "[POT] stack list" + #print dict([(player[1], Decimal(player[2])) for player in self.players]) + players_who_act_preflop = set([x[0] for x in self.actions['PREFLOP']]) + self.pot = Pot(players_who_act_preflop) - for street in self.actions: + #for street in self.actions: + for street in [x for x in self.streetList if x in self.actions]: uncalled = 0 calls = [0] for act in self.actions[street]: @@ -317,18 +322,30 @@ Add a raise on [street] by [player] to [amountTo] uncalled = Decimal(act[2]) # only the last bet or raise can be uncalled calls = [0] print "uncalled: ", uncalled + + self.pot.addMoney(act[0], Decimal(act[2])) + elif act[1] == 'raises': # [name, 'raises', amountby, amountto, amountcalled] print "calls %s and raises %s to %s" % (act[4],act[2],act[3]) self.totalpot += Decimal(act[2]) + Decimal(act[4]) calls = [0] uncalled = Decimal(act[2]) print "uncalled: ", uncalled + + self.pot.addMoney(act[0], Decimal(act[2])+Decimal(act[4])) + elif act[1] == 'calls': # [name, 'calls', amount] self.totalpot += Decimal(act[2]) calls = calls + [Decimal(act[2])] print "calls:", calls + + self.pot.addMoney(act[0], Decimal(act[2])) + elif act[1] == 'posts': self.totalpot += Decimal(act[3]) + + self.pot.addMoney(act[0], Decimal(act[3])) + if act[2] == 'big blind': # the bb gets called by out-of-blinds posts; but sb+bb only calls bb if uncalled == Decimal(act[3]): # a bb is already posted @@ -343,14 +360,15 @@ Add a raise on [street] by [player] to [amountTo] uncalled = Decimal(act[3]) calls = [0] pass - + elif act[1] == 'folds': + self.pot.addFold(act[0]) if uncalled > 0 and max(calls+[0]) < uncalled: print "DEBUG returning some bet, calls:", calls print "DEBUG returned: %.2f from %.2f" % ((uncalled - max(calls)), self.totalpot,) self.totalpot -= (uncalled - max(calls)) print "DEBUG new totalpot:", self.totalpot - + print "DEBUG new Pot.total:", self.pot if self.totalcollected is None: self.totalcollected = 0; @@ -446,7 +464,8 @@ Map the tuple self.gametype onto the pokerstars string describing it print >>fh, "DEBUG: what do they show" print >>fh, _("*** SUMMARY ***") - print >>fh, _("Total pot $%s | Rake $%.2f" % (self.totalpot, self.rake)) # TODO: side pots + print >>fh, "%s | Rake $%.2f" % (self.pot, self.rake) + #print >>fh, _("Total pot $%s | Rake $%.2f" % (self.totalpot, self.rake)) # TODO: side pots board = [] for s in self.board.values(): @@ -544,3 +563,128 @@ Map the tuple self.gametype onto the pokerstars string describing it class FpdbParseError(Exception): pass + +class Pot(object): + + def __init__(self, contenders): + self.contenders = contenders + self.committed = dict([(player,Decimal(0)) for player in contenders]) + self.total = Decimal(0) + + def addFold(self, player): + self.contenders.remove(player) + + def addMoney(self, player, amount): + self.committed[player] += amount + + def __str__(self): + self.total = sum(self.committed.values()) + committed = sorted([ (v,k) for (k,v) in self.committed.items()]) + lastbet = committed[-1][0] - committed[-2][0] + if lastbet > 0: # uncalled + returnto = committed[-1][1] + #print "returning %f to %s" % (lastbet, returnto) + self.total -= lastbet + self.committed[returnto] -= lastbet + + + + # now: for those contenders still contending.. + commitsall = sorted([(v,k) for (k,v) in self.committed.items() if v >0]) + + pots = [] + while len(commitsall) > 0: + commitslive = [(v,k) for (v,k) in commitsall if k in self.contenders] + v1 = commitslive[0][0] + pots += [sum([min(v,v1) for (v,k) in commitsall])] + #print "all: ", commitsall + #print "live:", commitslive + commitsall = [((v-v1),k) for (v,k) in commitsall if v-v1 >0] + + + #print "[**]", pots + + # TODO: I think rake gets taken out of the pots. + # so it goes: + # total pot x. main pot y, side pot z. | rake r + # and y+z+r = x + # for example: + # Total pot $124.30 Main pot $98.90. Side pot $23.40. | Rake $2 + # so....... that's tricky. + if len(pots) == 1: + return "Main pot $%.2f" % pots[0] + elif len(pots) == 2: + return "Main pot $%.2f, side pot $%2.f" % (pots[0],pots[1]) + elif len(pots) == 3: + return "Main pot $%.2f, side pot-1 $%2.f, side pot-2 $.2f" % (pots[0],pots[1],pots[2]) + else: + return "too many pots.. fix me" + + + + + #def addMoney(self, player, amount): + #uncalled = max(self.committed.values()) - self.committed[player] + + #if self.cap: + #overflow = self.committed[player] + amount - self.cap + #if overflow > 0: + #self.total += amount - overflow + #self.committed[player] = self.cap + #self.sidepot.addMoney(player, overflow) + #else: + ## because it was capped, we can only be calling here. + #self.calls.append(min(uncalled,amount)) + #self.committed[player] += amount + #self.total += amount + #else: + ## no player is currently all-in. + + #self.committed[player] += amount + #self.total += amount + + ## is this a new uncalled bet? + #r = amount - uncalled + #if r > 0: + #self.uncalled = (player, r) + #self.calls = [0] + #else: + #self.calls.append(amount + r) + + ## is this player all-in? + #if self.committed[player] == self.stacks[player]: + #self.cap = self.stacks[player] + #contenders = self.contenders[:] + #contenders.remove(player) + #sidepotstacks = dict([(player, self.stacks[player]-self.committed[player]) for player in contenders]) + #self.sidepot = Pot(contenders, sidepotstacks, self.sidepotnum+1) + #elif self.committed[player] > self.stacks[player]: + #print "ERROR %s problem" % (player,) + #print self.committed[player], self.stacks[player] + #raise FpdbParseError + + #def returnUncalled(self): + #print "[POT]" + #print "last bet", self.uncalled + #print "calls:", self.calls + #print + #if self.uncalled: + #if max(self.calls) < self.uncalled[1]: + #self.total -= self.uncalled[1] + #print "returned", self.uncalled[0],self.uncalled[1]-max(self.calls), "from", self.uncalled[1] + + + #def __str__(self): + #total = self.total + #if self.sidepotnum == 0: + #return "Main pot $%.2f%s" %(total, self.sidepot or '' ) + #elif self.sidepotnum > 0: + #if self.sidepot: + #return ", side pot-%d $%.2f%s" % (self.sidepotnum, total, self.sidepot) + #else: + #return ", side pot $%.2f." % (total,) + + + + +