A collection of classic arcade game remakes built with C++ and SFML. This project serves as a demonstration of game loop fundamentals, object-oriented design, and clean inter-file communication.

A faithful recreation of the classic "Frogger" gameplay involving lane/river navigation and timing.

• Gameplay: Navigate the frog across a busy multi-lane road and a dangerous river to reach safe lily pads.
• Technical Focus: Lane-based movement, AABB collision detection, and timed entity spawning.
• Controls:
  • Movement: Arrow Keys
  • Start: P | Restart: K (after Game Over)

A vector-style space shooter featuring physics-based movement and screen wrapping.

• Gameplay: Navigate a spaceship through an asteroid field, splitting larger rocks into smaller fragments. Watch out for the enemy UFO!
• Technical Focus: Circle-based collision, screen wrapping logic, and momentum-based movement.
• Controls:
  • Thrust: Up Arrow | Rotate: Left/Right Arrows
  • Shoot: Spacebar | Teleport: Q
  • Restart: K (after Game Over)

A core focus of these remakes is clean object-oriented design. Each project is structured to benefit from high cohesion and low coupling through:

• Class-Based Separation: Every game entity (Frog, Car, Spaceship, Asteroid) is encapsulated in its own header/source pair, maintaining its own internal state and logic.
• Accurate Class Boundaries: Logic is strictly separated between entity behavior and the overall Game controller.
• Effective Communication: Entities communicate through clean interfaces, ensuring that the game loop remains readable and maintainable.
• Custom Screen Abstraction: Both games utilize a shared abstraction over SFML, simplifying window management and asset loading.

• Game Loop: Explicit separation between Update (logic) and Draw (rendering) phases.
• Collision Systems: Optimized AABB (Axis-Aligned Bounding Box) and Circle-based detection algorithms.
• State Management: Robust handling of menu, playing, and game-over states.
• Asset Management: Integrated handling of textures and audio using SFML's native capabilities.

This project supports both Windows and macOS, using either Visual Studio or Visual Studio Code with CMake.

1. Prerequisites: Visual Studio with the "Desktop development with C++" workload installed.
2. Open Folder: Open the root Retro-Arcade-Remakes folder in Visual Studio (File > Open > Folder...).
3. Configure: Visual Studio will automatically detect the CMakeLists.txt files and configure the project.
4. Build & Run: Select the target game (Frogger or Asteroids) from the startup item dropdown and press F5 (or the Green Arrow). The build process handles copying the necessary SFML DLLs to the output directory automatically.

1. Prerequisites:
   • VS Code with the C/C++ and CMake Tools extensions.
   • A C++ compiler (like MinGW-w64 or the one from Visual Studio).
   • CMake installed and in your system's PATH.
2. Open Folder: Open the root Retro-Arcade-Remakes project folder in VS Code.
3. Configure & Build:
   • Choose your compiler when prompted by the CMake Tools extension.
   • Build the project using the "CMake: Build" button in the status bar (or via the Command Palette).
4. Run: Run the application using the "CMake: Run" command. The build script automatically copies the required SFML DLLs to the output directory.

1. Prerequisites:
   • VS Code with the C/C++ and CMake Tools extensions.
   • (SFML 2.6.2 is bundled in the repository, so no external installation is required).
2. Running the Project:
   • Via VS Code: Use the "CMake: Run" command in the Command Palette (Cmd+Shift+P). This method ensures the correct working directory for asset loading.
   • Via Terminal: Navigate to the project directory and use the standard CMake workflow:

     cd Frogger # or Asteroids
     mkdir build && cd build
     cmake ..
     make
     ./Frogger # or ./Asteroids

     Note: Always run the executable from within the build directory or via VS Code to ensure assets like textures and sounds load correctly.