ObstacleGame/Game.cpp

#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);
}