Ticking

Using Tick() functions to update game objects independently of events

This lesson is part of the course:

Game Dev with SDL2

Learn C++ and SDL development by creating hands on, practical projects inspired by classic retro games

View Full CourseGet Started for Free

Abstract art representing computer programming

Ryan McCombe

Posted 8 months ago

In our previous projects, we've updated the state of our objects based on events detected in our application loop:

1// Application Loop
2while (shouldContinue) {
3  // Handle Events
4  while (SDL_PollEvent(&Event)) {
5    if (Event.type == SDL_QUIT) {
6      shouldContinue = false;
7    }
8    GameObject.HandleEvent(Event);
9  }
10    
11  // Render Objects
12  GameWindow.Render();
13  GameObject.Render(GameWindow.GetSurface());
14    
15  // Update Frame
16  GameWindow.Update();
17}

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.

Tick Functions

To implement this capability, 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 are commonly called tick functions:

1// Application Loop
2while (shouldContinue) {
3  // Handle Events
4  while (SDL_PollEvent(&Event)) {
5    if (Event.type == SDL_QUIT) {
6      shouldContinue = false;
7    }
8    GameObject.HandleEvent(Event);
9  }
10
11  // Update Objects
12  GameObject.Tick();
13    
14  // Render Objects
15  GameWindow.Render();
16  GameObject.Render(GameWindow.GetSurface());
17    
18  // Update Frame
19  GameWindow.Update();
20}

Game Objects and Worlds

Complex projects can have thousands or millions of objects that are ticking on every frame, so we commonly use an intermediate object to manage this complexity

Let's have all of our game objects inherit from a standard base class:

1// GameObject.h
2#pragma once
3#include "SDL.h"
4
5class GameObject {
6 public:
7  virtual void HandleEvent(SDL_Event& E) {
8    // ...
9  }
10
11  virtual void Tick() {
12    // ...
13  }
14
15  virtual void Render(SDL_Surface* Surface) {
16    // ...
17  }
18};

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:

1// World.h
2#pragma once
3#include <vector>
4#include <memory>
5#include "GameObject.h"
6
7class World {
8 public:
9  void HandleEvent(SDL_Event& E) {
10    for (auto& Object : Objects) {
11      Object->HandleEvent(E);
12    }
13  }
14
15  void Tick() {
16    for (auto& Object : Objects) {
17      Object->Tick();
18    }
19  }
20
21  void Render(SDL_Surface* Surface) {
22    for (auto& Object : Objects) {
23      Object->Render(Surface);
24    }
25  }
26
27 private:
28  std::vector<std::unique_ptr<GameObject>> Objects;
29}

Let's update our main application loop to use our new class:

1// main.cpp
2#include <SDL.h>
3#include "Window.h"
4#include "World.h"
5
6int main(int argc, char** argv){
7  SDL_Init(SDL_INIT_VIDEO);
8
9  Window GameWindow;
10  World GameWorld;
11
12  SDL_Event Event;
13  bool shouldContinue{true};
14
15  // Application Loop
16  while (shouldContinue) {
17    // Handle Events
18    while (SDL_PollEvent(&Event)) {
19      if (Event.type == SDL_QUIT) {
20        shouldContinue = false;
21      }
22      GameWorld.HandleEvent(Event);  
23    }
24
25    // Update Objects
26    GameWorld.Tick(); 
27
28    // Render Objects
29    GameWindow.Render();
30    GameWorld.Render(GameWindow.GetSurface()); 
31
32    // Update Frame
33    GameWindow.Update();
34  }
35
36  SDL_Quit();
37  return 0;
38}

Game Object Subtypes

We can now use inheritance and polymorphism (overriding virtual functions) to support a variety of GameObject types. Let's update our program to support Goblin objects:

1// Goblin.h
2#pragma once
3#include <string>
4#include "GameObject.h"
5
6class Goblin : public GameObject {
7 public:
8  Goblin(const std::string& name, int x, int y)
9    : Name(name), xPosition(x), yPosition(y) {}
10
11  std::string Name;
12  int xPosition;
13  int yPosition;
14};

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:

1// World.h
2// ...
3class World {
4 public:
5  Goblin& SpawnGoblin(
6    const std::string& Name, int x, int y
7  ) {
8    Objects.emplace_back(
9      std::make_unique<Goblin>(Name, x, y)
10    );
11    return static_cast<Goblin&>(*Objects.back());
12  }
13  // ...
14
15 private:
16  std::vector<std::unique_ptr<GameObject>> Objects;
17};

1// main.cpp
2// ...
3int main(int argc, char** argv){
4  // ...
5  World GameWorld;
6  Goblin& Enemy{GameWorld.SpawnGoblin(
7    "Goblin Rogue", 100, 200)};
8  std::cout << "A " << Enemy.Name
9    << " was spawned in the world";
10    
11  // ...
12}

1A Goblin Rogue was spawned in the world

Finally, we can now override the Tick() function for our Goblin objects. Let's allow our goblins to move regardless of whether any events are happening:

1// Goblin.h
2#pragma once
3#include <string>
4#include "GameObject.h"
5
6class Goblin : public GameObject {
7 public:
8  Goblin(const std::string& name, int x, int y)
9      : Name(name), xPosition(x), yPosition(y) {}
10
11  std::string Name;
12  int xPosition;
13  int yPosition;
14
15  void Tick() override {
16    std::cout << "\nTick() updating position";
17    xPosition += 1;
18  }
19
20  void Render(SDL_Surface* Surface) override {
21    std::cout
22      << " - Rendering at x = " << xPosition;
23    // ...
24  }
25};

1A Goblin Rogue was spawned in the world
2Tick() updating position - Rendering at x = 101
3Tick() updating position - Rendering at x = 102
4Tick() updating position - Rendering at x = 103
5...

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:

1// Goblin.h
2// ...
3class Goblin : public GameObject {
4 public:
5  // ...
6  int Velocity{1};
7
8  void HandleEvent(SDL_Event& E) {
9    if (E.type != SDL_KEYDOWN) return;
10    if (E.key.keysym.sym == SDLK_RIGHT) {
11      std::cout << "\nHandleEvent() setting "
12        "velocity to 1";
13      Velocity = 1;
14    } else if (E.key.keysym.sym == SDLK_LEFT) {
15      std::cout << "\nHandleEvent() setting "
16        "velocity to -1";
17      Velocity = -1;
18    }
19  }
20
21  void Tick() override {
22    std::cout << "\nTick() updating position";
23    xPosition += Velocity;
24  }
25  
26  // ...
27};

1A Goblin Rogue was spawned in the world
2Tick() updating position - Rendering at x = 101
3Tick() updating position - Rendering at x = 102
4HandleEvent() setting velocity to -1
5Tick() updating position - Rendering at x = 101
6...

Preview: 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.

Dependencies and Off-By-One-Frame Errors

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:

1// NameTag.h
2#pragma once
3#include "GameObject.h"
4#include "Goblin.h"
5
6class NameTag : public GameObject {
7 public:
8  Goblin& Parent;
9
10  void Tick() override {
11    // Are these arguments correct?
12    // It's unclear whether Parent has ticked yet
13    SomeFunction(
14      Parent.xPosition,
15      Parent.yPosition
16    )
17  }
18};

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 explicitly, 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():

1// Application Loop
2while (shouldContinue) {
3  // Handle Events
4  while (SDL_PollEvent(&Event)) {
5    // ...
6  }
7
8  // Update Objects
9  GameWorld.TickPhysics();  
10  GameWorld.TickUI();  
11
12  // Render Objects
13  GameWindow.Render();
14  GameWorld.Render(GameWindow.GetSurface());
15
16  // Update Frame
17  GameWindow.Update();
18}

If we then establish the convention that any code that updates the physical state of our world belongs in TickPhysics(), any logic in an overloaded TickUI() function can be confident that those world positions are up to date:

1// NameTag.h
2// ...
3class NameTag : public GameObject {
4 public:
5  NameTag(const Goblin& Parent)
6  : Parent(Parent) {}
7
8  Goblin& Parent;
9  int xPosition;
10  int yPosition;
11
12  void TickUI() override {
13    // We know these values have been updated
14    // because TickPhysics() happens before TickUI()
15    xPosition = Parent.xPosition;
16    yPosition = Parent.yPosition;
17  }
18};

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 subtype, and potentially multiple methods if the type has multiple constructors.

1// World.h
2// ...
3class World {
4public:
5  Goblin& SpawnGoblin(int Arg1, int Arg2) {
6    // ...
7  }
8  
9  Dragon& SpawnDragon(int Arg1) {
10    // ...
11  }
12  
13  // The Dragon type has multiple constructors
14  Dragon& SpawnDragon(int Arg1, float Arg2) {
15    // ...
16  }
17  
18  // ...
19}

We could solve this by creating objects outside of our World, and then transferring ownership:

1// World.h
2// ...
3class World {
4public:
5  void AddObject(std::unique_ptr<GameObject> Object) {
6    // ...
7  }
8}

1auto Enemy1{std::make_unique<Goblin>(100, 200)};
2World.AddObject(std::move(Enemy1));
3
4auto Enemy2{std::make_unique<Dragon>(50)};
5World.AddObject(std::move(Enemy2));
6
7auto Enemy3{std::make_unique<Dragon>(100, 0.5f)};
8World.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:

1GetWorld()->SpawnActor<Goblin>(100, 200);
2GetWorld()->SpawnActor<Dragon>(50);
3GetWorld()->SpawnActor<Dragon>(100, 0.5f);

However, implementing this requires more complex C++ techniques that may be unfamiliar:

1// World.h
2// ...
3class World {
4 public:
5  template <typename T, typename... Args>
6  T& SpawnObject(Args&&... args) {
7    Objects.emplace_back(std::make_unique<T>(
8      std::forward<Args>(args)...));
9
10    return static_cast<T&>(*Objects.back());
11  }
12  // ...
13};

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 this example, we're using the Goblin type 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 helps us forward parameters from one function to another in a way that respects the value category of the original argument.

Our more flexible API can be used like this:

1// main.cpp
2// ...
3int main(int argc, char** argv){
4  // ...
5  World GameWorld;
6  
7  Player& PlayerOne{
8    GameWorld.SpawnObject<Player>(
9      "Player One"
10    )};
11    
12  Goblin& Enemy{
13    GameWorld.SpawnObject<Goblin>(
14      "Goblin", 100, 200
15    )};
16  // ...
17}

Summary

This lesson introduced the concept of ticking in game development using C++ and SDL2:

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.