Moving, Selecting, and Deleting Actors

We've got actors into our level, but now we need to manage them. This lesson builds on the drag-and-drop foundation to allow moving, selecting, and deleting actors within the level canvas.

First, we'll differentiate between dragging a new actor from the menu (which creates a copy) and dragging an existing actor in the level (which should move it). We'll introduce a way for actors to know their location (Menu or Level).

Next, we'll implement selection:

• Clicking an actor in the level selects it.
• A visual cue (like an outline) will show the selected actor.
• Clicking the background deselects.

Lastly, we'll hook up the delete key. When an actor is selected, pressing Delete will remove it from the level, requiring updates to event handling and the actor container.

By the end of this lesson, our program will let us drag and drop actors within the level to move them, click to select them, and press the delete key to remove them.

Moving Actors

Our drag-and-drop logic currently always creates a copy of the dragged actor when the mouse is released over the level. This makes sense when dragging from the ActorMenu, but if we drag an actor that's already in the Level, we want to move the original, not create another copy.

To differentiate these cases, we need a way for an Actor instance to know where it currently resides. We'll introduce an ActorLocation enum with values Level and Menu, and add a corresponding member variable to the Actor class, defaulting to Menu.

1// Editor/Actor.h
2// ...
3#pragma once
4#include <SDL.h>
5#include "Image.h"
6
7enum class ActorLocation { Level, Menu };
8
9namespace Editor {
10class Scene;
11class Actor {
12 public:
13  // ...
14
15  ActorLocation GetLocation() const {
16    return Location;
17  }
18
19  void SetLocation(ActorLocation NewLocation) {
20    Location = NewLocation;
21  }
22
23protected:
24  // ...
25  ActorLocation Location{ActorLocation::Menu};
26};
27}

When an actor is created via Clone() and is about to be added to the Level, its origin is effectively changing from the menu template to a placed instance. This is the point where we should update its location status.

Inside the Level::AddToLevel() function, just before pushing the NewActor onto the Actors vector, we'll call its SetLocation() method, passing ActorLocation::Level. This ensures all actors managed by the Level correctly identify themselves as being part of the level.

1// Editor/Source/Level.cpp
2// ...
3
4void Level::AddToLevel(ActorPtr NewActor) {
5  NewActor->SetLocation(ActorLocation::Level);
6  Actors.push_back(std::move(NewActor));
7}

The Level::HandleDrop() function is where the decision between cloning and moving happens. We can now use the actor's Location property to guide this decision.

Inside HandleDrop(), we'll add an if/else block based on DragActor->GetLocation(). The if (Location == Menu) branch contains the original code that clones the actor.

The else branch (implicitly Location == Level) simply updates the position of the DragActor itself using SetPosition().

1// Editor/Source/Level.cpp
2// ...
3
4void Level::HandleDrop(Actor* DragActor) {
5  if (!HasMouseFocus()) {
6    return;
7  }
8
9  int MouseX, MouseY;
10  SDL_GetMouseState(&MouseX, &MouseY);
11  auto [DragOffsetX, DragOffsetY]{
12    DragActor->GetDragOffset()
13  };
14
15  using enum ActorLocation;
16  if (DragActor->GetLocation() == Menu) {
17    ActorPtr NewActor{DragActor->Clone()};
18    NewActor->SetPosition(
19      MouseX - DragOffsetX,
20      MouseY - DragOffsetY
21    );
22    AddToLevel(std::move(NewActor));
23  } else {
24    DragActor->SetPosition(
25      MouseX - DragOffsetX,
26      MouseY - DragOffsetY
27    );
28  }
29}

Handling Overlapping Actors

We can now move actors, but a subtle bug emerges when actors overlap. If you click on a pixel where multiple actors are present, the current Level::HandleEvent() loop sends the SDL_MOUSEBUTTONDOWN event to all actors under the cursor.

Each actor that receives the click and is under the cursor will initiate a drag via Actor::HandleEvent(). This leads to multiple ACTOR_DRAG events being pushed, and unpredictable behavior when the mouse is released.

To fix this, we need the event handling process to stop once one actor has successfully "consumed" the click event. We can achieve this by modifying Actor::HandleEvent() to return a boolean value.

If an actor handles the event (i.e., it was clicked and initiated a drag), it should return true. Otherwise, it returns false. The loop in Level::HandleEvent() can then check this return value and break immediately after an actor returns true, preventing subsequent actors from processing the same click.

1// Editor/Actor.h
2// ...
3
4namespace Editor {
5class Scene;
6class Actor {
7 public:
8  // ...
9  virtual void HandleEvent(const SDL_Event& E);
10  virtual bool HandleEvent(const SDL_Event& E);
11  // ...
12}

We need to update the implementation of Actor::HandleEvent() in Actor.cpp to match the new bool return type declared in the header. The logic remains largely the same, but now we return values.

Inside the if block that detects a valid left-click on the actor, after pushing the ACTOR_DRAG event, we will return true. If the if condition is not met (meaning this actor didn't handle the click), the function reaches the end, where we return false.

1// Editor/Source/Actor.cpp
2// ...
3
4bool Actor::HandleEvent(const SDL_Event& E) {
5  if (
6    E.type == SDL_MOUSEBUTTONDOWN &&
7    E.button.button == SDL_BUTTON_LEFT &&
8    HasMouseFocus()
9  ) {
10    DragOffset.x = E.button.x - Rect.x;
11    DragOffset.y = E.button.y - Rect.y;
12
13    if (Location != ActorLocation::Menu) {
14      SetIsVisible(false);
15    }
16
17    SDL_Event DragEvent{UserEvents::ACTOR_DRAG};
18    DragEvent.user.data1 = this;
19    SDL_PushEvent(&DragEvent);
20    return true;
21  }
22  return false;
23}

Now that Actor::HandleEvent() returns whether it consumed the event, we’ll update the loop in Level::HandleEvent() in Level.cpp to use this information.

Inside the for loop that iterates through the Actors vector, we checks the return value immediately after calling the function. If true, the break statement exits the loop immediately.

1// Editor/Source/Level.cpp
2// ...
3
4void Level::HandleEvent(const SDL_Event& E) {
5  for (ActorPtr& A : Actors) {
6    A->HandleEvent(E);
7    if (A->HandleEvent(E)) {
8      break;
9    }
10  }
11}

Our program should now handle the overlapping actor scenario slightly more gracefully. However, it still has a small issue. In the scenario where the cursor was overlapping multiple actors, it is the first actor in the Actors array that returns true that gets moved.

Later actors don’t get notified of the click at all. This creates a slightly weird experience, because those later actors are rendered on top of earlier actors. So, with our current logic, we move the actor that is visually on the bottom of the set of actors the user clicked on. In the following example, that would be the block at index 2:

We want to maintain the behaviour that actors added later to our level appear on top of those added earlier, so let’s not change our Render() logic. Instead, we’ll fix this problem by changing the order in which actors get to handle events. That is, actors that occur later in our Actors array get the opportunity to handle events before those that occur earlier.

We can implement this by having our level’s HandleEvent() function iterate through our actors in reverse order.

In C++20 and later, the easiest way to iterate an array in reverse order is using std::views::reverse from the <ranges> header:

1// Editor/Source/Level.cpp
2// ...
3#include <ranges>
4// ...
5
6void Level::HandleEvent(const SDL_Event& E) {
7  using namespace std::views;
8  for (ActorPtr& A : reverse(Actors)) {
9    if (A->HandleEvent(E)) {
10      break;
11    }
12  }
13}

1for (int i = Actors.size() - 1; i >= 0; --i) {
2  if (Actors[i]->HandleEvent(E)) {
3    break;
4  }
5}

1for (
2  auto it{Actors.rbegin()};
3  it != Actors.rend();
4  ++it
5 ) {
6  // Note: 'it' is an iterator, so we
7  // need *it to get the unique_ptr
8  if ((*it)->HandleEvent(E)) {
9    break;
10  }
11}

Actor Visbility

The current dragging experience for actors within the level shows the actor fixed in place while a separate tooltip follows the cursor. This isn't as intuitive as making the original actor vanish during the drag.

We can improve this by controlling the actor's visibility. Let's introduce an isVisible boolean member to the Actor class, initialized to true. We'll provide getter and setter functions for this state.

The Actor::Render() function will then be modified to check isVisible at the beginning. If it's false, the function will simply return without drawing anything, effectively hiding the actor.

1// Editor/Actor.h
2// ...
3
4namespace Editor {
5class Scene;
6class Actor {
7 public:
8  // ...
9  void Render(SDL_Surface* Surface) {
10    if (GetIsVisible()) {
11      Art.Render(Surface, Rect);
12    }
13  }
14
15  bool GetIsVisible() const {
16    return isVisible;
17  }
18
19  void SetIsVisible(bool NewVisibility) {
20    isVisible = NewVisibility;
21  }
22
23protected:
24  // ...
25  bool isVisible{true};
26};
27}

Hiding the actor should occur when a drag starts, but only if the actor being dragged is part of the Level. When dragging from the ActorMenu, we’re cloning the actor, so showing both the original actor and something representing the clone in the tooltip is natural.

The drag initiation point is in Actor::HandleEvent(). Therefore, inside the if block processing the SDL_MOUSEBUTTONDOWN event, we add a nested if check. If the actor's location isn't the menu, we call SetIsVisible(false) to hide it just before the code that pushes the ACTOR_DRAG event.

1// Editor/Source/Actor.cpp
2// ...
3
4void Actor::HandleEvent(const SDL_Event& E) {
5  if (
6    E.type == SDL_MOUSEBUTTONDOWN &&
7    E.button.button == SDL_BUTTON_LEFT &&
8    HasMouseFocus()
9  ) {
10    DragOffset.x = E.button.x - Rect.x;
11    DragOffset.y = E.button.y - Rect.y;
12
13    if (Location != ActorLocation::Menu) {
14      SetIsVisible(false);
15    }
16
17    SDL_Event DragEvent{UserEvents::ACTOR_DRAG};
18    DragEvent.user.data1 = this;
19    SDL_PushEvent(&DragEvent);
20  }
21}

When the drag operation ends (i.e., the user releases the mouse button), the actor that was being dragged needs to become visible again in its new (or original, if dropped outside the level) position. This logic belongs where the drop is finalized.

In Level::HandleDrop(), regardless of whether the drop was valid (inside the level) or not, the first action should be to restore visibility. We add DragActor->SetIsVisible(true); at the very beginning of the function, ensuring the actor reappears immediately upon mouse release.

1// Editor/Source/Level.cpp
2// ...
3
4void Level::HandleDrop(Actor* DragActor) {
5  DragActor->SetIsVisible(true);
Previous Code (Unchanged)|Show
30}

Selecting Actors

To enable deletion, users first need a way to specify which actor they want to delete. This calls for a selection mechanism. We'll allow only one actor to be selected at a time.

The Level class is the natural place to manage this state. We'll add a member variable Actor* SelectedActor, initialized to nullptr, to store a raw pointer to the currently selected actor instance within the Actors vector.

1// Editor/Level.h
2// ...
3
4namespace Editor {
5// ...
6
7class Level {
8// ...
9
10 private:
11  // ...
12  Actor* SelectedActor{nullptr};
13};
14}

A simple way to handle selection is to make the actor the user just interacted with the selected one. Since dropping an actor (either cloned from the menu or moved within the level) signifies the end of an interaction with that actor, Level::HandleDrop() is a good place to set the selection.

Inside HandleDrop(), after either cloning and positioning NewActor or just positioning DragActor, we'll set SelectedActor to point to that actor.

For the cloning case, we’ll use SelectedActor = NewActor.get(), getting the raw pointer from the unique_ptr. For the moving case, we can just use SelectedActor = DragActor.

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 [DragOffsetX, DragOffsetY]{
13    DragActor->GetDragOffset()
14  };
15
16  using enum ActorLocation;
17  if (DragActor->GetLocation() == Menu) {
18    ActorPtr NewActor{DragActor->Clone()};
19    NewActor->SetPosition(
20      MouseX - DragOffsetX,
21      MouseY - DragOffsetY
22    );
23    SelectedActor = NewActor.get();
24    AddToLevel(std::move(NewActor));
25  } else {
26    DragActor->SetPosition(
27      MouseX - DragOffsetX,
28      MouseY - DragOffsetY
29    );
30    SelectedActor = DragActor;
31  }
32}

Rendering Selection Indicators

Users need visual feedback to know which actor is currently selected. We’ll see more examples of drawing indicators like these later in the lesson, but a common technique is to draw an outline or highlight around the selected object.

We can implement a simple outline by drawing a slightly larger rectangle filled with a distinct color (e.g., white) before drawing the selected actor itself. This creates a border effect.

The logic for this belongs in Level::Render(). Inside the loop that iterates through the Actors vector, before calling A->Render(Surface), we'll add a check.

If SelectedActor is not null, and the current actor A is the SelectedActor, and the SelectedActor is visible, we calculate the dimensions for the outline rectangle (e.g., one pixel larger on each side) and fill it using SDL_FillRect() with our chosen highlight color.

Then, the normal A->Render(Surface) call proceeds, drawing the actor on top of this rectangle.

1// Editor/Source/Level.cpp
2// ...
3
4void Level::Render(SDL_Surface* Surface) {
5  auto [r, g, b, a]{
6    Config::Editor::LEVEL_BACKGROUND
7  };
8
9  SDL_FillRect(Surface, &Rect, SDL_MapRGB(
10    Surface->format, r, g, b));
11
12  for (ActorPtr& A : Actors) {
13    if (SelectedActor &&
14      A.get() == SelectedActor &&
15      SelectedActor->GetIsVisible()
16    ) {
17      auto [x, y, w, h]{
18        SelectedActor->GetRect()
19      };
20      SDL_Rect Rect{x - 1, y - 1, w + 2, h + 2};
21      SDL_FillRect(Surface, &Rect, SDL_MapRGB(
22        Surface->format, 255, 255, 255)
23      );
24    }
25    A->Render(Surface);
26  }
27}

If we run our program, we should now see a white outline around the actor we currently have selected:

Clearing Selection

We need a way for the user to deselect the current actor. A common interaction pattern is to deselect by clicking anywhere that isn't another selectable object. Since our only selectable objects are actors within the level, clicking the level background or any other UI element should clear the selection.

We can implement this easily in Level::HandleEvent(). After the loop that dispatches events to actors, we add a check for SDL_MOUSEBUTTONDOWN with SDL_BUTTON_LEFT. If this event occurs, we unconditionally set SelectedActor = nullptr. If the click was on an actor, the selection will be immediately re-established later in frame update process by the HandleDrop() logic.

1// Editor/Source/Level.cpp
2// ...
3
4void Level::HandleEvent(const SDL_Event& E) {
5  using namespace std::views;
6  for (ActorPtr& A : reverse(Actors)) {
7    if (A->HandleEvent(E)) {
8      break;
9    }
10  }
11  
12  if (
13    E.type == SDL_MOUSEBUTTONDOWN &&
14    E.button.button == SDL_BUTTON_LEFT
15  ) {
16    SelectedActor = nullptr;
17  }
18}

Deleting Actors

With selection implemented, we can now add the deletion functionality. The standard way to trigger deletion is by pressing the 'Delete' key on the keyboard while an object is selected.

We'll modify Level::HandleEvent() again. We add an else if condition after the left-click check. This new condition checks for E.type == SDL_KEYDOWN, ensures E.key.keysym.sym == SDLK_DELETE, and verifies that SelectedActor is not nullptr.

If all are true, we know a deletion is requested for the selected actor.

1// Editor/Source/Level.cpp
2// ...
3
4void Level::HandleEvent(const SDL_Event& E) {
5  using namespace std::views;
6  for (ActorPtr& A : reverse(Actors)) {
7    if (A->HandleEvent(E)) {
8      break;
9    }
10  }
11
12  if (
13    E.type == SDL_MOUSEBUTTONDOWN &&
14    E.button.button == SDL_BUTTON_LEFT
15  ) {
16    SelectedActor = nullptr;
17  } else if (
18    E.type == SDL_KEYDOWN &&
19    E.key.keysym.sym == SDLK_DELETE &&
20    SelectedActor
21  ) {
22    
23    // TODO: delete the selected actor
24    // from the Actors array
25
26    SelectedActor = nullptr;
27  }
28}

To erase our selected actor, we can find its index in the Actors array, and then use the erase(begin() + index) approach to remove the element at that index:

1// Editor/Source/Level.cpp
2// ...
3
4void Level::HandleEvent(const SDL_Event& E) {
5  using namespace std::views;
6  for (ActorPtr& A : reverse(Actors)) {
7    if (A->HandleEvent(E)) {
8      break;
9    }
10  }
11
12  if (
13    E.type == SDL_MOUSEBUTTONDOWN &&
14    E.button.button == SDL_BUTTON_LEFT
15  ) {
16    SelectedActor = nullptr;
17  } else if (
18    E.type == SDL_KEYDOWN &&
19    E.key.keysym.sym == SDLK_DELETE &&
20    SelectedActor
21  ) {
22    
23    for (size_t i{0}; i < Actors.size(); ++i) {
24      if (Actors[i].get() == SelectedActor) {
25        Actors.erase(Actors.begin() + i);
26        break;
27      }
28    }
29
30    SelectedActor = nullptr;
31  }
32}

Note that, in general, we should be extremely cautious about modifying the structure of an array (such as removing items) whilst iterating over that same array. These structural modifications can easily break our iteration logic by, for example, changing the size() of the array.

In this case, deleting an array object whilst iterating the array is safe, because we immediately stop iterating (using break) as soon as we resize our array.

Advanced: std::erase_if() and Lambdas

A commonly-used and more elegant way of conditionally erasing items from arrays is the std::erase_if() function, added in C++20. To use it, we first need to define a function that returns a boolean indicating whether an item meets the criteria for deletion:

1bool isSelected(
2  Actor* SelectedActor,
3  const ActorPtr& ActorInArray
4) {
5  return SelectedActor == ActorInArray.get();
6}

We then provide the std::erase_if() function with a reference to our array, and the function that will determine if each element in the array should be deleted:

1std::erase_if(
2  Actors,
3  isSelected
4);

This code won’t compile yet, as std::erase_if() will only call our function with a single argument - the actor in the array that it is currently evaluating for deletion. Our isSelected function also needs the SelectedActor to compare it against.

We could solve this in two ways. First, we could change isSelected to be a member function of the Level class. In that case, it can just access the SelectedActor from the Level object - it doesn’t need the argument:

1class Level {
2  bool isSelected(
3    Actor* SelectedActor,
4    const ActorPtr& ActorInArray
5  ) {
6    return SelectedActor == ActorInArray.get();
7  }
8}

Alternatively, we can use a binding function, such as std::bind_front(), to provide the argument before handing it to std::erase_if():

1std::erase_if(
2  Actors,
3  std::bind_front(isSelected, SelectedActor)
4);

These are both techniques we covered earlier in the course:

Member Function Pointers and Binding

Explore advanced techniques for working with class member functions

In most cases, a more advanced technique would be used to solve this problem, called a lambda. Lambdas allow us to define small, concise blocks of logic.

They’re similar to a function definition but, unlike functions, lambdas can be defined within the bodies of other functions. They’re ideal for creating simple callable objects to control the behaviour of other algorithms, such as std::erase_if().

Solving our problem using a lambda would look like this:

1std::erase_if(
2  Actors,
3  [&](const ActorPtr& Actor){
4    return Actor.get() == SelectedActor;
5  }
6);

We cover functional programming techniques and lambdas in much more detail in our advanced course.

Lambdas

An introduction to lambda expressions - a concise way of defining simple, ad-hoc functions

Complete Code

Complete versions of the files we changed in this section are provided below. We updated the Actor class with new Location and isVisible members, and we updated it’s HandleEvent() function to return a bool:

1#pragma once
2#include <SDL.h>
3#include "Image.h"
4
5enum class ActorLocation { Level, Menu };
6
7namespace Editor {
8class Scene;
9class Actor {
10 public:
11  Actor(
12    Scene& ParentScene,
13    const SDL_Rect& Rect,
14    Image& Image
15  ) : ParentScene{ParentScene},
16      Rect{Rect},
17      Art{Image}
18  {}
19
20  bool HasMouseFocus() const;
21  virtual bool HandleEvent(const SDL_Event& E);
22
23  void Tick(float DeltaTime) {}
24
25  void Render(SDL_Surface* Surface) {
26    if (isVisible) {
27      Art.Render(Surface, Rect);
28    }
29  }
30
31  const SDL_Rect& GetRect() const {
32    return Rect;
33  }
34
35  const SDL_Point& GetDragOffset() const {
36    return DragOffset;
37  }
38
39  const Image& GetArt() const {
40    return Art;
41  }
42
43  SDL_Point GetPosition() const {
44    return {Rect.x, Rect.y};
45  }
46
47  void SetPosition(int x, int y) {
48    Rect.x = x;
49    Rect.y = y;
50  }
51
52  virtual std::unique_ptr<Actor> Clone() const {
53    return std::make_unique<Actor>(*this);
54  }
55
56  ActorLocation GetLocation() const {
57    return Location;
58  }
59
60  void SetLocation(ActorLocation NewLocation) {
61    Location = NewLocation;
62  }
63
64  bool GetIsVisible() const {
65    return isVisible;
66  }
67
68  void SetIsVisible(bool NewVisibility) {
69    isVisible = NewVisibility;
70  }
71
72protected:
73  Scene& ParentScene;
74  SDL_Rect Rect;
75  Image& Art;
76  SDL_Point DragOffset{0, 0};
77  ActorLocation Location{ActorLocation::Menu};
78  bool isVisible{true};
79};
80}

1// Editor/Source/Actor.cpp
2// ...
3#include "Editor/Actor.h"
4#include "Editor/Scene.h"
5
6using namespace Editor;
7
8bool Actor::HandleEvent(const SDL_Event& E) {
9  if (
10    E.type == SDL_MOUSEBUTTONDOWN &&
11    E.button.button == SDL_BUTTON_LEFT &&
12    HasMouseFocus()
13  ) {
14    DragOffset.x = E.button.x - Rect.x;
15    DragOffset.y = E.button.y - Rect.y;
16
17    if (Location != ActorLocation::Menu) {
18      SetIsVisible(false);
19    }
20
21    SDL_Event DragEvent{UserEvents::ACTOR_DRAG};
22    DragEvent.user.data1 = this;
23    SDL_PushEvent(&DragEvent);
24    return true;
25  }
26  return false;
27}
28
29bool Actor::HasMouseFocus() const {
30  if (!ParentScene.HasMouseFocus()) {
31    return false;
32  }
33
34  int x, y;
35  SDL_GetMouseState(&x, &y);
36
37  if (
38    x < Rect.x ||
39    x > Rect.x + Rect.w ||
40    y < Rect.y ||
41    y > Rect.y + Rect.h
42  ) { return false; }
43
44  return true;
45}

Over in the Level class, we added a new SelectedActor member, and made large updates to the HandleEvent(), HandleDrop(), and Render() functions.

We also updated AddToLevel() to ensure the Actor we add has its Location set to ActorLocation::Level:

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
24 private:
25  Scene& ParentScene;
26  ActorPtrs Actors;
27  Actor* SelectedActor{nullptr};
28  SDL_Rect Rect{
29    0, 0,
30    Config::Editor::LEVEL_WIDTH,
31    Config::Editor::LEVEL_HEIGHT
32  };
33};
34}

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

Summary

This lesson added core manipulation features for actors placed in the level. By introducing an ActorLocation enum, we enabled the editor to correctly interpret drag-and-drop: cloning from the menu, but moving within the level.

We tackled the issue of clicking stacked actors by making Actor::HandleEvent() return a status and processing actors in reverse rendering order, ensuring the visually top actor reacts.

We enhanced the dragging feel by hiding the source actor during the move. A selection system was built: clicking selects an actor (highlighted with an outline), and clicking away clears the selection.

Lastly, we implemented deletion logic: if an actor is selected, pressing the 'Delete' key removes it from the Level's Actors container, demonstrating keyboard event handling and vector modification.

Highlights:

• ActorLocation enum for state-based behavior.
• Conditional cloning vs. moving in HandleDrop().
• Boolean return from HandleEvent() for event consumption.
• Reverse iteration (std::views::reverse) for correct UI interaction order.
• isVisible flag for temporary hiding during drags.
• SelectedActor pointer for managing selection.
• Drawing selection outlines in Render().
• SDLK_DELETE key handling for actor removal.
• Using std::erase_if() to modify the actor collection.

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