def create_side_pots(self): reprocess_pots = True # gotta be a better way to do this but # I am getting tired of writing this bot while reprocess_pots: lowest_all_in_player = None for pot in self.pots: if pot.locked: continue lowest_all_in_player = PotManager.get_lowest_all_in_player(pot) break if lowest_all_in_player: amount = lowest_all_in_player.bet * len(pot.players) total = pot.amount difference = total - amount new_players = list(pot.players) new_players.remove(lowest_all_in_player) pot.locked = True pot.amount = amount side_pot = Pot('Side Pot {}'.format(len(self.pots)), difference, new_players) self.pots.append(side_pot) else: reprocess_pots = False
def create_initial_pot(table): amount = 0 side_pots_tmp = [] if table.ante > 0: for player in table.player_order: if player.stack > table.ante: amount += table.ante player.stack -= table.ante player.equity += table.ante else: player.equity = player.stack amount += player.stack side_pots_tmp.append(player.stack) player.stack = 0 if player.equity > (table.bb_amount + table.ante): amount += (player.equity - (table.bb_amount + table.ante)) player.equity = table.bb_amount + table.ante # instantiate pot object players = table.player_order[:] pot = Pot(players, amount) # append side pots to Pot obj in case of all-in players if side_pots_tmp: for p in side_pots_tmp: pot.side_pots.append(p) # Add the initial pot to the table table.pots.append(pot)
def __init__(self, starting_stack, blind_structure, hands_per_level, logging_level=logging.INFO): logging.basicConfig(stream=sys.stderr, level=logging_level) self.starting_stack = starting_stack self.blind_structure = blind_structure self.hands_per_level = hands_per_level self.players = [ mcplayer("Alice", self.starting_stack), randomplayer("Bob", self.starting_stack), randomplayer("Chris", self.starting_stack) ] self.pm = PlayerManager(self.players) self.pot = Pot() self.deck = Deck() self.board = [] self.blind_level = 1 #Uses 1 indexing not 0 indexing self.BIG_BLIND = self.blind_structure[self.blind_level - 1] self.SMALL_BLIND = self.blind_structure[self.blind_level - 1] // 2 self.num_hands = 0 self.game_state = {} self.players_in_hand = 0
def POST(self): i = web.input() potstr = i.pot handstr = i.hand my_pot = Pot(set(potstr.split())) my_hand = Hand(set(handstr.split())) # my_pot = Pot(set(["AC", "2C", "2S", "KS"])) # my_hand = Hand(set(["3C", "KH"])) allotherhand = allCardsExceptHand(my_pot, my_hand) mybesthand = getBestFromPotAndHand(my_pot, my_hand) results = [mybesthand] for alist in allotherhand: besthand = getBestFromPotAndHandList(my_pot, alist) results.append(besthand) sortResults = pokerrank(results) finalResults = [] for ahand in sortResults: finalResults.append(ahand) if (set(ahand.split()) == set(mybesthand.split())): break return render.calc(finalResults)
def test_pot(): #This class is hard it should test sooo many situations I'll list some #write tests for them as I go #1 player wins #1 player wins but one player that contributing to pot Folded #2 way split with 3 players #2 way split with 2 players #player is all in from posting small blind -wins/loses #player is all in from posting big blind -wins/loses #everyone folds PREFLOP #the winning player doesn't cover everyone #situation with 3 side pots. IE the player with the most chips has the worst hand, player with least chips has best hand. and etc for middle hand print("TESTING POT CLASS") stack = 100 bet = 10 p1 = Player("0", stack) p2 = Player("1", stack) p3 = Player("2", stack) players = [p1, p2, p3] print("testing 3 way split") pot = Pot() deck = Deck() deck.shuffle() board = [] hand = deck.draw(2) board.append(deck.draw(5)) #Note all 3 players are given the same hand which is not realistic but shouldn't matter p1.deal_new_hand(hand, 1) p2.deal_new_hand(hand, 1) p3.deal_new_hand(hand, 1) pot.add_to_pot(p1, bet) pot.add_to_pot(p2, bet) pot.add_to_pot(p3, bet) assert(p1.get_stack() == stack - bet) assert(p2.get_stack() == stack - bet) assert(p3.get_stack() == stack - bet) assert(pot.get_pot_size() == 3*bet) pot.payout(players, board) print(f"p1 stack: {p1.get_stack()}") assert(p1.get_stack() == stack) assert(p2.get_stack() == stack) assert(p3.get_stack() == stack) assert(pot.get_pot_size() == 0) print("Pot class: 8/8 tests passed")
def __init__(self, chairCount): players = [] pot = Pot() seats = [] dealOrder = [] button = 1 muck = collections.deque() for i in range(chairCount): seats.append('open')
def evaluate_pot(table): # Todo: Need more complete unit test coverage of this function """ Evaluates pot on table and creates side pots if necessary """ pot = table.pots[-1] if pot.side_pots: # import pdb # pdb.set_trace() pot.side_pots = sorted(pot.side_pots) while pot.side_pots: amount = pot.side_pots.pop(0) x = 0 new_players = [] for player in pot.players: player.equity -= amount x += 1 new_players.append(player) for player in pot.players: if player.stack == 0 and player.equity == 0: pot.players.remove(player) for p in pot.side_pots: ind = pot.side_pots.index(p) pot.side_pots[ind] -= amount amount = amount * x amount += pot.amount pot.amount = 0 new_pot = Pot(new_players, amount) table.pots.insert(0, new_pot) if len(pot.players) == 1: pot.side_pots = [] for player in pot.players: pot.amount += player.equity player.equity = 0 if len(pot.players) == 1: # Give last guy in pot money pot.players[0].stack += pot.amount table.pots.pop() if not table.pots: # Start new hand new_hand(table) else: while len(table.community_cards) < 5: deal(table) analyze(table) else: if len(table.community_cards) < 5: deal(table) else: analyze(table)
def __init__(self, game, button): self.game = game # make a copy of the deck for this round and shuffle it self.deck = copy.copy(game.deck) self.deck.shuffle() self.players = copy.copy(game.active_players) self.active_players = copy.copy(self.players) self.button = button self.pot = Pot() self.all_in = []
def test_discharge(self, mock_sleep): pot = Pot(5, 6) mock_gpio.IN = 'in' mock_gpio.OUT = 'out' pot.discharge() mock_gpio.setup.assert_has_calls([call(5, 'in'), call(6, 'out')]) mock_gpio.output.assert_called_once_with(6, False) mock_sleep.assert_called_once_with(0.005)
def __init__(self, game, button, evaluator): self.game = game self.ranks = [ "", "", "2", "3", "4", "5", "6", "7", "8", "9", "T", "J", "Q", "K", "A" ] # make a copy of the deck for this round and shuffle it self.deck = copy.copy(game.deck) self.deck.shuffle() self.players = copy.copy(game.active_players) self.active_players = copy.copy(self.players) self.button = button self.pot = Pot() self.all_in = [] self.evaluator = evaluator
class Board: """Mancala board. Board layout with pot indexs'. ______________________________________ | [13] (12)(11)(10)( 9)( 8)( 7) [ ] | | [ ] ( 0)( 1)( 2)( 3)( 4)( 5) [ 6] | ______________________________________ """ pots = [Pot(i) for i in range(14)] @property def state(self): return [pot.count for pot in self.pots]
def __init__(self, deck, players, blindtimer, rules, bigblindonly=False): self.__deck = deck self.__players = players self.__blinds = blindtimer.getblinds() self.__blindtimer = blindtimer self.__pots = [Pot(players, 0)] self.__community = Community() self.__rules = rules self.__bigblindonly = bigblindonly self.__currentplayer = None self.__nextplayeractions = () self.__firsttoact = None self.__lasttoact = None self.__winners = [] self.__round = self.NOT_SET
def post_small_blind(self, player): if player.money < 1: return False pot = Pot('Main Pot', player, 1) player.money -= 1 player.bet = 1 player.action = "SMALL BLIND" self.pots.append(pot) self.chat.message('<@{}> posts small blind $1'.format(player.slack_id)) self.current_bet = 1 self.big_blind = None self.small_blind = player return True
def __updatepot(self): # No pots? What are you doing here? if len(self.__pots) == 0: return players = self.__pots[-1].getplayers()[:] # Find everyone who's all in allins = [] for player in players: if player.isallin(): allins.append((player.gettotalbet(), player.name(), player)) allins.sort(key=lambda player: player[0]) # Remove the biggest all-in as they're still in if len(allins) > 1 and allins[-1][0] > allins[-2][0]: allins[-1][2].reducebet(allins[-1][0] - allins[-2][0]) allins[-1][2].notallin() self.__pots[-1].subtractvalue(allins[-1][0] - allins[-2][0]) del (allins[-1]) # fill the current pot and create a new side pot/pots last_allin = 0 allin_count = 0 for allin in allins: allin_count = allin_count + 1 if allin[0] > last_allin: # not already processed this all in bet for player in players: if allin[0] > player.gettotalbet(): self.__pots[-1].addvalue(player.gettotalbet()) player.addedtopot(player.gettotalbet()) else: self.__pots[-1].addvalue(allin[0]) player.addedtopot(allin[0]) last_allin = allin[0] players.remove(allin[2]) self.__pots.append(Pot(players, 0)) # fill the main pot or side pot for remaining players for player in players: if player.gettotalbet() == 0: continue self.__pots[-1].addvalue(player.gettotalbet()) player.addedtopot(player.gettotalbet())
def setUp(self): self.player1 = Player("player1", 100) self.player2 = Player("player2", 100) self.player3 = Player("player3", 100) self.player4 = Player("player4", 100) self.player5 = Player("player5", 100) self.player6 = Player("player6", 100) self.table = Table(6, 1, 2, [50, 100]) self.table.join(1, self.player1, 100) self.table.join(2, self.player2, 100) self.table.join(3, self.player3, 100) self.table.join(4, self.player4, 100) self.table.join(5, self.player5, 100) self.table.join(6, self.player6, 100) # Set player order; happy path for k, v in self.table.seats.items(): self.table.player_order.append(v) pot = Pot(self.table.player_order, 0) self.table.pots.append(pot)
from sets import Set from card import Card from hand import Hand from pot import Pot import itertools def findsubsets(S,m): return set(itertools.combinations(S, m)) class Utils(object): def __init__(self, info): self.info = info @staticmethod def getAllCombi(hand, pot): for card in hand.cards: print card for card in pot.cards: print card if __name__ == "__main__": my_pot = Pot(set([Card("A", "C"),Card("2", "C"),Card("2", "S"), Card("K", "S")])) my_hand = Hand(set([Card("3", "C"), Card("K", "H")])) Utils.getAllCombi(my_hand, my_pot)
def setUp(self): self.player1 = Player("player1", 100) self.player2 = Player("player2", 100) self.player3 = Player("player3", 100) self.player4 = Player("player4", 100) self.player5 = Player("player5", 100) self.player6 = Player("player6", 100) self.player7 = Player("player7", 100) self.player8 = Player("player8", 100) self.player9 = Player("player9", 100) self.table = Table(9, 1, 2, [50, 100]) self.table.join(1, self.player1, 100) self.table.join(2, self.player2, 100) self.table.join(3, self.player3, 100) self.table.join(4, self.player4, 100) self.table.join(5, self.player5, 100) self.table.join(6, self.player6, 100) self.table.join(7, self.player7, 100) self.table.join(8, self.player8, 100) self.table.join(9, self.player9, 100) cards = [ 13, 'h', 14, 'h', 5, 'h', 5, 's', 5, 'h', 10, 'c', 3, 'h', 4, 'h', 13, 's', 14, 's', 14, 's', 5, 's', 12, 's', 11, 's', 14, 's', 2, 'd', 4, 'h', 2, 'h' ] # Set player order; happy path for k, v in self.table.seats.items(): self.table.player_order.append(v) x = 0 for player in self.table.player_order: value = cards[x] x += 1 suit = cards[x] x += 1 card0 = Card("name", value, suit) value = cards[x] x += 1 suit = cards[x] x += 1 card1 = Card("name", value, suit) player.hole_cards.append(card0) player.hole_cards.append(card1) table_cards = [12, 'h', 11, 'h', 10, 'h', 5, 'c', 5, 'd'] x = 0 while len(self.table.community_cards) != 5: value = table_cards[x] x += 1 suit = table_cards[x] x += 1 card = Card("name", value, suit) self.table.community_cards.append(card) pot = Pot(self.table.player_order, 100) self.table.pots.append(pot)
cardstr += card.__str__() + " " cardstr = cardstr[0:-1] allhands.append(cardstr) besthand = poker(allhands) return besthand #print besthand else: return "2S 3C 7D 5C 6H" #print "invalid hand " + str(handlist) if __name__ == "__main__": potstr = sys.argv[1] handstr = sys.argv[2] my_pot = Pot(set(potstr.split())) my_hand = Hand(set(handstr.split())) # my_pot = Pot(set(["AC", "2C", "2S", "KS"])) # my_hand = Hand(set(["3C", "KH"])) allotherhand = allCardsExceptHand(my_hand) mybesthand = getBestFromPotAndHand(my_pot, my_hand) results = [] for alist in allotherhand: besthand = getBestFromPotAndHandList(my_pot, alist) results.append(besthand) sortResults = pokerrank(results) counter = 0
from flask import Flask from pot import Pot app = Flask(__name__) pot = Pot('teapot') @app.route('/teapot', methods=['GET']) def get(): return pot.get() @app.route('/teapot', methods=['BREW', 'POST']) def brew(): return pot.brew() @app.route('/teapot', methods=['WHEN']) def when(): return pot.when() if __name__ == '__main__': app.run(port=8081)
''' @brief: brewd is a flask-based xHTCPCP daemon and server, written in python3 @author: Bader Zaidan @version: 0.01 ''' from flask import Flask, redirect #, url_for from pot import Pot app = Flask(__name__) covfefe = Pot("covfefe") @app.route("/") def reroute(): #test redirect return redirect("pot", code=302) # return "Home" @app.route("/pot", methods=["GET"]) def get(): return covfefe.get() @app.route("/pot", methods=["HEAD"]) def head(): return covfefe.head()