Create Renderer#drawCircle

CMakeLists.txt

@@ -22,6 +22,8 @@ add_executable(Obstacle
         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)

README.md

@@ -1,7 +1,7 @@
 <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" height="200">
+    <img src="https://git.gnm.dev/Mathias/ObstacleGame/raw/branch/main/res/logo.png" alt="Logo" width="200">
   </a>
 </div>
 

src/Renderer.cpp

@@ -1,5 +1,38 @@
 #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;
@@ -15,8 +48,8 @@ void drawTexture(SDL_Renderer *renderer, SDL_Texture *texture, int x, int y, int
     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});
+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/Renderer.h

@@ -8,6 +8,7 @@
 #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, const std::string text, int x, int y);
+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/main.cpp

@@ -1,10 +1,12 @@
 #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();
@@ -12,18 +14,28 @@ int main() {
     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_ACCELERATED);
+    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) {
@@ -33,7 +45,7 @@ int main() {
         }
 
         currentState->update();
-        currentState->render(renderer);
+        currentState->render(renderer, deltaTime);
 
         if (!currentState->getNextState().empty()) {
             std::string nextStateName = currentState->getNextState();
@@ -45,8 +57,6 @@ int main() {
             }
             currentState->clearNextState();
         }
-
-        SDL_Delay(16);
     }
 
     SDL_DestroyRenderer(renderer);

src/states/EndingState.cpp

@@ -0,0 +1,37 @@
+#include "EndingState.h"
+#include "../Renderer.h"
+#include <iostream>
+#include <SDL_image.h>
+
+void EndingState::init() {
+    SDL_ShowCursor(SDL_ENABLE);
+    std::cout << "Ending state initialized\n";
+}
+
+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});
+
+    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

@@ -14,7 +14,7 @@ public:
     virtual void init() = 0;
     virtual void handleEvents(SDL_Event& event) = 0;
     virtual void update() = 0;
-    virtual void render(SDL_Renderer* renderer) = 0;
+    virtual void render(SDL_Renderer* renderer, double deltaTime) = 0;
 
     void changeRoom(const std::string& stateName) {
         nextStateName = stateName;

src/states/InGameState.cpp

@@ -33,11 +33,11 @@ void InGameState::checkCollision() {
             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) {
+            if (player.health > 1) {
                 player.health--;
             }
             else {
-                // TODO: Game over sccreen
+                this->changeRoom("ending");
             }
 
             opponents.erase(opponents.begin() + i);
@@ -50,6 +50,7 @@ void InGameState::checkCollision() {
             switch (item.type) {
             case Type::HEALTH:
                 if (player.health < 3) {
+                    items.erase(items.begin() + i);
                     player.health++;
                 }
                 break;
@@ -58,7 +59,6 @@ void InGameState::checkCollision() {
                 break;
             }
 
-            items.erase(items.begin() + i);
         }
     }
 }
@@ -141,6 +141,8 @@ void InGameState::renderHUD(SDL_Renderer* renderer, SDL_Texture* heart) const {
 }
 
 void InGameState::init() {
+    std::cout << "Game state initialized\n";
+    SDL_ShowCursor(SDL_ENABLE);
     startTime = time(nullptr);
 }
 
@@ -190,16 +192,17 @@ void InGameState::update() {
     }
 
     for (Opponent& o : opponents) {
-        o.move(10);
+        o.move(3);
     }
 
-    if (keys[0]) player.moveY(-20);
-    if (keys[1]) player.moveX(-20);
-    if (keys[2]) player.moveY(20);
-    if (keys[3]) player.moveX(20);
+    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) {
+void InGameState::render(SDL_Renderer* renderer, double deltaTime) {
     SDL_RenderClear(renderer);
 
     SDL_SetRenderDrawColor(renderer, 35, 39, 42, SDL_ALPHA_OPAQUE);
@@ -207,6 +210,10 @@ void InGameState::render(SDL_Renderer* renderer) {
     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);
 
@@ -215,10 +222,6 @@ void InGameState::render(SDL_Renderer* renderer) {
         renderOpponent(renderer, opponentTexture, o);
     }
 
-    for (Item i : this->items) {
-        renderItem(renderer, i);
-    }
-
     SDL_Texture* heart = IMG_LoadTexture(renderer, "./res/heart.png");
     renderHUD(renderer, heart);
 

src/states/InGameState.h

@@ -32,7 +32,7 @@ public:
     void init() override;
     void handleEvents(SDL_Event& event) override;
     void update() override;
-    void render(SDL_Renderer* renderer) override;
+    void render(SDL_Renderer* renderer, double deltaTime) override;
 
     void spawnItem(Type type);
     void createOpponent();

src/states/MainMenuState.cpp

@@ -4,12 +4,22 @@
 
 #include "../Renderer.h"
 
+int mouseX = 0;
+int mouseY = 0;
+
+int randomR = 255;
+int randomG = 255;
+int randomB = 255;
+
+int randomSkip = 0;
+
 void MainMenuState::update() {
-    // Handle updates like animations if necessary
+    // hide cursor
 }
 
 void MainMenuState::init() {
     std::cout << "Main menu state initialized\n";
+    SDL_ShowCursor(SDL_DISABLE);
 }
 
 void MainMenuState::handleEvents(SDL_Event& event) {
@@ -32,18 +42,35 @@ void MainMenuState::handleEvents(SDL_Event& event) {
     }
 
     if (event.type == SDL_MOUSEMOTION) {
-        std::cout << "Mouse moved\n";
+        mouseX = event.motion.x;
+        mouseY = event.motion.y;
     }
 }
 
-void MainMenuState::render(SDL_Renderer* renderer) {
+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-75, 100, 150, 150);
+    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

@@ -10,7 +10,7 @@ public:
     void init() override;
     void handleEvents(SDL_Event& event) override;
     void update() override;
-    void render(SDL_Renderer* renderer) override;
+    void render(SDL_Renderer* renderer, double deltaTime) override;
 };
 
 #endif