CS50 2D - Lecture 2 - Breakout

This lecture focuses on building a Breakout game, a single-player game created by Atari in the 70s, which expands upon concepts from Pong. Key features include scoring, levels, and advanced visuals. The demo showcased paddle selection, particle systems for brick collisions, health tracking, and persistent high scores, highlighting a significant increase in features compared to previous projects. The lecture emphasizes several core topics. Sprite sheets are introduced as an efficient way to manage numerous small graphics like paddles, bricks, and backgrounds, consolidating them into a single image file to avoid unwieldy individual images. Procedural layouts are used for bricks, ensuring dynamic and varied game experiences with each playthrough. Game states, such as "serve," "play," "victory," and "game over," are crucial for managing game flow and carrying data between them. The game also incorporates levels, health, particle systems for visual effects, and advanced collision detection for the ball interacting with both the paddle and multiple bricks. Finally, persistent save data for high scores is implemented, allowing players to track their progress across sessions. The state diagram for Breakout is significantly more complex than previous games like Flappy Bird or Pong, featuring eight distinct states and unidirectional transitions. The "start" state serves as a central hub, leading to "high score" or "paddle select." From "paddle select," players move to the "serve" state, then to "play." If the player takes damage, they briefly return to "serve" before re-entering "play." Clearing all bricks leads to a "victory" state, which then transitions back to "serve" for the next level. Losing all health results in a "game over" state, from which players can either return to "start" or, if they achieved a high score, enter the "enter high score" state before proceeding to "high score" and eventually back to "start." The project structure has evolved to manage complexity. Files are organized into semantically meaningful folders like `source`, `sounds`, `lib`, `graphics`, and `fonts`. This contrasts with previous projects where files were simply placed at the parent level. Dependencies are centralized in a `source/dependencies` file, rather than requiring everything in `main.lua`. Constants are also moved to a dedicated `constants.lua` file. The initial "start" state displays a title screen with "start" and "high scores" options, navigable via arrow keys. This state, like others, is encapsulated within a central state object. `love.graphics.newQuad` is introduced to define rectangular regions within a single sprite sheet, allowing the game to draw specific parts of a texture rather than loading multiple images. This is demonstrated with paddles, which have various colors and sizes defined within one texture atlas. Utility functions in `util.lua` help generate these quads, particularly for uniformly sized elements like bricks or balls. The "bounce" update introduces the ball, which behaves similarly to Pong, bouncing off the paddle and screen edges. Ball textures are also managed via sprite sheets, allowing for various colors. Collision detection between the ball and paddle uses the same AABB (Axis-Aligned Bounding Box) method as Pong. The "brick" update introduces the main objective of Breakout: breaking bricks. Initially, a single row of bricks is displayed, and the ball collides with and removes them. The `LevelMaker` class is introduced to procedurally generate brick layouts, offering variable rows and columns within the screen's virtual resolution (432x243). Bricks are also managed as objects with an `inPlay` flag, allowing them to be visually removed and ignored for collision without being permanently deleted, which is useful for level restarts. Collision detection for bricks is more intricate than for the paddle. The system determines whether the ball collides with the top, bottom, or sides of a brick by calculating offsets and penetration depths on both the X and Y axes. The axis with the shallower penetration depth is considered the primary collision axis, determining whether the ball's DX or DY should be inverted. This also influences the paddle's ability to impart "English" or spin on the ball, changing its trajectory based on where it hits the paddle and the paddle's movement direction. The "hearts" update introduces health and scoring. The game transitions from the "play" state to the "serve" state upon losing a heart, and to the "game over" state when all hearts are lost. Scores and health are passed between states to maintain continuity. Helper functions in `main.lua` handle rendering the score and health hearts on screen. The "pretty colors" update enhances visual variety by introducing bricks of different colors and tiers, which can be broken multiple times before being removed. This adds difficulty and visual dynamism, with patterns like alternating colors or gaps in brick layouts, all procedurally generated by the `LevelMaker`. Particle systems are added to provide visual feedback when bricks are hit. `love.graphics.newParticleSystem` allows for the creation of configurable particle effects, with parameters for lifetime, acceleration, emission area, and color. Particles are colored to match the brick they emanate from, adding polish to the game. The "victory" state and level progression are implemented. After clearing all bricks, the game transitions to a "level complete" screen, incrementing the level number and passing it to the `LevelMaker` to generate progressively more difficult levels. This provides a sense of achievement and challenge. High scores and data persistence are crucial for a complete game. `love.filesystem` functions are used to save and load high scores from a file on disk, identified by a unique identity string. The game stores a table of the top ten high scores, which are loaded at startup and updated if a player achieves a new high score. An "enter high score" state allows players to input their initials using a character selection UI, with clamping logic for letter values. Finally, a "paddle select" state is added before the game starts, allowing players to choose their paddle color. This uses the same sprite sheet and quad indexing logic as other elements, providing a simple customization option. Music is also integrated for atmosphere. In conclusion, Breakout represents a significant leap in complexity, integrating sprite sheets, advanced state management, intricate collision detection, procedural generation, particle systems, and data persistence to create a comprehensive and engaging game experience. These concepts will be foundational for future lectures, particularly for games involving animations and grid-based puzzles.