Refactor game.py to separate event management logic to EventsManager …

…class Separated the event management logic from game.py to a new class called EventsManager. The EventsManager class manages the events in the game, such as mouse clicks and key presses. The code has been updated to be compatible with the new class, and the changes have improved the readability of the code. Additionally, added comments to the game.py file to aid understanding.
UserMarekDrag · May 10, 2023 · c72862b · c72862b
1 parent b935456
commit c72862b
Show file tree

Hide file tree

Showing 3 changed files with 131 additions and 41 deletions.
diff --git a/.idea/workspace.xml b/.idea/workspace.xml
diff --git a/events_manager.py b/events_manager.py
@@ -0,0 1,80 @@
 import pygame
 from enemy import Mage, Boss
 from monster import Monster
 
 
 class EventsManager:
  """
  A class responsible for managing events in the game, such as handling user input and managing object interactions.
  """
 
  __shooting_enemies = (Mage, Boss)
 
  def __init__(self, window):
  self.window = window
  self.run = True
 
  def events(self, level_manager, player):
  """
  Process all game events, such as moving characters and handling collisions.
  """
  self.handle_enemy_shooting(level_manager, player)
  self.handle_enemy_moving(level_manager, player)
  self.handle_player_moving(player)
  self.handle_collision(level_manager, player)
  self.handle_fighting(level_manager, player)
 
  pygame.display.update()
 
  def handle_user_input(self, player):
  """
  Handle user input events.
  """
  for event in pygame.event.get():
  if event.type == pygame.QUIT:
  self.run = False
  if event.type == pygame.KEYDOWN:
  player.shoot(event)
 
  def get_alive_enemies(self, level_manager):
  """
  Get a list of all alive enemies.
  """
  return [enemy for enemy in level_manager.get_enemies() if enemy.is_alive]
 
  def handle_enemy_shooting(self, level_manager, player):
  """
  Handle enemy shooting events.
  """
  for enemy in self.get_alive_enemies(level_manager):
  if isinstance(enemy, self.__shooting_enemies):
  enemy.shoot(player)
 
  def handle_enemy_moving(self, level_manager, player):
  """
  Handle enemy movement events.
  """
  for enemy in self.get_alive_enemies(level_manager):
  enemy.move(target=player.rect)
 
  def handle_player_moving(self, player):
  """
  Handle player movement events based on key presses.
  """
  keys_pressed = pygame.key.get_pressed()
  player.move(keys=keys_pressed)
 
  def handle_fighting(self, level_manager, player):
  """
  Handle fighting events between the player and enemies.
  """
  for enemy in self.get_alive_enemies(level_manager):
  player.handle_bullets(enemy=enemy, win=self.window)
  enemy.handle_monster_bullets(player=player, win=self.window)
 
  def handle_collision(self, level_manager, player):
  """
  Handle collision events between the player and enemies.
  """
  for enemy in self.get_alive_enemies(level_manager):
  player.check_collision(enemy, Monster)
diff --git a/game.py b/game.py
@@ -1,11 1,10 @@
 import pygame
 from config import Config
 from player import Player
-from monster import Monster
-from enemy import Mage, Boss
 from backgrounds import Backgrounds
 from level_manager import LevelManager
 from display_manager import DisplayManager
 from events_manager import EventsManager
 
 backgrounds = Backgrounds()
 config = Config()
@@ -14,64 13,59 @@
 
 
 class Game:
-
- __shooting_enemies = (Mage, Boss)
  """
  Main Game class responsible for the game loop, checking the game state and controlling the game flow.
  """
 
  def __init__(self, menu):
  self.window = pygame.display.set_mode((config.WIDTH, config.HEIGHT))
  self.display_manager = DisplayManager(self.window)
  self.events_manager = EventsManager(self.window)
  self.clock = pygame.time.Clock()
  self.run = True
  self.stop = False
  self.player = None
  self.level_manager = LevelManager()
  self.menu = menu
 
- def events(self):
-
- for event in pygame.event.get():
- if event.type == pygame.QUIT:
- self.run = False
- if event.type == pygame.KEYDOWN:
- self.player.shoot(event)
-
- for enemy in self.level_manager.get_enemies():
- if enemy.is_alive and isinstance(enemy, self.__shooting_enemies):
- enemy.shoot(self.player)
-
- def character_movement(self):
- keys_pressed = pygame.key.get_pressed()
-
- self.player.move(keys=keys_pressed)
  def check_winner(self):
  """
  Check for the game end condition and return the winner.
  """
  if self.level_manager.all_enemies_defeated and self.level_manager.level == 5:
  return 'You Win!'
  elif not self.player.is_alive:
  return 'You died'
  else:
  return ""
 
- for enemy in self.level_manager.get_enemies():
- if enemy.is_alive:
- enemy.move(target=self.player.rect)
  def draw_winner_and_end_game(self, winner_text):
  """
  Display the winner and end the game.
  """
  self.display_manager.draw_winner(winner_text)
  self.stop = True
 
  def who_win(self):
- winner_text = ""
  """
  Determine the winner and end the game if a winner is found.
  """
  winner_text = None
  if self.level_manager.all_enemies_defeated and self.level_manager.level == 5:
  winner_text = 'You Win!'
 
  elif not self.player.is_alive:
  winner_text = 'You died'
 
- if winner_text != "":
  if winner_text:
  draw_text = self.display_manager.draw_winner(winner_text)
  self.menu.menu_end(draw_text)
  self.stop = True
 
- def update_fight(self):
- self.character_movement()
-
- for enemy in self.level_manager.get_enemies():
- if enemy.is_alive:
- self.player.check_collision(enemy, Monster)
- self.player.handle_bullets(enemy=enemy, win=self.window)
- enemy.handle_monster_bullets(player=self.player, win=self.window)
-
- pygame.display.update()
-
  def new_game(self):
  """
  Start a new game, resetting the level and player.
  """
  self.level_manager.level = 1
  self.level_manager.enemies = []
  self.player.reset()
@@ -80,22 74,27 @@ def new_game(self):
  self.main()
 
  def next_level(self):
-
  """
  Advance to the next level if all enemies are defeated.
  """
  if all(enemy.is_alive is False for enemy in self.level_manager.get_enemies()):
  self.display_manager.draw_level(self.level_manager)
  self.level_manager.go_to_next_level()
  else:
  return
 
  def main(self):
  """
  Main game loop, handling game events and updates.
  """
  self.player = Player(self.menu.character_update())
-
  while self.run:
  self.next_level()
- self.events()
  self.events_manager.handle_user_input(self.player)
  if not self.stop:
- self.update_fight()
  self.events_manager.events(self.level_manager, self.player)
  self.who_win()
  else:
  break
  self.display_manager.draw(self.player, self.level_manager)
  self.run = self.events_manager.run