Groups | Search | Server Info | Keyboard shortcuts | Login | Register [http] [https] [nntp] [nntps]
Groups > comp.lang.python > #80196
| Path | csiph.com!usenet.pasdenom.info!weretis.net!feeder4.news.weretis.net!feeds.phibee-telecom.net!newsfeed.xs4all.nl!newsfeed2a.news.xs4all.nl!xs4all!post.news.xs4all.nl!not-for-mail |
|---|---|
| Return-Path | <illusiontechniques@gmail.com> |
| X-Original-To | python-list@python.org |
| Delivered-To | python-list@mail.python.org |
| X-Spam-Status | OK 0.001 |
| X-Spam-Evidence | '*H*': 1.00; '*S*': 0.00; 'else:': 0.03; 'algorithm': 0.04; 'skip:[ 20': 0.04; 'elif': 0.05; 'nested': 0.07; 'none:': 0.07; 'over,': 0.07; 'skip:p 60': 0.07; '"__main__":': 0.09; '%s"': 0.09; '__name__': 0.09; 'check,': 0.09; 'main()': 0.09; 'skip:# 30': 0.09; 'skip:# 60': 0.09; 'python': 0.11; 'def': 0.12; 'changes': 0.15; '###': 0.16; "%s'": 0.16; "'%s": 0.16; "'q'": 0.16; '(x,': 0.16; '20)': 0.16; 'exit()': 0.16; 'main():': 0.16; 'pairs': 0.16; 'skip:# 80': 0.16; "skip:' 60": 0.16; 'skip:( 90': 0.16; 'skip:[ 40': 0.16; 'skip:[ 50': 0.16; 'skip:[ 60': 0.16; 'skip:l 90': 0.16; 'skip:p 90': 0.16; 'true:': 0.16; 'turn,': 0.16; 'skip:# 20': 0.16; "skip:' 30": 0.19; 'skip:f 30': 0.19; 'split': 0.19; 'stack': 0.19; 'import': 0.22; 'print': 0.22; 'skip:i 40': 0.24; 'skip:l 30': 0.24; 'skip:{ 20': 0.24; 'subject:Code': 0.24; "haven't": 0.24; 'player': 0.26; 'pass': 0.26; 'post': 0.26; 'skip:" 20': 0.27; 'skip:_ 20': 0.27; 'correct': 0.29; 'rest': 0.29; 'wondering': 0.29; 'skip:p 30': 0.29; 'raise': 0.29; 'skip:( 40': 0.30; 'skip:g 30': 0.30; 'message-id:@mail.gmail.com': 0.30; 'skip:( 20': 0.30; "skip:' 10": 0.31; 'option.': 0.31; 'skip:( 50': 0.31; 'class': 0.32; 'option': 0.32; 'worked': 0.33; 'skip:# 10': 0.33; 'skip:t 40': 0.33; 'screen': 0.34; 'skip:d 20': 0.34; 'could': 0.34; 'advice': 0.35; 'display': 0.35; 'skip:s 30': 0.35; 'test': 0.35; 'but': 0.35; 'received:google.com': 0.35; 'in.': 0.36; 'done': 0.36; 'next': 0.36; 'turn': 0.37; 'list': 0.37; 'starting': 0.37; 'feedback': 0.38; 'skip:o 20': 0.38; 'skip:[ 10': 0.38; 'to:addr :python-list': 0.38; 'to:addr:python.org': 0.39; 'enough': 0.39; 'skip:p 20': 0.39; 'how': 0.40; 'catch': 0.60; 'seat': 0.60; 'break': 0.61; 'skip:t 30': 0.61; 'establish': 0.61; 'back': 0.62; 'show': 0.63; 'name': 0.63; 'card': 0.63; 'skip:n 10': 0.64; 'more': 0.64; 'different': 0.65; 'cards': 0.65; 'biggest': 0.67; 'it!': 0.67; 'equals': 0.68; 'prompt': 0.68; 'skip:m 50': 0.68; 'skip:r 30': 0.69; 'hey,': 0.75; 'hand': 0.80; "'you": 0.84; '14:': 0.84; 'amateur': 0.84; 'random,': 0.84; 'ranks': 0.84; 'skip:s 80': 0.84; 'suits': 0.84; 'river': 0.91; 'round,': 0.91; 'rank': 0.93 |
| DKIM-Signature | v=1; a=rsa-sha256; c=relaxed/relaxed; d=gmail.com; s=20120113; h=mime-version:date:message-id:subject:from:to:content-type; bh=+uk1g2Vg1uqLXTcRchH/ds+xcgXlSzCi9meG2zUcxMU=; b=ycSHGtuC/uDbuHIfC7fADJZfMiC8okoZg9ixlj/+DHi9tmVkAijD5mNY/WW4nox5jw b/2snwsEAnQhiKo0Zi17N7IYezEK8yoEvqUUjC6kplIpgud/tFVpyCmSm/LczZLSqw8q Go3oWdJCeK/GKc5BPbDTty+9yAjDGWYfYux2gebtYpzAqwXThJD12F666cfuOjuEnHBs KGX88NpwkfdEkAmP68dOHS1Hm60ZhxgydXLjhOk3XTOC5HxKP/HDcs3+XVTiSl7c+mP+ +pEukFvRn+IPZTJW1OlaJPTjYn3Q7bVg2o0XMuwylT5STZ4mjsgf5mhnDn5DC9TFFu+R R67w== |
| MIME-Version | 1.0 |
| X-Received | by 10.112.169.106 with SMTP id ad10mr60181579lbc.13.1415114913680; Tue, 04 Nov 2014 07:28:33 -0800 (PST) |
| Date | Tue, 4 Nov 2014 07:28:33 -0800 |
| Subject | Code review |
| From | C Smith <illusiontechniques@gmail.com> |
| To | python-list@python.org |
| Content-Type | text/plain; charset=UTF-8 |
| X-Mailman-Approved-At | Tue, 04 Nov 2014 16:30:14 +0100 |
| X-BeenThere | python-list@python.org |
| X-Mailman-Version | 2.1.15 |
| Precedence | list |
| List-Id | General discussion list for the Python programming language <python-list.python.org> |
| List-Unsubscribe | <https://mail.python.org/mailman/options/python-list>, <mailto:python-list-request@python.org?subject=unsubscribe> |
| List-Archive | <http://mail.python.org/pipermail/python-list/> |
| List-Post | <mailto:python-list@python.org> |
| List-Help | <mailto:python-list-request@python.org?subject=help> |
| List-Subscribe | <https://mail.python.org/mailman/listinfo/python-list>, <mailto:python-list-request@python.org?subject=subscribe> |
| Newsgroups | comp.lang.python |
| Message-ID | <mailman.15454.1415115015.18130.python-list@python.org> (permalink) |
| Lines | 1159 |
| NNTP-Posting-Host | 2001:888:2000:d::a6 |
| X-Trace | 1415115015 news.xs4all.nl 2830 [2001:888:2000:d::a6]:39839 |
| X-Complaints-To | abuse@xs4all.nl |
| Xref | csiph.com comp.lang.python:80196 |
Show key headers only | View raw
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
# Heads up post blinds
if len(self.PLAYERORDER) == 2:
if bigblind >= playas[self.PLAYERORDER[1]].stacksize:
if bigblind == playas[self.PLAYERORDER[1]].stacksize:
playas[self.PLAYERORDER[1]].stacksize = 0
self.pot += bigblind
playas[self.PLAYERORDER[1]].all_in = 1
playas[self.PLAYERORDER[1]].in_front = bigblind
playas[self.PLAYERORDER[1]].put_in_pot = bigblind
else:
self.pot += playas[self.PLAYERORDER[1]].stacksize
playas[self.PLAYERORDER[1]].in_front =
playas[self.PLAYERORDER[1]].stacksize
playas[self.PLAYERORDER[1]].put_in_pot =
playas[self.PLAYERORDER[1]].stacksize
playas[self.PLAYERORDER[1]].stacksize = 0
playas[self.PLAYERORDER[1]].all_in = 1
if (bigblind/2) >= playas[self.PLAYERORDER[0]].stacksize:
if bigblind == playas[self.PLAYERORDER[0]].stacksize:
playas[self.PLAYERORDER[0]].in_front = bigblind/2
playas[self.PLAYERORDER[0]].put_in_pot = bigblind/2
playas[self.PLAYERORDER[0]].stacksize = 0
self.pot += bigblind/2
playas[self.PLAYERORDER[0]].all_in = 1
else:
playas[self.PLAYERORDER[0]].put_in_pot =
playas[self.PLAYERORDER[0]].stacksize
playas[self.PLAYERORDER[0]].in_front =
playas[self.PLAYERORDER[0]].stacksize
playas[self.PLAYERORDER[0]].stacksize = 0
playas[self.PLAYERORDER[0]].all_in = 1
if playas[self.PLAYERORDER[0]].all_in == 0:
playas[self.PLAYERORDER[0]].stacksize -= bigblind/2
playas[self.PLAYERORDER[0]].in_front = bigblind/2
playas[self.PLAYERORDER[0]].put_in_pot = bigblind/2
self.pot += bigblind/2
if playas[self.PLAYERORDER[1]].all_in == 0:
playas[self.PLAYERORDER[1]].stacksize -= bigblind
playas[self.PLAYERORDER[1]].in_front = bigblind
playas[self.PLAYERORDER[1]].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[1]].stacksize <= bigblind/2:
if playas[self.PLAYERORDER[1]].stacksize < bigblind/2:
playas[self.PLAYERORDER[1]].all_in = 1
self.pot += playas[self.PLAYERORDER[1]].stacksize
playas[self.PLAYERORDER[1]].in_front =
playas[self.PLAYERORDER[1]].stacksize
playas[self.PLAYERORDER[1]].put_in_pot =
playas[self.PLAYERORDER[1]].stacksize
playas[self.PLAYERORDER[1]].stacksize = 0
elif playas[self.PLAYERORDER[1]].stacksize == bigblind/2:
playas[self.PLAYERORDER[1]].all_in = 1
self.pot += bigblind/2
playas[self.PLAYERORDER[1]].in_front = bigblind/2
playas[self.PLAYERORDER[1]].put_in_pot = bigblind/2
playas[self.PLAYERORDER[1]].stacksize = 0
else: # normal post small blind
playas[self.PLAYERORDER[1]].stacksize -= bigblind/2
playas[self.PLAYERORDER[1]].in_front = bigblind/2
playas[self.PLAYERORDER[1]].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[0] for x in final_hand]
suits = [x[1] 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)[0] == True:
playas[player].hand_rank =
(9,straight_flush_finder(final_hand))
elif four_of_a_kind_finder(pairranks)[0] == True:
playas[player].hand_rank = (8,four_of_a_kind_finder(pairranks))
elif fullhouse_finder(pairranks)[0] == True:
playas[player].hand_rank = (7,fullhouse_finder(pairranks))
elif flush_finder(final_hand)[0] == True:
playas[player].hand_rank = (6,flush_finder(final_hand))
elif straight_finder(straightranks)[0] == True:
playas[player].hand_rank = (5,straight_finder(straightranks))
elif three_of_a_kind_finder(pairranks)[0] == True:
playas[player].hand_rank = (4,three_of_a_kind_finder(pairranks))
elif two_pair_finder(pairranks)[0] == True:
playas[player].hand_rank = (3,two_pair_finder(pairranks))
elif one_pair_finder(pairranks)[0] == 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[0]].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[0] >= handtobeat:
handtobeat = playas[player].hand_rank[0]
sidepot1winners.append(player)
for player in sidepot1winners:
if playas[player].hand_rank[0] < handtobeat:
sidepot1winners.remove(player)
sidepot1winners = tie_breaker(sidepot1winners,playas)
for player in sidepot1winners[0]:
print '%s you win %s chips' %
(player,sidepot1/len(sidepot1winners[0]))
playas[player].stacksize +=
(sidepot1/len(sidepot1winners[0]))
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[0] >= handtobeat:
handtobeat = playas[player].hand_rank[0]
winningplayers.append(player)
winnerscopy = winningplayers[:]
for player in winnerscopy:
if playas[player].hand_rank[0] < handtobeat:
winningplayers.remove(player)
# tie_breaker changes winningplayers into nested list
winningplayers = tie_breaker(winningplayers,playas)
for winnerwinner in winningplayers[0]:
self.hand_done = 1
print '%s you win %s chips' %
(winnerwinner,self.pot/len(winningplayers[0]))
playas[winnerwinner].stacksize += (self.pot/len(winningplayers[0]))
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[0]
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[0]
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[0],self.pot)
playas[self.in_hand[0]].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[0])
if showmuck == 's':
playas[self.in_hand[0]].showhand()
if showmuck == 'm':
playas[self.in_hand[0]].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[0]].all_in == 1:
raw_input("%s you are all in, hit enter to continue" %
self.left_to_act[0])
if self.left_to_act[0] not in self.in_hand:
self.in_hand.append(self.left_to_act[0])
del self.left_to_act[0]
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[0] + ' your hand is
'+playas[self.left_to_act[0]].hand[0]+'
'+playas[self.left_to_act[0]].hand[1]
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[0]].in_front)
print 'You have %s in the pot' % playas[self.left_to_act[0]].put_in_pot
print 'You started the hand with %s chips' %
playas[self.left_to_act[0]].start_stack
print 'This round, you have put %s chips in the pot' %
playas[self.left_to_act[0]].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[0]].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[0])
#Check your turn, if infront == cost
if current_action == 'c':
if self.left_to_act[0] in self.in_hand:
del self.in_hand[self.left_to_act[0]]
self.in_hand.append(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
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[0]))
while currentraise < 2*self.last_raise:
currentraise = int(raw_input('%s what will you
bet? (increments of 10) ' % self.left_to_act[0]))
# Bet with exactly enough chips, after check option
if
self.cost_to_play-playas[self.left_to_act[0]].in_front + currentraise
== playas[self.left_to_act[0]].stacksize:
raw_input("%s you are all in" % self.left_to_act[0])
playas[self.left_to_act[0]].all_in = 1
self.last_raise = playas[self.left_to_act[0]].stacksize
self.pot +=
(self.cost_to_play-playas[self.left_to_act[0]].in_front+playas[self.left_to_act[0]].stacksize)
self.cost_to_play += playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].in_front +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].put_in_pot +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].stacksize = 0
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
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[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
### Bet, not enough chips, after check option
elif
self.cost_to_play-playas[self.left_to_act[0]].in_front + currentraise
> playas[self.left_to_act[0]].stacksize:
raw_input("Not enough to raise that amount, %s put
all in, hit enter" % self.left_to_act[0])
playas[self.left_to_act[0]].all_in = 1
self.pot += playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].put_in_pot +=
playas[self.left_to_act[0]].stacksize
currentraise =
playas[self.left_to_act[0]].stacksize-self.cost_to_play-playas[self.left_to_act[0]].in_front
playas[self.left_to_act[0]].in_front +=
playas[self.left_to_act[0]].stacksize
self.cost_to_play += currentraise
self.last_raise = playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].stacksize = 0
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
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[0])
self.left_to_act.remove(self.left_to_act[0])
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[0]].in_front)
playas[self.left_to_act[0]].put_in_pot +=
(currentraise +
self.cost_to_play-playas[self.left_to_act[0]].in_front)
self.last_raise = currentraise
self.cost_to_play += currentraise
playas[self.left_to_act[0]].stacksize -=
(self.cost_to_play - playas[self.left_to_act[0]].in_front)
playas[self.left_to_act[0]].in_front +=
(self.cost_to_play - playas[self.left_to_act[0]].in_front)
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
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[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
# Fold, after check option. Hey, you can do it!
elif current_action == 'f':
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
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[0])
# Call
if current_action == 'c':
# Not enough chips, or just enough chips to call
if self.cost_to_play-playas[self.left_to_act[0]].in_front
>= playas[self.left_to_act[0]].stacksize:
playas[self.left_to_act[0]].all_in = 1
self.pot += playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].put_in_pot +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].in_front +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].stacksize = 0
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
self.in_hand.append(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
# Call, with more than enough chips
else:
playas[self.left_to_act[0]].stacksize -=
(self.cost_to_play-playas[self.left_to_act[0]].in_front)
self.pot +=
(self.cost_to_play-playas[self.left_to_act[0]].in_front)
playas[self.left_to_act[0]].put_in_pot +=
(self.cost_to_play-playas[self.left_to_act[0]].in_front)
playas[self.left_to_act[0]].in_front +=
(self.cost_to_play-playas[self.left_to_act[0]].in_front)
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
self.in_hand.append(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
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[0]))
while currentraise < 2*self.last_raise:
currentraise = int(raw_input('%s what will you raise?
(increments of 10) ' % self.left_to_act[0]))
# Raise with exactly enough chips
if self.cost_to_play-playas[self.left_to_act[0]].in_front
+ currentraise == playas[self.left_to_act[0]].stacksize:
raw_input("%s you are all in" % self.left_to_act[0])
self.pot += playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].put_in_pot +=
playas[self.left_to_act[0]].stacksize
self.cost_to_play += currentraise
self.last_raise = currentraise
playas[self.left_to_act[0]].all_in = 1
playas[self.left_to_act[0]].in_front +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].stacksize = 0
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
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[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
### Raise not enough chips
elif
self.cost_to_play-playas[self.left_to_act[0]].in_front + currentraise
> playas[self.left_to_act[0]].stacksize:
raw_input("%s put all in, hit enter" % self.left_to_act[0])
playas[self.left_to_act[0]].all_in = 1
self.cost_to_play = playas[self.left_to_act[0]].stacksize
self.last_raise = playas[self.left_to_act[0]].stacksize
self.pot += playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].put_in_pot +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].in_front +=
playas[self.left_to_act[0]].stacksize
playas[self.left_to_act[0]].stacksize = 0
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
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[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
# Raise with enough chips
self.pot += (currentraise +
self.cost_to_play-playas[self.left_to_act[0]].in_front)
playas[self.left_to_act[0]].put_in_pot += (currentraise +
self.cost_to_play-playas[self.left_to_act[0]].in_front)
self.last_raise = currentraise
self.cost_to_play += currentraise
playas[self.left_to_act[0]].stacksize -=
(self.cost_to_play - playas[self.left_to_act[0]].in_front)
playas[self.left_to_act[0]].in_front += (self.cost_to_play
- playas[self.left_to_act[0]].in_front)
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
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[0])
self.left_to_act.remove(self.left_to_act[0])
self.get_action(playas,bigblind,deck)
# Fold, after call option
elif current_action == 'f':
if self.left_to_act[0] in self.in_hand:
self.in_hand.remove(self.left_to_act[0])
self.left_to_act.remove(self.left_to_act[0])
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[0]].hand_rank[0]
reallywinners = []
reallyreally = []
reallyreallyreally = []
thisisitiswear = []
okaylastone = []
high_int = 0
if ranky == 9 or ranky == 5:
for player in winningplayers:
if playas[player].hand_rank[1][1] > high_int:
reallywinners = []
high_int = playas[player].hand_rank[1][1]
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][1] == 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[1][1] > high_int:
reallywinners = []
high_int = playas[player].hand_rank[1][1]
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][1] == 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[1][2] > high_int:
reallyreally = []
high_int = playas[player].hand_rank[1][2]
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank[1][2] == high_int:
if player not in reallyreally:
reallyreally.append(player)
elif ranky == 6:
for player in winningplayers:
if playas[player].hand_rank[1][1][0] > high_int:
reallywinners = []
high_int = playas[player].hand_rank[1][1][0]
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][1][0] == high_int:
if player not in reallywinners:
reallywinners.append(player)
elif ranky == 4:
for player in winningplayers:
if playas[player].hand_rank[1][1] > high_int:
reallywinners = []
high_int = playas[player].hand_rank[1][1]
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][1] == 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[1][2][0] > high_int:
reallyreally = []
high_int = playas[player].hand_rank[1][2][0]
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank[1][2][1] == high_int:
if player not in reallyreally:
reallyreally.append(player)
elif ranky == 3:
for player in winningplayers:
if playas[player].hand_rank[1][1] > high_int:
reallywinners = []
high_int = playas[player].hand_rank[1][1]
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][1] == 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[1][2] > high_int:
reallyreally = []
high_int = playas[player].hand_rank[1][2]
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank[1][2] == 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[1][3] > high_int:
reallyreallyreally = []
high_int = playas[player].hand_rank[1][3]
if player not in reallyreallyreally:
reallyreallyreally.append(player)
if playas[player].hand_rank[1][3] == high_int:
if player not in reallyreallyreally:
reallyreallyreally.append(player)
elif ranky == 2:
for player in winningplayers:
if playas[player].hand_rank[1][1] > high_int:
high_int = playas[player].hand_rank[1][1]
reallywinners = []
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][1] == 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[1][2][0] > high_int:
high_int = playas[player].hand_rank[1][2][0]
reallyreally = []
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank[1][2][0] == 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[1][2][1] > high_int:
high_int = playas[player].hand_rank[1][2][1]
reallyreallyreally = []
if player not in reallyreallyreally:
reallyreallyreally.append(player)
if playas[player].hand_rank[1][2][1] == 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[1][2][2] > high_int:
high_int = playas[player].hand_rank[1][2][2]
thisisitiswear = []
if player not in thisisitiswear:
thisisitiswear.append(player)
if playas[player].hand_rank[1][2][2] == high_int:
if player not in thisisitiswear:
thisisitiswear.append(player)
elif ranky == 1:
for player in winningplayers:
if playas[player].hand_rank[1][0] > high_int:
high_int = playas[player].hand_rank[1][0]
reallywinners = []
if player not in reallywinners:
reallywinners.append(player)
if playas[player].hand_rank[1][0] == 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[1][1] > high_int:
high_int = playas[player].hand_rank[1][1]
reallyreally = []
if player not in reallyreally:
reallyreally.append(player)
if playas[player].hand_rank[1][1] == 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[1][2] > high_int:
high_int = playas[player].hand_rank[1][2]
reallyreallyreally = []
if player not in reallyreallyreally:
reallyreallyreally.append(player)
if playas[player].hand_rank[1][2] == 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[1][3] > high_int:
high_int = playas[player].hand_rank[1][3]
thisisitiswear = []
if player not in thisisitiswear:
thisisitiswear.append(player)
if playas[player].hand_rank[1][3] == 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[1][4] > high_int:
high_int = playas[player].hand_rank[1][4]
okaylastone = []
if player not in okaylastone:
okaylastone.append(player)
if playas[player].hand_rank[1][4] == 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[0])
os.system('cls' if os.name=='nt' else 'clear')
###############################################################
def straight_finder(ranks):
if len(ranks) < 5:
return (False,0)
if ranks[0] == ranks[1]+1 and ranks[1] == ranks[2]+1 and ranks[2]
== ranks[3]+1\
and ranks[3] == ranks[4]+1:
return (True,ranks[0])
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 = []
quads = 0
for card,amount in rankcounter.items():
if amount == 4:
quads = card
if 0 < amount < 4:
highcards.append(card)
return (True,quads,max(highcards))
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[0],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]] += 1
flushranks = []
for card in final_hand:
if flushdict[card[1]] >= 5:
suit = card[1]
if card[0] == 'A':
flushranks.append(14)
elif card[0] == 'K':
flushranks.append(13)
elif card[0] == 'Q':
flushranks.append(12)
elif card[0] == 'J':
flushranks.append(11)
elif card[0] == 'T':
flushranks.append(10)
else:
flushranks.append(int(card[0]))
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]] += 1
flushranks = []
for card in final_hand:
if flushsuits[card[1]] >= 5:
suit = card[1]
if card[0] == 'A':
flushranks.append(14)
elif card[0] == 'K':
flushranks.append(13)
elif card[0] == 'Q':
flushranks.append(12)
elif card[0] == 'J':
flushranks.append(11)
elif card[0] == 'T':
flushranks.append(10)
else:
flushranks.append(int(card[0]))
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[0] == newflushranks[1]+1 and
newflushranks[1] == newflushranks[2]+1 and newflushranks[2] ==
newflushranks[3]+1\
and newflushranks[3] == newflushranks[4]+1:
return (True,newflushranks[0])
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()
Back to comp.lang.python | Previous | Next — Next in thread | Find similar | Unroll thread
Code review C Smith <illusiontechniques@gmail.com> - 2014-11-04 07:28 -0800
Re: Code review John Gordon <gordon@panix.com> - 2014-11-04 20:35 +0000
Re: Code review sohcahtoa82@gmail.com - 2014-11-04 16:09 -0800
Re: Code review C Smith <illusiontechniques@gmail.com> - 2014-11-04 22:23 -0800
csiph-web