In this project, we'll build a complete clone of the classic arcade game, Breakout. We'll implement all the core mechanics, including a paddle, a ball, breakable bricks, scoring, and multiple levels. To get started, we'll set up our project structure. We will be reusing a lot of code from our previous projects, including the component-based game engine and the level editor. This allows us to hit the ground running and focus on game-specific logic rather than rebuilding foundational systems. This first lesson will walk you through all the starting files, highlighting the minor changes we've made to our engine since we last worked on it. By the end, you'll have a running application that shows both our editor window and a new, empty window for our Breakout game. ## Starting Point Our starting point for this project is provided below, which primarily is split across three directories: - `Editor/` contains the files we built in the map editor project, which we can use to build levels for our game. - `Engine/` contains the code we wrote in the previous few chapters, covering the scene management as well as our entity and component system. We've made some minor changes to these files since the previous chapter, which we'll walk through later in this section. - `Breakout/` is where we'll add our new, game-specific functionality. All of these starting files are available as a zip file: - [breakout-start.zip](https://www.studyplan.dev/sdl2-assets/breakout-start.zip) This file includes some sample levels in the "/Assets" directory if you don't have any from our earlier level editor project. ```c++ #pragma once #include #include "Engine/Scene.h" class BreakoutScene : public Scene { public: BreakoutScene(Window& ParentWindow) : Scene{ParentWindow} {} }; ``` ```c++ #include "Editor/Actor.h" #include "Editor/Scene.h" using namespace Editor; bool Actor::HandleEvent(const SDL_Event& E) { if ( E.type == SDL_MOUSEBUTTONDOWN && E.button.button == SDL_BUTTON_LEFT && HasMouseFocus() ) { DragOffset.x = E.button.x - Rect.x; DragOffset.y = E.button.y - Rect.y; if (Location != ActorLocation::Menu) { SetIsVisible(false); } SDL_Event DragEvent{UserEvents::ACTOR_DRAG}; DragEvent.user.data1 = this; SDL_PushEvent(&DragEvent); return true; } return false; } bool Actor::HasMouseFocus() const { if (!ParentScene.HasMouseFocus()) { return false; } int x, y; SDL_GetMouseState(&x, &y); if ( x < Rect.x || x > Rect.x + Rect.w || y < Rect.y || y > Rect.y + Rect.h ) { return false; } return true; } ``` ```c++ #include #include "Editor/ActorTooltip.h" #include "Editor/Scene.h" #ifdef _WIN32 #include #include #endif using namespace Editor; ActorTooltip::ActorTooltip(Scene& ParentScene) : ParentScene{ParentScene} { SDLWindow = SDL_CreateWindow( "Tooltip", SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, 100, 100, SDL_WINDOW_HIDDEN | SDL_WINDOW_TOOLTIP | SDL_WINDOW_BORDERLESS | SDL_WINDOW_SKIP_TASKBAR | SDL_WINDOW_ALWAYS_ON_TOP ); CheckSDLError("Creating Tooltip Window"); #ifdef _WIN32 SDL_SysWMinfo wmInfo; SDL_GetVersion(&wmInfo.version); SDL_GetWindowWMInfo(SDLWindow, &wmInfo); HWND hwnd{wmInfo.info.win.window}; LONG style{GetWindowLong(hwnd, GWL_EXSTYLE)}; SetWindowLong(hwnd, GWL_EXSTYLE, style |= WS_EX_NOACTIVATE ); #endif DenyCursor = SDL_CreateSystemCursor( SDL_SYSTEM_CURSOR_NO ); CheckSDLError("Creating DenyCursor"); } ActorTooltip::~ActorTooltip() { if (!SDL_WasInit(SDL_INIT_VIDEO)) return; if (SDLWindow) { SDL_DestroyWindow(SDLWindow); } if (DenyCursor) { SDL_FreeCursor(DenyCursor); } } void ActorTooltip::Render() { if (!isVisible) return; DragActor->GetArt().Render( GetSurface(), SDL_Rect{ 0, 0, DragActor->GetRect().w, DragActor->GetRect().h }); SDL_UpdateWindowSurface(SDLWindow); } void ActorTooltip::Tick(float DeltaTime) { if (!isVisible) return; auto Buttons{ SDL_GetGlobalMouseState( nullptr, nullptr)}; if (!(Buttons & SDL_BUTTON_LEFT)) { SetIsVisible(false); ParentScene.GetLevel().HandleDrop(DragActor); } else { PositionWindow(); } } void ActorTooltip::PositionWindow() { int x, y; SDL_GetGlobalMouseState(&x, &y); if (ParentScene.GetLevel().HasMouseFocus()) { SDL_SetWindowOpacity(SDLWindow, 1); SDL_SetCursor(SDL_GetDefaultCursor()); auto [WinX, WinY]{ ParentScene.GetWindow().GetPosition() }; auto [GridX, GridY]{ ParentScene.GetLevel().SnapToGridPosition( x - WinX, y - WinY ) }; SDL_SetWindowPosition( SDLWindow, WinX + GridX, WinY + GridY ); } else { auto [DragOffsetX, DragOffsetY]{ DragActor->GetDragOffset() }; SDL_SetWindowPosition( SDLWindow, x - DragOffsetX, y - DragOffsetY ); SDL_SetWindowOpacity(SDLWindow, 0.5); SDL_SetCursor(DenyCursor); } } void ActorTooltip::HandleEvent( const SDL_Event& E) { using namespace UserEvents; if (E.type == ACTOR_DRAG) { DragActor = static_cast( E.user.data1 ); SDL_SetWindowSize( SDLWindow, DragActor->GetRect().w, DragActor->GetRect().h ); SetIsVisible(true); } } void ActorTooltip::SetIsVisible(bool Visible) { isVisible = Visible; if (isVisible) { SDL_ShowWindow(SDLWindow); } else { SDL_HideWindow(SDLWindow); SDL_SetCursor(SDL_GetDefaultCursor()); SDL_SetWindowOpacity(SDLWindow, 1); } } ``` ```c++ #include "Editor/Blocks.h" #include "Editor/Scene.h" using namespace Editor; BlueBlock::BlueBlock( Scene& ParentScene, SDL_Rect Rect) : Actor{ ParentScene, SDL_Rect{Rect.x, Rect.y, WIDTH, HEIGHT}, ParentScene.GetAssets().BlueBlock} {} GreenBlock::GreenBlock( Scene& ParentScene, SDL_Rect Rect) : Actor{ ParentScene, SDL_Rect{Rect.x, Rect.y, WIDTH, HEIGHT}, ParentScene.GetAssets().GreenBlock} {} CyanBlock::CyanBlock( Scene& ParentScene, SDL_Rect Rect) : Actor{ ParentScene, SDL_Rect{Rect.x, Rect.y, WIDTH, HEIGHT}, ParentScene.GetAssets().CyanBlock} {} OrangeBlock::OrangeBlock( Scene& ParentScene, SDL_Rect Rect) : Actor{ ParentScene, SDL_Rect{Rect.x, Rect.y, WIDTH, HEIGHT}, ParentScene.GetAssets().OrangeBlock} {} RedBlock::RedBlock( Scene& ParentScene, SDL_Rect Rect) : Actor{ ParentScene, SDL_Rect{Rect.x, Rect.y, WIDTH, HEIGHT}, ParentScene.GetAssets().RedBlock} {} YellowBlock::YellowBlock( Scene& ParentScene, SDL_Rect Rect) : Actor{ ParentScene, SDL_Rect{Rect.x, Rect.y, WIDTH, HEIGHT}, ParentScene.GetAssets().YellowBlock} {} ``` ```c++ #include "Editor/Button.h" #include "Editor/Scene.h" using namespace Editor; void Button::HandleEvent(const SDL_Event& E) { using enum ButtonState; if (E.type == SDL_MOUSEBUTTONDOWN && E.button.button == SDL_BUTTON_LEFT && State == Hover ) { HandleLeftClick(); } else if ( E.type == SDL_MOUSEMOTION && ParentScene.HasMouseFocus() ) { SDL_Point Pos{E.motion.x, E.motion.y}; bool Hovering(SDL_PointInRect(&Pos, &Rect)); if (State == Normal && Hovering) { State = Hover; } else if (State == Hover && !Hovering) { State = Normal; } } } void Button::Render(SDL_Surface* Surface) { using namespace Config; auto [r, g, b, a]{ BUTTON_COLORS[static_cast(State)]}; SDL_FillRect(Surface, &Rect, SDL_MapRGB( Surface->format, r, g, b )); ButtonText.Render(Surface, &Rect); } ``` ```c++ #include #include #include #include "Editor/Level.h" #include "Editor/Scene.h" using namespace Editor; void Level::HandleEvent(const SDL_Event& E) { using namespace std::views; using namespace UserEvents; for (ActorPtr& A : reverse(Actors)) { if (A->HandleEvent(E)) { break; } } if ( E.type == SDL_MOUSEBUTTONDOWN && E.button.button == SDL_BUTTON_LEFT ) { SelectedActor = nullptr; } else if ( E.type == SDL_KEYDOWN && E.key.keysym.sym == SDLK_DELETE && SelectedActor ) { std::erase_if(Actors, [&](ActorPtr& Actor){ return Actor.get() == SelectedActor; } ); SelectedActor = nullptr; } else if (E.type == LOAD_LEVEL) { LoadedLevel = E.user.code; Load(); } else if (E.type == SAVE_LEVEL) { Save(); } else if (E.type == SAVE_AND_PLAY_LEVEL) { SaveAndPlay(); } } void Level::Tick(float DeltaTime) { for (ActorPtr& A : Actors) { A->Tick(DeltaTime); } } void Level::Render(SDL_Surface* Surface) { auto [r, g, b, a]{ Config::Editor::LEVEL_BACKGROUND }; SDL_FillRect(Surface, &Rect, SDL_MapRGB( Surface->format, r, g, b)); for (ActorPtr& A : Actors) { if (SelectedActor && A.get() == SelectedActor && SelectedActor->GetIsVisible() ) { auto [x, y, w, h]{ SelectedActor->GetRect() }; SDL_Rect Rect{x - 1, y - 1, w + 2, h + 2}; SDL_FillRect(Surface, &Rect, SDL_MapRGB( Surface->format, 255, 255, 255) ); } A->Render(Surface); } } void Level::HandleDrop(Actor* DragActor) { DragActor->SetIsVisible(true); if (!HasMouseFocus()) { return; } int MouseX, MouseY; SDL_GetMouseState(&MouseX, &MouseY); auto [GridX, GridY]{ SnapToGridPosition( MouseX, MouseY ) }; DeleteAtPosition(GridX, GridY, DragActor); using enum ActorLocation; if (DragActor->GetLocation() == Menu) { ActorPtr NewActor{DragActor->Clone()}; NewActor->SetPosition(GridX, GridY); SelectedActor = NewActor.get(); AddToLevel(std::move(NewActor)); } else { DragActor->SetPosition(GridX, GridY); SelectedActor = DragActor; } SDL_Event E{UserEvents::LEVEL_EDIT}; SDL_PushEvent(&E); } void Level::AddToLevel(ActorPtr NewActor) { NewActor->SetLocation(ActorLocation::Level); Actors.push_back(std::move(NewActor)); } bool Level::HasMouseFocus() const { if (!ParentScene.HasMouseFocus()) { return false; } int x, y; SDL_GetGlobalMouseState(&x, &y); auto [WinX, WinY]{ ParentScene.GetWindow().GetPosition() }; if ( (x - WinX) >= Config::Editor::LEVEL_WIDTH || (y - WinY) >= Config::Editor::LEVEL_HEIGHT ) { return false; } return true; } SDL_Point Level::SnapToGridPosition( int x, int y ) { using namespace Config::Editor; int sx{HORIZONTAL_GRID_SNAP}; int sy{VERTICAL_GRID_SNAP}; return { (x / sx) * sx, (y / sy) * sy, }; } void Level::DeleteAtPosition( int x, int y, const Actor* Unless ) { for (size_t i{0}; i < Actors.size(); ++i) { auto [ax, ay]{Actors[i]->GetPosition()}; if (ax == x && ay == y && Actors[i].get() != Unless ) { Actors.erase(Actors.begin() + i); break; } } } namespace{ using namespace Config; using ActorLoaderFunc = std::function< std::unique_ptr(SDL_RWops*, Scene&)>; using enum ActorType; std::unordered_map< ActorType, ActorLoaderFunc > ActorLoaders{ {Actor, {}}, {BlueBlock, BlueBlock::Construct}, {GreenBlock, GreenBlock::Construct}, {CyanBlock, CyanBlock::Construct}, {OrangeBlock, OrangeBlock::Construct}, {RedBlock, RedBlock::Construct}, {YellowBlock, YellowBlock::Construct}}; } void Level::Load() { Actors.clear(); std::string FileName{std::format( "Assets/Level{}.bin", LoadedLevel )}; SDL_RWops* Handle{SDL_RWFromFile( FileName.c_str(), "rb")}; if (!Handle) { CheckSDLError("Loading Level"); return; } Uint8 FileVersion{SDL_ReadU8(Handle)}; if (FileVersion != VERSION) { // This file is from a different version of // our software - react as needed } Uint8 GridWidth{SDL_ReadU8(Handle)}; Uint8 GridHeight{SDL_ReadU8(Handle)}; Uint32 ActorCount{SDL_ReadLE32(Handle)}; std::cout << std::format( "Loading a version " "{} level ({}x{}) with {} actors\n", FileVersion, GridWidth, GridHeight, ActorCount ); for (size_t i{0}; i < ActorCount; ++i) { Uint8 Type{SDL_ReadU8(Handle)}; auto Loader {ActorLoaders[static_cast(Type)]}; if (Loader) { ActorPtr NewActor{Loader(Handle, ParentScene)}; NewActor->SetLocation(ActorLocation::Level); AddToLevel(std::move(NewActor)); } else { std::cout << "Error: No Loader for Actor " "Type " << Type << '\n'; } } SDL_RWclose(Handle); } void Level::Save() { std::string FileName{ std::format("Assets/Level{}.bin", LoadedLevel) }; SDL_RWops* Handle{SDL_RWFromFile( FileName.c_str(), "wb") }; if (!Handle) { CheckSDLError("Saving Level"); Handle = SDL_RWFromFile( FileName.c_str(), "w+b" ); } using namespace Config::Editor; SDL_WriteU8(Handle, VERSION); SDL_WriteU8(Handle, GRID_WIDTH); SDL_WriteU8(Handle, GRID_HEIGHT); SDL_WriteLE32(Handle, Actors.size()); for (const ActorPtr& A : Actors) { A->Serialize(Handle); } SDL_RWclose(Handle); } void Level::SaveAndPlay() { Save(); SDL_Event E{UserEvents::LAUNCH_LEVEL}; E.user.code = LoadedLevel; SDL_PushEvent(&E); } ``` ```c++ #pragma once #include #include "Image.h" enum class ActorLocation { Level, Menu }; namespace Editor { class Scene; class Actor { public: Actor( Scene& ParentScene, const SDL_Rect& Rect, Image& Image ) : ParentScene{ParentScene}, Rect{Rect}, Art{Image} {} bool HasMouseFocus() const; virtual bool HandleEvent(const SDL_Event& E); void Tick(float DeltaTime) {} void Render(SDL_Surface* Surface) { if (isVisible) { Art.Render(Surface, Rect); } } const SDL_Rect& GetRect() const { return Rect; } const SDL_Point& GetDragOffset() const { return DragOffset; } const Image& GetArt() const { return Art; } SDL_Point GetPosition() const { return {Rect.x, Rect.y}; } void SetPosition(int x, int y) { Rect.x = x; Rect.y = y; } virtual std::unique_ptr Clone() const { return std::make_unique(*this); } ActorLocation GetLocation() const { return Location; } void SetLocation(ActorLocation NewLocation) { Location = NewLocation; } bool GetIsVisible() const { return isVisible; } void SetIsVisible(bool NewVisibility) { isVisible = NewVisibility; } virtual Config::ActorType GetActorType() const { return Config::ActorType::Actor; } virtual void Serialize(SDL_RWops* Handle) const { using namespace Config::Editor; Uint8 ActorType{static_cast(GetActorType())}; SDL_WriteU8(Handle, ActorType); Uint8 GridRow = Rect.y / VERTICAL_GRID_SNAP; SDL_WriteU8(Handle, GridRow); Uint8 GridCol = Rect.x / HORIZONTAL_GRID_SNAP; SDL_WriteU8(Handle, GridCol); } static SDL_Rect GeneratePositionRectangle( SDL_RWops* Handle, int Width, int Height ) { using namespace Config::Editor; Uint8 GridRow{SDL_ReadU8(Handle)}; Uint8 GridCol{SDL_ReadU8(Handle)}; SDL_Rect R{0, 0, Width, Height}; R.x = GridCol * HORIZONTAL_GRID_SNAP; R.y = GridRow * VERTICAL_GRID_SNAP; return R; } protected: Scene& ParentScene; SDL_Rect Rect; Image& Art; SDL_Point DragOffset{0, 0}; ActorLocation Location{ActorLocation::Menu}; bool isVisible{true}; }; } ``` ```c++ #pragma once #include #include #include "Actor.h" #include "Blocks.h" #include "Config.h" namespace Editor { class Scene; using ActorPtr = std::unique_ptr; using ActorPtrs = std::vector; class ActorMenu { public: ActorMenu(Scene& ParentScene) : ParentScene{ParentScene} { using namespace Config::Editor; Actors.emplace_back( std::make_unique( GetScene(), SDL_Rect{ ACTOR_MENU_POSITION_X + PADDING, PADDING, 0, 0 } ) ); Actors.emplace_back( std::make_unique( GetScene(), SDL_Rect{ ACTOR_MENU_POSITION_X + PADDING, BlueBlock::HEIGHT + PADDING * 2, 0, 0 } ) ); Actors.emplace_back( std::make_unique( GetScene(), SDL_Rect{ ACTOR_MENU_POSITION_X + PADDING, BlueBlock::HEIGHT * 2 + PADDING * 3, 0, 0 } ) ); Actors.emplace_back( std::make_unique( GetScene(), SDL_Rect{ ACTOR_MENU_POSITION_X + PADDING, BlueBlock::HEIGHT * 3 + PADDING * 4, 0, 0 } ) ); Actors.emplace_back( std::make_unique( GetScene(), SDL_Rect{ ACTOR_MENU_POSITION_X + PADDING, BlueBlock::HEIGHT * 4 + PADDING * 5, 0, 0 } ) ); } void HandleEvent(const SDL_Event& E) { for (ActorPtr& A : Actors) { A->HandleEvent(E); } } void Tick(float DeltaTime) { for (ActorPtr& A : Actors) { A->Tick(DeltaTime); } } void Render(SDL_Surface* Surface) { using namespace Config::Editor; auto [r, g, b, a]{ACTOR_MENU_BACKGROUND}; SDL_FillRect( Surface, &Rect, SDL_MapRGB(Surface->format, r, g, b) ); for (ActorPtr& A : Actors) { A->Render(Surface); } } Scene& GetScene() const { return ParentScene; } private: Scene& ParentScene; ActorPtrs Actors; SDL_Rect Rect{ Config::Editor::ACTOR_MENU_POSITION_X, 0, Config::Editor::ACTOR_MENU_WIDTH, Config::Editor::WINDOW_HEIGHT }; }; } ``` ```c++ #pragma once #include #include "Actor.h" namespace Editor{ class Scene; class ActorTooltip { public: ActorTooltip(Scene& ParentScene); ~ActorTooltip(); ActorTooltip(const ActorTooltip&) = delete; ActorTooltip& operator=(const ActorTooltip&) = delete; void Render(); void Tick(float DeltaTime); void PositionWindow(); void HandleEvent(const SDL_Event& E); void SetIsVisible(bool NewVisibility); SDL_Surface* GetSurface() const { return SDL_GetWindowSurface(SDLWindow); } private: bool isVisible{false}; SDL_Window* SDLWindow{nullptr}; Actor* DragActor{nullptr}; Scene& ParentScene; SDL_Cursor* DenyCursor{nullptr}; }; } ``` ```c++ #pragma once #include "Image.h" namespace Editor { struct AssetManager { Image BlueBlock{"Assets/Brick_Blue_A.png"}; Image GreenBlock{"Assets/Brick_Green_A.png"}; Image CyanBlock{"Assets/Brick_Cyan_A.png"}; Image OrangeBlock{"Assets/Brick_Orange_A.png"}; Image RedBlock{"Assets/Brick_Red_A.png"}; Image YellowBlock{"Assets/Brick_Yellow_A.png"}; }; } ``` ```c++ #pragma once #include "Actor.h" #define DECLARE_BLOCK_TYPE(BlockName) \ public: \ static constexpr int WIDTH{50}; \ static constexpr int HEIGHT{25}; \ BlockName(Scene& ParentScene, SDL_Rect Rect); \ std::unique_ptr Clone() const override { \ return std::make_unique(*this); \ } \ Config::ActorType GetActorType() const override { \ return Config::ActorType::BlockName; \ } namespace Editor{ class BlueBlock : public Actor { public: static constexpr int WIDTH{50}; static constexpr int HEIGHT{25}; BlueBlock( Scene& ParentScene, SDL_Rect Rect ); std::unique_ptr Clone() const override { return std::make_unique(*this); } Config::ActorType GetActorType() const override { return Config::ActorType::BlueBlock; } static std::unique_ptr Construct( SDL_RWops* Handle, Scene& ParentScene ) { return std::make_unique( ParentScene, GeneratePositionRectangle( Handle, WIDTH, HEIGHT)); } }; class GreenBlock : public Actor { public: static constexpr int WIDTH{50}; static constexpr int HEIGHT{25}; GreenBlock(Scene& ParentScene, SDL_Rect Rect); Config::ActorType GetActorType() const override { return Config::ActorType::GreenBlock; } std::unique_ptr Clone() const override { return std::make_unique< GreenBlock>(*this); } Sint16 SomeNumber{32}; std::vector SomeArray{1, 2, 3}; void Serialize(SDL_RWops* Handle) const override { Actor::Serialize(Handle); SDL_WriteLE16(Handle, SomeNumber); SDL_WriteLE32(Handle, SomeArray.size()); for (Sint32 Num : SomeArray) { SDL_WriteLE32(Handle, Num); } } static std::unique_ptr Construct( SDL_RWops* Handle, Scene& ParentScene ) { auto NewActor{std::make_unique( ParentScene, GeneratePositionRectangle( Handle, WIDTH, HEIGHT))}; NewActor->SomeNumber = SDL_ReadLE16(Handle); Uint32 ArraySize{SDL_ReadLE32(Handle)}; NewActor->SomeArray.resize(ArraySize); for (int i{0}; i < ArraySize; ++i) { NewActor->SomeArray[i] = SDL_ReadLE32(Handle); } return NewActor; } }; class CyanBlock : public Actor { public: static constexpr int WIDTH{50}; static constexpr int HEIGHT{25}; CyanBlock(Scene& ParentScene, SDL_Rect Rect); Config::ActorType GetActorType() const override { return Config::ActorType::CyanBlock; } std::unique_ptr Clone() const override { return std::make_unique< CyanBlock>(*this); } void Serialize( SDL_RWops* Handle) const override { Actor::Serialize(Handle); } static std::unique_ptr Construct( SDL_RWops* Handle, Scene& ParentScene ) { using namespace Config::Editor; return std::make_unique( ParentScene, GeneratePositionRectangle( Handle, WIDTH, HEIGHT)); } }; class OrangeBlock : public Actor { public: static constexpr int WIDTH{50}; static constexpr int HEIGHT{25}; OrangeBlock(Scene& ParentScene, SDL_Rect Rect); Config::ActorType GetActorType() const override { return Config::ActorType::OrangeBlock; } std::unique_ptr Clone() const override { return std::make_unique< OrangeBlock>(*this); } void Serialize( SDL_RWops* Handle) const override { Actor::Serialize(Handle); } static std::unique_ptr Construct( SDL_RWops* Handle, Scene& ParentScene ) { using namespace Config::Editor; return std::make_unique( ParentScene, GeneratePositionRectangle( Handle, WIDTH, HEIGHT)); } }; class RedBlock : public Actor { public: static constexpr int WIDTH{50}; static constexpr int HEIGHT{25}; RedBlock(Scene& ParentScene, SDL_Rect Rect); Config::ActorType GetActorType() const override { return Config::ActorType::RedBlock; } std::unique_ptr Clone() const override { return std::make_unique< RedBlock>(*this); } void Serialize( SDL_RWops* Handle) const override { Actor::Serialize(Handle); } static std::unique_ptr Construct( SDL_RWops* Handle, Scene& ParentScene ) { using namespace Config::Editor; return std::make_unique( ParentScene, GeneratePositionRectangle( Handle, WIDTH, HEIGHT)); } }; class YellowBlock : public Actor { public: static constexpr int WIDTH{50}; static constexpr int HEIGHT{25}; YellowBlock(Scene& ParentScene, SDL_Rect Rect); Config::ActorType GetActorType() const override { return Config::ActorType::YellowBlock; } std::unique_ptr Clone() const override { return std::make_unique(*this); } void Serialize( SDL_RWops* Handle) const override { Actor::Serialize(Handle); } static std::unique_ptr Construct( SDL_RWops* Handle, Scene& ParentScene ) { using namespace Config::Editor; return std::make_unique( ParentScene, GeneratePositionRectangle( Handle, WIDTH, HEIGHT)); } }; } ``` ```c++ #pragma once #include #include #include "Text.h" enum class ButtonState { Normal = 0, Hover = 1, Active = 2, Disabled = 3 }; namespace Editor{ class Scene; class Button { public: Button( Scene& ParentScene, const std::string& Text, SDL_Rect Rect ) : ButtonText{Text, 20}, Rect{Rect}, ParentScene{ParentScene} {} virtual void HandleLeftClick() {} void HandleEvent(const SDL_Event& E); void Render(SDL_Surface* Surface); void Tick(float DeltaTime) {} ButtonState GetState() const { return State; } void SetState(ButtonState NewState) { State = NewState; } private: Scene& ParentScene; ButtonState State{ButtonState::Normal}; Text ButtonText; SDL_Rect Rect; }; } ``` ```c++ #pragma once; #include "Button.h" namespace Editor{ using namespace Config::Editor; class LoadLevelButton : public Button { public: constexpr static int WIDTH{40}; LoadLevelButton(Scene& ParentScene, int Level) : Level{Level}, Button { ParentScene, std::to_string(Level), { PADDING * Level + WIDTH * (Level-1), LEVEL_HEIGHT + PADDING, WIDTH, 30 } } { if (Level == 1) { SetState(ButtonState::Active); } } void HandleEvent(const SDL_Event& E) { Button::HandleEvent(E); if (E.type == UserEvents::LOAD_LEVEL) { if (E.user.code == Level) { SetState(ButtonState::Active); } else { SetState(ButtonState::Normal); } } } void HandleLeftClick() override { SDL_Event E{UserEvents::LOAD_LEVEL}; E.user.code = Level; SDL_PushEvent(&E); } private: int Level; }; class PlayLevelButton : public Button { public: constexpr static int WIDTH{70}; PlayLevelButton(Scene& ParentScene) : Button { ParentScene, "PLAY", { LEVEL_WIDTH - WIDTH - PADDING, LEVEL_HEIGHT + PADDING, WIDTH, 30 } } {} void HandleLeftClick() override { using namespace UserEvents; SDL_Event E{SAVE_AND_PLAY_LEVEL}; SDL_PushEvent(&E); } }; class SaveLevelButton : public Button { public: constexpr static int WIDTH{70}; SaveLevelButton(Scene& ParentScene) : Button { ParentScene, "SAVE", { LEVEL_WIDTH - WIDTH - PlayLevelButton::WIDTH - PADDING * 2, LEVEL_HEIGHT + PADDING, WIDTH, 30 } } { SetState(ButtonState::Disabled); } void HandleEvent(const SDL_Event& E) { Button::HandleEvent(E); using namespace UserEvents; if (E.type == LEVEL_EDIT) { SetState(ButtonState::Normal); } else if ( E.type == LOAD_LEVEL || E.type == SAVE_LEVEL || E.type == SAVE_AND_PLAY_LEVEL ) { SetState(ButtonState::Disabled); } } void HandleLeftClick() override { SDL_Event E{UserEvents::SAVE_LEVEL}; SDL_PushEvent(&E); } }; } ``` ```c++ #pragma once #include #include #include #include "Config.h" namespace Editor{ class Image { public: Image() = default; Image(const std::string& Path) : ImageSurface{IMG_Load(Path.c_str()) } { CheckSDLError("Loading Image"); } void Render( SDL_Surface* Surface, SDL_Rect Rect ) const { SDL_BlitScaled( ImageSurface, nullptr, Surface, &Rect); } Image(Image&& Other) noexcept : ImageSurface(Other.ImageSurface) { Other.ImageSurface = nullptr; } ~Image() { if (ImageSurface) { SDL_FreeSurface(ImageSurface); } } Image(const Image&) = delete; Image& operator=(const Image&) = delete; private: SDL_Surface* ImageSurface{nullptr}; }; } ``` ```c++ #pragma once #include #include #include #include "Actor.h" namespace Editor { class Scene; using ActorPtr = std::unique_ptr; using ActorPtrs = std::vector; class Level { public: Level(Scene& ParentScene) : ParentScene{ParentScene} { Load(); } void HandleEvent(const SDL_Event& E); void HandleDrop(Actor* DragActor); void Tick(float DeltaTime); void Render(SDL_Surface* Surface); bool HasMouseFocus() const; void AddToLevel(ActorPtr NewActor); SDL_Point SnapToGridPosition(int x, int y); void DeleteAtPosition( int x, int y, const Actor* Unless); void Load(); void Save(); void SaveAndPlay(); private: Scene& ParentScene; ActorPtrs Actors; Actor* SelectedActor{nullptr}; int LoadedLevel{1}; SDL_Rect Rect{ 0, 0, Config::Editor::LEVEL_WIDTH, Config::Editor::LEVEL_HEIGHT }; }; } ``` ```c++ #pragma once #include #include "ActorMenu.h" #include "ActorTooltip.h" #include "AssetManager.h" #include "Level.h" #include "Window.h" #include "EditorButtons.h" namespace Editor{ class Scene { public: Scene(Window& ParentWindow) : ParentWindow{ParentWindow} {} void HandleEvent(const SDL_Event& E) { ActorShelf.HandleEvent(E); TooltipWindow.HandleEvent(E); CurrentLevel.HandleEvent(E); LoadButton1.HandleEvent(E); LoadButton2.HandleEvent(E); LoadButton3.HandleEvent(E); SaveButton.HandleEvent(E); PlayButton.HandleEvent(E); } void Tick(float DeltaTime) { ActorShelf.Tick(DeltaTime); TooltipWindow.Tick(DeltaTime); CurrentLevel.Tick(DeltaTime); LoadButton1.Tick(DeltaTime); LoadButton2.Tick(DeltaTime); LoadButton3.Tick(DeltaTime); SaveButton.Tick(DeltaTime); PlayButton.Tick(DeltaTime); } void Render(SDL_Surface* Surface) { ActorShelf.Render(Surface); TooltipWindow.Render(); CurrentLevel.Render(Surface); LoadButton1.Render(Surface); LoadButton2.Render(Surface); LoadButton3.Render(Surface); SaveButton.Render(Surface); PlayButton.Render(Surface); } AssetManager& GetAssets() { return Assets; } bool HasMouseFocus() const { return ParentWindow.HasMouseFocus(); } Window& GetWindow() const { return ParentWindow; } Level& GetLevel() { return CurrentLevel; } private: ActorMenu ActorShelf{*this}; ActorTooltip TooltipWindow{*this}; Level CurrentLevel{*this}; Window& ParentWindow; AssetManager Assets; LoadLevelButton LoadButton1{*this, 1}; LoadLevelButton LoadButton2{*this, 2}; LoadLevelButton LoadButton3{*this, 3}; SaveLevelButton SaveButton{*this}; PlayLevelButton PlayButton{*this}; }; } ``` ```c++ #pragma once #include #include #include #include "Config.h" namespace Editor{ class Text { public: Text( const std::string& InitialText, int FontSize ) : Content(InitialText) { Font = TTF_OpenFont( Config::FONT.c_str(), FontSize); CheckSDLError("Opening Font"); SetText(InitialText); } ~Text() { if (!SDL_WasInit(SDL_INIT_VIDEO)) { return; } if (TextSurface) { SDL_FreeSurface(TextSurface); } if (Font) { TTF_CloseFont(Font); } } Text(const Text&) = delete; Text& operator=(const Text&) = delete; void SetText(const std::string& NewText) { Content = NewText; if (TextSurface) { SDL_FreeSurface(TextSurface); } TextSurface = TTF_RenderText_Blended(Font, Content.c_str(), Config::FONT_COLOR); CheckSDLError("Creating Text Surface"); } void Render( SDL_Surface* Surface, SDL_Rect* Rect ) { if (!TextSurface) return; int TextW{TextSurface->w}; int TextH{TextSurface->h}; // Center the text SDL_Rect Destination { Rect->x + (Rect->w - TextW) / 2, Rect->y + (Rect->h - TextH) / 2, TextW, TextH }; SDL_BlitSurface( TextSurface, nullptr, Surface, &Destination ); } private: std::string Content; TTF_Font* Font{nullptr}; SDL_Surface* TextSurface{nullptr}; }; } ``` ```c++ #pragma once #include #include "Config.h" namespace Editor{ class Window { public: Window() { SDLWindow = SDL_CreateWindow( Config::Editor::WINDOW_TITLE.c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, Config::Editor::WINDOW_WIDTH, Config::Editor::WINDOW_HEIGHT, 0 ); CheckSDLError("Creating Editor Window"); } ~Window() { if (SDLWindow && SDL_WasInit(SDL_INIT_VIDEO)) { SDL_DestroyWindow(SDLWindow); } } Window(const Window&) = delete; Window& operator=(const Window&) = delete; void Render() { auto [r, g, b, a]{ Config::Editor::WINDOW_BACKGROUND }; SDL_FillRect( GetSurface(), nullptr, SDL_MapRGB(GetSurface()->format, r, g, b)); } void Update() { SDL_UpdateWindowSurface(SDLWindow); } SDL_Surface* GetSurface() const { return SDL_GetWindowSurface(SDLWindow); } bool HasMouseFocus() const { int x, y, w, h, MouseX, MouseY; SDL_GetWindowPosition(SDLWindow, &x, &y); SDL_GetWindowSize(SDLWindow, &w, &h); SDL_GetGlobalMouseState(&MouseX, &MouseY); if ( MouseX < x || MouseX > x + w || MouseY < y || MouseY > y + h ) { return false; } return true; } SDL_Point GetPosition() const { int x, y; SDL_GetWindowPosition(SDLWindow, &x, &y); return {x, y}; } SDL_Point GetSize() const { int x, y; SDL_GetWindowSize(SDLWindow, &x, &y); return {x, y}; } private: SDL_Window* SDLWindow{nullptr}; }; } ``` ```c++ #include #include "Engine/ECS/CollisionComponent.h" #include "Engine/ECS/TransformComponent.h" #include "Engine/Utilities.h" #include "Engine/Scene.h" void CollisionComponent::Tick(float DeltaTime) { Vec2 OwnerPos{GetOwnerPosition()}; float OwnerScale{GetOwnerScale()}; WorldBounds.x = OwnerPos.x + Offset.x; WorldBounds.y = OwnerPos.y + Offset.y; WorldBounds.w = Width * OwnerScale; WorldBounds.h = Height * OwnerScale; } void CollisionComponent::Initialize() { if (!GetOwner()->GetComponent()) { std::cerr << "Error: CollisionComponent " "requires TransformComponent on its Owner.\n"; GetOwner()->RemoveComponent(this); } } void CollisionComponent::SetOffset( const Vec2& NewOffset ) { Offset = NewOffset; } void CollisionComponent::SetSize( float NewWidth, float NewHeight ) { if (NewWidth < 0 || NewHeight < 0) { std::cerr << "Warning: CollisionComponent " "width/height cannot be negative. " "Using absolute values.\n"; Width = std::abs(NewWidth); Height = std::abs(NewHeight); } else { Width = NewWidth; Height = NewHeight; } } const SDL_FRect& CollisionComponent::GetWorldBounds() const { return WorldBounds; } bool CollisionComponent::IsCollidingWith( const CollisionComponent& Other ) const { const SDL_FRect& A_world{GetWorldBounds()}; const SDL_FRect& B_world{ Other.GetWorldBounds()}; SDL_FRect A_sdl{A_world}; A_sdl.y -= A_world.h; SDL_FRect B_sdl{B_world}; B_sdl.y -= B_world.h; return SDL_HasIntersectionF(&A_sdl, &B_sdl); } void CollisionComponent::DrawDebugHelpers( SDL_Surface* Surface ) { SDL_FRect ScreenBoundsF{ GetScene().ToScreenSpace(WorldBounds)}; SDL_Rect ScreenBounds{ Utilities::Round(ScreenBoundsF)}; Utilities::DrawRectOutline( Surface, ScreenBounds, SDL_MapRGB(Surface->format, 255, 255, 0), 1 ); } bool CollisionComponent::GetCollisionRectangle( const CollisionComponent& Other, SDL_FRect* OutIntersection ) const { if (!OutIntersection) { std::cerr << "Error: OutIntersection pointer " "is null in GetCollisionRectangle.\n"; return false; } const SDL_FRect& A_world{GetWorldBounds()}; const SDL_FRect& B_world{ Other.GetWorldBounds()}; SDL_FRect A_sdl{A_world}; A_sdl.y -= A_world.h; SDL_FRect B_sdl{B_world}; B_sdl.y -= B_world.h; SDL_FRect Intersection_sdl; if (SDL_IntersectFRect( &A_sdl, &B_sdl, &Intersection_sdl)) { *OutIntersection = Intersection_sdl; OutIntersection->y += Intersection_sdl.h; return true; } return false; } ``` ```c++ #include "Engine/ECS/Commands.h" #include "Engine/ECS/Entity.h" #include "Engine/ECS/PhysicsComponent.h" void MovementCommand::Execute(Entity* Target) { if (!Target) return; PhysicsComponent* Physics{ Target->GetComponent() }; if (Physics) { Physics->SetVelocity({ Velocity.x, Physics->GetVelocity().y }); } else { std::cerr << "Error: MovementCommand " "requires a PhysicsComponent on entity\n"; } } void JumpCommand::Execute(Entity* Target) { if (!Target) return; PhysicsComponent* Physics{ Target->GetComponent() }; if (Physics) { Physics->ApplyImpulse(Impulse); } else { std::cerr << "Error: JumpCommand " "requires a PhysicsComponent on entity\n"; } } ``` ```c++ #include "Engine/ECS/Component.h" #include "Engine/ECS/Entity.h" #include "Engine/ECS/TransformComponent.h" #include "Engine/Scene.h" Scene& Component::GetScene() const { return GetOwner()->GetScene(); } AssetManager& Component::GetAssetManager() const { return GetScene().GetAssetManager(); } Vec2 Component::ToScreenSpace(const Vec2& Pos) const { return GetScene().ToScreenSpace(Pos); } Vec2 Component::GetOwnerPosition() const { TransformComponent* Transform{ GetOwner()->GetComponent() }; if (!Transform) { std::cerr << "Error: attempted to get position" " of an entity with no transform component\n"; return {0, 0}; } return Transform->GetPosition(); } void Component::SetOwnerPosition(const Vec2& Pos) const { TransformComponent* Transform{ GetOwner()->GetComponent() }; if (!Transform) { std::cerr << "Error: attempted to set position" " of an entity with no transform component\n"; } else { Transform->SetPosition(Pos); } } Vec2 Component::GetOwnerScreenSpacePosition() const { return ToScreenSpace(GetOwnerPosition()); } float Component::GetOwnerScale() const { TransformComponent* Transform{ GetOwner()->GetComponent() }; if (!Transform) { std::cerr << "Error: attempted to get scale" " of an entity with no transform component\n"; return 1.0; } return Transform->GetScale(); } ``` ```c++ #include #include "Engine/ECS/ImageComponent.h" #include "Engine/ECS/Entity.h" #include "Engine/ECS/TransformComponent.h" #include "Engine/AssetManager.h" #include "Engine/Utilities.h" namespace{ struct BlitInfo { SDL_Rect SourceRect; SDL_Rect DestRect; }; BlitInfo CalculateBlitInfo( ScalingMode Mode, int SurfaceW, int SurfaceH, float TargetX, float TargetY, float TargetW, float TargetH ) { BlitInfo Info; Info.SourceRect = { 0, 0, SurfaceW, SurfaceH }; if (Mode == ScalingMode::None) { Info.DestRect = Utilities::Round({ TargetX, TargetY, static_cast(SurfaceW), static_cast(SurfaceH) }); return Info; } if (Mode == ScalingMode::Fill) { Info.DestRect = Utilities::Round({ TargetX, TargetY, TargetW, TargetH }); return Info; } if (Mode == ScalingMode::Contain) { float Scale{ std::min(TargetW / SurfaceW, TargetH / SurfaceH)}; Info.DestRect = Utilities::Round({ TargetX, TargetY, SurfaceW * Scale, SurfaceH * Scale }); return Info; } if (Mode == ScalingMode::Cover) { float Scale{ std::max(TargetW / SurfaceW, TargetH / SurfaceH)}; if (Scale * SurfaceW > TargetW) { float ClipW{TargetW / Scale}; Info.SourceRect = Utilities::Round({ 0, 0, ClipW, static_cast(SurfaceH)}); } else if (Scale * SurfaceH > TargetH) { float ClipH{TargetH / Scale}; Info.SourceRect = Utilities::Round({ 0, 0, static_cast(SurfaceW), ClipH}); } Info.DestRect = Utilities::Round({ TargetX, TargetY, TargetW, TargetH}); return Info; } std::cerr << "Error: Unknown Scaling Mode\n"; return Info; } } ImageComponent::ImageComponent( Entity* Owner, const std::string& FilePath ) : Component(Owner), ImageFilePath(FilePath ) { ImageSurface = GetAssetManager() .LoadSurface(ImageFilePath); } void ImageComponent::Render( SDL_Surface* Surface ) { if (!ImageSurface) return; auto [TargetX, TargetY]{ GetOwnerScreenSpacePosition() + Offset }; float TargetW{GetWidth() * GetOwnerScale()}; float TargetH{GetHeight() * GetOwnerScale()}; int SurfaceW{GetSurfaceWidth()}; int SurfaceH{GetSurfaceHeight()}; BlitInfo Info{ CalculateBlitInfo( ScaleMode, SurfaceW, SurfaceH, TargetX, TargetY, TargetW, TargetH )}; if (SDL_BlitScaled( ImageSurface.get(), &Info.SourceRect, Surface, &Info.DestRect ) < 0) { std::cerr << "Error: Blit failed: " << SDL_GetError() << '\n'; } } void ImageComponent::DrawDebugHelpers( SDL_Surface* Surface ) { using Utilities::DrawRectOutline; if (!ImageSurface) return; // Calculate position and dimensions, similar to Render() auto [TargetX, TargetY]{ GetOwnerScreenSpacePosition() + Offset }; float OwnerScale{GetOwnerScale()}; float TargetW{GetWidth() * OwnerScale}; float TargetH{GetHeight() * OwnerScale}; int SurfaceW{GetSurfaceWidth()}; int SurfaceH{GetSurfaceHeight()}; // Natural Bounds (Green Outline) SDL_Rect NaturalBounds{ Utilities::Round({ TargetX, TargetY, SurfaceW * OwnerScale, SurfaceH * OwnerScale })}; DrawRectOutline( Surface, NaturalBounds, SDL_MapRGB(Surface->format, 0, 255, 0) ); // Rendered Bounds (Red Outline) BlitInfo Info{CalculateBlitInfo( ScaleMode, SurfaceW, SurfaceH, TargetX, TargetY, TargetW, TargetH )}; DrawRectOutline( Surface, Info.DestRect, SDL_MapRGB(Surface->format, 255, 0, 0) ); // Position marker (Blue Square) SDL_Rect DebugRect{ Utilities::Round({ TargetX - 5, TargetY - 5, 10, 10}) }; SDL_FillRect( Surface, &DebugRect, SDL_MapRGB(Surface->format, 0, 0, 255) ); } bool ImageComponent::LoadNewImage( const std::string& NewPath ) { ImageFilePath = NewPath; ImageSurface = GetAssetManager() .LoadSurface(NewPath); return ImageSurface != nullptr; } int ImageComponent::GetSurfaceWidth() const { if (!ImageSurface) { std::cerr << "Warning: Attempted to get " "width from null ImageSurface.\n"; return 0; } return ImageSurface->w; } int ImageComponent::GetSurfaceHeight() const { if (!ImageSurface) { std::cerr << "Warning: Attempted to get " "height from null ImageSurface.\n"; return 0; } return ImageSurface->h; } void ImageComponent::Initialize() { Entity* Owner{GetOwner()}; if (!Owner->GetComponent()) { std::cout << "Error: ImageComponent requires" " TransformComponent on its Owner\n"; Owner->RemoveComponent(this); } } void ImageComponent::SetWidth(float NewWidth) { Width = NewWidth; } void ImageComponent::SetHeight( float NewHeight) { Height = NewHeight; } void ImageComponent::ResetWidth() { Width = std::nullopt; } void ImageComponent::ResetHeight() { Height = std::nullopt; } float ImageComponent::GetWidth() const { // If Width has a value, return it. // Otherwise, return surface width. return Width.value_or(GetSurfaceWidth()); } float ImageComponent::GetHeight() const { // If Height has a value, return it. // Otherwise, return surface height. return Height.value_or(GetSurfaceHeight()); } void ImageComponent::SetScalingMode( ScalingMode Mode) { ScaleMode = Mode; } ``` ```c++ #include #include "Engine/ECS/InputComponent.h" #include "Engine/ECS/Commands.h" #include "Engine/ECS/Entity.h" #include "Engine/Vec2.h" namespace{ const float SPEED{5.0}; CommandPtr CreateMoveLeftCommand() { return std::make_unique( Vec2{-SPEED, 0.0}); } CommandPtr CreateMoveRightCommand() { return std::make_unique( Vec2{SPEED, 0.0}); } CommandPtr CreateJumpCommand() { const float JUMP_IMPULSE_MAGNITUDE{350.0}; return std::make_unique( Vec2{0.0, JUMP_IMPULSE_MAGNITUDE}); } } void InputComponent::Initialize() { BindKeyHeld(SDLK_LEFT, CreateMoveLeftCommand); BindKeyHeld(SDLK_RIGHT, CreateMoveRightCommand); BindKeyDown(SDLK_SPACE, CreateJumpCommand); } void InputComponent::Tick(float DeltaTime) { Entity* Owner{GetOwner()}; if (!Owner) return; const Uint8* CurrentKeyStates{ SDL_GetKeyboardState(nullptr)}; for (const auto& [Key, Factory] : KeyHeldBindings) { SDL_Scancode Scancode{ SDL_GetScancodeFromKey(Key)}; if (CurrentKeyStates[Scancode]) { Owner->HandleCommand(Factory()); } } } void InputComponent::HandleEvent( const SDL_Event& E) { if (E.type == SDL_KEYDOWN) { Entity* Owner{GetOwner()}; if (!Owner) return; SDL_Keycode Key{E.key.keysym.sym}; if (KeyDownBindings.contains(Key)) { Owner->HandleCommand( KeyDownBindings[Key]()); } } } ``` ```c++ #include #include "Engine/ECS/Entity.h" #include "Engine/ECS/PhysicsComponent.h" #include "Engine/ECS/TransformComponent.h" #include "Engine/Scene.h" void PhysicsComponent::Initialize() { if (!GetOwner()->GetComponent()) { std::cerr << "Error: PhysicsComponent " "requires TransformComponent on its Owner\n"; GetOwner()->RemoveComponent(this); } } void PhysicsComponent::SetMass(float NewMass) { if (NewMass <= 0.0) { std::cerr << "Error: Mass must be positive. " "Setting to 1.0kg instead\n"; Mass = 1.0; } else { Mass = NewMass; } } void PhysicsComponent::ApplyForce( const Vec2& Force ) { if (Mass > 0.0f) { Acceleration += Force / Mass; } } void PhysicsComponent::ApplyImpulse( const Vec2& Impulse ) { if (Mass > 0.0f) { Velocity += Impulse / Mass; } } void PhysicsComponent::Tick(float DeltaTime) { const Vec2 GRAVITY{0.0f, -9.8f}; ApplyForce(GRAVITY * Mass); Velocity += Acceleration * DeltaTime; SetOwnerPosition( GetOwnerPosition() + Velocity * DeltaTime ); Acceleration = {0.0, 0.0}; } void PhysicsComponent::DrawDebugHelpers( SDL_Surface* Surface ) { #ifdef DRAW_DEBUG_HELPERS auto [x, y]{GetOwnerScreenSpacePosition()}; SDL_Rect PositionIndicator{ int(x) - 2, int(y) - 2, 4, 4}; SDL_FillRect( GetScene().Trajectories, &PositionIndicator, SDL_MapRGB( GetScene().Trajectories->format, 0, 0, 255 ) ); #endif } ``` ```c++ #pragma once #include #include "Engine/ECS/Component.h" #include "Engine/Vec2.h" class CollisionComponent : public Component { public: using Component::Component; void SetOffset(const Vec2& NewOffset); void SetSize(float NewWidth, float NewHeight); const SDL_FRect& GetWorldBounds() const; bool IsCollidingWith( const CollisionComponent& Other ) const; bool GetCollisionRectangle( const CollisionComponent& Other, SDL_FRect* OutIntersection ) const; void Tick(float DeltaTime) override; void Initialize() override; void DrawDebugHelpers(SDL_Surface*) override; private: Vec2 Offset{0.0, 0.0}; float Width{1.0}; float Height{1.0}; SDL_FRect WorldBounds{0.0, 0.0, 0.0, 0.0}; }; ``` ```c++ #pragma once #include "Engine/Vec2.h" class Entity; class Command { public: virtual void Execute(Entity* Target) {} virtual ~Command() = default; }; class MovementCommand : public Command { public: MovementCommand(Vec2 Velocity) : Velocity{Velocity} {} void Execute(Entity* Target) override; Vec2 Velocity; }; class JumpCommand : public Command { public: JumpCommand(Vec2 Impulse) : Impulse(Impulse) {} void Execute(Entity* Target) override; Vec2 Impulse; }; ``` ```c++ #pragma once #include class Entity; class Scene; class AssetManager; struct Vec2; class Component { public: Component(Entity* Owner) : Owner(Owner) {} virtual void Initialize() {} virtual void HandleEvent(const SDL_Event& E) {} virtual void Tick(float DeltaTime) {} virtual void Render(SDL_Surface* Surface) {} virtual void DrawDebugHelpers( SDL_Surface* Surface) {} virtual ~Component() = default; Entity* GetOwner() const { return Owner; } Scene& GetScene() const; AssetManager& GetAssetManager() const; Vec2 ToScreenSpace(const Vec2& Pos) const; Vec2 GetOwnerPosition() const; void SetOwnerPosition(const Vec2& Pos) const; Vec2 GetOwnerScreenSpacePosition() const; float GetOwnerScale() const; private: Entity* Owner{nullptr}; }; ``` ```c++ #pragma once #include #include #include #include "Engine/ECS/Component.h" #include "Engine/ECS/Commands.h" class Scene; using ComponentPtr = std::unique_ptr; using ComponentPtrs = std::vector; class Entity { public: Entity(Scene& Scene) : OwningScene{Scene} {} Scene& GetScene() const { return OwningScene; } virtual void HandleEvent(const SDL_Event& E) { for (ComponentPtr& C : Components) { C->HandleEvent(E); } } virtual void Tick(float DeltaTime) { for (ComponentPtr& C : Components) { C->Tick(DeltaTime); } } virtual void Render(SDL_Surface* Surface) { for (ComponentPtr& C : Components) { C->Render(Surface); } #ifdef DRAW_DEBUG_HELPERS for (ComponentPtr& C : Components) { C->DrawDebugHelpers(Surface); } #endif } virtual void HandleCollision(Entity& Other) {} virtual ~Entity() = default; virtual void HandleCommand( std::unique_ptr Cmd ) { Cmd->Execute(this); } template requires std::derived_from CType* AddComponent(CArgs&&... ConstructorArgs) { ComponentPtr& NewComponent{ Components.emplace_back( std::make_unique( this, std::forward(ConstructorArgs)... ) ) }; NewComponent->Initialize(); return static_cast(NewComponent.get()); } template requires std::derived_from CType* GetComponent() { for (const ComponentPtr& C : Components) { if (auto Ptr{dynamic_cast( C.get() )}) { return Ptr; } } return nullptr; } void RemoveComponent(Component* PtrToRemove) { for (size_t i{0}; i < Components.size(); ++i) { if (Components[i].get() == PtrToRemove) { Components.erase(Components.begin() + i); return; } } std::cout << "Warning: Attempted to remove " "a component not found on this entity.\n"; } protected: ComponentPtrs Components; Scene& OwningScene; }; ``` ```c++ #pragma once #include #include #include #include #include "Engine/ECS/Component.h" #include "Engine/Vec2.h" enum class ScalingMode { None, Fill, Contain, Cover }; class ImageComponent : public Component { public: using Component::Component; ImageComponent( Entity* Owner, const std::string& FilePath ); void Initialize() override; void Render(SDL_Surface* Surface) override; void DrawDebugHelpers(SDL_Surface*) override; bool LoadNewImage(const std::string& NewPath); int GetSurfaceWidth() const; int GetSurfaceHeight() const; void SetWidth(float NewWidth); void SetHeight(float NewHeight); void ResetWidth(); void ResetHeight(); float GetWidth() const; float GetHeight() const; void SetScalingMode(ScalingMode Mode); void SetOffset(const Vec2& NewOffset) { Offset = NewOffset; } private: std::shared_ptr ImageSurface{nullptr}; std::string ImageFilePath; Vec2 Offset{0, 0}; std::optional Width{std::nullopt}; std::optional Height{std::nullopt}; ScalingMode ScaleMode{ScalingMode::Fill}; }; ``` ```c++ #pragma once #include #include #include #include #include "Engine/ECS/Component.h" class Command; using CommandPtr = std::unique_ptr; using CommandFactory = std::function< CommandPtr()>; using KeyToFactoryMap = std::unordered_map< SDL_Keycode, CommandFactory>; class InputComponent : public Component { public: using Component::Component; void Initialize() override; void Tick(float DeltaTime) override; void HandleEvent(const SDL_Event& E) override; void BindKeyDown( SDL_Keycode Key, CommandFactory Factory ) { KeyDownBindings[Key] = Factory; } void BindKeyHeld( SDL_Keycode Key, CommandFactory Factory ) { KeyHeldBindings[Key] = Factory; } private: // Map for discrete key presses (events) KeyToFactoryMap KeyDownBindings; // Map for continuous key holds (polling) KeyToFactoryMap KeyHeldBindings; }; ``` ```c++ #pragma once #include "Engine/ECS/Component.h" #include "Engine/Vec2.h" class PhysicsComponent : public Component { public: using Component::Component; void Initialize() override; void Tick(float DeltaTime) override; void DrawDebugHelpers(SDL_Surface* Surface) override; void ApplyForce(const Vec2& Force); void ApplyImpulse(const Vec2& Impulse); Vec2 GetVelocity() const { return Velocity; } void SetVelocity(const Vec2& NewVelocity) { Velocity = NewVelocity; } float GetMass() const { return Mass; } void SetMass(float NewMass); private: Vec2 Velocity{0.0, 0.0}; // m/s Vec2 Acceleration{0.0, 0.0}; // m/s^2 float Mass{1.0}; // kg }; ``` ```c++ #pragma once #include #include "Engine/Utilities.h" #include "Engine/Vec2.h" #include "Engine/ECS/Component.h" class TransformComponent : public Component { public: using Component::Component; Vec2 GetPosition() const { return Position; } void SetPosition(const Vec2& NewPosition) { Position = NewPosition; } float GetScale() const { return Scale; } void SetScale(float NewScale) { Scale = NewScale; } void DrawDebugHelpers(SDL_Surface* S) override { auto [x, y]{ToScreenSpace(Position)}; SDL_Rect Square{Utilities::Round({ x - 10, y - 10, 20, 20 })}; SDL_FillRect(S, &Square, SDL_MapRGB( S->format, 255, 0, 0)); } private: Vec2 Position{0, 0}; float Scale{1.0f}; }; ``` ```c++ #include #include "Engine/Scene.h" #include "Engine/ECS/CollisionComponent.h" void Scene::CheckCollisions() { for (size_t i{0}; i < Entities.size(); ++i) { CollisionComponent* ColA{ Entities[i] ->GetComponent()}; if (!ColA) { continue; } for (size_t j{i + 1}; j < Entities.size(); ++j) { CollisionComponent* ColB{ Entities[j] ->GetComponent()}; if (!ColB) { continue; } if (ColA->IsCollidingWith(*ColB)) { Entities[i]->HandleCollision( *Entities[j]); Entities[j]->HandleCollision( *Entities[i]); } } } } ``` ```c++ #pragma once #include #include #include #include #include #include struct SDLSurfaceDeleter { void operator()(SDL_Surface* Surface) const { SDL_FreeSurface(Surface); } }; using SurfacePtr = std::shared_ptr; using CacheMap = std::unordered_map; class AssetManager { public: // Load a surface, reusing if already loaded SurfacePtr LoadSurface(const std::string& Path) { if (SurfaceCache.contains(Path)) { std::cout << "CACHE HIT: " << Path << '\n'; return SurfaceCache[Path]; } std::cout << "CACHE MISS: " << Path << '\n'; SDL_Surface* Surface{IMG_Load(Path.c_str())}; if (!Surface) { std::cerr << "AssetManager failed to load: " << Path << " Error: " << IMG_GetError() << '\n'; return nullptr; } SurfacePtr SharedSurface( Surface, SDLSurfaceDeleter{} ); SurfaceCache[Path] = SharedSurface; return SharedSurface; } // Prevent copying/moving AssetManager() = default; AssetManager(const AssetManager&) = delete; AssetManager& operator=(const AssetManager&) = delete; AssetManager(AssetManager&&) = delete; AssetManager& operator=(AssetManager&&) = delete; private: CacheMap SurfaceCache; }; ``` ```c++ #pragma once #include #include "Engine/ECS/Entity.h" #include "Engine/AssetManager.h" #include "Engine/Window.h" #include "Engine/Vec2.h" using EntityPtr = std::unique_ptr; using EntityPtrs = std::vector; class Scene { public: Scene(Window& ParentWindow) : ParentWindow{ParentWindow} {} void HandleEvent(const SDL_Event& E) { for (auto& Entity : Entities) { Entity->HandleEvent(E); } } void Tick(float DeltaTime) { for (auto& Entity : Entities) { Entity->Tick(DeltaTime); } CheckCollisions(); } void Render(SDL_Surface* Surface) { SDL_GetClipRect(Surface, &Viewport); for (auto& Entity : Entities) { Entity->Render(Surface); } #ifdef DRAW_DEBUG_HELPERS SDL_BlitSurface( Trajectories, nullptr, Surface, nullptr ); #endif } Vec2 ToScreenSpace(const Vec2& Pos) const { auto [vx, vy, vw, vh]{Viewport}; float HorizontalScaling{ vw / WorldSpaceWidth}; float VerticalScaling{ vh / WorldSpaceHeight}; return { vx + Pos.x * HorizontalScaling, vy + (WorldSpaceHeight - Pos.y) * VerticalScaling }; } SDL_FRect ToScreenSpace( const SDL_FRect& Rect ) const { Vec2 ScreenPos{ ToScreenSpace( Vec2{Rect.x, Rect.y})}; float HorizontalScaling{ Viewport.w / WorldSpaceWidth}; float VerticalScaling{ Viewport.h / WorldSpaceHeight}; return { ScreenPos.x, ScreenPos.y, Rect.w * HorizontalScaling, Rect.h * VerticalScaling }; } AssetManager& GetAssetManager() { return Assets; } Window& GetWindow() const { return ParentWindow; } float GetWidth() { return WorldSpaceWidth; } float GetHeight() { return WorldSpaceHeight; } #ifdef DRAW_DEBUG_HELPERS SDL_Surface* Trajectories{ SDL_CreateRGBSurfaceWithFormat( 0, Config::Engine::WINDOW_WIDTH, Config::Engine::WINDOW_HEIGHT, 32, SDL_PIXELFORMAT_RGBA32 ) }; #endif protected: EntityPtrs Entities; private: void CheckCollisions(); SDL_Rect Viewport; float WorldSpaceWidth{13}; float WorldSpaceHeight{12}; AssetManager Assets; Window& ParentWindow; }; ``` ```c++ #pragma once #include namespace Utilities{ inline SDL_Rect Round(const SDL_FRect& R) { return { static_cast(SDL_round(R.x)), static_cast(SDL_round(R.y)), static_cast(SDL_round(R.w)), static_cast(SDL_round(R.h)), }; } inline void DrawRectOutline( SDL_Surface* Surface, const SDL_Rect& Rect, Uint32 Color, int Thickness = 3 ) { SDL_Rect Top{ Rect.x, Rect.y, Rect.w, Thickness}; SDL_FillRect(Surface, &Top, Color); SDL_Rect Bottom{ Rect.x, Rect.y + Rect.h - Thickness, Rect.w, Thickness}; SDL_FillRect(Surface, &Bottom, Color); int SideHeight{Rect.h - 2 * Thickness}; SDL_Rect Left{ Rect.x, Rect.y + Thickness, Thickness, SideHeight}; SDL_FillRect(Surface, &Left, Color); SDL_Rect Right{ Rect.x + Rect.w - Thickness, Rect.y + Thickness, Thickness, SideHeight}; SDL_FillRect(Surface, &Right, Color); } } ``` ```c++ #pragma once #include struct Vec2 { float x; float y; float GetLength() const { return std::sqrt(x * x + y * y); } float GetDistance(const Vec2& Other) const { return (*this - Other).GetLength(); } Vec2 Normalize() const { return *this / GetLength(); } Vec2 operator*(float Multiplier) const { return Vec2{x * Multiplier, y * Multiplier}; } Vec2 operator/(float Divisor) const { if (Divisor == 0.0f) { return Vec2{0, 0}; } return Vec2{x / Divisor, y / Divisor}; } Vec2& operator*=(float Multiplier) { x *= Multiplier; y *= Multiplier; return *this; } Vec2 operator/=(float Divisor) { if (Divisor == 0.0f) { return *this; } x /= Divisor; y /= Divisor; return *this; } Vec2 operator+(const Vec2& Other) const { return Vec2{x + Other.x, y + Other.y}; } Vec2 operator-(const Vec2& Other) const { return *this + (-Other); } Vec2& operator+=(const Vec2& Other) { x += Other.x; y += Other.y; return *this; } Vec2& operator-=(const Vec2& Other) { return *this += (-Other); } Vec2 operator-() const { return Vec2{-x, -y}; } float Dot(const Vec2 Other) const { return (x * Other.x) + (y * Other.y); } }; inline Vec2 operator*(float M, const Vec2& V) { return V * M; } inline std::ostream& operator<<( std::ostream& Stream, const Vec2& V ) { Stream << "{ x = " << V.x << ", y = " << V.y << " }"; return Stream; } ``` ```c++ #pragma once #include #include #include "Config.h" class Window { public: Window() { using namespace Config::Engine; SDLWindow = SDL_CreateWindow( WINDOW_TITLE.c_str(), SDL_WINDOWPOS_UNDEFINED, SDL_WINDOWPOS_UNDEFINED, WINDOW_WIDTH, WINDOW_HEIGHT, 0 ); } ~Window() { if (SDLWindow) { SDL_DestroyWindow(SDLWindow); } } Window(const Window&) = delete; Window& operator=(const Window&) = delete; void Render() { auto [r, g, b, a]{ Config::Engine::WINDOW_BACKGROUND }; SDL_FillRect( GetSurface(), nullptr, SDL_MapRGB( GetSurface()->format, r, g, b ) ); } void Update() { SDL_UpdateWindowSurface(SDLWindow); } SDL_Surface* GetSurface() { return SDL_GetWindowSurface(SDLWindow); } private: SDL_Window* SDLWindow; }; ``` ```c++ # cmake_minimum_required(VERSION 3.16) set(CMAKE_CXX_STANDARD 20) project(Breakout VERSION 1.0.0) add_executable(Breakout "main.cpp" "Editor/Source/Button.cpp" "Editor/Source/Blocks.cpp" "Editor/Source/Actor.cpp" "Editor/Source/ActorTooltip.cpp" "Editor/Source/Level.cpp" "Engine/Source/Scene.cpp" "Engine/ECS/Source/Component.cpp" "Engine/ECS/Source/CollisionComponent.cpp" "Engine/ECS/Source/ImageComponent.cpp" "Engine/ECS/Source/PhysicsComponent.cpp" "Engine/ECS/Source/InputComponent.cpp" "Engine/ECS/Source/Commands.cpp" # We'll add these later # "Breakout/Source/BreakoutScene.cpp" # "Breakout/Source/Ball.cpp" ) target_compile_definitions( Breakout PUBLIC WITH_EDITOR CHECK_ERRORS # We'll use these later # DRAW_DEBUG_HELPERS # ENABLE_CHEATS ) target_include_directories( Breakout PUBLIC ${PROJECT_SOURCE_DIR} ) add_subdirectory(external/SDL) add_subdirectory(external/SDL_image) add_subdirectory(external/SDL_ttf) target_link_libraries(Breakout PRIVATE SDL2 SDL2_image SDL2_ttf ) if (WIN32) target_link_libraries( Breakout PRIVATE SDL2main ) endif() set(AssetDirectory "${PROJECT_SOURCE_DIR}/Assets") add_custom_command( TARGET Breakout POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "$" "$" "$" "$" COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different "${AssetDirectory}" "$/Assets" VERBATIM ) ``` ```c++ #pragma once #include #include #include #include namespace UserEvents{ #ifdef WITH_EDITOR inline Uint32 ACTOR_DRAG{SDL_RegisterEvents(1)}; inline Uint32 LOAD_LEVEL{SDL_RegisterEvents(1)}; inline Uint32 SAVE_LEVEL{SDL_RegisterEvents(1)}; inline Uint32 SAVE_AND_PLAY_LEVEL{ SDL_RegisterEvents(1)}; inline Uint32 LEVEL_EDIT{SDL_RegisterEvents(1)}; #endif inline Uint32 LAUNCH_LEVEL{ SDL_RegisterEvents(1)}; } namespace Config { enum class ActorType : Uint8 { Actor = 0, BlueBlock = 1, GreenBlock = 2, CyanBlock = 3, OrangeBlock = 4, RedBlock = 5, YellowBlock = 6, }; inline const std::vector BUTTON_COLORS{ SDL_Color{15, 15, 15, 255}, // Normal SDL_Color{15, 155, 15, 255}, // Hover SDL_Color{225, 15, 15, 255}, // Active SDL_Color{60, 60, 60, 255} // Disabled }; inline constexpr SDL_Color FONT_COLOR{ 255, 255, 255, 255}; inline const std::string FONT{ "Assets/Rubik-SemiBold.ttf"}; } #ifdef WITH_EDITOR namespace Config::Editor { inline const Uint8 VERSION{1}; // Level inline const int HORIZONTAL_GRID_SNAP{50}; inline const int VERTICAL_GRID_SNAP{25}; inline const Uint8 GRID_WIDTH{13}; inline const Uint8 GRID_HEIGHT{6}; inline const int LEVEL_WIDTH{ HORIZONTAL_GRID_SNAP * GRID_WIDTH}; inline const int LEVEL_HEIGHT{ VERTICAL_GRID_SNAP * GRID_HEIGHT}; inline constexpr SDL_Color LEVEL_BACKGROUND{ 50, 50, 50, 255}; // ActorMenu inline const int ACTOR_MENU_WIDTH{70}; inline const int ACTOR_MENU_POSITION_X{LEVEL_WIDTH}; inline const SDL_Color ACTOR_MENU_BACKGROUND{ 15, 15, 15, 255}; inline const int PADDING{10}; // Window inline const std::string WINDOW_TITLE{"Editor"}; inline const int WINDOW_WIDTH{ LEVEL_WIDTH + ACTOR_MENU_WIDTH}; inline const int WINDOW_HEIGHT{LEVEL_HEIGHT + 50}; inline const SDL_Color WINDOW_BACKGROUND{ 35, 35, 35, 255}; } #endif namespace Config::Engine { inline const std::string WINDOW_TITLE{"Breakout"}; inline const int WINDOW_WIDTH{720}; inline const int WINDOW_HEIGHT{400}; inline const SDL_Color WINDOW_BACKGROUND{ 35, 35, 35, 255}; } inline void CheckSDLError( const std::string& Msg) { #ifdef CHECK_ERRORS const char* error = SDL_GetError(); if (*error != '\0') { std::cerr << Msg << " Error: " << error << '\n'; SDL_ClearError(); } #endif } ``` ```c++ #include #include #include #include "Config.h" #include "Engine/Window.h" #include "Breakout/BreakoutScene.h" #ifdef WITH_EDITOR #include "Editor/Scene.h" #include "Editor/Window.h" #endif int main(int argc, char** argv) { SDL_Init(SDL_INIT_VIDEO); CheckSDLError("SDL_Init"); IMG_Init(IMG_INIT_PNG); CheckSDLError("IMG_Init"); TTF_Init(); CheckSDLError("TTF_Init"); #ifdef WITH_EDITOR Editor::Window EditorWindow; Editor::Scene EditorScene{EditorWindow}; // Enable mouse button events for clicks that // change input focus SDL_SetHint( SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1" ); #endif Window GameWindow; BreakoutScene GameScene{GameWindow}; Uint64 LastTick{SDL_GetPerformanceCounter()}; SDL_Event E; while (true) { while (SDL_PollEvent(&E)) { #ifdef WITH_EDITOR EditorScene.HandleEvent(E); #endif GameScene.HandleEvent(E); if ( E.type == SDL_QUIT || E.type == SDL_WINDOWEVENT && E.window.event == SDL_WINDOWEVENT_CLOSE ) { TTF_Quit(); IMG_Quit(); SDL_Quit(); return 0; } } Uint64 CurrentTick{SDL_GetPerformanceCounter()}; float DeltaTime{ static_cast(CurrentTick - LastTick) / SDL_GetPerformanceFrequency() }; LastTick = CurrentTick; #ifdef WITH_EDITOR EditorScene.Tick(DeltaTime); EditorWindow.Render(); EditorScene.Render(EditorWindow.GetSurface()); EditorWindow.Update(); #endif GameScene.Tick(DeltaTime); GameWindow.Render(); GameScene.Render(GameWindow.GetSurface()); GameWindow.Update(); } return 0; } ``` ## Editor The files in our editor directory haven't been changed since our previous project. The `main.cpp` and `Config.h` files are also from our editor project, with a few additions we'll note later in the section. When `WITH_EDITOR` is defined, our program loads our editor, which can be used to create and modify levels for our game. A screenshot of our map editor

We'll load the files created by this editor into our breakout game later in the project. Note that, for now, we'll assume that `WITH_EDITOR` is always defined. Our project may not compile correctly if `WITH_EDITOR` is not defined. At the end of the project, we'll update our project to allow the editor to be fully excluded, and for our game to ship without it. ## Engine Most of our starting code is in the `Engine/` directory, which includes all the code we wrote in the previous few chapters. It matches the code we finished in our previous chapter, but with a few small changes. We'll highlight those changes below. ### Include Directories Our engine files are now stored within `Engine/` and `Engine/ECS/` directories. Therefore, we need to either update our project's include directories within our build configuration, or update all of our `#include` directives to reflect this new location. The starting code we provided above has chosen the latter approach, prepending `Engine/` or `Engine/ECS/` as appropriate. For example: ```c++ // ... // Before: #include "Component.h" #include "Vec2.h" // After: #include "Engine/ECS/Component.h" #include "Engine/Vec2.h" // ... ``` ### The `Config::Engine` Namespace The `Engine/Window.h` class is loading its title, size, and background color from variables defined within the `Config::Engine` namespace. We've added these values to our `Config.h` file: ```c++ // ... namespace Config::Engine { inline const std::string WINDOW_TITLE{"Breakout"}; inline const int WINDOW_WIDTH{720}; inline const int WINDOW_HEIGHT{400}; inline const SDL_Color WINDOW_BACKGROUND{ 35, 35, 35, 255}; } // ... ``` ### Adding `Scene::GetWidth()` and `Scene::GetHeight()` To help with the positioning of our elements, our `Scene` class has added getters to provide access to the private `WorldSpaceWidth` and `WorldSpaceHeight` variables: ```c++ // ... class Scene { public: // ... float GetWidth() { return WorldSpaceWidth; } float GetHeight() { return WorldSpaceHeight; } // ... }; ``` ### Adding `Entity::AddComponent<>()` and `Entity::GetComponent<>()` In our component chapters, we mentioned that our approach to defining functions like `GetTransformComponent()` and `GetPhysicsComponent()` was problematic. Every time we added a new component type, or a new constructor to an existing component type, we needed to update our `Entity` class with more functions. We proposed a more advanced technique involving templates to circumvent that limitation, which we've now implemented: ```c++ // ... class Entity { public: // ... template requires std::derived_from CType* AddComponent(CArgs&&... ConstructorArgs) { ComponentPtr& NewComponent{ Components.emplace_back( std::make_unique( this, std::forward(ConstructorArgs)... ) ) }; NewComponent->Initialize(); return static_cast(NewComponent.get()); } template requires std::derived_from CType* GetComponent() { for (const ComponentPtr& C : Components) { if (auto Ptr{dynamic_cast( C.get() )}) { return Ptr; } } return nullptr; } // ... }; ``` To add a component to an entity, we now use `AddComponent<>()`, passing the component type within `<` and `>`, and constructor arguments for that component within the `(` and `)`. For a hypothetical `AudioComponent`, that might look like this: ```c++ // Before: AddAudioComponent(42, 9.8, true);// // After: AddComponent(42, 9.8, true);// ``` To retrieve a component, we use `GetComponent<>()`, passing the component type within `<` and `>`, and an empty set of brackets - `(` and `)` ```c++ // Before: GetAudioComponent();// // After: GetComponent();// ``` This allows us to simplify our `Entity` class significantly by removing a lot of `GetSomeComponent()` and `AddSomeComponent()`-style functions. Note that, after removing those functions, some of our existing code will need to be updated to use the new API. For example: ```c++ // ... // Additional #include directives may also be needed #include "TransformComponent.h"// Vec2 Component::GetOwnerPosition() const { TransformComponent* Transform{ // Before: GetOwner()->GetTransformComponent()// // After: GetOwner()->GetComponent()// }; if (!Transform) { std::cerr << "Error: attempted to get position" " of an entity with no transform component\n"; return {0, 0}; } return Transform->GetPosition(); } ``` Our starting code provided above includes these changes ### Fixing the `Vec2` Forward Declaration An earlier version of a previous lesson was incorrectly forward-declaring our `Vec2` type as a `class` when it was actually a `struct`. This error was in the `Component.h` header file. That has now been corrected in the lesson and the starting code above, but if following on using your own version of the files, you may still have that issue: ```c++ #pragma once #include class Entity; class Scene; class AssetManager; class Vec2; // struct Vec2; // // ... class Component { // ... }; ``` ## Breakout Files Finally, we have the `Breakout/` directory, which is where we'll store classes that are specific to our game. However, not all of our work in this project will be within this directory - we'll be adding new capabilities to classes within the `Engine/` directory too. This separation is useful as, if we keep our engine code generic, we can reuse those components over and over again, across multiple projects. Capabilities we add to our engine during the process of making one game can make the next game better, or quicker to build. ### The `BreakoutScene` Class For now, the only breakout-specific code we'll add is a `BreakoutScene` class, which will eventually orchestrate our game flow. For now, it just inherits from the base `Scene` class in our `Engine`, and forwards the window to the base constructor. We'll connect this `BreakoutScene` to our main loop in the next section: ```c++ #pragma once #include #include "Engine/Scene.h" class BreakoutScene : public Scene { public: BreakoutScene(Window& ParentWindow) : Scene{ParentWindow} {} }; ``` ### Updates to `main.cpp` Our `main.cpp` primarily uses the same code from our level editor project. We've just added a new `Window` for our game, a `BreakoutScene` instance to manage it, and we've connected both to the event and application loops: ```c++ #include #include #include #include "Config.h" #include "Engine/Window.h"// #include "Breakout/BreakoutScene.h"// #ifdef WITH_EDITOR #include "Editor/Scene.h" #include "Editor/Window.h" #endif int main(int argc, char** argv) { SDL_Init(SDL_INIT_VIDEO); CheckSDLError("SDL_Init"); IMG_Init(IMG_INIT_PNG); CheckSDLError("IMG_Init"); TTF_Init(); CheckSDLError("TTF_Init"); #ifdef WITH_EDITOR Editor::Window EditorWindow; Editor::Scene EditorScene{EditorWindow}; #endif Window GameWindow;// BreakoutScene GameScene{GameWindow};// Uint64 LastTick{SDL_GetPerformanceCounter()}; SDL_Event E; while (true) { while (SDL_PollEvent(&E)) { #ifdef WITH_EDITOR EditorScene.HandleEvent(E); #endif GameScene.HandleEvent(E);// if ( E.type == SDL_QUIT || E.type == SDL_WINDOWEVENT && E.window.event == SDL_WINDOWEVENT_CLOSE ) { TTF_Quit(); IMG_Quit(); SDL_Quit(); return 0; } } Uint64 CurrentTick{SDL_GetPerformanceCounter()}; float DeltaTime{ static_cast(CurrentTick - LastTick) / SDL_GetPerformanceFrequency() }; LastTick = CurrentTick; #ifdef WITH_EDITOR EditorScene.Tick(DeltaTime); EditorWindow.Render(); EditorScene.Render(EditorWindow.GetSurface()); EditorWindow.Update(); #endif GameScene.Tick(DeltaTime);// GameWindow.Render();// GameScene.Render(GameWindow.GetSurface());// GameWindow.Update();// } return 0; } ``` ### Mouse Focus Clickthrough By default, SDL will _**not**_ report a mouse click event on a window that did not have input focus. This is a sensible default for single-window applications but can be a bit unintuitive for multi-window programs. For example, if we wanted to click the "Play" button in our editor, but the editor does not have input focus, we'd have to click it twice. The first click would make the window active, but not provide a click event to which our button can react. We can change this behaviour by setting the `SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH` hint to `"1"`, rather than its default value of `"0"`: ```c++ // ... int main(int argc, char** argv) { // ... #ifdef WITH_EDITOR Editor::Window EditorWindow; Editor::Scene EditorScene{EditorWindow}; SDL_SetHint(// SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH, "1"// );// #endif // ... return 0; } ``` ## Assets As usual, we should ensure the SDL DLL files are provided alongside our executable file. Any font and image files we reference should also be stored alongside the executable file. In our code examples, we reference images and fonts using paths like "Assets/Rubik-SemiBold.ttf" and "Assets/Brick_Blue_A.png". That means that an "Assets" directory should exist in the same location as our executable, and that "Assets" directory should include files like "Rubik-SemiBold.ttf" and "Brick_Blue_A.png" The assets used in our examples are provided below, but feel free to substitute your own if preferred: - [Breakout Free Assets on Itch.io](https://blackcreepycat.itch.io/breakout-free-asset-vol-1) - [Rubik Font on Google Fonts](https://fonts.google.com/specimen/Rubik) All of the code we introduced in this lesson, in addition to three example levels serialized from the map editor, are available here: - [breakout-start.zip](https://www.studyplan.dev/sdl2-assets/breakout-start.zip) ## The `CMakeLists.txt` File If you're using CMake, a `CMakeLists.txt` file is provided below that includes all the source files our build needs. It will also automatically copy the DLL files to the same location as the executable. Files stored in an "Assets" directory within the project folder will also be copied to an "Assets" directory in the same location as the executable. ```c++ # cmake_minimum_required(VERSION 3.16) set(CMAKE_CXX_STANDARD 20) project(Breakout VERSION 1.0.0) add_executable(Breakout "main.cpp" "Editor/Source/Button.cpp" "Editor/Source/Blocks.cpp" "Editor/Source/Actor.cpp" "Editor/Source/ActorTooltip.cpp" "Editor/Source/Level.cpp" "Engine/Source/Scene.cpp" "Engine/ECS/Source/Component.cpp" "Engine/ECS/Source/CollisionComponent.cpp" "Engine/ECS/Source/ImageComponent.cpp" "Engine/ECS/Source/PhysicsComponent.cpp" "Engine/ECS/Source/InputComponent.cpp" "Engine/ECS/Source/Commands.cpp" # These will be added later # "Breakout/Source/BreakoutScene.cpp" # "Breakout/Source/Ball.cpp" ) target_compile_definitions( Breakout PUBLIC WITH_EDITOR CHECK_ERRORS # We'll use these later # DRAW_DEBUG_HELPERS # ENABLE_CHEATS ) target_include_directories( Breakout PUBLIC ${PROJECT_SOURCE_DIR} ) add_subdirectory(external/SDL) add_subdirectory(external/SDL_image) add_subdirectory(external/SDL_ttf) target_link_libraries(Breakout PRIVATE SDL2 SDL2_image SDL2_ttf ) if (WIN32) target_link_libraries( Breakout PRIVATE SDL2main ) endif() set(AssetDirectory "${PROJECT_SOURCE_DIR}/Assets") add_custom_command( TARGET Breakout POST_BUILD COMMAND ${CMAKE_COMMAND} -E copy_if_different "$" "$" "$" "$" COMMAND ${CMAKE_COMMAND} -E copy_directory_if_different "${AssetDirectory}" "$/Assets" VERBATIM ) ``` ## Summary Our starting point should compile successfully, showing our Editor window and a currently-empty Breakout window: A screenshot of our starting point

We've successfully established the foundation for our Breakout clone. This lesson involved gathering all our previous work on the level editor and game engine, organizing it into a coherent project structure, and creating the initial `BreakoutScene` class for our game. Our application now compiles and runs, displaying both the editor and an empty game window, ready for us to start adding gameplay elements. Here's what we've accomplished: - We created a project structure that separates game-specific code (`Breakout/`) from reusable code (`Engine/`, `Editor/`). - We upgraded our `Entity` class to use generic, templated functions for adding and retrieving components, making our engine more flexible. - We configured `main.cpp` to run both the editor and the game loop simultaneously. - We learned how the `SDL_HINT_MOUSE_FOCUS_CLICKTHROUGH` hint makes multi-window interactions smoother.

Breakout: Project Setup

Understanding the Basics

Practical Applications

Common Mistakes

Next Steps

Additional Resources

Assessment Preparation