Space Invaders Game

A Python/PyGame implementation with advanced features

This Space Invaders-style game was developed using Python and the PyGame library. It features multiple game states, sound effects, music, score tracking, and dynamic difficulty progression. The project demonstrates strong object-oriented programming skills and game development techniques.

Game Screenshots

Start Screen

Main menu with play button and instructions

Gameplay

Player ship fighting alien invaders

Game Over

Death screen with final score display

Python Techniques Used

Object-Oriented Programming

Classes for Ship, Alien, Bullet, Button, and GameStats with encapsulation

Game State Management

Handling different game states (menu, gameplay, game over)

Event Handling

Processing keyboard inputs and mouse events

Collision Detection

Using PyGame's sprite collision methods

Resource Management

Loading images, sound effects, and music from files

Data Persistence

Saving and loading high scores to/from text files

Key Game Features

Multiple game states: Menu, Active Play, Game Over
Dynamic difficulty progression with increasing alien speed
Score tracking with high score persistence
Ship lives display at bottom of screen
Fullscreen toggle capability
Different music tracks for each game state
Sound effects for shooting, explosions, and death
Visual feedback for score changes and level progression

Code Structure

The game follows a modular structure with separate files for different components:

alien_invasion.py

Main game class managing overall flow and events

settings.py

Game configuration and dynamic settings

ship.py

Player ship behavior and rendering

alien.py

Alien enemy behavior and movement

bullet.py

Projectile mechanics and rendering

button.py

Interactive menu buttons

game_stats.py

Tracking game statistics and scores

scoreboard.py

Displaying and updating score information

Code Sample

# alien_invasion.py - Main game loop
def run_game(self):
    """Start the main loop for the game."""
    while True:
        self._check_events()

        if self.stats.game_active:
            self.ship.update()
            self._update_bullets()
            self._update_aliens()
        
        self._update_screen()
        self.clock.tick(60)

def _update_bullets(self):
    """Handle all bullet behavior."""
    self.bullets.update()
    self._remove_offscreen_bullets()
    self._check_bullet_alien_collisions()
    self._check_for_new_wave()

def _check_bullet_alien_collisions(self):
    """Respond to bullet-alien collisions."""
    collisions = pygame.sprite.groupcollide(
        self.bullets, self.aliens, True, True
    )
    
    if collisions:
        for aliens in collisions.values():
            self.stats.score += self.settings.alien_points * len(aliens)
            self.explosion_sound.play()
        self.sb.prep_score()
        self.sb.check_high_score()

Technical Challenges Overcome

Resource Path Handling: Implemented robust path resolution for assets across different environments
Game State Transitions: Created seamless transitions between menu, gameplay, and game over states
Dynamic Difficulty: Implemented scaling difficulty that increases as players progress
Performance Optimization: Efficient sprite management for smooth gameplay
Audio Management: Coordinated multiple sound effects and music tracks

Project Resources

View on GitHub

Skills Demonstrated

Object-oriented design principles
Game development architecture
Event-driven programming
Cross-platform resource management
Algorithm implementation (collision detection, pathing)
User experience design for games
Problem-solving and debugging complex systems