Compare commits

...

16 Commits

Author SHA1 Message Date
a870acda24 Fix items spawning at unreachable positions 2025-02-17 08:51:23 +01:00
128163df2a Update hitboxes 2024-12-09 09:20:17 +01:00
e5dc74257e Add high score 2024-12-09 09:07:41 +01:00
86feca9943 Create Renderer#drawCircle 2024-12-02 09:38:36 +01:00
ef72acbf0b Implement DeltaTime 2024-12-02 09:37:57 +01:00
69a957c6f6 Update game states 2024-12-02 09:37:49 +01:00
cc96b2aa1b Create EndingState 2024-12-02 09:37:39 +01:00
6ecbda7b44 Update README.md 2024-12-02 09:37:17 +01:00
38bf6601ed Update logo.png 2024-12-02 09:36:53 +01:00
824dd9e1f2 Update states 2024-11-25 22:30:59 +01:00
03aadf4163 Update README.md 2024-11-25 22:17:41 +01:00
0ff02760f2 Fix bug 2024-11-25 22:16:17 +01:00
0c85c17b0d Create README.md 2024-11-25 22:16:12 +01:00
50ffe0f575 Add logo.png 2024-11-25 22:08:15 +01:00
7401610cd0 Update CMakeLists.txt 2024-11-25 21:59:14 +01:00
d0c8bfa491 Make codebase modular 2024-11-25 21:59:07 +01:00
21 changed files with 709 additions and 349 deletions

View File

@ -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)

259
Game.cpp
View File

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

View File

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

View File

@ -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

View File

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

View File

@ -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.

BIN
res/logo.png Normal file

Binary file not shown.

After

Width:  |  Height:  |  Size: 397 KiB

70
src/Renderer.cpp Normal file
View File

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

14
src/Renderer.h Normal file
View File

@ -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

View File

@ -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;
}

8
src/entities/Opponent.h Normal file
View File

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

13
src/entities/Player.cpp Normal file
View File

@ -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;
}

11
src/entities/Player.h Normal file
View File

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

68
src/main.cpp Normal file
View File

@ -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;
}

View File

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

11
src/states/EndingState.h Normal file
View File

@ -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;
};

32
src/states/GameState.h Normal file
View File

@ -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

263
src/states/InGameState.cpp Normal file
View File

@ -0,0 +1,263 @@
#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;
if (item.x < 24) item.x += 24;
if (item.x > WINDOW_WIDTH - 24) item.x -= 24;
if (item.y < 24) item.y += 24;
if (item.y > WINDOW_HEIGHT - 24) item.y -= 24;
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);
}

View File

@ -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

View File

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

View File

@ -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