CrashOverrideX
Sealing v8.1 Subjectively Aware Standard for Hugging Face. Clean Model & Knowledge release.
a3e5f70 | from settings import * | |
| from support import draw_bar | |
| from game_data import MONSTER_DATA, ATTACK_DATA | |
| class MonsterIndex: | |
| def __init__(self, monsters, fonts, monster_frames): | |
| self.display_surface = pygame.display.get_surface() | |
| self.fonts = fonts | |
| self.monsters = monsters | |
| self.frame_index = 0 | |
| # frames | |
| self.icon_frames = monster_frames['icons'] | |
| self.monster_frames = monster_frames['monsters'] | |
| self.ui_frames = monster_frames['ui'] | |
| # tint surf | |
| self.tint_surf = pygame.Surface((WINDOW_WIDTH, WINDOW_HEIGHT)) | |
| self.tint_surf.set_alpha(200) | |
| # dimensions | |
| self.main_rect = pygame.FRect(0,0,WINDOW_WIDTH * 0.6,WINDOW_HEIGHT * 0.8).move_to(center = (WINDOW_WIDTH / 2, WINDOW_HEIGHT / 2)) | |
| # list | |
| self.visible_items = 6 | |
| self.list_width = self.main_rect.width * 0.3 | |
| self.item_height = self.main_rect.height / self.visible_items | |
| self.index = 0 | |
| self.selected_index = None | |
| # max values | |
| self.max_stats = {} | |
| for data in MONSTER_DATA.values(): | |
| for stat, value in data['stats'].items(): | |
| if stat != 'element': | |
| if stat not in self.max_stats: | |
| self.max_stats[stat] = value | |
| else: | |
| self.max_stats[stat] = value if value > self.max_stats[stat] else self.max_stats[stat] | |
| self.max_stats['health'] = self.max_stats.pop('max_health') | |
| self.max_stats['energy'] = self.max_stats.pop('max_energy') | |
| def input(self): | |
| keys = pygame.key.get_just_pressed() | |
| if keys[pygame.K_UP]: | |
| self.index -= 1 | |
| if keys[pygame.K_DOWN]: | |
| self.index += 1 | |
| if keys[pygame.K_SPACE]: | |
| if self.selected_index != None: | |
| selected_monster = self.monsters[self.selected_index] | |
| current_monster = self.monsters[self.index] | |
| self.monsters[self.index] = selected_monster | |
| self.monsters[self.selected_index] = current_monster | |
| self.selected_index = None | |
| else: | |
| self.selected_index = self.index | |
| self.index = self.index % len(self.monsters) | |
| def display_list(self): | |
| bg_rect = pygame.FRect(self.main_rect.topleft,(self.list_width, self.main_rect.height)) | |
| pygame.draw.rect(self.display_surface, COLORS['gray'], bg_rect,0,0,12,0,12,0) | |
| v_offset = 0 if self.index < self.visible_items else -(self.index - self.visible_items + 1) * self.item_height | |
| for index, monster in self.monsters.items(): | |
| # colors | |
| bg_color = COLORS['gray'] if self.index != index else COLORS['light'] | |
| text_color = COLORS['white'] if self.selected_index != index else COLORS['gold'] | |
| top = self.main_rect.top + index * self.item_height + v_offset | |
| item_rect = pygame.FRect(self.main_rect.left,top,self.list_width,self.item_height) | |
| text_surf = self.fonts['regular'].render(monster.name, False, text_color) | |
| text_rect = text_surf.get_frect(midleft = item_rect.midleft + vector(90, 0)) | |
| icon_surf = self.icon_frames[monster.name] | |
| icon_rect = icon_surf.get_frect(center = item_rect.midleft + vector(45,0)) | |
| if item_rect.colliderect(self.main_rect): | |
| # check corners | |
| if item_rect.collidepoint(self.main_rect.topleft): | |
| pygame.draw.rect(self.display_surface, bg_color, item_rect,0,0,12) | |
| elif item_rect.collidepoint(self.main_rect.bottomleft + vector(1,-1)): | |
| pygame.draw.rect(self.display_surface, bg_color, item_rect,0,0,0,0,12,0) | |
| else: | |
| pygame.draw.rect(self.display_surface, bg_color, item_rect) | |
| self.display_surface.blit(text_surf, text_rect) | |
| self.display_surface.blit(icon_surf, icon_rect) | |
| # lines | |
| for i in range(1, min(self.visible_items, len(self.monsters))): | |
| y = self.main_rect.top + self.item_height * i | |
| left = self.main_rect.left | |
| right = self.main_rect.left + self.list_width | |
| pygame.draw.line(self.display_surface, COLORS['light-gray'], (left, y), (right, y)) | |
| # shadow | |
| shadow_surf = pygame.Surface((4,self.main_rect.height)) | |
| shadow_surf.set_alpha(100) | |
| self.display_surface.blit(shadow_surf,(self.main_rect.left + self.list_width - 4,self.main_rect.top)) | |
| def display_main(self, dt): | |
| # data | |
| monster = self.monsters[self.index] | |
| # main bg | |
| rect = pygame.FRect(self.main_rect.left + self.list_width,self.main_rect.top, self.main_rect.width - self.list_width, self.main_rect.height) | |
| pygame.draw.rect(self.display_surface, COLORS['dark'], rect, 0, 12,0, 12,0) | |
| # monster display | |
| top_rect = pygame.FRect(rect.topleft, (rect.width, rect.height * 0.4)) | |
| pygame.draw.rect(self.display_surface, COLORS[monster.element], top_rect, 0,0,0,12) | |
| # monster animation | |
| self.frame_index += ANIMATION_SPEED * dt | |
| monster_surf = self.monster_frames[monster.name]['idle'][int(self.frame_index) % len(self.monster_frames[monster.name]['idle'])] | |
| monster_rect = monster_surf.get_frect(center = top_rect.center) | |
| self.display_surface.blit(monster_surf, monster_rect) | |
| # name | |
| name_surf = self.fonts['bold'].render(monster.name, False, COLORS['white']) | |
| name_rect = name_surf.get_frect(topleft = top_rect.topleft + vector(10,10)) | |
| self.display_surface.blit(name_surf, name_rect) | |
| # level | |
| level_surf = self.fonts['regular'].render(f'Lvl: {monster.level}', False, COLORS['white']) | |
| level_rect = level_surf.get_frect(bottomleft = top_rect.bottomleft + vector(10,-16)) | |
| self.display_surface.blit(level_surf, level_rect) | |
| draw_bar( | |
| surface = self.display_surface, | |
| rect = pygame.FRect(level_rect.bottomleft, (100,4)), | |
| value = monster.xp, | |
| max_value = monster.level_up, | |
| color = COLORS['white'], | |
| bg_color = COLORS['dark']) | |
| # element | |
| element_surf = self.fonts['regular'].render(monster.element, False, COLORS['white']) | |
| element_rect = element_surf.get_frect(bottomright = top_rect.bottomright + vector(-10,-10)) | |
| self.display_surface.blit(element_surf, element_rect) | |
| # health and energy | |
| bar_data = { | |
| 'width': rect.width * 0.45, | |
| 'height': 30, | |
| 'top': top_rect.bottom + rect.width * 0.03, | |
| 'left_side': rect.left + rect.width / 4, | |
| 'right_side': rect.left + rect.width * 3/4 | |
| } | |
| healthbar_rect = pygame.FRect((0,0), (bar_data['width'],bar_data['height'])).move_to(midtop = (bar_data['left_side'], bar_data['top'])) | |
| draw_bar(self.display_surface, healthbar_rect, monster.health, monster.get_stat('max_health'), COLORS['red'], COLORS['black'], 2) | |
| hp_text = self.fonts['regular'].render(f"HP: {int(monster.health)}/{int(monster.get_stat('max_health'))}", False, COLORS['white']) | |
| hp_rect = hp_text.get_frect(midleft = healthbar_rect.midleft + vector(10,0)) | |
| self.display_surface.blit(hp_text, hp_rect) | |
| energybar_rect = pygame.FRect((0,0), (bar_data['width'],bar_data['height'])).move_to(midtop = (bar_data['right_side'], bar_data['top'])) | |
| draw_bar(self.display_surface, energybar_rect, monster.energy, monster.get_stat('max_energy'), COLORS['blue'], COLORS['black'], 2) | |
| ep_text = self.fonts['regular'].render(f"EP: {int(monster.energy)}/{int(monster.get_stat('max_energy'))}", False, COLORS['white']) | |
| ep_rect = ep_text.get_frect(midleft = energybar_rect.midleft + vector(10,0)) | |
| self.display_surface.blit(ep_text, ep_rect) | |
| # info | |
| sides = {'left': healthbar_rect.left, 'right': energybar_rect.left} | |
| info_height = rect.bottom - healthbar_rect.bottom | |
| # stats | |
| stats_rect = pygame.FRect(sides['left'], healthbar_rect.bottom, healthbar_rect.width, info_height).inflate(0,-60).move(0,15) | |
| stats_text_surf = self.fonts['regular'].render('Stats', False, COLORS['white']) | |
| stats_text_rect = stats_text_surf.get_frect(bottomleft = stats_rect.topleft) | |
| self.display_surface.blit(stats_text_surf, stats_text_rect) | |
| monster_stats = monster.get_stats() | |
| stat_height = stats_rect.height / len(monster_stats) | |
| for index, (stat, value) in enumerate(monster_stats.items()): | |
| single_stat_rect = pygame.FRect(stats_rect.left,stats_rect.top + index * stat_height,stats_rect.width,stat_height) | |
| # icon | |
| icon_surf = self.ui_frames[stat] | |
| icon_rect = icon_surf.get_frect(midleft = single_stat_rect.midleft + vector(5,0)) | |
| self.display_surface.blit(icon_surf, icon_rect) | |
| # text | |
| text_surf = self.fonts['regular'].render(stat, False, COLORS['white']) | |
| text_rect = text_surf.get_frect(topleft = icon_rect.topleft + vector(30,-10)) | |
| self.display_surface.blit(text_surf, text_rect) | |
| # bar | |
| bar_rect = pygame.FRect((text_rect.left, text_rect.bottom + 2), (single_stat_rect.width - (text_rect.left - single_stat_rect.left),4)) | |
| draw_bar(self.display_surface, bar_rect, value, self.max_stats[stat] * monster.level, COLORS['white'], COLORS['black']) | |
| # abilities | |
| ability_rect = stats_rect.copy().move_to(left = sides['right']) | |
| ability_text_surf = self.fonts['regular'].render('Ability', False, COLORS['white']) | |
| ability_text_rect = ability_text_surf.get_frect(bottomleft = ability_rect.topleft) | |
| self.display_surface.blit(ability_text_surf, ability_text_rect) | |
| for index, ability in enumerate(monster.get_abilities()): | |
| element = ATTACK_DATA[ability]['element'] | |
| text_surf = self.fonts['regular'].render(ability, False, COLORS['black']) | |
| x = ability_rect.left + index % 2 * ability_rect.width / 2 | |
| y = 20 + ability_rect.top + int(index / 2) * (text_surf.get_height() + 20) | |
| rect = text_surf.get_frect(topleft = (x,y)) | |
| pygame.draw.rect(self.display_surface, COLORS[element], rect.inflate(10,10), 0, 4) | |
| self.display_surface.blit(text_surf, rect) | |
| def update(self, dt): | |
| self.input() | |
| self.display_surface.blit(self.tint_surf, (0,0)) | |
| self.display_list() | |
| self.display_main(dt) |