root/games/holdem/holdemtable.py

from games import deck
import hand

class InvalidActionException(Exception):
    pass

class InsufficientFundsException(Exception):
    pass

class ImproperPhaseException(Exception):
    pass

class player(object):
    def __init__(self, id, user_id, seat, starting_money):
        self.__seat = seat
        self.__id = id
        self.__user_id = user_id
        self.__money = starting_money
        self.__in_hand = True
        self.__cards = []
        self.__money_in_pot = None  #money in pot before previous round
        self.__action_history = []
        self.__has_acted = False
        self.__has_folded = False
        self.__action_log = []
        self.__status = "need implementing"
        self.__cards_shown = False

    def nextHand(self):
        self.__money_in_pot = 0.0
        self.__has_folded = False
        self.__cards = []
        self.__cards_shown = False
        self.__action_history = []



    def nextPhase(self):
        self.__action_history = []
        self.__money_in_pot += self.money_in_phase
        self.__has_acted = False
        self.__in_hand = not self.__has_folded


    def __publicData(self):
        dat =  {"owner" : self.user_id,
                "status": self.status,
                "money" : self.money,
                "seat"  : self.seat}
        if self.__cards_shown:
            dat["cards"] = self.cards
        return dat

    def __privateData(self):
        dat = {"user_id" : self.user_id,
               "id"      : self.id,
               "cards"   : self.cards}
        return dat

    def dealCard(self, card):
        self.cards.append(card)

    #returns money added to pot if any
    def doAction(self, action, value):
        if value != None and value > self.money:
            raise InsufficientFundsException("Insufficient Funds")
        else:
            if value != None: self.__money -= value
            if not self.__has_acted and not action in ["small_blinds","large_blinds","ante"]:
                self.__has_acted = True
            if action == "fold" or action == "muck": self.__has_folded = True
            if action == "show": self.__cards_shown = True
            self.__action_history.append((action,value))

    #lets make a bunch of getters
    id = property( lambda self: self.__id )
    cards = property( lambda self: self.__cards )
    money_in_pot = property( lambda self: self.__money_in_pot )
    action_history = property( lambda self: self.__action_history )
    has_folded = property( lambda self: self.__has_folded )
    has_acted = property( lambda self: self.__has_acted )
    status = property( lambda self: self.__status )
    user_id = property( lambda self: self.__user_id )
    seat = property( lambda self: self.__seat )
    money = property( lambda self: self.__money )
    money_in_phase = property( 
            lambda self: sum([ b for a,b in self.__action_history if b != None]) )
    public_data = property(__publicData)
    private_data = property(__privateData)
    in_hand = property( lambda self: self.__in_hand )


PHASES = ["blinds", "flop", "turn", "river", "showdown"]
class holdemround(object):
    

    def __init__(self,players,format):
        self.__deck = deck.deck()
        self.__blinds = None
        self.__round_length = format["round_length"]
        self.__blind_structure = format["blinds"]
        #keep both of these on hand so we can quickly find a player
        self.__players = players
        self.__player_array = players.values()
        self.__player_array.sort( cmp=lambda x,y: x.seat - y.seat) 
        self.__action_on = None
        self.__phase = 0
        self.__community_cards = None
        self.__possible_actions = None #to cache possible actions
        self.__hand_count = None
        self.__last_bet_raise = None


    #hand over?
    def __isHandOver(self):
        total = sum([ 1 for p in self.__player_array if not p.has_folded ])
        if total == 0: return True

        if self.__phase == len(PHASES): return True
        return False

    #wrap up the hand. Who wins?  Etc.
    def finishHand(self):
        if not self.hand_over:
            raise ImproperPhaseException("Hand is not over")
        #now, let's get a list of people who are still in.
        still_in = [ p for p in self.__player_array if not p.has_folded ]
        winner = None
        if len(still_in) == 1:
            winner = still_in[0]
        else:
            #create list of tuples of (id,hand)
            hands = [ (p.id,hand.best_hand(deck.card_vals(p.cards + self.__community_cards)))
                    for p in still_in ]
            #TODO add ties
            hands.sort(cmp = lambda a,b: cmp(a[1],b[1]))
            winner = hands.pop()
            print "%s withs with %s" % (winner[0],hand.format_hand(winner[1]))

            


    #return false if game is over
    def nextHand(self):
        self.__deck.shuffle()
        #rotate the players
        self.__player_array.append(self.__player_array.pop(0))
        self.__phase = None
        self.__community_cards = []
        self.__last_bet_raise = None
        if self.__hand_count == None:
            self.__hand_count = 0
        else: self.__hand_count += 1
        #Next phase of blinds
        if self.__hand_count % self.__round_length == 0 and\
           self.__hand_count/self.__round_length < len(self.__blind_structure):
            #Next blind phase
            self.__blinds = self.__blind_structure[self.__hand_count/self.__round_length]
        print self.__player_array
        for p in self.__player_array: p.nextHand()
        #deal cards
        for _ in range(2):
            for p in self.__player_array:
                p.dealCard(self.__deck.deal())

        return self.nextPhase()

    #returns false if hand is over
    def nextPhase(self):
        self.__action_on = None

        if self.__phase != None: self.__phase += 1
        else: self.__phase = 0

        for p in self.__player_array: p.nextPhase()

        if self.hand_over: return False

        pn = self.phase
        if pn == "blinds":
            self.__player_array[0].doAction("small_blinds",
                    min(self.__player_array[0],self.__blinds[1]))

            self.__player_array[1].doAction("large_blinds",
                    min(self.__player_array[1],self.__blinds[2]))
            #do antes for the rest
            for p in self.__player_array[2:]:
                p.doAction("ante",min(p.money,self.__blinds[0]))

            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())
        elif pn == "showdown":
            #If somebody bet or raised, they have to show
            if self.__last_bet_raise != None:
                self.__player_array[self.__last_bet_raise].doAction("show",None)
                self.__action_on = self.__last_bet_raise
            else:
                #Else we start fromt he button
                self.__action_on = None


        return self.nextAction()
    
    #Are there any outstanding bets?
    def outstandingBets(self):
        max_money = max([p.money_in_phase for p in self.__player_array])
        for p in self.__player_array:
            if not p.has_folded and p.money_in_phase < max_money:
                return True
        return False

    #returns false if phase is over
    def nextAction(self):
        self.__possible_actions = None

        #first check if we have just one player left.  then we have an easy winner

        if self.hand_over: return False

        #increment the action
        if self.__action_on != None:
            self.__action_on = ( self.__action_on + 1 ) % len(self.__player_array)
            while self.current_player.has_folded:
                self.__action_on = ( self.__action_on + 1 ) % len(self.__player_array)
        else: self.__action_on = 0
        if self.current_player.has_acted\
                and not self.outstandingBets():
                    return False
        else: return True

    def requiredAction(self, player_id):
        return self.__action_on != None and player_id == self.current_player.id

    #returns possible actions for a player
    def __getPossibleActions(self):
        if self.__possible_actions != None:
            return self.__possible_actions

        me = self.current_player
        if self.phase == "showdown":
            self.__possible_actions = {"muck":(None,None),
                                       "show":(None,None)}
        else:
            self.__possible_actions = {"fold":(None,None)}

            max_money = max([p.money_in_phase for p in self.__player_array])
            
            money_in_phase = me.money_in_phase
            
            min_bet = self.__blinds[2]
            if self.phase == "river": min_bet *= 2

            if max_money == money_in_phase: self.__possible_actions["check"] = (None,None)

            if max_money > money_in_phase: 
                call = min(me.money, max_money-money_in_phase)
                self.__possible_actions["call"] = (call,call)
            bet_raise = min( me.money, min_bet + max_money - money_in_phase )
            if max_money == 0 and me.money != 0.0:
                self.__possible_actions["bet"] = (bet_raise, me.money)
            #TODO this needs to change to reflect the last bet
            else: self.__possible_actions["raise"] = (bet_raise, me.money)

        return self.__possible_actions
        #TODO fix so unlimited raises aren't allowed


    def __getState(self):
        state = {"phase": self.phase,
                 "action_on": self.current_player.seat,
                 "pot_before_phase": self.pot,
                 "community_cards": self.__community_cards,
                 "hand_number": self.__hand_count,
                 "current_blinds": self.__blinds}
        p_actions = {}

        for (n,p) in self.__players.items():
            if p.in_hand: p_actions[n] = p.action_history
        state["player_actions"] = p_actions

        return state


    def doAction(self, p_id, action, value):
        if p_id != self.current_player.id:
            raise InvalidActionException("Action not on player " + p_id)

        pa = self.__getPossibleActions()
        if not action in pa:
            raise InvalidActionException("Action not in possible list")

        range = pa[action]
        if not (range[0] <= value <= range[1]):
            raise InvalidActionException("Value out of range")
        self.current_player.doAction(action,value)
        if action == "bet" or action == "raise":
            self.__last_bet_raise = self.__action_on
        if not self.nextAction():
            if not self.nextPhase():
                self.finishHand()
                if not self.nextHand():
                    #TODO add game end code handing hurr
                    pass

    #properties
    state = property( __getState )
    current_player = property( lambda self: self.__player_array[self.__action_on])
    hand_over = property( __isHandOver )
    possible_actions = property( __getPossibleActions )
    phase = property( lambda self: PHASES[self.__phase] )

    #returns the amount of money in pot before current phase
    pot = property( lambda self: sum([ p.money_in_pot for p in self.__player_array] ))

DEFAULT_FORMAT = {"max_players":2,
                  "round_length":8,
                  "starting_money":2000.0,
                  "blinds":[(None,25,50),
                            (None,50,100),
                            (None,100,200),
                            (25,100,200),
                            (25,150,300),
                            (50,200,400),
                            (75,300,600),
                            (100,500,1000),
                            (200,500,1500),
                            (300,1000,2000),
                            (400,1500,3000),
                            (500,2000,4000),
                            (500,3000,6000),
                            (1000,4000,8000),
                            (1000,5000,10000),
                            (2000,5000,15000),
                            (3000,10000,20000),
                            (4000,15000,30000),
                            (5000,20000,40000)]}

class holdemtable:
    def __init__(self, name, format = DEFAULT_FORMAT):
        self.__max_players = format["max_players"]
        self.__players={}
        self.__game_started = False
        self.__name = name
        self.__holdemgame = None
        self.__deferreds = []
        self.__format = format
        self.__cached_response = None


    def addPlayer(self, data, deferred ):
        p_id = data['client_id']
        self.__players[p_id]=player(p_id,
                                    data['user_id'],
                                    len(self.__players),
                                    self.__format["starting_money"])
        self.addDeferred( p_id, deferred )
        self.stateChanged("Player Added")
        self.checkStart()
    #check to see if the game is full and possibly start it
    def checkStart(self):
        if self.isFull():
            self.__game_state = holdemround(self.__players,self.__format)
            self.__game_started = True
            self.__game_state.nextHand()
            self.stateChanged("Game Starting")
            return True
        return False


    def isFull(self):
        return len(self.__players) >= self.__max_players

    def genStatus(self, p_id):
        if self.__cached_response == None:
            root = {}
            root["stat"] = "ok"
            root["type"] = "game_state"

            table_info = {}
            table_info["game_in_progress"] = self.__game_started
            table_info["name"] = self.__name
            table_info["format"] = self.__format

            players = {}
            for (n,d) in self.__players.items():
                players[n] = d.public_data
            table_info["players"] = players
            table_info["player_names"] = players.keys()
            root["table_info"] = table_info
            
            if self.__game_started:
                root["game_state"] = self.__game_state.state
            self.__cached_response = root

        copy = self.__cached_response.copy()
        you = self.__players[p_id].private_data

        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.possible_actions

        copy["you"] = you
        return copy

    def action(self, p_id, action, value):
        self.__game_state.doAction(p_id,action,value)
        self.stateChanged("Actioned")

    def addDeferred(self, p_id, deferred):
        self.__deferreds.append((p_id, deferred))

    #call this when the state changes to update all the deferred
    def stateChanged(self,action):
        dl = self.__deferreds[:]
        self.__deferreds = []
        self.__cached_response = None
        for (p,d) in dl:
            stat = self.genStatus(p)
            stat["action"] = action
            d.callback(stat)
    name = property( lambda self: self.__name )