def __init__(self, master):
Window.__init__(self, master=master, bg_music=master.bg_music)
self.bind_key(pygame.K_ESCAPE, lambda event: self.stop())
self.bind_joystick(0, "START", lambda event: self.stop())
self.bind_joystick(0, "B", lambda event: self.stop())
self.master = master
self.bg = RectangleShape(*self.size, (0, 0, 0, 170))
params_for_all_buttons = {
"font": (RESOURCES.FONT["algerian"], 100),
"bg": GREEN,
"hover_bg": GREEN_LIGHT,
"active_bg": GREEN_DARK,
"hover_sound": RESOURCES.SFX["select"],
"on_click_sound": RESOURCES.SFX["validate"],
"outline": 3,
"highlight_color": YELLOW
}
self.menu_buttons = ButtonListVertical(offset=30)
self.menu_buttons.add(
Button(self,
"Return",
**params_for_all_buttons,
callback=self.stop),
Button(self,
"Options",
**params_for_all_buttons,
callback=self.show_options),
Button(self,
"Garage",
**params_for_all_buttons,
callback=self.return_to_garage),
Button(self,
"Menu",
**params_for_all_buttons,
callback=self.return_to_menu))
def __init__(self, master):
super().__init__(master, width_ratio=0.25, height_ratio=1, outline=1, outline_color=WHITE, bg_color=BLUE, bind_escape=False)
self.bind_key(pygame.K_ESCAPE, lambda event: self.stop())
self.bind_event(pygame.MOUSEBUTTONDOWN, self.__handle_mouse_event)
self.master = master
self.text_title = Text("Options", font=("calibri", 50), color=WHITE)
self.button_list = ButtonListVertical(offset=20, justify="right")
def __init__(self, master, gameplay: FourInARowGameplay):
Section.__init__(self, master, "Choose AI level", gameplay)
self.buttons_ai_level = ButtonListVertical(offset=100)
theme = {"font": self.title.font, "y_add_size": -30}
disabled_levels = [FourInARowAI.HARD]
self.buttons_ai_level.add_multiple(
Button(self,
text=string.capwords(level),
theme=["section"],
**theme,
callback=lambda ai_level=level: self.play(ai_level),
state=Button.DISABLED if level in
disabled_levels else Button.NORMAL)
for level in FourInARowAI.get_available_levels())
class NavyWindow(Window):
def __init__(self):
Window.__init__(self, size=(1280, 720), flags=pygame.DOUBLEBUF, bg_music=RESOURCES.MUSIC["menu"])
self.set_icon(RESOURCES.IMG["icon"])
self.set_title(f"Navy - v{__version__}")
self.set_fps(60)
self.disable_key_joy_focus_for_all_window()
self.bg = Image(RESOURCES.IMG["menu_bg"], self.size)
self.logo = Image(RESOURCES.IMG["logo"])
params_for_all_buttons = {
"font": (None, 100),
"bg": GREEN,
"hover_bg": GREEN_LIGHT,
"active_bg": GREEN_DARK,
"outline": 3,
"highlight_color": YELLOW,
}
params_for_dialogs = {
"outline": 5,
"hide_all_without": [self.bg, self.logo]
}
self.start_game = NavySetup(1)
self.multiplayer_server = PlayerServer(self, **params_for_dialogs)
self.multiplayer_client = PlayerClient(self, **params_for_dialogs)
self.dialog_credits = Credits(self, **params_for_dialogs)
self.dialog_options = Options(self, **params_for_dialogs)
self.menu_buttons = ButtonListVertical(offset=30)
self.menu_buttons.add(
Button(self, "Play against AI", **params_for_all_buttons, callback=self.start_game.mainloop),
Button(self, "Play as P1", **params_for_all_buttons, callback=self.multiplayer_server.mainloop),
Button(self, "Play as P2", **params_for_all_buttons, callback=self.multiplayer_client.mainloop),
Button(self, "Quit", **params_for_all_buttons, callback=self.stop)
)
self.button_credits = Button(self, "Credits", callback=self.dialog_credits.mainloop, **params_for_all_buttons)
self.button_settings = Button.withImageOnly(self, Image(RESOURCES.IMG["settings"], size=self.button_credits.height - 20), callback=self.dialog_options.mainloop, **params_for_all_buttons)
def place_objects(self):
self.bg.center = self.center
self.logo.centerx = self.centerx
self.menu_buttons.move(centerx=self.centerx, bottom=self.bottom - 20)
self.button_settings.move(left=10, bottom=self.bottom - 10)
self.button_credits.move(right=self.right - 10, bottom=self.bottom - 10)
def __init__(self):
MainWindow.__init__(self, title=f"Navy - v{__version__}", size=(1280, 720), resources=RESOURCES, config=WINDOW_CONFIG_FILE)
self.bg = Image(RESOURCES.IMG["menu_bg"], size=self.size)
self.logo = Image(RESOURCES.IMG["logo"])
Button.set_default_theme("default")
Button.set_theme("default", {
"bg": GREEN,
"hover_bg": GREEN_LIGHT,
"active_bg": GREEN_DARK,
"highlight_color": YELLOW,
"outline": 3,
})
Button.set_theme("title", {
"font": (None, 100),
})
Button.set_theme("option", {
"font": ("calibri", 30),
})
Scale.set_default_theme("default")
Scale.set_theme("default", {
"color": TRANSPARENT,
"scale_color": GREEN,
"highlight_color": YELLOW,
"outline": 3
})
params_for_dialogs = {
"outline": 5,
"hide_all_without": [self.bg, self.logo]
}
self.start_game = NavySetup()
self.multiplayer_server = PlayerServer(self, **params_for_dialogs)
self.multiplayer_client = PlayerClient(self, **params_for_dialogs)
self.dialog_credits = Credits(self, **params_for_dialogs)
self.menu_buttons = ButtonListVertical(offset=30)
self.menu_buttons.add(
Button(self, "Play against AI", theme="title", callback=lambda: self.start_game.start(1)),
Button(self, "Play as P1", theme="title", callback=self.multiplayer_server.mainloop),
Button(self, "Play as P2", theme="title", callback=self.multiplayer_client.mainloop),
Button(self, "Quit", theme="title", callback=self.stop)
)
self.button_credits = Button(self, "Credits", font=("calibri", 50), callback=self.dialog_credits.mainloop)
def __init__(self, master: Window):
Window.__init__(self, bg_color=BACKGROUND_COLOR)
self.bind_key(pygame.K_ESCAPE, lambda event: self.stop())
self.master = master
self.logo = Image(RESOURCES.IMG["logo"])
arrow = pygame.transform.flip(RESOURCES.IMG["arrow"], True, False)
self.button_back = ImageButton(self,
img=arrow,
width=100,
callback=self.stop,
active_offset=(0, 5),
highlight_color=YELLOW)
self.grid = FourInARowGrid(self, self.width / 2, self.height * 0.75)
self.__player_turn = 0
self.player_who_start_first = 0
self.player = 0
self.__turn = str()
self.__turn_dict = dict()
self.__score_player = self.__score_enemy = 0
self.__highlight_line_window_callback = None
self.enemy = str()
self.ai = FourInARowAI()
self.text_score = Text()
self.text_player_turn = Text()
self.left_options = ButtonListVertical(offset=50)
self.left_options.add(
Button(self, "Restart", theme="option", callback=self.restart),
Button(self, "Quit game", theme="option", callback=self.quit_game))
self.text_winner = Text()
self.text_drawn_match = Text("Drawn match.")
self.token_players = Grid(self)
for row in range(2):
self.token_players.place(CircleShape(20,
PLAYER_TOKEN_COLOR[row + 1],
outline=2,
outline_color=WHITE),
row,
column=1,
padx=5,
pady=5,
justify="left")
self.enemy_quit_dialog = EnemyQuitGame(self)
class AILevelSelectorSection(Section):
def __init__(self, master, gameplay: FourInARowGameplay):
Section.__init__(self, master, "Choose AI level", gameplay)
self.buttons_ai_level = ButtonListVertical(offset=100)
theme = {"font": self.title.font, "y_add_size": -30}
disabled_levels = [FourInARowAI.HARD]
self.buttons_ai_level.add_multiple(
Button(self,
text=string.capwords(level),
theme=["section"],
**theme,
callback=lambda ai_level=level: self.play(ai_level),
state=Button.DISABLED if level in
disabled_levels else Button.NORMAL)
for level in FourInARowAI.get_available_levels())
def on_start_loop(self) -> None:
super().on_start_loop()
self.buttons_ai_level[0].focus_set()
def place_objects(self) -> None:
Section.place_objects(self)
self.buttons_ai_level.move(centerx=self.frame.centerx,
top=self.title.bottom + 50)
def set_grid(self) -> None:
self.button_back.set_obj_on_side(on_bottom=self.buttons_ai_level[0],
on_right=self.buttons_ai_level[0])
self.buttons_ai_level.set_obj_on_side(on_top=self.button_back,
on_left=self.button_back)
def play(self, ai_level: str) -> None:
self.gameplay.start(AI, ai_level=ai_level)
self.stop()
class SideBoard(Dialog):
def __init__(self, master):
super().__init__(master, width_ratio=0.25, height_ratio=1, outline=1, outline_color=WHITE, bg_color=BLUE, bind_escape=False)
self.bind_key(pygame.K_ESCAPE, lambda event: self.stop())
self.bind_event(pygame.MOUSEBUTTONDOWN, self.__handle_mouse_event)
self.master = master
self.text_title = Text("Options", font=("calibri", 50), color=WHITE)
self.button_list = ButtonListVertical(offset=20, justify="right")
def add_option(self, name: str, callback: Callable[..., None]) -> None:
button = TitleButton(
self, text=name, callback=lambda: self.__call(callback),
x_size=self.frame.w * 0.9, y_add_size=20, justify=("right", "center"), offset=(-10, 0)
)
self.button_list.add(button)
def place_objects(self) -> None:
self.text_title.move(centerx=self.frame.centerx, top=self.frame.top + 20)
self.button_list.move(top=self.text_title.bottom + 50, right=self.frame.right - 10)
def on_start_loop(self) -> None:
self.frame.left = self.right
self.place_objects()
self.master.image_game_preview.animate_move(self, speed=75, right=self.left)
self.frame.animate_move(self, speed=50, at_every_frame=self.place_objects, right=self.right)
def on_quit(self) -> None:
self.frame.animate_move(self, speed=50, at_every_frame=self.place_objects, left=self.right)
def __call(self, callback: Callable[..., None]):
self.stop()
callback()
def __handle_mouse_event(self, event: pygame.event.Event) -> None:
if event.type == pygame.MOUSEBUTTONDOWN and event.button == 1 and not self.frame.rect.collidepoint(*event.pos):
self.stop()
def __init__(self):
MainWindow.__init__(self,
title=f"4 in a row - v{__version__}",
size=(1280, 720),
bg_color=BACKGROUND_COLOR,
resources=RESOURCES,
config=WINDOW_CONFIG_FILE)
self.logo = Image(RESOURCES.IMG["logo"])
Text.set_default_theme("default")
Text.set_theme(
"default", {
"font": RESOURCES.font("heavy", 45),
"color": YELLOW,
"shadow": True,
"shadow_x": 3,
"shadow_y": 3
})
Text.set_theme("form", {
"font": RESOURCES.font("heavy", 35),
})
Button.set_default_theme("default")
Button.set_theme(
"default", {
"fg": YELLOW,
"disabled_fg": WHITE,
"shadow": True,
"shadow_x": 3,
"shadow_y": 3,
"bg": BLUE,
"hover_bg": (0, 175, 255),
"active_bg": BLUE,
"outline": 0,
"highlight_color": WHITE,
"highlight_thickness": 1,
"border_bottom_left_radius": 45,
"border_top_right_radius": 45,
"x_add_size": 150,
"offset": (0, -5),
"hover_offset": (-10, 0),
"active_offset": (0, 10),
})
Button.set_theme("title", {
"font": RESOURCES.font("heavy", 70),
"y_add_size": -50
})
Button.set_theme("option", {
"font": RESOURCES.font("heavy", 40),
"y_add_size": -20
})
Button.set_theme("section", {
"bg": BLUE_DARK,
"active_bg": BLUE_DARK,
"disabled_bg": GRAY_LIGHT
})
Entry.set_default_theme("default")
Entry.set_theme(
"default", {
"width": 12,
"font": RESOURCES.font("afterglow", 25),
"highlight_color": BLACK,
"highlight_thickness": 3
})
gameplay = FourInARowGameplay(self)
ai_level_selector = AILevelSelectorSection(self, gameplay)
local_playing = LocalPlayingSection(self, gameplay)
lan_playing_server = LANPlayingP1(self, gameplay)
lan_playing_client = LANPlayingP2(self, gameplay)
self.buttons = ButtonListVertical(offset=80, justify="right")
self.buttons.add(
Button(self,
"Play against AI",
theme="title",
callback=ai_level_selector.mainloop),
Button(self,
"Multiplayer",
theme="title",
callback=local_playing.mainloop),
Button(self,
"Play as P1 (LAN)",
theme="title",
callback=lan_playing_server.mainloop),
Button(self,
"Play as P2 (LAN)",
theme="title",
callback=lan_playing_client.mainloop),
Button(self, "Quit", theme="title", callback=self.stop),
)
class FourInARowGameplay(Window):
def __init__(self, master: Window):
Window.__init__(self, bg_color=BACKGROUND_COLOR)
self.bind_key(pygame.K_ESCAPE, lambda event: self.stop())
self.master = master
self.logo = Image(RESOURCES.IMG["logo"])
arrow = pygame.transform.flip(RESOURCES.IMG["arrow"], True, False)
self.button_back = ImageButton(self,
img=arrow,
width=100,
callback=self.stop,
active_offset=(0, 5),
highlight_color=YELLOW)
self.grid = FourInARowGrid(self, self.width / 2, self.height * 0.75)
self.__player_turn = 0
self.player_who_start_first = 0
self.player = 0
self.__turn = str()
self.__turn_dict = dict()
self.__score_player = self.__score_enemy = 0
self.__highlight_line_window_callback = None
self.enemy = str()
self.ai = FourInARowAI()
self.text_score = Text()
self.text_player_turn = Text()
self.left_options = ButtonListVertical(offset=50)
self.left_options.add(
Button(self, "Restart", theme="option", callback=self.restart),
Button(self, "Quit game", theme="option", callback=self.quit_game))
self.text_winner = Text()
self.text_drawn_match = Text("Drawn match.")
self.token_players = Grid(self)
for row in range(2):
self.token_players.place(CircleShape(20,
PLAYER_TOKEN_COLOR[row + 1],
outline=2,
outline_color=WHITE),
row,
column=1,
padx=5,
pady=5,
justify="left")
self.enemy_quit_dialog = EnemyQuitGame(self)
def start(self,
enemy: str,
player=1,
player_name=None,
enemy_name=None,
ai_level=None) -> None:
self.player = player
self.enemy = enemy
if enemy == LAN_PLAYER:
player_name = str(player_name)
self.client_socket.send("name", player_name)
result = self.client_socket.wait_for("name")
if result == self.client_socket.QUIT_MESSAGE:
return
enemy_name = str(self.client_socket.get(result))
self.__turn_dict = {
1: {
1: player_name,
2: enemy_name
}[player],
2: {
1: enemy_name,
2: player_name
}[player]
}
else:
player_name = str(player_name) if player_name is not None else "P1"
enemy_name = str(enemy_name) if enemy_name is not None else "P2"
self.__turn_dict = {
1: "You" if self.enemy == AI else player_name,
2: "AI" if self.enemy == AI else enemy_name
}
if self.enemy == AI:
self.ai.level = ai_level
for row, name in enumerate(self.__turn_dict.values()):
self.token_players.place(Text(name + ":"),
row,
column=0,
padx=5,
pady=5,
justify="right")
self.mainloop()
def on_start_loop(self) -> None:
self.grid[0].focus_set()
self.score_player = self.score_enemy = 0
self.player_who_start_first = 0
self.text_winner.hide()
self.restart(init=True)
def on_quit(self) -> None:
self.stop_connection()
def quit_game(self) -> None:
self.stop()
self.master.stop()
def restart(self, init=False) -> None:
if not init:
self.client_socket.send("restart")
self.grid.reset()
self.remove_window_callback(self.__highlight_line_window_callback)
if self.player_who_start_first == 0:
if self.enemy == AI:
self.player_turn = 1
elif self.enemy == LOCAL_PLAYER or (self.enemy == LAN_PLAYER
and self.player == 1):
self.player_turn = random.randint(1, 2)
if self.enemy == LAN_PLAYER:
self.client_socket.send("player_turn",
int(self.player_turn))
elif self.enemy == LAN_PLAYER and self.player == 2:
result = self.client_socket.wait_for("player_turn")
if result == self.client_socket.QUIT_MESSAGE:
self.stop()
return
self.player_turn = self.client_socket.get(result)
elif self.text_winner.is_shown():
self.player_turn = (self.player_who_start_first % 2) + 1
else:
self.player_turn = self.player_who_start_first
self.player_who_start_first = self.player_turn
self.text_winner.hide()
self.text_drawn_match.hide()
def place_objects(self) -> None:
self.logo.move(centerx=self.centerx, top=10)
self.grid.midbottom = self.midbottom
self.text_score.move(left=10, top=self.grid.top)
self.text_player_turn.move(left=self.text_score.left,
top=self.text_score.bottom + 50)
self.left_options.move(centerx=(self.left + self.grid.left) // 2,
top=self.text_player_turn.bottom + 50)
self.text_winner.center = ((self.grid.right + self.right) // 2,
self.grid.centery)
self.token_players.move(centerx=self.text_winner.centerx,
top=self.grid.top)
self.text_drawn_match.center = self.text_winner.center
def set_grid(self) -> None:
self.grid.set_obj_on_side(on_top=self.button_back,
on_left=self.left_options[0])
self.button_back.set_obj_on_side(on_bottom=self.left_options[0],
on_right=self.grid[0])
self.left_options.set_obj_on_side(on_top=self.button_back,
on_right=self.grid[0])
@property
def player_turn(self) -> int:
return self.__player_turn
@player_turn.setter
def player_turn(self, player: int) -> None:
self.__player_turn = player
self.__turn = turn = self.__turn_dict[player]
self.text_player_turn.message = f"Player turn:\n{turn}"
self.place_objects()
if self.enemy != LOCAL_PLAYER:
for column in filter(lambda column: not column.full(),
self.grid.columns):
column.set_enabled(self.player_turn == self.player)
if self.enemy == AI and self.player_turn == 2:
self.after(500, self.play, self.ai.play(self.grid.map))
@property
def score_player(self) -> int:
return self.__score_player
@score_player.setter
def score_player(self, value: int) -> None:
self.__score_player = value
self.__update_text_score()
@property
def score_enemy(self) -> int:
return self.__score_enemy
@score_enemy.setter
def score_enemy(self, value: int) -> None:
self.__score_enemy = value
self.__update_text_score()
def __update_text_score(self) -> None:
self.text_score.message = "Score:\n{you}: {score_1}\n{enemy}: {score_2}".format(
you=self.__turn_dict[1],
enemy=self.__turn_dict[2],
score_1=self.score_player,
score_2=self.score_enemy)
self.place_objects()
def update(self) -> None:
if self.enemy == LAN_PLAYER:
if self.client_socket.recv("column"):
self.play(self.client_socket.get("column"))
if self.client_socket.recv("restart"):
self.restart()
if self.client_socket.recv(self.client_socket.QUIT_MESSAGE):
self.enemy_quit_dialog.text.message = "{}\nhas left the game".format(
self.__turn_dict[(self.player % 2) + 1])
self.enemy_quit_dialog.mainloop()
def play(self, column: int) -> None:
self.block_only_event([
pygame.KEYDOWN, pygame.KEYUP, pygame.JOYBUTTONDOWN,
pygame.JOYBUTTONUP, pygame.MOUSEBUTTONDOWN, pygame.MOUSEBUTTONUP
])
if self.enemy == LAN_PLAYER and self.player_turn == self.player:
self.client_socket.send("column", column)
self.grid.play(self.player_turn, column)
line = self.check_victory()
if line:
for c in self.grid.columns:
c.disable()
self.left_options[0].focus_set()
self.update_winner()
self.highlight_line(line)
elif self.grid.full():
self.left_options[0].focus_set()
self.text_drawn_match.show()
else:
self.player_turn = (self.player_turn % 2) + 1
if self.enemy == LOCAL_PLAYER:
self.draw_and_refresh()
pygame.time.wait(500)
self.clear_all_events()
self.allow_all_events()
def check_victory(self) -> list[tuple[int, int]]:
grid = self.grid.map
grid_pos_getter = [
lambda row, col, index: (row, col + index), # Check row (->)
lambda row, col, index: (row, col - index), # Check row (<-)
lambda row, col, index: (row + index, col), # Check column
lambda row, col, index:
(row + index, col - index), # Check diagonal (/)
lambda row, col, index:
(row + index, col + index), # Check diagonal (\)
]
all_box_pos = list()
box_pos = list()
for row, column in filter(lambda pos: grid[pos] != 0, grid):
for grid_pos in grid_pos_getter:
index = 0
box_pos.clear()
while grid.get(grid_pos(row, column, index),
-1) == grid[row, column]:
box_pos.append(grid_pos(row, column, index))
index += 1
if len(box_pos) >= 4:
all_box_pos.extend(
filter(lambda pos: pos not in all_box_pos, box_pos))
return all_box_pos
def highlight_line(self, line: list[tuple[int, int]], highlight=True):
for row, col in line:
box = self.grid.columns[col].boxes[row]
if highlight:
box.circle.color = GREEN
else:
box.value = box.value
self.__highlight_line_window_callback = self.after(
500, self.highlight_line, line=line, highlight=not highlight)
def update_winner(self):
if self.player_turn == 1:
self.score_player += 1
else:
self.score_enemy += 1
winner = self.__turn
self.text_winner.message = f"Winner:\n{winner}"
self.text_winner.show()
def __init__(self):
super().__init__(title=f"Py-Game-Case - v{__version__}", size=(1280, 720), flags=pygame.RESIZABLE, bg_color=(0, 0, 100), resources=RESOURCES)
TitleButton.set_default_theme("default")
TitleButton.set_theme("default", {
"font": ("calibri", 30),
"bg": TRANSPARENT,
"fg": WHITE,
"outline": 0,
"hover_bg": set_color_alpha(WHITE, 100),
"active_bg": set_color_alpha(WHITE, 50),
"highlight_color": WHITE,
"highlight_thickness": 3,
"x_size": self.w * 0.25,
"y_add_size": 30,
"justify": ("left", "center"),
"offset": (10, 0),
"hover_offset": (0, -5),
"active_offset": (0, 10)
})
SettingsButton.set_default_theme("default")
SettingsButton.set_theme("default", {
"bg": WHITE,
"hover_bg": YELLOW,
"active_bg": change_brightness(YELLOW, -75),
"outline": 7,
"outline_color": WHITE,
"highlight_thickness": 0
})
self.launcher_updater = Updater(__version__)
self.image_game_preview = SpriteDict()
self.bg = DrawableListHorizontal()
left_color = BLACK
right_color = set_color_alpha(BLACK, 60)
self.bg.add(
RectangleShape(self.w * 0.25, self.h, left_color),
HorizontalGradientShape(self.w * 0.5, self.h, left_color, right_color),
RectangleShape(self.w * 0.25, self.h, right_color),
)
self.logo = Image(RESOURCES.IMG["logo"], width=self.bg[0].width)
self.buttons_game_launch = ButtonListVertical(offset=30)
self.buttons_game_dict = dict[str, TitleButton]()
self.window_game_dict = dict[str, MainWindow]()
for game_id, game_infos in GAMES.items():
button = TitleButton(
self, lambda game_id=game_id: self.show_preview(game_id), text=game_infos["name"],
callback=lambda game_id=game_id: self.launch_game(game_id)
)
self.image_game_preview[game_id] = Sprite(RESOURCES.IMG[game_id], height=self.height)
self.buttons_game_dict[game_id] = button
self.buttons_game_launch.add_multiple(self.buttons_game_dict.values())
self.game_id = None
self.game_launched_processes = GameProcessList()
self.settings_section = SettingsWindow(self)
self.updater_window = UpdaterWindow(self, self.launcher_updater)
self.side_board = SideBoard(self)
self.side_board.add_option("Settings", self.settings_section.mainloop)
if psutil.WINDOWS:
self.side_board.add_option("Update", lambda: self.updater_window.start(install=True))
self.button_settings = SettingsButton(self, size=40, callback=self.side_board.mainloop)
self.button_settings.force_use_highlight_thickness(True)
self.transition = GameLaunchTransition()
class PyGameCase(MainWindow):
RUNNING_STATE_SUFFIX = " - Running"
def __init__(self):
super().__init__(title=f"Py-Game-Case - v{__version__}", size=(1280, 720), flags=pygame.RESIZABLE, bg_color=(0, 0, 100), resources=RESOURCES)
TitleButton.set_default_theme("default")
TitleButton.set_theme("default", {
"font": ("calibri", 30),
"bg": TRANSPARENT,
"fg": WHITE,
"outline": 0,
"hover_bg": set_color_alpha(WHITE, 100),
"active_bg": set_color_alpha(WHITE, 50),
"highlight_color": WHITE,
"highlight_thickness": 3,
"x_size": self.w * 0.25,
"y_add_size": 30,
"justify": ("left", "center"),
"offset": (10, 0),
"hover_offset": (0, -5),
"active_offset": (0, 10)
})
SettingsButton.set_default_theme("default")
SettingsButton.set_theme("default", {
"bg": WHITE,
"hover_bg": YELLOW,
"active_bg": change_brightness(YELLOW, -75),
"outline": 7,
"outline_color": WHITE,
"highlight_thickness": 0
})
self.launcher_updater = Updater(__version__)
self.image_game_preview = SpriteDict()
self.bg = DrawableListHorizontal()
left_color = BLACK
right_color = set_color_alpha(BLACK, 60)
self.bg.add(
RectangleShape(self.w * 0.25, self.h, left_color),
HorizontalGradientShape(self.w * 0.5, self.h, left_color, right_color),
RectangleShape(self.w * 0.25, self.h, right_color),
)
self.logo = Image(RESOURCES.IMG["logo"], width=self.bg[0].width)
self.buttons_game_launch = ButtonListVertical(offset=30)
self.buttons_game_dict = dict[str, TitleButton]()
self.window_game_dict = dict[str, MainWindow]()
for game_id, game_infos in GAMES.items():
button = TitleButton(
self, lambda game_id=game_id: self.show_preview(game_id), text=game_infos["name"],
callback=lambda game_id=game_id: self.launch_game(game_id)
)
self.image_game_preview[game_id] = Sprite(RESOURCES.IMG[game_id], height=self.height)
self.buttons_game_dict[game_id] = button
self.buttons_game_launch.add_multiple(self.buttons_game_dict.values())
self.game_id = None
self.game_launched_processes = GameProcessList()
self.settings_section = SettingsWindow(self)
self.updater_window = UpdaterWindow(self, self.launcher_updater)
self.side_board = SideBoard(self)
self.side_board.add_option("Settings", self.settings_section.mainloop)
if psutil.WINDOWS:
self.side_board.add_option("Update", lambda: self.updater_window.start(install=True))
self.button_settings = SettingsButton(self, size=40, callback=self.side_board.mainloop)
self.button_settings.force_use_highlight_thickness(True)
self.transition = GameLaunchTransition()
def place_objects(self) -> None:
self.bg.center = self.center
self.logo.move(left=10, top=10)
self.buttons_game_launch.move(left=10, top=self.logo.bottom + 50)
self.image_game_preview.midright = self.midleft
self.button_settings.move(right=self.right - 20, top=20)
def set_grid(self) -> None:
self.button_settings.set_obj_on_side(on_bottom=self.buttons_game_launch[0], on_left=self.buttons_game_launch[0])
self.buttons_game_launch.set_obj_on_side(on_top=self.button_settings, on_right=self.button_settings)
def on_start_loop(self):
self.image_game_preview.move(right=self.left, top=self.top)
save_objects_center = list()
for obj in [self.logo, *self.buttons_game_dict.values(), self.button_settings]:
save_objects_center.append((obj, obj.get_move()))
self.buttons_game_launch.right = self.left
self.button_settings.left = self.right
default_logo_width = self.logo.width
self.logo.load(RESOURCES.IMG["logo"])
self.logo.midtop = self.midbottom
if psutil.WINDOWS:
if self.launcher_updater.has_a_downloaded_update() or (SETTINGS.auto_check_update and self.launcher_updater.has_a_new_release()):
self.logo.animate_move(self, speed=20, top=0, centerx=self.centerx)
self.updater_window.start()
self.logo.animate_move(self, speed=20, midbottom=self.center)
loading = ProgressBar(
default_logo_width, 40, TRANSPARENT, GREEN,
from_=0, to=len(GAMES), default=len(self.window_game_dict),
outline_color=WHITE, border_radius=10
)
loading.center = self.logo.center
loading.show_percent(ProgressBar.S_INSIDE, font=("calibri", 30), color=WHITE)
self.objects.add(loading)
self.objects.set_priority(loading, 0, relative_to=self.logo)
loading.animate_move(self, speed=10, centerx=loading.centerx, top=self.logo.bottom + 20)
try:
for game_id, game_infos in filter(lambda item: item[0] not in self.window_game_dict, GAMES.items()):
with ThemeNamespace(game_id):
self.window_game_dict[game_id] = game_infos["window"]()
loading.value = len(self.window_game_dict)
self.draw_and_refresh(pump=True)
except:
sys.excepthook(*sys.exc_info())
self.stop(force=True)
pygame.time.wait(100)
loading.animate_move(self, speed=10, center=self.logo.center)
self.objects.remove(loading)
self.logo.animation.rotate(angle=360, offset=5, point="center").scale_width(width=default_logo_width, offset=7).start(self)
for obj, move in save_objects_center:
obj.animate_move(self, speed=20, **move)
self.focus_mode(Button.MODE_KEY)
pygame.event.clear()
def on_quit(self) -> None:
self.launcher_updater.close()
def update(self) -> None:
if self.game_launched_processes:
for process in self.game_launched_processes.check_for_terminated_games():
self.buttons_game_dict[process.game_id].text = GAMES[process.game_id]["name"]
self.buttons_game_dict[process.game_id].state = Button.NORMAL
# if not self.game_launched_processes and not pygame.display.get_active():
# pass
if all(not button.has_focus() and not button.hover for button in self.buttons_game_launch) and self.game_id is not None:
self.image_game_preview.animate_move_in_background(self, speed=75, right=self.left)
self.game_id = None
def show_preview(self, game_id: str) -> None:
if self.game_id == game_id:
return
self.game_id = game_id
self.image_game_preview.animate_move_in_background(self, speed=75, right=self.left, after_animation=self.__show_preview)
def __show_preview(self) -> None:
self.image_game_preview.use_sprite(self.game_id)
self.image_game_preview.animate_move_in_background(self, speed=75, right=self.right)
def launch_game(self, game_id: str) -> None:
if not SETTINGS.launch_in_same_window:
self.game_launched_processes.launch(game_id)
self.buttons_game_dict[game_id].text += PyGameCase.RUNNING_STATE_SUFFIX
self.buttons_game_dict[game_id].state = Button.DISABLED
self.iconify()
else:
self.game_id = game_id
if self.image_game_preview.get_actual_sprite_name() != game_id:
self.image_game_preview.animate_move(self, speed=75, right=self.left)
self.image_game_preview.use_sprite(game_id)
self.image_game_preview.animate_move(self, speed=75, right=self.right)
window = self.window_game_dict[game_id]
window.mainloop(transition=self.transition)
def close(self) -> None:
if self.game_launched_processes:
self.iconify()
else:
self.stop(force=True)