class ScoreBoard(object):
def __init__(self, names, screen, event_manager):
self.names = names
self.screen = screen
self.background = pygame.Surface((SCREEN_WIDTH, CONTROLS_HEIGHT))
self.rect = self.background.get_rect()
self.rect.topleft = (0, BOARD_HEIGHT)
self.leaderboard = LeaderBoard()
self.scores = [0, 0]
def update(self, winner):
self.scores[winner] += 1
self.render()
def render(self):
self.background.fill(ORANGE)
for number in xrange(2):
self.background.blit(
NORMAL.render(str(self.scores[number]), True, WHITE),
(HALF_WIDTH * (number + 1) - HALF_BORDER - 40, HALF_BORDER))
self.background.blit(
NORMAL.render(self.names[number], True, WHITE),
(HALF_WIDTH * number + HALF_BORDER, HALF_BORDER))
self.screen.blit(self.background, self.rect)
pygame.display.update(self.rect)
def store_result(self):
for index in range(2):
self.leaderboard.store_match_result(
self.names[index], self.scores[index] - self.scores[index ^ 1])
def __init__(self, names, screen, event_manager):
self.names = names
self.screen = screen
self.background = pygame.Surface((SCREEN_WIDTH, CONTROLS_HEIGHT))
self.rect = self.background.get_rect()
self.rect.topleft = (0, BOARD_HEIGHT)
self.leaderboard = LeaderBoard()
self.scores = [0, 0]
def __init__(self, mode=2, width=16, height=16, mines_count=40):
super().__init__(width, height)
self.lb = LeaderBoard(
"minesweeper", {
"Nick": str,
"Time Spent": datetime.time,
"Playing date": datetime.datetime,
"Mode": str
})
self.lost = False
self.not_win = True
self.warning = False
self.cheat_mode = False
# cheat_mode позволяет смотреть расположение мин. Удобно для тестирования и обучения игре в сапер
self.mode = mode
# установка режима игры. Параметр mode устанавливает пользователь при запуске, на стартовом экране
if self.mode == 2:
self.width = width
self.height = height
self.mines_count = mines_count
elif self.mode == 1:
self.width = 9
self.height = 9
self.mines_count = 10
Minesweeper.set_view(self, 10, 10, 50)
elif self.mode == 3:
self.width = 9
self.height = 9
self.mines_count = 10
self.cheat_mode = True
Minesweeper.set_view(self, 10, 10, 50)
elif self.mode == 4:
self.width = width
self.height = height
self.mines_count = mines_count
self.cheat_mode = True
Minesweeper.set_view(self, 10, 10, 25)
self.tagged_mines = 0
self.board = [[-1] * width for _ in range(height)]
# Генерация мин. Ищет местоположение для мин, пока не установит все
i = 0
while i < self.mines_count:
x = randrange(self.width)
y = randrange(self.height)
if self.board[y][x] != 10:
self.board[y][x] = 10
i += 1
# значения по умолчанию
self.left = 10
self.top = 10
self.cell_size = 30
self.size_x = self.width * self.cell_size + self.left
self.size_y = self.height * self.cell_size + self.top
def main(self) -> None:
"""Run the game. The loop continues until
either the snake hits the wall or eats his tail.
"""
# Initialize pygame, generate screen and field
self._set_player_name()
self._leaderboard = LeaderBoard(self.player)
self._screen = self._init_screen()
pygame.init()
clock = pygame.time.Clock()
fps = 5
while True:
self._handle_screen(self._screen)
pygame.display.update()
clock.tick(fps)
def __init__(self, screen, event_manager):
super(LeaderBoardPage, self).__init__(screen, CORNSILK, event_manager)
header = LARGE.render("Leaderboard", True, ORANGE)
header_rect = header.get_rect()
header_rect.midtop = (HALF_WIDTH, 20)
heading = SMALL.render(
"Rank | Name | Matches Played | Wins | Losses | Point Difference | Win Percentage",
True, ORANGE)
heading_rect = heading.get_rect()
heading_rect.midtop = (HALF_WIDTH, 150)
self.texts.extend([(header, header_rect), (heading, heading_rect)])
self.leaderboard = LeaderBoard()
class LeaderBoardPage(Page):
def __init__(self, screen, event_manager):
super(LeaderBoardPage, self).__init__(screen, CORNSILK, event_manager)
header = LARGE.render("Leaderboard", True, ORANGE)
header_rect = header.get_rect()
header_rect.midtop = (HALF_WIDTH, 20)
heading = SMALL.render(
"Rank | Name | Matches Played | Wins | Losses | Point Difference | Win Percentage",
True, ORANGE)
heading_rect = heading.get_rect()
heading_rect.midtop = (HALF_WIDTH, 150)
self.texts.extend([(header, header_rect), (heading, heading_rect)])
self.leaderboard = LeaderBoard()
def display(self):
del self.texts[2:]
TOP = self.texts[1][1].top + 35
format_string = "{rank:>4d} | {name:20s} | {matches_played:>14d} | {wins:>4d} | {losses:>6d} | {point_diff:>16d} | {win_per:>14.2f}"
for index, leader in enumerate(self.leaderboard.get_top_number(10)):
res = SMALL.render(
format_string.format(**dict(
zip(("rank", "name", "matches_played", "wins", "losses",
"point_diff", "win_per"), leader))), True, BLACK)
res_rect = res.get_rect()
res_rect.top = TOP + 35 * index
res_rect.centerx = HALF_WIDTH
self.texts.append((res, res_rect))
super(LeaderBoardPage, self).display()
def __init__(self, screen, radius=30, x=100, y=400):
super().__init__(bird_sprite)
self.radius = radius
self.x = x
self.y = y
self.last_jump_time = time.time()
self.jumped = False
self.image = bird_down
self.rect = bird_down.get_rect()
self.rect.x = self.x
self.rect.y = self.y
self.vy = 3 / FPS * 60
self.screen = screen
self.lb = LeaderBoard("flappybird", {
"Nick": str,
"Playing date": datetime.datetime,
"Score": str
})
def run():
print('starting server...')
if len(sys.argv) != 2:
print("Usage: simple_scorer.py <data.json>", file=sys.stderr)
exit(1)
global lb
with open(sys.argv[1], "rt") as f:
lb = LeaderBoard(f.read())
global tokens
with open("allowed_tokens.txt", "rt") as f:
tokens = {}
for line in f:
tokens[line.strip().lower()] = 10
# Server settings
# Choose port 8080, for port 80, which is normally used for a http server, you need root access
server_address = ('127.0.0.1', 8081)
httpd = HTTPServer(server_address, RequestHandler)
print('running server...')
httpd.serve_forever()
def run_game():
# Initialize pygame, settings and create a screen object
pygame.init()
settings = Settings()
screen = pygame.display.set_mode((settings.screen_x, settings.screen_y))
pygame.display.set_caption("Alien Invasion")
# Make the Play as Guest Button
play_button = Button(settings, screen, "Play as Guest", adj_y=60)
# Create a instance to store game stats and create a scoreboard, leaderboard
stats = GameStats(settings)
sb = Scoreboard(settings, screen, stats)
lb = LeaderBoard(settings, screen)
# Create a ship, alien, and groups to store bullets and alien fleet
ship = Ship(screen, settings)
alien = Alien(settings, screen)
bullets = Group()
aliens = Group()
# Create the fleet of aliens
gf.create_fleet(settings, screen, ship, aliens)
# Load in all time scores
gf.get_top_score(stats, settings)
# Start the main loop for the game
while True:
gf.check_events(settings, stats, screen, sb, lb, ship, aliens, bullets, play_button)
if stats.game_active:
ship.update()
gf.update_bullets(settings, stats, screen, sb, ship, aliens, bullets)
gf.update_aliens(settings, stats, screen, sb, lb, ship, aliens, bullets)
gf.update_screen(settings, stats, screen, sb, lb, ship, aliens, bullets, play_button, True)
class Game:
""" Game class controls the flow of the game.
This class receives inputs from users and pass the inputs to other classes
to update the state of a field.
=== Private Attributes ===
_dim: the dimensions of a game.
_game_over: declares if the game ended to display score view
_field: an instance of a Field class representing a game field.
_in_game: declares if the window displays the game view
_view_leaderboard: declares if the window displays the leaderboard view.
_menu_index: keeps the record of selected_menu.
_screen: the pygame screen onto which the different scenes will display.
_view_title: declares if the window displays the main menu view.
=== Public Attributes ===
player: the player's alias.
leaderboard: a LeaderBoard class instance to store the player's score.
hand: declares handedness of player. 0 for left-handed; 1 for right-handed
"""
# Attributes
_dim: Tuple[int, int]
_in_game: bool
_game_over: bool
_view_leaderboard: bool
_view_title_screen: bool
_menu_index: int
_field: Optional[Field]
_screen: pygame.Surface
player: str
_leaderboard: Optional[LeaderBoard]
hand: int
# Constants
TEXT_COLOR = (50, 50, 50)
TITLE_SCREEN_COLOR = (255, 255, 255)
def __init__(self) -> None:
"""Initializer of game class with player <player_name>.
"""
self._dim = (800, 800)
self._in_game = False
self._game_over = False
self._menu_index = 0
self._field = None
self.player = None
self._view_leaderboard = False
self._view_title = True
self.hand = None
def main(self) -> None:
"""Run the game. The loop continues until
either the snake hits the wall or eats his tail.
"""
# Initialize pygame, generate screen and field
self._set_player_name()
self._leaderboard = LeaderBoard(self.player)
self._screen = self._init_screen()
pygame.init()
clock = pygame.time.Clock()
fps = 5
while True:
self._handle_screen(self._screen)
pygame.display.update()
clock.tick(fps)
# --------------------------------------------------------
# Helper function of main
# --------------------------------------------------------
def _set_player_name(self) -> None:
"""Ask a user to choose their name and controls
they wish to use.
"""
self.player = input("Enter your name \n")
invalid_input = True
while invalid_input:
hand_input = input("If you want to play a game with WASD, press 0, or press 1 to use arrow keys \n")
try:
self.hand = int(hand_input)
if self.hand not in [0, 1]:
print("Invalid input, Please enter 0 or 1.")
else:
invalid_input = False
except ValueError:
print("Invalid input, Please enter 0 or 1.")
def _init_screen(self) -> pygame.Surface:
"""Initialize title screen"""
screen = pygame.display.set_mode(self._dim, pygame.RESIZABLE)
screen.fill(self.TITLE_SCREEN_COLOR)
pygame.display.set_caption("Snake game")
self._menu_index = 0
return screen
def _handle_screen(self, screen: pygame.Surface):
"""Choose which screen to show"""
# if in_leader_board and not in_title and not in_game:
if self._view_title:
self._display_title_screen()
elif self._in_game:
self._run_game(screen)
elif self._game_over:
self._display_score()
else:
self._display_scoreboard()
# --------------------------------------------------------
# Main function to create view
# --------------------------------------------------------
def _display_minimenu(self, title: str, size: int, where: int = None,
show_score: bool = False,
show_leader_board: bool = False) -> None:
"""Displays a screen with <title> and font <size>.
Method also adds main menu options relative to <where>
"""
# Enable exiting game and process user inputs
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.KEYDOWN:
self._handle_key_input(event.key)
elif event.type == pygame.VIDEORESIZE:
self._dim = event.dict['size']
self._screen = pygame.display.set_mode(self._dim, pygame.RESIZABLE)
pygame.display.flip()
else:
pass
# self._screen = pygame.display.set_mode(self._dim, RESIZABLE)
self._screen.fill(self.TITLE_SCREEN_COLOR)
self._create_title(title, size)
self._create_menu_options(where)
if show_score:
margin_x = self._calc_margin_x(150)
self._create_menu_label("Game Over!", (margin_x, 200))
if self._field is None:
results = ""
else:
results = self.player + ": " + str(self._field.get_score())
result_margin = self._calc_margin_x(len(results) * 13)
self._create_menu_label(results, (result_margin, 250))
elif show_leader_board:
self._format_scoreboard()
# --------------------------------------------------------
# Helper function of _display_mini_menu
# --------------------------------------------------------
def _create_menu_label(self, label_text: str,
location: Tuple[int, int]) -> None:
"""Draw menu label from given label text at given location"""
menu_font = pygame.font.SysFont("Arial", 36)
menu_label = menu_font.render(label_text, 1, self.TEXT_COLOR)
self._screen.blit(menu_label, location)
def _draw_menu_selection_arrow(self,
x_location: int,
y_location: int) -> None:
"""Draw menu selection arrow into screen"""
menu_arrow_location = [[x_location, y_location + 2],
[x_location, y_location + 22],
[x_location + 20, y_location + 12]]
pygame.draw.polygon(self._screen, self.TEXT_COLOR, menu_arrow_location)
def _create_title(self, title: str, size: int,):
"""Create title label on the screen"""
title_font = pygame.font.SysFont("monospace", size)
title_label = title_font.render(title, 1, self.TEXT_COLOR)
title_width, title_height = title_label.get_size()
new_location = ((self._dim[0] - title_width) // 2, 50)
self._screen.blit(title_label, new_location)
def _create_menu_options(self, where: Optional[int]) -> None:
"""Create menu options with an arrow showing selected option"""
margin_x = self._calc_margin_x(190) + 35
if where is not None:
self._create_menu_label("Play", (margin_x, where))
self._create_menu_label("Leaderboard", (margin_x, where + 40) )
self._create_menu_label("Quit", (margin_x, where + 80))
self._draw_menu_selection_arrow(margin_x - 35,
[where, where + 40, where + 80][self._menu_index])
else:
self._create_menu_label("Play", (margin_x, 300))
self._create_menu_label("Leaderboard", (margin_x, 340), )
self._create_menu_label("Quit", (margin_x, 380))
self._draw_menu_selection_arrow(margin_x - 35,
[300, 340, 380][self._menu_index])
def _calc_margin_x(self, width: int) -> int:
"""Calculate horizontal margins based on given width"""
margin = (self._screen.get_width() - width) // 2
if margin < 0:
margin *= -1
return margin
def _format_scoreboard(self) -> None:
"""Formats game history to display top 10 scores and players"""
winners = self._leaderboard.get_top_ten()
i, j = 1, 1
for entry in winners:
player, score = entry
margin_x = self._calc_margin_x(700)
self._create_menu_label(player, (margin_x, 100 + j * 40))
self._create_menu_label(score,
(self._screen.get_width() - margin_x - 50,
100 + j * 40))
i += 1
j += 1
# --------------------------------------------------------
# Title Screen
# --------------------------------------------------------
def _display_title_screen(self) -> None:
"""Draw menu option arrow and update view"""
# Clear current view contents
self._display_minimenu("Snake game", 80)
# --------------------------------------------------------
# key_input_handler for title/score
# --------------------------------------------------------
def _handle_key_input(self, key_value: int) -> None:
"""Handle key inputs in title screen"""
if key_value == pygame.K_UP:
self._menu_index -= 1
if self._menu_index < 0:
self._menu_index = 2
elif key_value == pygame.K_DOWN:
self._menu_index += 1
if self._menu_index > 2:
self._menu_index = 0
elif key_value == pygame.K_RETURN:
self._change_view_flags()
def _change_view_flags(self) -> None:
"""Helper function of handle_key_input"""
if self._menu_index == 0: # user chooses to play
self._in_game = True
self._view_leaderboard = False
self._view_title = False
self._game_over = False
self._field = None
elif self._menu_index == 1: # user chooses to view leaderboard
self._in_game = False
self._view_leaderboard = True
self._view_title = False
self._game_over = False
else: # user chooses to exit GUI
pygame.quit()
sys.exit()
# --------------------------------------------------------
# run game
# --------------------------------------------------------
def _run_game(self, screen: pygame.Surface) -> None:
"""Recursively call this method until the game is over.
This method should receive user inputs and update state of a field
"""
key = None
for event in pygame.event.get():
if event.type == pygame.QUIT:
pygame.quit()
sys.exit()
elif event.type == pygame.KEYDOWN:
key = event.key
if self._field is None:
self._field = Field(screen, self.hand)
is_game_over = self._field.display_field(key)
if is_game_over:
self._game_over = True
self._in_game = False
score = self._field.get_score()
self._leaderboard.set_player_score(score)
self._display_score()
def _display_score(self) -> None:
"""Display game instance results"""
self._display_minimenu("Snake game", 80, None, True)
# --------------------------------------------------------
# Leader Board
# --------------------------------------------------------
def _display_scoreboard(self) -> None:
"""Display leaderboard screen with top 10 scores"""
history_size = self._leaderboard.get_history_size()
self._display_minimenu("LEADERBOARD", 54,
history_size * 55, False, True)
class Bird(pygame.sprite.Sprite):
def __init__(self, screen, radius=30, x=100, y=400):
super().__init__(bird_sprite)
self.radius = radius
self.x = x
self.y = y
self.last_jump_time = time.time()
self.jumped = False
self.image = bird_down
self.rect = bird_down.get_rect()
self.rect.x = self.x
self.rect.y = self.y
self.vy = 3 / FPS * 60
self.screen = screen
self.lb = LeaderBoard("flappybird", {
"Nick": str,
"Playing date": datetime.datetime,
"Score": str
})
def update(self, *args):
if IF_PLAYING:
self.rect = self.rect.move(0, self.vy)
self.y += self.vy
if self.jumped:
if time.time() - self.last_jump_time > 0.5:
self.image = bird_down
self.rect = bird_down.get_rect()
self.rect.x = self.x
self.rect.y = self.y
self.jumped = False
self.last_jump_time = time.time()
if args:
if "kill" in args:
self.kill()
if "reset" in args:
self.x = 100
self.y = 400
self.image = bird_down
self.rect = bird_down.get_rect()
self.rect.x = self.x
self.rect.y = self.y
if IF_PLAYING:
self.y -= 50
self.image = bird_up
self.rect = bird_up.get_rect()
self.rect.x = self.x
self.rect.y = self.y
self.jumped = True
if pygame.sprite.spritecollideany(
self, floor_sprite) or pygame.sprite.spritecollideany(
self, pipe_sprites):
global counter
if os.name == "posix":
nick = os.environ.get("USER")
else:
nick = os.environ.get("USERNAME")
self.lb.AddRecord(nick, "datetime('now', '+3 hours')", counter)
pygame.event.post(kill_event)
print("Game over")
class Minesweeper(Board):
def __init__(self, mode=2, width=16, height=16, mines_count=40):
super().__init__(width, height)
self.lb = LeaderBoard(
"minesweeper", {
"Nick": str,
"Time Spent": datetime.time,
"Playing date": datetime.datetime,
"Mode": str
})
self.lost = False
self.not_win = True
self.warning = False
self.cheat_mode = False
# cheat_mode позволяет смотреть расположение мин. Удобно для тестирования и обучения игре в сапер
self.mode = mode
# установка режима игры. Параметр mode устанавливает пользователь при запуске, на стартовом экране
if self.mode == 2:
self.width = width
self.height = height
self.mines_count = mines_count
elif self.mode == 1:
self.width = 9
self.height = 9
self.mines_count = 10
Minesweeper.set_view(self, 10, 10, 50)
elif self.mode == 3:
self.width = 9
self.height = 9
self.mines_count = 10
self.cheat_mode = True
Minesweeper.set_view(self, 10, 10, 50)
elif self.mode == 4:
self.width = width
self.height = height
self.mines_count = mines_count
self.cheat_mode = True
Minesweeper.set_view(self, 10, 10, 25)
self.tagged_mines = 0
self.board = [[-1] * width for _ in range(height)]
# Генерация мин. Ищет местоположение для мин, пока не установит все
i = 0
while i < self.mines_count:
x = randrange(self.width)
y = randrange(self.height)
if self.board[y][x] != 10:
self.board[y][x] = 10
i += 1
# значения по умолчанию
self.left = 10
self.top = 10
self.cell_size = 30
self.size_x = self.width * self.cell_size + self.left
self.size_y = self.height * self.cell_size + self.top
def render(self, place):
all_sprites.update()
self.place = place
cur_y = self.top
if not self.not_win:
render_text(self.place,
pygame,
self.size_x + 30,
150,
f"You win!",
scale=30,
colour=(0, 255, 0))
if self.tagged_mines == self.mines_count and self.not_win:
render_text(self.place,
pygame,
self.size_x + 30,
150,
f"Not all the mines have been marked",
scale=30,
colour=(0, 255, 0))
if not self.lost:
e = int(time.time() - start_time)
render_text(self.place,
pygame,
self.size_x + 30,
50,
f"Mines left: {self.mines_count - self.tagged_mines}",
scale=30,
colour=(0, 255, 0))
render_text(
self.place,
pygame,
self.size_x + 30,
100,
f"Your time: {'{:02d}:{:02d}:{:02d}'.format(e // 3600, (e % 3600 // 60), e % 60)}",
scale=30,
colour=(0, 255, 0))
else:
render_text(self.place,
pygame,
self.size_x + 30,
50,
f"Mines left: {self.result_left_mines}",
scale=30,
colour=(0, 255, 0))
render_text(self.place,
pygame,
self.size_x + 30,
100,
f"Your time: {self.total_time}",
scale=30,
colour=(0, 255, 0))
for i in range(self.height):
cur_x = self.left
for j in range(self.width):
if self.board[i][j] == 10 and self.lost or self.board[i][
j] == 10 and self.cheat_mode:
Tile("empty", cur_x, cur_y, self.cell_size)
Tile("bomb", cur_x, cur_y, self.cell_size)
elif self.lost and type(
self.board[i]
[j]) == list and self.board[i][j][1] == 10:
Tile("marked", cur_x, cur_y, self.cell_size)
Tile("bomb", cur_x, cur_y, self.cell_size)
elif self.board[i][j] in (0, 1, 2, 3, 4, 5, 6, 7, 8):
Tile(str(self.board[i][j]), cur_x, cur_y, self.cell_size)
elif type(self.board[i][j]) == list:
Tile("marked", cur_x, cur_y, self.cell_size)
else:
Tile("empty", cur_x, cur_y, self.cell_size)
pygame.draw.rect(place, (0, 0, 0),
(self.left, self.top, self.size_x - self.left,
self.size_y - self.top), 3)
cur_x += self.cell_size
cur_y += self.cell_size
def restart(self):
self.__init__(self.mode)
Minesweeper.set_view(self, 10, 10, 35)
self.total_time = 0
global start_time
start_time = time.time()
self.lost = False
def is_mine(self, x, y):
if self.board[y][x] == 10:
return True
return False
def get_click(self, mouse_pos):
try:
cell = self.get_cell(mouse_pos)
if cell:
self.open_cell(cell)
except Exception as e:
print("Unknown Error. Write to developers.", e)
# Функция для отмети мин(или не мин, если игрок ошибся). Есть возможность снять отметку мины
def mark_mine(self, mouse_pos):
cell = self.get_cell(mouse_pos)
if cell:
x, y = cell[0], cell[1]
if type(self.board[y]
[x]) != list and self.tagged_mines < self.mines_count:
self.board[y][x] = ["marked", self.board[y][x]]
self.tagged_mines += 1
# print("Marked", cell)
elif type(self.board[y][x]) == list:
self.board[y][x] = self.board[y][x][1]
self.tagged_mines -= 1
def open_cell(self, cell):
x, y = cell[0], cell[1]
counter = 0
if self.board[y][x] == 10:
self.lost = True
e = int(time.time() - start_time)
self.total_time = '{:02d}:{:02d}:{:02d}'.format(
e // 3600, (e % 3600 // 60), e % 60)
self.result_left_mines = self.mines_count - self.tagged_mines
print("YOU LOST")
# Алгоритм для автоматического открытия "безопастных" клеток
if self.board[y][x] == -1:
for y_edge in range(-1, 2):
for x_edge in range(-1, 2):
if x + x_edge < 0 or x + x_edge >= self.width or y + y_edge < 0 or y + y_edge >= self.height:
continue
if self.board[y + y_edge][x + x_edge] == 10:
counter += 1
elif type(self.board[y + y_edge][x + x_edge]) == list and \
self.board[y + y_edge][x + x_edge][1] == 10:
counter += 1
self.board[y][x] = counter
if self.board[y][x] == 0:
for y_edge in range(-1, 2):
for x_edge in range(-1, 2):
if x + x_edge < 0 or x + x_edge >= self.width or y + y_edge < 0 or y + y_edge >= self.height:
continue
if self.board[y + y_edge][x + x_edge] == -1:
self.open_cell((x + x_edge, y + y_edge))
# Функция - обработчик победы
def win(self):
self.counter = 0
if self.tagged_mines == self.mines_count:
for i in range(self.height):
for j in range(self.width):
if type(self.board[i]
[j]) == list and self.board[i][j][1] == 10:
self.counter += 1
if self.counter != self.mines_count:
self.warning = True
# print("Not all the mines have been marked")
else:
# print("You win!")
e = int(time.time() - start_time)
self.total_time = '{:02d}:{:02d}:{:02d}'.format(
e // 3600, (e % 3600 // 60), e % 60)
self.result_left_mines = self.mines_count - self.tagged_mines
self.not_win = False
if os.name == "posix":
nick = os.environ.get("USER")
else:
nick = os.environ.get("USERNAME")
time_in_seconds = e
game_mode = self.mode
self.lb.AddRecord(nick,
f"time('{time_in_seconds}', 'unixepoch')",
"datetime('now', '+3 hours')", game_mode)
# print(nick, time_in_seconds, date, game_mode, sep="\n")
return True
return False
import re
from flask import Flask, render_template, request, url_for, session, redirect
from flask_socketio import SocketIO, emit
from players import Players
from words import Words
from game_state import GameState
from leaderboard import LeaderBoard
from authentication import player_required
app = Flask(__name__)
config.load(app)
words = Words(app)
players = Players(app)
game_state = GameState(app)
leaderboard = LeaderBoard(app)
socketio = SocketIO(app, async_mode=None)
thread = None
stop_game = go_next = False
# TODO: look into using thread events instead of these flags
@app.route('/')
def index():
return render_template('index.html', leaderboard=leaderboard.rankings(), player=session.get("player"))
@app.route("/signout")
def signout():
session.clear()
return redirect(url_for("index"))
from flask import Flask, redirect, render_template, request
from gevent.wsgi import WSGIServer
from predict import InstrumentClassifier
from leaderboard import LeaderBoard
app = Flask(__name__)
app.config['MAX_CONTENT_LENGTH'] = 1 * 2**20
model_dir = 'data/working/single-notes-2000/models'
model_id = LeaderBoard(model_dir).best_model()
model = InstrumentClassifier(model_dir + '/' + model_id)
print('Using model:', model_id)
@app.route('/')
def hello():
return render_template('home.html', model_id=model_id)
@app.route('/api/classify/instrument', methods=['POST'])
def classify():
if 'audio_file' not in request.files:
return redirect('/')
# File-like object than can be directy passed to soundfile.read()
# without saving to disk.
audio_file = request.files['audio_file']
if audio_file.filename == '':