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 __get_cached_text__(string, light=True): color = light_color if light else dark_color background = dark_color if light else light_color if text_objects.get((string, color), None): return text_objects[(string, color)] else: new_text = draw_text(string, color, background) text_objects[(string, color)] = new_text return new_text
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) 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) self.tick += 2.5 / TICK_RATE if self.height < self.max_height and self.tick < 1: self.height += 2 elif self.height > 2 and (2 < self.tick < 3): self.height -= 2 elif (2 < self.tick < 3) and self.height == 2: # Finish the animation once we've finished shrinking self.finish_animation() ui_screen.fill(light_color, (0 + HALF_RES_WIDTH / 2, HALF_RES_HEIGHT - self.height // 2, HALF_RES_WIDTH, self.height)) ui_screen.fill(clear_color[self.get_manager(Manager.PLAYER).active_team], (1 + HALF_RES_WIDTH / 2, HALF_RES_HEIGHT + 1 - self.height // 2, HALF_RES_WIDTH - 2, self.height - 3)) if self.height == self.max_height: text_surface = draw_text(get_string(formatted_strings, "NEW_TURN_MESSAGE").format(self.turn_number), light_color) ui_screen.blit(text_surface, (HALF_RES_WIDTH - text_surface.get_width() // 2, HALF_RES_HEIGHT - text_surface.get_height() // 2))
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_upgrade_attributes(self, ui_screen): upgrade = base_upgrades[self.target] y_offset = 24 if upgrade.get(UpgradeAttribute.NEW_STAT): for piece_type, attributes in upgrade[ UpgradeAttribute.NEW_STAT].items(): for attribute in attributes: # Draw the affected piece ui_screen.blit( spr_pieces[self.team][piece_type].subsurface( 0, 0, 24, 24), (self.x + 2, self.y + 8 + y_offset)) # Render the affected attribute + its new stat text = get_string(attribute_label_strings, attribute) value = upgrade[ UpgradeAttribute.NEW_STAT][piece_type][attribute] if not isinstance(value, bool): text += " +" + str(value) ui_screen.blit(draw_text(text, dark_color, light_color), (self.x + 24, self.y + 16 + y_offset)) y_offset += 24 if upgrade.get(UpgradeAttribute.NEW_TYPE): for piece_type, attributes in upgrade[ UpgradeAttribute.NEW_TYPE].items(): for attribute in attributes: # Draw the affected piece ui_screen.blit( spr_pieces[self.team][piece_type].subsurface( 0, 0, 24, 24), (self.x + 2, self.y + 8 + y_offset)) # Render the affected attribute + its new stat text = get_string(attribute_label_strings, attribute) value = upgrade[ UpgradeAttribute.NEW_TYPE][piece_type][attribute] if not isinstance(value, bool): text += " -> " + str(value) ui_screen.blit(draw_text(text, dark_color, light_color), (self.x + 24, self.y + 16 + y_offset)) y_offset += 24 if upgrade.get(UpgradeAttribute.NEW_ATTACK_MULTIPLIER): for piece_type, multipliers in upgrade[ UpgradeAttribute.NEW_ATTACK_MULTIPLIER].items(): for enemy_archetype, value in multipliers.items(): # Render the first piece type ui_screen.blit( spr_pieces[self.team][piece_type].subsurface( 0, 0, 24, 24), (self.x + 2, self.y + 8 + y_offset)) # Render the attack icon ui_screen.blit(spr_combat_icon[self.team], (self.x + 2 + 24, self.y + 8 + y_offset)) # Render the target piece type ui_screen.blit( spr_pieces[self.team] [piece_archetype_to_type[enemy_archetype]].subsurface( 0, 0, 24, 24), (self.x + 2 + 48, self.y + 8 + y_offset)) # Render the new multiplier text = get_string(formatted_strings, "QUANTITY")\ .format(upgrade[UpgradeAttribute.NEW_ATTACK_MULTIPLIER][piece_type][enemy_archetype]) ui_screen.blit(draw_text(text, dark_color, light_color), (self.x + 72, self.y + 16 + y_offset)) y_offset += 24 if upgrade.get(UpgradeAttribute.NEW_BUILDABLE): for piece_type, new_pieces in upgrade[ UpgradeAttribute.NEW_BUILDABLE].items(): # Render the affected piece type ui_screen.blit( spr_pieces[self.team][piece_type].subsurface(0, 0, 24, 24), (self.x + 2, self.y + 8 + y_offset)) # Render the build icon ui_screen.blit(spr_build_icon[self.team], (self.x + 2 + 24, self.y + 8 + y_offset)) # Render each new buildable piece x_offset = 0 for new_piece in new_pieces: ui_screen.blit( spr_pieces[self.team][new_piece].subsurface( 0, 0, 24, 24), (self.x + 2 + 48 + x_offset, self.y + 8 + y_offset)) x_offset += 24 y_offset += 24 return y_offset