def startup(self, game):
self.game = game
sr = self.screen_rect
title = Label(self.font,
128,
"Two-Card Guts",
"gold3", {"midtop": (sr.centerx, 5)},
bg=prepare.FELT_GREEN)
title.image.set_alpha(160)
title2 = Label(self.font,
96,
"${} Ante".format(self.game.bet),
"darkred", {"midtop": (sr.centerx, title.rect.bottom)},
bg=prepare.FELT_GREEN)
title2.image.set_alpha(140)
self.titles = [title, title2]
self.player_buttons = ButtonGroup()
w, h = NeonButton.width, NeonButton.height
pos = sr.centerx - (w // 2), sr.centery - (h // 2)
NeonButton(pos, "Ante Up", self.start_game, None, self.player_buttons)
pos2 = sr.centerx - (w // 2), sr.centery + (h // 2) + 50
self.tutorial_button = NeonButton(pos2, "Tutorial", self.to_tutorial,
None, self.player_buttons)
self.advisor.queue_text("Ante Up ${} to play".format(self.game.bet),
dismiss_after=2500)
self.advisor.queue_text("Press Tutorial to learn how to play",
dismiss_after=2500)
self.advisor.queue_text("Press the Lobby button to exit",
dismiss_after=2500)
def startup(self, game):
self.game = game
self.current_player = self.game.deal_queue[
self.game.current_player_index]
self.player_buttons = ButtonGroup()
self.animations = pg.sprite.Group()
self.timer = 0
self.time_limit = 600
if self.current_player is self.game.dealer:
self.next = "Show Cards"
else:
self.next = "Player Turn"
if self.current_player is self.game.player:
x, y = self.screen_rect.centerx - 120, 695
NeonButton((x, y - 55), "Stay", self.stay, None,
self.player_buttons)
NeonButton((x, y + 55), "Pass", self.stay_out, None,
self.player_buttons)
if self.current_player is self.game.dealer:
stays = [x for x in self.game.players if x.stayed]
if not stays:
self.stay()
else:
self.current_player.play_hand(self.game)
def make_buttons(self, screen_rect):
buttons = ButtonGroup()
y = screen_rect.bottom - NeonButton.height - 10
lobby = NeonButton((20, y), "Lobby", self.back_to_lobby, None, buttons)
NeonButton((lobby.rect.right + 20, y), "Roll", self.roll, None,
buttons)
return buttons
def __init__(self):
super(DealerTurn, self).__init__()
pos = (self.screen_rect.right - (NeonButton.width + 10),
self.screen_rect.bottom - (NeonButton.height + 15))
self.lobby_button = NeonButton(pos,
"Lobby",
self.back_to_lobby,
bindings=[pg.K_ESCAPE])
def __init__(self):
super(VideoPoker, self).__init__()
w, h = prepare.RENDER_SIZE
self.screen_rect = pg.Rect((0, 0), (w, h))
self.machine = Machine((0, 0), (w - 300, h))
pos = (self.screen_rect.right - 330, self.screen_rect.bottom - 120)
self.lobby_button = NeonButton(pos, "lobby", self.back_to_lobby)
self.casino_player = None
def make_buttons(self):
self.buttons = ButtonGroup()
side_margin = 10
vert_space = 15
left = self.screen_rect.right - (NeonButton.width + side_margin)
top = self.screen_rect.bottom - (
(NeonButton.height * 5) + vert_space * 4)
self.deal_button = NeonButton((left, top), "Deal", self.deal, None,
self.buttons)
def __init__(self):
super(ShowResults, self).__init__()
pos = (self.screen_rect.right - (NeonButton.width + 10),
self.screen_rect.bottom - (NeonButton.height + 15))
self.lobby_button = NeonButton(pos,
"Lobby",
self.back_to_lobby,
bindings=[pg.K_ESCAPE])
self.coin_sound = prepare.SFX["coins"]
def make_buttons(self):
self.buttons = ButtonGroup()
self.new_game_button = NeonButton(
(0, 0), "Change", self.new_game_click, None, self.buttons)
self.quick_bet_button = NeonButton(
(0, 0), "Again", self.quick_bet_click, None, self.buttons)
self.quick_bet_button.rect.midbottom = (self.screen_rect.centerx,
self.screen_rect.centery - 30)
self.new_game_button.rect.center = (self.screen_rect.centerx,
self.screen_rect.centery + 30)
def __init__(self):
super(Betting, self).__init__()
self.make_buttons()
pos = (self.screen_rect.right - (NeonButton.width + 10),
self.screen_rect.bottom - (NeonButton.height + 15))
self.lobby_button = NeonButton(pos,
"Lobby",
self.back_to_lobby,
None,
self.buttons,
bindings=[pg.K_ESCAPE])
def __init__(self):
"""Initialise the bingo game"""
#
self.verbose = False
self.sound_muted = prepare.ARGS['debug']
#
self.screen_rect = pg.Rect((0, 0), prepare.RENDER_SIZE)
self.auto_pick = S['debug-auto-pick']
#
self.ui = common.ClickableGroup()
#
self.lobby_button = NeonButton(S['lobby-position'], 'Lobby',
self.return_to_lobby)
self.new_game_button = NeonButton(
S['new-game-position'], 'New',
lambda x: self.restart_game(None, None))
#
# The controls to allow selection of different numbers of cards
self.card_selector = cardselector.CardSelector('card-selector', self)
self.card_selector.linkEvent(events.E_NUM_CARDS_CHANGED,
self.change_number_of_cards)
self.ui.append(self.card_selector.ui)
#
self.create_card_collection()
self.ui.extend(self.cards)
#
self.winning_pattern = patterns.PATTERNS[0]
#
self.pattern_buttons = common.DrawableGroup()
self.debug_buttons = common.DrawableGroup()
self.buttons = common.DrawableGroup([self.pattern_buttons])
#
if prepare.DEBUG:
self.buttons.append(self.debug_buttons)
#
super(Bingo, self).__init__()
#
# The machine for picking balls
self.ball_machine = ballmachine.BallMachine('ball-machine', self)
self.ball_machine.start_machine()
self.ui.append(self.ball_machine.buttons)
#
self.all_cards = common.DrawableGroup()
self.all_cards.extend(self.cards)
self.all_cards.extend(self.dealer_cards)
#
B.linkEvent(events.E_PLAYER_PICKED, self.player_picked)
B.linkEvent(events.E_PLAYER_UNPICKED, self.player_unpicked)
B.linkEvent(events.E_CARD_COMPLETE, self.card_completed)
#
self.current_pick_sound = 0
self.last_pick_time = 0
def make_buttons(self, screen_rect):
buttons = ButtonGroup()
x, y = (screen_rect.centerx - (NeonButton.width // 2) - 170,
screen_rect.bottom - (NeonButton.height + 10))
NeonButton((x, y), "Lobby", self.back_to_x, "lobby", buttons)
x = screen_rect.centerx - (NeonButton.width // 2) + 170
NeonButton((x, y),
"Back",
self.back_to_x,
"stats_menu",
buttons,
bindings=[pg.K_ESCAPE])
return buttons
def make_main_buttons(self, screen_rect):
buttons = ButtonGroup()
pos = (9, screen_rect.bottom-(NeonButton.height+11))
NeonButton(pos, "Credits", 32, self.change_state, "credits", buttons)
pos = (screen_rect.right-(NeonButton.width+10),
screen_rect.bottom-(NeonButton.height+11))
NeonButton(pos, "High Scores", 28, self.change_state, "high_scores",
buttons)
pos = (screen_rect.centerx-(NeonButton.width//2),
screen_rect.bottom-(NeonButton.height+11))
NeonButton(pos, "Exit", 32, self.exit_game, None,
buttons, bindings=[pg.K_ESCAPE])
rect_style = (screen_rect.left, screen_rect.top, 150, 95)
return buttons
def __init__(self):
"""Initialise the bingo game"""
#
self.verbose = False
self.sound_muted = prepare.ARGS['debug']
#
self.screen_rect = pg.Rect((0, 0), prepare.RENDER_SIZE)
self.auto_pick = S['debug-auto-pick']
#
self.ui = common.ClickableGroup()
#
self.lobby_button = NeonButton(S['lobby-position'], 'Lobby', self.return_to_lobby)
self.new_game_button = NeonButton(S['new-game-position'], 'New', lambda x: self.restart_game(None, None))
#
# The controls to allow selection of different numbers of cards
self.card_selector = cardselector.CardSelector('card-selector', self)
self.card_selector.linkEvent(events.E_NUM_CARDS_CHANGED, self.change_number_of_cards)
self.ui.append(self.card_selector.ui)
#
self.create_card_collection()
self.ui.extend(self.cards)
#
self.winning_pattern = patterns.PATTERNS[0]
#
self.pattern_buttons = common.DrawableGroup()
self.debug_buttons = common.DrawableGroup()
self.buttons = common.DrawableGroup([self.pattern_buttons])
#
if prepare.DEBUG:
self.buttons.append(self.debug_buttons)
#
super(Bingo, self).__init__()
#
# The machine for picking balls
self.ball_machine = ballmachine.BallMachine('ball-machine', self)
self.ball_machine.start_machine()
self.ui.append(self.ball_machine.buttons)
#
self.all_cards = common.DrawableGroup()
self.all_cards.extend(self.cards)
self.all_cards.extend(self.dealer_cards)
#
B.linkEvent(events.E_PLAYER_PICKED, self.player_picked)
B.linkEvent(events.E_PLAYER_UNPICKED, self.player_unpicked)
B.linkEvent(events.E_CARD_COMPLETE, self.card_completed)
#
self.current_pick_sound = 0
self.last_pick_time = 0
def make_buttons(self):
side_margin = 10
vert_space = 12
left = self.screen_rect.right - (NeonButton.width + side_margin)
top = self.screen_rect.bottom - (
(NeonButton.height * 5) + vert_space * 5)
self.hit_button = NeonButton((left, top), "Hit", self.hit_click)
top += NeonButton.height + vert_space
self.stand_button = NeonButton((left, top), "Stand", self.stand)
top += NeonButton.height + vert_space
self.double_down_button = NeonButton((left, top), "Double",
self.double_down)
top += NeonButton.height + vert_space
self.split_button = NeonButton((left, top), "Split", self.split_hand)
self.buttons = ButtonGroup(self.hit_button, self.stand_button,
self.double_down_button, self.split_button)
def __init__(self):
super(PlayerTurn, self).__init__()
pos = (self.screen_rect.right-(NeonButton.width+10),
self.screen_rect.bottom-(NeonButton.height+15))
self.make_buttons()
self.lobby_button = NeonButton(pos, "Lobby", self.back_to_lobby, None, self.buttons, bindings=[pg.K_ESCAPE])
self.last_click = 0
def make_buttons(self):
self.buttons = ButtonGroup()
side_margin = 10
vert_space = 15
left = self.screen_rect.right-(NeonButton.width + side_margin)
top = self.screen_rect.bottom-((NeonButton.height*5)+vert_space*4)
self.deal_button = NeonButton((left, top), "Deal", self.deal, None, self.buttons)
def make_player_buttons(self, free_ride):
self.player_buttons = ButtonGroup()
w, h = NeonButton.width, NeonButton.height
sr = self.screen_rect
pos = sr.centerx - (w // 2), sr.centery + 120
text = "OK" if free_ride else "Ante Up"
NeonButton(pos, text, self.new_game, None, self.player_buttons)
def __init__(self):
super(CreditsScreen, self).__init__()
self.screen = pg.Rect((0, 0), prepare.RENDER_SIZE)
self.next = "lobby"
self.font = prepare.FONTS["Saniretro"]
self.dev_names = DEVELOPERS
self.artist_names = ARTISTS
self.assets_names = ASSETS_NAMES
self.software_names = SOFTWARE
self.zipper_blocks = []
self.zipper_block = None
self.chip_curtain = None
pos = (self.screen.centerx - (NeonButton.width // 2),
self.screen.bottom - NeonButton.height - 10)
self.done_button = NeonButton(pos, "Lobby", self.back_to_lobby)
self.use_music_handler = False
def make_buttons(self):
x = self.screen_rect.centerx - (NeonButton.width // 2)
y = 600
new_game = NeonButton((x, y),
"New",
self.load_or_new,
False,
self.buttons,
visible=False)
y = new_game.rect.bottom + 50
load_game = NeonButton((x, y),
"Load",
self.load_or_new,
True,
self.buttons,
visible=False)
return new_game, load_game
def __init__(self):
super(ShowResults, self).__init__()
self.buttons = ButtonGroup()
pos = (self.screen_rect.right - (NeonButton.width + 10),
self.screen_rect.bottom - (NeonButton.height + 10))
self.lobby_button = NeonButton(pos,
"Lobby",
self.warn,
None,
self.buttons,
bindings=[pg.K_ESCAPE])
def make_buttons(self, screen_rect):
buttons = ButtonGroup()
pos = (self.screen_rect.right - (NeonButton.width + 10),
self.screen_rect.bottom - (NeonButton.height + 15))
NeonButton(pos,
"Lobby",
self.back_to_lobby,
None,
buttons,
bindings=[pg.K_ESCAPE])
return buttons
def make_buttons(self, games, screen_rect, col=2):
spacer_x = 20
spacer_y = 20
start_y = 410
start_x = (screen_rect.w - NeonButton.width * col - spacer_x *
(col - 1)) // 2
buttons = ButtonGroup()
for i, game in enumerate(games):
y, x = divmod(i, col)
pos = (start_x + x * (NeonButton.width + spacer_x),
start_y + y * (NeonButton.height + spacer_y))
button = NeonButton(pos, game, self.view_game_stats, game, buttons)
pos = (screen_rect.centerx - (NeonButton.width // 2),
screen_rect.bottom - (NeonButton.height + 10))
NeonButton(pos,
"Lobby",
self.back_to_lobby,
None,
buttons,
bindings=[pg.K_ESCAPE])
return buttons
class VideoPoker(data.state.State):
"""Class to represent the Video Poker game."""
show_in_lobby = True
name = 'video_poker'
def __init__(self):
super(VideoPoker, self).__init__()
w, h = prepare.RENDER_SIZE
self.screen_rect = pg.Rect((0, 0), (w, h))
self.machine = Machine((0, 0), (w - 300, h))
pos = (self.screen_rect.right - 330, self.screen_rect.bottom - 120)
self.lobby_button = NeonButton(pos, "lobby", self.back_to_lobby)
self.casino_player = None
@staticmethod
def initialize_stats():
"""Return OrderedDict suitable for use in game stats
:return: collections.OrderedDict
"""
stats = OrderedDict([
("games played", 0),
("games won", 0),
("games lost", 0),
("double ups won", 0),
("double ups lost", 0),
("total wagered", 0),
("total won", 0),
("total lost", 0),
])
return stats
def back_to_lobby(self, *args):
self.machine.cash_out()
self.done = True
self.next = "lobby"
def startup(self, current_time, persistent):
self.persist = persistent
self.casino_player = self.persist["casino_player"]
self.casino_player.current_game = self.name
self.machine.startup(self.casino_player)
def get_event(self, event, scale=(1, 1)):
if event.type == pg.QUIT:
self.back_to_lobby(None)
self.lobby_button.get_event(event)
self.machine.get_event(event, scale)
def update(self, surface, keys, current_time, dt, scale):
mouse_pos = tools.scaled_mouse_pos(scale)
self.lobby_button.update(mouse_pos)
self.machine.update(mouse_pos, dt)
self.draw(surface, dt)
def draw(self, surface, dt):
surface.fill(prepare.FELT_GREEN)
self.machine.draw(surface)
self.lobby_button.draw(surface)
def make_main_buttons(self, screen_rect):
buttons = ButtonGroup()
pos = (9, screen_rect.bottom - (NeonButton.height + 11))
NeonButton(pos, "Credits", self.change_state, "credits", buttons)
pos = (screen_rect.right - (NeonButton.width + 10),
screen_rect.bottom - (NeonButton.height + 11))
NeonButton(pos, "Stats", self.change_state, "stats_menu", buttons)
pos = (screen_rect.centerx - (NeonButton.width // 2),
screen_rect.bottom - (NeonButton.height + 11))
NeonButton(pos,
"Exit",
self.exit_game,
None,
buttons,
bindings=[pg.K_ESCAPE])
rect_style = (screen_rect.left, screen_rect.top, 150, 95)
Button(rect_style,
buttons,
idle_image=prepare.GFX["atm_dim"],
hover_image=prepare.GFX["atm_bright"],
call=self.change_state,
args="atm")
return buttons
def __init__(self):
super(CreditsScreen, self).__init__()
self.screen = pg.Rect((0, 0), prepare.RENDER_SIZE)
self.next = "lobby"
self.font = prepare.FONTS["Saniretro"]
self.dev_names = DEVELOPERS
self.artist_names = ARTISTS
self.assets_names = ASSETS_NAMES
self.software_names = SOFTWARE
self.zipper_blocks =[]
self.zipper_block = None
self.chip_curtain = None
pos = (self.screen.centerx-(NeonButton.width//2),
self.screen.bottom-NeonButton.height-10)
self.done_button = NeonButton(pos, "Lobby", self.back_to_lobby)
self.use_music_handler = False
def __init__(self):
self.done = False
self.quit = False
self.next = None
rect = self.advisor_back.get_rect().union(
self.advisor_front.get_rect())
self.advisor_button = Button(rect, call=self.toggle_advisor)
self.buttons = ButtonGroup()
pos = (self.screen_rect.right - (NeonButton.width + 10),
self.screen_rect.bottom - (NeonButton.height + 10))
lobby_button = NeonButton(pos,
"Lobby",
self.back_to_lobby,
None,
self.buttons,
bindings=[pg.K_ESCAPE])
self.animations = pg.sprite.Group()
class CreditsScreen(data.state.State):
"""
This is the main state governing the credits screen.
"""
name = 'credits'
def __init__(self):
super(CreditsScreen, self).__init__()
self.screen = pg.Rect((0, 0), prepare.RENDER_SIZE)
self.next = "lobby"
self.font = prepare.FONTS["Saniretro"]
self.dev_names = DEVELOPERS
self.artist_names = ARTISTS
self.assets_names = ASSETS_NAMES
self.software_names = SOFTWARE
self.zipper_blocks =[]
self.zipper_block = None
self.chip_curtain = None
pos = (self.screen.centerx-(NeonButton.width//2),
self.screen.bottom-NeonButton.height-10)
self.done_button = NeonButton(pos, "Lobby", self.back_to_lobby)
self.use_music_handler = False
def back_to_lobby(self, *args):
self.done = True
pg.mixer.stop()
def make_groups(self, names, group_size=5):
return [names[i:i+group_size] for i in range(0, len(names), group_size)]
def make_titles_blocks(self, title_name_pairs):
titles = []
zipper_blocks = []
for pair in title_name_pairs:
title_text, names = pair
title = SlotReelTitle((self.screen.centerx, 20), title_text, initial_move=(0, -120))
grouped = self.make_groups(names)
for group in grouped:
block = ZipperBlock(self.font, group, (700, 230))
zipper_blocks.append(block)
titles.append(title)
return iter(titles), iter(zipper_blocks)
def startup(self, current_time, persistent):
"""
Prepare title, spinners, and zipper blocks. Names are randomized each
time so that no single dev is always first in the credits.
"""
self.persist = persistent
self.zipper_blocks = []
dev_names = self.dev_names[:]
artist_names = self.artist_names[:]
assets_names = self.assets_names[:]
software_names = self.software_names[:]
for names in (dev_names, artist_names, assets_names):
random.shuffle(names)
self.titles, self.zipper_blocks = self.make_titles_blocks(
[("Developers", dev_names),
("Artists", artist_names),
("Assets", assets_names),
("Software", software_names)])
self.title = next(self.titles)
self.zipper_block = next(self.zipper_blocks)
spots = [(self.title.rect.left-100, self.title.rect.centery),
(self.title.rect.right+100, self.title.rect.centery)]
self.spinners = pg.sprite.Group()
Spinner(spots[0], "black", self.spinners)
Spinner(spots[1], "black", self.spinners, reverse=True)
self.chip_curtain = None
self.title.startup()
def get_event(self, event, scale=(1, 1)):
"""
Set the state to done on Xing; pressing escape; or clicking the
lobby button.
"""
if event.type == pg.QUIT:
self.back_to_lobby()
elif event.type == pg.KEYUP and event.key == pg.K_ESCAPE:
self.back_to_lobby()
self.done_button.get_event(event)
def switch_blocks(self):
"""
Switch to the next zipper block and title. If all blocks have been
used, initialize the chip_curtain.
"""
try:
rect = self.title.rect
self.zipper_block = next(self.zipper_blocks)
self.title = next(self.titles)
if self.title.rect != rect:
rect = self.title.rect
spots = [(rect.x-100, rect.centery),
(rect.right+100, rect.centery)]
self.spinners.empty()
Spinner(spots[0], "blue", self.spinners)
Spinner(spots[1], "blue", self.spinners, reverse=True)
self.title.startup()
except StopIteration:
self.end_titles = []
self.zipper_block = None
self.title = None
self.spinners.empty()
self.back_to_lobby()
def update(self, surface, keys, current_time, dt, scale):
"""Update all elements and then draw the state."""
mouse_pos = tools.scaled_mouse_pos(scale)
self.done_button.update(mouse_pos)
if self.title:
if self.title.moving:
for spinner in self.spinners:
spinner.rect.move_ip(self.title.move_speed)
self.title.update()
if self.zipper_block and self.title.spun_out:
self.zipper_block.update(dt)
if self.zipper_block.done:
self.switch_blocks()
if self.chip_curtain:
self.chip_curtain.update(dt)
if self.chip_curtain.done:
self.done = True
self.spinners.update(dt)
self.draw(surface)
def draw(self, surface):
"""Render all currently active elements to the target surface."""
surface.fill(prepare.BACKGROUND_BASE)
if self.title:
self.title.draw(surface)
self.spinners.draw(surface)
if self.zipper_block:
self.zipper_block.draw(surface)
if self.chip_curtain:
self.chip_curtain.draw(surface)
self.done_button.draw(surface)
class EndRound(BlackjackState):
def __init__(self):
super(EndRound, self).__init__()
pos = (self.screen_rect.right - (NeonButton.width + 10),
self.screen_rect.bottom - (NeonButton.height + 15))
self.lobby_button = NeonButton(pos,
"Lobby",
self.back_to_lobby,
bindings=[pg.K_ESCAPE])
self.make_buttons()
def make_buttons(self):
self.buttons = ButtonGroup()
self.new_game_button = NeonButton(
(0, 0), "Change", self.new_game_click, None, self.buttons)
self.quick_bet_button = NeonButton(
(0, 0), "Again", self.quick_bet_click, None, self.buttons)
self.quick_bet_button.rect.midbottom = (self.screen_rect.centerx,
self.screen_rect.centery - 30)
self.new_game_button.rect.center = (self.screen_rect.centerx,
self.screen_rect.centery + 30)
def new_game_click(self, *args):
self.game.advisor.empty()
self.next = "Betting"
self.done = True
def quick_bet_click(self, *args):
self.game.quick_bet = self.game.last_bet
self.new_game_click()
def startup(self, game):
self.game = game
if game.advisor_active:
text = "The current bet amount is ${}".format(self.game.last_bet)
self.game.advisor.queue_text(text, dismiss_after=3000)
text2 = "Press Change Bet for a different amount"
self.game.advisor.queue_text(text2, dismiss_after=3000)
text3 = "Press the Lobby button to exit"
self.game.advisor.queue_text(text3, dismiss_after=3000)
def get_event(self, event, scale):
if event.type == pg.QUIT:
self.back_to_lobby()
self.game.get_event(event)
if self.window:
self.window.get_event(event)
else:
self.buttons.get_event(event)
self.lobby_button.get_event(event)
def update(self, surface, keys, current_time, dt, scale):
mouse_pos = tools.scaled_mouse_pos(pg.mouse.get_pos(), scale)
self.game.update(dt, mouse_pos)
for label in self.game.result_labels:
label.update(dt)
if self.window:
self.window.update(mouse_pos)
if self.window.done:
self.window = None
else:
self.buttons.update(mouse_pos)
self.lobby_button.update(mouse_pos)
def draw(self, surface):
g = self.game
surface.fill(prepare.FELT_GREEN)
for label in g.labels:
label.draw(surface)
g.player.draw_hand_bets(surface)
g.player.chip_pile.draw(surface)
g.chip_total_label.draw(surface)
g.dealer.draw_hand(surface)
g.deck.draw(surface)
g.chip_rack.draw(surface)
self.lobby_button.draw(surface)
g.player.draw_hands(surface)
for blinker in self.game.result_labels:
blinker.draw(surface)
self.buttons.draw(surface)
self.draw_advisor(surface)
self.game.player.chip_pile.draw(surface)
self.window and self.window.draw(surface)
class EndRound(BlackjackState):
def __init__(self):
super(EndRound, self).__init__()
pos = (self.screen_rect.right-(NeonButton.width+10),
self.screen_rect.bottom-(NeonButton.height+15))
self.lobby_button = NeonButton(pos, "Lobby", self.back_to_lobby, bindings=[pg.K_ESCAPE])
self.make_buttons()
def make_buttons(self):
self.buttons = ButtonGroup()
self.new_game_button = NeonButton((0,0), "Change", self.new_game_click,
None, self.buttons)
self.quick_bet_button = NeonButton((0, 0), "Again", self.quick_bet_click,
None, self.buttons)
self.quick_bet_button.rect.midbottom = (self.screen_rect.centerx,
self.screen_rect.centery-30)
self.new_game_button.rect.center = (self.screen_rect.centerx,
self.screen_rect.centery+30)
def new_game_click(self, *args):
self.game.advisor.empty()
self.next = "Betting"
self.done = True
def quick_bet_click(self, *args):
self.game.quick_bet = self.game.last_bet
self.new_game_click()
def startup(self, game):
self.game = game
if game.advisor_active:
text = "The current bet amount is ${}".format(self.game.last_bet)
self.game.advisor.queue_text(text, dismiss_after=3000)
text2 = "Press Change Bet for a different amount"
self.game.advisor.queue_text(text2, dismiss_after=3000)
text3 = "Press the Lobby button to exit"
self.game.advisor.queue_text(text3, dismiss_after=3000)
def get_event(self, event, scale):
if event.type == pg.QUIT:
self.back_to_lobby()
self.game.get_event(event)
if self.window:
self.window.get_event(event)
else:
self.buttons.get_event(event)
self.lobby_button.get_event(event)
def update(self, surface, keys, current_time, dt, scale):
mouse_pos = tools.scaled_mouse_pos(pg.mouse.get_pos(), scale)
self.game.update(dt, mouse_pos)
for label in self.game.result_labels:
label.update(dt)
if self.window:
self.window.update(mouse_pos)
if self.window.done:
self.window = None
else:
self.buttons.update(mouse_pos)
self.lobby_button.update(mouse_pos)
def draw(self, surface):
g = self.game
surface.fill(prepare.FELT_GREEN)
for label in g.labels:
label.draw(surface)
g.player.draw_hand_bets(surface)
g.player.chip_pile.draw(surface)
g.chip_total_label.draw(surface)
g.dealer.draw_hand(surface)
g.deck.draw(surface)
g.chip_rack.draw(surface)
self.lobby_button.draw(surface)
g.player.draw_hands(surface)
for blinker in self.game.result_labels:
blinker.draw(surface)
self.buttons.draw(surface)
self.draw_advisor(surface)
self.game.player.chip_pile.draw(surface)
self.window and self.window.draw(surface)
class Betting(BlackjackState):
def __init__(self):
super(Betting, self).__init__()
self.make_buttons()
pos = (self.screen_rect.right - (NeonButton.width + 10),
self.screen_rect.bottom - (NeonButton.height + 15))
self.lobby_button = NeonButton(pos,
"Lobby",
self.back_to_lobby,
None,
self.buttons,
bindings=[pg.K_ESCAPE])
def back_to_lobby(self, *args):
player = self.game.player
for hand in player.hands:
player.chip_pile.add_chips(cash_to_chips(
hand.bet.get_chip_total()))
self.leave_state()
def startup(self, game):
self.game = game
if self.game.quick_bet and (
self.game.quick_bet <=
self.game.player.chip_pile.get_chip_total()):
chips = self.game.player.chip_pile.withdraw_chips(
self.game.quick_bet)
self.game.current_player_hand.bet.add_chips(chips)
self.deal()
elif self.game.advisor_active:
self.game.advisor.queue_text(
"Click chips in your chip pile to place bet",
dismiss_after=3000)
self.game.advisor.queue_text(
"Click chips in pot to remove from bet", dismiss_after=3000)
def make_buttons(self):
self.buttons = ButtonGroup()
side_margin = 10
vert_space = 15
left = self.screen_rect.right - (NeonButton.width + side_margin)
top = self.screen_rect.bottom - (
(NeonButton.height * 5) + vert_space * 4)
self.deal_button = NeonButton((left, top), "Deal", self.deal, None,
self.buttons)
def deal(self, *args):
bets = [x.bet.get_chip_total() for x in self.game.player.hands]
self.game.last_bet = max(bets)
self.game.quick_bet = 0
self.next = "Dealing"
self.game.casino_player.increase("games played")
self.game.advisor.empty()
self.done = True
def get_event(self, event, scale):
self.game.get_event(event)
if event.type == pg.QUIT:
self.back_to_lobby()
elif event.type == pg.MOUSEBUTTONDOWN:
pos = tools.scaled_mouse_pos(scale, event.pos)
if not self.game.moving_stacks and event.button == 1:
new_movers = self.game.player.chip_pile.grab_chips(pos)
self.last_click = pg.time.get_ticks()
if new_movers:
self.play_chip_sound()
self.game.moving_stacks.append(new_movers)
for hand in self.game.player.hands:
unbet_stack = hand.bet.grab_chips(pos)
if unbet_stack:
self.play_chip_sound()
self.game.player.chip_pile.add_chips(unbet_stack.chips)
elif event.type == pg.MOUSEBUTTONUP:
now = pg.time.get_ticks()
span = now - self.last_click
pos = tools.scaled_mouse_pos(scale, event.pos)
if self.game.moving_stacks and event.button == 1:
for stack in self.game.moving_stacks:
stack.rect.bottomleft = pos
if self.game.chip_rack.rect.collidepoint(pos):
self.play_chip_sound()
self.game.player.chip_pile.add_chips(
self.game.chip_rack.break_chips(stack.chips))
elif span > 300 and self.game.player.chip_pile.rect.collidepoint(
pos):
self.play_chip_sound()
self.game.player.chip_pile.add_chips(stack.chips)
else:
self.play_chip_sound()
self.game.current_player_hand.bet.add_chips(
stack.chips)
self.game.moving_stacks = []
if self.window:
self.window.get_event(event)
else:
self.lobby_button.get_event(event)
self.deal_button.get_event(event)
def update(self, surface, keys, current_time, dt, scale):
mouse_pos = tools.scaled_mouse_pos(pg.mouse.get_pos(), scale)
self.game.update(dt, mouse_pos)
bets = [x.bet.get_chip_total() for x in self.game.player.hands]
self.deal_button.visible = any(bets) and not self.game.moving_stacks
if self.window:
self.window.update(mouse_pos)
if self.window.done:
self.window = None
else:
self.lobby_button.update(mouse_pos)
self.deal_button.update(mouse_pos)
for stack in self.game.moving_stacks:
x, y = mouse_pos
stack.rect.bottomleft = (x - (self.game.chip_size[0] // 2), y + 6)
def draw(self, surface):
g = self.game
surface.fill(prepare.FELT_GREEN)
for label in g.labels:
label.draw(surface)
g.player.draw_hands(surface)
g.player.draw_hand_bets(surface)
g.player.chip_pile.draw(surface)
g.chip_total_label.draw(surface)
g.dealer.draw_hand(surface)
g.deck.draw(surface)
g.chip_rack.draw(surface)
for stack in g.moving_stacks:
stack.draw(surface)
self.buttons.draw(surface)
self.draw_advisor(surface)
self.window and self.window.draw(surface)
class PlayerTurn(BlackjackState):
def __init__(self):
super(PlayerTurn, self).__init__()
pos = (self.screen_rect.right-(NeonButton.width+10),
self.screen_rect.bottom-(NeonButton.height+15))
self.make_buttons()
self.lobby_button = NeonButton(pos, "Lobby", self.back_to_lobby, None, self.buttons, bindings=[pg.K_ESCAPE])
self.last_click = 0
def play_deal_sound(self):
choice(self.game.deal_sounds).play()
def make_buttons(self):
side_margin = 10
vert_space = 12
left = self.screen_rect.right-(NeonButton.width + side_margin)
top = self.screen_rect.bottom-((NeonButton.height*5)+vert_space*5)
self.hit_button = NeonButton((left,top), "Hit", self.hit_click)
top += NeonButton.height + vert_space
self.stand_button = NeonButton((left, top), "Stand", self.stand)
top += NeonButton.height + vert_space
self.double_down_button = NeonButton((left,top), "Double",
self.double_down)
top += NeonButton.height + vert_space
self.split_button = NeonButton((left, top), "Split", self.split_hand)
self.buttons = ButtonGroup(self.hit_button, self.stand_button,
self.double_down_button,
self.split_button)
def hit_click(self, *args):
self.hit(self.game.current_player_hand)
def hit(self, hand):
"""Draw a card from deck and add to hand."""
self.play_deal_sound()
self.game.player.add_slot(hand)
card = self.game.deck.draw_card()
card.face_up = True
destination = hand.slots[-1]
dest_x, dest_y = destination.topleft
hand.cards.append(card)
dur = get_distance(destination.center, card.pos) * 20 // card.speed
ani = Animation(x=dest_x, y=dest_y, duration=dur, round_values=True)
ani.start(card.rect)
self.animations.add(ani)
def stand(self, *args):
"""Player is done with this hand."""
self.game.current_player_hand.final = True
def double_down(self, *args):
"""
Double player's bet on the hand, deal one
more card and finalize hand.
"""
hand = self.game.current_player_hand
bet = hand.bet.get_chip_total()
bet_chips = self.game.player.chip_pile.withdraw_chips(bet)
hand.bet.add_chips(bet_chips)
self.hit(hand)
hand.final = True
def split_hand(self, *args):
"""
Split player's hand into two hands, adjust hand locations
and deal a new card to both hands.
"""
player = self.game.player
hand = self.game.current_player_hand
bet = hand.bet.get_chip_total()
hand.slots = hand.slots[:-1]
move = ((self.screen_rect.left+50)-hand.slots[0].left, 0)
player.move_hands(move)
p_slot = player.hands[-1].slots[0]
hand_slot = p_slot.move(int(prepare.CARD_SIZE[0] * 3.5), 0)
card = hand.cards.pop()
new_hand = Hand(hand_slot.topleft, [card],
player.chip_pile.withdraw_chips(bet))
new_hand.slots = [hand_slot]
card.rect.topleft = hand_slot.topleft
player.hands.append(new_hand)
player.add_slot(new_hand)
self.play_deal_sound()
self.game.player.add_slot(hand)
card1 = self.game.deck.draw_card()
dest = hand.slots[-1]
dest_x, dest_y = dest.topleft
card1.face_up = True
hand.cards.append(card1)
ani = Animation(x=dest_x, y=dest_y, duration=1000, round_values=True)
ani.start(card1.rect)
card2 = self.game.deck.draw_card()
dest = new_hand.slots[-1]
dest_x, dest_y = dest.topleft
card2.face_up = True
new_hand.cards.append(card2)
ani2 = Animation(x=dest_x, y=dest_y, duration=1000, delay=500, round_values=True)
ani2.start(card2.rect)
ani3 = Task(self.play_deal_sound, 1500)
self.animations.add(ani, ani2, ani3)
def startup(self, game):
self.game = game
self.animations = pg.sprite.Group()
def get_event(self, event, scale):
now = pg.time.get_ticks()
span = now - self.last_click
if event.type == pg.QUIT:
self.back_to_lobby()
if event.type == pg.MOUSEBUTTONUP:
self.last_click = now
self.game.get_event(event)
if span > 300:
if self.window:
self.window.get_event(event)
else:
self.buttons.get_event(event)
def update(self, surface, keys, current_time, dt, scale):
mouse_pos = tools.scaled_mouse_pos(pg.mouse.get_pos(), scale)
g = self.game
g.update(dt, mouse_pos)
self.split_button.active = False
self.split_button.visible = False
self.double_down_button.active = False
self.double_down_button.visible = False
hand = g.current_player_hand
hand_score = hand.best_score()
if hand_score is None:
hand.busted = True
hand.final = True
chip_total = g.player.chip_pile.get_chip_total()
bet = hand.bet.get_chip_total()
if len(hand.cards) == 2 and len(g.player.hands) < 2:
c1 = hand.card_values[hand.cards[0].value]
c2 = hand.card_values[hand.cards[1].value]
if c1 == c2 and chip_total >= bet:
self.split_button.active = True
self.split_button.visible = True
if len(hand.cards) == 2:
if hand_score == 21:
hand.blackjack = True
hand.final = True
elif chip_total >= bet:
self.double_down_button.active = True
self.double_down_button.visible = True
if hand.final:
if all([hand.final for hand in g.player.hands]):
if not self.animations:
g.dealer.hand.cards[0].face_up = True
self.next = "Dealer Turn"
self.done = True
else:
next_hand = [x for x in g.player.hands if not x.final][0]
g.current_player_hand = next_hand
if self.window:
self.window.update(mouse_pos)
if self.window.done:
self.window = None
else:
self.buttons.update(mouse_pos)
self.animations.update(dt)
def draw_hand_frame(self, surface):
hand = self.game.current_player_hand
rects = [x for x in hand.slots]
pg.draw.rect(surface, pg.Color("gold3"),
hand.slots[0].unionall(rects).inflate(8, 8), 3)
def draw(self, surface):
g = self.game
surface.fill(prepare.FELT_GREEN)
for label in g.labels:
label.draw(surface)
g.player.draw_hand_bets(surface)
g.player.chip_pile.draw(surface)
g.chip_total_label.draw(surface)
g.dealer.draw_hand(surface)
g.deck.draw(surface)
g.chip_rack.draw(surface)
self.buttons.draw(surface)
self.lobby_button.draw(surface)
g.player.draw_hands(surface)
self.draw_advisor(surface)
self.draw_hand_frame(surface)
self.game.player.chip_pile.draw(surface)
self.window and self.window.draw(surface)
class Bingo(statemachine.StateMachine):
"""State to represent a bing game"""
name = "bingo"
show_in_lobby = True
def __init__(self):
"""Initialise the bingo game"""
#
self.verbose = False
self.sound_muted = prepare.ARGS['debug']
#
self.screen_rect = pg.Rect((0, 0), prepare.RENDER_SIZE)
self.auto_pick = S['debug-auto-pick']
#
self.ui = common.ClickableGroup()
#
self.lobby_button = NeonButton(S['lobby-position'], 'Lobby',
self.return_to_lobby)
self.new_game_button = NeonButton(
S['new-game-position'], 'New',
lambda x: self.restart_game(None, None))
#
# The controls to allow selection of different numbers of cards
self.card_selector = cardselector.CardSelector('card-selector', self)
self.card_selector.linkEvent(events.E_NUM_CARDS_CHANGED,
self.change_number_of_cards)
self.ui.append(self.card_selector.ui)
#
self.create_card_collection()
self.ui.extend(self.cards)
#
self.winning_pattern = patterns.PATTERNS[0]
#
self.pattern_buttons = common.DrawableGroup()
self.debug_buttons = common.DrawableGroup()
self.buttons = common.DrawableGroup([self.pattern_buttons])
#
if prepare.DEBUG:
self.buttons.append(self.debug_buttons)
#
super(Bingo, self).__init__()
#
# The machine for picking balls
self.ball_machine = ballmachine.BallMachine('ball-machine', self)
self.ball_machine.start_machine()
self.ui.append(self.ball_machine.buttons)
#
self.all_cards = common.DrawableGroup()
self.all_cards.extend(self.cards)
self.all_cards.extend(self.dealer_cards)
#
B.linkEvent(events.E_PLAYER_PICKED, self.player_picked)
B.linkEvent(events.E_PLAYER_UNPICKED, self.player_unpicked)
B.linkEvent(events.E_CARD_COMPLETE, self.card_completed)
#
self.current_pick_sound = 0
self.last_pick_time = 0
@staticmethod
def initialize_stats():
"""Return OrderedDict suitable for use in game stats
:return: collections.OrderedDict
"""
stats = OrderedDict([("games played", 0), ("cards won", 0),
("cards lost", 0), ("total lost", 0),
("total won", 0), ("time played", '00:00:00'),
("_last squares", [])])
return stats
def startup(self, current_time, persistent):
"""This method will be called each time the state resumes."""
self.persist = persistent
self.casino_player = self.persist["casino_player"]
self.casino_player.current_game = self.name
#
self.casino_player.increase('games played')
self.cards.set_card_numbers(self.casino_player.get(
'_last squares', []))
self.money_display.set_money(self.casino_player.cash)
self.time_started = time.time()
def get_event(self, event, scale=(1, 1)):
"""Check for events"""
super(Bingo, self).get_event(event, scale)
self.lobby_button.get_event(event)
self.new_game_button.get_event(event)
#
if event.type == pg.QUIT:
if prepare.ARGS['straight']:
pg.quit()
sys.exit()
else:
self.done = True
self.next = "lobby"
elif event.type in (pg.MOUSEBUTTONDOWN, pg.MOUSEMOTION):
#
self.ui.process_events(event, scale)
self.bonus_buttons.process_events(event, scale)
#
pos = tools.scaled_mouse_pos(scale, event.pos)
elif event.type == pg.KEYUP:
if event.key == pg.K_ESCAPE:
self.done = True
self.next = "lobby"
elif event.key == pg.K_SPACE:
self.next_chip(None, None)
elif event.key == pg.K_m:
#self.persist["music_handler"].mute_unmute_music()
self.sound_muted = not self.sound_muted
elif event.key == pg.K_f:
for card in self.cards:
self.add_generator('flash-labels', card.flash_labels())
def return_to_lobby(self, arg):
"""Return to the lobby screen"""
self.game_started = False
self.done = True
self.next = "lobby"
self.casino_player.set('_last squares', self.cards.get_card_numbers())
self.casino_player.cash = self.money_display.amount
self.casino_player.increase_time('time played',
time.time() - self.time_started)
def drawUI(self, surface, scale):
"""Update the main surface once per frame"""
mouse_pos = tools.scaled_mouse_pos(scale, pg.mouse.get_pos())
self.lobby_button.update(mouse_pos)
self.new_game_button.update(mouse_pos)
#
surface.fill(S['table-color'])
#
self.lobby_button.draw(surface)
self.new_game_button.draw(surface)
self.all_cards.draw(surface)
self.ball_machine.draw(surface)
self.buttons.draw(surface)
self.card_selector.draw(surface)
self.money_display.draw(surface)
self.bonus_display.draw(surface)
self.bonus_buttons.draw(surface)
def initUI(self):
"""Initialise the UI display"""
#
# Buttons that show the winning patterns
x, y = S['winning-pattern-position']
for idx, pattern in enumerate(patterns.PATTERNS):
dx, dy = S['winning-pattern-buttons'][pattern.name]
new_button = patterns.PatternButton(
idx, (x + dx, y + dy),
'bingo-wide-red-button',
'bingo-wide-red-button-off',
'winning-pattern',
pattern.name,
pattern == self.winning_pattern,
S,
scale=S['winning-pattern-scale'])
new_button.linkEvent(common.E_MOUSE_CLICK, self.change_pattern,
pattern)
new_button.pattern = pattern
self.pattern_buttons.append(new_button)
self.ui.extend(self.pattern_buttons)
#
# Simple generator to flash the potentially winning squares
self.add_generator('potential-winners', self.flash_potential_winners())
#
# Display of the money the player has
self.money_display = moneydisplay.MoneyDisplay('money-display',
S['money-position'], 0,
self)
prepare.BROADCASTER.linkEvent(events.E_SPEND_MONEY, self.spend_money)
#
# Button for next chip
self.next_chip_button = common.ImageOnOffButton(
'next-chip',
S['next-chip-position'],
'bingo-next-chip-on',
'bingo-next-chip-off',
'next-chip',
'Next Chip (SPC)',
True,
S,
scale=S['next-chip-scale'])
self.next_chip_button.linkEvent(common.E_MOUSE_CLICK, self.next_chip)
self.ui.append(self.next_chip_button)
self.buttons.append(self.next_chip_button)
#
# Menu bar
self.menu_bar = common.NamedSprite('bingo-menu-bar',
S['menu-bar-position'],
scale=S['menu-bar-scale'])
self.buttons.append(self.menu_bar)
#
self.bonus_display = bonusdisplay.BonusDisplay(
'bonus-display', S['bonus-light-position'], self)
#
self.bonus_buttons = bonusbuttons.BonusButtonsDisplay(
'bonus-buttons', S['bonus-buttons-position'], self)
self.bonus_display.linkEvent(
events.E_BONUS_REACHED,
lambda o, a: self.bonus_buttons.pick_new_button())
#
# Debugging buttons
if prepare.DEBUG and S['show-debug-buttons']:
self.debug_buttons.append(
common.ImageOnOffButton('auto-pick',
S['debug-auto-pick-position'],
'bingo-yellow-button',
'bingo-yellow-off-button',
'small-button',
'Auto pick',
S['debug-auto-pick'],
S,
scale=S['small-button-scale']))
self.debug_buttons[-1].linkEvent(common.E_MOUSE_CLICK,
self.toggle_auto_pick)
#
self.debug_buttons.append(
common.ImageButton('restart',
S['debug-restart-position'],
'bingo-yellow-button',
'small-button',
'Restart',
S,
scale=S['small-button-scale']))
self.debug_buttons[-1].linkEvent(common.E_MOUSE_CLICK,
self.restart_game)
#
self.debug_buttons.append(
common.ImageButton('next-ball',
S['debug-next-ball-position'],
'bingo-yellow-button',
'small-button',
'Next Ball',
S,
scale=S['small-button-scale']))
self.debug_buttons[-1].linkEvent(common.E_MOUSE_CLICK,
self.next_ball)
#
self.debug_buttons.append(
common.ImageButton('new-cards',
S['debug-new-cards-position'],
'bingo-yellow-button',
'small-button',
'New Cards',
S,
scale=S['small-button-scale']))
self.debug_buttons[-1].linkEvent(common.E_MOUSE_CLICK,
self.draw_new_cards)
self.ui.extend(self.debug_buttons)
def spend_money(self, amount, arg):
"""Money has been spent"""
self.log.info('Money has been spent {1} by {0}'.format(arg, amount))
self.money_display.add_money(amount)
if amount < 0:
self.play_sound('bingo-pay-money')
self.casino_player.increase('total lost', -amount)
else:
self.casino_player.increase('total won', amount)
def change_pattern(self, obj, pattern):
"""Change the winning pattern"""
self.log.info('Changing pattern to {0}'.format(pattern.name))
#
# Account for the random factor
if pattern.name == "Random":
self.add_generator(
'randomize-buttons',
self.randomly_highlight_buttons(
self.pattern_buttons[-1], self.pattern_buttons[:-1],
S['randomize-button-number'], S['randomize-button-delay'],
lambda b: self.change_pattern(None, b.pattern)))
return
#
self.winning_pattern = pattern
self.highlight_patterns(self.winning_pattern, one_shot=True)
#
# Clear all flashing squares
for card in self.all_cards:
card.potential_winning_squares = []
for square in card.squares.values():
square.is_focused = False
#
# Update UI
for button in self.pattern_buttons:
button.state = (button.pattern == self.winning_pattern)
def toggle_auto_pick(self, obj, arg):
"""Toggle whether we are auto-picking numbers"""
self.log.debug('Toggling auto-pick')
self.auto_pick = not self.auto_pick
self.debug_buttons[0].state = self.auto_pick
def restart_game(self, obj, arg):
"""Restart the game"""
self.log.info('Restart game')
self.ball_machine.reset_machine(self.ball_machine.interval)
self.cards.reset()
self.dealer_cards.reset()
self.current_pick_sound = 0
self.last_pick_time = 0
self.casino_player.increase('games played')
def next_ball(self, obj, arg):
"""Move on to the next ball
This is a debugging method - no using the normal UI
"""
self.ball_machine.call_next_ball()
def next_chip(self, obj, arg):
"""Move on to the next ball"""
if self.next_chip_button.state:
self.ball_machine.call_next_ball()
self.add_generator('next-chip-animation', self.animate_next_chip())
def animate_next_chip(self):
"""Animate the button after choosing another chip"""
self.next_chip_button.state = False
yield S['next-chip-delay'] * 1000
self.next_chip_button.state = True
def draw_new_cards(self, obj, arg):
"""Draw a new set of cards"""
self.log.debug('Drawing new set of cards')
self.cards.draw_new_numbers()
self.cards.reset()
def create_card_collection(self):
"""Return a new card collection"""
number = self.card_selector.number_of_cards
self.cards = playercard.PlayerCardCollection(
'player-card', S['player-cards-position'],
S['player-card-offsets'][number], self)
dx, dy = S['dealer-card-offset']
dealer_offsets = [(dx + x, dy + y)
for x, y in S['player-card-offsets'][number]]
self.dealer_cards = dealercard.DealerCardCollection(
'dealer-card', S['player-cards-position'], dealer_offsets, self)
def change_number_of_cards(self, number, arg=None):
"""Change the number of cards in play"""
self.log.info('Changing the number of cards to {0}'.format(number))
#
# Store off the old card number to reuse
self.casino_player.set('_last squares', self.cards.get_card_numbers())
#
# Remove old cards
for card in self.cards:
self.all_cards.remove(card)
self.ui.remove(card)
for card in self.dealer_cards:
self.all_cards.remove(card)
#
# Create new cards
self.create_card_collection()
self.cards.set_card_numbers(self.casino_player.get(
'_last squares', []))
#
self.all_cards.extend(self.cards)
self.all_cards.extend(self.dealer_cards)
self.ui.extend(self.cards)
self.restart_game(None, None)
def highlight_patterns(self, pattern, one_shot):
"""Test method to cycle through the winning patterns"""
self.log.debug('Creating new highlight pattern generators')
for card in self.cards:
self.add_generator('highlight-patterns-card-%s' % card.name,
self.highlight_pattern(card, pattern, one_shot))
def highlight_pattern(self, card, pattern, one_shot):
"""Highlight a particular pattern on a card"""
for squares in pattern.get_matches(card):
for square in squares:
square.highlighted_state = bingocard.S_GOOD
card.set_dirty()
yield 100
for square in squares:
square.highlighted_state = bingocard.S_NONE
card.set_dirty()
yield 10
#
if not one_shot:
self.add_generator(
'highlight',
self.highlight_pattern(card, pattern, one_shot=False))
def ball_picked(self, ball):
"""A ball was picked"""
# Turn off the button to prevent the player from accidentally choosing another
# ball at the same time
self.add_generator('next-chip-animation', self.animate_next_chip())
#
# If auto-picking then update the cards
auto_pick_cards = list(self.dealer_cards)
if self.auto_pick:
auto_pick_cards.extend(self.cards)
for card in auto_pick_cards:
card.call_square(ball.number)
#
# Highlight the card labels
for card in self.all_cards:
card.highlight_column(ball.letter)
def player_picked(self, square, arg):
"""The player picked a square"""
if not square.card.is_active:
return
#
self.bonus_display.add_bonus()
#
# Check to see if we created a new potentially winning square
called_squares = list(square.card.called_squares)
prior_called_squares = list(called_squares)
prior_called_squares.remove(square.text)
#
_, winners = self.winning_pattern.get_number_to_go_and_winners(
square.card, called_squares)
_, prior_winners = self.winning_pattern.get_number_to_go_and_winners(
square.card, prior_called_squares)
self.log.debug('{0} / {1}'.format(winners, prior_winners))
#
if len(winners) > len(prior_winners):
self.play_sound('bingo-potential-winner')
#
# Increment sound if we did this quickly
if time.time() - self.last_pick_time < S['player-pick-interval']:
self.current_pick_sound = min(self.current_pick_sound + 1,
len(S['player-pick-sounds']) - 1)
else:
self.current_pick_sound = 0
self.last_pick_time = time.time()
self.play_sound(S['player-pick-sounds'][self.current_pick_sound])
#
self.log.info('Player picked {0}'.format(square))
def player_unpicked(self, square, arg):
"""The player unpicked a square"""
self.log.info('Player unpicked {0}'.format(square))
self.play_sound('bingo-unpick')
def flash_potential_winners(self):
"""Flash the squares that are potential winners"""
while True:
for state, delay in S['card-focus-flash-timing']:
for card in self.all_cards:
potential_squares = card.potential_winning_squares
if potential_squares:
for square in potential_squares:
square.is_focused = state
card.set_dirty()
yield delay * 1000
def play_sound(self, name):
"""Play a named sound - respects the mute settings"""
if not self.sound_muted:
prepare.SFX[name].play()
def get_missing_squares(self, squares):
"""Return a list of the numbers that have not been called"""
return [
square for square in squares
if square.text not in self.ball_machine.called_balls
]
def card_completed(self, card, arg):
"""A card was completed"""
self.log.info('Card {0} owned by {1} was completed'.format(
card.index, card.card_owner))
#
if card.card_owner == bingocard.T_PLAYER:
self.casino_player.increase('cards won' if card.card_state ==
bingocard.S_WON else 'cards lost')
else:
self.casino_player.increase('cards won' if card.card_state ==
bingocard.S_LOST else 'cards lost')
#
# Find the matching card from the dealer or player and deactivate it
other_card = self.cards[
card.
index] if card.card_owner == bingocard.T_DEALER else self.dealer_cards[
card.index]
other_card.active = False
other_card.set_card_state(bingocard.S_LOST)
#
# Check for all cards done
for item in self.cards:
if item.active and item != card:
return
else:
for item in self.cards:
self.add_generator('flash-labels', item.flash_labels())
def randomly_highlight_buttons(self,
source_button,
buttons,
number_of_times,
delay,
final_callback,
speed_up=None,
states=(False, True)):
"""Randomly highlight buttons in a group and then call the callback when complete"""
false_state, true_state = states
last_chosen = None
if source_button:
source_button.state = true_state
#
# Turn all buttons off
for button in buttons:
button.state = false_state
#
for i in range(number_of_times):
#
# Choose one to highlight, but not the last one
while True:
chosen = random.choice(buttons)
if chosen != last_chosen:
break
#
# Highlight it
self.log.debug('Setting to button {0}, {1}'.format(
buttons.index(chosen), chosen.name))
chosen.state = true_state
if last_chosen:
last_chosen.state = false_state
last_chosen = chosen
#
self.play_sound('bingo-beep')
#
if i != number_of_times - 1:
yield delay
#
# Shortern delay
delay *= speed_up if speed_up else S['randomize-button-speed-up']
#
if source_button:
source_button.state = false_state
#
final_callback(chosen)
def pause_machine(self, delay):
"""Pause the ball machine for a certain length of time"""
self.ball_machine.pause()
def unpause():
yield delay * 1000
self.ball_machine.unpause()
self.add_generator('un-pause', unpause())
def double_up(self):
"""Double up all cards"""
for card in self.cards:
card.double_down()
def slow_machine(self):
"""Slow the machine down"""
self.ball_machine.change_speed(None,
self.ball_machine.speed_transitions[0])
def start_auto_pick(self, delay):
"""Temporarily auto pick the numbers"""
self.auto_pick = True
def unauto():
yield delay * 1000
self.auto_pick = False
self.add_generator('un-auto', unauto())
def win_card(self):
"""Win one of the cards"""
possible_cards = [card for card in self.cards if card.active]
if possible_cards:
card = random.choice(possible_cards)
card.set_card_state(bingocard.S_WON)
self.play_sound(card.card_success_sound)
B.processEvent((events.E_CARD_COMPLETE, card))
card.active = False
class Betting(BlackjackState):
def __init__(self):
super(Betting, self).__init__()
self.make_buttons()
pos = (self.screen_rect.right-(NeonButton.width+10),
self.screen_rect.bottom-(NeonButton.height+15))
self.lobby_button = NeonButton(pos, "Lobby", self.back_to_lobby, None, self.buttons, bindings=[pg.K_ESCAPE])
def back_to_lobby(self, *args):
player = self.game.player
for hand in player.hands:
player.chip_pile.add_chips(cash_to_chips(hand.bet.get_chip_total()))
self.leave_state()
def startup(self, game):
self.game = game
if self.game.quick_bet and (self.game.quick_bet <= self.game.player.chip_pile.get_chip_total()):
chips = self.game.player.chip_pile.withdraw_chips(self.game.quick_bet)
self.game.current_player_hand.bet.add_chips(chips)
self.deal()
elif self.game.advisor_active:
self.game.advisor.queue_text("Click chips in your chip pile to place bet", dismiss_after=3000)
self.game.advisor.queue_text("Click chips in pot to remove from bet", dismiss_after=3000)
def make_buttons(self):
self.buttons = ButtonGroup()
side_margin = 10
vert_space = 15
left = self.screen_rect.right-(NeonButton.width + side_margin)
top = self.screen_rect.bottom-((NeonButton.height*5)+vert_space*4)
self.deal_button = NeonButton((left, top), "Deal", self.deal, None, self.buttons)
def deal(self, *args):
bets = [x.bet.get_chip_total() for x in self.game.player.hands]
self.game.last_bet = max(bets)
self.game.quick_bet = 0
self.next = "Dealing"
self.game.casino_player.increase("games played")
self.game.advisor.empty()
self.done = True
def get_event(self, event, scale):
self.game.get_event(event)
if event.type == pg.QUIT:
self.back_to_lobby()
elif event.type == pg.MOUSEBUTTONDOWN:
pos = tools.scaled_mouse_pos(scale, event.pos)
if not self.game.moving_stacks and event.button == 1:
new_movers = self.game.player.chip_pile.grab_chips(pos)
self.last_click = pg.time.get_ticks()
if new_movers:
self.play_chip_sound()
self.game.moving_stacks.append(new_movers)
for hand in self.game.player.hands:
unbet_stack = hand.bet.grab_chips(pos)
if unbet_stack:
self.play_chip_sound()
self.game.player.chip_pile.add_chips(unbet_stack.chips)
elif event.type == pg.MOUSEBUTTONUP:
now = pg.time.get_ticks()
span = now - self.last_click
pos = tools.scaled_mouse_pos(scale, event.pos)
if self.game.moving_stacks and event.button == 1:
for stack in self.game.moving_stacks:
stack.rect.bottomleft = pos
if self.game.chip_rack.rect.collidepoint(pos):
self.play_chip_sound()
self.game.player.chip_pile.add_chips(self.game.chip_rack.break_chips(stack.chips))
elif span > 300 and self.game.player.chip_pile.rect.collidepoint(pos):
self.play_chip_sound()
self.game.player.chip_pile.add_chips(stack.chips)
else:
self.play_chip_sound()
self.game.current_player_hand.bet.add_chips(stack.chips)
self.game.moving_stacks = []
if self.window:
self.window.get_event(event)
else:
self.lobby_button.get_event(event)
self.deal_button.get_event(event)
def update(self, surface, keys, current_time, dt, scale):
mouse_pos = tools.scaled_mouse_pos(pg.mouse.get_pos(), scale)
self.game.update(dt, mouse_pos)
bets = [x.bet.get_chip_total() for x in self.game.player.hands]
self.deal_button.visible = any(bets) and not self.game.moving_stacks
if self.window:
self.window.update(mouse_pos)
if self.window.done:
self.window = None
else:
self.lobby_button.update(mouse_pos)
self.deal_button.update(mouse_pos)
for stack in self.game.moving_stacks:
x, y = mouse_pos
stack.rect.bottomleft = (x - (self.game.chip_size[0] // 2),
y + 6)
def draw(self, surface):
g = self.game
surface.fill(prepare.FELT_GREEN)
for label in g.labels:
label.draw(surface)
g.player.draw_hands(surface)
g.player.draw_hand_bets(surface)
g.player.chip_pile.draw(surface)
g.chip_total_label.draw(surface)
g.dealer.draw_hand(surface)
g.deck.draw(surface)
g.chip_rack.draw(surface)
for stack in g.moving_stacks:
stack.draw(surface)
self.buttons.draw(surface)
self.draw_advisor(surface)
self.window and self.window.draw(surface)
def __init__(self):
super(Keno, self).__init__()
self.screen_rect = pg.Rect((0, 0), prepare.RENDER_SIZE)
self.game_started = False
self.font = prepare.FONTS["Saniretro"]
self.advisor = KenoAdvisor()
self.mock_label = Label(self.font, 64, 'KENO [WIP]', 'gold3',
{'center': (672, 102)})
b_width = 360
b_height = 90
side_margin = 10
w = self.screen_rect.right - (b_width + side_margin)
h = self.screen_rect.bottom - (b_height + 15)
self.buttons = ButtonGroup()
NeonButton((w, h), "Lobby", self.back_to_lobby, None, self.buttons)
self.turns = 16
self.play_max_active = False
ball_path = os.path.join('resources', 'keno', 'balls', '64x64',
'sheet.png')
ball_sheet = pg.image.load(ball_path).convert_alpha()
self.balls = tools.strip_from_sheet(ball_sheet, (0, 0), (64, 64), 10,
8)
self.keno_card = KenoCard(self.balls)
#self.keno_card = KenoCard() -- no ball graphics
self.prev_spot_count = 0
self.pay_table = PayTable(self.keno_card)
self.pay_table.update(0)
self.round_history = RoundHistory(self.keno_card)
self.alert = None
self.quick_picking = Action(
pg.Rect(370, 760, 150, 75),
Label(self.font, 32, 'QUICK PICK', 'gold3', {'center': (0, 0)}),
self.activate_quick_pick)
self.betting = Action(
pg.Rect(682, 760, 150, 75),
Label(self.font, 32, 'BET 1', 'gold3', {'center': (0, 0)}),
self.activate_bet)
self.clearing = Action(
pg.Rect(526, 760, 150, 75),
Label(self.font, 32, 'CLEAR', 'gold3', {'center': (0, 0)}),
self.activate_clear)
self.playing = Action(
pg.Rect(838, 760, 156, 75),
Label(self.font, 32, 'PLAY', 'gold3', {'center': (0, 0)}),
self.activate_play)
self.playing_max = Action(
pg.Rect(838, 840, 156, 75),
Label(self.font, 32, 'PLAY MAX', 'gold3', {'center': (0, 0)}),
self.activate_playmax)
self.actions = {
'quick pick': self.quick_picking,
'betting': self.betting,
'clearing': self.clearing,
'playing': self.playing,
'playing max': self.playing_max,
}
self.gui_widgets = {
'title': self.mock_label,
'card': self.keno_card,
'quick_pick': self.quick_picking,
'play': self.playing,
'play_max': self.playing_max,
'pay_table': self.pay_table,
'round_history': self.round_history,
'balance': None,
'bet_action': None,
'clear': None,
'bet': None,
'won': None,
'spot': None,
}
class PlayerTurn(BlackjackState):
def __init__(self):
super(PlayerTurn, self).__init__()
pos = (self.screen_rect.right - (NeonButton.width + 10),
self.screen_rect.bottom - (NeonButton.height + 15))
self.make_buttons()
self.lobby_button = NeonButton(pos,
"Lobby",
self.back_to_lobby,
None,
self.buttons,
bindings=[pg.K_ESCAPE])
self.last_click = 0
def play_deal_sound(self):
choice(self.game.deal_sounds).play()
def make_buttons(self):
side_margin = 10
vert_space = 12
left = self.screen_rect.right - (NeonButton.width + side_margin)
top = self.screen_rect.bottom - (
(NeonButton.height * 5) + vert_space * 5)
self.hit_button = NeonButton((left, top), "Hit", self.hit_click)
top += NeonButton.height + vert_space
self.stand_button = NeonButton((left, top), "Stand", self.stand)
top += NeonButton.height + vert_space
self.double_down_button = NeonButton((left, top), "Double",
self.double_down)
top += NeonButton.height + vert_space
self.split_button = NeonButton((left, top), "Split", self.split_hand)
self.buttons = ButtonGroup(self.hit_button, self.stand_button,
self.double_down_button, self.split_button)
def hit_click(self, *args):
self.hit(self.game.current_player_hand)
def hit(self, hand):
"""Draw a card from deck and add to hand."""
self.play_deal_sound()
self.game.player.add_slot(hand)
card = self.game.deck.draw_card()
card.face_up = True
destination = hand.slots[-1]
dest_x, dest_y = destination.topleft
hand.cards.append(card)
dur = get_distance(destination.center, card.pos) * 20 // card.speed
ani = Animation(x=dest_x, y=dest_y, duration=dur, round_values=True)
ani.start(card.rect)
self.animations.add(ani)
def stand(self, *args):
"""Player is done with this hand."""
self.game.current_player_hand.final = True
def double_down(self, *args):
"""
Double player's bet on the hand, deal one
more card and finalize hand.
"""
hand = self.game.current_player_hand
bet = hand.bet.get_chip_total()
bet_chips = self.game.player.chip_pile.withdraw_chips(bet)
hand.bet.add_chips(bet_chips)
self.hit(hand)
hand.final = True
def split_hand(self, *args):
"""
Split player's hand into two hands, adjust hand locations
and deal a new card to both hands.
"""
player = self.game.player
hand = self.game.current_player_hand
bet = hand.bet.get_chip_total()
hand.slots = hand.slots[:-1]
move = ((self.screen_rect.left + 50) - hand.slots[0].left, 0)
player.move_hands(move)
p_slot = player.hands[-1].slots[0]
hand_slot = p_slot.move(int(prepare.CARD_SIZE[0] * 3.5), 0)
card = hand.cards.pop()
new_hand = Hand(hand_slot.topleft, [card],
player.chip_pile.withdraw_chips(bet))
new_hand.slots = [hand_slot]
card.rect.topleft = hand_slot.topleft
player.hands.append(new_hand)
player.add_slot(new_hand)
self.play_deal_sound()
self.game.player.add_slot(hand)
card1 = self.game.deck.draw_card()
dest = hand.slots[-1]
dest_x, dest_y = dest.topleft
card1.face_up = True
hand.cards.append(card1)
ani = Animation(x=dest_x, y=dest_y, duration=1000, round_values=True)
ani.start(card1.rect)
card2 = self.game.deck.draw_card()
dest = new_hand.slots[-1]
dest_x, dest_y = dest.topleft
card2.face_up = True
new_hand.cards.append(card2)
ani2 = Animation(x=dest_x,
y=dest_y,
duration=1000,
delay=500,
round_values=True)
ani2.start(card2.rect)
ani3 = Task(self.play_deal_sound, 1500)
self.animations.add(ani, ani2, ani3)
def startup(self, game):
self.game = game
self.animations = pg.sprite.Group()
def get_event(self, event, scale):
now = pg.time.get_ticks()
span = now - self.last_click
if event.type == pg.QUIT:
self.back_to_lobby()
if event.type == pg.MOUSEBUTTONUP:
self.last_click = now
self.game.get_event(event)
if span > 300:
if self.window:
self.window.get_event(event)
else:
self.buttons.get_event(event)
def update(self, surface, keys, current_time, dt, scale):
mouse_pos = tools.scaled_mouse_pos(pg.mouse.get_pos(), scale)
g = self.game
g.update(dt, mouse_pos)
self.split_button.active = False
self.split_button.visible = False
self.double_down_button.active = False
self.double_down_button.visible = False
hand = g.current_player_hand
hand_score = hand.best_score()
if hand_score is None:
hand.busted = True
hand.final = True
chip_total = g.player.chip_pile.get_chip_total()
bet = hand.bet.get_chip_total()
if len(hand.cards) == 2 and len(g.player.hands) < 2:
c1 = hand.card_values[hand.cards[0].value]
c2 = hand.card_values[hand.cards[1].value]
if c1 == c2 and chip_total >= bet:
self.split_button.active = True
self.split_button.visible = True
if len(hand.cards) == 2:
if hand_score == 21:
hand.blackjack = True
hand.final = True
elif chip_total >= bet:
self.double_down_button.active = True
self.double_down_button.visible = True
if hand.final:
if all([hand.final for hand in g.player.hands]):
if not self.animations:
g.dealer.hand.cards[0].face_up = True
self.next = "Dealer Turn"
self.done = True
else:
next_hand = [x for x in g.player.hands if not x.final][0]
g.current_player_hand = next_hand
if self.window:
self.window.update(mouse_pos)
if self.window.done:
self.window = None
else:
self.buttons.update(mouse_pos)
self.animations.update(dt)
def draw_hand_frame(self, surface):
hand = self.game.current_player_hand
rects = [x for x in hand.slots]
pg.draw.rect(surface, pg.Color("gold3"),
hand.slots[0].unionall(rects).inflate(8, 8), 3)
def draw(self, surface):
g = self.game
surface.fill(prepare.FELT_GREEN)
for label in g.labels:
label.draw(surface)
g.player.draw_hand_bets(surface)
g.player.chip_pile.draw(surface)
g.chip_total_label.draw(surface)
g.dealer.draw_hand(surface)
g.deck.draw(surface)
g.chip_rack.draw(surface)
self.buttons.draw(surface)
self.lobby_button.draw(surface)
g.player.draw_hands(surface)
self.draw_advisor(surface)
self.draw_hand_frame(surface)
self.game.player.chip_pile.draw(surface)
self.window and self.window.draw(surface)
class Dealing(BlackjackState):
def __init__(self):
super(Dealing, self).__init__()
pos = (self.screen_rect.right - (NeonButton.width + 10),
self.screen_rect.bottom - (NeonButton.height + 15))
self.lobby_button = NeonButton(pos,
"Lobby",
self.back_to_lobby,
None,
bindings=[pg.K_ESCAPE])
def startup(self, game):
self.game = game
self.make_card_animations()
def flip_card(self, card):
card.face_up = True
def make_card_animations(self):
g = self.game
self.animations = pg.sprite.Group()
deal_delay = 0
for i in range(2):
card = g.deck.draw_card()
destination = g.current_player_hand.slots[-1]
dest_x, dest_y = destination.topleft
dur = get_distance(destination.center, card.pos) * 20 // card.speed
ani = Animation(x=dest_x,
y=dest_y,
duration=dur,
delay=deal_delay,
round_values=True)
ani2 = Task(self.play_deal_sound, deal_delay)
ani3 = Task(self.flip_card, deal_delay + dur, args=(card, ))
g.current_player_hand.cards.append(card)
if not i % 2:
g.player.add_slot(g.current_player_hand)
ani.start(card.rect)
self.animations.add(ani, ani2, ani3)
deal_delay += dur
for i in range(2):
card = g.deck.draw_card()
destination = g.dealer.hand.slots[-1]
dest_x, dest_y = destination.topleft
dur = get_distance(destination.center, card.pos) * 20 // card.speed
ani = Animation(x=dest_x,
y=dest_y,
duration=dur,
delay=deal_delay,
round_values=True)
ani2 = Task(self.play_deal_sound, deal_delay)
ani.start(card.rect)
g.dealer.hand.cards.append(card)
g.dealer.add_slot()
self.animations.add(ani, ani2)
if i:
ani3 = Task(self.flip_card, deal_delay + dur, args=(card, ))
self.animations.add(ani3)
deal_delay += dur
def get_event(self, event, scale):
if event.type == pg.QUIT:
self.back_to_lobby()
self.game.get_event(event)
if self.window:
self.window.get_event(event)
else:
self.lobby_button.get_event(event)
def update(self, surface, keys, current_time, dt, scale):
mouse_pos = tools.scaled_mouse_pos(pg.mouse.get_pos(), scale)
self.game.update(dt, mouse_pos)
if self.window:
self.window.update(mouse_pos)
if self.window.done:
self.window = None
else:
self.lobby_button.update(mouse_pos)
if self.animations:
self.animations.update(dt)
else:
self.next = "Player Turn"
self.done = True
def draw(self, surface):
g = self.game
surface.fill(prepare.FELT_GREEN)
for label in g.labels:
label.draw(surface)
g.player.draw_hand_bets(surface)
g.chip_total_label.draw(surface)
g.dealer.draw_hand(surface)
g.deck.draw(surface)
g.chip_rack.draw(surface)
self.lobby_button.draw(surface)
g.player.draw_hands(surface)
g.player.chip_pile.draw(surface)
self.draw_advisor(surface)
self.window and self.window.draw(surface)
class Dealing(BlackjackState):
def __init__(self):
super(Dealing, self).__init__()
pos = (self.screen_rect.right-(NeonButton.width+10),
self.screen_rect.bottom-(NeonButton.height+15))
self.lobby_button = NeonButton(pos, "Lobby", self.back_to_lobby, None, bindings=[pg.K_ESCAPE])
def startup(self, game):
self.game = game
self.make_card_animations()
def flip_card(self, card):
card.face_up = True
def make_card_animations(self):
g = self.game
self.animations = pg.sprite.Group()
deal_delay = 0
for i in range(2):
card = g.deck.draw_card()
destination = g.current_player_hand.slots[-1]
dest_x, dest_y = destination.topleft
dur = get_distance(destination.center, card.pos) * 20 // card.speed
ani = Animation(x=dest_x, y=dest_y, duration=dur,
delay=deal_delay, round_values=True)
ani2 = Task(self.play_deal_sound, deal_delay)
ani3 = Task(self.flip_card, deal_delay + dur, args=(card,))
g.current_player_hand.cards.append(card)
if not i % 2:
g.player.add_slot(g.current_player_hand)
ani.start(card.rect)
self.animations.add(ani, ani2, ani3)
deal_delay += dur
for i in range(2):
card = g.deck.draw_card()
destination = g.dealer.hand.slots[-1]
dest_x, dest_y = destination.topleft
dur = get_distance(destination.center, card.pos) * 20 // card.speed
ani = Animation(x=dest_x, y=dest_y, duration=dur,
delay=deal_delay, round_values=True)
ani2 = Task(self.play_deal_sound, deal_delay)
ani.start(card.rect)
g.dealer.hand.cards.append(card)
g.dealer.add_slot()
self.animations.add(ani, ani2)
if i:
ani3 = Task(self.flip_card, deal_delay + dur, args=(card,))
self.animations.add(ani3)
deal_delay += dur
def get_event(self, event, scale):
if event.type == pg.QUIT:
self.back_to_lobby()
self.game.get_event(event)
if self.window:
self.window.get_event(event)
else:
self.lobby_button.get_event(event)
def update(self, surface, keys, current_time, dt, scale):
mouse_pos = tools.scaled_mouse_pos(pg.mouse.get_pos(), scale)
self.game.update(dt, mouse_pos)
if self.window:
self.window.update(mouse_pos)
if self.window.done:
self.window = None
else:
self.lobby_button.update(mouse_pos)
if self.animations:
self.animations.update(dt)
else:
self.next = "Player Turn"
self.done = True
def draw(self, surface):
g = self.game
surface.fill(prepare.FELT_GREEN)
for label in g.labels:
label.draw(surface)
g.player.draw_hand_bets(surface)
g.chip_total_label.draw(surface)
g.dealer.draw_hand(surface)
g.deck.draw(surface)
g.chip_rack.draw(surface)
self.lobby_button.draw(surface)
g.player.draw_hands(surface)
g.player.chip_pile.draw(surface)
self.draw_advisor(surface)
self.window and self.window.draw(surface)
class Bingo(statemachine.StateMachine):
"""State to represent a bing game"""
name = "bingo"
show_in_lobby = True
def __init__(self):
"""Initialise the bingo game"""
#
self.verbose = False
self.sound_muted = prepare.ARGS['debug']
#
self.screen_rect = pg.Rect((0, 0), prepare.RENDER_SIZE)
self.auto_pick = S['debug-auto-pick']
#
self.ui = common.ClickableGroup()
#
self.lobby_button = NeonButton(S['lobby-position'], 'Lobby', self.return_to_lobby)
self.new_game_button = NeonButton(S['new-game-position'], 'New', lambda x: self.restart_game(None, None))
#
# The controls to allow selection of different numbers of cards
self.card_selector = cardselector.CardSelector('card-selector', self)
self.card_selector.linkEvent(events.E_NUM_CARDS_CHANGED, self.change_number_of_cards)
self.ui.append(self.card_selector.ui)
#
self.create_card_collection()
self.ui.extend(self.cards)
#
self.winning_pattern = patterns.PATTERNS[0]
#
self.pattern_buttons = common.DrawableGroup()
self.debug_buttons = common.DrawableGroup()
self.buttons = common.DrawableGroup([self.pattern_buttons])
#
if prepare.DEBUG:
self.buttons.append(self.debug_buttons)
#
super(Bingo, self).__init__()
#
# The machine for picking balls
self.ball_machine = ballmachine.BallMachine('ball-machine', self)
self.ball_machine.start_machine()
self.ui.append(self.ball_machine.buttons)
#
self.all_cards = common.DrawableGroup()
self.all_cards.extend(self.cards)
self.all_cards.extend(self.dealer_cards)
#
B.linkEvent(events.E_PLAYER_PICKED, self.player_picked)
B.linkEvent(events.E_PLAYER_UNPICKED, self.player_unpicked)
B.linkEvent(events.E_CARD_COMPLETE, self.card_completed)
#
self.current_pick_sound = 0
self.last_pick_time = 0
@staticmethod
def initialize_stats():
"""Return OrderedDict suitable for use in game stats
:return: collections.OrderedDict
"""
stats = OrderedDict([("games played", 0),
("cards won", 0),
("cards lost", 0),
("total lost", 0),
("total won", 0),
("time played", '00:00:00'),
("_last squares", [])])
return stats
def startup(self, current_time, persistent):
"""This method will be called each time the state resumes."""
self.persist = persistent
self.casino_player = self.persist["casino_player"]
self.casino_player.current_game = self.name
#
self.casino_player.increase('games played')
self.cards.set_card_numbers(self.casino_player.get('_last squares', []))
self.money_display.set_money(self.casino_player.cash)
self.time_started = time.time()
def get_event(self, event, scale=(1,1)):
"""Check for events"""
super(Bingo, self).get_event(event, scale)
self.lobby_button.get_event(event)
self.new_game_button.get_event(event)
#
if event.type == pg.QUIT:
if prepare.ARGS['straight']:
pg.quit()
sys.exit()
else:
self.done = True
self.next = "lobby"
elif event.type in (pg.MOUSEBUTTONDOWN, pg.MOUSEMOTION):
#
self.ui.process_events(event, scale)
self.bonus_buttons.process_events(event, scale)
#
pos = tools.scaled_mouse_pos(scale, event.pos)
elif event.type == pg.KEYUP:
if event.key == pg.K_ESCAPE:
self.done = True
self.next = "lobby"
elif event.key == pg.K_SPACE:
self.next_chip(None, None)
elif event.key == pg.K_m:
#self.persist["music_handler"].mute_unmute_music()
self.sound_muted = not self.sound_muted
elif event.key == pg.K_f:
for card in self.cards:
self.add_generator('flash-labels', card.flash_labels())
def return_to_lobby(self, arg):
"""Return to the lobby screen"""
self.game_started = False
self.done = True
self.next = "lobby"
self.casino_player.set('_last squares', self.cards.get_card_numbers())
self.casino_player.cash = self.money_display.amount
self.casino_player.increase_time('time played', time.time() - self.time_started)
def drawUI(self, surface, scale):
"""Update the main surface once per frame"""
mouse_pos = tools.scaled_mouse_pos(scale, pg.mouse.get_pos())
self.lobby_button.update(mouse_pos)
self.new_game_button.update(mouse_pos)
#
surface.fill(S['table-color'])
#
self.lobby_button.draw(surface)
self.new_game_button.draw(surface)
self.all_cards.draw(surface)
self.ball_machine.draw(surface)
self.buttons.draw(surface)
self.card_selector.draw(surface)
self.money_display.draw(surface)
self.bonus_display.draw(surface)
self.bonus_buttons.draw(surface)
def initUI(self):
"""Initialise the UI display"""
#
# Buttons that show the winning patterns
x, y = S['winning-pattern-position']
for idx, pattern in enumerate(patterns.PATTERNS):
dx, dy = S['winning-pattern-buttons'][pattern.name]
new_button = patterns.PatternButton(
idx, (x + dx, y + dy),
'bingo-wide-red-button', 'bingo-wide-red-button-off', 'winning-pattern',
pattern.name,
pattern == self.winning_pattern, S,
scale=S['winning-pattern-scale']
)
new_button.linkEvent(common.E_MOUSE_CLICK, self.change_pattern, pattern)
new_button.pattern = pattern
self.pattern_buttons.append(new_button)
self.ui.extend(self.pattern_buttons)
#
# Simple generator to flash the potentially winning squares
self.add_generator('potential-winners', self.flash_potential_winners())
#
# Display of the money the player has
self.money_display = moneydisplay.MoneyDisplay(
'money-display', S['money-position'], 0, self
)
prepare.BROADCASTER.linkEvent(events.E_SPEND_MONEY, self.spend_money)
#
# Button for next chip
self.next_chip_button = common.ImageOnOffButton(
'next-chip', S['next-chip-position'],
'bingo-next-chip-on', 'bingo-next-chip-off', 'next-chip',
'Next Chip (SPC)', True,
S, scale=S['next-chip-scale']
)
self.next_chip_button.linkEvent(common.E_MOUSE_CLICK, self.next_chip)
self.ui.append(self.next_chip_button)
self.buttons.append(self.next_chip_button)
#
# Menu bar
self.menu_bar = common.NamedSprite(
'bingo-menu-bar', S['menu-bar-position'], scale=S['menu-bar-scale']
)
self.buttons.append(self.menu_bar)
#
self.bonus_display = bonusdisplay.BonusDisplay(
'bonus-display', S['bonus-light-position'], self)
#
self.bonus_buttons = bonusbuttons.BonusButtonsDisplay(
'bonus-buttons', S['bonus-buttons-position'], self
)
self.bonus_display.linkEvent(
events.E_BONUS_REACHED,
lambda o, a: self.bonus_buttons.pick_new_button()
)
#
# Debugging buttons
if prepare.DEBUG and S['show-debug-buttons']:
self.debug_buttons.append(common.ImageOnOffButton(
'auto-pick', S['debug-auto-pick-position'],
'bingo-yellow-button', 'bingo-yellow-off-button', 'small-button',
'Auto pick',
S['debug-auto-pick'],
S, scale=S['small-button-scale']
))
self.debug_buttons[-1].linkEvent(common.E_MOUSE_CLICK, self.toggle_auto_pick)
#
self.debug_buttons.append(common.ImageButton(
'restart', S['debug-restart-position'],
'bingo-yellow-button', 'small-button',
'Restart',
S, scale=S['small-button-scale']
))
self.debug_buttons[-1].linkEvent(common.E_MOUSE_CLICK, self.restart_game)
#
self.debug_buttons.append(common.ImageButton(
'next-ball', S['debug-next-ball-position'],
'bingo-yellow-button', 'small-button',
'Next Ball',
S, scale=S['small-button-scale']
))
self.debug_buttons[-1].linkEvent(common.E_MOUSE_CLICK, self.next_ball)
#
self.debug_buttons.append(common.ImageButton(
'new-cards', S['debug-new-cards-position'],
'bingo-yellow-button', 'small-button',
'New Cards',
S, scale=S['small-button-scale']
))
self.debug_buttons[-1].linkEvent(common.E_MOUSE_CLICK, self.draw_new_cards)
self.ui.extend(self.debug_buttons)
def spend_money(self, amount, arg):
"""Money has been spent"""
self.log.info('Money has been spent {1} by {0}'.format(arg, amount))
self.money_display.add_money(amount)
if amount < 0:
self.play_sound('bingo-pay-money')
self.casino_player.increase('total lost', -amount)
else:
self.casino_player.increase('total won', amount)
def change_pattern(self, obj, pattern):
"""Change the winning pattern"""
self.log.info('Changing pattern to {0}'.format(pattern.name))
#
# Account for the random factor
if pattern.name == "Random":
self.add_generator(
'randomize-buttons',
self.randomly_highlight_buttons(
self.pattern_buttons[-1],
self.pattern_buttons[:-1],
S['randomize-button-number'], S['randomize-button-delay'],
lambda b: self.change_pattern(None, b.pattern)
)
)
return
#
self.winning_pattern = pattern
self.highlight_patterns(self.winning_pattern, one_shot=True)
#
# Clear all flashing squares
for card in self.all_cards:
card.potential_winning_squares = []
for square in card.squares.values():
square.is_focused = False
#
# Update UI
for button in self.pattern_buttons:
button.state = (button.pattern == self.winning_pattern)
def toggle_auto_pick(self, obj, arg):
"""Toggle whether we are auto-picking numbers"""
self.log.debug('Toggling auto-pick')
self.auto_pick = not self.auto_pick
self.debug_buttons[0].state = self.auto_pick
def restart_game(self, obj, arg):
"""Restart the game"""
self.log.info('Restart game')
self.ball_machine.reset_machine(self.ball_machine.interval)
self.cards.reset()
self.dealer_cards.reset()
self.current_pick_sound = 0
self.last_pick_time = 0
self.casino_player.increase('games played')
def next_ball(self, obj, arg):
"""Move on to the next ball
This is a debugging method - no using the normal UI
"""
self.ball_machine.call_next_ball()
def next_chip(self, obj, arg):
"""Move on to the next ball"""
if self.next_chip_button.state:
self.ball_machine.call_next_ball()
self.add_generator('next-chip-animation', self.animate_next_chip())
def animate_next_chip(self):
"""Animate the button after choosing another chip"""
self.next_chip_button.state = False
yield S['next-chip-delay'] * 1000
self.next_chip_button.state = True
def draw_new_cards(self, obj, arg):
"""Draw a new set of cards"""
self.log.debug('Drawing new set of cards')
self.cards.draw_new_numbers()
self.cards.reset()
def create_card_collection(self):
"""Return a new card collection"""
number = self.card_selector.number_of_cards
self.cards = playercard.PlayerCardCollection(
'player-card',
S['player-cards-position'],
S['player-card-offsets'][number],
self
)
dx, dy = S['dealer-card-offset']
dealer_offsets = [(dx + x, dy +y) for x, y in S['player-card-offsets'][number]]
self.dealer_cards = dealercard.DealerCardCollection(
'dealer-card',
S['player-cards-position'],
dealer_offsets,
self
)
def change_number_of_cards(self, number, arg=None):
"""Change the number of cards in play"""
self.log.info('Changing the number of cards to {0}'.format(number))
#
# Store off the old card number to reuse
self.casino_player.set('_last squares', self.cards.get_card_numbers())
#
# Remove old cards
for card in self.cards:
self.all_cards.remove(card)
self.ui.remove(card)
for card in self.dealer_cards:
self.all_cards.remove(card)
#
# Create new cards
self.create_card_collection()
self.cards.set_card_numbers(self.casino_player.get('_last squares', []))
#
self.all_cards.extend(self.cards)
self.all_cards.extend(self.dealer_cards)
self.ui.extend(self.cards)
self.restart_game(None, None)
def highlight_patterns(self, pattern, one_shot):
"""Test method to cycle through the winning patterns"""
self.log.debug('Creating new highlight pattern generators')
for card in self.cards:
self.add_generator(
'highlight-patterns-card-%s' % card.name,
self.highlight_pattern(card, pattern, one_shot)
)
def highlight_pattern(self, card, pattern, one_shot):
"""Highlight a particular pattern on a card"""
for squares in pattern.get_matches(card):
for square in squares:
square.highlighted_state = bingocard.S_GOOD
card.set_dirty()
yield 100
for square in squares:
square.highlighted_state = bingocard.S_NONE
card.set_dirty()
yield 10
#
if not one_shot:
self.add_generator('highlight', self.highlight_pattern(card, pattern, one_shot=False))
def ball_picked(self, ball):
"""A ball was picked"""
# Turn off the button to prevent the player from accidentally choosing another
# ball at the same time
self.add_generator('next-chip-animation', self.animate_next_chip())
#
# If auto-picking then update the cards
auto_pick_cards = list(self.dealer_cards)
if self.auto_pick:
auto_pick_cards.extend(self.cards)
for card in auto_pick_cards:
card.call_square(ball.number)
#
# Highlight the card labels
for card in self.all_cards:
card.highlight_column(ball.letter)
def player_picked(self, square, arg):
"""The player picked a square"""
if not square.card.is_active:
return
#
self.bonus_display.add_bonus()
#
# Check to see if we created a new potentially winning square
called_squares = list(square.card.called_squares)
prior_called_squares = list(called_squares)
prior_called_squares.remove(square.text)
#
_, winners = self.winning_pattern.get_number_to_go_and_winners(square.card, called_squares)
_, prior_winners = self.winning_pattern.get_number_to_go_and_winners(square.card, prior_called_squares)
self.log.debug('{0} / {1}'.format(winners, prior_winners))
#
if len(winners) > len(prior_winners):
self.play_sound('bingo-potential-winner')
#
# Increment sound if we did this quickly
if time.time() - self.last_pick_time < S['player-pick-interval']:
self.current_pick_sound = min(self.current_pick_sound + 1, len(S['player-pick-sounds']) - 1)
else:
self.current_pick_sound = 0
self.last_pick_time = time.time()
self.play_sound(S['player-pick-sounds'][self.current_pick_sound])
#
self.log.info('Player picked {0}'.format(square))
def player_unpicked(self, square, arg):
"""The player unpicked a square"""
self.log.info('Player unpicked {0}'.format(square))
self.play_sound('bingo-unpick')
def flash_potential_winners(self):
"""Flash the squares that are potential winners"""
while True:
for state, delay in S['card-focus-flash-timing']:
for card in self.all_cards:
potential_squares = card.potential_winning_squares
if potential_squares:
for square in potential_squares:
square.is_focused = state
card.set_dirty()
yield delay * 1000
def play_sound(self, name):
"""Play a named sound - respects the mute settings"""
if not self.sound_muted:
prepare.SFX[name].play()
def get_missing_squares(self, squares):
"""Return a list of the numbers that have not been called"""
return [square for square in squares if square.text not in self.ball_machine.called_balls]
def card_completed(self, card, arg):
"""A card was completed"""
self.log.info('Card {0} owned by {1} was completed'.format(card.index, card.card_owner))
#
if card.card_owner == bingocard.T_PLAYER:
self.casino_player.increase('cards won' if card.card_state == bingocard.S_WON else 'cards lost')
else:
self.casino_player.increase('cards won' if card.card_state == bingocard.S_LOST else 'cards lost')
#
# Find the matching card from the dealer or player and deactivate it
other_card = self.cards[card.index] if card.card_owner == bingocard.T_DEALER else self.dealer_cards[card.index]
other_card.active = False
other_card.set_card_state(bingocard.S_LOST)
#
# Check for all cards done
for item in self.cards:
if item.active and item != card:
return
else:
for item in self.cards:
self.add_generator('flash-labels', item.flash_labels())
def randomly_highlight_buttons(self, source_button, buttons, number_of_times, delay, final_callback, speed_up=None,
states=(False, True)):
"""Randomly highlight buttons in a group and then call the callback when complete"""
false_state, true_state = states
last_chosen = None
if source_button:
source_button.state = true_state
#
# Turn all buttons off
for button in buttons:
button.state = false_state
#
for i in range(number_of_times):
#
# Choose one to highlight, but not the last one
while True:
chosen = random.choice(buttons)
if chosen != last_chosen:
break
#
# Highlight it
self.log.debug('Setting to button {0}, {1}'.format(buttons.index(chosen), chosen.name))
chosen.state = true_state
if last_chosen:
last_chosen.state = false_state
last_chosen = chosen
#
self.play_sound('bingo-beep')
#
if i != number_of_times - 1:
yield delay
#
# Shortern delay
delay *= speed_up if speed_up else S['randomize-button-speed-up']
#
if source_button:
source_button.state = false_state
#
final_callback(chosen)
def pause_machine(self, delay):
"""Pause the ball machine for a certain length of time"""
self.ball_machine.pause()
def unpause():
yield delay * 1000
self.ball_machine.unpause()
self.add_generator('un-pause', unpause())
def double_up(self):
"""Double up all cards"""
for card in self.cards:
card.double_down()
def slow_machine(self):
"""Slow the machine down"""
self.ball_machine.change_speed(None, self.ball_machine.speed_transitions[0])
def start_auto_pick(self, delay):
"""Temporarily auto pick the numbers"""
self.auto_pick = True
def unauto():
yield delay * 1000
self.auto_pick = False
self.add_generator('un-auto', unauto())
def win_card(self):
"""Win one of the cards"""
possible_cards = [card for card in self.cards if card.active]
if possible_cards:
card = random.choice(possible_cards)
card.set_card_state(bingocard.S_WON)
self.play_sound(card.card_success_sound)
B.processEvent((events.E_CARD_COMPLETE, card))
card.active = False
class ShowResults(BlackjackState):
def __init__(self):
super(ShowResults, self).__init__()
pos = (self.screen_rect.right - (NeonButton.width + 10),
self.screen_rect.bottom - (NeonButton.height + 15))
self.lobby_button = NeonButton(pos,
"Lobby",
self.back_to_lobby,
bindings=[pg.K_ESCAPE])
self.coin_sound = prepare.SFX["coins"]
def startup(self, game):
self.game = game
self.game.result_labels = []
self.fade_labels = []
self.alpha = 255
total_ani_time = 2000
fade_ani = Animation(alpha=0, duration=total_ani_time)
fade_ani.start(self)
self.animations.add(fade_ani)
self.game.tally_hands()
payout = self.game.pay_out()
if payout:
self.coin_sound.play()
hands = self.game.player.hands
if len(hands) > 2:
text_size = 64
elif len(hands) == 2:
text_size = 80
else:
text_size = 96
win_piles = []
loss_piles = []
self.winnings = []
self.losses = []
for hand in hands:
amount = hand.bet.get_chip_total()
hand.bet_amount = amount
bl = hand.bet.stacks[0].rect.bottomleft
if hand.blackjack:
text, color = "Blackjack", "gold3"
text_size -= 8
chips = cash_to_chips(int(amount * 2.5))
amount = int(amount * 1.5)
win_piles.append(BetPile(bl, self.game.chip_size, chips))
elif hand.winner:
text, color = "Win", "gold3"
chips = cash_to_chips(amount * 2)
win_piles.append(BetPile(bl, self.game.chip_size, chips))
elif hand.push:
text, color = "Push", "gold3"
chips = cash_to_chips(amount)
win_piles.append(BetPile(bl, self.game.chip_size, chips))
elif hand.busted:
text, color = "Bust", "darkred"
chips = cash_to_chips(amount)
loss_piles.append(BetPile(bl, self.game.chip_size, chips))
amount *= -1
else:
text, color = "Loss", "darkred"
chips = cash_to_chips(amount)
loss_piles.append(BetPile(bl, self.game.chip_size, chips))
amount *= -1
centerx = (hand.slots[0].left + hand.slots[-1].right) // 2
centery = hand.slots[0].centery
label = Blinker(self.font, text_size, text, color,
{"center": (centerx, centery)}, 450)
self.game.result_labels.append(label)
amt_color = "darkgreen" if amount >= 0 else "darkred"
bet_label = Label(self.font,
120,
"{:+}".format(amount),
amt_color, {"bottomleft": bl},
bg=prepare.FELT_GREEN)
move_ani = Animation(bottom=bl[1] - 150,
duration=total_ani_time,
round_values=True)
move_ani.start(bet_label.rect)
self.animations.add(move_ani)
self.fade_labels.append(bet_label)
hand.bet.chips = []
hand.bet.stacks = []
payout_duration = 1000
center = self.game.player.chip_pile.rect.center
for pile in win_piles:
self.winnings.append(pile)
for stack in pile.stacks:
ani = Animation(left=center[0],
bottom=center[1],
duration=payout_duration,
round_values=True)
ani.start(stack.rect)
self.animations.add(ani)
center = self.game.chip_rack.rect.center
for loss_pile in loss_piles:
self.losses.append(loss_pile)
for stack in loss_pile.stacks:
ani = Animation(left=center[0],
bottom=center[1],
duration=payout_duration,
round_values=True)
ani.start(stack.rect)
self.animations.add(ani)
pay_ani = Task(self.game.player.chip_pile.add_chips,
payout_duration,
args=[payout])
remove_chips = Task(self.remove_chips, payout_duration)
end_it = Task(self.end_state, total_ani_time)
self.animations.add(pay_ani, remove_chips, end_it)
def remove_chips(self):
self.winnings = []
self.losses = []
def end_state(self):
self.next = "End Round"
self.done = True
def get_event(self, event, scale):
if event.type == pg.QUIT:
self.back_to_lobby()
self.game.get_event(event)
if self.window:
self.window.get_event(event)
else:
self.lobby_button.get_event(event)
def update(self, surface, keys, current_time, dt, scale):
mouse_pos = tools.scaled_mouse_pos(pg.mouse.get_pos(), scale)
self.game.update(dt, mouse_pos)
for blinker in self.game.result_labels:
blinker.update(dt)
self.animations.update(dt)
for fader in self.fade_labels:
fader.image.set_alpha(self.alpha)
if self.window:
self.window.update(mouse_pos)
if self.window.done:
self.window = None
else:
self.lobby_button.update(mouse_pos)
def draw(self, surface):
g = self.game
surface.fill(prepare.FELT_GREEN)
for label in g.labels:
label.draw(surface)
g.player.draw_hand_bets(surface)
g.player.chip_pile.draw(surface)
g.chip_total_label.draw(surface)
g.dealer.draw_hand(surface)
g.deck.draw(surface)
g.chip_rack.draw(surface)
self.lobby_button.draw(surface)
g.player.draw_hands(surface)
for blinker in self.game.result_labels:
blinker.draw(surface)
for fader in self.fade_labels:
fader.draw(surface)
self.draw_advisor(surface)
self.game.player.chip_pile.draw(surface)
for pile in self.winnings:
pile.draw(surface)
for pile_ in self.losses:
pile_.draw(surface)
self.window and self.window.draw(surface)
def __init__(self):
super(EndRound, self).__init__()
pos = (self.screen_rect.right-(NeonButton.width+10),
self.screen_rect.bottom-(NeonButton.height+15))
self.lobby_button = NeonButton(pos, "Lobby", self.back_to_lobby, bindings=[pg.K_ESCAPE])
self.make_buttons()
class DealerTurn(BlackjackState):
def __init__(self):
super(DealerTurn, self).__init__()
pos = (self.screen_rect.right-(NeonButton.width+10),
self.screen_rect.bottom-(NeonButton.height+15))
self.lobby_button = NeonButton(pos, "Lobby", self.back_to_lobby, bindings=[pg.K_ESCAPE])
def startup(self, game):
self.game = game
g = game
if all([hand.busted for hand in g.player.hands]):
g.dealer.hand.final = True
self.state = "End Round"
delay = 1000
while not g.dealer.hand.final:
hand_score = g.dealer.hand.best_score()
if hand_score is None:
g.dealer.hand.busted = True
g.dealer.hand.final = True
elif hand_score == 21 and len(g.dealer.hand.cards) == 2:
g.dealer.hand.blackjack = True
g.dealer.hand.final = True
elif hand_score < 17:
self.hit(g.dealer.hand, delay)
delay += 1000
else:
g.dealer.hand.final = True
def hit(self, hand, delay_time=0):
"""Draw a card from deck and add to hand."""
self.play_deal_sound()
card = self.game.deck.draw_card()
card.face_up = True
destination = hand.slots[-1]
dest_x, dest_y = destination.topleft
dur = get_distance(destination.center, card.pos) * 20 // card.speed
self.game.dealer.add_slot()
hand.cards.append(card)
ani = Animation(x=dest_x, y=dest_y, duration=dur,
delay=delay_time, round_values=True)
ani.start(card.rect)
self.animations.add(ani)
def get_event(self, event, scale):
if event.type == pg.QUIT:
self.back_to_lobby()
self.game.get_event(event)
if self.window:
self.window.get_event(event)
else:
self.lobby_button.get_event(event)
def update(self, surface, keys, current_time, dt, scale):
mouse_pos = tools.scaled_mouse_pos(pg.mouse.get_pos(), scale)
self.game.update(dt, mouse_pos)
if self.window:
self.window.update(mouse_pos)
if self.window.done:
self.window = None
else:
self.lobby_button.update(mouse_pos)
self.animations.update(dt)
if not self.animations:
self.next = "Show Results"
self.done = True
def draw(self, surface):
g = self.game
surface.fill(prepare.FELT_GREEN)
for label in g.labels:
label.draw(surface)
g.player.draw_hand_bets(surface)
g.player.chip_pile.draw(surface)
g.chip_total_label.draw(surface)
g.dealer.draw_hand(surface)
g.deck.draw(surface)
g.chip_rack.draw(surface)
self.lobby_button.draw(surface)
g.player.draw_hands(surface)
self.draw_advisor(surface)
self.game.player.chip_pile.draw(surface)
self.window and self.window.draw(surface)
class ShowResults(BlackjackState):
def __init__(self):
super(ShowResults, self).__init__()
pos = (self.screen_rect.right-(NeonButton.width+10),
self.screen_rect.bottom-(NeonButton.height+15))
self.lobby_button = NeonButton(pos, "Lobby", self.back_to_lobby, bindings=[pg.K_ESCAPE])
self.coin_sound = prepare.SFX["coins"]
def startup(self, game):
self.game = game
self.game.result_labels = []
self.fade_labels = []
self.alpha = 255
total_ani_time = 2000
fade_ani = Animation(alpha=0, duration=total_ani_time)
fade_ani.start(self)
self.animations.add(fade_ani)
self.game.tally_hands()
payout = self.game.pay_out()
if payout:
self.coin_sound.play()
hands = self.game.player.hands
if len(hands) >2:
text_size = 64
elif len(hands) == 2:
text_size = 80
else:
text_size = 96
win_piles = []
loss_piles = []
self.winnings = []
self.losses = []
for hand in hands:
amount = hand.bet.get_chip_total()
hand.bet_amount = amount
bl = hand.bet.stacks[0].rect.bottomleft
if hand.blackjack:
text, color = "Blackjack", "gold3"
text_size -= 8
chips = cash_to_chips(int(amount * 2.5))
amount = int(amount * 1.5)
win_piles.append(BetPile(bl, self.game.chip_size, chips))
elif hand.winner:
text, color = "Win", "gold3"
chips = cash_to_chips(amount * 2)
win_piles.append(BetPile(bl, self.game.chip_size, chips))
elif hand.push:
text, color = "Push", "gold3"
chips = cash_to_chips(amount)
win_piles.append(BetPile(bl, self.game.chip_size, chips))
elif hand.busted:
text, color = "Bust", "darkred"
chips = cash_to_chips(amount)
loss_piles.append(BetPile(bl, self.game.chip_size, chips))
amount *= -1
else:
text, color = "Loss", "darkred"
chips = cash_to_chips(amount)
loss_piles.append(BetPile(bl, self.game.chip_size, chips))
amount *= -1
centerx = (hand.slots[0].left + hand.slots[-1].right) // 2
centery = hand.slots[0].centery
label = Blinker(self.font, text_size, text, color,
{"center": (centerx, centery)},
450)
self.game.result_labels.append(label)
amt_color = "darkgreen" if amount >= 0 else "darkred"
bet_label = Label(self.font, 120, "{:+}".format(amount), amt_color,
{"bottomleft": bl}, bg=prepare.FELT_GREEN)
move_ani = Animation(bottom=bl[1]-150, duration=total_ani_time, round_values=True)
move_ani.start(bet_label.rect)
self.animations.add(move_ani)
self.fade_labels.append(bet_label)
hand.bet.chips = []
hand.bet.stacks = []
payout_duration = 1000
center = self.game.player.chip_pile.rect.center
for pile in win_piles:
self.winnings.append(pile)
for stack in pile.stacks:
ani = Animation(left=center[0], bottom=center[1], duration=payout_duration, round_values=True)
ani.start(stack.rect)
self.animations.add(ani)
center = self.game.chip_rack.rect.center
for loss_pile in loss_piles:
self.losses.append(loss_pile)
for stack in loss_pile.stacks:
ani = Animation(left=center[0], bottom=center[1], duration=payout_duration, round_values=True)
ani.start(stack.rect)
self.animations.add(ani)
pay_ani = Task(self.game.player.chip_pile.add_chips, payout_duration, args=[payout])
remove_chips = Task(self.remove_chips, payout_duration)
end_it = Task(self.end_state, total_ani_time)
self.animations.add(pay_ani, remove_chips, end_it)
def remove_chips(self):
self.winnings = []
self.losses = []
def end_state(self):
self.next = "End Round"
self.done = True
def get_event(self, event, scale):
if event.type == pg.QUIT:
self.back_to_lobby()
self.game.get_event(event)
if self.window:
self.window.get_event(event)
else:
self.lobby_button.get_event(event)
def update(self, surface, keys, current_time, dt, scale):
mouse_pos = tools.scaled_mouse_pos(pg.mouse.get_pos(), scale)
self.game.update(dt, mouse_pos)
for blinker in self.game.result_labels:
blinker.update(dt)
self.animations.update(dt)
for fader in self.fade_labels:
fader.image.set_alpha(self.alpha)
if self.window:
self.window.update(mouse_pos)
if self.window.done:
self.window = None
else:
self.lobby_button.update(mouse_pos)
def draw(self, surface):
g = self.game
surface.fill(prepare.FELT_GREEN)
for label in g.labels:
label.draw(surface)
g.player.draw_hand_bets(surface)
g.player.chip_pile.draw(surface)
g.chip_total_label.draw(surface)
g.dealer.draw_hand(surface)
g.deck.draw(surface)
g.chip_rack.draw(surface)
self.lobby_button.draw(surface)
g.player.draw_hands(surface)
for blinker in self.game.result_labels:
blinker.draw(surface)
for fader in self.fade_labels:
fader.draw(surface)
self.draw_advisor(surface)
self.game.player.chip_pile.draw(surface)
for pile in self.winnings:
pile.draw(surface)
for pile_ in self.losses:
pile_.draw(surface)
self.window and self.window.draw(surface)
class DealerTurn(BlackjackState):
def __init__(self):
super(DealerTurn, self).__init__()
pos = (self.screen_rect.right - (NeonButton.width + 10),
self.screen_rect.bottom - (NeonButton.height + 15))
self.lobby_button = NeonButton(pos,
"Lobby",
self.back_to_lobby,
bindings=[pg.K_ESCAPE])
def startup(self, game):
self.game = game
g = game
if all([hand.busted for hand in g.player.hands]):
g.dealer.hand.final = True
self.state = "End Round"
delay = 1000
while not g.dealer.hand.final:
hand_score = g.dealer.hand.best_score()
if hand_score is None:
g.dealer.hand.busted = True
g.dealer.hand.final = True
elif hand_score == 21 and len(g.dealer.hand.cards) == 2:
g.dealer.hand.blackjack = True
g.dealer.hand.final = True
elif hand_score < 17:
self.hit(g.dealer.hand, delay)
delay += 1000
else:
g.dealer.hand.final = True
def hit(self, hand, delay_time=0):
"""Draw a card from deck and add to hand."""
self.play_deal_sound()
card = self.game.deck.draw_card()
card.face_up = True
destination = hand.slots[-1]
dest_x, dest_y = destination.topleft
dur = get_distance(destination.center, card.pos) * 20 // card.speed
self.game.dealer.add_slot()
hand.cards.append(card)
ani = Animation(x=dest_x,
y=dest_y,
duration=dur,
delay=delay_time,
round_values=True)
ani.start(card.rect)
self.animations.add(ani)
def get_event(self, event, scale):
if event.type == pg.QUIT:
self.back_to_lobby()
self.game.get_event(event)
if self.window:
self.window.get_event(event)
else:
self.lobby_button.get_event(event)
def update(self, surface, keys, current_time, dt, scale):
mouse_pos = tools.scaled_mouse_pos(pg.mouse.get_pos(), scale)
self.game.update(dt, mouse_pos)
if self.window:
self.window.update(mouse_pos)
if self.window.done:
self.window = None
else:
self.lobby_button.update(mouse_pos)
self.animations.update(dt)
if not self.animations:
self.next = "Show Results"
self.done = True
def draw(self, surface):
g = self.game
surface.fill(prepare.FELT_GREEN)
for label in g.labels:
label.draw(surface)
g.player.draw_hand_bets(surface)
g.player.chip_pile.draw(surface)
g.chip_total_label.draw(surface)
g.dealer.draw_hand(surface)
g.deck.draw(surface)
g.chip_rack.draw(surface)
self.lobby_button.draw(surface)
g.player.draw_hands(surface)
self.draw_advisor(surface)
self.game.player.chip_pile.draw(surface)
self.window and self.window.draw(surface)
def __init__(self):
super(ShowResults, self).__init__()
pos = (self.screen_rect.right-(NeonButton.width+10),
self.screen_rect.bottom-(NeonButton.height+15))
self.lobby_button = NeonButton(pos, "Lobby", self.back_to_lobby, bindings=[pg.K_ESCAPE])
self.coin_sound = prepare.SFX["coins"]
