Limnoria/plugins/Holdem.py

###
# Copyright (c) 2004, Jeremiah Fincher
# All rights reserved.
#
# Redistribution and use in source and binary forms, with or without
# modification, are permitted provided that the following conditions are met:
#
#   * Redistributions of source code must retain the above copyright notice,
#     this list of conditions, and the following disclaimer.
#   * Redistributions in binary form must reproduce the above copyright notice,
#     this list of conditions, and the following disclaimer in the
#     documentation and/or other materials provided with the distribution.
#   * Neither the name of the author of this software nor the name of
#     contributors to this software may be used to endorse or promote products
#     derived from this software without specific prior written consent.
#
# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
# AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
# IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
# ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
# LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
# CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
# SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
# INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
# CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
# ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
# POSSIBILITY OF SUCH DAMAGE.
###

"""
Turns the bot into a poker dealer.
"""

import supybot

__revision__ = "$Id$"
__author__ = supybot.authors.jemfinch
__contributors__ = {}

###
# TODO:
#
# Betting timeouts.
# Change the "bet" command to allow saying a specific amount to bet to.
# Change the stack command to see another person's stack.
# Keep a bankroll in the users registry.
# Allow the "sit" command to have specified a stack size, subtracting it from
#  the bankroll.
# Write a command to allow Owner users to give a person money.
# Re-expand the commands using forwarder so they can have better help. 
###

import sets
import random
import operator
import itertools

import poker

import supybot.conf as conf
import supybot.utils as utils
import supybot.ircdb as ircdb
from supybot.commands import *
import supybot.plugins as plugins
import supybot.ircutils as ircutils
import supybot.privmsgs as privmsgs
import supybot.registry as registry
import supybot.callbacks as callbacks


def configure(advanced):
    # This will be called by setup.py to configure this module.  Advanced is
    # a bool that specifies whether the user identified himself as an advanced
    # user or not.  You should effect your configuration by manipulating the
    # registry as appropriate.
    from supybot.questions import expect, anything, something, yn
    conf.registerPlugin('Holdem', True)

class PokerError(ValueError):
    pass

Holdem = conf.registerPlugin('Holdem')
conf.registerChannelValue(Holdem, 'blind',
    registry.PositiveInteger(10, """Determines what the small blind is.
    The big blind will be twice this."""))
conf.registerChannelValue(Holdem, 'color',
    registry.Boolean(True, """Determines whether the bot will use color to
    distinguish between consecutive hands."""))

users = {}

class Player(object):
    def __init__(self, user, stack):
        self.user = user
        self.stack = stack

    def __hash__(self):
        return hash(self.user)

    def nick(self):
        return users[self.user]

class Table(object):
    def __init__(self, channel):
        self.irc = None
        self.button = 0
        self.players = []
        self.channel = channel
        self.waitingToJoin = []
        self.waitingToLeave = []
        self.colors = itertools.cycle(['red', 'orange', 'yellow',
                                       'green', 'light blue', 'blue',
                                       'purple'])

    def _color(self, s):
        if conf.get(conf.supybot.plugins.Holdem.color, self.channel):
            s = ircutils.mircColor(s, self.color)
            s = ircutils.bold(s)
        return s

    def public(self, s, noColor=False):
        if not noColor:
            s = self._color(s)
        self.irc.reply(s, to=self.channel)

    def private(self, player, s, noColor=False):
        if not noColor:
            s = self._color(s)
        self.irc.reply(s, to=users[player.user], private=True)

    def error(self, s):
        s = self._color('%s: %s' % (self.irc.msg.nick, s))
        self.irc.reply(s, to=self.channel)

    def sit(self, player):
        if player in self.players:
            self.error('You\'re already seated.')
            return
        self.waitingToJoin.append(player)
        self.irc.reply('You will be dealt in when the next hand begins.')

    def stand(self, player):
        if player in self.players:
            self.waitingToLeave.append(player)
            self.irc.reply('You will leave this table when this hand ends.')
        elif player in self.waitingToJoin:
            self.waitingToJoin.remove(player)
        else:
            self.error('You aren\'t currently seated.')

    def deal(self, startingPlayer):
        # Ignore player.
        self.color = self.colors.next()
        self.blind = conf.get(conf.supybot.plugins.Holdem.blind, self.channel)
        if self.waitingToJoin:
            self.players.extend(self.waitingToJoin)
            self.waitingToJoin = []
        while self.waitingToLeave:
            playa = self.waitingToLeave.pop()
            self.players.remove(playa)

        for player in self.players[:]:
            if player.stack < 2*self.blind:
                self.public('%s doesn\'t have enough money to play this hand.'
                            % player.nick())
                self.players.remove(player)

        if len(self.players) < 2:
            self.public('I can\'t deal a new game with fewer than 2 people.')
            return

        self.hands = {}
        self.buckets = {}
        for player in self.players:
            self.buckets[player] = 0
        self.foldedBuckets = []
        self.tableCards = []
        self.button += 1
        self.button %= len(self.players)
        self._waitingOn = self.button
        self.deck = poker.deck[:]
        random.shuffle(self.deck)
        for player in self.players:
            self.hands[player] = [self.deck.pop()]
        for player in self.players:
            self.hands[player].append(self.deck.pop())
            self.hand(player)
        self.public('The cards are dealt.')
        self.startRound()
        # Blinds.
        smallBlind = self.nextPlayer()
        smallBlind.stack -= self.blind
        self.buckets[smallBlind] += self.blind
        self.currentBets[smallBlind] = self.blind
        self.public('%s places small blind of %s.' %
                    (smallBlind.nick(), self.blind))
        bigBlind = self.nextPlayer()
        bigBlind.stack -= 2*self.blind
        self.buckets[bigBlind] += 2*self.blind
        self.currentBets[bigBlind] = 2*self.blind
        self.public('%s places big blind of %s.' %
                    (bigBlind.nick(), 2*self.blind))
        self.currentBet = 2*self.blind
        self.startBettingRound()

    def startRound(self):
        self.couldBet = {}
        self.currentBet = 0
        self.currentBets = {}
        self._waitingOn = self.button
        for player in self.hands:
            self.currentBets[player] = 0

    def nextRound(self):
        self.startRound()
        self.deck.pop() # Burn a card.
        if len(self.tableCards) == 0:
            self.tableCards.append(self.deck.pop())
            self.tableCards.append(self.deck.pop())
            self.tableCards.append(self.deck.pop())
            self.public('Flop dealt, table shows %s.' % self.tableCards)
            self.startBettingRound()
        elif len(self.tableCards) == 3:
            self.tableCards.append(self.deck.pop())
            self.public('Turn dealt, table shows %s.' % self.tableCards)
            self.startBettingRound()
        elif len(self.tableCards) == 4:
            self.tableCards.append(self.deck.pop())
            self.public('River dealt, table shows %s.' % self.tableCards)
            self.startBettingRound()
        else:
            self.finishGame()

    def finishGame(self):
        try:
            if len(self.buckets) == 1:
                total = self.pot()
                player = self.buckets.keys()[0]
                player.stack += total
                self.public('%s wins the hand for %s.' % (player.nick(), total))
                return
            assert len(self.hands) == len(self.buckets)
            hands = [(player, poker.score(hand + self.tableCards))
                     for (player, hand) in self.hands.iteritems()]
            utils.sortBy(operator.itemgetter(1), hands)
            hands.reverse()
            buckets = self.buckets.values() + self.foldedBuckets
            for (player, (kind, hand)) in hands:
                amountBet = self.buckets[player]
                totalReceived = 0
                for (i, bucket) in enumerate(buckets):
                    received = min(bucket, amountBet)
                    totalReceived += received
                    buckets[i] -= received
                player.stack += totalReceived
                self.public('%s wins %s with a %s, %s' %
                            (player.nick(), totalReceived, kind[2:], hand))
                buckets = filter(None, buckets)
                if not buckets:
                    break
        finally:
            self.public('This hand is finished, prepare for the next hand.')
        
    def waitingOn(self):
        self._waitingOn %= len(self.players)
        return self.players[self._waitingOn]

    def pot(self):
        return sum(self.buckets.values()) + sum(self.foldedBuckets)

    def startBettingRound(self):
        player = self.nextPlayer()
        if player is None:
            self.nextRound()
            return
        s = 'Betting begins with %s.' % self.waitingOn().nick()
        s = 'The pot is currently at %s.  %s' % (self.pot(), s)
        self.public(s)

    def checkWrongPlayer(self, player):
        if player != self.waitingOn():
            self.public('It\'s not your turn, %s.' % player.nick())
            return True
        return False

    def nextPlayer(self):
        seen = sets.Set()
        while 1:
            self._waitingOn += 1
            player = self.waitingOn()
            if player in seen:
                return None # Handled by checkEndOfRound.
            seen.add(player)
            if player not in self.buckets or player.stack <= 0:
                continue
            else:
                break
        return self.waitingOn()

    def checkEndOfRound(self):
        # if all currentBets are not currentBet for all users with stacks.
        if len(self.buckets) == 1:
            # Only one guy left, let's distribute.
            self.finishGame()
            return
        finished = True
        for player in self.buckets:
            if player not in self.couldBet:
                finished = False
                break
            if self.currentBet > self.currentBets[player] and player.stack:
                finished = False
                break
        if finished:
            self.nextRound()
        else:
            player = self.nextPlayer()
            if player is not None:
                self.public('%s, it\'s your turn.  The current bet is %s.  '
                            'You\'ve bet %s already this round.' %
                            (player.nick(), self.currentBet,
                             self.currentBets[player]))
            else:
                self.nextRound()

    def checkNoCurrentBet(self):
        if self.currentBet:
            self.error('There\'s a bet of %s, you must call it, '
                       'raise it, or fold.' % self.currentBet)
            return True
        return False
    
    def hand(self, player):
        try:
            self.private(player, 'Your hand is %s.' % self.hands[player])
        except KeyError:
            self.error('You\'re not dealt in right now.')

    def table(self, player):
        self.public('The table shows %s.' % self.tableCards)

    def fold(self, player):
        if self.checkWrongPlayer(player):
            return
        bucket = self.buckets.pop(player)
        if bucket:
            self.foldedBuckets.append(bucket)
        del self.hands[player]
        self.checkEndOfRound()

    def check(self, player):
        if self.checkWrongPlayer(player):
            return
        if self.currentBet and self.currentBets[player] < self.currentBet:
            self.error('There is a bet of %s, you must call it, raise it, '
                       'or fold.' % self.currentBet)
        self.public('%s checks.' % player.nick())
        self.couldBet[player] = True
        self.checkEndOfRound()

    def addCurrentBet(self, player, amount):
        self.couldBet[player] = True
        self.buckets[player] += amount
        self.currentBets[player] += amount
        self.currentBet = max(self.currentBet, self.currentBets[player])
        player.stack -= amount
        return amount
            
    def call(self, player):
        if self.checkWrongPlayer(player):
            return
        toCall = self.currentBet - self.currentBets[player]
        bet = self.addCurrentBet(player, min(toCall, player.stack))
        self.public('%s calls %s.' % (player.nick(), bet))
        self.checkEndOfRound()

    def bet(self, player, amount):
        if self.checkWrongPlayer(player):
            return
        if self.checkNoCurrentBet():
            return
        if amount > player.stack:
            self.error('You only have %s in your stack, you can\'t '
                       'bet that much.  Perhaps you should use the allin '
                       'command.' % player.stack)
            return
        if amount < 2*self.blind:
            self.error('You must bet at least the big blind.')
            return
        bet = self.addCurrentBet(player, amount)
        self.public('%s bets %s.' % (player.nick(), bet))
        self.checkEndOfRound()
        
    def RAISE(self, player, amount):
        if self.checkWrongPlayer(player):
            return
        if not self.currentBet:
            self.error('You can\'t raise when there\'s no current '
                       'bet.  Perhaps you should use the bet command.')
            return
        if amount < self.currentBet:
            self.error('You can\'t raise by less than the current '
                       'bet of %s.' % self.currentBet)
            return
        totalRaise = amount + self.currentBet - self.currentBets[player]
        bet = self.addCurrentBet(player, min(totalRaise, player.stack))
        self.public('%s raises to %s.' % (player.nick(), bet))
        self.checkEndOfRound()
        
    def allin(self, player):
        if self.checkWrongPlayer(player):
            return
        bet = self.addCurrentBet(player, player.stack)
        self.public('%s goes all-in, %s.' % (player.nick(), bet))
        self.checkEndOfRound()
        
        
def getPlayer(irc, msg, args, state):
    callConverter('user', irc, msg, args, state)
    Holdem = irc.getCallback('Holdem')
    try:
        state.args[-1] = Holdem.getPlayer(state.args[-1])
    except KeyError:
        irc.error('You\'re not currently seated, sit down first.', Raise=True)

addConverter('player', getPlayer)

class Holdem(callbacks.Privmsg):
    def __init__(self):
        self.players = {}
        self.tables = ircutils.IrcDict()
        self.__parent = super(Holdem, self)
        self.__parent.__init__()
        setattr(self.__class__, 'raise', self.__class__.RAISE)
        
    def __call__(self, irc, msg):
        try:
            # users is a global, used by Tables.
            users[ircdb.users.getUser(msg.prefix)] = msg.nick
        except KeyError:
            pass
        self.__parent.__call__(irc, msg)

    def callCommand(self, name, irc, msg, *args, **kwargs):
        if irc.isChannel(msg.args[0]):
            self.__parent.callCommand(name, irc, msg, *args, **kwargs)

    def getPlayer(self, user):
        if user not in self.players:
            self.players[user] = Player(user, 1000)
        return self.players[user]

    def getTable(self, irc, channel):
        table = self.tables[channel]
        table.irc = irc
        return table

    def forwarder(name):
        def f(self, irc, msg, args, channel, player):
            """takes no arguments

            Does %s in the current game in the channel in which it's given.
            """
            try:
                table = self.getTable(irc, channel)
                getattr(table, name)(player)
            except KeyError:
                return
        f.__doc__ %= name
        f = utils.changeFunctionName(f, name)
        f = wrap(f, ['onlyInChannel', 'player'])
        return f
    #forwarder = staticmethod(forwarder)

    def start(self, irc, msg, args, player):
        """takes no arguments

        Starts a table in the channel this message is sent in.
        """
        channel = msg.args[0]
        if channel in self.tables:
            irc.error('There\'s already a table in this channel.', Raise=True)
        else:
            self.tables[channel] = Table(channel)
            irc.replySuccess()
    start = wrap(start, ['player'])

    sit = forwarder('sit')
    call = forwarder('call')
    deal = forwarder('deal')
    fold = forwarder('fold')
    hand = forwarder('hand')
    table = forwarder('table')
    check = forwarder('check')
    allin = forwarder('allin')
    stand = forwarder('stand')

    def stack(self, irc, msg, args, player):
        """takes no arguments

        Returns the size of your stack.
        """
        irc.reply(player.stack)
    stack = wrap(stack, ['player'])

    def bet(self, irc, msg, args, channel, player, amount):
        """<amount>

        Bets <amount>.
        """
        if channel in self.tables:
            self.getTable(irc, channel).bet(player, amount)
    bet = wrap(bet, ['onlyInChannel', 'player', 'positiveInt'])

    def RAISE(self, irc, msg, args, channel, player, amount):
        """<amount>

        Calls the current bet and raises it by <amount>.
        """
        if channel in self.tables:
            self.getTable(irc, channel).RAISE(player, amount)
    RAISE = wrap(RAISE, ['onlyInChannel', 'player', 'positiveInt'])


Class = Holdem

# vim:set shiftwidth=4 tabstop=8 expandtab textwidth=78: