Update hitboxes

CMakeLists.txt

@@ -10,11 +10,20 @@ find_package(SDL2_image REQUIRED)
 find_package(SDL2_ttf REQUIRED)
 
 add_executable(Obstacle
-        Main.cpp
-        Game.cpp
-        Game.h
-        Helper.cpp
-        Helper.h
+        src/main.cpp
+        src/Renderer.cpp
+        src/Renderer.h
+        src/states/GameState.h
+        src/states/InGameState.cpp
+        src/states/InGameState.h
+        src/states/MainMenuState.cpp
+        src/states/MainMenuState.h
+        src/entities/Player.cpp
+        src/entities/Player.h
+        src/entities/Opponent.cpp
+        src/entities/Opponent.h
+        src/states/EndingState.cpp
+        src/states/EndingState.h
 )
 
 target_link_libraries(Obstacle SDL2::SDL2 SDL2_image::SDL2_image SDL2_ttf::SDL2_ttf)

Game.cpp

@@ -1,259 +0,0 @@
-#include "Game.h"
-#include "Helper.h"
-#include <algorithm>
-#include <string>
-
-#define WINDOW_WIDTH 700
-#define WINDOW_HEIGHT 500
-
-bool keys[4] = {false, false, false, false};
-
-void Game::spawnItem(Type type) {
-    Item item{};
-    item.type = type;
-    item.x = rand() % WINDOW_WIDTH;
-    item.y = rand() % WINDOW_HEIGHT;
-
-    items.push_back(item);
-}
-
-void Opponent::move(int timeMultiplier) {
-    if (this->x < this->targetX) this->x += timeMultiplier;
-    if (this->x > this->targetX) this->x -= timeMultiplier;
-    if (this->y < this->targetY) this->y += timeMultiplier;
-    if (this->y > this->targetY) this->y -= timeMultiplier;
-}
-
-void Player::moveX(int dx) {
-    if (x + dx < 0 || x + dx > WINDOW_WIDTH - 80) return;
-    if (y < 40 && this->x + dx < 30 * 3 + 15) return;
-    x += dx;
-}
-
-void Player::moveY(int dy) {
-    if (y + dy < 0 || y + dy > WINDOW_HEIGHT - 96) return;
-    if (y + dy < 40 && this->x < 30 * 3 + 15) return;
-    y += dy;
-}
-
-void Game::checkCollision() {
-    for (int i = 0; i < opponents.size(); i++) {
-        Opponent o = opponents[i];
-        if (o.x == o.targetX && o.y == o.targetY) {
-            opponents.erase(opponents.begin() + i);
-        }
-        if (player.x < o.x + 80 && player.x + 80 > o.x && player.y < o.y + 96 && player.y + 96 > o.y) {
-            if (player.health > 0) {
-                player.health--;
-            }
-            else {
-                // TODO: Game over sccreen
-            }
-
-            opponents.erase(opponents.begin() + i);
-        }
-    }
-
-    for (int i = 0; i < items.size(); i++) {
-        Item item = items[i];
-        if (player.x < item.x + 24 && player.x + 80 > item.x && player.y < item.y + 24 && player.y + 96 > item.y) {
-            switch (item.type) {
-            case Type::HEALTH:
-                if (player.health < 3) {
-                    player.health++;
-                }
-                break;
-            case Type::DAMAGE:
-                player.health--;
-                break;
-            }
-
-            items.erase(items.begin() + i);
-        }
-    }
-}
-
-void Game::renderHUD(SDL_Renderer* renderer, SDL_Texture* heart) const {
-    SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
-    SDL_Rect bgRect = {0, 0, 30 * 3 + 15, 40};
-    SDL_RenderFillRect(renderer, &bgRect);
-
-    for (int i = 0; i < this->player.health; i++) {
-        drawTexture(renderer, heart, 10 + i * 30, 10, 24, 24);
-    }
-}
-
-void Game::renderPlayer(SDL_Renderer* renderer, SDL_Texture* playerTexture, Player p) const {
-    drawTexture(renderer, playerTexture, p.x, p.y, 80, 96);
-
-    if (showHitboxes) {
-        SDL_SetRenderDrawColor(renderer, 255, 0, 0, SDL_ALPHA_OPAQUE);
-        SDL_Rect hitbox = {p.x, p.y, 80, 96};
-        SDL_RenderDrawRect(renderer, &hitbox);
-    }
-}
-
-void Game::renderItem(SDL_Renderer* renderer, Item i) const {
-    SDL_Texture* itemTexture = IMG_LoadTexture(renderer, i.type == Type::HEALTH ? "./res/heart.png" : "./res/damage.png");
-    switch (i.type) {
-    case Type::HEALTH:
-        drawTexture(renderer, itemTexture, i.x, i.y, 24, 24);
-        SDL_DestroyTexture(itemTexture);
-        break;
-    case Type::DAMAGE:
-        drawTexture(renderer, itemTexture, i.x, i.y, 24, 24);
-        SDL_DestroyTexture(itemTexture);
-
-        break;
-    default: break;
-    }
-
-    if (showHitboxes) {
-        SDL_SetRenderDrawColor(renderer, 255, 0, 0, SDL_ALPHA_OPAQUE);
-        SDL_Rect hitbox = {i.x, i.y, 24, 24};
-        SDL_RenderDrawRect(renderer, &hitbox);
-    }
-}
-
-void Game::createOpponent() {
-    Opponent o;
-
-    int edge = rand() % 4;
-    switch (edge) {
-    case 0:
-        o.x = rand() % WINDOW_WIDTH;
-        o.y = -96;
-        o.targetY = WINDOW_HEIGHT + 96;
-        o.targetX = rand() % WINDOW_WIDTH;
-        break;
-    case 1:
-        o.x = rand() % WINDOW_WIDTH;
-        o.y = WINDOW_HEIGHT;
-        o.targetY = -96;
-        o.targetX = rand() % WINDOW_WIDTH;
-        break;
-    case 2:
-        o.x = -80;
-        o.y = rand() % WINDOW_HEIGHT;
-        o.targetX = WINDOW_WIDTH + 80;
-        o.targetY = rand() % WINDOW_HEIGHT;
-        break;
-    case 3:
-        o.x = WINDOW_WIDTH;
-        o.y = rand() % WINDOW_HEIGHT;
-        o.targetX = -80;
-        o.targetY = rand() % WINDOW_HEIGHT;
-        break;
-    }
-
-    opponents.push_back(o);
-}
-
-void Game::renderOpponent(SDL_Renderer* renderer, SDL_Texture* opponentTexture, Opponent o) const {
-    drawTexture(renderer, opponentTexture, o.x, o.y, 80, 96);
-
-    if (showHitboxes) {
-        SDL_SetRenderDrawColor(renderer, 255, 0, 0, SDL_ALPHA_OPAQUE);
-        SDL_Rect hitbox = {o.x, o.y, 80, 96};
-        SDL_RenderDrawRect(renderer, &hitbox);
-    }
-}
-
-void Game::render(SDL_Renderer* renderer, SDL_Texture* bg) {
-    SDL_RenderClear(renderer);
-
-    SDL_SetRenderDrawColor(renderer, 35, 39, 42, SDL_ALPHA_OPAQUE);
-
-    drawTexture(renderer, bg, 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
-
-    SDL_Texture* playerTexture = IMG_LoadTexture(renderer, "./res/player.png");
-    renderPlayer(renderer, playerTexture, this->player);
-
-    SDL_Texture* opponentTexture = IMG_LoadTexture(renderer, "./res/opponent.png");
-    for (Opponent o : this->opponents) {
-        renderOpponent(renderer, opponentTexture, o);
-    }
-
-    for (Item i : this->items) {
-        renderItem(renderer, i);
-    }
-
-    SDL_Texture* heart = IMG_LoadTexture(renderer, "./res/heart.png");
-    renderHUD(renderer, heart);
-
-    TTF_Font* font = TTF_OpenFont("./res/font.ttf", 24);
-
-    drawText(renderer, font, "h: " + std::to_string(player.health), 30 * 3 + 15 + 10, 10);
-
-    SDL_DestroyTexture(playerTexture);
-    SDL_DestroyTexture(opponentTexture);
-    SDL_DestroyTexture(heart);
-
-    SDL_RenderPresent(renderer);
-}
-
-void Game::run() {
-    SDL_Window* window = SDL_CreateWindow("Obstacle Game", SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
-                                          WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_SHOWN);
-    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE);
-
-    SDL_Texture* background = IMG_LoadTexture(renderer, "./res/background.png");
-
-    int startTime = time(nullptr);
-
-    TTF_Init();
-
-    bool gameOpen = true;
-    while (gameOpen) {
-        SDL_Event event;
-        while (SDL_PollEvent(&event)) {
-            if (event.type == SDL_QUIT) gameOpen = false;
-
-            if (event.type == SDL_KEYDOWN || event.type == SDL_KEYUP) {
-                bool isPressed = (event.type == SDL_KEYDOWN);
-                switch (event.key.keysym.sym) {
-                case SDLK_w:
-                    keys[0] = isPressed;
-                    break;
-                case SDLK_a:
-                    keys[1] = isPressed;
-                    break;
-                case SDLK_s:
-                    keys[2] = isPressed;
-                    break;
-                case SDLK_d:
-                    keys[3] = isPressed;
-                    break;
-                case SDLK_h:
-                    if (isPressed) showHitboxes = !showHitboxes;
-                    break;
-                }
-            }
-        }
-
-        if (keys[0]) player.moveY(-20);
-        if (keys[1]) player.moveX(-20);
-        if (keys[2]) player.moveY(20);
-        if (keys[3]) player.moveX(20);
-
-        checkCollision();
-
-        if (rand() % 100 == 0) createOpponent();
-
-        if (time(nullptr) - startTime > 5) {
-            startTime = time(nullptr);
-            spawnItem(Type::HEALTH);
-        }
-
-        for (Opponent& o : opponents) {
-            o.move(10);
-        }
-
-        render(renderer, background);
-        SDL_Delay(16);
-    }
-
-    SDL_DestroyTexture(background);
-    SDL_DestroyRenderer(renderer);
-    SDL_DestroyWindow(window);
-}

Helper.cpp

@@ -1,36 +0,0 @@
-#include "Helper.h"
-void drawTexture(SDL_Renderer *renderer, SDL_Texture *texture, int x, int y, int w, int h) {
-    SDL_Rect src;
-    src.x = 0;
-    src.y = 0;
-    SDL_QueryTexture(texture, nullptr, nullptr, &src.w, &src.h);
-
-    SDL_Rect dist;
-    dist.x = x;
-    dist.y = y;
-    dist.w = w;
-    dist.h = h;
-
-    SDL_RenderCopy(renderer, texture, &src, &dist);
-}
-
-void drawText(SDL_Renderer *renderer, TTF_Font *font, const std::string text, int x, int y) {
-    SDL_Surface *surface = TTF_RenderText_Solid(font, text.c_str(), {255, 255, 255});
-    SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, surface);
-
-    SDL_Rect src;
-    src.x = 0;
-    src.y = 0;
-    SDL_QueryTexture(texture, nullptr, nullptr, &src.w, &src.h);
-
-    SDL_Rect dist;
-    dist.x = x;
-    dist.y = y;
-
-    TTF_SizeText(font, text.c_str(), &dist.w, &dist.h);
-
-    SDL_RenderCopy(renderer, texture, &src, &dist);
-
-    SDL_FreeSurface(surface);
-    SDL_DestroyTexture(texture);
-}

Helper.h

@@ -1,10 +0,0 @@
-#ifndef CPP_LEARNING_HELPER_H
-#define CPP_LEARNING_HELPER_H
-#include <SDL2/SDL.h>
-#include <SDL2/SDL_ttf.h>
-#include <string>
-
-void drawTexture(SDL_Renderer *renderer, SDL_Texture *texture, int x, int y, int w, int h);
-void drawText(SDL_Renderer *renderer, TTF_Font *font, const std::string text, int x, int y);
-
-#endif

Main.cpp

@@ -1,9 +0,0 @@
-#include "Game.h"
-
-using namespace std;
-
-int main() {
-    Game game{};
-
-    game.run();
-}

README.md

@@ -1,3 +1,45 @@
-# ObstacleGame
+<br />
+<div align="center">
+  <a href="https://git.gnm.dev/Mathias/ObstacleGame/">
+    <img src="https://git.gnm.dev/Mathias/ObstacleGame/raw/branch/main/res/logo.png" alt="Logo" width="200">
+  </a>
+</div>
 
-Entwickelt für die Berufschule: Ein Spiel, in welchem du Gegnern ausweichen musst.
+
+## 🎮 Obstacle Game
+
+Entwickelt für die Berufschule: Ein Spiel, in welchem du Gegnern ausweichen musst. Geschrieben in C++ mit der SDL2 Library.
+
+### ⬇️ Installation
+
+1. Klone das Repository
+   ```sh
+   git clone https://git.gnm.dev/Mathias/ObstacleGame.git
+   ```
+   
+2. Installer SDL2, SDL2_image, SDL2_ttf, SDL2_mixer
+   ```sh
+   sudo apt-get install libsdl2-dev libsdl2-image-dev libsdl2-ttf-dev libsdl2-mixer-dev
+   ```
+   
+3. Installer CMake
+   ```sh
+    sudo apt-get install cmake
+    ```
+   
+4. Baue das Projekt
+    ```sh
+    mkdir build
+    cd build
+    cmake ..
+    make
+    ```
+   
+5. Starte das Spiel
+    ```sh
+    ./ObstacleGame
+    ```
+   
+### 📝 License
+
+Distributed under the MIT License. See `LICENSE` for more information.

src/Renderer.cpp

@@ -0,0 +1,70 @@
+#include "Renderer.h"
+
+void drawCircle(SDL_Renderer *renderer, int32_t centreX, int32_t centreY, int32_t radius) {
+    const int32_t diameter = (radius * 2);
+
+    int32_t x = (radius - 1);
+    int32_t y = 0;
+    int32_t tx = 1;
+    int32_t ty = 1;
+    int32_t error = (tx - diameter);
+
+    while (x >= y) {
+        SDL_RenderDrawPoint(renderer, centreX + x, centreY - y);
+        SDL_RenderDrawPoint(renderer, centreX + x, centreY + y);
+        SDL_RenderDrawPoint(renderer, centreX - x, centreY - y);
+        SDL_RenderDrawPoint(renderer, centreX - x, centreY + y);
+        SDL_RenderDrawPoint(renderer, centreX + y, centreY - x);
+        SDL_RenderDrawPoint(renderer, centreX + y, centreY + x);
+        SDL_RenderDrawPoint(renderer, centreX - y, centreY - x);
+        SDL_RenderDrawPoint(renderer, centreX - y, centreY + x);
+
+        if (error <= 0) {
+            y++;
+            error += ty;
+            ty += 2;
+        }
+
+        if (error > 0) {
+            x--;
+            tx += 2;
+            error += (tx - diameter);
+        }
+    }
+}
+
+void drawTexture(SDL_Renderer *renderer, SDL_Texture *texture, int x, int y, int w, int h) {
+    SDL_Rect src;
+    src.x = 0;
+    src.y = 0;
+    SDL_QueryTexture(texture, nullptr, nullptr, &src.w, &src.h);
+
+    SDL_Rect dist;
+    dist.x = x;
+    dist.y = y;
+    dist.w = w;
+    dist.h = h;
+
+    SDL_RenderCopy(renderer, texture, &src, &dist);
+}
+
+void drawText(SDL_Renderer *renderer, TTF_Font *font, const std::string text, int x, int y, SDL_Color color) {
+    SDL_Surface *surface = TTF_RenderText_Solid(font, text.c_str(), color);
+    SDL_Texture *texture = SDL_CreateTextureFromSurface(renderer, surface);
+
+    SDL_Rect src;
+    src.x = 0;
+    src.y = 0;
+    SDL_QueryTexture(texture, nullptr, nullptr, &src.w, &src.h);
+
+    SDL_Rect dist;
+    dist.x = x;
+    dist.y = y;
+
+    TTF_SizeText(font, text.c_str(), &dist.w, &dist.h);
+
+    SDL_RenderCopy(renderer, texture, &src, &dist);
+
+    SDL_FreeSurface(surface);
+    SDL_DestroyTexture(texture);
+}

src/Renderer.h

@@ -0,0 +1,14 @@
+#ifndef CPP_LEARNING_HELPER_H
+#define CPP_LEARNING_HELPER_H
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_ttf.h>
+#include <string>
+
+#define WINDOW_WIDTH 700
+#define WINDOW_HEIGHT 500
+
+void drawTexture(SDL_Renderer *renderer, SDL_Texture *texture, int x, int y, int w, int h);
+void drawText(SDL_Renderer *renderer, TTF_Font *font, std::string text, int x, int y, SDL_Color color);
+void drawCircle(SDL_Renderer *renderer, int32_t centreX, int32_t centreY, int32_t radius);
+
+#endif

src/entities/Opponent.cpp

@@ -0,0 +1,8 @@
+#include "Opponent.h"
+
+void Opponent::move(int timeMultiplier) {
+    if (this->x < this->targetX) this->x += timeMultiplier;
+    if (this->x > this->targetX) this->x -= timeMultiplier;
+    if (this->y < this->targetY) this->y += timeMultiplier;
+    if (this->y > this->targetY) this->y -= timeMultiplier;
+}

src/entities/Opponent.h

@@ -0,0 +1,8 @@
+#include "Player.h"
+
+class Opponent : public Player {
+public:
+    int targetX = 0;
+    int targetY = 0;
+    void move(int multiplier);
+};

src/entities/Player.cpp

@@ -0,0 +1,13 @@
+#include "Player.h"
+
+void Player::moveX(int dx) {
+    if (x + dx < 0 || x + dx > WINDOW_WIDTH - 80) return;
+    if (y < 40 && this->x + dx < 30 * 3 + 15) return;
+    x += dx;
+}
+
+void Player::moveY(int dy) {
+    if (y + dy < 0 || y + dy > WINDOW_HEIGHT - 96) return;
+    if (y + dy < 40 && this->x < 30 * 3 + 15) return;
+    y += dy;
+}

src/entities/Player.h

@@ -0,0 +1,11 @@
+#include "../Renderer.h"
+
+class Player {
+public:
+    int x = 40;
+    int y = 40;
+    int unsigned health = 3;
+
+    void moveX(int dx);
+    void moveY(int dy);
+};

src/main.cpp

@@ -0,0 +1,68 @@
+#include "states/GameState.h"
+#include "states/MainMenuState.h"
+#include "states/InGameState.h"
+#include "states/EndingState.h"
+#include "Renderer.h"
+#include <SDL2/SDL.h>
+#include <memory>
+#include <unordered_map>
+#include <iostream>
+
+int main() {
+    TTF_Init();
+
+    SDL_Window* window = SDL_CreateWindow("Obstacle Game",
+                                          SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED,
+                                          WINDOW_WIDTH, WINDOW_HEIGHT, SDL_WINDOW_SHOWN);
+    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_SOFTWARE);
+
+    std::unordered_map<std::string, std::shared_ptr<GameState>> states;
+    states["main_menu"] = std::make_shared<MainMenuState>();
+    states["game"] = std::make_shared<InGameState>();
+    states["ending"] = std::make_shared<EndingState>();
+
+    std::shared_ptr<GameState> currentState = states["main_menu"];
+
+    Uint64 NOW = SDL_GetPerformanceCounter();
+    Uint64 LAST = 0;
+    double deltaTime = 0;
+
+    currentState->init();
+
+    bool running = true;
+    while (running) {
+        LAST = NOW;
+        NOW = SDL_GetPerformanceCounter();
+
+        deltaTime = (double)((NOW - LAST)*1000 / (double)SDL_GetPerformanceFrequency() );
+
+        SDL_Event event;
+        while (SDL_PollEvent(&event)) {
+            if (event.type == SDL_QUIT) {
+                running = false;
+            }
+            currentState->handleEvents(event);
+        }
+
+        currentState->update();
+        currentState->render(renderer, deltaTime);
+
+        if (!currentState->getNextState().empty()) {
+            std::string nextStateName = currentState->getNextState();
+            if (nextStateName == "exit") {
+                running = false;
+            } else if (states.find(nextStateName) != states.end()) {
+                currentState = states[nextStateName];
+                currentState->init();
+            }
+            currentState->clearNextState();
+        }
+    }
+
+    SDL_DestroyRenderer(renderer);
+    SDL_DestroyWindow(window);
+    SDL_Quit();
+    TTF_Quit();
+
+    return 0;
+}

src/states/EndingState.cpp

@@ -0,0 +1,43 @@
+#include "EndingState.h"
+#include "../Renderer.h"
+#include <iostream>
+#include <SDL_image.h>
+
+int score = 0;
+
+void EndingState::init() {
+    SDL_ShowCursor(SDL_ENABLE);
+    std::cout << "Ending state initialized\n";
+    score = SDL_GetTicks() / 100;
+}
+
+void EndingState::handleEvents(SDL_Event& event) {
+    if (event.type == SDL_KEYDOWN) {
+        switch (event.key.keysym.sym) {
+            case SDLK_ESCAPE:
+                std::cout << "Exiting game\n";
+                this->changeRoom("exit");
+                break;
+            default:
+                break;
+        }
+    }
+}
+
+void EndingState::update() {
+
+}
+
+void EndingState::render(SDL_Renderer* renderer, double deltaTime) {
+    SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
+    SDL_RenderClear(renderer);
+
+    TTF_Font *font = TTF_OpenFont("./res/font.ttf", 24);
+    drawText(renderer, font, "GAME OVER",
+             WINDOW_WIDTH / 2 - 100, WINDOW_HEIGHT / 2 - 50, {255, 0, 0, SDL_ALPHA_OPAQUE});
+
+    drawText(renderer, font, "Score: " + std::to_string(score),
+             WINDOW_WIDTH / 2 - 120, WINDOW_HEIGHT / 2, {255, 255, 255, SDL_ALPHA_OPAQUE});
+
+    SDL_RenderPresent(renderer);
+}

src/states/EndingState.h

@@ -0,0 +1,11 @@
+#include "GameState.h"
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_ttf.h>
+
+class EndingState final : public GameState {
+public:
+    void init() override;
+    void handleEvents(SDL_Event& event) override;
+    void update() override;
+    void render(SDL_Renderer* renderer, double deltaTime) override;
+};

src/states/GameState.h

@@ -0,0 +1,32 @@
+#ifndef GAME_STATE_H
+#define GAME_STATE_H
+
+#include <string>
+#include <SDL2/SDL.h>
+
+class GameState {
+protected:
+    std::string nextStateName;
+
+public:
+    virtual ~GameState() = default;
+
+    virtual void init() = 0;
+    virtual void handleEvents(SDL_Event& event) = 0;
+    virtual void update() = 0;
+    virtual void render(SDL_Renderer* renderer, double deltaTime) = 0;
+
+    void changeRoom(const std::string& stateName) {
+        nextStateName = stateName;
+    }
+
+    std::string getNextState() const {
+        return nextStateName;
+    }
+
+    void clearNextState() {
+        nextStateName.clear();
+    }
+};
+
+#endif

src/states/InGameState.cpp

@@ -0,0 +1,258 @@
+#include "InGameState.h"
+#include <iostream>
+
+bool keys[4] = {false, false, false, false};
+
+SDL_Rect InGameState::getPlayerHitbox(const Player& player) const {
+    return {player.x + 20, player.y + 20, 40, 56};
+}
+
+SDL_Rect InGameState::getItemHitbox(const Item& item) const {
+    return {item.x, item.y, 24, 24};
+}
+
+SDL_Rect InGameState::getOpponentHitbox(const Opponent& opponent) const {
+    return {opponent.x, opponent.y, 80, 96};
+}
+
+void InGameState::spawnItem(Type type) {
+    Item item{};
+    item.type = type;
+    item.x = rand() % WINDOW_WIDTH;
+    item.y = rand() % WINDOW_HEIGHT;
+
+    for (const Item i : items) {
+        if (i.type == type) return;
+    }
+
+    items.push_back(item);
+}
+
+void InGameState::renderPlayer(SDL_Renderer* renderer, SDL_Texture* playerTexture, Player p) const {
+    drawTexture(renderer, playerTexture, p.x, p.y, 80, 96);
+
+    if (showHitboxes) {
+        SDL_SetRenderDrawColor(renderer, 255, 0, 0, SDL_ALPHA_OPAQUE);
+        SDL_Rect hitbox = getPlayerHitbox(p);
+        SDL_RenderDrawRect(renderer, &hitbox);
+    }
+}
+
+
+
+void InGameState::checkCollision() {
+    for (int i = 0; i < opponents.size(); i++) {
+        Opponent o = opponents[i];
+        SDL_Rect opponentHitbox = getOpponentHitbox(o);
+        SDL_Rect playerHitbox = getPlayerHitbox(player);
+
+        if (o.x == o.targetX && o.y == o.targetY) {
+            opponents.erase(opponents.begin() + i);
+        } else if (SDL_HasIntersection(&playerHitbox, &opponentHitbox)) {
+            if (player.health > 1) {
+                player.health--;
+            } else {
+                this->changeRoom("ending");
+            }
+            opponents.erase(opponents.begin() + i);
+        }
+    }
+
+    for (int i = 0; i < items.size(); i++) {
+        Item item = items[i];
+        SDL_Rect itemHitbox = getItemHitbox(item);
+        SDL_Rect playerHitbox = getPlayerHitbox(player);
+
+        if (SDL_HasIntersection(&playerHitbox, &itemHitbox)) {
+            switch (item.type) {
+                case Type::HEALTH:
+                    if (player.health < 3) {
+                        player.health++;
+                        items.erase(items.begin() + i);
+                    }
+                    break;
+                case Type::DAMAGE:
+                    player.health--;
+                    items.erase(items.begin() + i);
+                    break;
+            }
+        }
+    }
+}
+
+
+void InGameState::renderItem(SDL_Renderer* renderer, Item i) const {
+    SDL_Texture* itemTexture = IMG_LoadTexture(
+            renderer, i.type == Type::HEALTH ? "./res/heart.png" : "./res/damage.png");
+    drawTexture(renderer, itemTexture, i.x, i.y, 24, 24);
+    SDL_DestroyTexture(itemTexture);
+
+    if (showHitboxes) {
+        SDL_SetRenderDrawColor(renderer, 255, 0, 0, SDL_ALPHA_OPAQUE);
+        SDL_Rect hitbox = getItemHitbox(i);
+        SDL_RenderDrawRect(renderer, &hitbox);
+    }
+}
+
+void InGameState::createOpponent() {
+    Opponent o;
+
+    int edge = rand() % 4;
+    switch (edge) {
+    case 0:
+        o.x = rand() % WINDOW_WIDTH;
+        o.y = -96;
+        o.targetY = WINDOW_HEIGHT + 96;
+        o.targetX = rand() % WINDOW_WIDTH;
+        break;
+    case 1:
+        o.x = rand() % WINDOW_WIDTH;
+        o.y = WINDOW_HEIGHT;
+        o.targetY = -96;
+        o.targetX = rand() % WINDOW_WIDTH;
+        break;
+    case 2:
+        o.x = -80;
+        o.y = rand() % WINDOW_HEIGHT;
+        o.targetX = WINDOW_WIDTH + 80;
+        o.targetY = rand() % WINDOW_HEIGHT;
+        break;
+    case 3:
+        o.x = WINDOW_WIDTH;
+        o.y = rand() % WINDOW_HEIGHT;
+        o.targetX = -80;
+        o.targetY = rand() % WINDOW_HEIGHT;
+        break;
+    }
+
+    opponents.push_back(o);
+}
+
+void InGameState::renderOpponent(SDL_Renderer* renderer, SDL_Texture* opponentTexture, Opponent o) const {
+    drawTexture(renderer, opponentTexture, o.x, o.y, 80, 96);
+
+    if (showHitboxes) {
+        SDL_SetRenderDrawColor(renderer, 255, 0, 0, SDL_ALPHA_OPAQUE);
+        SDL_Rect hitbox = getOpponentHitbox(o);
+        SDL_RenderDrawRect(renderer, &hitbox);
+    }
+}
+
+void InGameState::renderHUD(SDL_Renderer* renderer, SDL_Texture* heart) const {
+    SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
+    SDL_Rect bgRect = {0, 0, 30 * 3 + 15, 40};
+    SDL_RenderFillRect(renderer, &bgRect);
+
+    for (int i = 0; i < this->player.health; i++) {
+        drawTexture(renderer, heart, 10 + i * 30, 10, 24, 24);
+    }
+
+    TTF_Font *font = TTF_OpenFont("./res/font.ttf", 24);
+    int score = SDL_GetTicks() / 100;
+
+    int marginL = 90;
+    if (score > 9) marginL = 70;
+    if (score > 99) marginL = 50;
+    if (score > 999) marginL = 20;
+    if (score > 9999) marginL = 0;
+
+    SDL_Rect highRect = {WINDOW_WIDTH - 120 + marginL - 10, 0, 120, 40};
+    SDL_RenderFillRect(renderer, &highRect);
+
+
+    drawText(renderer, font, std::to_string(score),WINDOW_WIDTH - 120 + marginL, 10,
+             {255, 255, 255, SDL_ALPHA_OPAQUE});
+    TTF_CloseFont(font);
+}
+
+void InGameState::init() {
+    std::cout << "Game state initialized\n";
+    SDL_ShowCursor(SDL_ENABLE);
+    startTime = time(nullptr);
+}
+
+
+void InGameState::handleEvents(SDL_Event& event) {
+    if (event.type == SDL_KEYDOWN) {
+        switch (event.key.keysym.sym) {
+        case SDLK_ESCAPE:
+            std::cout << "Switching to main menu\n";
+            this->changeRoom("main_menu");
+            break;
+        default:
+            break;
+        }
+    }
+
+    if (event.type == SDL_KEYDOWN || event.type == SDL_KEYUP) {
+        bool isPressed = (event.type == SDL_KEYDOWN);
+        switch (event.key.keysym.sym) {
+        case SDLK_w:
+            keys[0] = isPressed;
+            break;
+        case SDLK_a:
+            keys[1] = isPressed;
+            break;
+        case SDLK_s:
+            keys[2] = isPressed;
+            break;
+        case SDLK_d:
+            keys[3] = isPressed;
+            break;
+        case SDLK_h:
+            if (isPressed) showHitboxes = !showHitboxes;
+            break;
+        }
+    }
+}
+
+void InGameState::update() {
+    checkCollision();
+
+    if (rand() % 100 == 0) createOpponent();
+
+    if (time(nullptr) - startTime > 5) {
+        startTime = time(nullptr);
+        spawnItem(Type::HEALTH);
+    }
+
+    for (Opponent& o : opponents) {
+        o.move(3);
+    }
+
+    int speed = 10;
+    if (keys[0]) player.moveY(speed * -1);
+    if (keys[1]) player.moveX(speed * -1);
+    if (keys[2]) player.moveY(speed);
+    if (keys[3]) player.moveX(speed);
+}
+
+void InGameState::render(SDL_Renderer* renderer, double deltaTime) {
+    SDL_RenderClear(renderer);
+
+    SDL_SetRenderDrawColor(renderer, 35, 39, 42, SDL_ALPHA_OPAQUE);
+
+    SDL_Texture* background = IMG_LoadTexture(renderer, "./res/background.png");
+    drawTexture(renderer, background, 0, 0, WINDOW_WIDTH, WINDOW_HEIGHT);
+
+    for (Item i : this->items) {
+        renderItem(renderer, i);
+    }
+
+    SDL_Texture* playerTexture = IMG_LoadTexture(renderer, "./res/player.png");
+    renderPlayer(renderer, playerTexture, this->player);
+
+    SDL_Texture* opponentTexture = IMG_LoadTexture(renderer, "./res/opponent.png");
+    for (Opponent o : this->opponents) {
+        renderOpponent(renderer, opponentTexture, o);
+    }
+
+    SDL_Texture* heart = IMG_LoadTexture(renderer, "./res/heart.png");
+    renderHUD(renderer, heart);
+
+    SDL_DestroyTexture(playerTexture);
+    SDL_DestroyTexture(opponentTexture);
+    SDL_DestroyTexture(heart);
+
+    SDL_RenderPresent(renderer);
+}

src/states/InGameState.h

@@ -1,22 +1,11 @@
+#ifndef INGAME_STATE_H
+#define INGAME_STATE_H
+
+#include "../entities/Opponent.h"
+#include "GameState.h"
 #include <vector>
-#include <time.h>
-
-#ifndef CPP_LEARNING_GAME_H
-#define CPP_LEARNING_GAME_H
-
-#include <SDL2/SDL.h>
 #include <SDL2/SDL_image.h>
 
-class Player {
-public:
-    int x = 40;
-    int y = 40;
-    int unsigned health = 3;
-
-    void moveX(int dx);
-    void moveY(int dy);
-};
-
 enum class Type {
     HEALTH,
     DAMAGE
@@ -29,33 +18,34 @@ struct Item {
     Type type;
 };
 
-class Opponent : public Player {
-public:
-    int targetX = 0;
-    int targetY = 0;
-    void move(int multiplier);
-};
-
-class Game {
+class InGameState final : public GameState {
     Player player;
     std::vector<Opponent> opponents;
     std::vector<Item> items;
+    int startTime = 0;
 
     bool showHitboxes = false;
 
     void renderPlayer(SDL_Renderer* renderer, SDL_Texture* player, Player p) const;
 
 public:
+    void init() override;
+    void handleEvents(SDL_Event& event) override;
+    void update() override;
+    void render(SDL_Renderer* renderer, double deltaTime) override;
+
+    SDL_Rect getPlayerHitbox(const Player &player) const;
+    SDL_Rect getOpponentHitbox(const Opponent& o) const;
+    SDL_Rect getItemHitbox(const Item& i) const;
+
     void spawnItem(Type type);
     void createOpponent();
     void checkCollision();
     void renderHUD(SDL_Renderer* renderer, SDL_Texture* heart) const;
     void renderItem(SDL_Renderer* renderer, Item i) const;
-    void render(SDL_Renderer* renderer, SDL_Texture* bg);
-    void run();
-
     void renderOpponent(SDL_Renderer* renderer, SDL_Texture* opponentTexture, Opponent o) const;
+
+
 };
 
-
 #endif

src/states/MainMenuState.cpp

@@ -0,0 +1,76 @@
+#include "MainMenuState.h"
+#include <iostream>
+#include <SDL_image.h>
+
+#include "../Renderer.h"
+
+int mouseX = 0;
+int mouseY = 0;
+
+int randomR = 255;
+int randomG = 255;
+int randomB = 255;
+
+int randomSkip = 0;
+
+void MainMenuState::update() {
+    // hide cursor
+}
+
+void MainMenuState::init() {
+    std::cout << "Main menu state initialized\n";
+    SDL_ShowCursor(SDL_DISABLE);
+}
+
+void MainMenuState::handleEvents(SDL_Event& event) {
+    if (event.type == SDL_KEYDOWN) {
+        switch (event.key.keysym.sym) {
+        case SDLK_RETURN:
+            std::cout << "Switching to game state\n";
+            break;
+        case SDLK_ESCAPE:
+            std::cout << "Exiting game\n";
+            this->changeRoom("exit");
+            break;
+        default:
+            break;
+        }
+    }
+
+    if (event.type == SDL_MOUSEBUTTONDOWN) {
+        this->changeRoom("game");
+    }
+
+    if (event.type == SDL_MOUSEMOTION) {
+        mouseX = event.motion.x;
+        mouseY = event.motion.y;
+    }
+}
+
+void MainMenuState::render(SDL_Renderer* renderer, double deltaTime) {
+    SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
+    SDL_RenderClear(renderer);
+
+    SDL_Texture* title = IMG_LoadTexture(renderer, "./res/logo.png");
+
+    drawTexture(renderer, title, WINDOW_WIDTH/2-115, 100, 230, 125);
+
+    SDL_SetRenderDrawColor(renderer, 255, 255, 255, SDL_ALPHA_OPAQUE);
+    drawCircle(renderer, mouseX, mouseY, 10);
+    TTF_Font *font = TTF_OpenFont("./res/font.ttf", 24);
+
+    while (randomSkip == 30) {
+        randomR = rand() % 200 + 55;
+        randomG = rand() % 200 + 55;
+        randomB = rand() % 200 + 55;
+        randomSkip = 0;
+    }
+
+    drawText(renderer, font, "Click to Start", WINDOW_WIDTH/2-160, 320, {randomR, randomG, randomB, SDL_ALPHA_OPAQUE});
+
+    randomSkip++;
+
+    SDL_RenderPresent(renderer);
+
+    SDL_Delay(deltaTime < 16 ? 16 - deltaTime : 0);
+}

src/states/MainMenuState.h

@@ -0,0 +1,16 @@
+#ifndef MAIN_MNU_STATE_H
+#define MAIN_MNU_STATE_H
+
+#include "GameState.h"
+#include <SDL2/SDL.h>
+#include <SDL2/SDL_ttf.h>
+
+class MainMenuState final : public GameState {
+public:
+    void init() override;
+    void handleEvents(SDL_Event& event) override;
+    void update() override;
+    void render(SDL_Renderer* renderer, double deltaTime) override;
+};
+
+#endif