class Game:
def __init__(self, num_players=1, num_decks=6):
self.num_decks = num_decks
self.dealer = Dealer()
self.bot = Bot('Bot')
self.players = []
self.busted = []
self.stand = []
self.move = 0
self.dealer_done = False
self.bot_moves = []
for i in xrange(0,num_players):
self.players.append(Player('Player'+str(i+1)))
self.players.append(self.bot)
self.deck = Deck(num_decks)
self.bot_deck = self.deck.deck * 1
for player in self.players:
player.make_bet()
if player.name == 'Bot':
player.add(self.bot_deck.pop())
player.add(self.bot_deck.pop())
self.bot_deck.pop()
self.bot_deck.pop()
else:
player.add(self.deck.draw())
player.add(self.deck.draw())
self.dealer.add(self.deck.draw())
self.dealer.add(self.deck.draw())
self.rules = RulesEngine(self.dealer, self.players)
def ongoing(self):
return not len(self.players) == 0 or not self.dealer_done
def winner(self):
self.stand.sort(key=lambda x: x.val)
self.stand.reverse()
winner = self.dealer if self.dealer.val <= 21 else Player("Default")
for player in self.stand:
if player.val > winner.val:
winner = player
return winner
def payout(self):
self.rules.update(self.stand)
def reset(self):
self.players = self.rules.players
self.stand = []
self.busted = []
self.dealer_done = False
self.bot.update(self.players+[self.dealer])
if len(self.deck.deck) <= self.deck.num_decks*52*0.25: # re-shuffle if < 75% of deck left
self.deck.deck = self.deck.generate(self.deck.num_decks)
self.deck.shuffle()
self.reset_count()
self.dealer.clear_hand()
for player in self.players:
player.clear_hand()
self.bot_deck = self.deck.deck * 1
for player in self.players:
player.make_bet()
if player.name == 'Bot':
player.add(self.bot_deck.pop())
player.add(self.bot_deck.pop())
self.bot_deck.pop()
self.bot_deck.pop()
else:
player.add(self.deck.draw())
player.add(self.deck.draw())
self.dealer.add(self.deck.draw())
self.dealer.add(self.deck.draw())
self.bot_moves = []
def move_player(self, player, hand):
newplayers = []
if self.players[0].name == "Bot":
move = player.play(self.dealer,hand)
else:
move = self.move
if move == 1:
player.add(self.deck.draw(),hand)
if hand == len(player.hands)-1:
newplayers.append(player)
elif move == -1:
if hand == len(player.hands)-1:
self.busted.append(player)
elif move == 2:
player.add(self.deck.draw(),hand)
player.doubled_down = True
player.cash -= player.bet
player.bet *= 2
if hand == len(player.hands)-1:
newplayers.append(player)
elif move == 3:
player.aces.append(0)
player.tmp.append(0)
player.hands.append([])
card2 = player.hands[0].pop()
player.val[0] = 0
player.add(player.hands[0].pop(),0)
player.cash -= player.bet
player.val.append(0)
player.add(card2,1)
player.add(self.deck.draw(),0)
player.add(self.deck.draw(),1)
newplayers.append(player)
def run(self):
newplayers = []
move = self.dealer.play()
if move == 1:
self.dealer.add(self.deck.draw())
self.bot_deck.pop()
else:
self.dealer_done = True
for i in xrange(0,len(self.players)):
for j in xrange(0,len(self.players[i].hands)):
if self.players[i].name == "Bot":
move = self.players[i].play(self.dealer,j)
if move == 2 and len(self.bot.hands[j]) > 2:
move = 1
if not (move == 0 and (j,move) in self.bot_moves):
self.bot_moves.append((j,move))
else:
move = self.move
if move == 1:
if self.players[i].name == 'Bot':
self.players[i].add(self.bot_deck.pop(),j)
else:
self.players[i].add(self.deck.draw(),j)
if j == len(self.players[i].hands)-1:
newplayers.append(self.players[i])
elif move == -1:
if j == len(self.players[i].hands)-1:
self.busted.append(self.players[i])
elif move == 2:
if self.players[i].name == 'Bot':
self.players[i].add(self.bot_deck.pop(),j)
else:
self.players[i].add(self.deck.draw(),j)
self.players[i].doubled_down = True
self.players[i].cash -= self.players[i].bet
self.players[i].bet *= 2
if j == len(self.players[i].hands)-1:
newplayers.append(self.players[i]) # STAND?
elif move == 3:
self.players[i].aces.append(0)
self.players[i].tmp.append(0)
self.players[i].hands.append([])
card2 = self.players[i].hands[0].pop()
self.players[i].val[0] = 0
self.players[i].add(self.players[i].hands[0].pop(),0)
self.players[i].cash -= self.players[i].bet
self.players[i].val.append(0)
self.players[i].add(card2,1)
if self.players[i].name == 'Bot':
self.players[i].add(self.bot_deck.pop(),0)
self.players[i].add(self.bot_deck.pop(),1)
else:
self.players[i].add(self.deck.draw(),0)
self.players[i].add(self.deck.draw(),1)
newplayers.append(self.players[i])
else:
if j == len(self.players[i].hands)-1:
self.stand.append(self.players[i])
self.players = newplayers
def reset_count(self):
self.bot.rcount = 0
self.bot.tcount = 0
self.bot.dead_cards = 0
def __repr__(self):
repr = ['\n']
repr.append('Dealer: ' + str(self.dealer))
for player in self.players:
repr.append('Active Player --> ' + str(player))
for player in self.stand:
repr.append('Standing Player --> ' + str(player))
for player in self.busted:
repr.append('Busted Player --> ' + str(player))
repr.append('\n')
return '\n'.join(repr)
class Game(object):
"""
A sequence of Blackjack Rounds that keeps track of total money won or lost
"""
def __init__(self, strategy=None):
self.shoe = Shoe(SHOE_SIZE)
self.money = 0.0
self.bet = 1.0
self.stake = 1.0
self.player = Player(strategy=strategy)
self.dealer = Dealer()
def get_status(self, hand):
if not hand.surrender:
if hand.busted():
status = "LOST"
else:
if hand.blackjack():
if self.dealer.hand.blackjack():
status = "PUSH"
else:
status = "WON 3:2"
elif self.dealer.hand.busted():
status = "WON"
elif self.dealer.hand.value < hand.value:
status = "WON"
elif self.dealer.hand.value > hand.value:
status = "LOST"
elif self.dealer.hand.value == hand.value:
if self.dealer.hand.blackjack():
status = "LOST" # player's 21 vs dealers blackjack
else:
status = "PUSH"
else:
status = "SURRENDER"
return status
def get_hand_winnings(self, hand):
win = 0.0
bet = self.stake
status = self.get_status(hand)
if status == "LOST":
win += -1
elif status == "WON":
win += 1
elif status == "WON 3:2":
win += 1.5
elif status == "SURRENDER":
win += -0.5
if hand.doubled:
win *= 2
bet *= 2
win *= self.stake
return win, bet, status
def play_round(self):
self.stake = 1.0
player_hand = Hand([self.shoe.deal(), self.shoe.deal()])
dealer_hand = Hand([self.shoe.deal()])
self.player.set_hands(player_hand, dealer_hand)
self.dealer.set_hand(dealer_hand)
print "Dealer Hand: %s" % self.dealer.hand
print "Player Hand: %s\n" % self.player.hands[0]
self.player.play(self.shoe)
self.dealer.play(self.shoe)
for hand in self.player.hands:
win, bet, flag = self.get_hand_winnings(hand)
self.money += win
self.bet += bet
self.player.strategy.record_result(hand, self.player, win)
# print "Player Hand: %s %s (Value: %d, Busted: %r, BlackJack: %r, Splithand: %r, Soft: %r, Surrender: %r, Doubled: %r)" % (hand, status, hand.value, hand.busted(), hand.blackjack(), hand.splithand, hand.soft(), hand.surrender, hand.doubled)
# print "Dealer Hand: %s (%d)" % (self.dealer.hand, self.dealer.hand.value)
print self.player.strategy.qlearner.print_q()
def get_money(self):
return self.money
def get_bet(self):
return self.bet
class Game(object):
def __init__(self):
self.shoe = Shoe(DECKS_IN_SHOE)
self.players = []
self.dealer = Dealer()
def init_game(self):
print('''
.------.
|A_ _ | Welcome to Ben's Blackjack Game
|( \/ ).-----.
| \ /|J /\ | Please follow the prompts below
| \/ | / \ |
`-----| \ / |
| \/ J|
`------'
''')
self.init_players()
def init_players(self):
player_count = get_non_negative_int_lt(
"How many players will be playing: ", 6)
for i in range(1, int(player_count) + 1):
name = input("Player %d name: " % i)
self.players.append(Player(name))
print('\n', end='')
def play(self):
while True:
self.play_round()
def play_round(self):
self.take_bets()
self.display_dealer()
for player in self.players:
print(f"\nIt is now {player.name}'s turn")
self.play_hand(player)
self.dealer.play(self.shoe)
self.display_dealer()
self.resolve_bets()
self.display_money()
self.kick_players()
def take_bets(self):
for player in self.players:
bet_amount = get_non_negative_int_lt(
f"How much would {player.name} like to bet? [Minimum: ${MINIMUM_BET}, Balance: {player.money}]: $",
player.money, "You can not bet that amount!")
if bet_amount < MINIMUM_BET:
bet_amount = MINIMUM_BET
player.money -= bet_amount
player.set_hand(
Hand([self.shoe.deal(), self.shoe.deal()], bet_amount))
self.dealer.set_hand(Hand([self.shoe.deal(), self.shoe.deal()]))
print('\n', end='')
def display_dealer(self):
print("Dealer's Hand:", self.dealer.hand)
def play_hand(self, player):
for i, hand in enumerate(player.hands):
while not hand.busted() and not hand.stayed:
print(f"\t{player.name}'s hand {i+1}\n\t", hand)
choice = self.handle_hand_options(player, hand)
if choice == 'Hit':
print(f"\t{player.name} chose to Hit!")
player.hit(hand, self.shoe)
elif choice == 'Stay':
print(f"\t{player.name} chose to Stay!")
player.stay(hand)
elif choice == "Double Down":
print(f"\t{player.name} chose to Double Down!")
player.double_down(hand, self.shoe)
elif choice == "Split":
print(f"\t{player.name} chose to Split!")
player.split(hand)
if hand.busted():
print(f"\t{player.name}'s final hand {i+1} went bust\n\t",
hand)
else:
print(f"\t{player.name}'s final hand {i+1}\n\t", hand)
print('\n', end='')
def handle_hand_options(self, player, hand):
option_number = 1
valid_options = []
print('\tType the corresponding number:')
print(f"\t\t[{option_number}] 'Stay'")
valid_options.append('Stay')
option_number += 1
if hand.value < 21:
print(f"\t\t[{option_number}] 'Hit'")
valid_options.append('Hit')
option_number += 1
if hand.length(
) == 2 and hand.value != 21 and player.money > hand.bet and not hand.split_hand:
print(f"\t\t[{option_number}] 'Double Down'")
valid_options.append('Double Down')
option_number += 1
if hand.splitable() and len([
h for h in player.hands if h.split_hand
]) <= SPLIT_LIMIT and player.money > hand.bet:
print(f"\t\t[{option_number}] 'Split'")
valid_options.append('Split')
option_number += 1
choice = get_non_negative_int_lt('\tChoice: ',
max_val=option_number - 1,
err="That is an invalid choice")
print('\n', end='')
return valid_options[choice - 1]
def display_money(self):
for player in self.players:
print(f"{player.name} has ${player.money}")
print("\n", end='')
def resolve_bets(self):
print(f"\tBetting Results:")
dealer_value = self.dealer.hand.value
dealer_blackjack = self.dealer.hand.blackjack()
for player in self.players:
for hand in player.hands:
if not hand.busted() and hand.value > dealer_value:
player.money += hand.bet * WIN_MULTIPLIER
print(f"\t{player.name} won ${hand.bet * WIN_MULTIPLIER}")
elif not hand.busted(
) and hand.value == dealer_value and not dealer_blackjack:
player.money += hand.bet
print(f"\t{player.name} pushed")
else:
print(f"\t{player.name} lost his bet of ${hand.bet}")
print('\n', end='')
def kick_players(self):
for player in self.players:
if player.money == 0:
self.players.remove(player)
print(f"{player.name} has been eliminated")
print("\n", end='')
class Game(BaseClass):
"""
The Game
"""
def __init__(self, com, minPl, maxPl, cd_join, cd_kick, d):
BaseClass.__init__(self)
self.com = com
self.minPl = minPl
self.maxPl = maxPl
self.maxQueue = 20
self.cd_join = cd_join
self.cd_kick = cd_kick
self.com.regEvt("chat", self.chat)
self.com.regEvt("join", self.join)
self.com.regEvt("play", self.pl_play)
self.com.regEvt("client_error", self.cl_er)
self.clients = []
self.debug = d
def setup_new_game(self):
self.log("Setting up new game")
self.dealer = Dealer(self, self.cd_kick)
self.dealer.regEvt("won", self.pl_won)
self.dealer.regEvt("kick", self.pl_kicked)
self.status = 0
self.count_time = 0
self.playing_list = []
for c in self.clients:
c.playerId = 0
self.check_countdown()
def start_game(self):
"""
this is the actual start game method
counting down is another one
"""
self.log("starting game")
n = len(self.clients)
if n > self.maxPl:
n = self.maxPl
self.total_player = n
for i in xrange(0, n):
self.clients[i].playerId = i + 1
self.playing_list.append(self.clients[i])
self.dealer.start_game(n)
self.status = 2 # playing
#time comes
#this is called every time in the outer loop
#it will check 2 things: counting down in the game
#and counting down in player move
def check_time(self):
now = time.time()
if self.status == 1: #waiting
if now - self.count_time >= self.cd_join: #time up
self.start_game()
elif self.status == 2: #playing
self.dealer.check_time()
#event
def chat(self, sockId, msg):
playerName = self.by_sockId(sockId).playerName
self.com.bc_chat(playerName, msg)
def join(self, sockId, msg):
if len(self.clients) > self.maxQueue:
self.com.kick_bysockId(sockId)
return
for c in self.clients:
if c.sockId == sockId:
self.com.s_invalid(sockId, "You already joined")
return
if c.playerName == msg:
self.com.s_invalid(sockId, "The name is already taken")
return
try:
p = PlayerInfo(msg, 0, sockId)
except:
self.com.s_invalid(sockId, msg)
return
self.clients.append(p)
self.com.s_accept(sockId, msg)
if self.status == 0 or self.status == 1: # waiting or counting
self.check_countdown()
else:
self.com.s_wait(sockId, msg)
self.com.bc_newplayer(self.all_player())
def pl_play(self, sockId, msg):
if self.status == 2:
player = self.by_sockId(sockId)
try:
self.dealer.play(player.playerId, msg)
except UnoException as e:
self.com.s_invalid(sockId, e.__str__())
def pl_won(self, playerId):
playerName = self.by_playerId(playerId).playerName
self.com.bc_gg(playerName)
self.setup_new_game()
def pl_kicked(self, playerId):
p = self.by_playerId(playerId)
self.playing_list.remove(p)
self.kick(p)
def cl_er(self, sockId):
try:
player = self.by_sockId(sockId)
except Exception as e:
return
if player in self.playing_list:
self.dealer.kick_player(player.playerId)
else:
self.kick(player)
if self.status == 1: #counting
self.check_countdown()
def kick(self, p):
sockId = p.sockId
self.clients.remove(p)
self.com.kick_bysockId(sockId)
self.com.bc_newplayer(self.all_player())
#check if we should start counting down
def check_countdown(self):
if len(self.clients) >= self.minPl and len(self.clients) <= self.maxPl:
self.count_time = time.time()
self.status = 1
else:
self.status = 0
#helper
def all_player(self):
n = len(self.clients)
all_player = ",".join([p.playerName for p in self.clients if p.playerId <= n])
return all_player
def by_sockId(self, sockId):
return [c for c in self.clients if c.sockId == sockId][0]
def by_playerId(self, playerId):
return [c for c in self.playing_list if c.playerId == playerId][0]
def by_name(self, name):
return [c for c in self.client if c.playerName == name][0]
def log(self, s):
if self.debug:
print s
#send method from player class
def com_s_deal(self, playerId, msg):
self.log("Sending deal to: %d with %s" % (playerId, msg))
sockId = self.by_playerId(playerId).sockId
self.com.s_deal(sockId, msg)
def com_s_go(self, playerId, msg):
sockId = self.by_playerId(playerId).sockId
self.com.s_go(sockId, msg)
def com_bc_gg(self, playerId):
playerName = self.by_playerId(playerId).playerName
self.com.bc_gg(playerName)
def com_bc_uno(self, playerId):
playerName = self.by_playerId(playerId).playerName
self.com.bc_uno(playerName)
def com_bc_play(self, playerId, msg):
playerName = self.by_playerId(playerId).playerName
self.com.bc_play(playerName, "%s,%s" % (playerName, msg))
def com_bc_startgame(self):
msg = ",".join([p.playerName for p in self.playing_list])
self.com.bc_start(msg)
class CasinoBJTable(object):
DEBUG = False
ROLLOUTS = False
def __init__(self, numDecks, numPlayers):
self.numDecks = numDecks
self.deck = Shoe(numDecks)
self.dealer = Dealer(Dealer.bankStart, numDecks)
self.playersList = []
self.numPlayers = numPlayers
for i in range(0, numPlayers):
if CasinoBJTable.ROLLOUTS:
playerPerson = Player(i, Player.startingBank, numDecks)
self.playersList.append(playerPerson)
else:
self.playersList.append(
ROPlayer(i, Player.startingBank, numDecks,
"MEGA_DICT.bin"))
self.playersList.append(
BSPlayer(i, Player.startingBank, numDecks))
self.playersList.append(
CCPlayer(i, Player.startingBank, numDecks))
# self.playersList.append(Dealer(Dealer.bankStart, numDecks))
shuffle(self.playersList)
def givePlayerCard(self, player):
aCard = self.deck.getTopCard()
print "Giving the player: " + aCard
player.getCard(aCard, 0)
def updatePlayers(self, aCard):
for i in range(0, self.numPlayers):
self.playersList[i].countCard(aCard)
def saveGameState(self):
exit("Save Not implemented")
def playRound(self):
for pl in self.playersList:
counter = 0
moreHands = True
if CasinoBJTable.DEBUG:
StaticBJLogger.writeDealerMove(
DealerMove("TEST" + str(pl.getHands()[0].getHandValue()),
pl.getHands()[counter])) # Move.NOTCOMPLETE))
while moreHands:
old = len(pl.getHands())
while counter < len(pl.getHands()):
if CasinoBJTable.DEBUG:
print "counter:", counter
keepGoing = True
while keepGoing == True:
if CasinoBJTable.DEBUG:
keepGoing = pl.play(counter)
else:
keepGoing = pl.play(
counter,
self.dealer.getVisibleHand(0).getHandValue())
if keepGoing == True:
newCard = self.deck.getTopCard()
pl.getHands()[counter].addCard(newCard)
self.updatePlayers(newCard)
if CasinoBJTable.ROLLOUTS:
StaticBJLogger.writeDealerMove(
DealerMove(
self.dealer.getVisibleHand(
0).getHandValue(),
Move.NOTCOMPLETE))
counter += 1
if CasinoBJTable.DEBUG:
print "OUT"
moreHands = (old != len(pl.getHands()))
keepGoing = True
while keepGoing == True:
keepGoing = self.dealer.play(None, None)
if keepGoing == True:
newCard = self.deck.getTopCard()
self.dealer.getHands()[0].addCard(newCard)
self.updatePlayers(newCard)
if (CasinoBJTable.ROLLOUTS):
if (len(pl.getHands()) == 2):
if (self.dealer.getHands()[0].isBust()
and pl.getHands()[0].isBust()
and pl.getHands()[1].isBust()):
StaticBJLogger.writeDealerMove(
DealerMove(self.dealer.getHands()[0].getHandValue(),
Move.NOTCOMPLETE))
elif (self.dealer.getHands()[0].isBust()
and not pl.getHands()[0].isBust()
and not pl.getHands()[1].isBust()):
StaticBJLogger.writeDealerMove(
DealerMove(self.dealer.getHands()[0].getHandValue(),
Move.WON_BOTH))
elif (self.dealer.getHands()[0].isBust()
and pl.getHands()[0].isBust()
and not pl.getHands()[1].isBust()):
StaticBJLogger.writeDealerMove(
DealerMove(self.dealer.getHands()[0].getHandValue(),
Move.WON_HAND_2))
elif (self.dealer.getHands()[0].isBust()
and not pl.getHands()[0].isBust()
and pl.getHands()[1].isBust()):
StaticBJLogger.writeDealerMove(
DealerMove(self.dealer.getHands()[0].getHandValue(),
Move.WON_HAND_1))
elif (
not self.dealer.getHands()[0].isBust() and
(pl.getHands()[0].isBust() and pl.getHands()[1].isBust())):
StaticBJLogger.writeDealerMove(
DealerMove(self.dealer.getHands()[0].getHandValue(),
Move.LOST))
elif (not self.dealer.getHands()[0].isBust()
and not pl.getHands()[0].isBust()
and pl.getHands()[1].isBust()):
if (self.dealer.getHands()[0].getHandValue() >=
pl.getHands()[0].getHandValue()):
StaticBJLogger.writeDealerMove(
DealerMove(
self.dealer.getHands()[0].getHandValue(),
Move.LOST))
else:
StaticBJLogger.writeDealerMove(
DealerMove(
self.dealer.getHands()[0].getHandValue(),
Move.WON_HAND_1))
elif (not self.dealer.getHands()[0].isBust()
and pl.getHands()[0].isBust()
and not pl.getHands()[1].isBust()):
if (self.dealer.getHands()[0].getHandValue() >=
pl.getHands()[1].getHandValue()):
StaticBJLogger.writeDealerMove(
DealerMove(
self.dealer.getHands()[0].getHandValue(),
Move.LOST))
else:
StaticBJLogger.writeDealerMove(
DealerMove(
self.dealer.getHands()[0].getHandValue(),
Move.WON_HAND_2))
elif (not self.dealer.getHands()[0].isBust()
and not pl.getHands()[0].isBust()
and not pl.getHands()[1].isBust()):
if (self.dealer.getHands()[0].getHandValue() >=
pl.getHands()[0].getHandValue()):
if (self.dealer.getHands()[0].getHandValue() >=
pl.getHands()[1].getHandValue()):
StaticBJLogger.writeDealerMove(
DealerMove(
self.dealer.getHands()[0].getHandValue(),
Move.LOST))
else:
StaticBJLogger.writeDealerMove(
DealerMove(
self.dealer.getHands()[0].getHandValue(),
Move.WON_HAND_2))
else:
if (self.dealer.getHands()[0].getHandValue() >=
pl.getHands()[1].getHandValue()):
StaticBJLogger.writeDealerMove(
DealerMove(
self.dealer.getHands()[0].getHandValue(),
Move.WON_HAND_1))
else:
StaticBJLogger.writeDealerMove(
DealerMove(
self.dealer.getHands()[0].getHandValue(),
Move.WON_BOTH))
else:
# House rules: tie on a bust for dealer and player
if (self.dealer.getHands()[0].isBust()
and pl.getHands()[0].isBust()):
StaticBJLogger.writeDealerMove(
DealerMove(self.dealer.getHands()[0].getHandValue(),
Move.NOTCOMPLETE))
elif (self.dealer.getHands()[0].isBust()
and not pl.getHands()[0].isBust()):
StaticBJLogger.writeDealerMove(
DealerMove(self.dealer.getHands()[0].getHandValue(),
Move.WON_HAND_1))
elif (not self.dealer.getHands()[0].isBust()
and pl.getHands()[0].isBust()):
StaticBJLogger.writeDealerMove(
DealerMove(self.dealer.getHands()[0].getHandValue(),
Move.LOST))
elif (not self.dealer.getHands()[0].isBust()
and not pl.getHands()[0].isBust()):
if (self.dealer.getHands()[0].getHandValue() >=
pl.getHands()[0].getHandValue()):
StaticBJLogger.writeDealerMove(
DealerMove(
self.dealer.getHands()[0].getHandValue(),
Move.LOST))
else:
StaticBJLogger.writeDealerMove(
DealerMove(
self.dealer.getHands()[0].getHandValue(),
Move.WON_HAND_1))
else:
for pl in self.playersList:
gm = GameMove()
for val in pl.getHandsVals():
if val > 21:
gm.incBust()
elif val > self.dealer.getHands()[0].getHandValue():
gm.incWon()
else:
gm.incLoss()
if isinstance(pl, BSPlayer):
if CasinoBJTable.DEBUG:
print "BS"
StaticBJGameLogger.writeBSMove(gm)
elif isinstance(pl, ROPlayer):
if CasinoBJTable.DEBUG:
print "RO"
StaticBJGameLogger.writeROMove(gm)
elif isinstance(pl, CCPlayer):
if CasinoBJTable.DEBUG:
print "CC"
StaticBJGameLogger.writeCCMove(gm)
elif isinstance(pl, Dealer):
if CasinoBJTable.DEBUG:
print "Dealer"
StaticBJGameLogger.writeDealerMove(gm)
else:
if CasinoBJTable.DEBUG:
"wah wah"
def initPlayers(self):
for i in range(0, 2):
for pl in self.playersList:
newCard = self.deck.getTopCard()
pl.getHands()[0].addCard(newCard)
self.updatePlayers(newCard)
if (i == 1): # Hide the dealers other card
topCard = self.deck.getTopCard()
topCard.setIsVisible(False)
self.dealer.getHands()[0].addCard(topCard)
else:
newCard = self.deck.getTopCard()
self.dealer.getHands()[0].addCard(newCard)
self.updatePlayers(newCard)
def resetPlayers(self):
for pl in self.playersList:
pl.setHand([Hand([])])
pl.hasDouble = False
pl.hasSplit = False
self.dealer.setHand([Hand([])])
def __repr__(self):
strPlayers = ""
for i in range(0, self.numPlayers):
strPlayers += str(self.playersList[i])
strPlayers += "\n"
return (strPlayers)
# plays blackjack till a specific time
# day, hour, minute is the ending time for the function
def play(self, day, hour, minute):
endTime = DateTimeCustom(day, hour, minute)
self.resetPlayers()
while not endTime.greaterEqualTo():
if self.deck.yellowCardPassed():
del self.deck
self.deck = Shoe(self.numDecks)
self.initPlayers()
self.playRound()
self.resetPlayers()
