# Code review

C Smith illusiontechniques at gmail.com
Tue Nov 4 16:28:33 CET 2014

```I was wondering if I could get some feedback on the biggest thing I
have done as an amateur Python coder. The sidepots algorithm isn't
correct yet, but I haven't worked on it in a while and thought I would
get some advice before diving back in.

import random, os
##################################################################
class Table(object):
def __init__(self,bigblind=20,PLAYERNUM=0,pot=0,PLAYERORDER=None,
hand_done=0,\
left_to_act=None,cost_to_play=0,in_hand=None,last_raise=0,cards_in_play=None,round='preflop'):
if cards_in_play is None:
cards_in_play = []
if in_hand is None:
in_hand = []
if PLAYERORDER is None:
PLAYERORDER = []
if left_to_act is None:
left_to_act = []
self.hand_done = hand_done
self.round = round
self.cards_in_play = cards_in_play
self.last_raise = last_raise
self.in_hand = in_hand
self.cost_to_play = cost_to_play
self.left_to_act = left_to_act
self.PLAYERORDER = PLAYERORDER
self.bigblind = bigblind
self.PLAYERNUM = PLAYERNUM
self.pot = pot
##################################################################
def fillseats(self,listofplayers, playas):
seating = [x for x in range(1,len(listofplayers)+1)]
random.shuffle(seating)
for y in listofplayers:
playas[y].seatnumber = seating.pop()
for x in listofplayers:
newx = str(playas[x].seatnumber)+x
self.PLAYERORDER.append(newx)
self.PLAYERORDER = sorted(self.PLAYERORDER)
neworder = []
for x in self.PLAYERORDER:
neworder.append(x[1:])
self.PLAYERORDER = neworder
self.PLAYERNUM = len(self.PLAYERORDER)
##########################################################
def postblinds(self,playas,bigblind,deck):
# establish player.start_stack for sidepots
for player in self.PLAYERORDER:
playas[player].start_stack = playas[player].stacksize
if len(self.PLAYERORDER) == 2:
if bigblind >= playas[self.PLAYERORDER].stacksize:
if bigblind == playas[self.PLAYERORDER].stacksize:
playas[self.PLAYERORDER].stacksize = 0
self.pot += bigblind
playas[self.PLAYERORDER].all_in = 1
playas[self.PLAYERORDER].in_front = bigblind
playas[self.PLAYERORDER].put_in_pot = bigblind
else:
self.pot += playas[self.PLAYERORDER].stacksize
playas[self.PLAYERORDER].in_front =
playas[self.PLAYERORDER].stacksize
playas[self.PLAYERORDER].put_in_pot =
playas[self.PLAYERORDER].stacksize
playas[self.PLAYERORDER].stacksize = 0
playas[self.PLAYERORDER].all_in = 1
if (bigblind/2) >= playas[self.PLAYERORDER].stacksize:
if bigblind == playas[self.PLAYERORDER].stacksize:
playas[self.PLAYERORDER].in_front = bigblind/2
playas[self.PLAYERORDER].put_in_pot = bigblind/2
playas[self.PLAYERORDER].stacksize = 0
self.pot += bigblind/2
playas[self.PLAYERORDER].all_in = 1
else:
playas[self.PLAYERORDER].put_in_pot =
playas[self.PLAYERORDER].stacksize
playas[self.PLAYERORDER].in_front =
playas[self.PLAYERORDER].stacksize
playas[self.PLAYERORDER].stacksize = 0
playas[self.PLAYERORDER].all_in = 1
if playas[self.PLAYERORDER].all_in == 0:
playas[self.PLAYERORDER].stacksize -= bigblind/2
playas[self.PLAYERORDER].in_front = bigblind/2
playas[self.PLAYERORDER].put_in_pot = bigblind/2
self.pot += bigblind/2
if playas[self.PLAYERORDER].all_in == 0:
playas[self.PLAYERORDER].stacksize -= bigblind
playas[self.PLAYERORDER].in_front = bigblind
playas[self.PLAYERORDER].put_in_pot = bigblind
self.pot += bigblind
self.left_to_act = self.PLAYERORDER[:]
self.cost_to_play = bigblind
self.last_raise = bigblind
else: # post blinds for more that 2 players
# player has not enough or just enough for big blind
if playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize
<= bigblind:
if
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize <
bigblind:

playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].put_in_pot =
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize

playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].in_front =
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].all_in = 1
self.pot +=
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize

playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize = 0
elif
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize ==
bigblind:

playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].in_front = bigblind

playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].put_in_pot =
bigblind
playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].all_in = 1
self.pot += bigblind

playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize = 0
else:
# Normal post bigblind

playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].stacksize -=
bigblind

playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].in_front = bigblind

playas[self.PLAYERORDER[2%len(self.PLAYERORDER)]].put_in_pot =
bigblind
self.pot += bigblind
# player has not enough or just enough for small blind
if playas[self.PLAYERORDER].stacksize <= bigblind/2:
if playas[self.PLAYERORDER].stacksize < bigblind/2:
playas[self.PLAYERORDER].all_in = 1
self.pot += playas[self.PLAYERORDER].stacksize
playas[self.PLAYERORDER].in_front =
playas[self.PLAYERORDER].stacksize
playas[self.PLAYERORDER].put_in_pot =
playas[self.PLAYERORDER].stacksize
playas[self.PLAYERORDER].stacksize = 0
elif playas[self.PLAYERORDER].stacksize == bigblind/2:
playas[self.PLAYERORDER].all_in = 1
self.pot += bigblind/2
playas[self.PLAYERORDER].in_front = bigblind/2
playas[self.PLAYERORDER].put_in_pot = bigblind/2
playas[self.PLAYERORDER].stacksize = 0
else: # normal post small blind
playas[self.PLAYERORDER].stacksize -= bigblind/2
playas[self.PLAYERORDER].in_front = bigblind/2
playas[self.PLAYERORDER].put_in_pot = bigblind/2
self.pot += bigblind/2
self.left_to_act =
self.PLAYERORDER[3%len(self.PLAYERORDER):]+self.PLAYERORDER[:3%len(self.PLAYERORDER)]
self.cost_to_play = bigblind
self.last_raise = bigblind
for x in self.PLAYERORDER:
playas[x].drawcard(deck.draw())
for x in self.PLAYERORDER:
playas[x].drawcard(deck.draw())
for x in self.PLAYERORDER:
print x+" stacksize is "+str(playas[x].stacksize)
print x+" is at seat number "+str(playas[x].seatnumber)
print raw_input('to begin, hit any key')
self.get_action(playas, bigblind, deck)
##################################################################
def showdown(self,playas,bigblind,deck):
print "in_hand equals %s" % self.in_hand
handtobeat = 0
for player in self.in_hand:
final_hand = self.cards_in_play + playas[player].hand
ranks = [x for x in final_hand]
suits = [x for x in final_hand]
#ints with Ace as 14 and 2 for straights
straightranks = []
#ints with Ace as 14 for pairs
pairranks = []
for rank in ranks:
if rank == 'T':
straightranks.append(10)
elif rank == 'J':
straightranks.append(11)
elif rank == 'Q':
straightranks.append(12)
elif rank == 'K':
straightranks.append(13)
elif rank == 'A':
straightranks.append(1)
straightranks.append(14)
else:
straightranks.append(int(rank))
pairranks = [x for x in straightranks if x != 1]
straightranks = sorted(list(set(straightranks)),reverse=True)
########### USE straightranks FOR STRAIGHTS
if straight_flush_finder(final_hand) == True:
playas[player].hand_rank =
(9,straight_flush_finder(final_hand))
elif four_of_a_kind_finder(pairranks) == True:
playas[player].hand_rank = (8,four_of_a_kind_finder(pairranks))
elif fullhouse_finder(pairranks) == True:
playas[player].hand_rank = (7,fullhouse_finder(pairranks))
elif flush_finder(final_hand) == True:
playas[player].hand_rank = (6,flush_finder(final_hand))
elif straight_finder(straightranks) == True:
playas[player].hand_rank = (5,straight_finder(straightranks))
elif three_of_a_kind_finder(pairranks) == True:
playas[player].hand_rank = (4,three_of_a_kind_finder(pairranks))
elif two_pair_finder(pairranks) == True:
playas[player].hand_rank = (3,two_pair_finder(pairranks))
elif one_pair_finder(pairranks) == True:
playas[player].hand_rank = (2,one_pair_finder(pairranks))
else:
playas[player].hand_rank = (1,highcard_finder(pairranks))
# check if any player has a different amount in the
pot (sidepot necessary)
one_put_in_pot = playas[self.in_hand].put_in_pot
for player in self.in_hand:
if playas[player].put_in_pot != one_put_in_pot:
bigstack = 0
bigplayer = ''
for player in self.in_hand:
if playas[player].put_in_pot > bigstack:
bigplayer = player
bigstack = playas[player].put_in_pot
in_hand_copy = self.in_hand[:]
in_hand_copy.remove(bigplayer)
lowstack = 999999999999999
lowman = ''
for player in in_hand_copy:
if playas[player].put_in_pot < lowstack:
lowman = player
lowstack = playas[player].put_in_pot
if playas[bigplayer].put_in_pot > playas[lowman].put_in_pot:
print 'bigplayer %s put in pot is %s' %
(bigplayer, playas[bigplayer].put_in_pot)
print 'lowman %s put in pot %s' % (lowman,
playas[lowman].put_in_pot)
for player in self.in_hand:
print '%s is in hand and put %s in pot' %
(player, playas[player].put_in_pot)
raw_input("Sidepot split necessary, hit enter to continue")
sidepot1 = 0
for player in self.PLAYERORDER:
sidepot1 +=
min(playas[player].put_in_pot,playas[lowman].put_in_pot)
sidepot1elig = self.in_hand[:]
self.pot -= sidepot1
sidepot1winners = []
handtobeat = 0
for player in sidepot1elig:
if playas[player].hand_rank >= handtobeat:
handtobeat = playas[player].hand_rank
sidepot1winners.append(player)
for player in sidepot1winners:
if playas[player].hand_rank < handtobeat:
sidepot1winners.remove(player)
sidepot1winners = tie_breaker(sidepot1winners,playas)
for player in sidepot1winners:
print '%s you win %s chips' %
(player,sidepot1/len(sidepot1winners))
playas[player].stacksize +=
(sidepot1/len(sidepot1winners))
showmuck = 'x'
while showmuck not in ['s','m']:
showmuck = raw_input('%s show or muck
hand? (hit s OR m) ' % player)
if showmuck == 's':
playas[player].showhand()
print playas[player].hand_rank
if showmuck == 'm':
playas[player].muckhand()
anothercopy = self.in_hand[:]
for player in anothercopy:
if playas[player].start_stack == playas[lowman].start_stack:
self.in_hand.remove(player)
break
############## rest of showdown
handtobeat = 0
winningplayers = []
for player in self.in_hand:
if playas[player].hand_rank >= handtobeat:
handtobeat = playas[player].hand_rank
winningplayers.append(player)
winnerscopy = winningplayers[:]
for player in winnerscopy:
if playas[player].hand_rank < handtobeat:
winningplayers.remove(player)
# tie_breaker changes winningplayers into nested list
winningplayers = tie_breaker(winningplayers,playas)
for winnerwinner in winningplayers:
self.hand_done = 1
print '%s you win %s chips' %
(winnerwinner,self.pot/len(winningplayers))
playas[winnerwinner].stacksize += (self.pot/len(winningplayers))
showmuck = 'x'
while showmuck not in ['s','m']:
showmuck = raw_input('%s show or muck hand? (hit s OR
m) ' % winnerwinner)
if showmuck == 's':
playas[winnerwinner].showhand()
print playas[winnerwinner].hand_rank
if showmuck == 'm':
playas[winnerwinner].muckhand()
self.end_hand(playas,bigblind,deck)
#################################################################################
def turn_one(self, deck):
self.cards_in_play.append(deck.draw())
print self.cards_in_play[-1] + ' drawn'
raw_input('Hit Enter')
def burn_one(self, deck):
deck.burn()
print 'Card Burnt'
raw_input('Hit Enter')
##################################
def end_hand(self, playas, bigblind, deck):
print 'hand done'
playercopy = self.PLAYERORDER[:]
for x in playercopy:
print '%s stacksize is %s' % (x, playas[x].stacksize)
if playas[x].stacksize == 0:
print '%s you are out of the game.' % x
self.PLAYERORDER.remove(x)
if len(self.PLAYERORDER) == 1:
print 'tournament over, %s wins' % self.PLAYERORDER
exit()
raw_input('Hit enter for the next hand')
for player in self.PLAYERORDER:
playas[player].put_in_pot = 0
playas[player].all_in = 0
buttonmover = self.PLAYERORDER
self.PLAYERORDER = self.PLAYERORDER[1:]
self.PLAYERORDER.append(buttonmover)
self.left_to_act = []
self.in_hand = []
self.hand_done = 0
for x in self.PLAYERORDER:
playas[x].in_front = 0
playas[x].hand = []
self.cards_in_play = []
self.pot = 0
self.round = 'preflop'
self.last_raise = 0
self.cost_to_play = 0
deck.renew()
self.postblinds(playas, bigblind, deck)
##################################################################
def get_action(self,playas,bigblind,deck):
###################### test if folded around to a player (hand done
without showdown) ##################
if len(self.left_to_act) == 0 and len(self.in_hand) == 1:
self.hand_done = 1
print '%s you win %s chips' % (self.in_hand,self.pot)
playas[self.in_hand].stacksize += self.pot
showmuck = 'x'
while showmuck not in ['s','m']:
showmuck = raw_input('%s show or muck hand? (hit s OR
m) ' % self.in_hand)
if showmuck == 's':
playas[self.in_hand].showhand()
if showmuck == 'm':
playas[self.in_hand].muckhand()
for player in self.in_hand:
print playas[player].put_in_pot
raw_input('Hit enter')
self.end_hand(playas,bigblind,deck)
###########################################################################
################# test if river (last) round is done (SHOWDOWN) ################
if len(self.left_to_act) == 0 and self.round == 'river':
self.hand_done = 1
#return excess chips
bigstack = 0
bigplayer = ''
for player in self.in_hand:
if playas[player].put_in_pot > bigstack:
bigplayer = player
bigstack = playas[player].put_in_pot
in_hand_copy = self.in_hand[:]
in_hand_copy.remove(bigplayer)
nextbigstack = 0
nextbigplayer = ''
for player in in_hand_copy:
if playas[player].put_in_pot > nextbigstack:
nextbigplayer = player
nextbigstack = playas[player].put_in_pot
if playas[bigplayer].put_in_pot > playas[nextbigplayer].put_in_pot:
## ## nextbigstack could have folded
difference = playas[bigplayer].put_in_pot -
playas[nextbigplayer].put_in_pot
playas[bigplayer].stacksize += difference
playas[bigplayer].put_in_pot = playas[nextbigplayer].put_in_pot
self.pot -= difference
self.showdown(playas,bigblind,deck)
print self.cards_in_play
print 'Hand done'
raw_input('hit enter')
self.end_hand(playas,bigblind,deck)
#####################################################################################
################# test if turn (2nd to last round) is done
##################################
if len(self.left_to_act) == 0 and self.round == 'turn':
print self.cards_in_play
print 'Turn done'
raw_input('hit enter')
self.round = 'river'
for x in self.PLAYERORDER:
playas[x].in_front = 0
self.last_raise = bigblind
self.cost_to_play = 0
neworder = self.PLAYERORDER[1:]+self.PLAYERORDER[0:1]
for x in neworder:
if x in self.in_hand:
self.left_to_act.append(x)
self.in_hand = []
self.burn_one(deck)
self.turn_one(deck)
for player in self.in_hand:
playas[player].in_front = 0
self.get_action(playas,bigblind,deck)
#####################################################################################
################# test if flop is done
###################################################
if len(self.left_to_act) == 0 and self.round == 'postflop':
print self.cards_in_play
print 'Postflop done'
raw_input('hit enter')
self.round = 'turn'
for x in self.PLAYERORDER:
playas[x].in_front = 0
self.last_raise = bigblind
self.cost_to_play = 0
neworder = self.PLAYERORDER[1:]+self.PLAYERORDER[0:1]
for x in neworder:
if x in self.in_hand:
self.left_to_act.append(x)
self.in_hand = []
self.burn_one(deck)
self.turn_one(deck)
for player in self.in_hand:
playas[player].in_front = 0
self.get_action(playas,bigblind,deck)
#####################################################################################
################# test if preflop play is done
##################################
if len(self.left_to_act) == 0 and self.round == 'preflop':
for x in self.PLAYERORDER:
playas[x].in_front = 0
print ' stacksize is %s' % playas[x].stacksize
print 'in hand ',self.in_hand
print 'player order ',self.PLAYERORDER
print 'flop done'
print 'pot is '+str(self.pot)
self.last_raise = bigblind
self.cost_to_play = 0
neworder = self.PLAYERORDER[1:]+self.PLAYERORDER[0:1]
for x in neworder:
if x in self.in_hand:
self.left_to_act.append(x)
self.in_hand = []
self.burn_one(deck)
self.turn_one(deck)
self.turn_one(deck)
self.turn_one(deck)
print self.cards_in_play
self.round = 'postflop'
raw_input("hit enter")
self.get_action(playas,bigblind,deck)
###############
turnscreen(self.left_to_act)
###############
# Catch a player all-in and pass their turn
if playas[self.left_to_act].all_in == 1:
raw_input("%s you are all in, hit enter to continue" %
self.left_to_act)
if self.left_to_act not in self.in_hand:
self.in_hand.append(self.left_to_act)
del self.left_to_act
self.get_action(playas,bigblind,deck)
############# Display for each action prompt
for x in self.PLAYERORDER:
print x +'stacksize is '+ str(playas[x].stacksize)
print self.left_to_act + ' your hand is
'+playas[self.left_to_act].hand+'
'+playas[self.left_to_act].hand
print 'The last raise is '+str(self.last_raise)
print 'The pot is '+str(self.pot)
print 'The cost to play is
'+str(self.cost_to_play-playas[self.left_to_act].in_front)
print 'You have %s in the pot' % playas[self.left_to_act].put_in_pot
print 'You started the hand with %s chips' %
playas[self.left_to_act].start_stack
print 'This round, you have put %s chips in the pot' %
playas[self.left_to_act].in_front
showcards = (', ').join(x for x in self.cards_in_play)
print 'The cards in play are '+showcards
# Check if a player can Check their turn
if playas[self.left_to_act].in_front >= self.cost_to_play:
current_action = 'q'
current_action = raw_input("%s will you check, bet, or
fold? (type c OR b OR f) " % self.left_to_act)
#Check your turn, if infront == cost
if current_action == 'c':
if self.left_to_act in self.in_hand:
del self.in_hand[self.left_to_act]
self.in_hand.append(self.left_to_act)
self.left_to_act.remove(self.left_to_act)
self.get_action(playas,bigblind,deck)
# Bet , after check option
elif current_action == 'b':
currentraise = 3
while currentraise % 10 != 0:
currentraise = int(raw_input('%s what will you
bet? (increments of 10) ' % self.left_to_act))
while currentraise < 2*self.last_raise:
currentraise = int(raw_input('%s what will you
bet? (increments of 10) ' % self.left_to_act))
# Bet with exactly enough chips, after check option
if
self.cost_to_play-playas[self.left_to_act].in_front + currentraise
== playas[self.left_to_act].stacksize:
raw_input("%s you are all in" % self.left_to_act)
playas[self.left_to_act].all_in = 1
self.last_raise = playas[self.left_to_act].stacksize
self.pot +=
(self.cost_to_play-playas[self.left_to_act].in_front+playas[self.left_to_act].stacksize)
self.cost_to_play += playas[self.left_to_act].stacksize

playas[self.left_to_act].in_front +=
playas[self.left_to_act].stacksize
playas[self.left_to_act].put_in_pot +=
playas[self.left_to_act].stacksize
playas[self.left_to_act].stacksize = 0
if self.left_to_act in self.in_hand:
self.in_hand.remove(self.left_to_act)
for x in self.in_hand:
if x not in self.left_to_act:
self.left_to_act.append(x)
self.in_hand.append(self.left_to_act)
self.left_to_act.remove(self.left_to_act)
self.get_action(playas,bigblind,deck)
### Bet, not enough chips, after check option
elif
self.cost_to_play-playas[self.left_to_act].in_front + currentraise
> playas[self.left_to_act].stacksize:
raw_input("Not enough to raise that amount, %s put
all in, hit enter" % self.left_to_act)
playas[self.left_to_act].all_in = 1
self.pot += playas[self.left_to_act].stacksize
playas[self.left_to_act].put_in_pot +=
playas[self.left_to_act].stacksize
currentraise =
playas[self.left_to_act].stacksize-self.cost_to_play-playas[self.left_to_act].in_front
playas[self.left_to_act].in_front +=
playas[self.left_to_act].stacksize
self.cost_to_play += currentraise
self.last_raise = playas[self.left_to_act].stacksize
playas[self.left_to_act].stacksize = 0
if self.left_to_act in self.in_hand:
self.in_hand.remove(self.left_to_act)
for x in self.in_hand:
if x not in self.left_to_act:
self.left_to_act.append(x)
self.in_hand.append(self.left_to_act)
self.left_to_act.remove(self.left_to_act)
self.get_action(playas,bigblind,deck)
# Rest of Bet, more than enough chips after check option
self.pot += (currentraise +
self.cost_to_play-playas[self.left_to_act].in_front)
playas[self.left_to_act].put_in_pot +=
(currentraise +
self.cost_to_play-playas[self.left_to_act].in_front)
self.last_raise = currentraise
self.cost_to_play += currentraise
playas[self.left_to_act].stacksize -=
(self.cost_to_play - playas[self.left_to_act].in_front)
playas[self.left_to_act].in_front +=
(self.cost_to_play - playas[self.left_to_act].in_front)
if self.left_to_act in self.in_hand:
self.in_hand.remove(self.left_to_act)
for x in self.in_hand:
if x not in self.left_to_act:
self.left_to_act.append(x)
self.in_hand.append(self.left_to_act)
self.left_to_act.remove(self.left_to_act)
self.get_action(playas,bigblind,deck)
# Fold, after check option. Hey, you can do it!
elif current_action == 'f':
if self.left_to_act in self.in_hand:
self.in_hand.remove(self.left_to_act)
self.left_to_act.remove(self.left_to_act)
self.get_action(playas,bigblind,deck)
# Prompt for action, no check option
current_action = raw_input("%s will you call, raise, or fold?
(type c OR r OR f) " % self.left_to_act)
# Call
if current_action == 'c':
# Not enough chips, or just enough chips to call
if self.cost_to_play-playas[self.left_to_act].in_front
>= playas[self.left_to_act].stacksize:
playas[self.left_to_act].all_in = 1
self.pot += playas[self.left_to_act].stacksize
playas[self.left_to_act].put_in_pot +=
playas[self.left_to_act].stacksize
playas[self.left_to_act].in_front +=
playas[self.left_to_act].stacksize
playas[self.left_to_act].stacksize = 0
if self.left_to_act in self.in_hand:
self.in_hand.remove(self.left_to_act)
self.in_hand.append(self.left_to_act)
self.left_to_act.remove(self.left_to_act)
self.get_action(playas,bigblind,deck)
# Call, with more than enough chips
else:
playas[self.left_to_act].stacksize -=
(self.cost_to_play-playas[self.left_to_act].in_front)
self.pot +=
(self.cost_to_play-playas[self.left_to_act].in_front)
playas[self.left_to_act].put_in_pot +=
(self.cost_to_play-playas[self.left_to_act].in_front)
playas[self.left_to_act].in_front +=
(self.cost_to_play-playas[self.left_to_act].in_front)
if self.left_to_act in self.in_hand:
self.in_hand.remove(self.left_to_act)
self.in_hand.append(self.left_to_act)
self.left_to_act.remove(self.left_to_act)
self.get_action(playas,bigblind,deck)
# Raise, no check option
elif current_action == 'r':
currentraise = 3
while currentraise % 10 != 0:
currentraise = int(raw_input('%s what will you raise?
(increments of 10) ' % self.left_to_act))
while currentraise < 2*self.last_raise:
currentraise = int(raw_input('%s what will you raise?
(increments of 10) ' % self.left_to_act))
# Raise with exactly enough chips
if self.cost_to_play-playas[self.left_to_act].in_front
+ currentraise == playas[self.left_to_act].stacksize:
raw_input("%s you are all in" % self.left_to_act)
self.pot += playas[self.left_to_act].stacksize
playas[self.left_to_act].put_in_pot +=
playas[self.left_to_act].stacksize
self.cost_to_play += currentraise
self.last_raise = currentraise
playas[self.left_to_act].all_in = 1
playas[self.left_to_act].in_front +=
playas[self.left_to_act].stacksize
playas[self.left_to_act].stacksize = 0
if self.left_to_act in self.in_hand:
self.in_hand.remove(self.left_to_act)
for x in self.in_hand:
if x not in self.left_to_act:
self.left_to_act.append(x)
self.in_hand.append(self.left_to_act)
self.left_to_act.remove(self.left_to_act)
self.get_action(playas,bigblind,deck)
### Raise not enough chips
elif
self.cost_to_play-playas[self.left_to_act].in_front + currentraise
> playas[self.left_to_act].stacksize:
raw_input("%s put all in, hit enter" % self.left_to_act)
playas[self.left_to_act].all_in = 1

self.cost_to_play = playas[self.left_to_act].stacksize
self.last_raise = playas[self.left_to_act].stacksize
self.pot += playas[self.left_to_act].stacksize
playas[self.left_to_act].put_in_pot +=
playas[self.left_to_act].stacksize
playas[self.left_to_act].in_front +=
playas[self.left_to_act].stacksize
playas[self.left_to_act].stacksize = 0
if self.left_to_act in self.in_hand:
self.in_hand.remove(self.left_to_act)
for x in self.in_hand:
if x not in self.left_to_act:
self.left_to_act.append(x)
self.in_hand.append(self.left_to_act)
self.left_to_act.remove(self.left_to_act)
self.get_action(playas,bigblind,deck)
# Raise with enough chips
self.pot += (currentraise +
self.cost_to_play-playas[self.left_to_act].in_front)
playas[self.left_to_act].put_in_pot += (currentraise +
self.cost_to_play-playas[self.left_to_act].in_front)
self.last_raise = currentraise
self.cost_to_play += currentraise
playas[self.left_to_act].stacksize -=
(self.cost_to_play - playas[self.left_to_act].in_front)
playas[self.left_to_act].in_front += (self.cost_to_play
- playas[self.left_to_act].in_front)
if self.left_to_act in self.in_hand:
self.in_hand.remove(self.left_to_act)
for x in self.in_hand:
if x not in self.left_to_act:
self.left_to_act.append(x)
self.in_hand.append(self.left_to_act)
self.left_to_act.remove(self.left_to_act)
self.get_action(playas,bigblind,deck)
# Fold, after call option
elif current_action == 'f':
if self.left_to_act in self.in_hand:
self.in_hand.remove(self.left_to_act)
self.left_to_act.remove(self.left_to_act)
self.get_action(playas,bigblind,deck)
#########################################################################
class Deck(object):
def __init__(self,cards=None):
if cards is None:
cards = []
self.cards = cards
suits = ["S","C","D","H"]
ranks = ["2","3","4","5","6","7","8","9","T","J","Q","K","A"]
for suit in suits:
for rank in ranks:
self.cards.append(rank+suit)
random.shuffle(self.cards)
def draw(self):
return self.cards.pop()
def burn(self):
self.cards = self.cards[0:-1]
def renew(self):
suits = ["S","C","D","H"]
ranks = ["2","3","4","5","6","7","8","9","T","J","Q","K","A"]
self.cards = []
for suit in suits:
for rank in ranks:
self.cards.append(rank+suit)
random.shuffle(self.cards)
##################################################################
class Player(object):
playercount = 0
def __init__(self,stacksize=0,HUMAN=True,hand=None,seatnumber=0,\
in_front=0,hand_rank=0,all_in=0,start_stack=0, put_in_pot=0):
self.all_in = all_in
self.seatnumber = seatnumber
self.start_stack = start_stack
self.hand_rank = hand_rank
self.stacksize = stacksize
self.HUMAN = HUMAN
self.in_front = in_front
self.put_in_pot = put_in_pot
if hand == None:
hand = []
self.hand = hand
Player.playercount += 1
def drawcard(self,card):
self.hand.append(card)
def muckhand(self):
self.hand = []
print 'mucked'
def showhand(self):
print self.hand
##################################################################
def tie_breaker(winningplayers,playas):
ranky = playas[winningplayers].hand_rank
reallywinners = []
reallyreally = []
reallyreallyreally = []
thisisitiswear = []
okaylastone = []
high_int = 0
if ranky == 9 or ranky == 5:
for player in winningplayers:
if playas[player].hand_rank > high_int:
reallywinners = []
high_int = playas[player].hand_rank
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank == high_int:
if player not in reallywinners:
reallywinners.append(player)
elif ranky == 8 or ranky == 7:
for player in winningplayers:
if playas[player].hand_rank > high_int:
reallywinners = []
high_int = playas[player].hand_rank
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank == high_int:
if player not in reallywinners:
reallywinners.append(player)
if len(reallywinners) >= 2:
high_int = 0
for player in reallywinners:
if playas[player].hand_rank > high_int:
reallyreally = []
high_int = playas[player].hand_rank
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank == high_int:
if player not in reallyreally:
reallyreally.append(player)
elif ranky == 6:
for player in winningplayers:
if playas[player].hand_rank > high_int:
reallywinners = []
high_int = playas[player].hand_rank
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank == high_int:
if player not in reallywinners:
reallywinners.append(player)
elif ranky == 4:
for player in winningplayers:
if playas[player].hand_rank > high_int:
reallywinners = []
high_int = playas[player].hand_rank
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank == high_int:
if player not in reallywinners:
reallywinners.append(player)
if len(reallywinners) >= 2:
high_int = 0
for player in reallywinners:
if playas[player].hand_rank > high_int:
reallyreally = []
high_int = playas[player].hand_rank
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank == high_int:
if player not in reallyreally:
reallyreally.append(player)
elif ranky == 3:
for player in winningplayers:
if playas[player].hand_rank > high_int:
reallywinners = []
high_int = playas[player].hand_rank
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank == high_int:
if player not in reallywinners:
reallywinners.append(player)
if len(reallywinners) >= 2:
high_int = 0
for player in reallywinners:
if playas[player].hand_rank > high_int:
reallyreally = []
high_int = playas[player].hand_rank
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank == high_int:
if player not in reallyreally:
reallyreally.append(player)
if len(reallyreally) >= 2:
high_int = 0
for player in reallyreally:
if playas[player].hand_rank > high_int:
reallyreallyreally = []
high_int = playas[player].hand_rank
if player not in reallyreallyreally:
reallyreallyreally.append(player)
if playas[player].hand_rank == high_int:
if player not in reallyreallyreally:
reallyreallyreally.append(player)
elif ranky == 2:
for player in winningplayers:
if playas[player].hand_rank > high_int:
high_int = playas[player].hand_rank
reallywinners = []
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank == high_int:
if player not in reallywinners:
reallywinners.append(player)
if len(reallywinners) >= 2:
high_int = 0
for player in reallywinners:
if playas[player].hand_rank > high_int:
high_int = playas[player].hand_rank
reallyreally = []
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank == high_int:
if player not in reallyreally:
reallyreally.append(player)
if len(reallyreally) >= 2:
high_int = 0
for player in reallyreally:
if playas[player].hand_rank > high_int:
high_int = playas[player].hand_rank
reallyreallyreally = []
if player not in reallyreallyreally:
reallyreallyreally.append(player)
if playas[player].hand_rank == high_int:
if player not in reallyreallyreally:
reallyreallyreally.append(player)
if len(reallyreallyreally) >= 2:
high_int = 0
for player in reallyreallyreally:
if playas[player].hand_rank > high_int:
high_int = playas[player].hand_rank
thisisitiswear = []
if player not in thisisitiswear:
thisisitiswear.append(player)
if playas[player].hand_rank == high_int:
if player not in thisisitiswear:
thisisitiswear.append(player)
elif ranky == 1:
for player in winningplayers:
if playas[player].hand_rank > high_int:
high_int = playas[player].hand_rank
reallywinners = []
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank == high_int:
if player not in reallywinners:
reallywinners.append(player)
if len(reallywinners) >= 2:
high_int = 0
for player in reallywinners:
if playas[player].hand_rank > high_int:
high_int = playas[player].hand_rank
reallyreally = []
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank == high_int:
if player not in reallyreally:
reallyreally.append(player)
if len(reallyreally) >= 2:
high_int = 0
for player in reallyreally:
if playas[player].hand_rank > high_int:
high_int = playas[player].hand_rank
reallyreallyreally = []
if player not in reallyreallyreally:
reallyreallyreally.append(player)
if playas[player].hand_rank == high_int:
if player not in reallyreallyreally:
reallyreallyreally.append(player)
if len(reallyreallyreally) >= 2:
high_int = 0
for player in reallyreallyreally:
if playas[player].hand_rank > high_int:
high_int = playas[player].hand_rank
thisisitiswear = []
if player not in thisisitiswear:
thisisitiswear.append(player)
if playas[player].hand_rank == high_int:
if player not in thisisitiswear:
thisisitiswear.append(player)
if len(thisisitiswear) >= 2:
high_int = 0
for player in thisisitiswear:
if playas[player].hand_rank > high_int:
high_int = playas[player].hand_rank
okaylastone = []
if player not in okaylastone:
okaylastone.append(player)
if playas[player].hand_rank == high_int:
if player not in okaylastone:
okaylastone.append(player)
if len(okaylastone) >= 1:
return [okaylastone,thisisitiswear,reallyreallyreally,reallyreally,reallywinners]
elif len(thisisitiswear) >= 1:
return [thisisitiswear,reallyreallyreally,reallyreally,reallywinners]
elif len(reallyreallyreally) >= 1:
return [reallyreallyreally,reallyreally,reallywinners]
elif len(reallyreally) >= 1:
return [reallyreally,reallywinners]
else:
return [reallywinners]
######################################################################
def turnscreen(listplayrs):
os.system('cls' if os.name=='nt' else 'clear')
raw_input("Turn the screen to %s and hit enter" % listplayrs)
os.system('cls' if os.name=='nt' else 'clear')
###############################################################
def straight_finder(ranks):
if len(ranks) < 5:
return (False,0)
if ranks == ranks+1 and ranks == ranks+1 and ranks
== ranks+1\
and ranks == ranks+1:
return (True,ranks)
else:
return straight_finder(ranks[1:])
###############################################################################
def four_of_a_kind_finder(ranks):
rankcounter = {14:0,13:0,12:0,11:0,10:0,9:0,8:0,7:0,6:0,5:0,4:0,3:0,2:0}
for rank in ranks:
rankcounter[rank] += 1
if 4 in rankcounter.values():
highcards = []
for card,amount in rankcounter.items():
if amount == 4:
if 0 < amount < 4:
highcards.append(card)
else:
return (False,0)
################################################################################
def fullhouse_finder(ranks):
rankcounter = {14:0,13:0,12:0,11:0,10:0,9:0,8:0,7:0,6:0,5:0,4:0,3:0,2:0}
for rank in ranks:
rankcounter[rank] += 1
set3s = []
set2s = []
for card,amount in rankcounter.items():
if amount == 3:
set3s.append(card)
if amount == 2:
set2s.append(card)
if len(set3s) == 2:
set2s.append(min(have3))
set3s.remove(min(have3))
if len(set3s) == 1 and len(set2s) >= 1:
return (True,set3s,max(set2s))
else:
return (False,0,0)
#################################################
def two_pair_finder(pairranks):
rankcounter = {14:0,13:0,12:0,11:0,10:0,9:0,8:0,7:0,6:0,5:0,4:0,3:0,2:0}
pairsof2 = []
for rank in pairranks:
rankcounter[rank] += 1
if rankcounter[rank] == 2:
pairsof2.append(rank)
highlist = []
for rank,amount in rankcounter.items():
if amount == 1:
highlist.append(rank)
highcard = max(highlist)
if len(pairsof2) >= 2:
overpair = max(pairsof2)
pairsof2.remove(max(pairsof2))
return (True,overpair,max(pairsof2),highcard)
else:
return (False,0,0,0)
#################################################
def flush_finder(final_hand):
flushdict = {'S':0,'C':0,'H':0,'D':0}
for card in final_hand:
flushdict[card] += 1
flushranks = []
for card in final_hand:
if flushdict[card] >= 5:
suit = card
if card == 'A':
flushranks.append(14)
elif card == 'K':
flushranks.append(13)
elif card == 'Q':
flushranks.append(12)
elif card == 'J':
flushranks.append(11)
elif card == 'T':
flushranks.append(10)
else:
flushranks.append(int(card))
if len(flushranks) >= 5:
return (True,sorted(flushranks,reverse=True),suit)
else:
return (False,0,0)
##################################################################
def straight_flush_finder(final_hand):
flushsuits = {'S':0,'C':0,'H':0,'D':0}
for card in final_hand:
flushsuits[card] += 1
flushranks = []
for card in final_hand:
if flushsuits[card] >= 5:
suit = card
if card == 'A':
flushranks.append(14)
elif card == 'K':
flushranks.append(13)
elif card == 'Q':
flushranks.append(12)
elif card == 'J':
flushranks.append(11)
elif card == 'T':
flushranks.append(10)
else:
flushranks.append(int(card))
if len(flushranks) >= 5:
flushrankscopy = flushranks[:]
for rank in flushrankscopy:
if rank == 14:
flushranks.append(1)
newflushranks = sorted(list(set(flushranks)),reverse=True)
while len(newflushranks) >= 5:
if newflushranks == newflushranks+1 and
newflushranks == newflushranks+1 and newflushranks ==
newflushranks+1\
and newflushranks == newflushranks+1:
return (True,newflushranks)
else:
newflushranks = newflushranks[1:]
return (False,0,0)
return (False,0,0)
######################################################################
def three_of_a_kind_finder(pairranks):
rankcounter = {14:0,13:0,12:0,11:0,10:0,9:0,8:0,7:0,6:0,5:0,4:0,3:0,2:0}
for rank in pairranks:
rankcounter[rank] += 1
threes = []
highcards = []
for card,amount in rankcounter.items():
if amount == 3:
threes.append(card)
if 0 < amount < 3:
highcards.append(card)
highcards.sort(reverse=True)
if len(threes) >= 1:
return (True,max(threes),highcards[:2])
return (False,0)
######################################################################
def one_pair_finder(pairranks):
rankcounter = {14:0,13:0,12:0,11:0,10:0,9:0,8:0,7:0,6:0,5:0,4:0,3:0,2:0}
for rank in pairranks:
rankcounter[rank] += 1
highcards = []
pairsof2 = []
for card,amount in rankcounter.items():
if amount == 1:
highcards.append(card)
if amount == 2:
pairsof2.append(card)
if len(pairsof2) >=1:
return (True,max(pairsof2),sorted(highcards,reverse=True))
else:
return (False,0,0)
######################################################################
def highcard_finder(pairranks):
highlist = (sorted(pairranks,reverse=True))
return highlist
######################################################################
def main():
playernum = 0
while playernum not in range(2,10):
playernum = int(raw_input("Welcome to Simultron, How Many Players?"))
listofplayers = []
for x in range(int(playernum)):
listofplayers.append("player"+str(x+1))
for x in listofplayers:
print "Welcome "+x
startstack = 0
while startstack not in range(100,1000000,10):
startstack = int(raw_input("What will the starting stack sizes
be? (100-1000000 increments of 10) "))
bigblind = 19
while bigblind not in range(20,1000,20):
bigblind = int(raw_input("What will the big blind start at?
(20-1000, increments of 20) "))
deck1 = Deck()
table1 = Table(bigblind)
playas = dict((name, Player(stacksize=startstack)) for name in
listofplayers)
table1.fillseats(listofplayers,playas)
table1.postblinds(playas,bigblind,deck1)
if __name__ == "__main__":
main()

```