def update(self):
game_controller = controller.get_game_controller()
current_health = game_controller.get_sans_hp()
# current_health = player.get_health()
if self.last_health != current_health:
scale = current_health / self.last_health
self.__render_health_bar(scale, current_health)
def click_handling():
game_controller = controller.get_game_controller()
if game_controller.is_paused():
pause_menu_sprite: pause_menu.Menu = pause_menu_group.sprites()[0]
if pause_menu_sprite.is_clicked_on_resume():
game_controller.unpause_game()
music.unpause_music()
if pause_menu_sprite.is_clicked_on_quit():
game_controller.quit()
if game_controller.is_at_main_menu():
main_menu_sprite: main_menu.Menu = misc_group.sprites()[1]
if main_menu_sprite.is_play_title_clicked():
game_controller.display_game()
pg.event.post(event_store.event["IN_GAME"]["object"])
if main_menu_sprite.is_quit_title_clicked():
game_controller.quit()
if main_menu_sprite.is_option_title_clicked():
pg.event.post(event_store.event["OPTION_MENU"]["object"])
if game_controller.is_at_game_over():
game_over_sprite: game_over.Menu = misc_group.sprites()[0]
if game_over_sprite.is_clicked_on_back():
game_controller.display_main_menu()
load_main_menu(config.screen_center)
if game_controller.is_at_option_menu():
option_menu_sprite: option.Menu = misc_group.sprites()[0]
if option_menu_sprite.is_clicked_on_bgm():
music.toggle_bgm()
config.toggle_bgm()
if option_menu_sprite.is_clicked_on_sfx():
config.toggle_sfx()
if option_menu_sprite.is_clicked_on_back():
game_controller.display_main_menu()
load_main_menu(config.screen_center)
def __set_heart_position(self, pos_x, pos_y):
game_controller = controller.get_game_controller()
center_adjustment = [
pos_x - self.image_size[0] / 2, pos_y - self.image_size[1] / 2
]
if game_controller.is_at_main_menu(
) or game_controller.is_at_option_menu(
) or game_controller.is_at_game_over():
self.rect.x = center_adjustment[0]
self.rect.y = center_adjustment[1]
return
if center_adjustment[1] < self.border_top_left[1] + 5:
center_adjustment[1] = self.border_top_left[1] + 5
elif center_adjustment[1] + self.image_size[1] > self.border_top_left[
1] + 200 - 5:
center_adjustment[
1] = self.border_top_left[1] + 200 - self.image_size[1] - 5
if center_adjustment[0] < self.border_top_left[0]:
center_adjustment[0] = self.border_top_left[0] + 4
elif center_adjustment[0] + self.image_size[0] > self.border_top_left[
0] + 800:
center_adjustment[
0] = self.border_top_left[0] + 800 - self.image_size[0] - 5
self.rect.x = center_adjustment[0]
self.rect.y = center_adjustment[1]
def kill_bar(self):
game_controller = controller.get_game_controller()
game_controller.toggle_attack()
spec.increment_spec_index()
game_controller.allow_new_cloud()
# game_controller.allow_new_render()
game_controller.allow_new_item()
pg.event.post(event_store.event["LOAD_BONE"]["object"])
self.kill()
def load_option_menu():
game_controller = controller.get_game_controller()
game_controller.display_option_menu()
misc_group.empty()
option_menu_sprite = option.Menu()
misc_group.add(option_menu_sprite)
# attack_bar_sprite = attack_bar.Bar()
# misc_group.add(attack_bar_sprite)
misc_group.update()
def gen_cloud():
center = config.screen_center
game_controller = controller.get_game_controller()
y_offset = random.randint(125, 280)
cloud_sprite = cloud.Cloud((center[0] + 300, center[1] + y_offset))
misc_group.add(cloud_sprite)
misc_group.update()
game_controller.block_new_cloud()
pg.time.set_timer(event_store.event["ALLOW_NEW_CLOUD"]["object"], 1000,
True)
def gen_item():
center = config.screen_center
game_controller = controller.get_game_controller()
y_offset = random.randint(225, 285)
item_sprite = item.Item((center[0] + 300, center[1] + y_offset))
misc_group.add(item_sprite)
misc_group.update()
print("CALLING NEW ITEM")
game_controller.block_new_item()
pg.time.set_timer(event_store.event["ALLOW_NEW_ITEM"]["object"], 2000,
True)
def damage_check(self):
game_controller = controller.get_game_controller()
damage = 0
if self.bar_posx <= 200 or self.bar_posx >= 395:
damage = 20
elif self.bar_posx <= 280 or self.bar_posx >= 330:
damage = 50
elif self.bar_posx < 330 or self.bar_posx > 280:
damage = 100
game_controller.handle_attack(damage)
self.kill_bar()
def key_handling(key: int):
game_controller = controller.get_game_controller()
if key == pg.K_SPACE and game_controller.is_attacking():
attack_bar_sprite: attack_bar.Bar = misc_group.sprites()[0]
attack_bar_sprite.damage_check()
if key == pg.K_ESCAPE:
if game_controller.is_paused():
game_controller.unpause_game()
music.unpause_music()
else:
pause_menu_sprite = pause_menu.Menu()
pause_menu_group.add(pause_menu_sprite)
pause_menu_group.update()
game_controller.pause_game()
music.pause_music()
def prep_for_new_render():
game_controller = controller.get_game_controller()
last_sprite = game_controller.get_last_sprite()
if not game_controller.allow_new_render:
return
if last_sprite.is_outside:
return
if spec.current_specs["type"] != "attack":
pg.time.set_timer(event_store.event["LOAD_BONE"]["object"],
spec.current_specs["start_time"], True)
game_controller.block_render()
else:
if len(obstacles_group.sprites()) == 0:
pg.event.post(event_store.event["ATTACK_SANS"]["object"])
game_controller.block_render()
game_controller.block_new_item()
game_controller.block_new_cloud()
def __handle_mouse_event(self):
(mouse_x, mouse_y) = pg.mouse.get_pos()
if self.last_mouse_movement[0] != mouse_x or self.last_mouse_movement[
1] != mouse_y:
self.__set_heart_position(mouse_x, mouse_y)
game_controller = controller.get_game_controller()
if game_controller.is_in_game():
if mouse_x < 250:
mouse_x = 250
elif mouse_x > 1025:
mouse_x = 1025
if mouse_y < 465:
mouse_y = 465
if mouse_y > 640:
mouse_y = 640
pg.mouse.set_pos((mouse_x, mouse_y))
self.last_mouse_movement[0] = mouse_x
self.last_mouse_movement[1] = mouse_y
def load_in_game(screen_center: Tuple[int, int]):
music.play_ingame_music()
spec.load_specs()
game_controller = controller.get_game_controller()
game_controller.game_loaded = True
sans_sprite = sans.Sans((screen_center[0], screen_center[1] - 100))
border_sprite = border.Border(screen_center)
health_bar_sprite = health_bar.Bar()
sans_health_sprite = sans_health_bar.Bar()
generator.generate_sprites(
(screen_center[0] + 400, screen_center[1] + 200))
character_group.add(sans_sprite)
misc_group.add(border_sprite)
gameplay_group.add(health_bar_sprite)
gameplay_group.add(sans_health_sprite)
gameplay_group.update()
character_group.update()
misc_group.update()
game_controller.display_game()
def generate_sprites(start_pos: Tuple[int, int]):
game_controller = controller.get_game_controller()
print("RENDERING INDEX: ", spec.specs_index)
current_specs = spec.current_specs
total_sprite = current_specs["quantity"]
if current_specs["type"] == "continuous":
last_sprite = continuous_bone_generator(current_specs, total_sprite,
start_pos)
elif current_specs["type"] == "double":
last_sprite = double_bone_generator(current_specs, total_sprite,
start_pos,
sprites_group.obstacles_group)
else:
last_sprite = continuous_bone_generator(current_specs, total_sprite,
start_pos)
game_controller.set_last_sprite(last_sprite)
if spec.get_specs_length() == spec.specs_index + 1:
pg.event.clear()
game_controller.block_render()
return
spec.increment_spec_index()
game_controller.allow_render()
print("READY FOR NEXT RENDER")
def main():
screen, clock = init_game()
game_controller = controller.get_game_controller()
game_controller.display_main_menu()
screen_center = (screen.get_width() / 2, screen.get_height() / 2)
load_config(screen_center)
map_event()
load_main_menu(screen_center)
pg.display.flip()
while game_controller.is_game_running():
screen.fill(BLACK)
events = pg.event.get()
for event in events:
if event.type == pg.KEYDOWN:
key_handling(event.key)
if event.type == pg.MOUSEBUTTONUP:
click_handling()
if event.type == pg.QUIT:
game_controller.quit()
if event.type == event_store.event["IN_GAME"]["value"]:
load_in_game(screen_center)
if event.type == event_store.event["LOAD_BONE"]["value"]:
if spec.specs_index != 0:
border_sprite = border.Border(screen_center)
misc_group.add(border_sprite)
generator.generate_sprites(
(screen_center[0] + 400, screen_center[1] + 200))
if event.type == event_store.event["OPTION_MENU"]["value"]:
load_option_menu()
if event.type == event_store.event["ALLOW_NEW_CLOUD"]["value"]:
game_controller.allow_new_cloud()
if event.type == event_store.event["ALLOW_NEW_ITEM"]["value"]:
game_controller.allow_new_item()
if event.type == event_store.event["GAME_OVER"]["value"]:
game_controller.display_game_over()
load_game_over(screen_center, screen)
if event.type == event_store.event["ATTACK_SANS"]["value"]:
game_controller.toggle_attack()
load_attack_bar(screen_center)
misc_group.draw(screen)
if event.type == event_store.event["END_GAME"]["value"]:
game_controller.display_end_game()
if game_controller.is_at_game_over():
misc_group.draw(screen)
spec.reset_spec_index()
game_controller.allow_render()
if game_controller.is_at_main_menu(
) or game_controller.is_at_option_menu():
misc_group.draw(screen)
gameplay_group.draw(screen)
gameplay_group.update()
misc_group.update()
if game_controller.game_loaded and game_controller.is_in_game():
if game_controller.is_paused():
pause_menu_group.draw(screen)
else:
misc_group.draw(screen)
if game_controller.is_new_cloud_allowed():
generator.gen_cloud()
if game_controller.is_new_item_allowed():
generator.gen_item()
character_group.draw(screen)
obstacles_group.draw(screen)
gameplay_group.draw(screen)
character_group.update()
obstacles_group.update()
gameplay_group.update()
misc_group.update()
check_for_collision()
prep_for_new_render()
if spec.specs_index == spec.get_specs_length() - 1 and len(
obstacles_group.sprites()) == 0:
spec.reset_spec_index()
game_controller.allow_render()
generator.generate_sprites(
(screen_center[0] + 400, screen_center[1] + 200))
pg.display.update()
clock.tick(120)
