Learn C++ and Make a Game from Scratch

Learn how to declare and use variables in C++, including std::string, integers, and floats, and print outputs with cout, newlines, and end-of-line markers.

Learn how the if statement evaluates a boolean condition to execute code blocks, using comparisons, proper booleans, and else branches, while avoiding confusing nesting and accidental assignments.

Explore using for loops with arrays and vectors, including index-based, range-based, and for-each iteration. Understand off-by-one pitfalls, size calculations, and iterators begin and end for traversing vectors.

Compare the while loop to the for loop, and learn the do while loop that runs at least once, including break, continue, and proper increment to avoid infinite loops.

Learn how switch statements work with integers and enums, including case and default handling, fall-through with breaks, and how enum types define mood options and safe enum class usage.

Learn to generate a random sequence in c++ using a vector and a seed, then scan the numbers to find the smallest value, handling empty input and edge cases.

Learn how to define and call functions to organize code, use void and return values, pass arguments with signatures, and return std::vector<int> such as random numbers for flexible programs.

Learn variadic templates and template specialization in C++, using multiple template arguments and unpacking (recursion) to sum values, including ints, floats, and strings, with practical caveats.

Learn to separate utility code into a library project and build a reusable static library while exploring includes, linking, and the role of templates and the standard library.

Explore how dynamic link libraries differ from static libraries, learn to expose functions with export/import directives, and link dlls and libs in a Visual Studio project for reusable shared code.

Explore how memory is organized as labeled boxes with addresses, how variables like x store values, and how the ampersand accesses addresses and creates references that share a memory location.

Explore how the stack memory stores variables as a top-of-stack block sequence, with scopes limiting lifetimes, as x, value, c, and d are pushed and popped during execution.

Explore how heap memory differs from the stack, how to allocate with new, and how to delete to free heap memory, preventing leaks and dangling pointers.

Diagnose access violations and memory leaks in heap-allocated memory by understanding delete, null pointers, and dangling references. Explore smart pointers in C++11 to improve memory safety.

Explore pure virtual functions and polymorphism in C++. See how abstract base classes define interfaces like take damage for characters and how virtual tables call the correct derived function.

Explore the move assignment operator and its relation to the move constructor, learning how ownership transfers between objects, guard against self-assignment, and the big five in C++.

Move class declarations to a header and definitions to a cpp file, forward declare related classes, provide copy and move constructors, and use include guards.

Learn to implement a template class in c++ by building a generic dynamic number and the big five (destructor, copy and move constructors/assignments) with int and float examples.

Learn to implement binary operators for a dynamic int outside the class, support left and right operands with int types, and understand why the friend keyword is best used sparingly.

Learn the basics of git as a version control tool and how GitHub hosts your repositories, including installation, console commands, and creating an account.

Create and switch between branches to safely develop features, fall back to the main branch when needed, then merge changes back with git merge and delete obsolete branches.

Learn to traverse git history using hard and soft resets, reflog, and restore, and understand the risks of history deletion in team workflows before mastering revert.

Master git history with revert, not reset, learning to apply on commits, use vim to edit messages, and manage branches and merging.

Install and set up cmake, a cross-platform build tool for c and c++, and add it to the system path to enable building projects via CMake lists.

Learn to set up a cross-platform C++ project with cmake by creating a cmake list and building in a build folder for light years spaceship game, without a game engine.

Learn to automate copying dynamic link libraries into the build output using CMake post-build commands, replacing manual DLL copying for SFML and other libraries.

Explore rendering in the game loop by clearing the window, drawing a 100 by 100 rectangle, and displaying the frame with a render function overridden by subclasses.

Encapsulate the program by turning main into a template entry point and splitting the engine and game into two targets, with the game supplying get application.

Define a shared core with data types and a logging macro that replaces cout with printf, enabling easy backend swapping and unified, scalable logging for your game framework.

Define common data types with type aliases for smart pointers and containers using std::unique_ptr, std::shared_ptr, std::vector, std::map, and std::unordered_map. Explain ordering, hashing, and how aliases enable future swapping of implementations.

Implement the world class to represent a level and enable loading and running multiple game levels with a template loader, begin play and tick, and a virtual destructor.

Implement a clean cycle in the asset manager by iterating the texture map with an iterator, removing textures when only one shared_ptr remains, and scheduling cleanups with a clock interval.

Add a base spaceship and a player spaceship, implementing velocity, a tick with delta time, and spawning in the world, with rotation and velocity controls for movement.

Clamp the player's movement to the game window by querying window size from the application and restricting input at left, right, top, and bottom edges before normalization.

Fetch and integrate the Box2D 2D physics engine into a C++ game project via CMake, pulling from GitHub, linking to the engine, and testing collision detection.

Implement a physics contact listener to signal actor overlaps by overriding begin and end contact, and broadcasting when actors begin and end overlap.

Explore lambdas, delegates, and the std::function class in C++, learn to broadcast events with a delegate pattern, and master capture lists, by value and by reference.

Add eye-catching hit feedback to enemies by blinking their sprite with a red color offset using a lerp during updates, and plan to spawn an explosion VFX on destruction.

Create a particle class for explosion effects in C++, with velocity, lifetime, and a fade, including random velocity, size, and lifetime, to support an explosion actor that spawns multiple particles.