In our previous projects, we've updated the state of our objects based on events detected in our event loop: ```c++ // Application Loop while (shouldContinue) { // Handle Events while (SDL_PollEvent(&Event)) { if (Event.type == SDL_EVENT_QUIT) { shouldContinue = false; } GameObject.HandleEvent(Event);// } // Render Objects GameWindow.Render(); GameObject.Render(GameWindow.GetSurface()); // Update Frame GameWindow.Update(); } ``` However, in more complex projects, most objects may need to update their state consistently, even when they're not receiving any events. For example, characters not controlled by our player may need to continue to act and move, and animation, and visual effects should continue to update. ## Starting Point To keep the focus on the new concepts, we will start with a minimal project containing just a `main.cpp` file and our `Window.h` class from earlier chapters. This provides a clean foundation for introducing the new `GameObject` and `World` classes that will be central to this chapter's lessons: ```c++ #include #include #include "Window.h" int main(int, char**) { SDL_Init(SDL_INIT_VIDEO); Window GameWindow; bool IsRunning = true; SDL_Event Event; while (IsRunning) { while (SDL_PollEvent(&Event)) { if (Event.type == SDL_EVENT_QUIT) { IsRunning = false; } } GameWindow.Render(); GameWindow.Update(); } SDL_Quit(); return 0; } ``` ```c++ #pragma once #include class Window { public: Window() { SDLWindow = SDL_CreateWindow( "My Program", 600, 300, 0 ); } void Render() { const auto* Fmt = SDL_GetPixelFormatDetails( GetSurface()->format ); SDL_FillSurfaceRect( GetSurface(), nullptr, SDL_MapRGB(Fmt, nullptr, 50, 50, 50) ); } void Update() { SDL_UpdateWindowSurface(SDLWindow); } SDL_Surface* GetSurface() const { return SDL_GetWindowSurface(SDLWindow); } Window(const Window&) = delete; Window& operator=(const Window&) = delete; ~Window() { if (SDLWindow && SDL_WasInit(SDL_INIT_VIDEO)) { SDL_DestroyWindow(SDLWindow); } } private: SDL_Window* SDLWindow{nullptr}; }; ``` ## Tick Functions To allow our objects to update independently of events, our applications can introduce the notion of _**ticking**_. On every iteration of our application loop, we call a function on our objects that allows them to update their state. These functions are commonly given names like `Tick()` or `Update()`: ```c++ // Application Loop while (shouldContinue) { // Handle Events while (SDL_PollEvent(&Event)) { if (Event.type == SDL_EVENT_QUIT) { shouldContinue = false; } GameObject.HandleEvent(Event); } // Update Objects// GameObject.Tick();// // Render Objects GameWindow.Render(); GameObject.Render(GameWindow.GetSurface()); // Update Frame GameWindow.Update(); } ``` ## Game Objects and Worlds Complex projects can have thousands or millions of objects that are ticking on every frame so, as before, we commonly use an intermediate manager-style object to manage this complexity. Let's have all of our game objects inherit from a standard base class called `GameObject`: ```c++ #pragma once #include class GameObject { public: virtual void HandleEvent(const SDL_Event& E) { // ... } virtual void Tick() { // ... } virtual void Render(SDL_Surface* Surface) { // ... } }; ``` We'll create a `World` class that manages all of the game objects in our world. When our main application loop prompts our world to handle an event, tick, or render, we'll forward that instruction to all of our objects: ```c++ #pragma once #include #include #include "GameObject.h" class World { public: void HandleEvent(const SDL_Event& E) { for (auto& Object : Objects) { Object->HandleEvent(E); } } void Tick() { for (auto& Object : Objects) { Object->Tick(); } } void Render(SDL_Surface* Surface) { for (auto& Object : Objects) { Object->Render(Surface); } } private: std::vector> Objects; }; ``` Let's update our main application loop to use our new class: ```c++ #include #include #include "Window.h" #include "World.h" int main(int, char**){ SDL_Init(SDL_INIT_VIDEO); Window GameWindow; World GameWorld; SDL_Event Event; bool shouldContinue{true}; // Application Loop while (shouldContinue) { // Handle Events while (SDL_PollEvent(&Event)) { if (Event.type == SDL_EVENT_QUIT) { shouldContinue = false; } GameWorld.HandleEvent(Event); // } // Update Objects GameWorld.Tick(); // // Render Objects GameWindow.Render(); GameWorld.Render(GameWindow.GetSurface()); // // Update Frame GameWindow.Update(); } SDL_Quit(); return 0; } ``` ## Game Object Subtypes We can now use inheritance and runtime polymorphism (overriding `virtual` functions) to support a variety of `GameObject` types. Let's update our program to support `Goblin` objects: ```c++ #pragma once #include #include "GameObject.h" class Goblin : public GameObject { public: Goblin(const std::string& name, int x, int y) : Name(name), xPosition(x), yPosition(y) {} std::string Name; int xPosition; int yPosition; }; ``` We'll add a `SpawnGoblin()` method to the `World` class, which will create a `GameObject` managed by that `World` when called. This function will also return a reference to the spawned object, so callers can access it if needed: ```c++ #pragma once #include #include #include "GameObject.h" #include "Goblin.h" class World { public: void HandleEvent(const SDL_Event& E) { for (auto& Object : Objects) { Object->HandleEvent(E); } } void Tick() { for (auto& Object : Objects) { Object->Tick(); } } void Render(SDL_Surface* Surface) { for (auto& Object : Objects) { Object->Render(Surface); } } Goblin& SpawnGoblin(// const std::string& Name, int x, int y// ) {// Objects.emplace_back(// std::make_unique(Name, x, y)// );// return static_cast(*Objects.back());// }// private: std::vector> Objects; }; ``` We can now add `Goblin`s to our `World` using this function: ```c++ // main.cpp #include #include #include #include "Window.h" #include "World.h" #include "Goblin.h" int main(int, char**){ // ... World GameWorld; Goblin& Enemy{GameWorld.SpawnGoblin( "Goblin Rogue", 100, 200)}; std::cout << "A " << Enemy.Name << " was spawned in the world"; // ... } ``` ```c++ // A Goblin Rogue was spawned in the world ``` Finally, we can override the `Tick()` function for our `Goblin` objects. Let's allow our goblins to move regardless of whether any events are happening: ```c++ #pragma once #include #include #include "GameObject.h" class Goblin : public GameObject { public: Goblin(const std::string& name, int x, int y) : Name(name), xPosition(x), yPosition(y) {} std::string Name; int xPosition; int yPosition; void Tick() override { std::cout << "\nTick() updating position"; xPosition += 1; } void Render(SDL_Surface* Surface) override { std::cout << " - Rendering at x = " << xPosition; // ... } }; ``` ```c++ // A Goblin Rogue was spawned in the world Tick() updating position - Rendering at x = 101 Tick() updating position - Rendering at x = 102 Tick() updating position - Rendering at x = 103 ... ``` If needed, they can also react to events in addition to ticking. When the player presses an arrow key, let's change the direction our `Goblin` moves on each tick: ```c++ #pragma once #include #include #include #include "GameObject.h" class Goblin : public GameObject { public: Goblin(const std::string& name, int x, int y) : Name(name), xPosition(x), yPosition(y) {} std::string Name; int xPosition; int yPosition; int Velocity{1}; void HandleEvent(const SDL_Event& E) override { if (E.type != SDL_EVENT_KEY_DOWN) return; if (E.key.key == SDLK_RIGHT) { std::cout << "\nHandleEvent() setting " "velocity to 1"; Velocity = 1; } else if (E.key.key == SDLK_LEFT) { std::cout << "\nHandleEvent() setting " "velocity to -1"; Velocity = -1; } } void Tick() override { std::cout << "\nTick() updating position"; xPosition += Velocity; } void Render(SDL_Surface* Surface) override { std::cout << " - Rendering at x = " << xPosition; // ... } }; ``` ```c++ // A Goblin Rogue was spawned in the world Tick() updating position - Rendering at x = 101 Tick() updating position - Rendering at x = 102 HandleEvent() setting velocity to -1 Tick() updating position - Rendering at x = 101 ... ``` ## Complete Code A complete version of the architecture we built in this lesson is available below: ```c++ #include #include #include "Window.h" #include "World.h" int main(int, char**) { SDL_Init(SDL_INIT_VIDEO); Window GameWindow; World GameWorld; GameWorld.SpawnGoblin("Goblin Rogue", 100, 200); bool IsRunning = true; SDL_Event Event; while (IsRunning) { while (SDL_PollEvent(&Event)) { if (Event.type == SDL_EVENT_QUIT) { IsRunning = false; } GameWorld.HandleEvent(Event); } GameWorld.Tick(); GameWindow.Render(); GameWorld.Render(GameWindow.GetSurface()); GameWindow.Update(); } SDL_Quit(); return 0; } ``` ```c++ #pragma once #include class Window { public: Window() { SDLWindow = SDL_CreateWindow( "My Program", 600, 300, 0 ); } void Render() { const auto* Fmt = SDL_GetPixelFormatDetails( GetSurface()->format ); SDL_FillSurfaceRect( GetSurface(), nullptr, SDL_MapRGB(Fmt, nullptr, 50, 50, 50) ); } void Update() { SDL_UpdateWindowSurface(SDLWindow); } SDL_Surface* GetSurface() const { return SDL_GetWindowSurface(SDLWindow); } Window(const Window&) = delete; Window& operator=(const Window&) = delete; ~Window() { if (SDLWindow && SDL_WasInit(SDL_INIT_VIDEO)) { SDL_DestroyWindow(SDLWindow); } } private: SDL_Window* SDLWindow{nullptr}; }; ``` ```c++ #pragma once #include class GameObject { public: virtual void HandleEvent(const SDL_Event& E) {} virtual void Tick() {} virtual void Render(SDL_Surface* Surface) {} virtual ~GameObject() = default; }; ``` ```c++ #pragma once #include #include #include #include "GameObject.h" #include "Goblin.h" class World { public: void HandleEvent(const SDL_Event& E) { for (auto& Object : Objects) { Object->HandleEvent(E); } } void Tick() { for (auto& Object : Objects) { Object->Tick(); } } void Render(SDL_Surface* Surface) { for (auto& Object : Objects) { Object->Render(Surface); } } Goblin& SpawnGoblin( const std::string& Name, int x, int y ) { Objects.emplace_back( std::make_unique(Name, x, y) ); return static_cast(*Objects.back()); } private: std::vector> Objects; }; ``` ```c++ #pragma once #include #include #include #include "GameObject.h" class Goblin : public GameObject { public: Goblin(const std::string& name, int x, int y) : Name(name), xPosition(x), yPosition(y) {} std::string Name; int xPosition; int yPosition; int Velocity{1}; void HandleEvent(const SDL_Event& E) override { if (E.type != SDL_EVENT_KEY_DOWN) return; if (E.key.key == SDLK_RIGHT) { std::cout << "\nHandleEvent() setting " "velocity to 1"; Velocity = 1; } else if (E.key.key == SDLK_LEFT) { std::cout << "\nHandleEvent() setting " "velocity to -1"; Velocity = -1; } } void Tick() override { std::cout << "\nTick() updating position"; xPosition += Velocity; } void Render(SDL_Surface* Surface) override { std::cout << " - Rendering at x = " << xPosition; // ... } }; ``` ### Using Time Deltas The previous example is setting our object's velocity in terms of ticks - that is, our object is moving by one unit per tick. This is generally not recommended, as we do not know how much time has passed between invocations of `Tick()`. If our game can complete iterations of its application loop more quickly, that means our `Tick()` functions will be called more frequently, and our objects will therefore move faster than we intended. In the next lesson, we'll expand our tick functions to include _**time deltas**_. This allows us to implement our behaviors in terms of consistent, real-world units such as seconds and milliseconds. ## Advanced: Tick Dependencies In complex projects, updating objects often depends on the state of other objects in the world. For example, consider a UI element that appears attached to one of our game objects: ```c++ #pragma once #include "GameObject.h" #include "Goblin.h" class NameTag : public GameObject { public: Goblin& Parent; void Tick() override { // Are these arguments correct? // It's unclear whether Parent has ticked yet SomeFunction( Parent.xPosition,// Parent.yPosition// ); } }; ``` The issue here is that we don't know the order in which our objects' `Tick()` functions are called. If `Parent` ticks before `NameTag`, there's no problem. However, if `NameTag` ticks first, the `Parent.xPosition` and `Parent.yPosition` values will not have been updated yet, resulting in stale data. Using these stale values means our `NameTag`'s position will be based on where the `Goblin` was in the previous frame, not the current frame. As a result, our `NameTag` will lag one frame behind the `Goblin` object it's supposed to be attached to. These off-by-one-frame issues are extremely common, even in major released projects. They're difficult to notice, especially when many things are happening on-screen simultaneously. However, they contribute to a general feeling that our game is less responsive than it should be, so it's worth preventing these problems where possible. In complex projects, the architecture to manage these inter-object dependencies can get quite elaborate. A common and simple first step involves breaking our tick process into multiple phases and establishing a convention on what type of updates should be performed in each phase. For example, we could split our ticking into two phases: `TickPhysics()`, followed by `TickUI()`: ```c++ // Application Loop while (shouldContinue) { // Handle Events while (SDL_PollEvent(&Event)) { // ... } // Update Objects GameWorld.TickPhysics(); // GameWorld.TickUI(); // // Render Objects GameWindow.Render(); GameWorld.Render(GameWindow.GetSurface()); // Update Frame GameWindow.Update(); } ``` We can then establish the convention that any code that updates the physical state of our world belongs in `TickPhysics()`. Our `TickUI()` functions are called after **all** objects have had their `TickPhysics()` functions called, so any code in a `TickUI()` function can be confident that our object's positions in the world are up to date: ```c++ #pragma once #include "GameObject.h" #include "Goblin.h" class NameTag : public GameObject { public: NameTag(const Goblin& Parent) : Parent(Parent) {} Goblin& Parent; int xPosition; int yPosition; void TickUI() override { // We know these values have been updated // because TickPhysics() happens before TickUI() xPosition = Parent.xPosition;// yPosition = Parent.yPosition;// } }; ``` ## Advanced: Generalizing Object Creation The `GameWorld.SpawnGoblin(Name, x, y)` approach in this section was used to simplify memory management. It absolves consumers from needing to manage the lifecycle of their `GameObject` instances, as it is all handled by the `World` class. However, larger projects can have hundreds or thousands of `GameObject` subtypes. Therefore, scaling this technique would involve adding an additional method to our `World` class for each of these subtypes, and potentially multiple methods if the type has multiple constructors. ```c++ // World.h // ... class World { public: Goblin& SpawnGoblin(int Arg1, int Arg2) { // ... } Dragon& SpawnDragon(int Arg1) { // ... } // The Dragon type has multiple constructors Dragon& SpawnDragon(int Arg1, float Arg2) { // ... } // ... }; ``` We could solve this by creating objects outside of our `World`, and then transferring ownership: ```c++ // World.h // ... class World { public: void AddObject(std::unique_ptr Object) { // ... } }; ``` ```c++ auto Enemy1{std::make_unique(100, 200)}; World.AddObject(std::move(Enemy1)); auto Enemy2{std::make_unique(50)}; World.AddObject(std::move(Enemy2)); auto Enemy3{std::make_unique(100, 0.5f)}; World.AddObject(std::move(Enemy3)); ``` We can make this API simpler and less error-prone. For comparison, the Unreal Engine API for creating objects in the world looks like this: ```c++ GetWorld()->SpawnActor(100, 200); GetWorld()->SpawnActor(50); GetWorld()->SpawnActor(100, 0.5f); ``` However, implementing this requires more complex C++ techniques that may be unfamiliar, so don't worry if this is difficult to follow. It's not required for this course and is only included as a reference: ```c++ // ... class World { public: template T& SpawnObject(Args&&... args) { Objects.emplace_back(std::make_unique( std::forward(args)...)); return static_cast(*Objects.back()); } // ... }; ``` We introduce these techniques and cover them in more detail in our advanced course. They include: - Function templates, which enable the compiler to create functions at compile time, based on template arguments we provide between `<` and `>` tokens. In the following example, we're using the `Player` and `Goblin` types as a template argument. - The `...` syntax, which allows us to create variadic functions. Variadic functions can handle a variable number of parameters. In this example, we're collecting an unknown number of parameters to forward to the constructor of the type we passed as a template argument. - The `std::forward` function, which implements perfect forwarding. This allows arguments to be forwarded from one function to another in a way that respects their **value category**. Our more flexible API can be used like this: ```c++ // main.cpp // ... int main(int, char**){ // ... World GameWorld; Player& PlayerOne{ GameWorld.SpawnObject( "Player One" )}; Goblin& Enemy{ GameWorld.SpawnObject( "Goblin", 100, 200 )}; // ... } ``` ## Summary This lesson introduced the concept of **ticking**: - We introduced tick functions, and how we can use them to allow our objects to update their state on every frame. - We created `GameObject` and `World` classes to manage multiple game objects and remove complexity from our application loop. - We discussed potential issues like off-by-one-frame errors and how to mitigate them. - Finally, we explored advanced techniques for generalizing object creation in larger projects.

Ticking

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation