Beginning C++ Game Programming, Third Edition (John Horton)（Z-Library）

【One-Line Pitch】 A hands-on, zero-prerequisite path into C++20 and 2D game development: you learn the language by building four increasingly ambitious, fully playable games with SFML. Best for complete beginners, self-taught hobbyists, and anyone who wants a project-driven refresher rather than a dry syntax reference. 【Book Arc】 - **Opening (~0%–10%)**: Environment setup (Visual Studio 2022, SFML) and the first project, Timber!!!, introduces the game loop, rendering a window, sprites, and the input-update-draw cycle. - **Early (~10%–30%)**: Core language fundamentals — variables, operators, decisions, strings, loops, arrays, switch, enumerations, and functions — applied immediately to animating sprites, HUDs, and game mechanics. - **Early–Middle (~30%–45%)**: Object-oriented programming arrives through Pong (classes, encapsulation, inheritance, polymorphism), then AABB collision detection, physics, and scorekeeping finish that game. - **Middle (~45%–60%)**: The Zombie Shooter project pushes into references, pointers, the STL (vectors, maps), the TextureHolder class, collision/pickups/bullets, SFML Views for layered HUDs, and file I/O for high scores. - **Late (~60%–85%)**: Run! rebuilds everything around advanced OOP — the Entity Component System pattern, factory pattern, smart pointers, and a generic GameObject/Component architecture. - **Ending (~85%–100%)**: Final polish with parallax backgrounds, OpenGL programmable shaders and GLSL, camera classes, and a completed endless-runner game. 【Key Takeaways】 - **Games are the teaching vehicle, not a side project** (Opening): every C++ concept is introduced because the current game needs it, which keeps motivation high and makes abstract ideas concrete. - **The game loop is the spine of everything** (Opening): input, update, draw, repeat — understanding this cycle early makes all later architecture decisions legible. - **OOP is taught progressively, not dumped upfront** (Early–Middle): classes start simple with Bat and Ball, then grow into inheritance and polymorphism, so the "why" of each feature lands before the "how." - **Pointers and the STL solve real scaling problems** (Middle): managing a horde of zombies motivates pointers, vectors, and maps far better than toy examples would. - **Design patterns appear as refactors, not theory** (Late): the Entity Component System and factory pattern emerge because the Run! game becomes unwieldy without them — a lesson in when architecture matters. - **Smart pointers and composition over inheritance** (Late): the book explicitly steers toward modern C++ ownership semantics and away from deep inheritance trees. - **Shaders and OpenGL are reachable for beginners** (Ending): GLSL is introduced gently, with a working parallax shader, showing that low-level graphics isn't off-limits. - **Four complete games beat one toy demo** (Throughout): finishing playable projects — Timberman-like, Pong, zombie shooter, endless runner — builds the confidence and portfolio to start your own. 【Reading Tips】 - **Type every line yourself.** This is a build-along book; copying code from GitHub without typing it defeats the purpose, especially in the early chapters where syntax familiarity is the goal. - **Deep-read the OOP and pointer chapters (roughly 30%–60%).** These are the conceptual bottlenecks; skimming them will make the Run! project feel like magic rather than engineering. - **Skim the asset/setup sections** (installing SFML, configuring Visual Studio, preparing sprites and sounds) on a first pass — return to them only when something breaks. - **Don't skip the "reader challenge" and FAQ boxes.** They flag the exact spots where beginners get stuck and often preview the next concept. - **After each game, close the book and rebuild one mechanic from memory** before moving on; the fourth game assumes fluency with the first three. 【Coverage Limits】 The excerpts cover the book's structure, chapter topics, and stated goals in detail, but do not include actual code listings, exercise solutions, or the full text of later chapters — so this guide describes the learning path rather than the precise implementation of any single feature.