Project Overview
This project is a Python implementation of the classic Breakout arcade game, built using the turtle graphics module and organized with Object-Oriented Programming (OOP) principles. The player controls a paddle at the bottom of the screen, bouncing a ball to break a wall of coloured bricks while keeping the ball in play inside visible boundaries. It started as a simple “everything-in-one-file” script and evolved into a cleaner, more maintainable OOP design.
Core Technologies
- Python – main programming language
- turtle – simple 2D graphics for rendering the game
- Object-Oriented Programming – Paddle, Ball, BrickWall, and Scoreboard classes
Technical Execution & Problem Solving
The first working version of this project was written procedurally in a single file: one big game loop, lots of shared variables, and inline collision checks. It worked, but as features like brick collision, score tracking, and visible walls were added, the code became hard to reason about and debug.
To fix this, the game was refactored into a set of focused classes:
- Paddle – handles horizontal movement and boundary checks.
- Ball – manages position updates, wall bounces, paddle bounces, and reset behavior.
- BrickWall – creates and stores all brick objects, and exposes a method to check and handle ball–brick collisions.
- Scoreboard – tracks the current score, updates the HUD, and displays the “GAME OVER” message.
A simple draw_walls() helper is used to render a visible frame, making
it clear when the ball hits the boundaries. The main loop is now responsible only for
high-level orchestration: moving the ball, checking collisions, and updating the screen.
This separation of concerns makes the project easier to extend (e.g. adding lives,
power-ups, or multiple levels) without turning the main file into a tangle of
conditionals.
Key Features
- Retro-style Breakout gameplay using Python’s built-in turtle graphics.
- OOP-based architecture with dedicated classes for paddle, ball, bricks, and score.
- Visible playfield walls drawn around the game area for clear collision feedback.
- Brick collision detection that removes bricks and increments the score.
- Scoreboard HUD at the top of the screen, displaying the current score and game-over state.
- Clean main loop that reads almost like pseudocode: move ball → bounce → collide → update score.
Demonstrated Skill Set
- Object-Oriented Design: turning a procedural prototype into structured classes.
- Game loop and state management: frame updates, timing, and collision checks.
- 2D geometry: basic coordinate-based collision detection between the ball, paddle, bricks, and walls.
- Refactoring: migrating from a “big script” approach to a modular, readable codebase.
- Debugging: iterating on collision thresholds and boundaries to make gameplay feel fair and responsive.
What I Learned & Next Steps
The biggest lesson from this project was why OOP matters. The initial single-file version became hard to maintain once more features were added, even though it technically worked. Refactoring into classes made everything clearer: each object owns its behavior, and the game loop just coordinates them. This directly reinforced the concepts from Day 22 (Pong) and showed how they scale to more complex games like Breakout.
If I were to extend this further, I would:
- Add multiple lives and levels with increasing difficulty.
- Introduce power-ups (wider paddle, multi-ball, slow motion, etc.).
- Experiment with sound effects and simple animations.
- Extract each class into its own module to mirror a more “engine-like” structure.
Overall, this project was a practical exercise in balancing simplicity with structure. Starting procedurally helped me get something working quickly; refactoring into OOP made it something I’d be happy to show in a portfolio.