Grid-Based Placement

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.

We can achieve this conditional behavior in PositionWindow(). We already have an if statement checking if the Level has mouse focus.

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

Now, let's add the code to the if block for when the tooltip should snap.

Because our tooltip was created using SDL_CreatePopupWindow(), its position is always set relative to its parent window. This makes our math very simple: SDL_GetMouseState() returns the mouse position relative to that same parent window.

We can simply pass these mouse coordinates to SnapToGridPosition(), and then pass the result directly to SDL_SetWindowPosition().

1// ...
2
3void ActorTooltip::PositionWindow() {
4  float x, y;
5  SDL_GetMouseState(&x, &y);
6
7  if (ParentScene.GetLevel().HasMouseFocus()) {
8    SDL_SetWindowOpacity(SDLWindow, 1.0f);
9    SDL_SetCursor(SDL_GetDefaultCursor());
10
11    auto [GridX, GridY]{
12      ParentScene.GetLevel().SnapToGridPosition(
13        int(x), int(y)
14      )
15    };
16
17    SDL_SetWindowPosition(SDLWindow, GridX, GridY);
18  } else {
Else Block Unchanged|Show
30  }
31}

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.

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 (casting them to int), 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// ...
2
3void Level::HandleDrop(Actor* DragActor) {
4  DragActor->SetIsVisible(true);
5  if (!HasMouseFocus()) {
6    return;
7  }
8
9  float MouseX, MouseY;
10  SDL_GetMouseState(&MouseX, &MouseY);
11  auto [GridX, GridY]{
12    SnapToGridPosition(
13      int(MouseX), int(MouseY)
14    )
15  };
16
17  using enum ActorLocation;
18  if (DragActor->GetLocation() == Menu) {
19    ActorPtr NewActor{DragActor->Clone()};
20    NewActor->SetPosition(GridX, GridY);
21    SelectedActor = NewActor.get();
22    AddToLevel(std::move(NewActor));
23  } else {
24    DragActor->SetPosition(GridX, GridY);
25    SelectedActor = DragActor;
26  }
27}
28
29// ...

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

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 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// ...
2
3namespace Editor {
4// ...
5
6class Level {
7 public:
8  // ...
9  void DeleteAtPosition(
10    int x, int y, const Actor* Unless);
11  // ...
12};
13}

Now, let's implement DeleteAtPosition() in 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// ...
2
3void Level::DeleteAtPosition(
4  int x, int y, const Actor* Unless
5) {
6  for (size_t i{0}; i < Actors.size(); ++i) {
7    auto [ax, ay]{Actors[i]->GetPosition()};
8    if (ax == x && ay == y
9        && Actors[i].get() != Unless
10    ) {
11      Actors.erase(Actors.begin() + i);
12      break;
13    }
14  }
15}

Advanced: Using std::erase_if() and Lambdas

Solving this problem using the std::erase_if() and lambda approach we introduced in the previous lesson would look like this:

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

Note that the std::erase_if() function is only available in C++20 and later.

Replacing Actors

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

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 versions of the files we updated are provided below:

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 snap the tooltip to a grid when it is dragged within 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.

In the next lesson, we'll tackle saving the level layout to a file, allowing us to persist our designs.