def __draw_game(self, game, overview):
self.canvas.Fill(*ledcolors.scoreboard.fill)
# Draw the pregame renderer
if Status.is_pregame(overview.status):
pregame = Pregame(overview)
renderer = PregameRenderer(self.canvas, pregame,
self.data.config.coords["pregame"],
self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
# Draw the final game renderer
elif Status.is_complete(overview.status):
final = Final(game)
scoreboard = Scoreboard(overview)
renderer = FinalRenderer(self.canvas, final, scoreboard,
self.data.config, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
# Draw the scoreboar renderer
elif Status.is_irregular(overview.status):
scoreboard = Scoreboard(overview)
StatusRenderer(self.canvas, scoreboard, self.data.config).render()
else:
scoreboard = Scoreboard(overview)
ScoreboardRenderer(self.canvas, scoreboard,
self.data.config).render()
self.canvas = self.matrix.SwapOnVSync(self.canvas)
def __draw_game(self, game, overview):
color = self.data.config.scoreboard_colors.color("default.background")
self.canvas.Fill(color["r"], color["g"], color["b"])
# Draw the pregame renderer
if Status.is_pregame(overview.status):
scoreboard = Scoreboard(overview)
scroll_max_x = self.__max_scroll_x(self.data.config.layout.coords("pregame.scrolling_text"))
pregame = Pregame(overview)
renderer = PregameRenderer(self.canvas, pregame, scoreboard, self.data, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
# Draw the final game renderer
elif Status.is_complete(overview.status):
scroll_max_x = self.__max_scroll_x(self.data.config.layout.coords("final.scrolling_text"))
final = Final(game)
scoreboard = Scoreboard(overview)
renderer = FinalRenderer(self.canvas, final, scoreboard, self.data, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
# Draw the scoreboar renderer
elif Status.is_irregular(overview.status):
scoreboard = Scoreboard(overview)
if scoreboard.get_text_for_reason():
scroll_max_x = self.__max_scroll_x(self.data.config.layout.coords("status.scrolling_text"))
renderer = StatusRenderer(self.canvas, scoreboard, self.data, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
else:
StatusRenderer(self.canvas, scoreboard, self.data).render()
else:
scoreboard = Scoreboard(overview)
ScoreboardRenderer(self.canvas, scoreboard, self.data).render()
self.canvas = self.matrix.SwapOnVSync(self.canvas)
def __draw_game(self, game, overview):
color = self.data.config.scoreboard_colors.color("default.background")
self.canvas.Fill(color["r"], color["g"], color["b"])
# Draw the pregame renderer
if Status.is_pregame(overview.status):
scoreboard = Scoreboard(overview)
scroll_max_x = self.__max_scroll_x(self.data.config.layout.coords("pregame.scrolling_text"))
pregame = Pregame(overview)
renderer = PregameRenderer(self.canvas, pregame, scoreboard, self.data, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
# Draw the final game renderer
elif Status.is_complete(overview.status):
scroll_max_x = self.__max_scroll_x(self.data.config.layout.coords("final.scrolling_text"))
final = Final(game)
scoreboard = Scoreboard(overview)
renderer = FinalRenderer(self.canvas, final, scoreboard, self.data, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
# Draw the scoreboar renderer
elif Status.is_irregular(overview.status):
scoreboard = Scoreboard(overview)
if scoreboard.get_text_for_reason():
scroll_max_x = self.__max_scroll_x(self.data.config.layout.coords("status.scrolling_text"))
renderer = StatusRenderer(self.canvas, scoreboard, self.data, self.scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
else:
StatusRenderer(self.canvas, scoreboard, self.data).render()
else:
scoreboard = Scoreboard(overview)
ScoreboardRenderer(self.canvas, scoreboard, self.data).render()
self.canvas = self.matrix.SwapOnVSync(self.canvas)
def render(self):
if self.data.config.testing_mode:
debug.info("Rendering in Testing Mode")
while True:
self.data.refresh_overview()
self.scoreboard = Scoreboard(self.data.overview, self.data)
ScoreboardRenderer(self.data, self.matrix,
Scoreboard(self.data.games[0],
self.data)).render()
#self._draw_event_animation("goal", self.scoreboard.home_team.id, self.scoreboard.home_team.name)
#PenaltyRenderer(self.data, self.matrix, self.sleepEvent, self.scoreboard.away_team).render()
#TeamSummary(self.data, self.matrix, self.sleepEvent).render()
sleep(1)
debug.info("Testing Mode Refresh")
if self.data.config.test_goal_animation:
debug.info("Rendering in Testing Mode")
while True:
self._draw_event_animation("goal", id=9)
while self.data.network_issues:
Clock(self.data, self.matrix, self.sleepEvent, duration=60)
self.data.refresh_data()
while True:
debug.info('Rendering...')
#if self.status.is_offseason(self.data.date()):
# Offseason (Show offseason related stuff)
#debug.info("It's offseason")
#self.__render_offday()
if self.data.config.testScChampions:
self.test_stanley_cup_champion(
self.data.config.testScChampions)
else:
# Season.
if not self.data.config.live_mode:
debug.info("Live mode is off. Going through the boards")
self.__render_offday()
elif self.data.is_pref_team_offday():
debug.info("Your preferred teams are Off today")
self.__render_offday()
elif self.data.is_nhl_offday():
debug.info("There is no game in the NHL today")
self.__render_offday()
else:
debug.info("Game Day Wooooo")
self.__render_game_day()
self.data.refresh_data()
def render(self):
self.index = 0
self.games = self.data.games
self.num_games = len(self.games)
try:
while not self.sleepEvent.is_set():
self.matrix.clear()
if self.index >= (len(self.games)):
return
ScoreboardRenderer(self.data, self.matrix, Scoreboard(self.games[self.index], self.data)).render()
self.show_indicator()
self.matrix.render()
if self.data.network_issues:
self.matrix.network_issue_indicator()
if self.data.newUpdate and not self.data.config.clock_hide_indicators:
self.matrix.update_indicator()
#sleep(self.rotation_rate)
self.sleepEvent.wait(self.rotation_rate)
self.index += 1
except IndexError:
print("no game to display, you set preferred teams only or NHL OFF DAY today")
return
def print_game_data_debug(self):
debug.log("Game Data Refreshed: %s",
self.current_game._data["gameData"]["game"]["id"])
debug.log("Pre: %s", Pregame(self.current_game,
self.config.time_format))
debug.log("Live: %s", Scoreboard(self.current_game))
debug.log("Final: %s", Postgame(self.current_game))
def render(self):
if self.data.config.testing_mode:
debug.info("Rendering in Testing Mode")
while True:
self._draw_goal_animation()
ScoreboardRenderer(self.data, self.matrix,
Scoreboard(self.data.games[0],
self.data)).render()
self.matrix.render()
data.refresh.daily(self.data)
sleep(15)
debug.info("Testing Mode Refresh")
if self.data.config.test_goal_animation:
debug.info("Rendering in Testing Mode")
while True:
self._draw_goal_animation()
self.matrix.render()
sleep(1)
while self.data.network_issues:
Clock(self.data, self.matrix, self.sleepEvent, duration=60)
self.data.refresh_data()
while True:
try:
debug.info('Rendering...')
if self.status.is_offseason(self.data.date()):
# Offseason (Show offseason related stuff)
debug.info("It's offseason")
self.__render_offday()
elif self.data.config.testScChampions:
self.test_stanley_cup_champion(
self.data.config.testScChampions)
else:
# Season.
if not self.data.config.live_mode:
debug.info(
"Live mode is off. Going through the boards")
self.__render_offday()
elif self.data.is_pref_team_offday():
debug.info("Your preferred teams are Off today")
self.__render_offday()
elif self.data.is_nhl_offday():
debug.info("There is no game in the NHL today")
self.__render_offday()
else:
debug.info("Game Day Wooooo")
self.__render_game_day()
self.data.refresh_data()
except AttributeError as e:
debug.log(f"ERROR WHILE RENDERING: {e}")
debug.log("Refreshing data in a minute")
self.boards.fallback(self.data, self.matrix, self.sleepEvent)
self.data.refresh_data()
def __refresh_game(self, game, overview):
"""Draws the provided game on the canvas."""
if overview.status == PRE_GAME or overview.status == SCHEDULED:
pregame = Pregame(overview)
renderer = PregameRenderer(self.canvas, pregame,
self.current_scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
elif overview.status == GAME_OVER or overview.status == FINAL:
final = Final(game)
scoreboard = Scoreboard(overview)
renderer = FinalRenderer(self.canvas, final, scoreboard,
self.current_scrolling_text_pos)
self.__update_scrolling_text_pos(renderer.render())
else:
scoreboard = Scoreboard(overview)
ScoreboardRenderer(self.canvas, scoreboard).render()
self.canvas = self.matrix.SwapOnVSync(self.canvas)
def __render_game_day(self):
debug.info("Showing Game")
# Initialize the scoreboard. get the current status at startup
self.data.refresh_overview()
self.scoreboard = Scoreboard(self.data.overview, self.data.teams_info,
self.data.config)
self.away_score = self.scoreboard.away_team.goals
self.home_score = self.scoreboard.home_team.goals
while True:
if self.data._is_new_day():
debug.log('This is a new day')
return
if self.data.needs_refresh:
print("refreshing")
self.data.refresh_current_date()
self.data.refresh_overview()
self.data.refresh_games()
self.data.refresh_standings()
if self.data.network_issues:
self.matrix.network_issue_indicator()
if self.status.is_live(self.data.overview.status):
""" Live Game state """
debug.info("Game is Live")
self.scoreboard = Scoreboard(self.data.overview,
self.data.teams_info,
self.data.config)
self.check_new_goals()
self.__render_live(self.scoreboard)
elif self.status.is_final(self.data.overview.status):
""" Post Game state """
debug.info("Game Over")
self.scoreboard = Scoreboard(self.data.overview,
self.data.teams_info,
self.data.config)
self.__render_postgame(self.scoreboard)
elif self.status.is_scheduled(self.data.overview.status):
""" Pre-game state """
debug.info("Game is Scheduled")
self.scoreboard = Scoreboard(self.data.overview,
self.data.teams_info,
self.data.config)
self.__render_pregame(self.scoreboard)
def render(self):
color = self.data.config.scoreboard_colors.color("default.background")
self.canvas.Fill(color["r"], color["g"], color["b"])
starttime = time.time()
# Main and only loop
while True:
# If we need to refresh the overview data, do that
if self.data.needs_refresh:
self.data.refresh_overview()
# Draw the current game
self.__draw_game(self.data.current_game(), self.data.overview)
# Check if we need to scroll until it's finished
if self.data.config.rotation_scroll_until_finished == False:
self.scrolling_finished = True
# Set the refresh rate
refresh_rate = self.data.config.scrolling_speed
# If we're not scrolling anything, scroll is always finished.
if Status.is_static(self.data.overview.status) and not Scoreboard(
self.data.overview).get_text_for_reason():
self.scrolling_finished = True
time.sleep(refresh_rate)
endtime = time.time()
time_delta = endtime - starttime
rotate_rate = self.__rotate_rate_for_status(
self.data.overview.status)
# If we're ready to rotate, let's do it
if time_delta >= rotate_rate and self.scrolling_finished:
starttime = time.time()
self.scrolling_finished = False
self.data.needs_refresh = True
if Status.is_fresh(self.data.overview.status):
self.scrolling_text_pos = self.canvas.width
if self.__should_rotate_to_next_game(self.data.overview):
self.scrolling_text_pos = self.canvas.width
game = self.data.advance_to_next_game()
if endtime - self.data.games_refresh_time >= GAMES_REFRESH_RATE:
self.data.refresh_games()
if self.data.needs_refresh:
self.data.refresh_overview()
if Status.is_complete(self.data.overview.status):
if Final(self.data.current_game()
).winning_pitcher == 'Unknown':
self.data.refresh_games()
def __render_game(self):
while True:
# If we need to refresh the overview data, do that
if self.data.needs_refresh:
self.data.refresh_overview()
# Draw the current game
self.__draw_game(self.data.current_game(), self.data.overview)
# Check if we need to scroll until it's finished
if self.data.config.rotation_scroll_until_finished == False:
self.scrolling_finished = True
# Set the refresh rate
refresh_rate = self.data.config.scrolling_speed
# Currently the only thing that's always static is the live scoreboard
if Status.is_static(self.data.overview.status):
self.scrolling_finished = True
# If the status is irregular and there's no 'reason' text, finish scrolling
if Status.is_irregular(self.data.overview.status) and Scoreboard(
self.data.overview).get_text_for_reason() is None:
self.scrolling_finished = True
time.sleep(refresh_rate)
endtime = time.time()
time_delta = endtime - self.starttime
rotate_rate = self.__rotate_rate_for_status(
self.data.overview.status)
# If we're ready to rotate, let's do it
if time_delta >= rotate_rate and self.scrolling_finished:
self.starttime = time.time()
self.scrolling_finished = False
self.scrolling_period = 0.0
self.data.needs_refresh = True
if Status.is_fresh(self.data.overview.status):
self.scrolling_text_pos = self.canvas.width
if self.__should_rotate_to_next_game(self.data.overview):
self.scrolling_text_pos = self.canvas.width
game = self.data.advance_to_next_game()
if endtime - self.data.games_refresh_time >= GAMES_REFRESH_RATE:
self.data.refresh_games()
if self.data.needs_refresh:
self.data.refresh_overview()
if Status.is_complete(self.data.overview.status):
if Final(self.data.current_game()
).winning_pitcher == 'Unknown':
self.data.refresh_games()
def render_irregular_status(canvas,
layout: Layout,
colors: Color,
scoreboard: Scoreboard,
short_text,
text_pos=0):
pos = 0
if scoreboard.get_text_for_reason():
pos = __render_scroll_text(canvas, layout, colors, scoreboard,
text_pos)
__render_game_status(canvas, layout, colors, scoreboard, short_text)
return pos
def __init__(self) -> None:
"""
Initialize the game, and create game resources.
"""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Alien invasion")
# Create an instance to store game statistics and scoreboard.
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
# Make the play button
self.play_button = Button(self, "Play")
def render(self):
self.index = 0
self.games = self.data.games
self.num_games = len(self.games)
try:
while True:
self.matrix.clear()
if self.index >= (len(self.games)):
return
ScoreboardRenderer(self.data, self.matrix, Scoreboard(self.games[self.index], self.data.teams_info, self.data.config)).render()
self.show_indicator()
self.matrix.render()
if self.data.network_issues:
self.matrix.network_issue_indicator()
sleep(self.rotation_rate)
self.index += 1
except IndexError:
print("NHL OFF DAY today")
return
def __render_game_day(self):
debug.info("Showing Game")
# Initialize the scoreboard. get the current status at startup
self.data.refresh_overview()
self.scoreboard = Scoreboard(self.data.overview, self.data)
self.away_score = self.scoreboard.away_team.goals
self.home_score = self.scoreboard.home_team.goals
# Cache to save goals and allow all the details to be collected on the API.
self.goal_team_cache = []
self.sleepEvent.clear()
while not self.sleepEvent.is_set():
if self.data._is_new_day():
debug.log('This is a new day')
return
# Display the pushbutton board
if self.data.pb_trigger:
debug.info(
'PushButton triggered in game day loop....will display ' +
self.data.config.pushbutton_state_triggered1 + ' board')
if not self.data.screensaver:
self.data.pb_trigger = False
#Display the board from the config
self.boards._pb_board(self.data, self.matrix, self.sleepEvent)
# Display the Weather Alert board
if self.data.wx_alert_interrupt:
debug.info(
'Weather Alert triggered in game day loop....will display weather alert board'
)
self.data.wx_alert_interrupt = False
#Display the board from the config
self.boards._wx_alert(self.data, self.matrix, self.sleepEvent)
# Display the screensaver board
if self.data.screensaver:
if not self.data.pb_trigger:
debug.info('Screensaver triggered in game day loop....')
#self.data.wx_alert_interrupt = False
#Display the board from the config
self.boards._screensaver(self.data, self.matrix,
self.sleepEvent)
else:
self.data.pb_trigger = False
if self.status.is_live(self.data.overview.status):
""" Live Game state """
#blocks the screensaver from running if game is live
self.data.screensaver_livegame = True
debug.info("Game is Live")
self.scoreboard = Scoreboard(self.data.overview, self.data)
self.check_new_goals()
self.__render_live(self.scoreboard)
if self.scoreboard.intermission:
debug.info("Main event is in Intermission")
# Show Boards for Intermission
self.draw_end_period_indicator()
self.sleepEvent.wait(self.refresh_rate)
self.check_new_goals()
self.boards._intermission(self.data, self.matrix,
self.sleepEvent)
else:
self.sleepEvent.wait(self.refresh_rate)
elif self.status.is_game_over(self.data.overview.status):
print(self.data.overview.status)
debug.info("Game Over")
self.scoreboard = Scoreboard(self.data.overview, self.data)
self.check_new_goals()
if self.data.isPlayoff and self.stanleycup_round:
self.check_stanley_cup_champion()
if self.data.ScChampions_id:
StanleyCupChampions(self.data,
self.data.ScChampions_id,
self.matrix,
self.sleepEvent).render()
self.__render_postgame(self.scoreboard)
self.sleepEvent.wait(self.refresh_rate)
elif self.status.is_final(self.data.overview.status):
""" Post Game state """
debug.info("FINAL")
self.scoreboard = Scoreboard(self.data.overview, self.data)
self.check_new_goals()
if self.data.isPlayoff and self.stanleycup_round:
self.check_stanley_cup_champion()
if self.data.ScChampions_id:
StanleyCupChampions(self.data, self.matrix,
self.sleepEvent).render()
self.__render_postgame(self.scoreboard)
self.sleepEvent.wait(self.refresh_rate)
if self.data._next_game():
debug.info("moving to the next preferred game")
return
if not self.goal_team_cache:
self.boards._post_game(self.data, self.matrix,
self.sleepEvent)
elif self.status.is_scheduled(self.data.overview.status):
""" Pre-game state """
debug.info("Game is Scheduled")
self.scoreboard = Scoreboard(self.data.overview, self.data)
self.__render_pregame(self.scoreboard)
#sleep(self.refresh_rate)
self.sleepEvent.wait(self.refresh_rate)
self.boards._scheduled(self.data, self.matrix, self.sleepEvent)
elif self.status.is_irregular(self.data.overview.status):
""" Pre-game state """
debug.info("Game is irregular")
self.scoreboard = Scoreboard(self.data.overview, self.data)
self.__render_irregular(self.scoreboard)
#sleep(self.refresh_rate)
self.sleepEvent.wait(self.refresh_rate)
self.boards._scheduled(self.data, self.matrix, self.sleepEvent)
self.data.refresh_data()
self.data.refresh_overview()
if self.data.network_issues:
self.matrix.network_issue_indicator()
if self.data.newUpdate and not self.data.config.clock_hide_indicators:
self.matrix.update_indicator()
class AlienInvasion:
"""
Overall class to manage game assets and behavior.
"""
def __init__(self) -> None:
"""
Initialize the game, and create game resources.
"""
pygame.init()
self.settings = Settings()
self.screen = pygame.display.set_mode(
(self.settings.screen_width, self.settings.screen_height))
pygame.display.set_caption("Alien invasion")
# Create an instance to store game statistics and scoreboard.
self.stats = GameStats(self)
self.sb = Scoreboard(self)
self.ship = Ship(self)
self.bullets = pygame.sprite.Group()
self.aliens = pygame.sprite.Group()
self._create_fleet()
# Make the play button
self.play_button = Button(self, "Play")
def run_game(self):
"""
Start the main loop for the game.
"""
while True:
self._check_events()
if self.stats.game_active:
self.ship.update()
self._update_bullets()
self._update_aliens()
self._update_screen()
def _check_events(self):
"""
Respond to keypresses and mouse events.
"""
for event in pygame.event.get():
if event.type == pygame.QUIT:
sys.exit()
elif event.type == pygame.KEYDOWN:
self._check_keydown_events(event)
elif event.type == pygame.KEYUP:
self._check_keyup_events(event)
elif event.type == pygame.MOUSEBUTTONDOWN:
mouse_pos = pygame.mouse.get_pos()
self._check_play_button(mouse_pos)
def _check_play_button(self, mouse_pos):
"""
Start a new game when the player clicks play.
"""
button_clicked = self.play_button.rect.collidepoint(mouse_pos)
if button_clicked and not self.stats.game_active:
# Reset the game settings.
self.settings.initialize_dynamic_settings()
# Reset the game statistics.
self.stats.reset_stats()
self.stats.game_active = True
self.sb.prep_score()
self.sb.prep_level()
self.sb.prep_ships()
# Get rid of any remaining aliens and bullets.
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and center the ship.
self._create_fleet()
self.ship.center_ship()
# Hide the mouse cursor.
pygame.mouse.set_visible(False)
def _check_keydown_events(self, event):
"""
Respond to keypresses.
"""
if event.key == pygame.K_RIGHT:
self.ship.moving_right = True
elif event.key == pygame.K_LEFT:
self.ship.moving_left = True
elif event.key == pygame.K_q:
sys.exit()
elif event.key == pygame.K_SPACE:
self._fire_bullet()
def _check_keyup_events(self, event):
"""
Respond to keyreleases.
"""
if event.key == pygame.K_RIGHT:
self.ship.moving_right = False
elif event.key == pygame.K_LEFT:
self.ship.moving_left = False
def _fire_bullet(self):
"""
Create a new bullet and add it to the bullets group.
"""
if len(self.bullets) < self.settings.bullets_allowed:
new_bullet = Bullet(self)
self.bullets.add(new_bullet)
def _update_bullets(self):
"""
Update position of bullets and get rid of old bullets.
"""
# Update bullets positions.
self.bullets.update()
# Get rid of bullets that have disappeared.
for bullet in self.bullets.copy():
if bullet.rect.bottom <= 0:
self.bullets.remove(bullet)
self._check_bullet_alien_collisions()
def _check_bullet_alien_collisions(self):
"""
Respond to bullet-alien collisions.
"""
# Remove any bullets and aliens that have collided.
collisions = pygame.sprite.groupcollide(self.bullets, self.aliens,
True, True)
if collisions:
for aliens in collisions.values():
self.stats.score += self.settings.alien_points * len(aliens)
self.sb.prep_score()
self.sb.check_high_score()
if not self.aliens:
# Destroy existing bullets and create new fleet.
self.bullets.empty()
self._create_fleet()
self.settings.increase_speed()
# Increase level.
self.stats.level += 1
self.sb.prep_level()
def _update_aliens(self):
"""
Check if the fleet is at an edge,
then update the positions of all aliens in the fleet.
"""
self._check_fleet_edges()
self.aliens.update()
# Look for alien-ship collisions.
if pygame.sprite.spritecollideany(self.ship, self.aliens):
self._ship_hit()
# Look for aliens hitting the bottom of the screen.
self._check_aliens_bottom()
def _ship_hit(self):
"""
Respond to the ship being hit by an alien.
"""
if self.stats.ships_left > 0:
# Decrement ships_left, and update scoreboard.
self.stats.ships_left -= 1
self.sb.prep_ships()
# Get rid of any remaining aliens and bullets.
self.aliens.empty()
self.bullets.empty()
# Create a new fleet and center the ship.
self._create_fleet()
self.ship.center_ship()
# Pause
sleep(1.0)
else:
self.stats.game_active = False
pygame.mouse.set_visible(True)
def _check_aliens_bottom(self):
"""
Check if any aliens has reach the bottom of the screen.
"""
screen_rect = self.screen.get_rect()
for alien in self.aliens.sprites():
if alien.rect.bottom >= screen_rect.bottom:
# Treat this the same as if the ship got hit.
self._ship_hit()
break
def _create_fleet(self):
"""
Create the fleet of aliens.
"""
# Create an alien and find the number of aliens in a row.
# Spacing between each alien is equal to one alien width.
alien = Alien(self)
alien_width, alien_height = alien.rect.size
available_space_x = self.settings.screen_width - (2 * alien_width)
number_aliens_x = available_space_x // (2 * alien_width)
# Determine the number of rows of aliens that fit on the screen.
ship_height = self.ship.rect.height
available_space_y = (self.settings.screen_height - (3 * alien_height) -
ship_height)
number_rows = available_space_y // (2 * alien_height)
# Create full fleet of aliens.
for row_number in range(number_rows):
for alien_number in range(number_aliens_x):
self._create_alien(alien_number, row_number)
def _create_alien(self, alien_number, row_number):
# Create an alien and place it in the row.
alien = Alien(self)
alien_width, alien_height = alien.rect.size
alien.x = alien_width + 2 * alien_width * alien_number
alien.rect.x = alien.x
alien.rect.y = alien_height + 2 * alien_height * row_number
self.aliens.add(alien)
def _check_fleet_edges(self):
"""
Respond appropriately if any aliens have reached an edge.
"""
for alien in self.aliens.sprites():
if alien.check_edges():
self._change_fleet_direction()
break
def _change_fleet_direction(self):
"""
Drop the entire fleet and change the fleet's direction.
"""
for alien in self.aliens.sprites():
alien.rect.y += self.settings.fleet_drop_speed
self.settings.fleet_direction *= -1
def _update_screen(self):
"""
Update images on the screen, and flip to the new screen.
"""
self.screen.fill(self.settings.bg_color)
self.ship.blitme()
for bullet in self.bullets.sprites():
bullet.draw_bullet()
self.aliens.draw(self.screen)
# Draw the score information.
self.sb.show_score()
# Draw the play button if the game is inactive.
if not self.stats.game_active:
self.play_button.draw_button()
pygame.display.flip()
def __render_game_day(self):
debug.info("Showing Game")
# Initialize the scoreboard. get the current status at startup
self.data.refresh_overview()
self.scoreboard = Scoreboard(self.data.overview, self.data)
self.away_score = self.scoreboard.away_team.goals
self.home_score = self.scoreboard.home_team.goals
self.sleepEvent.clear()
while not self.sleepEvent.is_set():
if self.data._is_new_day():
debug.log('This is a new day')
return
# Display the pushbutton board
if self.data.pb_trigger:
debug.info(
'PushButton triggered in game day loop....will display ' +
self.data.config.pushbutton_state_triggered1 + ' board')
self.data.pb_trigger = False
#Display the board from the config
self.boards._pb_board(self.data, self.matrix, self.sleepEvent)
if self.status.is_live(self.data.overview.status):
""" Live Game state """
debug.info("Game is Live")
self.scoreboard = Scoreboard(self.data.overview, self.data)
self.check_new_goals()
self.__render_live(self.scoreboard)
if self.scoreboard.intermission:
debug.info("Main event is in Intermission")
# Show Boards for Intermission
self.draw_end_period_indicator()
#sleep(self.refresh_rate)
self.sleepEvent.wait(self.refresh_rate)
self.boards._intermission(self.data, self.matrix,
self.sleepEvent)
else:
self.sleepEvent.wait(self.refresh_rate)
elif self.status.is_game_over(self.data.overview.status):
debug.info("Game Over")
self.scoreboard = Scoreboard(self.data.overview, self.data)
self.__render_postgame(self.scoreboard)
# sleep(self.refresh_rate)
self.sleepEvent.wait(self.refresh_rate)
elif self.status.is_final(self.data.overview.status):
""" Post Game state """
debug.info("FINAL")
self.scoreboard = Scoreboard(self.data.overview, self.data)
self.__render_postgame(self.scoreboard)
#sleep(self.refresh_rate)
self.sleepEvent.wait(self.refresh_rate)
if self.data._next_game():
debug.info("moving to the next preferred game")
return
self.boards._post_game(self.data, self.matrix, self.sleepEvent)
elif self.status.is_scheduled(self.data.overview.status):
""" Pre-game state """
debug.info("Game is Scheduled")
self.scoreboard = Scoreboard(self.data.overview, self.data)
self.__render_pregame(self.scoreboard)
#sleep(self.refresh_rate)
self.sleepEvent.wait(self.refresh_rate)
self.boards._scheduled(self.data, self.matrix, self.sleepEvent)
elif self.status.is_irregular(self.data.overview.status):
""" Pre-game state """
debug.info("Game is irregular")
self.scoreboard = Scoreboard(self.data.overview, self.data)
self.__render_irregular(self.scoreboard)
#sleep(self.refresh_rate)
self.sleepEvent.wait(self.refresh_rate)
self.boards._scheduled(self.data, self.matrix, self.sleepEvent)
sleep(5)
self.data.refresh_data()
self.data.refresh_overview()
if self.data.network_issues:
self.matrix.network_issue_indicator()
def render(self):
for team_id in self.preferred_teams:
self.team_id = team_id
team_colors = self.data.config.team_colors
bg_color = team_colors.color("{}.primary".format(team_id))
txt_color = team_colors.color("{}.text".format(team_id))
prev_game = self.teams_info[team_id].previous_game
next_game = self.teams_info[team_id].next_game
try:
if prev_game:
prev_game_id = self.teams_info[team_id].previous_game.dates[0]["games"][0]["gamePk"]
prev_game_scoreboard = Scoreboard(nhl_api.overview(prev_game_id), self.teams_info, self.data.config)
else:
prev_game_scoreboard = False
self.data.network_issues = False
except ValueError:
prev_game_scoreboard = False
self.data.network_issues = True
try:
if next_game:
next_game_id = self.teams_info[team_id].next_game.dates[0]["games"][0]["gamePk"]
next_game_scoreboard = Scoreboard(nhl_api.overview(next_game_id), self.teams_info, self.data.config)
else:
next_game_scoreboard = False
self.data.network_issues = False
except ValueError:
next_game_scoreboard = False
self.data.network_issues = True
stats = self.teams_info[team_id].stats
im_height = 67
team_abbrev = self.teams_info[team_id].abbreviation
logo_coord = self.layout._get_summary_logo_coord(team_id)
team_logo = Image.open(get_file('assets/logos/{}.png'.format(team_abbrev)))
i = 0
image = self.draw_team_summary(stats, prev_game_scoreboard, next_game_scoreboard, bg_color, txt_color,
im_height)
self.matrix.clear()
self.matrix.draw_image((0, 0), image)
self.matrix.draw_image((logo_coord["x"], logo_coord["y"]), team_logo.convert("RGB"))
self.matrix.render()
if self.data.network_issues:
self.matrix.network_issue_indicator()
sleep(5)
# Move the image up until we hit the bottom.
while i > -(im_height - self.matrix.height):
i -= 1
self.matrix.clear()
self.matrix.draw_image((0, i), image)
self.matrix.draw_image((logo_coord["x"], logo_coord["y"]), team_logo.convert("RGB"))
self.matrix.render()
if self.data.network_issues:
self.matrix.network_issue_indicator()
sleep(0.3)
# Show the bottom before we change to the next table.
sleep(5)
def draw_series_table(self, series):
color_top_bg = self.team_colors.color("{}.primary".format(
series.top_team.id))
color_top_team = self.team_colors.color("{}.text".format(
series.top_team.id))
color_bottom_bg = self.team_colors.color("{}.primary".format(
series.bottom_team.id))
color_bottom_team = self.team_colors.color("{}.text".format(
series.bottom_team.id))
# Table
self.matrix.draw.line([(0, 21), (self.matrix.width, 21)],
width=1,
fill=(150, 150, 150))
# use rectangle because I want to keep symmetry for the background of team's abbrev
self.matrix.draw.rectangle([0, 14, 12, 20],
fill=(color_top_bg['r'], color_top_bg['g'],
color_top_bg['b']))
self.matrix.draw_text((1, 15),
series.top_team.abbrev,
font=self.font,
fill=(color_top_team['r'], color_top_team['g'],
color_top_team['b']))
self.matrix.draw.rectangle([0, 22, 12, 28],
fill=(color_bottom_bg['r'],
color_bottom_bg['g'],
color_bottom_bg['b']))
self.matrix.draw_text(
(1, 23),
series.bottom_team.abbrev,
font=self.font,
fill=(color_bottom_team['r'], color_bottom_team['g'],
color_bottom_team['b']))
rec_width = 0
top_row = 15
bottom_row = 23
loosing_color = (150, 150, 150)
# text offset for loosing score if the winning team has a score of 10 or higher and loosing team
# have a score lower then 10
"""
TODO: Grabbing all the games of a series cause delay up to 15 sec for certain users. I think its time to put all the data
refresh into a thread and refresh everything from there
.
"""
offset_correction = 0
for game in series.games:
attempts_remaining = 5
while attempts_remaining > 0:
try:
# Request the game overview
overview = nhl_api.overview(game["gameId"])
# get the scoreboard
scoreboard = Scoreboard(overview, self.data)
if self.data.status.is_final(overview.status) and hasattr(
scoreboard, "winning_team"):
if scoreboard.winning_team == series.top_team.id:
winning_row = top_row
loosing_row = bottom_row
winning_team_color = color_top_team
winning_bg_color = color_top_bg
else:
winning_row = bottom_row
loosing_row = top_row
winning_team_color = color_bottom_team
winning_bg_color = color_bottom_bg
# Look loosing score text needs an offset
if len(str(scoreboard.winning_score)) == 2 and len(
str(scoreboard.winning_score)) == 1:
offset_correction = 1
self.matrix.draw_text(
((rec_width + 15 + offset_correction),
loosing_row),
str(scoreboard.loosing_score),
font=self.font,
fill=loosing_color,
backgroundColor=None,
backgroundOffset=[1, 1, 1, 1])
position = self.matrix.draw_text(
(rec_width + 15, winning_row),
str(scoreboard.winning_score),
font=self.font,
fill=(winning_team_color['r'],
winning_team_color['g'],
winning_team_color['b']),
backgroundColor=(winning_bg_color['r'],
winning_bg_color['g'],
winning_bg_color['b']),
backgroundOffset=[1, 1, 1, 1])
# Increment
rec_width += (position["size"][0] + 4)
break
except ValueError as error_message:
self.data.network_issues = True
debug.error(
"Failed to get the Games for the {} VS {} series: {} attempts remaining"
.format(series.top_team.abbrev,
series.bottom_team.abbrev, attempts_remaining))
debug.error(error_message)
attempts_remaining -= 1
self.sleepEvent.wait(1)
except KeyError as error_message:
debug.error(
"Failed to get the overview for game id {}. Data unavailable or is TBD"
.format(game["gameId"]))
debug.error(error_message)
break
# If one of the request for player info failed after 5 attempts, return an empty dictionary
if attempts_remaining == 0:
return False
def __draw_game(self):
game = self.data.current_game
bgcolor = self.data.config.scoreboard_colors.color(
"default.background")
self.canvas.Fill(bgcolor["r"], bgcolor["g"], bgcolor["b"])
scoreboard = Scoreboard(game)
layout = self.data.config.layout
colors = self.data.config.scoreboard_colors
teams.render_team_banner(
self.canvas,
layout,
self.data.config.team_colors,
scoreboard.home_team,
scoreboard.away_team,
self.data.config.full_team_names,
self.data.config.short_team_names_for_runs_hits,
)
if status.is_pregame(game.status()): # Draw the pregame information
self.__max_scroll_x(layout.coords("pregame.scrolling_text"))
pregame = Pregame(game, self.data.config.time_format)
pos = pregamerender.render_pregame(
self.canvas, layout, colors, pregame, self.scrolling_text_pos,
self.data.config.pregame_weather)
self.__update_scrolling_text_pos(pos, self.canvas.width)
elif status.is_complete(game.status()): # Draw the game summary
self.__max_scroll_x(layout.coords("final.scrolling_text"))
final = Postgame(game)
pos = postgamerender.render_postgame(self.canvas, layout, colors,
final, scoreboard,
self.scrolling_text_pos)
self.__update_scrolling_text_pos(pos, self.canvas.width)
elif status.is_irregular(game.status()): # Draw game status
short_text = self.data.config.layout.coords(
"status.text")["short_text"]
if scoreboard.get_text_for_reason():
self.__max_scroll_x(layout.coords("status.scrolling_text"))
pos = irregular.render_irregular_status(
self.canvas, layout, colors, scoreboard, short_text,
self.scrolling_text_pos)
self.__update_scrolling_text_pos(pos, self.canvas.width)
else:
irregular.render_irregular_status(self.canvas, layout, colors,
scoreboard, short_text)
self.data.scrolling_finished = True
else: # draw a live game
if scoreboard.homerun() or scoreboard.strikeout():
self.animation_time += 1
else:
self.animation_time = 0
loop_point = self.data.config.layout.coords("atbat")["loop"]
self.scrolling_text_pos = min(self.scrolling_text_pos, loop_point)
pos = gamerender.render_live_game(self.canvas, layout, colors,
scoreboard,
self.scrolling_text_pos,
self.animation_time)
self.__update_scrolling_text_pos(pos, loop_point)
# Show network issues
if self.data.network_issues:
network.render_network_error(self.canvas, layout, colors)
self.canvas = self.matrix.SwapOnVSync(self.canvas)
def render(self):
for team_id in self.preferred_teams:
self.team_id = team_id
team = self.teams_info[team_id]
team_data = Team(team.team_id, team.abbreviation, team.name)
team_colors = self.data.config.team_colors
bg_color = team_colors.color("{}.primary".format(team_id))
txt_color = team_colors.color("{}.text".format(team_id))
prev_game = team.previous_game
next_game = team.next_game
logo_renderer = LogoRenderer(self.matrix, self.data.config,
self.layout.logo, team_data,
'team_summary')
try:
if prev_game:
prev_game_id = self.teams_info[
team_id].previous_game.dates[0]["games"][0]["gamePk"]
prev_game_scoreboard = Scoreboard(
nhl_api.overview(prev_game_id), self.data)
else:
prev_game_scoreboard = False
self.data.network_issues = False
except ValueError:
prev_game_scoreboard = False
self.data.network_issues = True
try:
if next_game:
next_game_id = self.teams_info[team_id].next_game.dates[0][
"games"][0]["gamePk"]
next_game_scoreboard = Scoreboard(
nhl_api.overview(next_game_id), self.data)
else:
next_game_scoreboard = False
self.data.network_issues = False
except ValueError:
next_game_scoreboard = False
self.data.network_issues = True
stats = team.stats
im_height = 67
team_abbrev = team.abbreviation
team_logo = Image.open(
get_file('assets/logos/{}.png'.format(team_abbrev)))
i = 0
if not self.sleepEvent.is_set():
image = self.draw_team_summary(stats, prev_game_scoreboard,
next_game_scoreboard, bg_color,
txt_color, im_height)
self.matrix.clear()
logo_renderer.render()
self.matrix.draw_image_layout(
self.layout.info,
image,
)
self.matrix.render()
if self.data.network_issues:
self.matrix.network_issue_indicator()
self.sleepEvent.wait(5)
# Move the image up until we hit the bottom.
while i > -(im_height -
self.matrix.height) and not self.sleepEvent.is_set():
i -= 1
self.matrix.clear()
logo_renderer.render()
self.matrix.draw_image_layout(self.layout.info, image, (0, i))
self.matrix.render()
if self.data.network_issues:
self.matrix.network_issue_indicator()
self.sleepEvent.wait(0.3)
# Show the bottom before we change to the next table.
self.sleepEvent.wait(5)
def __render_game_day(self):
debug.info("Showing Game")
# Initialize the scoreboard. get the current status at startup
self.data.refresh_overview()
self.scoreboard = Scoreboard(self.data.overview, self.data)
self.away_score = self.scoreboard.away_team.goals
self.home_score = self.scoreboard.home_team.goals
self.away_penalties = self.scoreboard.away_team.penalties
self.home_penalties = self.scoreboard.home_team.penalties
# Announce a game today to /dev/shm/getNHL.txt.1
home_name = self.scoreboard.home_team.name
away_name = self.scoreboard.away_team.name
stime = self.scoreboard.start_time
f = open('/dev/shm/getNHL.txt.1', 'w')
#f.write('Blues game today!')
f.write('NHL: %s vs %s, %spm\n' % (home_name, away_name, stime))
f.close()
subprocess_cmd = 'sudo -H -u pi bash -c "rsync /dev/shm/getNHL.txt.1 [email protected]:/dev/shm/"'
subprocess.run([subprocess_cmd], shell=True)
# Cache to save goals and penalties and allow all the details to be collected on the API.
self.goal_team_cache = []
self.penalties_team_cache = []
self.sleepEvent.clear()
while not self.sleepEvent.is_set():
if self.data._is_new_day():
debug.log('This is a new day')
return
# Display the pushbutton board
if self.data.pb_trigger:
debug.info(
'PushButton triggered in game day loop....will display ' +
self.data.config.pushbutton_state_triggered1 + ' board')
if not self.data.screensaver:
self.data.pb_trigger = False
#Display the board from the config
self.boards._pb_board(self.data, self.matrix, self.sleepEvent)
# Display the Weather Alert board
if self.data.wx_alert_interrupt:
debug.info(
'Weather Alert triggered in game day loop....will display weather alert board'
)
self.data.wx_alert_interrupt = False
#Display the board from the config
self.boards._wx_alert(self.data, self.matrix, self.sleepEvent)
# Display the screensaver board
if self.data.screensaver:
if not self.data.pb_trigger:
debug.info('Screensaver triggered in game day loop....')
#self.data.wx_alert_interrupt = False
#Display the board from the config
self.boards._screensaver(self.data, self.matrix,
self.sleepEvent)
else:
self.data.pb_trigger = False
if self.status.is_live(self.data.overview.status):
""" Live Game state """
#blocks the screensaver from running if game is live
self.data.screensaver_livegame = True
debug.info("Game is Live")
sbrenderer = ScoreboardRenderer(self.data, self.matrix,
self.scoreboard)
self.check_new_penalty()
self.check_new_goals()
self.__render_live(sbrenderer)
if self.scoreboard.intermission:
debug.info("Main event is in Intermission")
# Show Boards for Intermission
self.draw_end_period_indicator()
self.sleepEvent.wait(self.refresh_rate)
self.check_new_penalty()
self.check_new_goals()
self.boards._intermission(self.data, self.matrix,
self.sleepEvent)
else:
self.sleepEvent.wait(self.refresh_rate)
elif self.status.is_game_over(self.data.overview.status):
debug.info("Game Over")
sbrenderer = ScoreboardRenderer(self.data, self.matrix,
self.scoreboard)
self.check_new_goals()
if self.data.isPlayoff and self.data.stanleycup_round:
self.check_stanley_cup_champion()
if self.data.ScChampions_id:
StanleyCupChampions(self.data, self.matrix,
self.sleepEvent).render()
self.__render_postgame(sbrenderer)
self.sleepEvent.wait(self.refresh_rate)
elif self.status.is_final(self.data.overview.status):
""" Post Game state """
debug.info("FINAL")
sbrenderer = ScoreboardRenderer(self.data, self.matrix,
self.scoreboard)
self.check_new_goals()
# Announce a game today to /dev/shm/getNHL.txt.1
home_name = self.scoreboard.home_team.name
away_name = self.scoreboard.away_team.name
home_goals = self.scoreboard.home_team.goals
away_goals = self.scoreboard.away_team.goals
f = open('/dev/shm/getNHL.txt.1', 'w')
#f.write('Blues game today!')
f.write('%s %d, %s %d FINAL\n' %
(home_name, home_goals, away_name, away_goals))
f.close()
subprocess_cmd = 'sudo -H -u pi bash -c "rsync /dev/shm/getNHL.txt.1 [email protected]:/dev/shm/"'
subprocess.run([subprocess_cmd], shell=True)
if self.data.isPlayoff and self.data.stanleycup_round:
self.check_stanley_cup_champion()
if self.data.ScChampions_id:
StanleyCupChampions(self.data, self.matrix,
self.sleepEvent).render()
self.__render_postgame(sbrenderer)
self.sleepEvent.wait(self.refresh_rate)
if not self.goal_team_cache:
self.boards._post_game(self.data, self.matrix,
self.sleepEvent)
elif self.status.is_scheduled(self.data.overview.status):
""" Pre-game state """
debug.info("Game is Scheduled")
sbrenderer = ScoreboardRenderer(self.data, self.matrix,
self.scoreboard)
self.__render_pregame(sbrenderer)
#sleep(self.refresh_rate)
self.sleepEvent.wait(self.refresh_rate)
self.boards._scheduled(self.data, self.matrix, self.sleepEvent)
#announce upcoming game
home_name = self.scoreboard.home_team.name
away_name = self.scoreboard.away_team.name
stime = self.scoreboard.start_time
f = open('/dev/shm/getNHL.txt.1', 'w')
f.write('NHL: %s vs %s, %spm\n' %
(home_name, away_name, stime))
f.close()
subprocess_cmd = 'sudo -H -u pi bash -c "rsync /dev/shm/getNHL.txt.1 [email protected]:/dev/shm/"'
subprocess.run([subprocess_cmd], shell=True)
elif self.status.is_irregular(self.data.overview.status):
""" Pre-game state """
debug.info("Game is irregular")
sbrenderer = ScoreboardRenderer(self.data, self.matrix,
self.scoreboard)
self.__render_irregular(sbrenderer)
#sleep(self.refresh_rate)
self.sleepEvent.wait(self.refresh_rate)
self.boards._scheduled(self.data, self.matrix, self.sleepEvent)
self.data.refresh_data()
self.data.refresh_overview()
self.scoreboard = Scoreboard(self.data.overview, self.data)
if self.data.network_issues:
self.matrix.network_issue_indicator()
if self.data.newUpdate and not self.data.config.clock_hide_indicators:
self.matrix.update_indicator()
