Ticking

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}

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}

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};

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}

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};

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}

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};

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};

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};

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}

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};