def render(self, game_screen, ui_screen): super().render(game_screen, ui_screen) pos_x = 24 pos_y = HALF_RES_HEIGHT - 24 text_height = min(HALF_RES_HEIGHT - 24, self.text.get_height()) # Draw the menu box + scrollbar game_screen.blit(Menu.draw_menu_box(self.width, self.height), (pos_x, pos_y)) game_screen.blit( Menu.draw_scroll_bar(8, self.height, self.scroll_height, self.scroll_pos, self.text.get_height()), (pos_x + self.width, pos_y)) # Draw the text subscroll scrolled_text = self.text.subsurface( (0, self.scroll_pos, self.text.get_width(), text_height)) game_screen.blit(scrolled_text, (pos_x + 12, pos_y + 12)) # Draw the prompt text prompt_text = get_text(label_strings, "TUTORIAL_PROMPT") game_screen.blit(prompt_text, (pos_x + self.width - prompt_text.get_width(), pos_y + self.height + 8))
def render(self, game_screen, ui_screen): super().render(game_screen, ui_screen) base_x = 24 base_y = 24 # Draw winning team game_screen.blit( Menu.draw_menu_box(RESOLUTION_WIDTH - 48, 24, background=light_team_color[self.winning_team]), (base_x, base_y)) game_screen.blit( draw_text( get_string(formatted_strings, "RESULTS_HEADER").format( get_string(team_name_strings, self.winning_team), self.turn), light_color, dark_color), (base_x + 8, base_y + 8)) x = 0 for piece in self.winning_pieces: if x < RESOLUTION_WIDTH - 24: game_screen.blit( spr_pieces[piece.team][piece.piece_type].subsurface( 0, 0, 24, 24), (base_x + x, base_y + 24)) x += 12 x = 0 y = 2 team_box_width = (RESOLUTION_WIDTH - (36 * len(self.all_teams))) // len(self.all_teams) for team in self.all_teams: stats = self.team_stats[team].items() game_screen.blit( Menu.draw_menu_box(team_box_width, (len(stats) + 1) * 24, background=shadow_color[team]), (base_x + x, base_y + (y * 24))) game_screen.blit(get_text(team_name_strings, team), (base_x + x + 8, base_y + (y * 24) + 8)) y += 1 for stat, value in stats: game_screen.blit( draw_text( get_string(formatted_strings, stat).format(value), light_color, dark_color), (base_x + x + 8, base_y + (y * 24) + 8)) y += 1 x += team_box_width + 24 y = 2 results_text = draw_text(get_string(label_strings, "RESULTS_PROMPT"), light_color, shadow_color[Team.RED]) game_screen.blit(results_text, (RESOLUTION_WIDTH - results_text.get_width() - 24, RESOLUTION_HEIGHT - 16))
def render_attribute(self, attribute): surface = pygame.Surface((96, 12), pygame.SRCALPHA, 32) surface.blit(spr_piece_attribute_icons[self.team][attribute], (0, 0)) value = self.get_manager(Manager.TEAM).attr(self.team, self.target, attribute) if attribute in [Attribute.ARCHETYPE, Attribute.MOVEMENT_TYPE]: surface.blit(get_text(attribute_value_strings, value, light=False), (14, 0)) else: surface.blit(draw_text(str(value), dark_color), (14, 0)) return surface
def render(self, game_screen, ui_screen): super().render(game_screen, ui_screen) if self.toast: self.toast.render(game_screen, ui_screen) # Render phase indicator bar ui_screen.fill(light_color, (0, RESOLUTION_HEIGHT - GRID_HEIGHT, RESOLUTION_WIDTH, GRID_HEIGHT)) ui_screen.fill(clear_color[self.team], (1, RESOLUTION_HEIGHT - GRID_HEIGHT + 1, RESOLUTION_WIDTH - 2, GRID_HEIGHT - 3)) x = 0 for phase in BattlePhase: ui_screen.blit(spr_phase_indicator[self.team][phase.value], (x * GRID_WIDTH, RESOLUTION_HEIGHT - GRID_HEIGHT)) x += 1 ui_screen.blit(spr_cursor[self.team], (self.get_manager(Manager.TURN).phase.value * GRID_WIDTH, RESOLUTION_HEIGHT - GRID_HEIGHT)) # Render phase indicator text ui_screen.blit( get_text(phase_strings, self.get_manager(Manager.TURN).phase), (3 + GRID_WIDTH * x, RESOLUTION_HEIGHT - GRID_HEIGHT + 6)) # Render resource count x += 3 ui_screen.blit( draw_resource_count( spr_resource_icon, spr_digit_icons, self.team, self.get_manager(Manager.TEAM).resources[self.team]), (GRID_WIDTH * x, RESOLUTION_HEIGHT - GRID_HEIGHT)) # Render turn submission status x += 1 for team in self.get_manager(Manager.TEAM).get_teams(): if self.get_manager(Manager.TEAM).turn_submitted[team]: ui_screen.blit( spr_turn_submitted_indicator[team], (GRID_WIDTH * x, RESOLUTION_HEIGHT - GRID_HEIGHT)) x += 1 elif self.get_manager(Manager.PLAYER).is_ai_thinking(team): ui_screen.blit( spr_turn_thinking_indicator[team], (GRID_WIDTH * x, RESOLUTION_HEIGHT - GRID_HEIGHT)) x += 1
def render(self, game_screen, ui_screen): super().render(game_screen, ui_screen) label_text = get_text(label_strings, self.label) ui_screen.blit(label_text, (self.x, self.y - 24)) # Draw the text box ui_screen.fill( light_color, (self.x - 1, self.y - 1, self.width + 3, self.height + 3)) ui_screen.fill(shadow_color[Team.RED], (self.x, self.y, self.width, self.height)) # Draw the current text rendered_text = self.current_text + "|" if len( self.current_text) >= 32 else self.current_text + "_" text = draw_text(rendered_text, light_color) ui_screen.blit(text, (self.x + 4, self.y + 2))
def render(self, game_screen, ui_screen): super().render(game_screen, ui_screen) row_y = 0 # Render any menu options we have for option in self.options: position_x, position_y = self.root_x, self.root_y + row_y * 24 is_selected = self.menu_pos == self.options.index(option) x_offset = 0 if is_selected else 16 box = self.draw_menu_box(self.width - x_offset, self.option_height, background=light_team_color[Team.RED] if is_selected else shadow_color[Team.RED]) game_screen.blit(box, (position_x - 24 + x_offset, position_y)) game_screen.blit(spr_main_menu_option[option], (position_x - 24 + x_offset, position_y)) game_screen.blit(get_text(main_menu_strings, option), (position_x + 24 + 8, position_y + 4)) row_y += 1
def create_toast_from_event(self, event): if event.team == self.team: self.toast = ToastNotification( self, get_text(notification_strings, event.event_type, light=True), self.team)
def render(self, game_screen, ui_screen): super().render(game_screen, ui_screen) if self.text_input: self.text_input.render(game_screen, ui_screen) elif self.tutorial: self.tutorial.render(game_screen, ui_screen) else: # Draw text for the menu title menu_title_text = get_text(main_menu_strings, self.current_menu[0]) game_screen.blit( self.draw_menu_box(self.width - 16, 24, background=light_team_color[Team.RED]), (self.root_x - 8, self.root_y - 16)) game_screen.blit(menu_title_text, (self.root_x + 24, self.root_y - 12)) # Draw a scrollbar if necessary if self.should_show_scroll_bar(self.max_displayable_options, self.num_options): width = 8 height = self.option_height * min(self.max_displayable_options, self.num_options) game_screen.blit( self.draw_scroll_bar(width, height, self.max_displayable_options, self.menu_min, self.num_options), (self.root_x + self.width - 24, self.root_y)) # Draw each menu option row_y = 0 displayable_options = self.current_menu[1][self.menu_min:self. menu_max] for option in displayable_options: is_selected = self.menu_pos == self.current_menu[1].index( option) x_offset = 0 if is_selected else 16 position_x, position_y = self.root_x, self.root_y + row_y * self.option_height box = self.draw_menu_box( self.width - x_offset, self.option_height, background=light_team_color[Team.RED] if is_selected else shadow_color[Team.RED]) game_screen.blit(box, (position_x - 24 + x_offset, position_y)) # Render splash graphics for top-level menu options if is_selected and self.current_menu[0] == Option.START: splash_width = self.width - 24 splash_height = 24 * (self.max_displayable_options) game_screen.blit( self.draw_menu_box(splash_width, splash_height), (self.root_x - splash_width - 24, self.root_y)) game_screen.blit( spr_main_menu_preview[option[0]], (self.root_x - splash_width - 12, self.root_y + 12)) game_screen.fill(clear_color[Team.RED], (self.root_x - splash_width - 12, self.root_y + 132, 120, 2)) if isinstance(option[0], str): # Render arbitrary text # Format the text a bit text = option[0]\ .replace("_", " ")\ .replace(".map", "")\ .replace(".sav", "")\ .title() # Render arbitrary text game_screen.blit(draw_text(text, light_color, dark_color), (position_x + 8, position_y + 8)) # For campaign, render an icon for completed missions if option[0] in self.progress: game_screen.blit( spr_mission_completed, (position_x + self.width - 48, position_y - 2)) # Render map previews if we're trying to select a map if is_selected and self.current_menu[0] in [ Option.NEW_GAME, Option.NEW_MAP, Option.LOAD_GAME, Option.LOAD_MAP, Option.NEW_NETWORK_GAME, Option.LOAD_NETWORK_GAME, Option.NEW_CAMPAIGN_GAME, Option.LOAD_CAMPAIGN_GAME ]: if self.current_menu[0] in [ Option.LOAD_GAME, Option.LOAD_NETWORK_GAME ]: asset_type = AssetType.SAVE elif self.current_menu[0] in [ Option.NEW_CAMPAIGN_GAME ]: asset_type = AssetType.CAMPAIGN_MAP elif self.current_menu[0] in [ Option.LOAD_CAMPAIGN_GAME ]: asset_type = AssetType.CAMPAIGN_SAVE else: asset_type = AssetType.MAP container_height = 24 * self.max_displayable_options container_width = self.width - 24 map_preview = draw_map_preview_from_file( container_width, container_height, option[0], asset_type=asset_type) game_screen.blit( map_preview, (self.root_x - container_width - 24, self.root_y)) elif option[0] in Setting: # Display the setting prompt and the current value display_string = get_string( formatted_strings, option[0]).format(SETTINGS.get_unsaved(option[0])) game_screen.blit( draw_text(display_string, light_color, dark_color), (position_x + 24, position_y + 8)) else: # Display the icon for the option game_screen.blit(spr_main_menu_option[option[0]], (position_x - 24 + x_offset, position_y)) # Display prerendered text game_screen.blit(get_text(main_menu_strings, option[0]), (position_x + 24, position_y + 8)) row_y += 1
def render(self, ui_screen): super().render(ui_screen) player_manager = self.get_manager(Manager.PLAYER) game_screen = Surface((RESOLUTION_WIDTH, RESOLUTION_HEIGHT), SRCALPHA, 32) game_screen.fill(clear_color[Team.RED]) game_screen.blit(spr_title_text, (self.root_x - spr_title_text.get_width() // 2, 24)) # Render a minimap preview of the current map minimap = draw_map_preview(menu_width - 24, 144, self.bitmap, self.pieces, self.team_data) game_screen.blit(minimap, (self.root_x - minimap.get_width() - 24, self.root_y)) # Render the current lobby status-- open and filled teams for network games, human and AI teams for local if self.is_network_game(): filled_teams = self.get_manager(Manager.NETWORK).filled_teams ai_teams = [] else: filled_teams = dict([(team, get_string(label_strings, "HUMAN_TEAM")) for team in player_manager.human_teams]) ai_teams = player_manager.ai_teams row_y = 0 for team in self.teams: position_x, position_y = self.root_x, self.root_y + row_y * 24 + 1 is_filled = team in filled_teams.keys() x_offset = 0 if is_filled else 16 game_screen.fill(light_color, (position_x - 24 - 1 + x_offset, position_y - 1, menu_width + 3 - x_offset, 24)) game_screen.fill( light_team_color[team] if is_filled else shadow_color[team], (position_x - 24 + x_offset, position_y, menu_width - x_offset, 21)) if team in filled_teams: game_screen.blit( draw_text(filled_teams[team], light_color, dark_color), (position_x + 8, position_y + 4)) elif team in ai_teams: personality_type = player_manager.get_ai_player( team).personality.personality_type game_screen.blit( get_text(personality_strings, personality_type), (position_x + 8, position_y + 4)) else: game_screen.blit(get_text(label_strings, "OPEN_TEAM"), (position_x + 8, position_y + 4)) row_y += 1 if self.lobby_menu: self.lobby_menu.render(game_screen, ui_screen) return game_screen
def render(self, game_screen, ui_screen): super().render(game_screen, ui_screen) # If we have multiple targets, draw tabs for each target if len(self.targets) > 0: index = 0 for target, team in self.targets: x_offset = 0 if self.index == index else GRID_WIDTH / 2 ui_screen.blit( Menu.draw_menu_box(GRID_WIDTH + 8, GRID_HEIGHT * 2, background=team_color[team], border=clear_color[team]), (self.x - GRID_WIDTH + x_offset, self.y + (index * GRID_HEIGHT * 2))) index += 1 # Draw the base container ui_screen.blit( Menu.draw_menu_box(self.width, self.height, background=light_color, border=clear_color[self.team]), (self.x, self.y)) if self.target in PieceType: # Render piece icons ui_screen.fill(clear_color[self.team], (self.x + 4, self.y + 12, 16, 16)) ui_screen.blit( spr_pieces[self.team][self.target].subsurface(0, 0, 24, 24), (self.x + 2, self.y + 8)) ui_screen.blit( get_text(piece_name_strings, self.target, light=False), (self.x + 32, self.y + 16)) y_offset = self.render_piece_attributes(ui_screen) elif self.target in UpgradeType: # Render upgrade icons ui_screen.blit(spr_upgrade_icons[self.team][self.target], (self.x + 4, self.y + 8)) ui_screen.blit( get_text(upgrade_name_strings, self.target, light=False), (self.x + 32, self.y + 16)) y_offset = self.render_upgrade_attributes(ui_screen) else: # Render menu option icons ui_screen.blit(spr_order_options[self.team][self.target], (self.x + 4, self.y + 8)) ui_screen.blit( get_text(menu_option_strings, self.target, light=False), (self.x + 32, self.y + 16)) y_offset = 16 # Render the description text description = get_multiline_text(menu_help_strings, self.target, light=False, width=subgrid_width * subgrid_size - 8) ui_screen.blit(description, (self.x + 4, self.y + 16 + y_offset)) # Render any bought upgrades for this piece relevant_upgrades = [ upgrade for upgrade in self.get_manager( Manager.TEAM).get_owned_upgrades(self.team) if self.target in base_upgrades[upgrade][UpgradeAttribute.DISPLAY_FOR] ] x_offset = 0 for upgrade in relevant_upgrades: ui_screen.blit(spr_upgrade_icons[self.team][upgrade], (self.x + 4 + x_offset, self.y + subgrid_size * subgrid_height - 4)) x_offset += 24
def render(self, game_screen, ui_screen): super().render(game_screen, ui_screen) if self.detailbox: self.detailbox.render(game_screen, ui_screen) else: row_y = 0 displayable_options = self.options[self.menu_min:self.menu_max] # Draw a scrollbar if necessary if self.should_show_scroll_bar(self.max_displayable_options, self.num_options): width = 6 height = self.option_height * min(self.max_displayable_options, self.num_options) ui_screen.blit( self.draw_scroll_bar(width, height, self.max_displayable_options, self.menu_min, self.num_options), (self.root_x + self.width, self.root_y)) for option in displayable_options: is_selected = self.menu_pos == self.options.index(option) x_offset = 0 if is_selected else 4 # Draw the row position_x, position_y = self.root_x, \ self.root_y + row_y * self.option_height box = self.draw_menu_box( self.width - x_offset, self.option_height, background=light_team_color[self.team] if is_selected else clear_color[self.team]) ui_screen.blit(box, (position_x + x_offset, position_y)) if option in PieceType: # Render buildable pieces ui_screen.blit(spr_menu_option_item_background[self.team], (self.root_x + x_offset, self.root_y + row_y * option_height)) ui_screen.blit( spr_pieces[self.team][option].subsurface(0, 0, 24, 24), (self.root_x + x_offset, self.root_y + row_y * option_height)) ui_screen.blit( get_text(piece_name_strings, option, light=True), (self.root_x + 29, self.root_y + 8 + row_y * option_height)) # if self.option_pos == row_y + self.option_min: ui_screen.blit( draw_resource_count( spr_resource_icon, spr_digit_icons, self.team, self.get_manager(Manager.TEAM).attr( self.team, option, Attribute.PRICE)), (self.root_x + self.width - 20, self.root_y + row_y * option_height)) row_y += 1 elif option in UpgradeType: # Render purchaseable upgrades ui_screen.blit(spr_upgrade_icons[self.team][option], (self.root_x + x_offset, self.root_y + row_y * option_height)) ui_screen.blit( get_text(upgrade_name_strings, option, light=True), (self.root_x + 29, self.root_y + 8 + row_y * option_height)) # if self.option_pos == row_y + self.option_min: ui_screen.blit( draw_resource_count( spr_resource_icon, spr_digit_icons, self.team, base_upgrades[option][ UpgradeAttribute.UPGRADE_PRICE]), (self.root_x + self.width - 24, self.root_y + row_y * option_height)) row_y += 1 else: # Render menu option icons ui_screen.blit(spr_order_options[self.team][option], (self.root_x + x_offset, self.root_y + row_y * option_height)) # Render 'contested' indicator if necessary if self.is_option_contested(option): ui_screen.blit(spr_contested_icon[self.team], (self.root_x + x_offset, self.root_y + row_y * option_height)) ui_screen.blit( get_text(menu_option_strings, option, light=True), (self.root_x + 29, self.root_y + 8 + row_y * option_height)) row_y += 1