Animating Snake Movement

Learn to animate the snake's movement across cells for a smooth, dynamic visual effect.

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

Right now, our snake moves instantly between cells. We'll enhance this by implementing a sliding animation, giving the illusion of the snake smoothly traversing the grid. This involves dynamically adjusting the portion of each cell occupied by the snake.

To do this, we’ll be using our Tick() mechanism to provide frame-by-frame adjustments to our snake’s visuals.

This is the final part of our project, so we’ll also finish things off with a list of suggestions on how we can further develop the game and put our skills to the test!

Screenshot showing the final state of the snake game

Currently, when our cell has a CellState of Snake, we fill the entire cell with our snake color. This is done in our Render() function, where we’re currently using the BackgroundRect rectangle to define the bounds of both our background color and our snake segment:

1// Cell.h
2// ...
3
4class Cell {
5public:
6  // ...
7  void Render(SDL_Surface* Surface) {
8    SDL_FillRect(Surface, &BackgroundRect,
9      SDL_MapRGB(
10        Surface->format,
11        BackgroundColor.r,
12        BackgroundColor.g,
13        BackgroundColor.b
14      )
15    );
16
17    if (CellState == Apple) {
18      Assets.Apple.Render(
19        Surface, &BackgroundRect);
20    } else if (CellState == Snake) {
21      SDL_FillRect(Surface, &BackgroundRect,
22        SDL_MapRGB(
23          Surface->format,
24          SnakeColor.r,
25          SnakeColor.g,
26          SnakeColor.b
27        )
28      );
29    }
30  }
31  // ...
32};

Instead, we want to create the visual effect of our snake sliding across the cell. From a high level, this involves two steps:

Creating a different SDL_Rect member to store what part of our cell should be filled by the snake color
Updating the values of this SDL_Rect on every frame (ie, on every Tick() invocation) to create the sliding animation effect

Let’s work through this step by step.

Adding `SnakeRect`

First, let’s define the SDL_Rect for our snake blitting. We’ll call it SnakeRect:

1// Cell.h
2// ...
3
4class Cell {
5  // ...
6private:
7  // ...
8  SDL_Rect SnakeRect;
9};

We’ll initialize our SnakeRect to have the same dimensions as our BackgroundRect:

1// Cell.h
2// ...
3
4class Cell {
5  // ...
6private:
7  void Initialize() {
8    SnakeRect = BackgroundRect;
9    // ...
10  }
11  // ...
12};

Let’s update our Render() function to use this SnakeRect for our snake, rather than the BackgroundRect it is currently using:

1// Cell.h
2// ...
3
4class Cell {
5public:
6  // ...
7  void Render(SDL_Surface* Surface) {
8    SDL_FillRect(Surface, &BackgroundRect,
9      SDL_MapRGB(
10        Surface->format,
11        BackgroundColor.r,
12        BackgroundColor.g,
13        BackgroundColor.b
14      )
15    );
16
17    if (CellState == Apple) {
18      Assets.Apple.Render(
19        Surface, &BackgroundRect);
20    } else if (FillPercent > 0) {
21      SDL_FillRect(Surface, &SnakeRect,
22        SDL_MapRGB(
23          Surface->format,
24          SnakeColor.r,
25          SnakeColor.g,
26          SnakeColor.b
27        )
28      );
29    }
30  }
31  // ...
32};

Adding `FillPercent` and `FillDirection`

To control the effect of the snake sliding across our cell, we’ll need two new member variables:

A FillPercent variable, controlling how far the snake has slid across our cell
A FillDirection variable, controlling which direction the snake needs to slide

Think of FillPercent as how much of the cell the snake occupies, ranging from 0.0 (empty) to 1.0 (completely full). FillDirection indicates where the snake enters the cell (Up, Down, Left, or Right).

Here are some examples of how they work together:

FillPercent = 0.0: The cell is entirely the background color. The snake hasn't entered yet.
FillPercent = 1.0: The cell is entirely the snake color. The snake completely fills the cell.
FillPercent = 0.5, FillDirection = Right: The snake is entering from the left. The left half of the cell is the snake color, and the right half is the background color.
FillPercent = 0.25, FillDirection = Down: The snake is entering from the top. The top quarter of the cell is the snake color, and the bottom three-quarters are the background color.

`FillPercent`

Let’s add the FillPercent floating point member to our class:

1// Cell.h
2// ...
3
4class Cell {
5  // ...
6private:
7  float FillPercent{0};
8  // ...
9};

When our game starts or restarts, we’ll initialize FillPercent to 0, except for the two cells that contain our initial snake segments:

1// Cell.h
2// ...
3
4class Cell {
5  // ...
6private:
7  void Initialize() {
8    CellState = Empty;
9    SnakeRect = BackgroundRect;
10    SnakeColor = Config::SNAKE_COLOR;
11    SnakeDuration = 0;
12    FillPercent = 0.0;
13
14    int StartRow{Config::GRID_ROWS / 2};
15    if (Row == StartRow && Column == 2) {
16      CellState = Snake;
17      SnakeDuration = 1;
18      FillPercent = 1.0;
19    } else if (Row == StartRow && Column ==3) {
20      CellState = Snake;
21      SnakeDuration = 2;
22      FillPercent = 1.0;
23    } else if (
24      Row == StartRow &&
25      Column == 11
26    ) {
27      CellState = Apple;
28    }
29  }
30  // ...
31};

Currently, our Render() function checks if CellState == Snake to decide if it needs to render the snake in our cell. We’ll update this to check if FillPercent > 0 instead:

1// Cell.h
2// ...
3
4class Cell {
5public:
6  void Render(SDL_Surface* Surface) {
7    SDL_FillRect(Surface, &BackgroundRect,
8      SDL_MapRGB(
9        Surface->format,
10        BackgroundColor.r,
11        BackgroundColor.g,
12        BackgroundColor.b
13      )
14    );
15
16    if (CellState == Apple) {
17      Assets.Apple.Render(
18        Surface, &BackgroundRect);
19    } else if (FillPercent > 0) {
20      SDL_FillRect(Surface, &SnakeRect,
21        SDL_MapRGB(
22          Surface->format,
23          SnakeColor.r,
24          SnakeColor.g,
25          SnakeColor.b
26        )
27      );
28    }
29  }
30  // ...
31};

`FillDirection`

We’ll also need a FillDirection value representing which direction we need to fill our cell. For example, if the snake is entering the cell from the left, the cell should be filled with the snake color from left to right.

For example, if on a given frame, FillPercent is 0.5 and FillDirection is Right, that corresponds to the left half of the cell containing the snake color, and the right half of the cell containing the background color.

Let’s add FillDirection to our class, using the MovementDirection type we have already declared:

1// Cell.h
2// ...
3
4class Cell {
5  // ...
6private:
7  MovementDirection FillDirection{Right};
8  // ...
9};

We’ll initialize it to Right for all cells, as our snake always starts by moving right:

1// Cell.h
2// ...
3
4class Cell {
5  // ...
6private:
7  void Initialize() {
8    FillDirection = Right;
9    // ...
10  }
11  // ...
12};

However, when a snake visits a cell, we’ll update that cell’s FillDirection to keep track of which direction the snake entered the cell from. We’ll also set FillPercent to 0 when the snake head first enters, and we’ll animate this value from 0 to 1 in the next section:

1// Cell.h
2// ...
3
4class Cell {
5  // ...
6private:
7  void Advance(SDL_UserEvent& E) {
8    SnakeData* Data{
9      static_cast<SnakeData*>(E.data1)};
10
11    bool isThisCell{
12      Data->HeadRow == Row &&
13      Data->HeadCol == Column
14    };
15
16    if (isThisCell) {
17      if (CellState == Snake) {
18        SDL_Event Event{UserEvents::GAME_LOST};
19        SDL_PushEvent(&Event);
20        return;
21      }
22      if (CellState == Apple) {
23        SDL_Event Event{
24          UserEvents::APPLE_EATEN};
25        SDL_PushEvent(&Event);
26      }
27      CellState = Snake;
28      SnakeDuration = Data->Length;
29      FillDirection = Data->Direction;
30      FillPercent = 0;
31    } else if (CellState == Snake) {
32      if (SnakeDuration == Data->Length) {
33        FillDirection = Data->Direction;
34      }
35      SnakeDuration--;
36      if (SnakeDuration <= 0) {
37        CellState = Empty;
38      }
39    }
40  }
41  // ...
42};

Animating the Snake’s Head

To give our snake’s head the illusion of sliding into the cell, we’ll update our SnakeRect variable to gradually increase how much of the cell is filled with our snake color. Our FillPercent should start at 0.0 when the snake first enters the cell and, by the time the snake is ready to advance to the next cell, FillPercent should be at 1.0.

As we want our animation to update every frame, we’ll use the Tick() function to implement this. We know our cell has animation work to do if its CellState is Snake, but its FillPercent hasn’t yet reached 1.0. In that case, we’ll call a new private GrowHead() function:

1// Cell.h
2// ...
3
4class Cell {
5public:
6  void Tick(Uint32 DeltaTime) {
7    if (CellState == Snake && FillPercent < 1) {
8      GrowHead(DeltaTime);
9    }
10  }
11  // ...
12
13private:
14  void GrowHead(float DeltaTime) {
15    // TODO: Grow Head
16  }
17  // ...
18};

Note that the GrowHead() invocation is converting the DeltaTime from a Uint32 to a float. This is important, as we want to use floating point calculations in GrowHead().

Within successive invocations of GrowHead(), we want to increase our FillPercent such that it reaches 1.0 by the time our snake is ready to advance to the next cell. For example, if our Config::ADVANCE_INTERVAL is set to 200, our snake advances every 200 milliseconds, so we want our fill percent to increase from 0 to 1 over that interval.

For example, if DeltaTime is 20, that means 20 milliseconds have passed since the previous frame. We’d want our fill percent to increase by 0.1, as the 20 milliseconds delta time is 10% of the 200-millisecond interval time.

So, in general, we increase our FillPercent by DeltaTime divided by ADVANCE_INTERVAL. We also don’t want FillPercent to go above 1.0, so if this calculation increases it beyond that, we reduce it back down:

1// Cell.h
2// ...
3
4class Cell {
5  // ...
6private:
7  void GrowHead(float DeltaTime) {
8    using namespace Config;
9    FillPercent += DeltaTime / ADVANCE_INTERVAL;
10    if (FillPercent > 1) FillPercent = 1;
11
12    // TODO: Grow Head
13  }
14};

We now use this FillPercent value in combination with our FillDirection to modify the size or position of our SnakeRect.

Our SnakeRect value should have the same x, y, w, and h values as our BackgroundRect, with the exception of one property. The property we need to change depends on our FillDirection, and what its new value should be depends on our FullPercent.

To fill the cell from left to right, we scale the width (w) of the snake rectangle by our FillPercent
To fill the cell from top to bottom, we scale the height (h) of the snake rectangle based on our FillPercent
To fill the cell from right to left, we move the horizontal position (x) of our snake rectangle. Since x represents the left edge of the rectangle, we need to start it at the right edge of the cell and move it leftwards. We calculate the starting x position by adding BackgroundRect.x (the left edge of the cell) to the remaining portion of the cell width, which is CELL_SIZE * (1 - FillPercent).
To fill the cell from bottom to top, we move the vertical position (y) of our snake rectangle. Since y represents the top edge of the rectangle, we need to start it at the bottom edge of the cell and move it upwards. We calculate the starting y position by adding BackgroundRect.y (the top edge of the cell) to the remaining portion of the cell height, which is CELL_SIZE * (1 - FillPercent).

Putting all this logic together, we have the following. Note that we’re using Config::CELL_SIZE to retrieve the width or height of each cell. We could alternatively have used BackgroundRect.w or BackgroundRect.h - they all have the same value:

1// Cell.h
2// ...
3
4class Cell {
5  // ...
6private:
7  void GrowHead(float DeltaTime) {
8    using namespace Config;
9    FillPercent += DeltaTime / ADVANCE_INTERVAL;
10    if (FillPercent > 1) FillPercent = 1;
11
12    SnakeRect = BackgroundRect;
13    if (FillDirection == Right) {
14      SnakeRect.w = CELL_SIZE * FillPercent;
15    } else if (FillDirection == Down) {
16      SnakeRect.h = CELL_SIZE * FillPercent;
17    } else if (FillDirection == Left) {
18      SnakeRect.x = BackgroundRect.x +
19        CELL_SIZE * (1 - FillPercent);
20    } else if (FillDirection == Up) {
21      SnakeRect.y = BackgroundRect.y +
22        CELL_SIZE * (1 - FillPercent);
23    }
24  }
25  // ...
26};

Running our game, we should now see our snake’s head animating smoothly. However, our other snake segments remain on screen even after the snake has left those cells. Let’s apply similar logic in reverse to animate the snake’s tail leaving cells it no longer occupies.

Animating the Snake’s Tail

We can animate the snake’s tail leaving a cell in much the same way we animated the head entering. First, we need to update the FillDirection variable with the direction that the snake’s head leaves our cell - that is, the turn after the snake entered the cell.

We can determine this from the UserEvents::ADVANCE event that comes after the ADVANCE event where the snake entered our cell. There are many ways we could detect this - we could add a new variable to our Cell class for example.

In our setup, we can also infer this by comparing the snake’s current length to the SnakeDuration remaining on our Cell, before we decrement it. If those values are the same, that means the snake’s head entered our cell on the previous turn, and is leaving our cell on this turn.

As such, its Direction is the direction that it is leaving our cell, and we can set FillDirection accordingly:

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

Updating Tick

In our Tick() function, we know that we need to animate the snake out of our cell if its CellState is not Snake, but it is still rendering some part of the snake segment, that is, its FillPercent is greater than 0. We’ll create a new ShrinkTail() private method to handle this animation:

1// Cell.h
2// ...
3
4class Cell {
5public:
6  void Tick(Uint32 DeltaTime) {
7    if (CellState == Snake && FillPercent < 1) {
8      GrowHead(DeltaTime);
9    } else if (CellState != Snake && FillPercent > 0) {
10      ShrinkTail(DeltaTime);
11    }
12  }
13  // ...
14private:
15  // ...
16  void ShrinkTail(float DeltaTime) {
17     // TODO: Shrink Tail
18  }
19  // ...
20};

The logic we need for ShrinkTail() will effectively be the inverse of what we had in GrowHead(). Therefore, we update FillPercent and SnakeRect in the opposite way we did within GrowHead():

We use the DeltaTime and ADVANCE_INTERVAL to decrease the FillPercent
If this causes the FillPercent to fall below 0, we increase it back to 0.

Our SnakeRect calculations are the same as they were in GrowHead(), but in the opposite direction:

The FillDirection == Right logic in ShrinkTail() is the same as the FillDirection == Left logic in GrowHead()
The FillDirection == Left logic in ShrinkTail() is the same as the FillDirection == Right logic in GrowHead()
The FillDirection == Top logic in ShrinkTail() is the same as the FillDirection == Bottom logic in GrowHead()
The FillDirection == Bottom logic in ShrinkTail() is the same as the FillDirection == Top logic in GrowHead()

Our complete ShrinkTail() function looks like this:

1// Cell.h
2// ...
3
4class Cell {
5  // ...
6private:
7  void ShrinkTail(float DeltaTime) {
8    using namespace Config;
9    FillPercent -= DeltaTime / ADVANCE_INTERVAL;
10    if (FillPercent < 0) FillPercent = 0;
11
12    if (FillDirection == Right) {
13      SnakeRect.x = BackgroundRect.x +
14        CELL_SIZE * (1 - FillPercent);
15    } else if (FillDirection == Left) {
16      SnakeRect.w = CELL_SIZE * FillPercent;
17    } else if (FillDirection == Up) {
18      SnakeRect.h = CELL_SIZE * FillPercent;
19    } else if (FillDirection == Down) {
20      SnakeRect.y = BackgroundRect.y +
21        CELL_SIZE * (1 - FillPercent);
22    }
23  }
24  // ...
25};

Complete Code

Our final Cell.h code is available below:

Cell.h

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  {
16    Initialize();
17  }
18
19  void HandleEvent(SDL_Event& E) {
20    using namespace UserEvents;
21    if (E.type == ADVANCE) {
22      Advance(E.user);
23    } else if (E.
24      type == APPLE_EATEN) {
25      if (CellState == Snake) {
26        ++SnakeDuration;
27      }
28    } else if (E.type == GAME_LOST) {
29      SnakeColor = Config::SNAKE_LOST_COLOR;
30    } else if (E.type == GAME_WON) {
31      SnakeColor = Config::SNAKE_VICTORY_COLOR;
32    } else if (E.type == RESTART_GAME) {
33      Initialize();
34    }
35  }
36
37  void Tick(Uint32 DeltaTime) {
38    if (CellState == Snake && FillPercent < 1) {
39      GrowHead(DeltaTime);
40    } else if (CellState != Snake && FillPercent > 0) {
41      ShrinkTail(DeltaTime);
42    }
43  }
44
45  void Render(SDL_Surface* Surface) {
46    SDL_FillRect(Surface, &BackgroundRect,
47      SDL_MapRGB(
48        Surface->format,
49        BackgroundColor.r,
50        BackgroundColor.g,
51        BackgroundColor.b
52      )
53    );
54
55    if (CellState == Apple) {
56      Assets.Apple.Render(
57        Surface, &BackgroundRect);
58    } else if (FillPercent > 0) {
59      SDL_FillRect(Surface, &SnakeRect,
60        SDL_MapRGB(
61          Surface->format,
62          SnakeColor.r,
63          SnakeColor.g,
64          SnakeColor.b
65        )
66      );
67    }
68  }
69
70  bool PlaceApple() {
71    if (CellState != Empty) return false;
72
73    CellState = Apple;
74    return true;
75  }
76
77private:
78  void Initialize() {
79    CellState = Empty;
80    SnakeColor = Config::SNAKE_COLOR;
81    SnakeDuration = 0;
82    FillPercent = 0;
83    FillDirection = Right;
84
85    int StartRow{Config::GRID_ROWS / 2};
86    if (Row == StartRow && Column == 2) {
87      CellState = Snake;
88      SnakeDuration = 1;
89      FillPercent = 1;
90    } else if (Row == StartRow && Column ==3) {
91      CellState = Snake;
92      SnakeDuration = 2;
93      FillPercent = 1;
94    } else if (
95      Row == StartRow &&
96      Column == 11
97    ) {
98      CellState = Apple;
99    }
100
101    SnakeRect = BackgroundRect;
102  }
103
104  void Advance(SDL_UserEvent& E) {
105    SnakeData* Data{
106      static_cast<SnakeData*>(
107        E.data1)};
108
109    bool isThisCell{
110      Data->HeadRow == Row &&
111      Data->HeadCol == Column
112    };
113
114    if (isThisCell) {
115      if (CellState == Snake) {
116        SDL_Event Event{UserEvents::GAME_LOST};
117        SDL_PushEvent(&Event);
118        return;
119      }
120      if (CellState == Apple) {
121        SDL_Event Event{
122          UserEvents::APPLE_EATEN};
123        SDL_PushEvent(&Event);
124      }
125      CellState = Snake;
126      SnakeDuration = Data->Length;
127      FillDirection = Data->Direction;
128      FillPercent = 0;
129    } else if (CellState == Snake) {
130      if (SnakeDuration == Data->Length) {
131        FillDirection = Data->Direction;
132      }
133      SnakeDuration--;
134      if (SnakeDuration <= 0) {
135        CellState = Empty;
136      }
137    }
138  }
139
140  void GrowHead(float DeltaTime) {
141    using namespace Config;
142    FillPercent += DeltaTime / ADVANCE_INTERVAL;
143    if (FillPercent > 1) FillPercent = 1;
144
145    SnakeRect = BackgroundRect;
146    if (FillDirection == Right) {
147      SnakeRect.w = CELL_SIZE * FillPercent;
148    } else if (FillDirection == Down) {
149      SnakeRect.h = CELL_SIZE * FillPercent;
150    } else if (FillDirection == Left) {
151      SnakeRect.x = BackgroundRect.x +
152        CELL_SIZE * (1 - FillPercent);
153    } else if (FillDirection == Up) {
154      SnakeRect.y = BackgroundRect.y +
155        CELL_SIZE * (1 - FillPercent);
156    }
157  }
158
159  void ShrinkTail(float DeltaTime) {
160    using namespace Config;
161    FillPercent -= DeltaTime / ADVANCE_INTERVAL;
162    if (FillPercent < 0) FillPercent = 0;
163
164    SnakeRect = BackgroundRect;
165    if (FillDirection == Right) {
166      SnakeRect.x = BackgroundRect.x +
167        CELL_SIZE * (1 - FillPercent);
168    } else if (FillDirection == Left) {
169      SnakeRect.w = CELL_SIZE * FillPercent;
170    } else if (FillDirection == Up) {
171      SnakeRect.h = CELL_SIZE * FillPercent;
172    } else if (FillDirection == Down) {
173      SnakeRect.y = BackgroundRect.y +
174        CELL_SIZE * (1 - FillPercent);
175    }
176  }
177
178  int Row;
179  int Column;
180  CellState CellState;
181  SDL_Color SnakeColor;
182  int SnakeDuration;
183
184  SDL_Rect BackgroundRect{
185    Column * Config::CELL_SIZE + Config::PADDING,
186    Row * Config::CELL_SIZE + Config::PADDING,
187    Config::CELL_SIZE,
188    Config::CELL_SIZE
189  };
190
191  SDL_Color BackgroundColor{
192    (Row + Column) % 2 == 0
193      ? Config::CELL_COLOR_A
194      : Config::CELL_COLOR_B
195  };
196
197  SDL_Rect SnakeRect;
198  Assets& Assets;
199
200  float FillPercent{0};
201  MovementDirection FillDirection{Right};
202};

The remaining project files (which were not changed in this section) are available here:

Engine/Window.h

1#pragma once
2#include <SDL.h>
3#include "GameConfig.h"
4
5class Window {
6public:
7  Window() {
8    SDLWindow = SDL_CreateWindow(
9      Config::GAME_NAME.c_str(),
10      SDL_WINDOWPOS_UNDEFINED,
11      SDL_WINDOWPOS_UNDEFINED,
12      Config::WINDOW_WIDTH,
13      Config::WINDOW_HEIGHT, 0
14    );
15
16    CheckSDLError("Creating Window");
17  }
18
19  ~Window() {
20    if (SDLWindow) {
21      SDL_DestroyWindow(SDLWindow);
22    }
23  }
24
25  Window(const Window&) = delete;
26  Window& operator=(const Window&) = delete;
27
28  void Render() {
29    SDL_FillRect(
30      GetSurface(), nullptr,
31      SDL_MapRGB(GetSurface()->format,
32                 Config::BACKGROUND_COLOR.r,
33                 Config::BACKGROUND_COLOR.g,
34                 Config::BACKGROUND_COLOR.b));
35  }
36
37  void Update() {
38    SDL_UpdateWindowSurface(SDLWindow);
39  }
40
41  SDL_Surface* GetSurface() {
42    return SDL_GetWindowSurface(SDLWindow);
43  }
44
45private:
46  SDL_Window* SDLWindow;
47};

Engine/Image.h

1#pragma once
2#include <SDL.h>
3#include <SDL_image.h>
4#include <string>
5
6class Image {
7 public:
8  Image(const std::string& Path) {
9    ImageSurface = IMG_Load(Path.c_str());
10    CheckSDLError("Loading Image");
11  }
12
13  ~Image() {
14    if (ImageSurface) {
15      SDL_FreeSurface(ImageSurface);
16    }
17  }
18
19  void Render(
20    SDL_Surface* Surface, SDL_Rect* Rect
21  ) {
22    SDL_BlitScaled(
23      ImageSurface, nullptr, Surface, Rect);
24  }
25
26  // Prevent copying
27  Image(const Image&) = delete;
28  Image& operator=(const Image&) = delete;
29
30 private:
31  SDL_Surface* ImageSurface{nullptr};
32};

Engine/Text.h

1#pragma once
2#include <SDL.h>
3#include <SDL_ttf.h>
4#include <string>
5#include "GameConfig.h"
6
7class Text {
8public:
9  Text(
10    const std::string& InitialText,
11    int FontSize
12  ) : Content(InitialText) {
13    Font = TTF_OpenFont(
14      Config::FONT.c_str(), FontSize);
15    CheckSDLError("Opening Font");
16
17    SetText(InitialText);
18  }
19
20  ~Text() {
21    if (TextSurface) {
22      SDL_FreeSurface(TextSurface);
23    }
24    if (Font) {
25      TTF_CloseFont(Font);
26    }
27  }
28
29  Text(const Text&) = delete;
30  Text& operator=(const Text&) = delete;
31
32  void SetText(const std::string& NewText) {
33    Content = NewText;
34
35    if (TextSurface) {
36      SDL_FreeSurface(TextSurface);
37    }
38    TextSurface = TTF_RenderText_Blended(
39      Font, Content.c_str(), Config::FONT_COLOR);
40    CheckSDLError("Creating Text Surface");
41  }
42
43  void Render(
44    SDL_Surface* Surface, SDL_Rect* Rect
45  ) {
46    if (TextSurface) {
47      SDL_BlitSurface(
48        TextSurface, nullptr, Surface, Rect
49      );
50    }
51  }
52
53private:
54  std::string Content;
55  TTF_Font* Font{nullptr};
56  SDL_Surface* TextSurface{nullptr};
57};

Engine/Random.h

1#pragma once
2#include <random>
3
4namespace Random {
5  inline std::random_device SEEDER;
6  inline std::mt19937 ENGINE{SEEDER()};
7
8  inline int Int(int Min, int Max) {
9    std::uniform_int_distribution Get{Min, Max};
10    return Get(ENGINE);
11  }
12}

Assets.h

1#pragma once
2#include "GameConfig.h"
3#include "Engine/Image.h"
4
5struct Assets {
6  Image Apple{Config::APPLE_IMAGE};
7};

GameConfig.h

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 =
10    SDL_RegisterEvents(1);
11  inline Uint32 APPLE_EATEN =
12    SDL_RegisterEvents(1);
13  inline Uint32 GAME_WON =
14    SDL_RegisterEvents(1);
15  inline Uint32 GAME_LOST =
16    SDL_RegisterEvents(1);
17  inline Uint32 RESTART_GAME =
18    SDL_RegisterEvents(1);
19}
20
21namespace Config{
22  // Game Settings
23  inline const std::string GAME_NAME{
24    "Snake"};
25  inline constexpr int ADVANCE_INTERVAL{200};
26
27  inline constexpr int GRID_COLUMNS{16};
28  static_assert(
29    GRID_COLUMNS >= 12,
30    "Grid must be at least 12 columns wide");
31
32  inline constexpr int GRID_ROWS{5};
33  static_assert(
34    GRID_ROWS >= 5,
35    "Grid must be at least 5 rows tall");
36
37  inline constexpr int MAX_SCORE{
38    GRID_COLUMNS * GRID_ROWS - 1};
39
40  // Size and Positioning
41  inline constexpr int PADDING{5};
42  inline constexpr int CELL_SIZE{36};
43  inline constexpr int FOOTER_HEIGHT{60};
44
45  inline constexpr int GRID_HEIGHT{
46    CELL_SIZE * GRID_ROWS};
47  inline constexpr int GRID_WIDTH{
48    CELL_SIZE * GRID_COLUMNS};
49
50  inline constexpr int WINDOW_HEIGHT{
51    GRID_HEIGHT + FOOTER_HEIGHT
52    + PADDING * 2
53  };
54  inline constexpr int WINDOW_WIDTH{
55    GRID_WIDTH + PADDING * 2
56  };
57
58  // Colors
59  inline constexpr SDL_Color BACKGROUND_COLOR{
60    85, 138, 52, 255};
61  inline constexpr SDL_Color CELL_COLOR_A{
62    171, 214, 82, 255};
63  inline constexpr SDL_Color CELL_COLOR_B{
64    161, 208, 74, 255};
65  inline constexpr SDL_Color SNAKE_COLOR{
66    67, 117, 234, 255};
67  inline constexpr SDL_Color SNAKE_LOST_COLOR{
68    227, 67, 97, 255};
69  inline constexpr SDL_Color SNAKE_VICTORY_COLOR{
70    255, 140, 0, 255};
71  inline constexpr SDL_Color BUTTON_COLOR{
72    73, 117, 46, 255};
73  inline constexpr SDL_Color BUTTON_HIGHLIGHT_COLOR{
74    67, 117, 234, 255};
75  inline constexpr SDL_Color SCORE_BACKGROUND_COLOR{
76    73, 117, 46, 255};
77  inline constexpr SDL_Color FONT_COLOR{
78    255, 255, 255, 255};
79
80  // Asset Paths
81  inline const std::string APPLE_IMAGE{
82    "apple.png"};
83  inline const std::string FONT{
84    "Rubik-SemiBold.ttf"};
85}
86
87inline void CheckSDLError(
88  const std::string& Msg){
89#ifdef CHECK_ERRORS
90  const char* error = SDL_GetError();
91  if (*error != '\0') {
92    std::cerr << Msg << " Error: "
93      << error << '\n';
94    SDL_ClearError();
95  }
96#endif
97}

GameState.h

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    using namespace UserEvents;
10    using namespace Config;
11    if (E.type == SDL_KEYDOWN) {
12      HandleKeyEvent(E.key);
13    } else if (E.type == APPLE_EATEN) {
14      ++Snake.Length;
15      if (Snake.Length == MAX_LENGTH) {
16        SDL_Event Event{GAME_WON};
17        SDL_PushEvent(&Event);
18      }
19    } else if (E.type == RESTART_GAME) {
20      RestartGame();
21    } else if (E.type == GAME_LOST ||
22               E.type == GAME_WON) {
23      IsGameOver = true;
24    }
25  }
26
27  void Tick(Uint32 DeltaTime) {
28    if (IsPaused || IsGameOver) return;
29
30    ElapsedTime += DeltaTime;
31    if (ElapsedTime >= Config::ADVANCE_INTERVAL) {
32      ElapsedTime = 0;
33      UpdateSnake();
34    }
35  }
36
37private:
38  void HandleKeyEvent(SDL_KeyboardEvent& E) {
39    if (IsGameOver) return;
40    switch (E.keysym.sym) {
41      case SDLK_UP:
42      case SDLK_w:
43        if (Snake.Direction != Down) {
44          NextDirection = Up;
45        }
46        break;
47      case SDLK_DOWN:
48      case SDLK_s:
49        if (Snake.Direction != Up) {
50          NextDirection = Down;
51        }
52        break;
53      case SDLK_LEFT:
54      case SDLK_a:
55        if (Snake.Direction != Right) {
56          NextDirection = Left;
57        }
58        break;
59      case SDLK_RIGHT:
60      case SDLK_d:
61        if (IsPaused) {
62          NextDirection = Right;
63          IsPaused = false;
64          UpdateSnake();
65        } else if (Snake.Direction != Left) {
66          NextDirection = Right;
67        }
68        break;
69    }
70  }
71
72  void UpdateSnake() {
73    Snake.Direction = NextDirection;
74    switch (NextDirection) {
75      case Up:
76        Snake.HeadRow--;
77        break;
78      case Down:
79        Snake.HeadRow++;
80        break;
81      case Left:
82        Snake.HeadCol--;
83        break;
84      case Right:
85        Snake.HeadCol++;
86        break;
87    }
88
89    if (
90      Snake.HeadRow < 0 ||
91      Snake.HeadRow >= Config::GRID_ROWS ||
92      Snake.HeadCol < 0 ||
93      Snake.HeadCol >= Config::GRID_COLUMNS
94    ) {
95      SDL_Event Event{UserEvents::GAME_LOST};
96      SDL_PushEvent(&Event);
97    } else {
98      SDL_Event Event{UserEvents::ADVANCE};
99      Event.user.data1 = &Snake;
100      SDL_PushEvent(&Event);
101    }
102  }
103
104  void RestartGame() {
105    IsPaused = true;
106    IsGameOver = false;
107    ElapsedTime = 0;
108    Snake = {Config::GRID_ROWS / 2, 3, 2, Right};
109    NextDirection = Right;
110  }
111
112  bool IsPaused{true};
113  bool IsGameOver{false};
114  Uint32 ElapsedTime{0};
115  SnakeData Snake{Config::GRID_ROWS / 2, 3, 2};
116  MovementDirection NextDirection{Right};
117};

GameUI.h

1#pragma once
2#include <SDL.h>
3#include "Grid.h"
4#include "Assets.h"
5#include "ScoreCounter.h"
6#include "RestartButton.h"
7
8class GameUI {
9 public:
10  GameUI()
11  : Grid{Assets},
12    ScoreCounter{Assets} {}
13
14  void HandleEvent(SDL_Event& E) {
15    Grid.HandleEvent(E);
16    ScoreCounter.HandleEvent(E);
17    RestartButton.HandleEvent(E);
18  }
19
20  void Tick(Uint32 DeltaTime) {
21    Grid.Tick(DeltaTime);
22  }
23
24  void Render(SDL_Surface* Surface) {
25    Grid.Render(Surface);
26    ScoreCounter.Render(Surface);
27    RestartButton.Render(Surface);
28  }
29
30 private:
31  Grid Grid;
32  Assets Assets;
33  ScoreCounter ScoreCounter;
34  RestartButton RestartButton;
35};

Grid.h

1#pragma once
2#include <SDL.h>
3#include <vector>
4#include "Cell.h"
5#include "GameConfig.h"
6#include "Engine/Random.h"
7
8class Grid {
9public:
10  Grid(Assets& Assets) {
11    using namespace Config;
12    Cells.reserve(GRID_ROWS * GRID_COLUMNS);
13    for (int R{0}; R < GRID_ROWS; ++R) {
14      for (int C{0}; C < GRID_COLUMNS; ++C) {
15        Cells.emplace_back(R, C, Assets);
16      }
17    }
18  }
19
20  void HandleEvent(SDL_Event& E) {
21    for (auto& Cell : Cells) {
22      Cell.HandleEvent(E);
23    }
24    if (E.type == UserEvents::APPLE_EATEN) {
25      PlaceRandomApple();
26    }
27  }
28
29  void Tick(Uint32 DeltaTime) {
30    for (auto& Cell : Cells) {
31      Cell.Tick(DeltaTime);
32    }
33  }
34
35  void Render(SDL_Surface* surface) {
36    for (auto& Cell : Cells) {
37      Cell.Render(surface);
38    }
39  }
40
41private:
42  std::vector<Cell> Cells;
43
44  void PlaceRandomApple() {
45    while (true) {
46      using Random::Int;
47      size_t RandomIndex{Int(0, Cells.size() - 1)};
48      if (Cells[RandomIndex].PlaceApple()) {
49        break;
50      }
51    }
52  }
53};

RestartButton.h

1#pragma once
2#include <SDL.h>
3#include "GameConfig.h"
4#include "Engine/Text.h"
5
6class RestartButton {
7public:
8  void Render(SDL_Surface* Surface) {
9    SDL_FillRect(Surface, &ButtonRect,
10      SDL_MapRGB(
11        Surface->format,
12        CurrentColor.r,
13        CurrentColor.g,
14        CurrentColor.b
15      )
16    );
17    Text.Render(Surface, &TextRect);
18  }
19
20  void HandleEvent(SDL_Event& E) {
21    using namespace UserEvents;
22    using namespace Config;
23    if (E.type == SDL_MOUSEBUTTONDOWN) {
24      HandleClick(E.button);
25    } else if (
26      E.type == GAME_LOST ||
27      E.type == GAME_WON
28    ) {
29      CurrentColor = BUTTON_HIGHLIGHT_COLOR;
30    } else if (E.type == RESTART_GAME) {
31      CurrentColor = BUTTON_COLOR;
32    }
33  }
34
35private:
36  void HandleClick(SDL_MouseButtonEvent& E) {
37    using namespace UserEvents;
38    if (
39      E.x >= ButtonRect.x &&
40      E.x <= ButtonRect.x + ButtonRect.w &&
41      E.y >= ButtonRect.y &&
42      E.y <= ButtonRect.y + ButtonRect.h
43    ) {
44      SDL_Event RestartEvent{RESTART_GAME};
45      SDL_PushEvent(&RestartEvent);
46    }
47  }
48
49  Text Text{"RESTART", 20};
50
51  SDL_Rect ButtonRect{
52    Config::WINDOW_WIDTH - 150,
53    Config::GRID_HEIGHT + 10,
54    150 - Config::PADDING,
55    Config::FOOTER_HEIGHT - Config::PADDING
56  };
57
58  SDL_Rect TextRect{
59    ButtonRect.x + Config::PADDING * 5,
60    ButtonRect.y + Config::PADDING * 3,
61    0, 0
62  };
63
64  SDL_Color CurrentColor{Config::BUTTON_COLOR};
65};

ScoreCounter.h

1#pragma once
2#include <SDL.h>
3#include "Engine/Text.h"
4#include "Assets.h"
5#include "GameConfig.h"
6
7class ScoreCounter {
8public:
9  ScoreCounter(Assets& Assets) : Assets{Assets} {}
10
11  void HandleEvent(SDL_Event& E) {
12    if (E.type == UserEvents::APPLE_EATEN) {
13      ++CurrentScore;
14      Text.SetText(GetScoreString());
15    } else if (E.type == UserEvents::RESTART_GAME) {
16      CurrentScore = 0;
17      Text.SetText(GetScoreString());
18    }
19  }
20
21  void Render(SDL_Surface* Surface) {
22    using namespace Config;
23    SDL_FillRect(Surface, &BackgroundRect,
24      SDL_MapRGB(Surface->format,
25        SCORE_BACKGROUND_COLOR.r,
26        SCORE_BACKGROUND_COLOR.g,
27        SCORE_BACKGROUND_COLOR.b
28      ));
29
30    Assets.Apple.Render(Surface, &AppleRect);
31    Text.Render(Surface, &TextRect);
32  }
33
34private:
35  std::string GetScoreString() {
36    return std::to_string(CurrentScore) + "/"
37      + std::to_string(MaxScore);
38  }
39
40  Assets& Assets;
41  int CurrentScore{0};
42  int MaxScore{Config::MAX_LENGTH - 2};
43  Text Text{GetScoreString(), 40};
44
45  SDL_Rect BackgroundRect{
46    Config::PADDING,
47    Config::GRID_HEIGHT + Config::PADDING * 2,
48    MaxScore > 99 ? 250 : 190,
49    Config::FOOTER_HEIGHT - Config::PADDING};
50
51  SDL_Rect AppleRect{
52    BackgroundRect.x + Config::PADDING,
53    BackgroundRect.y + Config::PADDING,
54    BackgroundRect.h - Config::PADDING * 2,
55    BackgroundRect.h - Config::PADDING * 2
56  };
57
58  SDL_Rect TextRect{
59    AppleRect.x + AppleRect.w + Config::PADDING,
60    AppleRect.y,
61    0, 0};
62};

SnakeData.h

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{Right};
10};

CMakeLists.txt

1cmake_minimum_required(VERSION 3.16)
2
3set(CMAKE_CXX_STANDARD 20)
4
5project(Snake VERSION 1.0.0)
6add_executable(Snake
7  "main.cpp"
8  "GameConfig.h"
9  "Engine/Window.h"
10  "Engine/Image.h"
11  "Engine/Text.h"
12  "Engine/Random.h"
13  "GameUI.h"
14  "Assets.h"
15  "GameState.h"
16  "Cell.h"
17  "Grid.h"
18  "SnakeData.h"
19  "ScoreCounter.h"
20  "RestartButton.h")
21
22target_include_directories(
23  Snake PUBLIC ${PROJECT_SOURCE_DIR}
24)
25
26add_subdirectory(external/SDL)
27add_subdirectory(external/SDL_image)
28add_subdirectory(external/SDL_ttf)
29
30target_link_libraries(Snake PRIVATE
31  SDL2
32  SDL2_image
33  SDL2_ttf
34)
35
36if (WIN32)
37  target_link_libraries(
38    Snake PRIVATE SDL2main
39  )
40endif()
41
42set(AssetDirectory "${PROJECT_SOURCE_DIR}/Assets")
43add_custom_command(
44  TARGET Snake POST_BUILD COMMAND
45  ${CMAKE_COMMAND} -E copy_if_different
46    "$<TARGET_FILE:SDL2>"
47    "$<TARGET_FILE:SDL2_image>"
48    "$<TARGET_FILE:SDL2_ttf>"
49    "${AssetDirectory}/apple.png"
50    "${AssetDirectory}/Rubik-SemiBold.ttf"
51    "$<TARGET_FILE_DIR:Snake>"
52  VERBATIM
53)

Assets/Rubik-SemiBold.tff available from Google Fonts
Assets/bomb.png available from IconFinder
Assets/flag.png available from IconsDB

Improvement Ideas

Congratulations on building your working Snake game! You've learned a lot about SDL2, game loops, event handling, and animation. However, the learning process doesn't stop here.

A crucial part of becoming a better programmer is to experiment, iterate, and improve upon your creations. By taking on self-directed challenges, you solidify your understanding and develop problem-solving skills.

Now that you have a functional base, consider exploring some of the following improvements. These will not only enhance your game but also deepen your understanding of C++ and game development principles. Think of these as opportunities to apply what you've learned and push your abilities further.

User-Defined Game Settings

Currently, many of the game's core parameters, like grid size (GRID_ROWS, GRID_COLUMNS) and the snake's movement speed (ADVANCE_INTERVAL), are hardcoded as constants. A more flexible and user-friendly approach would be to allow the player to customize these settings.

Consider adding a simple menu system, perhaps accessible at the start of the game or through a pause screen. This menu could present options to:

Adjust Grid Size: Let the player choose between different grid dimensions (e.g., small, medium, large). This will affect the game's difficulty and play area.
Change Snake Speed: Offer options to control how quickly the snake moves (e.g., slow, normal, fast). This can significantly alter the game's challenge.
Customize Colors: Allow the player to personalize the snake's color, the background, or the cell colors.

Implementing these features will require you to:

Create UI elements to represent the settings.
Handle user input to change the settings.
Store the selected settings (perhaps in a separate GameSettings class).
Modify your game logic to use these settings instead of hardcoded values.

Input Queue

Currently, every time our game advances, only the most recent keyboard input is used to determine how the snake turns (GameState::NextDirection). This can make our game effectively ignore some inputs if the user provides an additional input before the next Advance().

This behavior is sometimes fine, but many games use an input queue to allow all inputs provided in quick succession to be acted upon.

This involves creating a data structure (like a std::vector or std::queue) that stores a sequence of player inputs. Then, in your game's update loop, you would process all of the inputs from the queue in a way that feels better for the type of game you’re making.

Reducing Event Traffic

To keep things simple, our project routed pretty much every event through to every relevant object in our game. This results in a lot of excess traffic, where the object’s HandleEvent() functions are invoked with an event the object has no interest in.

Every function call that results in no effect has an unnecessary performance cost. An obvious way to reduce this traffic is having each parent check an event is relevant to its children before forwarding it:

1void HandleEvent(const SDL_Event& E){
2  if (isRelevantToChildren(E.type) {
3    for (auto& Child : Children) {
4      Child.HandleEvent(E);
5    }
6  }
7};

However, this limits flexibility. When creating a parent class, we often won’t know what type of children we’ll eventually be managing.

Even if we did know exactly what event types the children are interested in, declaring that within the parent would typically be a bad design.

To keep our code well organized and understandable, the event types that a class is interested in should be managed within that same class. For example, the event types that Cell objects are interested in should be declared in the Cell class.

Objects can then provide that list to their parent, or to some object that is managing event traffic. For example:

1class Child: public EventReceiver {
2  // Subscribe to event types from constructor
3  Child(EventReceiver* Parent) {
4    Parent->SubscribeToEventTypes({
5      UserEvents::GAME_START,
6      UserEvents::GAME_END,
7      // ...
8    })
9  }
10  
11  // ...
12}

This system can become increasingly elaborate - for example, objects may subscribe or unsubscribe from events at different points during their lifecycle:

1class Child: public EventReceiver {
2  // ...
3  void SetIsDisabled() {
4    // No longer interested in mouse events
5    Parent->UnsubscribeToEventTypes({
6      SDL_MOUSEMOTION,
7      SDL_MOUSEBUTTON
8    })
9  }
10  
11  // ...
12}

This situation is one example of a problem that can be solved by concepts like function pointers, delegates, and observers that we covered earlier in the course.

Refactoring

Now that you have a complete game, it's a good time to revisit your code and look for areas to improve its structure, readability, and maintainability.

If a class or system doesn’t make sense or is difficult to follow, that’s a good indicator that it could use some refactoring. Here are some examples that might be worth considering:

GameState and GameUI Interaction: Consider separating game logic from UI updates more cleanly. GameState could focus solely on the game's internal state, and GameUI (and its children) could observe changes in GameState.

This can perhaps be through the observer pattern, or implementing logic in the Tick() function that queries the GameState for information that is relevant to what needs to be displayed on the GameUI.

Cell Responsibilities: The Cell class currently handles a lot of different tasks: rendering, animation, collision detection, and even some game logic (like pushing APPLE_EATEN events). You might consider breaking down Cell into smaller, more specialized classes or components. For example, you could have a separate SnakeSegment class to handle the snake-specific logic and animation, and Cell could focus on representing the grid cell itself.

`const`

To keep our lessons as simple as possible, we restrict the syntax as much as possible to keep the focus on the core concepts. However, there are some more advanced C++ features that you may want to add if you’re more comfortable.

One such example is the const keyword, which we covered in more detail here:

Constants and `const`-Correctness

Learn the intricacies of using const and how to apply it in different contexts

The most useful place where we can apply const to our game is when our functions are receiving arguments by reference or pointer. If the function is not going to modify that argument, we should mark it as const. This applies to all of our HandleEvent() functions, for example:

1// ScoreCounter.h
2// ...
3
4class ScoreCounter {
5public:
6  void HandleEvent(const SDL_Event& E) {
7    // ...
8  }
9  // ...
10};

When a class method does not modify any of the class members, it is also useful to mark that method as const. For example:

1// ScoreCounter.h
2// ...
3
4class ScoreCounter {
5  // ...
6private:
7  std::string GetScoreString() const {
8    return std::to_string(CurrentScore) + "/"
9      + std::to_string(MaxScore);
10  }
11  // ...
12};

`static` and `inline`

More keywords we should consider deploying are static and inline. We cover these keywords in more detail here in our advanced course:

Abstract art representing computer programming

Static Class Variables and Functions

A guide to sharing values between objects using static class variables and functions

An example that can be made static and inline in our snake game is the SnakeColor, as this variable has the same value in every Cell instance:

1// ScoreCounter.h
2// ...
3
4class Cell {
5  // ...
6private:
7  inline static SDL_Color SnakeColor;
8  // ...
9};

Friends and `private` Constructors

Finally, we should consider how our objects can be constructed. Currently, all of our classes have public constructors, meaning they can be created by any other class.

However, this may not align with our designs. For example, Asset objects are intended to only be constructed by GameUI objects, so we may want to make that constraint official.

To do this, we can make the Asset constructor private, and give GameUI access to this constructor by declaring it to be a friend:

1#pragma once
2#include "GameConfig.h"
3#include "Engine/Image.h"
4
5struct Assets {
6  Image Apple{Config::APPLE_IMAGE};
7
8private:
9  friend class GameUI;
10  Assets() = default;
11};

We cover the friend keyword in more detail here:

Friend Classes and Functions

An introduction to the friend keyword, which allows classes to give other objects and functions enhanced access to its members

Summary

This lesson focused on implementing a visual improvement: animating the snake's movement across the grid. We replaced the instantaneous cell-to-cell jumps with a smooth sliding effect. This was done with the following components:

FillPercent (0.0 to 1.0) controls how much of a cell is filled by the snake.
FillDirection indicates the direction of snake movement within a cell.
SnakeRect is dynamically resized and repositioned in each frame to create the animation.
GrowHead() handles the animation of the snake entering a cell.
ShrinkTail() handles the animation of the snake leaving a cell.

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