class ChampionViewer(TextButton):
def __init__(self, master, assembly_file: str, *args, **kwargs):
TextButton.__init__(self, master, *args, **kwargs, command=self.select)
self.file = assembly_file
self.master = master
self.comment = get_champion_comment(assembly_file)
self.selected = False
self.select_img = Image(IMG["valide"])
self.select_img.hide()
master.add(self.select_img)
def hide_all(self):
self.hide()
self.select_img.hide()
def update(self, *args, **kwargs):
self.select_img.move(left=self.right + 10, centery=self.centery)
def select(self):
self.selected = not self.selected
if self.selected:
if len(self.master.selected) >= MAX_NB_PLAYERS:
self.selected = False
return
self.select_img.show()
self.master.selected.append(self)
else:
self.select_img.hide()
try:
self.master.selected.remove(self)
except ValueError:
pass
def update_file(self, new_file: str, new_name: str):
self.file = new_file
self.set_text(new_name)
self.comment = get_champion_comment(new_file)
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()
class Gameplay(Window):
def __init__(self, car_id: int, env: str):
Window.__init__(self,
bg_color=ENVIRONMENT[env],
bg_music=RESOURCES.MUSIC["gameplay"])
self.bind_key(pygame.K_ESCAPE, lambda event: self.pause())
self.bind_joystick(0, "START", lambda event: self.pause())
font = RESOURCES.FONT["cooperblack"]
# Demaraction lines
self.road = DrawableListVertical(bg_color=GRAY, offset=70)
self.white_bands = list()
white_bands_width = 50 #px
white_lines_height = 10 #px
for i in range(5):
if i % 2 == 0:
self.road.add(
RectangleShape(self.width, white_lines_height, WHITE))
else:
white_bands = DrawableListHorizontal(offset=20)
while white_bands.width < self.width:
white_bands.add(
RectangleShape(white_bands_width, white_lines_height,
WHITE))
self.road.add(white_bands)
self.white_bands.append(white_bands)
# Environment
self.env_top = DrawableListHorizontal(offset=400)
self.env_bottom = DrawableListHorizontal(offset=400)
while self.env_top.width < self.width:
self.env_top.add(Image(RESOURCES.IMG[env], height=110))
while self.env_bottom.width < self.width:
self.env_bottom.add(Image(RESOURCES.IMG[env], height=110))
#Infos
params_for_infos = {
"font": (font, 45),
"color": YELLOW,
"shadow": True,
"shadow_x": 3,
"shadow_y": 3
}
self.infos_score = Info("Score", round_n=0, **params_for_infos)
self.infos_speed = Info("Speed",
extension="km/h",
**params_for_infos,
justify="right")
self.infos_distance = Info("Distance",
round_n=2,
extension="km",
**params_for_infos,
justify="right")
self.infos_time_100 = Info("High speed", **params_for_infos)
self.infos_time_opposite = Info("Opposite side", **params_for_infos)
self.clock_time_100 = Clock()
self.clock_time_opposite = Clock()
self.total_time_100 = self.total_time_opposite = 0
self.car = PlayerCar(car_id)
self.speed = 0
self.traffic = TrafficCarList(nb_ways=4, max_nb_car=6)
self.clock_traffic = Clock()
self.img_crash = Image(RESOURCES.IMG["crash"], size=150)
self.count_down = CountDown(self,
3,
font=(font, 90),
color=YELLOW,
shadow=True,
shadow_x=5,
shadow_y=5)
self.last_car_way = 0
# Background
self.background = DrawableList(draw=False)
self.background.add(self.env_top, self.env_bottom, *self.white_bands,
self.traffic)
# Default values
self.update_clock = Clock()
self.update_time = 15 #ms
self.pixel_per_sec = 6 # For 1km/h
self.pixel_per_ms = self.pixel_per_sec * self.update_time / 1000
self.paused = False
self.go_to_garage = self.restart = False
self.crashed_car = None
self.disable_key_joy_focus()
self.init_game()
def pause(self):
if not self.count_down.is_shown():
self.paused = True
self.car.stop_animation()
for car in self.traffic:
car.stop_animation()
pause = Pause(self)
pause.mainloop()
if self.loop and not self.count_down.is_shown():
self.count_down.start(at_end=self.return_to_game)
self.objects.set_priority(self.count_down, self.objects.end)
def return_to_game(self):
self.paused = False
self.car.restart_animation()
for car in self.traffic:
car.restart_animation()
self.clock_traffic.tick()
self.clock_time_100.tick()
self.clock_time_opposite.tick()
self.update_clock.tick()
def init_game(self):
self.go_to_garage = False
self.paused = False
self.crashed_car = None
for info in (self.infos_speed, self.infos_score, self.infos_distance,
self.infos_time_100, self.infos_time_opposite):
info.value = 0
if info in (self.infos_time_100, self.infos_time_opposite):
info.hide()
self.total_time_100 = self.total_time_opposite = 0
self.count_down.start()
self.img_crash.hide()
def place_objects(self):
self.count_down.center = self.road.center = self.center
self.infos_score.move(topleft=(10, 10))
self.infos_speed.move(right=self.right - 10, top=10)
self.infos_distance.move(right=self.right - 10,
bottom=self.road.top - 10)
self.infos_time_100.move(left=10, bottom=self.road.top - 10)
self.infos_time_opposite.move(left=10, top=self.road.bottom + 10)
self.car.move(centery=self.road.centery, left=50)
self.env_top.move(centerx=self.centerx,
centery=(self.top + self.road[0].top) / 2)
self.env_bottom.move(centerx=self.centerx,
centery=(self.road[-1].bottom + self.bottom) / 2)
def update(self):
if self.paused:
return
self.update_player_car()
if self.update_clock.elapsed_time(self.update_time):
self.update_infos()
self.update_background()
self.update_traffic()
self.rect_to_update = (self.road.rect, self.env_top.rect,
self.env_bottom.rect, self.infos_score.rect,
self.infos_speed.rect,
self.infos_distance.rect,
self.infos_time_100.rect,
self.infos_time_opposite.rect)
def update_player_car(self):
if not self.count_down.is_shown():
joystick = self.joystick[0]
controls = SAVE["controls"]
car_handling = (
(controls["speed_up"], self.car.speed_up),
(controls["brake"], self.car.brake),
(controls["up"], self.car.moveUp),
(controls["down"], self.car.moveDown),
)
for control, car_function in car_handling:
car_function(self.keyboard.is_pressed(control["key"]))
car_function(joystick.get_value(control["joy"]))
if SAVE["auto_acceleration"] is True:
self.car.speed_up()
self.car.update(self.pixel_per_ms)
if self.car.top < self.road[0].bottom + 5:
self.car.top = self.road[0].bottom + 5
elif self.car.bottom > self.road[-1].top - 5:
self.car.bottom = self.road[-1].top - 5
if not self.car.is_crashed():
self.speed = self.car.speed
for car in self.traffic:
collision = pygame.sprite.collide_mask(self.car, car)
if collision:
self.car.crash(car)
self.crashed_car = car
self.play_sound(RESOURCES.SFX["crash"])
self.img_crash.show()
self.img_crash.move(centerx=collision[0] + self.car.left,
centery=collision[1] + self.car.top)
self.objects.set_priority(self.img_crash, self.objects.end)
elif self.car.right <= 0 and self.crashed_car.right <= 0:
self.end_game()
def car_in_opposite_side(self) -> bool:
return bool(self.car.bottom < self.road.centery)
def update_infos(self):
min_speed = 30
score_to_add = (self.car.speed - min_speed) / 5
bonus = False
if self.car.speed > 30 and self.car_in_opposite_side():
self.infos_time_opposite.show()
self.infos_time_opposite.value = self.clock_time_opposite.get_elapsed_time(
) / 1000
score_to_add += 120
bonus = True
else:
self.total_time_opposite += self.infos_time_opposite.value
self.infos_time_opposite.value = 0
self.clock_time_opposite.restart()
self.infos_time_opposite.hide()
if self.car.speed >= 100:
self.infos_time_100.show()
self.infos_time_100.value = self.clock_time_100.get_elapsed_time(
) / 1000
score_to_add += 150
bonus = True
else:
self.total_time_100 += self.infos_time_100.value
self.infos_time_100.value = 0
self.clock_time_100.restart()
self.infos_time_100.hide()
if bonus:
self.infos_score.color = GREEN_DARK
self.infos_score.shadow_color = YELLOW
else:
self.infos_score.color = YELLOW
self.infos_score.shadow_color = BLACK
self.infos_score.value += score_to_add * self.update_time / 1000
self.infos_speed.value = self.car.speed
self.infos_distance.value += self.car.speed * self.pixel_per_ms / (
1000 * 3.6)
def update_background(self):
offset = self.speed * self.pixel_per_ms
self.background.move_ip(-offset, 0)
for white_bands_list in self.white_bands:
if white_bands_list[0].right <= 0:
white_bands_list.remove_from_index(0)
if white_bands_list[-1].right < self.right:
white_bands_list.add(
RectangleShape(*white_bands_list[-1].size, WHITE))
for env in (self.env_top, self.env_bottom):
img = env[0]
if img.right <= 0:
img.move(left=env[-1].right + env.offset)
env.set_priority(img, env.end)
if self.img_crash.is_shown():
self.img_crash.move_ip(-offset, 0)
def update_traffic(self):
for car in self.traffic.drawable:
car.update(self.pixel_per_ms)
if car.right < 0:
self.traffic.remove(car)
for way, car_list in enumerate(self.traffic.ways, 1):
for i in range(1, len(car_list)):
car_1 = car_list[i - 1]
car_2 = car_list[i]
if car_2.left - car_1.right < 20:
if (way in [1, 2]) and (car_1.speed < car_2.speed):
car_2.speed = car_1.speed
elif (way in [3, 4]) and (car_1.speed > car_2.speed):
car_1.speed = car_2.speed
ratio = (2 - (round(self.infos_score.value) / 20000)) * 1000
if self.car.speed > 30 and self.clock_traffic.elapsed_time(ratio):
if self.traffic.empty(
) or self.traffic.last.right < self.right - 20:
self.traffic.add_cars(self, self.road,
round(self.infos_score.value))
def end_game(self):
for car in self.traffic:
car.stop_animation()
self.crashed_car = None
score = round(self.infos_score.value)
distance = round(self.infos_distance.value, 1)
time_100 = round(self.total_time_100, 1)
time_opposite = round(self.total_time_opposite, 1)
window = EndGame(self, score, distance, time_100, time_opposite)
window.mainloop()
if self.restart:
self.traffic.clear()
self.car.move(left=50, centery=self.road.centery)
self.car.restart()
self.init_game()
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)
class EndGame(Window):
def __init__(self, master, score: int, distance: float, time_100: float,
time_opposite: float):
Window.__init__(self, master=master, bg_music=master.bg_music)
self.master = master
self.bg = RectangleShape(*self.size, (0, 0, 0, 170))
self.text_score = Text(f"Your score\n{score}",
(RESOURCES.FONT["algerian"], 90),
YELLOW,
justify="center")
self.img_highscore = Image(RESOURCES.IMG["new_high_score"], width=150)
if score > SAVE["highscore"]:
SAVE["highscore"] = score
else:
self.img_highscore.hide()
MAX_MONEY = pow(10, 9) - 1
money_distance = round(300.40 * distance)
money_time_100 = round(12.5 * time_100)
money_time_opposite = round(21.7 * time_opposite)
money_gained = money_distance + money_time_100 + money_time_opposite
total = SAVE["money"] + money_gained
SAVE["money"] = MAX_MONEY if total > MAX_MONEY else total
self.text_money = Text(format_number(SAVE["money"]),
(RESOURCES.FONT["algerian"], 50),
YELLOW,
img=Image(RESOURCES.IMG["piece"], height=40),
compound="right")
font = ("calibri", 50)
self.frame = RectangleShape(0.75 * self.width,
0.45 * self.height,
BLACK,
outline=1,
outline_color=WHITE)
self.text_distance = Text(f"Distance: {distance}", font, WHITE)
self.img_green_arrow_distance = Image(RESOURCES.IMG["green_arrow"],
height=40)
self.text_money_distance = Text(money_distance,
font,
WHITE,
img=Image(RESOURCES.IMG["piece"],
height=40),
compound="right")
self.text_time_100 = Text(f"Time up to 100: {time_100}", font, WHITE)
self.img_green_arrow_time_100 = Image(RESOURCES.IMG["green_arrow"],
height=40)
self.text_money_time_100 = Text(money_time_100,
font,
WHITE,
img=Image(RESOURCES.IMG["piece"],
height=40),
compound="right")
self.text_time_opposite = Text(
f"Time in opposite side: {time_opposite}", font, WHITE)
self.img_green_arrow_time_opposite = Image(
RESOURCES.IMG["green_arrow"], height=40)
self.text_money_time_opposite = Text(money_time_opposite,
font,
WHITE,
img=Image(RESOURCES.IMG["piece"],
height=40),
compound="right")
self.total_money = DrawableListHorizontal(offset=10)
self.total_money.add(
Text("TOTAL: ", font, WHITE),
Text(money_gained,
font,
WHITE,
img=Image(RESOURCES.IMG["piece"], height=40),
compound="right"))
params_for_all_buttons = {
"font": (RESOURCES.FONT["algerian"], 50),
"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 = ButtonListHorizontal(offset=30)
self.menu_buttons.add(
Button(self,
"Restart",
**params_for_all_buttons,
callback=self.restart_game),
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 place_objects(self):
self.text_money.move(top=5, right=self.right - 10)
self.text_score.move(centerx=self.centerx,
centery=self.top + 0.25 * self.height)
self.img_highscore.move(left=self.text_score.right,
centery=self.text_score.centery)
offset = self.frame.height / 6
self.frame.move(centerx=self.centerx, top=0.75 * self.centery)
self.text_distance.move(left=self.frame.left + 5,
top=self.frame.top + 10)
self.text_time_100.move(left=self.frame.left + 5,
top=self.text_distance.bottom + offset)
self.text_time_opposite.move(left=self.frame.left + 5,
top=self.text_time_100.bottom + offset)
self.img_green_arrow_distance.move(left=self.frame.centerx + 75,
centery=self.text_distance.centery)
self.img_green_arrow_time_100.move(left=self.frame.centerx + 75,
centery=self.text_time_100.centery)
self.img_green_arrow_time_opposite.move(
left=self.frame.centerx + 75,
centery=self.text_time_opposite.centery)
self.text_money_distance.move(
left=self.img_green_arrow_distance.right + 20,
centery=self.text_distance.centery)
self.text_money_time_100.move(
left=self.img_green_arrow_time_100.right + 20,
centery=self.text_time_100.centery)
self.text_money_time_opposite.move(
left=self.img_green_arrow_time_opposite.right + 20,
centery=self.text_time_opposite.centery)
self.total_money.move(centerx=self.frame.centerx,
bottom=self.frame.bottom - 10)
self.menu_buttons.move(centerx=self.centerx, bottom=self.bottom - 50)
def restart_game(self):
self.master.restart = True
self.stop()
def return_to_garage(self):
self.master.go_to_garage = True
self.master.stop()
self.stop()
def return_to_menu(self):
self.master.stop()
self.stop()