alien_invasion/alien_invasion.py

import sys
from time import sleep
import pygame
from settings import Settings
from game_stats import GameStats
from ship import Ship
from bullet import Bullet
from alien import Alien
from pygame.sprite import Group


class AlienInvasion:
  """Overall class to manage game assets and behavior."""

  def __init__(self):
    pygame.init()
    self.clock = pygame.time.Clock()
    self.settings = Settings()
    self.screen = pygame.display.set_mode((0,0), pygame.FULLSCREEN)
    self.settings.screen_width = self.screen.get_rect().width
    self.settings.screen_height = self.screen.get_rect().height
    pygame.display.set_caption("Alien Invasion")
    self.bg_color = self.settings.bg_color
    self.stats = GameStats(self)
    self.ship = Ship(self)
    self.bullets = Group()
    self.aliens = Group()
    self._create_fleet()

  def run_game(self):
    """Start the main loop for the game."""
    while True:
      # Check for events and update the game state.
      self._check_events()
      if self.stats.game_active:
        # Update the ship, bullets, and aliens.
        self.ship.update()
        self._update_bullets()
        self._update_aliens()
      # Redraw the screen during each pass through the loop.
      self._update_screen()
      self.clock.tick(60)

  def _create_fleet(self):
      """Create a fleet of aliens."""
      alien = Alien(self)
      alien_width, alien_height = alien.rect.size
      current_x, current_y = alien_width, alien_height
      while current_y < (self.settings.screen_height - 3 * alien_height):
        while current_x < (self.settings.screen_width - 2 * alien_width):
          self._create_alien(current_x, current_y)
          current_x += 2 * alien_width
        current_x = alien_width  
        current_y += 2 * alien_height

  def _create_alien(self, x_position, y_position):
      """Create an alien and place it in the fleet."""
      alien = Alien(self)
      alien.x = x_position
      alien.rect.x = x_position
      alien.rect.y = y_position
      self.aliens.add(alien)

  def _check_fleet_edges(self):
      """Respond appropriately if any aliens have reached an edge."""
      for alien in self.aliens.sprites():
          if alien.check_edges():
              self._change_fleet_direction()
              break

  def _change_fleet_direction(self):
      """Drop the entire fleet and change its direction."""
      for alien in self.aliens.sprites():
          alien.rect.y += self.settings.fleet_drop_speed
      self.settings.fleet_direction *= -1

  def _check_events(self):
    """Respond to keypresses and mouse events."""
    for event in pygame.event.get():
      if event.type == pygame.QUIT:
        sys.exit()
      elif event.type == pygame.KEYDOWN:
        self._check_keydown_events(event)
      elif event.type == pygame.KEYUP:
        self._check_keyup_events(event)

  def _check_keydown_events(self, event):
    """Respond to key presses."""
    if event.key == pygame.K_RIGHT:
      self.ship.moving_right = True
    elif event.key == pygame.K_LEFT:
      self.ship.moving_left = True
    elif event.key == pygame.K_q:
      sys.exit()
    elif event.key == pygame.K_SPACE:
      self._fire_bullet()

  def _check_keyup_events(self, event):
    """Respond to key releases."""
    if event.key == pygame.K_RIGHT:
      self.ship.moving_right = False
    elif event.key == pygame.K_LEFT:
      self.ship.moving_left = False

  def _fire_bullet(self):
    """Fire a bullet if the limit is not reached."""
    if len(self.bullets) < self.settings.bullets_allowed:
      # Create a new bullet and add it to the bullets group.
      new_bullet = Bullet(self)
      self.bullets.add(new_bullet)

  def _update_bullets(self):
    """Update position of bullets and remove old bullets."""
    self.bullets.update()
    for bullet in self.bullets.copy():
      if bullet.rect.bottom <= 0:
        self.bullets.remove(bullet)
    self._check_bullet_alien_collisions()

  def _check_alien_bottom(self):
    """Check if any aliens have reached the bottom of the screen."""
    for alien in self.aliens.sprites():
      if alien.rect.bottom >= self.settings.screen_height:
        self._ship_hit()
        break

  def _check_bullet_alien_collisions(self):
    """Respond to bullet-alien collisions."""
    collisions = pygame.sprite.groupcollide(self.bullets, self.aliens, True, True)
    if not self.aliens:
      # If the fleet is empty, create a new fleet.
      self.bullets.empty()
      self._create_fleet()

  def _ship_hit(self):
    """Respond to the ship being hit by an alien."""
    if self.stats.ships_left > 0:
      # Decrement ships_left and reset the game state.
      self.stats.ships_left -= 1
      self.bullets.empty()
      self.aliens.empty()
      self._create_fleet()
      self.ship.center_ship()
      sleep(0.5)
    else:
      self.stats.game_active = False
      pygame.mouse.set_visible(True)

  def _update_aliens(self):
    """Update the positions of aliens."""
    self._check_fleet_edges()
    self.aliens.update()
    if pygame.sprite.spritecollideany(self.ship, self.aliens):
      self._ship_hit()
      self._check_bullet_alien_collisions()
    self._check_alien_bottom()

  def _update_screen(self):
    """Update images on the screen and flip to the new screen."""
    self.screen.fill(self.bg_color)
    for bullet in self.bullets.sprites():
      bullet.draw_bullet()
    self.ship.blitme()
    self.aliens.draw(self.screen)
    pygame.display.flip()

if __name__ == '__main__':
  # Make a game instance and run the game.
  ai = AlienInvasion()
  ai.run_game()