def make_labels_rolls(self, font, text_list, y):
"""
Create each text label and a corresponding roller. Arguments are
a font object; a list of strings to make labels from; and the y
coordinate that the top label starts from.
"""
labels = []
rollers = pg.sprite.Group()
for i, text in enumerate(text_list):
if not i % 2:
pos = (-self.off, y)
roll = Roller(pos, random.choice(COLORS), "right", self.speed)
r = roll.rect
label = Label(
font, self.font_size, text, "goldenrod3",
{"midright": (r.left - self.chip_space, r.centery)})
label.speed = self.speed
else:
pos = (SCREEN_WIDTH + self.off, y)
roll = Roller(pos, random.choice(COLORS), "left", self.speed)
r = roll.rect
label = Label(
font, self.font_size, text, "goldenrod3",
{"midleft": (r.right + self.chip_space, r.centery)})
label.speed = -self.speed
label.true_centerx = label.rect.centerx
label.moving = True
labels.append(label)
rollers.add(roll)
y += self.vert_space
return labels, rollers
def build(self):
x = self.rect.left + self.padding
y = y_initial = self.rect.top
for row in RANKS:
label = Label(self.font, self.text_size, row, self.text_color,
{"topleft": (x, y)})
self.table.append(label)
y += self.line_height
x += self.col_space * 2 - self.padding * 2
y = y_initial
for col in PAYTABLE:
for row in col:
text = str(row)
label = Label(self.font, self.text_size, text, self.text_color,
{"topright": (x, y)})
self.table.append(label)
y += self.line_height
x += self.col_space
y = y_initial
# borders between cols
x = self.rect.left + self.col_space
y0 = self.rect.top
y1 = self.rect.bottom
for i in range(5):
line = [(x, y0), (x, y1)]
self.lines.append(line)
x += self.col_space
self.rank_rect = pg.Rect((self.rect.left, self.rect.top),
(self.rect.w, self.line_height))
self.bet_rect = pg.Rect((self.rect.left, self.rect.top),
(self.col_space, self.rect.h))
def __init__(self, cash=0, chips=None):
self.name = "YOU"
self.cards = []
self.cash = cash
chip_size = prepare.CHIP_SIZE
self.stayed = False
self.passed = False
font = prepare.FONTS["Saniretro"]
label_center = (700, 820)
self.stay_label = Label(font,
48,
"Stayed in",
"gold3", {"center": label_center},
bg=prepare.FELT_GREEN)
self.pass_label = Label(font,
48,
"Passed",
"darkred", {"center": label_center},
bg=prepare.FELT_GREEN)
self.name_label = Label(
font, 48, self.name, "gold3",
{"center": (label_center[0], label_center[1] + 60)})
for label in [self.stay_label, self.pass_label, self.name_label]:
label.image.set_alpha(200)
self.label = None
self.dealer_button_topleft = label_center[0] - 40, label_center[1] - 100
slot_rect = pg.Rect((645, 860), prepare.CARD_SIZE)
self.card_slots = [slot_rect, slot_rect.move(60, 0)]
self.orientation = "bottom"
self.won = 0
self.lost = 0
def __init__(self, controller):
super(Credits, self).__init__(controller)
self.next = None
self.screen_rect = pg.Rect((0, 0), prepare.RENDER_SIZE)
cent_x = self.screen_rect.centerx
self.anykey = FlashingText((cent_x, 650), "[Press Any Key]",
"Fixedsys500c", pg.Color("gold"), 30, 350)
self.titles = []
names = ["/u/mekire", "/u/bitcraft", "/u/iminurnamez"]
for i, name in enumerate(names, start=-1):
text = "Some stuff by {}".format(name)
self.titles.append(
Label(
prepare.FONTS["Fixedsys500c"], 48, text, pg.Color("white"),
{
"centerx": self.screen_rect.centerx,
"centery": self.screen_rect.centery + i * 80
}))
self.titles.append(
Label(
prepare.FONTS["Fixedsys500c"], 48, "Your Name Here",
pg.Color("white"), {
"centerx": self.screen_rect.centerx,
"centery": self.screen_rect.centery + (i + 1) * 80
}))
def __init__(self,
pos,
text,
font_size=16,
call=None,
args=None,
*groups,
**kwargs):
text = text.replace("_", " ")
blank = constants.GFX["neon_button_blank"]
scaled = pg.transform.scale(
blank, (blank.get_width() // 2, blank.get_height() // 2))
on_label = Label(constants.FONTS["Fixedsys500c"], font_size, text,
constants.HIGH_LIGHT_GREEN, {"center": (45, 14)})
off_label = Label(constants.FONTS["Fixedsys500c"], font_size, text,
constants.LOW_LIGHT_GREEN, {"center": (45, 14)})
on_image = scaled.subsurface((self.width, 0, self.width, self.height))
off_image = scaled.subsurface((0, 0, self.width, self.height))
on_label.draw(on_image)
off_label.draw(off_image)
rect = on_image.get_rect(topleft=pos)
settings = {
"hover_image": on_image,
"idle_image": off_image,
"call": call,
"args": args
}
settings.update(kwargs)
super(SmallNeonButton, self).__init__(rect, *groups, **settings)
def make_high_scores_table(self, high_scores, score):
font = prog_constants.FONTS["Fixedsys500c"]
color = constants.LOW_LIGHT_GREEN
left1, left2, top = 350, 500, 100
placed = False
self.name_label = None
self.flasher = None
self.textbox = None
for i, info in enumerate(high_scores):
name, high_score = info
name_label = Label(font, 32, name, color,
{"topleft": (left1, top)})
if high_score == score and not placed and not name:
placed = True
label = FlashingText(font, 32, "{}".format(high_score), color,
{"topleft": (left2, top)}, 500)
self.flasher = label
self.name_label = name_label
self.name_index = i
validator = lambda x: len(x) == 3
box_size = (96, 32)
self.textbox = Textbox2({"topleft": (left1 - 4, top + 2)},
call=self.enter_name,
box_size=box_size,
validator=validator,
font_path=font)
else:
label = Label(font, 32, "{}".format(high_score), color,
{"topleft": (left2, top)})
self.labels.extend([label, name_label])
top += 40
self.high_scores = high_scores
def make_buttons(self):
self.buttons = ButtonGroup()
self.labels = []
buttons = [("Balance Inquiry", "ACCOUNTSCREEN", (34, 450)),
("Deposit", "DEPOSIT", (34, 580)),
("Withdrawal", "WITHDRAWAL", (1278, 450)),
("Cash Advance", "ADVANCE", (1278, 580)),
("Exit", "", (1278, 840))]
for text, next_state_name, topleft in buttons:
callback = self.set_next
bound = []
if text == "Exit":
callback = self.back_to_lobby
bound = [pg.K_ESCAPE]
Button((topleft, (88, 65)),
self.buttons,
args=next_state_name,
call=callback,
bindings=bound)
if topleft[0] == 34:
rect_pos = {"midleft": (topleft[0] + 115, topleft[1] + 32)}
else:
rect_pos = {"midright": (topleft[0] - 27, topleft[1] + 32)}
label = Label(self.font, 36, text, "white", rect_pos, bg="blue2")
self.labels.append(label)
title = Label(
self.font, 48, "Select Transaction Type", "white",
{"midtop": (self.screen_rect.centerx, self.screen_rect.top + 80)})
self.labels.append(title)
def startup(self, persistent):
self.persist = persistent
msg = self.persist["message"]
self.label = Label(self.font, 36, msg, "white",
{"center": self.screen_rect.center})
self.exit_label = Label(self.font, 36, "OK", "white",
{"midright": (1251, 872)})
def startup(self, persistent):
self.persist = persistent
self.labels = pg.sprite.Group()
font = prog_constants.FONTS["Fixedsys500c"]
sr = constants.SCREEN_RECT
self.missiles = pg.sprite.Group()
self.all_explosions = pg.sprite.Group()
self.explosions = pg.sprite.Group()
self.buildings = pg.sprite.Group()
left, bottom = 50, 500
for x in "Missiles":
label = Label(font, 192, x, constants.LOW_LIGHT_GREEN,
{"bottomleft": (left, bottom)})
img = label.image
damaged_label = Label(font, 192, x, (166, 0, 33),
{"bottomleft": (left, bottom)})
damaged_img = damaged_label.image
width = img.get_width()
MockCity((left + (width // 2), bottom), img, damaged_img,
self.buildings)
left += width
self.blinker = FlashingText(font, 50, "[Press Any Key]",
pg.Color("white"),
{"center": (sr.centerx, 625)}, 350)
self.missile_speed = .12
self.missile_timer = 0
self.missile_frequency = 200
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 __init__(self, player, level):
font = prog_constants.FONTS["Fixedsys500c"]
self.level_label = Label(font, 16, "Level {}".format(level.level_num),
constants.LOW_LIGHT_GREEN,
{"topleft": (0, 0)})
self.cash_label = Label(font, 16, "${}".format(player.cash),
constants.LOW_LIGHT_GREEN,
{"topleft": (0, 20)})
self.ammo_label = Label(font, 16, "Ammo: {}".format(player.ammo),
constants.LOW_LIGHT_GREEN,
{"topleft": (0, 40)})
def make_dynamic_labels(self, player):
text = "The maximum advance is ${:.2f}".format(
player.account.max_advance)
dyna1 = Label(
self.font, 36, text, "white",
{"midtop": (self.screen_rect.centerx, self.screen_rect.top + 80)})
fee_text = "A {}% fee will be added to the advance amount".format(
player.account.lending_rate * 100)
dyna2 = Label(
self.font, 36, fee_text, "white",
{"midtop": (self.screen_rect.centerx, dyna1.rect.bottom + 10)})
self.dynamic_labels = [dyna1, dyna2]
def __init__(self, card):
self.rect = pg.Rect(1036, 200, 340, 554)
self.font = prepare.FONTS["Saniretro"]
self.color = '#181818'
self.card = card
self.header_labels = []
self.header_labels.extend(
[Label(self.font, 32, 'HIT', 'white', {'center': (1080, 224)})])
self.header_labels.extend(
[Label(self.font, 32, 'WIN', 'white', {'center': (1280, 224)})])
self.pay_labels = []
def __init__(self, controller):
super(GameWin, self).__init__(controller)
font = prog_constants.FONTS["Fixedsys500c"]
color = constants.LOW_LIGHT_GREEN
sr = constants.SCREEN_RECT
self.labels = [
Label(font, 48, "Congratulations", color,
{"midtop": (sr.centerx, 200)}),
Label(font, 48, "Your cities are saved", color,
{"midtop": (sr.centerx, 300)})
]
self.buttons = ButtonGroup()
NeonButton((373, 630), "OK", 32, self.to_title, None, self.buttons)
def make_info_label(self, rect):
labels = []
y = rect.bottom + self.padding
if self.state == "WON" or self.state == "DOUBLE UP":
text = "you have won: {} double up to: {}".format(
self.win, self.win * 2)
label = MultiLineLabel(self.font,
35,
text,
self.text_color, {
"centerx": rect.centerx,
"top": y
},
char_limit=20,
align="center")
labels.append(label)
else:
if self.state == "GAME OVER":
if self.win > 0:
text = 'you win {}'.format(self.win)
label = Label(self.font, self.text_size, text,
self.text_color, {
"centerx": rect.centerx,
"top": y
})
labels.append(label)
elif self.current_bet == 0:
text = "game over"
label = Label(self.font, self.text_size, text,
self.text_color, {
"centerx": rect.centerx,
"top": y
})
labels.append(label)
text = 'Credits {}'.format(self.credits)
label = Label(self.font, self.text_size, text, self.text_color,
{"topright": (rect.right, y)})
labels.append(label)
coins_text = "Current Bet {}".format(self.current_bet)
label = Label(self.font, self.text_size, coins_text, self.text_color,
{"topleft": (rect.x, y)})
labels.append(label)
balance = 'Balance: ${}'.format(self.player.cash)
pos = ((self.rect.right + self.padding), (self.rect.top + 300))
label = Label(self.font, 50, balance, self.text_color,
{"topleft": pos})
labels.append(label)
return labels
def __init__(self, name, orientation, hand_topleft):
self.name = name
self.orientation = orientation
self.cards = []
self.stayed = False
self.passed = False
self.hand_topleft = hand_topleft
font = prepare.FONTS["Saniretro"]
slot_rect = pg.Rect(self.hand_topleft, prepare.CARD_SIZE)
if orientation == "left":
name_pos = hand_topleft[0] + 60, hand_topleft[1] + 240
db_pos = hand_topleft[0] + 170, hand_topleft[1] + 80
self.card_slots = [slot_rect, slot_rect.move(0, 60)]
elif orientation == "right":
name_pos = hand_topleft[0] + 60, hand_topleft[1] + 240
db_pos = hand_topleft[0] - 120, hand_topleft[1] + 80
self.card_slots = [slot_rect, slot_rect.move(0, 60)]
else:
name_pos = hand_topleft[0] + 90, hand_topleft[1] + 210
db_pos = hand_topleft[0] + 60, hand_topleft[1] + 285
self.card_slots = [slot_rect, slot_rect.move(60, 0)]
self.name_label = Label(font,
48,
self.name,
"antiquewhite", {"center": name_pos},
bg=prepare.FELT_GREEN)
self.name_label.image.set_alpha(100)
center = self.name_label.rect.midbottom
label_center = center[0], center[1] + 20
self.stay_label = Label(font,
48,
"Stayed in",
"gold3", {"center": label_center},
bg=prepare.FELT_GREEN)
self.stay_label.image.set_alpha(200)
self.pass_label = Label(font,
48,
"Passed",
"darkred", {"center": label_center},
bg=prepare.FELT_GREEN)
self.pass_label.image.set_alpha(200)
self.label = None
self.dealer_button_topleft = db_pos
self.guts = randint(-10, 20)
self.won = 0
self.lost = 0
names = ["cardslide{}".format(x) for x in (2, 3, 4)]
self.fold_sounds = [prepare.SFX[name] for name in names]
def make_labels(self):
sr = self.screen_rect
self.labels = []
self.alpha = 255
self.big_alpha = 255
self.animations = pg.sprite.Group()
text = "Free Ride" if self.game.free_ride else "Ante Up"
self.big_label = Label(self.font,
320,
text,
"gold3", {"center": sr.center},
bg=prepare.FELT_GREEN)
self.big_label.image.set_colorkey(prepare.FELT_GREEN)
left, top = self.big_label.rect.topleft
ani = Animation(x=left, y=top - 500, duration=2000, round_values=True)
fade = Animation(alpha=0, duration=2000, round_values=True)
big_fader = Animation(big_alpha=0,
duration=1500,
delay=500,
round_values=True)
fade.start(self)
ani.start(self.big_label.rect)
big_fader.start(self)
self.animations.add(ani, fade, big_fader)
if not self.game.free_ride:
dest = self.game.pot_label.rect.center
for p in self.game.players:
pos = p.name_label.rect.center
label = Label(self.font,
96,
"${}".format(self.game.bet),
"darkred", {"center": pos},
bg=prepare.FELT_GREEN)
label.image.set_colorkey(prepare.FELT_GREEN)
left, top = label.rect.topleft
self.labels.append(label)
ani = Animation(centerx=dest[0],
centery=dest[1],
duration=2000,
delay=50,
round_values=True,
transition="in_quart")
ani.callback = self.add_bet_to_pot
ani.start(label.rect)
self.animations.add(ani)
fader = Animation(alpha=0, duration=2100, round_values=True)
fader.start(self)
self.animations.add(fader)
def __init__(self):
super(AdvanceScreen, self).__init__()
self.make_textbox()
self.title = Label(
self.font, 36, "Enter Cash Advance Amount", "white",
{"midtop": (self.screen_rect.centerx, self.screen_rect.top + 300)})
self.make_enter_button()
def make_enter_button(self):
self.button_labels = []
self.buttons = ButtonGroup()
Button(((1278, 840), (88, 65)), self.buttons, bindings=[pg.K_RETURN])
rect_pos = {"midright": (1251, 872)}
label = Label(self.font, 36, "Enter", "white", rect_pos, bg="blue2")
self.button_labels.append(label)
def make_labels(self):
labels_info = [("Drop chips in chip rack", 36, "antiquewhite", 100, {
"midtop":
(self.chip_rack.rect.centerx, self.chip_rack.rect.bottom + 5)
}),
("to make change", 36, "antiquewhite", 100, {
"midtop": (self.chip_rack.rect.centerx,
self.chip_rack.rect.bottom + 60)
}),
("Blackjack Pays 3 to 2", 64, "gold3", 120, {
"midtop": (580, 300)
}),
("Dealer must draw to 16 and stand on 17", 48,
"antiquewhite", 100, {
"midtop": (580, 240)
})]
labels = []
for info in labels_info:
label = Label(self.font,
info[1],
info[0],
info[2],
info[4],
bg=prepare.FELT_GREEN)
label.image.set_alpha(info[3])
labels.append(label)
return labels
def build(self):
font_size = 48
text = "0"
text_color = "white"
rect_attrib = {'center': (0, 0)}
x_origin = 336
x = x_origin
y = 200
for row in range(0, 8):
for col in range(1, 11):
text = str(col + (10 * row))
label = Label(self.font, font_size, text, text_color,
rect_attrib)
if self.sheet:
spot = KenoSpot(x, y, 64, 64, label,
self.sheet[int(text) - 1])
else:
spot = KenoSpot(x, y, 64, 64, label)
self.spots.extend([spot])
x += 70
y += 70
x = x_origin
def startup(self, persistent):
self.persist = persistent
self.animations = pg.sprite.Group()
self.buttons = ButtonGroup()
font = prog_constants.FONTS["Fixedsys500c"]
color = constants.LOW_LIGHT_GREEN
sr = constants.SCREEN_RECT
NeonButton((373, 630), "Next Level", 32, self.next_level,
None, self.buttons)
self.make_city_icons()
total = sum((icon.current_points for icon in self.city_icons))
points_text = "${}".format(total)
self.points_label = Label(font, 32,
points_text, color, {"center": (sr.centerx, 200)})
level_num = self.persist["player"].level_num
self.title = Label(font, 48, "Level {} Complete".format(level_num),
color, {"midtop": (sr.centerx, 5)})
def make_showdown_label(self):
pos = self.screen_rect.center
self.label = Label(self.font,
self.showdown_font_size,
"Showdown!",
"gold3", {"center": pos},
bg=prepare.FELT_GREEN)
self.label.image.set_colorkey(prepare.FELT_GREEN)
self.label.image.set_alpha(self.alpha)
def __init__(self, controller):
super(Scene, self).__init__(controller)
self.next = None
self.screen_rect = pg.Rect((0, 0), prepare.RENDER_SIZE)
cent_x = self.screen_rect.centerx
self.anykey = FlashingText((cent_x, 650), "[Press Any Key]",
"Fixedsys500c", pg.Color("gold"), 30, 350)
self.title = Label(prepare.FONTS["Fixedsys500c"], 72, "Your game here!",
pg.Color("white"), {"center": self.screen_rect.center})
def build(self):
x = self.rect.left
y = self.rect.top + self.line_height
for index, card in enumerate(self.hand):
card.rect.left = x
card.rect.top = y
label = Label(self.font, self.text_size, 'held', self.text_color,
{"bottom": card.rect.top, "centerx": card.rect.centerx})
self.held_labels.append(label)
if index == 0:
label = Label(self.font, self.text_size, 'dealer', self.text_color,
{"bottom": card.rect.top, "centerx": card.rect.centerx})
else:
label = Label(self.font, self.text_size, 'player', self.text_color,
{"bottom": card.rect.top, "centerx": card.rect.centerx})
self.double_up_labels.append(label)
x += self.card_spacing + card.rect.w
def __init__(self, midbottom, points, image, current_points=0):
self.current_points = current_points
self.points = points
self.image = image
self.rect = self.image.get_rect(midbottom=midbottom)
self.points_label = Label(prog_constants.FONTS["Fixedsys500c"], 24,
"{}".format(self.current_points),
constants.LOW_LIGHT_GREEN,
{"midtop": (midbottom[0], midbottom[1] + 4)})
def setup_debug_entry(self):
self.debug_lbl = Label(self.font, self.font_size, '6 6', "gold3",
{"center": (750, 950)})
settings = {
"command": self.debug_roll,
"inactive_on_enter": False,
'active': False
}
self.widgets.append(TextBox((700, 1000, 150, 30), **settings))
def draw_hand_bets(self, surface):
for hand in self.hands:
hand.bet.draw(surface)
amount = max(hand.bet.get_chip_total(), hand.bet_amount)
label = Label(self.font, 36, "Bet: ${}".format(amount),
"antiquewhite", {"bottomleft": (hand.tl[0], hand.tl[1] - 3)},
bg=prepare.FELT_GREEN)
label.image.set_alpha(160)
label.draw(surface)
def update(self, spot, bet=1):
self.pay_labels = []
row = PAYTABLE[spot]
hit_x = 1080
win_x = 1280
row_y = 224 + 32
for entry in row:
hit, win = entry
win *= bet
self.pay_labels.extend([
Label(self.font, 32, str(hit), 'white',
{'center': (hit_x, row_y)})
])
self.pay_labels.extend([
Label(self.font, 32, str(win), 'white',
{'center': (win_x, row_y)})
])
row_y += 32
def __init__(self, card):
self.rect = pg.Rect(24, 200, 304, 554)
self.font = prepare.FONTS["Saniretro"]
self.color = '#181818'
self.card = card
self.header_labels = []
self.header_labels.extend(
[Label(self.font, 32, 'ROUND', 'white', {'center': (100, 224)})])
self.header_labels.extend(
[Label(self.font, 32, 'HITS', 'white', {'center': (280, 224)})])
self.result_labels = []
self.round_x = 100
self.hit_x = 280
self.row_y = 224 + 32
self.rounds = 1
