Changeset 12

Timestamp:

02/03/08 16:52:57 (4 years ago)

Author:

mike

Message:

Added hand checking code

Files:

• client.py (modified) (2 diffs)
• holdemtable.py (modified) (8 diffs)
• tabled.py (modified) (2 diffs)

client.py

@@ -11 +11 @@
 from twisted.internet import defer
 from pprint import PrettyPrinter
+from string import split
 
 pprinter = PrettyPrinter().pprint
 
-def dealWithData(data):
-    pprinter(data)
+def makeAction( action, value):
+    msg = { "method":"action",
+            "action":action,
+            "value":value }
 
 class PokerClientProtocol(NetstringReceiver):
+    def dealWithData(self,data):
+        print "---------------"
+        pprinter(data)
+        if data["you"]["required_action"]:
+            print "---------------"
+            print "We need some input. Possible actions:"
+            p_acts = data["you"]["possible_actions"]
+            vals = [None,None]
+            while not vals[0] in p_acts:
+                pprinter(p_acts)
+                str = raw_input('Action? format: <action> OR <action>,<value>:\n')
+                vals = split(str,",")
+                vals.append(None)
+            self.sendString( cjson.encode(makeAction(vals[0], vals[1])))
+
     def __init__(self,table_name, user_id, client_id ):
         self.table_name = table_name
@@ -33 +51 @@
         
         decoded = cjson.decode(line)
-        dealWithData(decoded)
+        self.dealWithData(decoded)
         
     def connectionLost(self, reason):

holdemtable.py

@@ -11 +11 @@
         self.money = self.starting_money
         self.cards = []
+        self.money_in_pot = None  #money in pot before previous round
+        self.__action_history = []
+        self.status = "need implementing"
+
+    def nextHand(self):
+        self.__in_hand = True
+        self.money_in_pot = 0.0
+        self.cards = []
+        self.__action_history = []
+
+    def moneyInPhase(self):
+        m = 0.0
+        for (a,b) in self.action_history if b:
+            m += b
+        return m
+
+    def nextPhase(self):
         self.action_history = []
-        self.status = "need implementing"
-
-    def nextHand(self):
-        self.cards = []
-        self.actionHistory = []
+        self.money_in_pot += self.moneyInPhase()
+
 
     def publicData(self):
@@ -28 +42 @@
                "cards"          : self.cards}
         return dat
+
     def actionHistory(self):
-        return self.action_history
+        return self.__action_history
 
     def dealCard(self, card):
         self.cards.append(card)
     #returns money added to pot if any
-    def doAction(self, action):
-        self.action_history.append( action )
+    def doAction(self, action, value):
+        if value and value > self.money: return False
+        else:
+            self.money -= value
+            self.__action_history.append((action,value))
+            return True
 
     def inHand(self):
         #TODO need to change this
-        return True 
+        return self.__in_hand
 
 PHASES = ["blinds", "flop", "turn", "river"]
 class holdemround:
-    def __init__(self, players):
+    def __init__(self,players,blinds):
         self.deck = deck.deck()
+        self.blinds = blinds
         #keep both of these on hand so we can quickly find a player
         self.players = players
@@ -53 +73 @@
         self.phase = 0
         self.community_cards = None
-        self.pot = None
+        self.possible_actions = None #to cache possible actions
         pass
+
+    #hand over?
+
+    def isHandOver(self):
+        total = sum([ 1 for p in self.player_array if p.inHand() ])
+        if total == 0: return True
+
+        self.phase == len(PHASES): return True
+        return False
 
     #return false if game is over
     def nextHand(self):
         self.deck.shuffle()
-        self.action_on = 0
         #rotate the players
         self.player_array.append(self.player_array.pop(0))
-        self.phase = 0
+        self.phase = None
         self.pot = 0.0
         self.community_cards = []
@@ -68 +96 @@
         for p in self.player_array: p.nextHand()
         #deal cards
-        for _ in xrange(2):
+        for _ in range(2):
             for p in self.player_array:
                 p.dealCard(self.deck.deal())
-        return True
+
+        return nextPhase()
 
     #returns false if hand is over
     def nextPhase(self):
-        self.phase += 1
-        if self.phase == len(PHASES): return False
-        return True
+        self.action_on = None
+
+        if self.phase != None: self.phase += 1
+        else: self.phase = 0
+
+        if self.isHandOver(): return False
+        else: return nextAction()
     
+
     #returns false if phase is over
     def nextAction(self):
-        self.action_on = ( self.button_on + 1 ) % len(self.player_array)
+        self.possible_actions = None
+
+        #first check if we have just one player left.  then we have an easy winner
+
+        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)
+        else: self.action = 0
         return True
 
-    def requiredAction( self, player_id):
-        self.action_on and player_id == self.player_array[self.action_on].id
+    def requiredAction(self, player_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 player_id != self.player_array[self.action_on].id: return None
-        else: return {} #TODO add stuff here
+        if possible_actions != None:
+            return possible_actions
+
+        me = self.players[player_id]
+        possible_actions = {"fold":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
+        #TODO this needs to change if it's the river
+        if max_money == 0: possible_actions["bet"] = self.blinds[1]
+        #TODO this needs to change to reflect the last bet
+        else: possible_actions["raise"] = self.blinds[1] + max_money
+
+        return possible_actions
+        #TODO fix so unlimited raises aren't allowed
+
 
     def getState(self):
@@ -100 +162 @@
 
         for (n,p) in self.players.items():
-            if p.inHand(): p_actions[n] = p.publicData()
+            if p.inHand(): p_actions[n] = p.actionHistory()
         state["player_actions"] = p_actions
 
@@ -109 +171 @@
 
 class holdemtable:
-    max_players = 2
-    def __init__(self, name):
+    def __init__(self, name, max_players):
+        self.max_players = max_players
         self.players={}
         self.game_started = False
@@ -145 +207 @@
         you = self.players[p_id].privateData()
 
-        req_action = self.game_started and\
-                     self.game_state.requiredAction(p_id)
-
-        you["reqired_action"] = req_action
+        req_action = self.game_started and self.game_state.requiredAction(p_id)
+        if self.game_started: print self.game_state.requiredAction(p_id)
+
+        print req_action
+        you["required_action"] = req_action
         if req_action: you["possible_actions"] = self.game_state.possibleActions(p_id)
 
@@ -168 +231 @@
         return root
 
+    def action(self, p_id, action, value):
+        pass
+
     def addDeferred(self, p_id, deferred):
         print "Adding player id(%s) to deferred" % p_id

tabled.py

@@ -13 +13 @@
 from twisted.internet import defer
 
-tables = {"test_table":holdemtable("test_table")}
+tables = {}
 
 class PokerTableProtocol(NetstringReceiver):
@@ -42 +42 @@
                         protocol.MakeError(103,"Already connected")) )
                     return
+                table_name = decoded["table_name"]
 
-                self.table = tables[decoded["table_name"]]
+                if not table_name in tables:
+                    tables[table_name]=holdemtable(table_name)
+
+                self.table = tables[table_name]
                 if self.table.isFull():
                     self.sendString( cjson.encode(