Snake Movement and Navigation

Learn how to implement core snake game mechanics including movement, controls, and state management

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

Get Started for Free

Ryan McCombe

Posted 8 hours ago

In this lesson, we'll implement the core mechanics of our snake game. We'll create the game state management system, handle user input for controlling the snake's movement, and implement the snake's movement logic. By the end, you'll have a fully functional snake that responds to player controls.

We'll start by defining the fundamental data structures needed to track our snake's state, including its position, length, and direction. Then we'll expand our state system to advance the game through time.

Finally, we’ll allow our game state to respond to user input, allowing the player to control the direction their snake moves.

Adding a `SnakeData` Struct

Let’s start by defining a simple struct that stores the current state of our snake. We’ll store the row and column of the snake’s head, how long the snake is, and the direction it is currently moving:

1// SnakeData.h
2#pragma once
3
4enum MovementDirection { Up, Down, Left, Right };
5
6struct SnakeData {
7  int HeadRow;
8  int HeadCol;
9  int Length;
10  MovementDirection Direction;
11};

Alternative Implementations

In this version of the game, the type we use to manage our snake - SnakeData - will be a very simple type comprising only 4 variables and no functions. This is because much of the complexity is going to be managed by the Cell class, which will keep track of whether or not each cell contains a snake segment.

As with all programming projects, there are many ways to solve any problem. We could have a more complex Snake type and transfer some responsibility away from our Cell class. It is likely to feel more intuitive that all snake behavior be the responsibility of a Snake class rather than a bunch of Cell objects managing individual segments.

The Snake approach tends to be a little more complex to implement, but feel free to experiment here and implement the game differently from what we’re showing if you feel more comfortable.

Adding a `GameState` Class

When we’re working on a game, it is common to have an object that is designed to manage the overall state of our game world. We’ll create a GameState class for this. Game states typically don’t need to be rendered, but they usually need to be notified of events and ticks, so we’ll add our HandleEvent() and Tick() functions:

1// GameState.h
2#pragma once
3#include <SDL.h>
4
5class GameState {
6public:
7  void HandleEvent(SDL_Event& E) {}
8  void Tick(Uint32 DeltaTime) {}
9};

This GameState class will also be responsible for managing the state of our snake, so we’ll store a SnakeData object. As we covered before, the snake will initially have the following characteristics:

Its head will be on the middle row, ie CONFIG::GRID_ROWS / 2
Its head will be on column 3
Its length will be 2
It will be moving Right

Let’s initialize our SnakeData accordingly:

1// GameState.h
2// ...
3#include "SnakeData.h"
4
5class GameState {
6  // ...
7private:
8  SnakeData Snake{
9    Config::GRID_ROWS / 2, 3, 2, Right};
10};

Designated Initialization

The initialization in our previous example can be a little difficult to read. We have four arguments provided as Config::GRID_ROWS / 2, 3, 2, Right, and it’s not immediately clear which argument maps to which SnakeData member variable.

Arguments are mapped to to the members based on their order but, without opening the SnakeData.h file, it’s not clear what the order should be.

C++20 added designated initialization, which we can use to initialize data members by name rather than by order. The syntax is as follows - note the . before each name:

1SnakeData Snake{
2  .HeadRow = Config::GRID_ROWS / 2,
3  .HeadCol = 3,
4  .Length = 2,
5  .Direction = Right
6};

This makes our initialization a little easier to follow, but it is also more resilient, as it will continue to work as expected even if the members within the SnakeData struct are reordered.

We cover dedicated initialization and similar techniques in detail in our advanced course:

Abstract art representing computer programming

List, Aggregate, and Designated Initialization

A quick guide to creating objects using lists, including std::initializer_list, aggregate and designated initialization

Over in main.cpp, let’s initialize our GameState struct and call HandleEvent() and Tick() at the appropriate times within our game loop:

1// main.cpp
2#include <SDL.h>
3#include <SDL_image.h>
4#include <SDL_ttf.h>
5
6#include "Engine/Window.h"
7#include "GameState.h"
8#include "GameUI.h"
9
10int main(int argc, char** argv) {
11  SDL_Init(SDL_INIT_VIDEO);
12  CheckSDLError("Initializing SDL");
13
14  IMG_Init(IMG_INIT_PNG);
15  CheckSDLError("Initializing SDL_image");
16
17  TTF_Init();
18  CheckSDLError("Initializing SDL_ttf");
19
20  Window GameWindow;
21  GameUI UI;
22  GameState State;
23
24  Uint32 PreviousTick{SDL_GetTicks()};
25  Uint32 CurrentTick;
26  Uint32 DeltaTime;
27
28  SDL_Event Event;
29  while (true) {
30    CurrentTick = SDL_GetTicks();
31    DeltaTime = CurrentTick - PreviousTick;
32
33    // Events
34    while (SDL_PollEvent(&Event)) {
35      UI.HandleEvent(Event);
36      State.HandleEvent(Event);
37      if (Event.type == SDL_QUIT) {
38        SDL_Quit();
39        IMG_Quit();
40        return 0;
41      }
42    }
43
44    // Tick
45    State.Tick(DeltaTime);
46    UI.Tick(DeltaTime);
47
48    // Render
49    GameWindow.Render();
50    UI.Render(GameWindow.GetSurface());
51
52    // Swap
53    GameWindow.Update();
54
55    PreviousTick = CurrentTick;
56  }
57
58  return 0;
59}

Advancing the Game State

In most Snake implementations, our game advances on a specific interval. For example, every 200 milliseconds, our snake’s position changes. Let’s start by defining this advance interval as a variable within our GameConfig.h file:

1// GameConfig.h
2// ...
3
4namespace Config{
5  // ...
6  inline constexpr int ADVANCE_INTERVAL{200};
7  // ...
8}
9
10// ...

We’ll also define a user event that we can use with SDL’s event mechanism. We can dispatch this user event any time our game advances, so any component that needs to react to this can do so. We covered user events in more detail in a dedicated lesson earlier in the course:

Custom User Events

Discover how to use the SDL2 event system to handle custom, game-specific interactions

Let’s start by registering our event within our GameConfig.h. We’ll have a few of these custom event types as we progress through our course, so let’s put them in a UserEvents namespace:

1// GameConfig.h
2// ...
3namespace UserEvents{
4  inline Uint32 ADVANCE{SDL_RegisterEvents(1)};
5}
6
7// ...

In our GameState.h, we’ll keep track of how much time has passed by accumulating the time deltas reported to our Tick() function invocations. When we’ve accumulated enough milliseconds to satisfy our ADVANCE_INTERVAL configuration, we’ll reset our accumulated time and advance our game state.

We’ll put this advance logic in a private UpdateSnake() function which we’ll implement next:

1// GameState.h
2#pragma once
3#include <SDL.h>
4#include "GameConfig.h"
5#include "SnakeData.h"
6
7class GameState {
8public:
9  void HandleEvent(SDL_Event& E) {}
10
11  void Tick(Uint32 DeltaTime) {
12    ElapsedTime += DeltaTime;
13    if (ElapsedTime >= Config::ADVANCE_INTERVAL) {
14      ElapsedTime = 0;
15      UpdateSnake();
16    }
17  }
18
19private:
20  void UpdateSnake() {}
21  Uint32 ElapsedTime{0};
22  // ...
23};

Why do we Need to Tick?

You may be wondering why this game needs to Tick() at all. We could instead have a timer, such as an SDL_Timer, that advances the game every 200 milliseconds.

This is true, but even in games that only update on a specific interval, there are almost always parts of the program that we want to update in real-time. This can include animations and visual effects that don’t meaningfully modify the game’s state, but still improve the player experience.

Later in this chapter, we’ll use our Tick() functions to smoothly animate our snake’s position between cells, rather than have the jolted movement pattern of only updating every 200 milliseconds.

Our new UpdateSnake() function will update our SnakeData to reflect its new position. Where our snake moves next will be based on a new NextDirection variable that our GameState manages.

For now, the NextDirection will always be Right, but we’ll later update our class to allow players to change this direction based on keyboard input.

Finally, our UpdateSnake() function will dispatch one of our new UserEvents::ADVANCE events, notifying other components that the game state has advanced. We’ll include a pointer to the SnakeData in that event which other components can access as needed to determine how they need to react:

1// GameState.h
2// ...
3
4class GameState {
5// ...
6private:
7  void UpdateSnake() {
8    Snake.Direction = NextDirection;
9    switch (NextDirection) {
10      case Up:
11        Snake.HeadRow--;
12        break;
13      case Down:
14        Snake.HeadRow++;
15        break;
16      case Left:
17        Snake.HeadCol--;
18        break;
19      case Right:
20        Snake.HeadCol++;
21        break;
22    }
23
24    SDL_Event Event{UserEvents::ADVANCE};
25    Event.user.data1 = &Snake;
26    SDL_PushEvent(&Event);
27  }
28
29  // Direction the snake will move in when the
30  // game state next advances
31  MovementDirection NextDirection{Right};
32  // ...
33};

Rendering the Moving Snake

Over in Cell.h, let’s react to our game state advancing, and therefore our snake moving. Within our HandleEvent() function, we’ll check if the event has the UserEvents::ADVANCE type and, if it does, we’ll pass it off to a new private Advance() method:

1// Cell.h
2// ...
3
4class Cell {
5public:
6  void HandleEvent(SDL_Event& E) {
7    using namespace UserEvents;
8    if (E.type == ADVANCE) {
9      Advance(E.user);
10    }
11  }
12  // ...
13
14private:
15  void Advance(SDL_UserEvent& E) {
16    // TODO - Update Cell
17  }
18  // ...
19};

Within our Advance() method, we first need to understand if the snake advanced into this cell. To do this, we can first retrieve the SnakeData pointer that our GameState attaches to all UserEvents::ADVANCE events:

1// Cell.h
2// ...
3#include "SnakeData.h" 
4// ...
5
6class Cell {
7// ...
8private:
9  void Advance(SDL_UserEvent& E) {
10    SnakeData* Data{static_cast<SnakeData*>(
11      E.data1)};
12    // TODO - Update Cell
13  }
14  // ...
15};

By comparing the HeadRow and HeadCol of the SnakeData to the Row and Column of the cell reacting to the event, we can understand if the snake has advanced into this cell. If it has, we’ll update the CellState to Snake:

1// Cell.h
2// ...
3
4class Cell {
5// ...
6private:
7  void Advance(SDL_UserEvent& E) {
8    SnakeData* Data{static_cast<SnakeData*>(
9      E.data1)};
10
11    bool isThisCell{
12      Data->HeadRow == Row &&
13      Data->HeadCol == Column
14    };
15
16    if (isThisCell) {
17      CellState = Snake;
18    }
19  }
20};

If we run our game, we should now notice our snake continuously growing to the right, expanding by one cell every time our Config::ADVANCE_INTERVAL elapses:

Screenshot of the snake stretching towards the apple

We don’t want our snake growing to the right - rather, we want it moving to the right. To do this, we’ll need to remove snake segments from the tail.

Managing Snake Segments

When a snake moves in our game, we need to both add new segments at the head and remove old segments from the tail. We'll implement this using a duration system where each cell keeps track of how long it should remain part of the snake.

Let's add a SnakeDuration counter to our Cell class. We’ll initialize this to 0 for now, but we’ll update its value later:

1// Cell.h
2// ...
3
4class Cell {
5// ...
6private:
7  // ...
8  // How many more advances this cell
9  // remains part of the snake
10  int SnakeDuration{0};
11};

This counter works as follows:

When a cell becomes the snake's head, we set its duration to the snake's total length
Every game advance decrements the duration of all snake cells
When a cell's duration reaches zero, it reverts to an empty cell

This system handles the snake's movement:

New head segments get the full snake length as their duration
Tail segments naturally disappear when their duration expires
The snake maintains its length as it moves

Let's implement this logic in our Advance() function:

1// Cell.h
2// ...
3
4class Cell {
5  // ...
6private:
7  // ...
8  void Advance(SDL_UserEvent& E) {
9    SnakeData* Data{static_cast<SnakeData*>(
10      E.data1)};
11
12    bool isThisCell{
13      Data->HeadRow == Row &&
14      Data->HeadCol == Column
15    };
16
17    if (isThisCell) {
18      CellState = Snake;
19    } else if (CellState == Snake) {
20      --SnakeDuration;
21      if (SnakeDuration == 0) {
22        CellState = Empty;
23      }
24    }
25  }
26};

Finally, we need to set SnakeDuration to appropriate values any time a cell becomes a Snake segment. In Advance(), if the snake advances into our cell, we know how long the cell needs to remain a snake segment by looking at the overall length of the snake:

1// Cell.h
2// ...
3
4class Cell {
5// ...
6private:
7  // ...
8  void Advance(SDL_UserEvent& E) {
9    SnakeData* Data{static_cast<SnakeData*>(
10      E.data1)};
11
12    bool isThisCell{
13      Data->HeadRow == Row &&
14      Data->HeadCol == Column
15    };
16
17    if (isThisCell) {
18      CellState = Snake;
19      SnakeDuration = Data->Length;
20    } else if (CellState == Snake) {
21      --SnakeDuration;
22      if (SnakeDuration == 0) {
23        CellState = Empty;
24      }
25    }
26  }
27};

When our game is initialized, we start with a two-segment snake. We need to initialize the SnakeDuration for those cells too, with the snake’s head segment having an initial duration of 2 and the tail segment having a duration of 1. All other cells should have a duration of 0:

1// Cell.h
2// ...
3
4class Cell {
5// ...
6private:
7  // ...
8  void Initialize() {
9    CellState = Empty;
10    SnakeDuration = 0;
11
12    int InitialRow{Config::GRID_ROWS / 2};
13    if (Row == InitialRow && Column == 2) {
14      CellState = Snake;
15      SnakeDuration = 1;
16    } else if (Row == InitialRow && Column == 3) {
17      CellState = Snake;
18      SnakeDuration = 2;
19    } else if (Row == InitialRow && Column == 11) {
20      CellState = Apple;
21    }
22  }
23};

Running our program, our snake should now move right:

Screenshot of the snake moving towards the apple

Turning the Snake

As the final step in this section, let’s allow the player to change the snake’s direction using the arrow keys or the WASD keys. Our GameState is already receiving keyboard events - we just need to react to them appropriately.

Let’s update HandleEvent() to check for SDL_KEYDOWN events, and forward them to a new HandleKeyEvent() private method:

1// GameState.h
2// ...
3
4class GameState {
5public:
6  // ...
7  void HandleEvent(SDL_Event& E) {
8    if (E.type == SDL_KEYDOWN) {
9      HandleKeyEvent(E.key);
10    }
11  }
12
13private:
14  // ...
15  void HandleKeyEvent(SDL_KeyboardEvent& E) {}
16};

Our HandleKeyEvent() will check for arrow or WASD keypresses, and then update the NextDirection variable as appropriate.

We don’t want our snake to turn 180 degrees in a single step. For example, if the snake is currently moving Right it won’t be able to change its direction to Left in a single advance. It can only turn Up or Down, or continue moving Right.

We’ll implement these restrictions using a set of if statements:

1// GameState.h
2// ...
3
4class GameState {
5  // ...
6private:
7  void HandleKeyEvent(SDL_KeyboardEvent& E) {
8    switch (E.keysym.sym) {
9      case SDLK_UP:
10      case SDLK_w:
11        if (Snake.Direction != Down) {
12          NextDirection = Up;
13        }
14        break;
15      case SDLK_DOWN:
16      case SDLK_s:
17        if (Snake.Direction != Up) {
18          NextDirection = Down;
19        }
20        break;
21      case SDLK_LEFT:
22      case SDLK_a:
23        if (Snake.Direction != Right) {
24          NextDirection = Left;
25        }
26        break;
27      case SDLK_RIGHT:
28      case SDLK_d:
29        if (Snake.Direction != Left) {
30          NextDirection = Right;
31        }
32        break;
33    }
34  }
35  // ...
36};

If we run our game, we should now be able to move our snake around:

Screenshot of the snake changing movement direction

Our snake’s movement will feel quite jolted as we’re only updating its visual position by a large step every time the game state advances, rather than by a small step on every frame.

We may prefer this jolted movement for the more retro feel, but later in the chapter we’ll demonstrate how to make the snake’s movement feel smoother by updating it on every frame.

Complete Code

Complete versions of the files we changed in this part are available below

GameConfig.h (Edited)

1#pragma once
2#define CHECK_ERRORS
3
4#include <iostream>
5#include <SDL.h>
6#include <string>
7
8namespace UserEvents{
9  inline Uint32 ADVANCE{SDL_RegisterEvents(1)};
10}
11
12namespace Config{
13  // Game Settings
14  inline const std::string GAME_NAME{"Snake"};
15  inline constexpr int ADVANCE_INTERVAL{200};
16
17  inline constexpr int GRID_COLUMNS{16};
18  static_assert(
19    GRID_COLUMNS >= 12,
20    "Grid must be at least 12 columns wide");
21
22  inline constexpr int GRID_ROWS{5};
23  static_assert(
24    GRID_ROWS >= 5,
25    "Grid must be at least 5 rows tall");
26
27  inline constexpr int MAX_SCORE{
28    GRID_COLUMNS * GRID_ROWS - 1};
29
30  // Size and Positioning
31  inline constexpr int PADDING{5};
32  inline constexpr int CELL_SIZE{36};
33
34  inline constexpr int GRID_HEIGHT{
35    CELL_SIZE * GRID_ROWS
36  };
37  inline constexpr int GRID_WIDTH{
38    CELL_SIZE * GRID_COLUMNS};
39
40  inline constexpr int WINDOW_HEIGHT{
41    GRID_HEIGHT + PADDING * 2};
42
43  inline constexpr int WINDOW_WIDTH{
44    GRID_WIDTH + PADDING * 2};
45
46  // Colors
47  inline constexpr SDL_Color BACKGROUND_COLOR{
48    85, 138, 52, 255};
49  inline constexpr SDL_Color CELL_COLOR_A{
50    171, 214, 82, 255};
51  inline constexpr SDL_Color CELL_COLOR_B{
52    161, 208, 74, 255};
53  inline constexpr SDL_Color SNAKE_COLOR{
54    67, 117, 234, 255};
55  inline constexpr SDL_Color FONT_COLOR{
56    255, 255, 255, 255};
57
58  // Asset Paths
59  inline const std::string APPLE_IMAGE{
60    "apple.png"};
61  inline const std::string FONT{
62    "Rubik-SemiBold.ttf"};
63}
64
65inline void CheckSDLError(
66  const std::string& Msg){
67#ifdef CHECK_ERRORS
68  const char* error = SDL_GetError();
69  if (*error != '\0') {
70    std::cerr << Msg << " Error: "
71      << error << '\n';
72    SDL_ClearError();
73  }
74#endif
75}

SnakeData.h (Created)

1#pragma once
2
3enum MovementDirection { Up, Down, Left, Right };
4
5struct SnakeData {
6  int HeadRow;
7  int HeadCol;
8  int Length;
9  MovementDirection Direction;
10};

GameState.h (Created)

1#pragma once
2#include <SDL.h>
3#include "GameConfig.h"
4#include "SnakeData.h"
5
6class GameState {
7public:
8  void HandleEvent(SDL_Event& E) {
9    if (E.type == SDL_KEYDOWN) {
10      HandleKeyEvent(E.key);
11    }
12  }
13
14  void Tick(Uint32 DeltaTime) {
15    ElapsedTime += DeltaTime;
16    if (ElapsedTime >= Config::ADVANCE_INTERVAL) {
17      ElapsedTime = 0;
18      UpdateSnake();
19    }
20  }
21
22private:
23  void HandleKeyEvent(SDL_KeyboardEvent& E) {
24    switch (E.keysym.sym) {
25      case SDLK_UP:
26      case SDLK_w:
27        if (Snake.Direction != Down) {
28          NextDirection = Up;
29        }
30        break;
31      case SDLK_DOWN:
32      case SDLK_s:
33        if (Snake.Direction != Up) {
34          NextDirection = Down;
35        }
36        break;
37      case SDLK_LEFT:
38      case SDLK_a:
39        if (Snake.Direction != Right) {
40          NextDirection = Left;
41        }
42        break;
43      case SDLK_RIGHT:
44      case SDLK_d:
45        if (Snake.Direction != Left) {
46          NextDirection = Right;
47        }
48        break;
49    }
50  }
51
52  void UpdateSnake() {
53    Snake.Direction = NextDirection;
54    switch (NextDirection) {
55      case Up:
56        Snake.HeadRow--;
57        break;
58      case Down:
59        Snake.HeadRow++;
60        break;
61      case Left:
62        Snake.HeadCol--;
63        break;
64      case Right:
65        Snake.HeadCol++;
66        break;
67    }
68
69    SDL_Event Event{UserEvents::ADVANCE};
70    Event.user.data1 = &Snake;
71    SDL_PushEvent(&Event);
72  }
73
74  Uint32 ElapsedTime{0};
75  SnakeData Snake{
76    Config::GRID_ROWS / 2, 3, 2, Right};
77  MovementDirection NextDirection{Right};
78};

Cell.h (Edited)

1#pragma once
2#include <SDL.h>
3#include "GameConfig.h"
4#include "SnakeData.h"
5#include "Assets.h"
6
7enum CellState { Snake, Apple, Empty };
8
9class Cell {
10public:
11  Cell(int Row, int Column, Assets& Assets)
12  : Row(Row),
13    Column(Column),
14    Assets{Assets},
15    BackgroundRect{
16      Column * Config::CELL_SIZE + Config::PADDING,
17      Row * Config::CELL_SIZE + Config::PADDING,
18      Config::CELL_SIZE, Config::CELL_SIZE},
19    BackgroundColor {
20      (Row + Column) % 2 == 0
21        ? Config::CELL_COLOR_A
22        : Config::CELL_COLOR_B}
23  {
24    Initialize();
25  }
26
27  void HandleEvent(SDL_Event& E) {
28    using namespace UserEvents;
29    if (E.type == ADVANCE) {
30      Advance(E.user);
31    }
32  }
33
34  void Tick(Uint32 DeltaTime) {}
35
36  void Render(SDL_Surface* Surface) {
37    SDL_FillRect(Surface, &BackgroundRect,
38      SDL_MapRGB(
39        Surface->format,
40        BackgroundColor.r,
41        BackgroundColor.g,
42        BackgroundColor.b
43      )
44    );
45
46    if (CellState == Apple) {
47      Assets.Apple.Render(Surface, &BackgroundRect);
48    } else if (CellState == Snake) {
49      SDL_FillRect(Surface, &BackgroundRect,
50        SDL_MapRGB(
51          Surface->format,
52          Config::SNAKE_COLOR.r,
53          Config::SNAKE_COLOR.g,
54          Config::SNAKE_COLOR.b
55        )
56      );
57    }
58  }
59
60private:
61  void Initialize() {
62    CellState = Empty;
63    SnakeDuration = 0;
64
65    int MiddleRow{Config::GRID_ROWS / 2};
66    if (Row == MiddleRow && Column == 2) {
67      CellState = Snake;
68      SnakeDuration = 1;
69    } else if (Row == MiddleRow && Column == 3) {
70      CellState = Snake;
71      SnakeDuration = 2;
72    } else if (Row == MiddleRow && Column == 11) {
73      CellState = Apple;
74    }
75  }
76
77  void Advance(SDL_UserEvent& E) {
78    SnakeData* Data{static_cast<SnakeData*>(
79      E.data1)};
80
81    bool isThisCell{
82      Data->HeadRow == Row &&
83      Data->HeadCol == Column
84    };
85
86    if (isThisCell) {
87      CellState = Snake;
88      SnakeDuration = Data->Length;
89    } else if (CellState == Snake) {
90      --SnakeDuration;
91      if (SnakeDuration == 0) {
92        CellState = Empty;
93      }
94    }
95  }
96
97  int Row;
98  int Column;
99  CellState CellState;
100  int SnakeDuration;
101  SDL_Rect BackgroundRect;
102  SDL_Color BackgroundColor;
103  Assets& Assets;
104};

main.cpp (Edited)

1#include <SDL.h>
2#include <SDL_image.h>
3#include <SDL_ttf.h>
4
5#include "Engine/Window.h"
6#include "GameState.h"
7#include "GameUI.h"
8
9int main(int argc, char** argv) {
10  SDL_Init(SDL_INIT_VIDEO);
11  CheckSDLError("Initializing SDL");
12
13  IMG_Init(IMG_INIT_PNG);
14  CheckSDLError("Initializing SDL_image");
15
16  TTF_Init();
17  CheckSDLError("Initializing SDL_ttf");
18
19  Window GameWindow{};
20  GameState State{};
21  GameUI UI{};
22
23  Uint32 PreviousTick{SDL_GetTicks()};
24  Uint32 CurrentTick;
25  Uint32 DeltaTime;
26
27  SDL_Event Event;
28  while (true) {
29    CurrentTick = SDL_GetTicks();
30    DeltaTime = CurrentTick - PreviousTick;
31
32    // Events
33    while (SDL_PollEvent(&Event)) {
34      UI.HandleEvent(Event);
35      State.HandleEvent(Event);
36      if (Event.type == SDL_QUIT) {
37        SDL_Quit();
38        IMG_Quit();
39        return 0;
40      }
41    }
42
43    // Tick
44    State.Tick(DeltaTime);
45    UI.Tick(DeltaTime);
46
47    // Render
48    GameWindow.Render();
49    UI.Render(GameWindow.GetSurface());
50
51    // Swap
52    GameWindow.Update();
53
54    PreviousTick = CurrentTick;
55  }
56
57  return 0;
58}

Files not listed above have not been changed since the previous section.

Summary

In this lesson, we built the core movement mechanics for our snake game. We implemented a state-based game system that manages the snake's position, handles user input, and updates the game at regular intervals. The key steps we took include:

Game state management using a dedicated GameState class
Event-based movement control using SDL keyboard events
Snake segment tracking using a duration-based system
Frame-independent game updates using SDL_GetTicks()
Custom event handling for game state changes

Free and Unlimited Access

Professional C++

Unlock the true power of C++ by mastering complex features, optimizing performance, and learning expert workflows used in professional development

Ryan McCombe

Posted 8 hours ago

Lesson Contents