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): 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 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 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): 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 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 __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 __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(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(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 __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_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()
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 __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 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()