Grid-Based Placement

In the previous lessons, we built the core functionality for dragging, dropping, selecting, and deleting actors in our level editor. Currently, actors can be placed anywhere on the level canvas, overlapping freely. While this works for some game styles, many benefit from more structured placement.

This lesson introduces grid-based positioning. First, we'll implement grid snapping. When dragging or dropping an actor within the level, its position will automatically "snap" to the nearest grid line. This helps designers align objects precisely without tedious manual adjustments.

Then, we'll take it a step further and transform our editor into a true cell-based system. We'll modify the logic so that only one actor can occupy any given grid cell at a time. Dropping an actor onto an already occupied cell will replace the existing actor.

By the end, you'll understand:

• How to define and configure a grid system.
• The math behind snapping coordinates to a grid.
• Modifying tooltip and actor placement logic for snapping.
• Enforcing single occupancy per grid cell.

Snapping to Grid Positions

Our first step towards a grid-based system is configuring the grid itself. In Config.h, inside the Config::Editor namespace, we'll add constants defining the snapping distances. HORIZONTAL_GRID_SNAP will be 50, and VERTICAL_GRID_SNAP will be 25, reflecting the dimensions of our game's blocks.

We also need to define how many grid cells make up our level. Let's add GRID_WIDTH and GRID_HEIGHT. We’ll set them to 13 and 6 for our examples, but our program will scale to any values we prefer here.

We'll use the Uint8 type for these. This is an 8-bit unsigned integer, meaning it can hold values from 0 to 255. Using a fixed-size type like Uint8 is important because we intend to serialize these dimensions to a file later; it ensures the data size is predictable. If we needed larger levels, Uint16 would be the next choice.

We’ll also update the level's rendering size - LEVEL_WIDTH and LEVEL_HEIGHT - to be based on these new values. This ensures that the level's rendering area in the editor always matches the space required by the defined grid. Any changes to the grid configuration (number of cells or snap size) will automatically propagate to the level's dimensions.

1// Config.h
2// ...
3
4#ifdef WITH_EDITOR
5namespace Config::Editor {
6// Level
7inline const int HORIZONTAL_GRID_SNAP{50};
8inline const int VERTICAL_GRID_SNAP{25};
9inline const Uint8 GRID_WIDTH{13};
10inline const Uint8 GRID_HEIGHT{6};
11inline const int LEVEL_WIDTH{
12  HORIZONTAL_GRID_SNAP * GRID_WIDTH};
13inline const int LEVEL_HEIGHT{
14  VERTICAL_GRID_SNAP * GRID_HEIGHT};
15inline constexpr SDL_Color LEVEL_BACKGROUND{
16  50, 50, 50, 255};
17
18// ...
19}
20// ...
21#endif

Now that we have the grid dimensions configured, we need a function within our Level class to perform the actual snapping calculation. This function will take an arbitrary coordinate (x, y) and return the coordinates of the top-left corner of the grid cell that contains it.

Let's declare this function in Editor/Level.h. We'll add a public member function SnapToGridPosition() that accepts two int parameters (x and y) and returns an SDL_Point, which holds the resulting snapped x and y coordinates.

1// Editor/Level.h
2// ...
3
4namespace Editor {
5 // ...
6
7class Level {
8 public:
9  // ...
10  SDL_Point SnapToGridPosition(int x, int y);
11  // ...
12};
13}

Now let's implement SnapToGridPosition() in Editor/Source/Level.cpp.

The logic relies on integer division. When we divide the input coordinate (e.g., x) by the corresponding grid snap size (sx), integer division automatically truncates any remainder, effectively rounding down to the nearest whole number of grid steps.

Multiplying this result back by the snap size (sx) gives us the coordinate of the grid line just below or at the input coordinate. We do this for both x and y using HORIZONTAL_GRID_SNAP and VERTICAL_GRID_SNAP from our configuration, and return the result as an SDL_Point.

1// Editor/Source/Level.cpp
2// ...
3
4SDL_Point Level::SnapToGridPosition(
5  int x, int y
6) {
7  using namespace Config::Editor;
8  int sx{HORIZONTAL_GRID_SNAP};
9  int sy{VERTICAL_GRID_SNAP};
10  return {
11    (x / sx) * sx,
12    (y / sy) * sy,
13  };
14}

Snapping the Tooltip to the Grid

Now that our Level can calculate snapped positions, let's apply this to the ActorTooltip. We want the tooltip to snap to the grid, but only when the mouse cursor is actually hovering over the level area. When the cursor is outside the level (e.g., over the actor menu or elsewhere on the screen entirely), the tooltip should follow the mouse smoothly as before.

We can achieve this conditional behavior in ActorTooltip::PositionWindow(). We already have an if statement checking ParentScene.GetLevel().HasMouseFocus().

The logic for smooth, non-snapped positioning (using the DragOffset) belongs in the else block – the case where the mouse is not over the level.

Let's refactor the code. We’ll move the lines that calculate the position using DragOffset and the corresponding SDL_SetWindowPosition() call inside the else block.

1// Editor/Source/ActorTooltip.cpp
2// ...
3
4void ActorTooltip::PositionWindow() {
5  int x, y;
6  SDL_GetGlobalMouseState(&x, &y);
7  
8  auto [DragOffsetX, DragOffsetY]{
9    DragActor->GetDragOffset()
10  };
11
12  SDL_SetWindowPosition(
13    SDLWindow,
14    x - DragOffsetX,
15    y - DragOffsetY
16  );
17
18  if (ParentScene.GetLevel().HasMouseFocus()) {
19    SDL_SetWindowOpacity(SDLWindow, 1);
20    SDL_SetCursor(SDL_GetDefaultCursor());
21  } else {
22    auto [DragOffsetX, DragOffsetY]{
23      DragActor->GetDragOffset()
24    };
25
26    SDL_SetWindowPosition(
27      SDLWindow,
28      x - DragOffsetX,
29      y - DragOffsetY
30    );
31    SDL_SetWindowOpacity(SDLWindow, 0.5);
32    SDL_SetCursor(DenyCursor);
33  }
34}

Now, let's add the code to the if block for when the tooltip should snap. We face a slight complication: the tooltip's position is set using global screen coordinates - SDL_SetWindowPosition() - but our SnapToGridPosition() function works with coordinates relative to the level area within our main window.

To bridge this, we first need the screen coordinates of our main window's top-left corner. We can get this from the ParentScene, storing the result in WinX and WinY.

Next, we calculate the mouse's position relative to this window by subtracting WinX and WinY from the global mouse coordinates (x, y). We pass these relative coordinates (x - WinX, y - WinY) to SnapToGridPosition().

This gets what the grid-snapped tooltip position would be if our main window was positioned at (0, 0) within the overall screen. We’ll store those values at GridX, GridY.

However, our main window is unlikely to be positioned at (0, 0) so, when setting the final position of our tooltip, we need to add the window’s actual position back to our final result. So, we call SDL_SetWindowPosition() , passing WinX + GridX and WinY + GridY.

1// Editor/Source/ActorTooltip.cpp
2// ...
3
4void ActorTooltip::PositionWindow() {
5  int x, y;
6  SDL_GetGlobalMouseState(&x, &y);
7
8  if (ParentScene.GetLevel().HasMouseFocus()) {
9    SDL_SetWindowOpacity(SDLWindow, 1);
10    SDL_SetCursor(SDL_GetDefaultCursor());
11    auto [WinX, WinY]{
12      ParentScene.GetWindow().GetPosition()
13    };
14
15    auto [GridX, GridY]{
16      ParentScene.GetLevel().SnapToGridPosition(
17        x - WinX, y - WinY
18      )
19    };
20
21    SDL_SetWindowPosition(
22      SDLWindow, WinX + GridX, WinY + GridY
23    );
24  } else {
Else Block Unchanged|Show
35  }
36}

Don’t worry if this transformation between coordinate systems doesn’t entirely make sense at this point. We have dedicated lessons on coordinate systems, and transformations between them, coming later in the course.

If we run our program now, we should see our tooltip snapping to grid positions as we drag our actor over the level. However, once we drop the actor, its position in the level is not snapped to that same grid, so let’s address that next.

Snapping Actors to the Grid

Our final step for snapping is to ensure the actors themselves land on the grid coordinates when dropped. This requires updating the Level::HandleDrop() function.

We previously used the mouse position and a drag offset to determine the drop location. Now, we want to ignore the drag offset and use only the snapped grid position.

We’ll modify HandleDrop() to delete the code that gets DragOffset. After getting the window-relative MouseX and MouseY, we’ll call SnapToGridPosition() to calculate GridX and GridY.

We’ll then update both SetPosition() calls (inside the if for cloned actors and the else for moved actors) to use GridX, GridY as the target coordinates.

1// Editor/Source/Level.cpp
2// ...
3
4void Level::HandleDrop(Actor* DragActor) {
5  DragActor->SetIsVisible(true);
6  if (!HasMouseFocus()) {
7    return;
8  }
9
10  int MouseX, MouseY;
11  SDL_GetMouseState(&MouseX, &MouseY);
12  auto [GridX, GridY]{
13    SnapToGridPosition(
14      MouseX, MouseY
15    )
16  };
17
18  using enum ActorLocation;
19  if (DragActor->GetLocation() == Menu) {
20    ActorPtr NewActor{DragActor->Clone()};
21    NewActor->SetPosition(GridX, GridY);
22    SelectedActor = NewActor.get();
23    AddToLevel(std::move(NewActor));
24  } else {
25    DragActor->SetPosition(GridX, GridY);
26    SelectedActor = DragActor;
27  }
28}
29
30void Level::AddToLevel(ActorPtr NewActor) {
31  NewActor->SetLocation(ActorLocation::Level);
32  Actors.push_back(std::move(NewActor));
33}
34
35bool Level::HasMouseFocus() const {
36  if (!ParentScene.HasMouseFocus()) {
37    return false;
38  }
39  int x, y;
40  SDL_GetGlobalMouseState(&x, &y);
41  auto [WinX, WinY]{
42    ParentScene.GetWindow().GetPosition()
43  };
44
45  if (
46    x >= WinX + Config::Editor::LEVEL_WIDTH ||
47    y >= WinY + Config::Editor::LEVEL_HEIGHT
48  ) {
49    return false;
50  }
51  return true;
52}
53
54SDL_Point Level::SnapToGridPosition(
55  int x, int y
56) {
57  using namespace Config::Editor;
58  int sx{HORIZONTAL_GRID_SNAP};
59  int sy{VERTICAL_GRID_SNAP};
60  return {
61    (x / sx) * sx,
62    (y / sy) * sy,
63  };
64}

Running our program, we should now see we can easily position our actors in an organized grid:

One Actor Per Grid Position

Our editor now snaps actors to a grid, but it still allows multiple actors to occupy the same grid cell. For many tile or grid-based games, this is undesirable; each cell should hold at most one actor. We need to enforce this constraint.

The desired behavior is: when an actor is dropped onto a grid cell, any actor already present in that cell should be removed first. However, if the user simply clicks an actor and releases (effectively dropping it back into its original cell), we shouldn't delete and replace it.

To implement this, we'll add a helper function to the Level class specifically for deleting an actor at a given grid position, with an exception for the actor being dropped.

Let's declare DeleteAtPosition() in the public section of Editor/Level.h. The Unless parameter will hold a pointer to the actor currently being dragged/dropped, preventing it from deleting itself if dropped in its own previous location.

1// Editor/Level.h
2// ...
3
4namespace Editor {
5// ...
6
7class Level {
8 public:
9  // ...
10  void DeleteAtPosition(
11    int x, int y, const Actor* Unless);
12  // ...
13};
14}

Now, let's implement DeleteAtPosition() in Editor/Source/Level.cpp. We need to search through our Actors vector to find if any actor's position matches the provided x and y.

We can use a traditional for loop with an index. Inside the loop, we’ll get the position (ax, ay) of the current actor Actors[i]. We’ll check if ax == x and ay == y. We’ll check if the raw pointer Actors[i].get() is not equal to the Unless pointer.

If all conditions are true, we've found a different actor at the target location that needs to be removed. We use Actors.erase() to remove it and immediately break from the loop, as there can be at most one actor per position now.

1// Editor/Source/Level.cpp
2// ...
3
4void Level::DeleteAtPosition(
5  int x, int y, const Actor* Unless
6) {
7  for (size_t i{0}; i < Actors.size(); ++i) {
8    auto [ax, ay]{Actors[i]->GetPosition()};
9    if (ax == x && ay == y
10        && Actors[i].get() != Unless
11    ) {
12      Actors.erase(Actors.begin() + i);
13      break;
14    }
15  }
16}

1// Editor/Source/Level.cpp
2// ...
3
4void Level::DeleteAtPosition(
5  int x, int y, const Actor* Unless
6) {
7  std::erase_if(Actors,
8    [&](const ActorPtr& Actor){
9      auto [ax, ay]{Actor->GetPosition()};
10      return
11        ax == x &&
12        ay == y &&
13        Actor.get() != Unless;
14     }
15  );
16}

Finally, we integrate the deletion logic into the drop handling process. In Level::HandleDrop(), right after calculating the target grid coordinates GridX, GridY, we need to call our new deletion function.

We’ll add our call to DeleteAtPosition() to ensure that, before we either clone DragActor to (GridX, GridY) or move DragActor to (GridX, GridY), any other actor currently occupying that cell is removed.

The DragActor pointer is passed as the Unless argument, preventing self-deletion when moving an actor back to its original cell or just clicking it.

1// Editor/Source/Level.cpp
2// ...
3
4void Level::HandleDrop(Actor* DragActor) {
5  DragActor->SetIsVisible(true);
6  if (!HasMouseFocus()) {
7    return;
8  }
9
10  int MouseX, MouseY;
11  SDL_GetMouseState(&MouseX, &MouseY);
12  auto [GridX, GridY]{
13    SnapToGridPosition(
14      MouseX,
15      MouseY
16    )
17  };
18  DeleteAtPosition(GridX, GridY, DragActor);
19  
Remaining Code (Unchanged)|Show
30}

If we compile and run our program, we should now verify that, when we drop an actor into a grid position, any other actor that was previously in that grid position gets replaced.

Complete Code

Our updated Level class and Config.h file are provided below:

1#pragma once
2#include <iostream>
3#include <SDL.h>
4#include <string>
5#include <vector>
6
7namespace UserEvents{
8#ifdef WITH_EDITOR
9  inline Uint32 ACTOR_DRAG{
10    SDL_RegisterEvents(1)};
11#endif
12}
13
14namespace Config {
15inline const std::vector BUTTON_COLORS{
16  SDL_Color{15, 15, 15, 255},  // Normal
17  SDL_Color{15, 155, 15, 255}, // Hover
18  SDL_Color{225, 15, 15, 255}, // Active
19  SDL_Color{60, 60, 60, 255}   // Disabled
20};
21
22inline constexpr SDL_Color FONT_COLOR{
23  255, 255, 255, 255};
24
25inline const std::string FONT{
26  "Assets/Rubik-SemiBold.ttf"};
27}
28
29#ifdef WITH_EDITOR
30namespace Config::Editor {
31// Level
32inline const int HORIZONTAL_GRID_SNAP{50};
33inline const int VERTICAL_GRID_SNAP{25};
34inline const Uint8 GRID_WIDTH{13};
35inline const Uint8 GRID_HEIGHT{6};
36inline const int LEVEL_WIDTH{
37  HORIZONTAL_GRID_SNAP * GRID_WIDTH};
38inline const int LEVEL_HEIGHT{
39  VERTICAL_GRID_SNAP * GRID_HEIGHT};
40inline constexpr SDL_Color LEVEL_BACKGROUND{
41  50, 50, 50, 255};
42
43// ActorMenu
44inline const int ACTOR_MENU_WIDTH{70};
45inline const int ACTOR_MENU_POSITION_X{LEVEL_WIDTH};
46inline const SDL_Color ACTOR_MENU_BACKGROUND{
47  15, 15, 15, 255};
48inline const int PADDING{10};
49
50// Window
51inline const std::string WINDOW_TITLE{"Editor"};
52inline const int WINDOW_WIDTH{
53  LEVEL_WIDTH + ACTOR_MENU_WIDTH};
54inline const int WINDOW_HEIGHT{LEVEL_HEIGHT + 50};
55inline const SDL_Color WINDOW_BACKGROUND{
56  35, 35, 35, 255};
57}
58#endif
59
60inline void CheckSDLError(
61  const std::string& Msg) {
62#ifdef CHECK_ERRORS
63  const char* error = SDL_GetError();
64  if (*error != '\0') {
65    std::cerr << Msg << " Error: "
66      << error << '\n';
67    SDL_ClearError();
68  }
69#endif
70}

1#pragma once
2#include <SDL.h>
3#include <memory>
4#include <vector>
5#include "Actor.h"
6
7namespace Editor {
8class Scene;
9using ActorPtr = std::unique_ptr<Actor>;
10using ActorPtrs = std::vector<ActorPtr>;
11
12class Level {
13 public:
14  Level(Scene& ParentScene)
15  : ParentScene{ParentScene} {}
16
17  void HandleEvent(const SDL_Event& E);
18  void HandleDrop(Actor* DragActor);
19  void Tick(float DeltaTime);
20  void Render(SDL_Surface* Surface);
21  bool HasMouseFocus() const;
22  void AddToLevel(ActorPtr NewActor);
23  SDL_Point SnapToGridPosition(int x, int y);
24  void DeleteAtPosition(
25    int x, int y, const Actor* Unless);
26
27 private:
28  Scene& ParentScene;
29  ActorPtrs Actors;
30  Actor* SelectedActor{nullptr};
31
32  SDL_Rect Rect{
33    0, 0,
34    Config::Editor::LEVEL_WIDTH,
35    Config::Editor::LEVEL_HEIGHT
36  };
37};
38}

1#include <ranges>
2#include "Editor/Level.h"
3#include "Editor/Scene.h"
4
5using namespace Editor;
6
7void Level::HandleEvent(const SDL_Event& E) {
8  using namespace std::views;
9  for (ActorPtr& A : reverse(Actors)) {
10    if (A->HandleEvent(E)) {
11      break;
12    }
13  }
14
15  if (
16    E.type == SDL_MOUSEBUTTONDOWN &&
17    E.button.button == SDL_BUTTON_LEFT
18  ) {
19    SelectedActor = nullptr;
20  } else if (
21    E.type == SDL_KEYDOWN &&
22    E.key.keysym.sym == SDLK_DELETE &&
23    SelectedActor
24  ) {
25    std::erase_if(Actors,
26      [&](ActorPtr& Actor){
27        return Actor.get() == SelectedActor;
28      }
29    );
30
31    SelectedActor = nullptr;
32  }
33}
34
35void Level::Tick(float DeltaTime) {
36  for (ActorPtr& A : Actors) {
37    A->Tick(DeltaTime);
38  }
39}
40
41void Level::Render(SDL_Surface* Surface) {
42  auto [r, g, b, a]{
43    Config::Editor::LEVEL_BACKGROUND
44  };
45
46  SDL_FillRect(Surface, &Rect, SDL_MapRGB(
47    Surface->format, r, g, b));
48
49  for (ActorPtr& A : Actors) {
50    if (SelectedActor &&
51      A.get() == SelectedActor &&
52      SelectedActor->GetIsVisible()
53    ) {
54      auto [x, y, w, h]{
55        SelectedActor->GetRect()
56      };
57      SDL_Rect Rect{x - 1, y - 1, w + 2, h + 2};
58      SDL_FillRect(Surface, &Rect, SDL_MapRGB(
59        Surface->format, 255, 255, 255)
60      );
61    }
62    A->Render(Surface);
63  }
64}
65
66void Level::HandleDrop(Actor* DragActor) {
67  DragActor->SetIsVisible(true);
68  if (!HasMouseFocus()) {
69    return;
70  }
71
72  int MouseX, MouseY;
73  SDL_GetMouseState(&MouseX, &MouseY);
74  auto [GridX, GridY]{
75    SnapToGridPosition(
76      MouseX,
77      MouseY
78    )
79  };
80  DeleteAtPosition(GridX, GridY, DragActor);
81
82  using enum ActorLocation;
83  if (DragActor->GetLocation() == Menu) {
84    ActorPtr NewActor{DragActor->Clone()};
85    NewActor->SetPosition(GridX, GridY);
86    SelectedActor = NewActor.get();
87    AddToLevel(std::move(NewActor));
88  } else {
89    DragActor->SetPosition(GridX, GridY);
90    SelectedActor = DragActor;
91  }
92}
93
94void Level::AddToLevel(ActorPtr NewActor) {
95  NewActor->SetLocation(ActorLocation::Level);
96  Actors.push_back(std::move(NewActor));
97}
98
99bool Level::HasMouseFocus() const {
100  if (!ParentScene.HasMouseFocus()) {
101    return false;
102  }
103  int x, y;
104  SDL_GetGlobalMouseState(&x, &y);
105  auto [WinX, WinY]{
106    ParentScene.GetWindow().GetPosition()
107  };
108
109  if (
110    x >= WinX + Config::Editor::LEVEL_WIDTH ||
111    y >= WinY + Config::Editor::LEVEL_HEIGHT
112  ) {
113    return false;
114  }
115  return true;
116}
117
118SDL_Point Level::SnapToGridPosition(
119  int x, int y
120) {
121  using namespace Config::Editor;
122  int sx{HORIZONTAL_GRID_SNAP};
123  int sy{VERTICAL_GRID_SNAP};
124  return {
125    (x / sx) * sx,
126    (y / sy) * sy,
127  };
128}
129
130void Level::DeleteAtPosition(
131  int x, int y, const Actor* Unless
132) {
133  std::erase_if(Actors,
134    [&](const ActorPtr& Actor){
135      auto [ax, ay]{Actor->GetPosition()};
136      return
137        ax == x &&
138        ay == y &&
139        Actor.get() != Unless;
140     }
141  );
142}

We also updated the PositionWindow() function of our ActorTooltip:

1#include "Editor/ActorTooltip.h"
2#include "Editor/Scene.h"
3
4using namespace Editor;
5
6ActorTooltip::ActorTooltip(Scene& ParentScene)
7  : ParentScene{ParentScene} {
8  SDLWindow = SDL_CreateWindow(
9    "Tooltip",
10    SDL_WINDOWPOS_UNDEFINED,
11    SDL_WINDOWPOS_UNDEFINED,
12    100,
13    100,
14    SDL_WINDOW_HIDDEN
15    | SDL_WINDOW_TOOLTIP
16    | SDL_WINDOW_BORDERLESS
17    | SDL_WINDOW_SKIP_TASKBAR
18    | SDL_WINDOW_ALWAYS_ON_TOP
19  );
20  CheckSDLError("Creating Tooltip Window");
21
22  DenyCursor = SDL_CreateSystemCursor(
23    SDL_SYSTEM_CURSOR_NO
24  );
25  CheckSDLError("Creating DenyCursor");
26}
27
28ActorTooltip::~ActorTooltip() {
29  if (!SDL_WasInit(SDL_INIT_VIDEO)) return;
30  if (SDLWindow) {
31    SDL_DestroyWindow(SDLWindow);
32  }
33  if (DenyCursor) {
34    SDL_FreeCursor(DenyCursor);
35  }
36}
37
38void ActorTooltip::Render() {
39  if (!isVisible) return;
40  DragActor->GetArt().Render(
41    GetSurface(),
42    SDL_Rect{
43      0, 0,
44      DragActor->GetRect().w,
45      DragActor->GetRect().h
46    });
47
48  SDL_UpdateWindowSurface(SDLWindow);
49}
50
51void ActorTooltip::Tick(float DeltaTime) {
52  if (!isVisible) return;
53
54  auto Buttons{
55    SDL_GetGlobalMouseState(
56      nullptr, nullptr)};
57  if (!(Buttons & SDL_BUTTON_LEFT)) {
58    SetIsVisible(false);
59    ParentScene.GetLevel().HandleDrop(DragActor);
60  } else {
61    PositionWindow();
62  }
63}
64
65void ActorTooltip::PositionWindow() {
66  int x, y;
67  SDL_GetGlobalMouseState(&x, &y);
68
69  if (ParentScene.GetLevel().HasMouseFocus()) {
70    SDL_SetWindowOpacity(SDLWindow, 1);
71    SDL_SetCursor(SDL_GetDefaultCursor());
72    auto [WinX, WinY]{
73      ParentScene.GetWindow().GetPosition()
74    };
75
76    auto [GridX, GridY]{
77      ParentScene.GetLevel().SnapToGridPosition(
78        x - WinX, y - WinY
79      )
80    };
81
82    SDL_SetWindowPosition(
83      SDLWindow, WinX + GridX, WinY + GridY
84    );
85  } else {
86    auto [DragOffsetX, DragOffsetY]{
87      DragActor->GetDragOffset()
88    };
89
90    SDL_SetWindowPosition(
91      SDLWindow, x - DragOffsetX, y - DragOffsetY
92    );
93    SDL_SetWindowOpacity(SDLWindow, 0.5);
94    SDL_SetCursor(DenyCursor);
95  }
96}
97
98void ActorTooltip::HandleEvent(
99  const SDL_Event& E) {
100  using namespace UserEvents;
101  if (E.type == ACTOR_DRAG) {
102    DragActor = static_cast<Actor*>(
103      E.user.data1
104    );
105    SDL_SetWindowSize(
106      SDLWindow,
107      DragActor->GetRect().w,
108      DragActor->GetRect().h
109    );
110    SetIsVisible(true);
111  }
112}
113
114void ActorTooltip::SetIsVisible(bool Visible) {
115  isVisible = Visible;
116  if (isVisible) {
117    SDL_ShowWindow(SDLWindow);
118  } else {
119    SDL_HideWindow(SDLWindow);
120    SDL_SetCursor(SDL_GetDefaultCursor());
121    SDL_SetWindowOpacity(SDLWindow, 1);
122  }
123}

Summary

This lesson transitioned our level editor from freeform placement to a structured grid-based system. We implemented grid snapping for precise alignment and enforced a rule allowing only one actor per grid cell, replacing any existing actor upon dropping a new one.

Key steps:

• Defined grid parameters in configuration.
• Used fixed-width integers (Uint8) for grid dimensions to prepare for serialization.
• Implemented a SnapToGridPosition() function using integer division math: $(\text{coord} / \text{snap}) \times \text{snap}$.
• Updated ActorTooltip::PositionWindow() to handle coordinate space conversions (global mouse -> window relative -> snapped -> window relative -> screen) for snapped tooltip positioning over the level.
• Modified Level::HandleDrop() to use snapped coordinates and ignore the drag offset.
• Added Level::DeleteAtPosition() to remove existing actors from a target cell before placing a new one.
• Integrated the deletion call into HandleDrop() to enforce single occupancy per 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

View Course