Changeset 13 for holdemtable.py

Timestamp:

02/03/08 18:29:26 (4 years ago)

Author:

mike

Message:

Added some actioN

Files:

• holdemtable.py (modified) (14 diffs)

holdemtable.py

@@ -2 +2 @@
 import random
 from twisted.internet import defer
+
+class InvalidActionException(Exception):
+    pass
+
+class InsufficientFundsException(Exception):
+    pass
 
 class player:
@@ -11 +17 @@
         self.money = self.starting_money
         self.cards = []
-        self.money_in_pot = None  #money in pot before previous round
+        self.__money_in_pot = None  #money in pot before previous round
         self.__action_history = []
         self.status = "need implementing"
@@ -17 +23 @@
     def nextHand(self):
         self.__in_hand = True
-        self.money_in_pot = 0.0
+        self.__money_in_pot = 0.0
         self.cards = []
         self.__action_history = []
 
+    def moneyInPot(self):
+        return __money_in_pot
+
     def moneyInPhase(self):
-        m = 0.0
-        for (a,b) in self.action_history if b:
-            m += b
-        return m
+        return sum([ b for a,b in self.__action_history if b != None])
 
     def nextPhase(self):
-        self.action_history = []
-        self.money_in_pot += self.moneyInPhase()
+        self.__action_history = []
+        self.__money_in_pot += self.moneyInPhase()
 
 
@@ -50 +56 @@
     #returns money added to pot if any
     def doAction(self, action, value):
-        if value and value > self.money: return False
+        print value
+        print self.money
+        if value != None and value > self.money:
+            raise InsufficientFundsException("Insufficient Funds")
         else:
             self.money -= value
             self.__action_history.append((action,value))
-            return True
 
     def inHand(self):
         #TODO need to change this
         return self.__in_hand
+
 
 PHASES = ["blinds", "flop", "turn", "river"]
@@ -70 +79 @@
         self.player_array.sort( cmp=lambda x,y: x.seat - y.seat) 
         print self.player_array
-        self.action_on = None
+        self.__action_on = None
         self.phase = 0
         self.community_cards = None
@@ -76 +85 @@
         pass
 
+    def actionOn(self):
+        return self.__action_on
     #hand over?
 
@@ -82 +93 @@
         if total == 0: return True
 
-        self.phase == len(PHASES): return True
+        if self.phase == len(PHASES): return True
         return False
 
@@ -100 +111 @@
                 p.dealCard(self.deck.deal())
 
-        return nextPhase()
+        return self.nextPhase()
 
     #returns false if hand is over
     def nextPhase(self):
-        self.action_on = None
+        self.__action_on = None
 
         if self.phase != None: self.phase += 1
         else: self.phase = 0
 
+        pn = PHASES[self.phase]
+        if pn == "blinds":
+            self.player_array[0].doAction("small_blinds",self.blinds[0])
+            self.player_array[1].doAction("large_blinds",self.blinds[1])
+            self.__action_on = 1
+        elif pn == "flop":
+            for _ in range(3):
+                self.community_cards.append(self.deck.deal)
+        elif pn == "turn":
+            self.community_cards.append(self.deck.deal)
+        elif pn == "river":
+            self.community_cards.append(self.deck.deal)
+
+
         if self.isHandOver(): return False
-        else: return nextAction()
+        else: return self.nextAction()
     
 
@@ -121 +146 @@
         if self.isHandOver(): return False
 
-        #increment the acction
-        if self.action != None:
-            self.action_on = ( self.button_on + 1 ) % len(self.player_array)
-            while not self.player_array[self.action_on].inHand():
-                self.action_on = ( self.button_on + 1 ) % len(self.player_array)
+        #increment the action
+        if self.__action_on != None:
+            self.__action_on = ( self.__action_on + 1 ) % len(self.player_array)
+            while not self.player_array[self.__action_on].inHand():
+                self.__action_on = ( self.__action_on + 1 ) % len(self.player_array)
         else: self.action = 0
         return True
 
     def requiredAction(self, player_id):
-        return self.action_on != None and player_id == self.player_array[self.action_on].id
+        return self.__action_on != None and player_id == self.player_array[self.__action_on].id
 
     #returns possible actions for a player
-    def possibleActions(self, player_id):
-        if possible_actions != None:
-            return possible_actions
-
-        me = self.players[player_id]
-        possible_actions = {"fold":None}
+    def possibleActions(self):
+        if self.possible_actions != None:
+            return self.possible_actions
+
+        me = self.player_array[self.__action_on]
+        self.possible_actions = {"fold":(None,None)}
 
         max_money = max([p.moneyInPhase() for p in self.player_array])
 
         money_in_phase = me.moneyInPhase()
-        if max_money == money_in_phase: possible_actions["check"] = None
-        if max_money > money: possible_actions["call"] = max_money
+        if max_money == money_in_phase: self.possible_actions["check"] = (None,None)
+        if max_money > money_in_phase: self.possible_actions["call"] =\
+                (max_money - money_in_phase, max_money - money_in_phase)
         #TODO this needs to change if it's the river
-        if max_money == 0: possible_actions["bet"] = self.blinds[1]
+        if max_money == 0: self.possible_actions["bet"] = (self.blinds[1], me.money)
         #TODO this needs to change to reflect the last bet
-        else: possible_actions["raise"] = self.blinds[1] + max_money
-
-        return possible_actions
+        else: self.possible_actions["raise"] = (self.blinds[1] + max_money - money_in_phase, me.money)
+
+        return self.possible_actions
         #TODO fix so unlimited raises aren't allowed
 
@@ -156 +182 @@
     def getState(self):
         state = {"phase": PHASES[self.phase],
-                 "action_on": self.player_array[self.action_on].seat,
+                 "action_on": self.player_array[self.__action_on].seat,
                  "pot_before_phase": self.pot,
                  "community_cards": self.community_cards }
@@ -167 +193 @@
         return state
 
+    def potSize(self):
+        return sum([ p.moneyInPot for p in self.player_array ])
+
+    def doAction(self, p_id, action, value):
+        if p_id != self.player_array[self.__action_on].id:
+            raise InvalidActionException("Action not on player " + p_id)
+
+        pa = self.possibleActions()
+        if not action in pa:
+            raise InvalidActionException("Action not in possible list")
+
+        range = pa[action]
+        if not (range[0] <= value <= range[1]):
+            print range[0]
+            print value
+            print range[1]
+            raise InvalidActionException("Value out of range")
+        self.player_array[self.__action_on].doAction(action,value)
+        self.nextAction()
+
+
+        
+
+
 
 
 
 class holdemtable:
-    def __init__(self, name, max_players):
+    def __init__(self, name, max_players = 4):
         self.max_players = max_players
         self.players={}
@@ -190 +240 @@
     def checkStart(self):
         if self.isFull():
-            self.game_state = holdemround(self.players)
+            self.game_state = holdemround(self.players,self.blinds)
             self.game_started = True
             self.game_state.nextHand()
@@ -212 +262 @@
         print req_action
         you["required_action"] = req_action
-        if req_action: you["possible_actions"] = self.game_state.possibleActions(p_id)
+        if req_action: you["possible_actions"] = self.game_state.possibleActions()
 
         root["you"] = you
@@ -232 +282 @@
 
     def action(self, p_id, action, value):
-        pass
+        self.game_state.doAction(p_id,action,value)
+        self.stateChanged("Actioned")
 
     def addDeferred(self, p_id, deferred):
-        print "Adding player id(%s) to deferred" % p_id
         self.deferred.append((p_id, deferred))