ReiMerc/zombo-shooter
1
0
Fork 0
Code Issues 1 Pull Requests Actions Packages Projects Releases Wiki Activity

Fix indentation

Browse Source
This commit is contained in:
Reimar 2025-11-03 14:09:23 +01:00
parent fda8d5ffe8
commit 35569defc2
14 changed files with 270 additions and 270 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

16
src/Arrow.cpp
View File

@ -4,16 +4,16 @@
void Arrow::draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const void Arrow::draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const
{ {
renderer->draw_sprite_rotated( renderer->draw_sprite_rotated(
sprite, sprite,
(int)(x - sprite.width / 2 + renderer->screen_width / 2 - player_x), (int)(x - sprite.width / 2 + renderer->screen_width / 2 - player_x),
(int)(y - sprite.height / 2 + renderer->screen_height / 2 - player_y), (int)(y - sprite.height / 2 + renderer->screen_height / 2 - player_y),
angle * 180 / std::numbers::pi angle * 180 / std::numbers::pi
); );
} }
void Arrow::update() void Arrow::update()
{ {
x += std::cos(angle) * speed; x += std::cos(angle) * speed;
y += std::sin(angle) * speed; y += std::sin(angle) * speed;
} }

14
src/Arrow.hpp
View File

@ -8,18 +8,18 @@
class Arrow class Arrow
{ {
private: private:
double x; double x;
double y; double y;
double angle; double angle;
static constexpr int speed = 5; static constexpr int speed = 5;
public: public:
Arrow(double x, double y, double angle) : x(x), y(y), angle(angle) {} Arrow(double x, double y, double angle) : x(x), y(y), angle(angle) {}
void draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const; void draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const;
void update(); void update();
}; };
#endif #endif

164
src/Game.cpp
View File

@ -8,120 +8,120 @@ using namespace std::literals::chrono_literals;
Game::Game() : renderer("Zombo Shooter", 800, 450), player(&renderer), map(&renderer, 40) Game::Game() : renderer("Zombo Shooter", 800, 450), player(&renderer), map(&renderer, 40)
{ {
arrow_sprite = renderer.load_sprite("./assets/arrow.png", 22, 8); arrow_sprite = renderer.load_sprite("./assets/arrow.png", 22, 8);
zombo_sprite = renderer.load_sprite("./assets/zombo.png", 40, 40); zombo_sprite = renderer.load_sprite("./assets/zombo.png", 40, 40);
} }
void Game::update(std::stop_token stop_token) void Game::update(std::stop_token stop_token)
{ {
while (!stop_token.stop_requested()) { while (!stop_token.stop_requested()) {
game_mutex.lock(); game_mutex.lock();
ticks++; ticks++;
player.update(); player.update();
for (Arrow &arrow : arrows) { for (Arrow &arrow : arrows) {
arrow.update(); arrow.update();
} }
for (Zombo &zombo : zombos) { for (Zombo &zombo : zombos) {
zombo.update(player.x, player.y); zombo.update(player.x, player.y);
} }
if (ticks % 100 == 0 && zombos.size() < 20) { if (ticks % 100 == 0 && zombos.size() < 20) {
zombos.emplace_back(20.0, 20.0); zombos.emplace_back(20.0, 20.0);
} }
renderer.redraw(); renderer.redraw();
map.check_bounds(player.x, player.y); map.check_bounds(player.x, player.y);
game_mutex.unlock(); game_mutex.unlock();
std::this_thread::sleep_for(16666us); std::this_thread::sleep_for(16666us);
} }
} }
void Game::draw() void Game::draw()
{ {
const std::lock_guard lock(game_mutex); const std::lock_guard lock(game_mutex);
renderer.clear_screen(0x80, 0x40, 0xFF, 0xFF); renderer.clear_screen(0x80, 0x40, 0xFF, 0xFF);
map.draw(player.x, player.y); map.draw(player.x, player.y);
for (const Zombo &zombo : zombos) { for (const Zombo &zombo : zombos) {
zombo.draw(&renderer, *zombo_sprite, player.x, player.y); zombo.draw(&renderer, *zombo_sprite, player.x, player.y);
} }
for (const Arrow &arrow : arrows) { for (const Arrow &arrow : arrows) {
arrow.draw(&renderer, *arrow_sprite, player.x, player.y); arrow.draw(&renderer, *arrow_sprite, player.x, player.y);
} }
player.draw(); player.draw();
renderer.flush(); renderer.flush();
} }
void Game::run() void Game::run()
{ {
std::jthread update_thread = std::jthread(std::bind_front(&Game::update, this)); std::jthread update_thread = std::jthread(std::bind_front(&Game::update, this));
while (true) { while (true) {
SDL_Event e; SDL_Event e;
SDL_WaitEvent(&e); SDL_WaitEvent(&e);
if (e.type == SDL_QUIT) { if (e.type == SDL_QUIT) {
break; break;
} }
if (e.type == SDL_KEYDOWN) { if (e.type == SDL_KEYDOWN) {
switch (e.key.keysym.sym) { switch (e.key.keysym.sym) {
case SDLK_RIGHT: case SDLK_RIGHT:
case SDLK_d: case SDLK_d:
player.x_vel = player.speed; player.x_vel = player.speed;
break; break;
case SDLK_LEFT: case SDLK_LEFT:
case SDLK_a: case SDLK_a:
player.x_vel = -player.speed; player.x_vel = -player.speed;
break; break;
case SDLK_DOWN: case SDLK_DOWN:
case SDLK_s: case SDLK_s:
player.y_vel = player.speed; player.y_vel = player.speed;
break; break;
case SDLK_UP: case SDLK_UP:
case SDLK_w: case SDLK_w:
player.y_vel = -player.speed; player.y_vel = -player.speed;
break; break;
} }
} }
if (e.type == SDL_KEYUP) { if (e.type == SDL_KEYUP) {
switch (e.key.keysym.sym) { switch (e.key.keysym.sym) {
case SDLK_RIGHT: case SDLK_RIGHT:
case SDLK_d: case SDLK_d:
case SDLK_LEFT: case SDLK_LEFT:
case SDLK_a: case SDLK_a:
player.x_vel = 0; player.x_vel = 0;
break; break;
case SDLK_DOWN: case SDLK_DOWN:
case SDLK_s: case SDLK_s:
case SDLK_UP: case SDLK_UP:
case SDLK_w: case SDLK_w:
player.y_vel = 0; player.y_vel = 0;
break; break;
} }
} }
if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == 1) { if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == 1) {
arrows.emplace_back(player.x, player.y, player.angle); arrows.emplace_back(player.x, player.y, player.angle);
} }
int mouse_x, mouse_y; int mouse_x, mouse_y;
SDL_GetMouseState(&mouse_x, &mouse_y); SDL_GetMouseState(&mouse_x, &mouse_y);
player.angle = std::atan2(mouse_y - renderer.screen_height / 2, mouse_x - renderer.screen_width / 2); player.angle = std::atan2(mouse_y - renderer.screen_height / 2, mouse_x - renderer.screen_width / 2);
draw(); draw();
} }
} }

26
src/Game.hpp
View File

@ -12,26 +12,26 @@
class Game class Game
{ {
private: private:
GameRenderer renderer; GameRenderer renderer;
Player player; Player player;
Map map; Map map;
std::vector<Arrow> arrows; std::vector<Arrow> arrows;
std::vector<Zombo> zombos; std::vector<Zombo> zombos;
std::unique_ptr<Sprite> arrow_sprite, zombo_sprite; std::unique_ptr<Sprite> arrow_sprite, zombo_sprite;
std::mutex game_mutex; std::mutex game_mutex;
unsigned int ticks = 0; unsigned int ticks = 0;
void update(std::stop_token stop_token); void update(std::stop_token stop_token);
public: public:
Game(); Game();
~Game() = default; ~Game() = default;
void run(); void run();
void draw(); void draw();
}; };
#endif #endif

28
src/GameRenderer.hpp
View File

@ -9,32 +9,32 @@
class GameRenderer class GameRenderer
{ {
private: private:
SDL_Renderer *renderer; SDL_Renderer *renderer;
SDL_Window *window; SDL_Window *window;
std::string title; std::string title;
public: public:
int screen_width; int screen_width;
int screen_height; int screen_height;
GameRenderer(const std::string &title, int screen_width, int screen_height); GameRenderer(const std::string &title, int screen_width, int screen_height);
~GameRenderer(); ~GameRenderer();
std::unique_ptr<Sprite> load_sprite(const std::string &file, int width, int height) const; std::unique_ptr<Sprite> load_sprite(const std::string &file, int width, int height) const;
void draw_sprite(const Sprite &sprite, int x, int y) const; void draw_sprite(const Sprite &sprite, int x, int y) const;
void draw_sprite_flipped(const Sprite &sprite, int x, int y) const; void draw_sprite_flipped(const Sprite &sprite, int x, int y) const;
void draw_sprite_rotated(const Sprite &sprite, int x, int y, double angle) const; void draw_sprite_rotated(const Sprite &sprite, int x, int y, double angle) const;
void clear_screen(uint8_t r, uint8_t g, uint8_t b, uint8_t a) const; void clear_screen(uint8_t r, uint8_t g, uint8_t b, uint8_t a) const;
void flush() const; void flush() const;
void redraw() const; void redraw() const;
}; };
#endif #endif

154
src/Map.cpp
View File

@ -2,110 +2,110 @@
#include "Map.hpp" #include "Map.hpp"
Map::Map(GameRenderer *renderer, int tile_size) : Map::Map(GameRenderer *renderer, int tile_size) :
renderer(renderer), renderer(renderer),
tile_size(tile_size), tile_size(tile_size),
tiles(renderer->screen_width / tile_size, std::vector(renderer->screen_height / tile_size, Tile::grass)), tiles(renderer->screen_width / tile_size, std::vector(renderer->screen_height / tile_size, Tile::grass)),
tile_offset_x(-renderer->screen_width / tile_size / 2.0), tile_offset_x(-renderer->screen_width / tile_size / 2.0),
tile_offset_y(-renderer->screen_height / tile_size / 2.0) tile_offset_y(-renderer->screen_height / tile_size / 2.0)
{ {
grass_sprite = renderer->load_sprite("./assets/grass_tile.png", tile_size, tile_size); grass_sprite = renderer->load_sprite("./assets/grass_tile.png", tile_size, tile_size);
path_sprite = renderer->load_sprite("./assets/path_tile.png", tile_size, tile_size); path_sprite = renderer->load_sprite("./assets/path_tile.png", tile_size, tile_size);
// Create horizontal starting path // Create horizontal starting path
int y = renderer->screen_height / tile_size / 2; int y = renderer->screen_height / tile_size / 2;
for (unsigned int x = 0; x < tiles.size(); x++) { for (unsigned int x = 0; x < tiles.size(); x++) {
if (rand() % 2 == 0) y += rand() % 3 - 1; if (rand() % 2 == 0) y += rand() % 3 - 1;
tiles[x][y] = Tile::path; tiles[x][y] = Tile::path;
} }
// Create vertical starting path // Create vertical starting path
int x = renderer->screen_width / tile_size / 2; int x = renderer->screen_width / tile_size / 2;
for (unsigned int y = 0; y < tiles[x].size(); y++) { for (unsigned int y = 0; y < tiles[x].size(); y++) {
if (rand() % 2 == 0) x += rand() % 3 - 1; if (rand() % 2 == 0) x += rand() % 3 - 1;
tiles[x][y] = Tile::path; tiles[x][y] = Tile::path;
} }
} }
std::vector<Tile> Map::generate_tiles(const std::vector<Tile> &prev_tiles) const std::vector<Tile> Map::generate_tiles(const std::vector<Tile> &prev_tiles) const
{ {
std::vector<Tile> new_tiles = std::vector(prev_tiles.size(), Tile::grass); std::vector<Tile> new_tiles = std::vector(prev_tiles.size(), Tile::grass);
int path_idx = 0; int path_idx = 0;
for (unsigned int i = 0; i < prev_tiles.size(); i++) { for (unsigned int i = 0; i < prev_tiles.size(); i++) {
if (prev_tiles[i] == Tile::path) path_idx = i; if (prev_tiles[i] == Tile::path) path_idx = i;
} }
if (rand() % 2 == 0) path_idx += rand() % 3 - 1; if (rand() % 2 == 0) path_idx += rand() % 3 - 1;
new_tiles[path_idx] = Tile::path; new_tiles[path_idx] = Tile::path;
return new_tiles; return new_tiles;
} }
void Map::check_bounds(const double player_x, const double player_y) void Map::check_bounds(const double player_x, const double player_y)
{ {
// Generate to the left // Generate to the left
if (tile_offset_x * tile_size + renderer->screen_width > player_x) { if (tile_offset_x * tile_size + renderer->screen_width > player_x) {
const std::vector<Tile> new_tiles = generate_tiles(tiles[0]); const std::vector<Tile> new_tiles = generate_tiles(tiles[0]);
tiles.insert(tiles.begin(), new_tiles); tiles.insert(tiles.begin(), new_tiles);
tile_offset_x--; tile_offset_x--;
} }
// Generate upwards // Generate upwards
if (tile_offset_y * tile_size + renderer->screen_height > player_y) { if (tile_offset_y * tile_size + renderer->screen_height > player_y) {
std::vector<Tile> prev_tiles; std::vector<Tile> prev_tiles;
for (unsigned int x = 0; x < tiles.size(); x++) { for (unsigned int x = 0; x < tiles.size(); x++) {
prev_tiles.push_back(tiles[x][0]); prev_tiles.push_back(tiles[x][0]);
} }
const std::vector<Tile> new_tiles = generate_tiles(prev_tiles); const std::vector<Tile> new_tiles = generate_tiles(prev_tiles);
for (unsigned int x = 0; x < tiles.size(); x++) { for (unsigned int x = 0; x < tiles.size(); x++) {
tiles[x].insert(tiles[x].begin(), new_tiles[x]); tiles[x].insert(tiles[x].begin(), new_tiles[x]);
} }
tile_offset_y--; tile_offset_y--;
} }
// Generate to the right // Generate to the right
if (player_x > tile_offset_x * tile_size + (double)tiles.size() * tile_size - renderer->screen_width / 2) { if (player_x > tile_offset_x * tile_size + (double)tiles.size() * tile_size - renderer->screen_width / 2) {
const std::vector<Tile> new_tiles = generate_tiles(tiles.back()); const std::vector<Tile> new_tiles = generate_tiles(tiles.back());
tiles.push_back(new_tiles); tiles.push_back(new_tiles);
} }
// Generate downwards // Generate downwards
if (player_y > tile_offset_y * tile_size + (double)tiles[0].size() * tile_size - renderer->screen_height / 2) { if (player_y > tile_offset_y * tile_size + (double)tiles[0].size() * tile_size - renderer->screen_height / 2) {
std::vector<Tile> prev_tiles; std::vector<Tile> prev_tiles;
for (unsigned int x = 0; x < tiles.size(); x++) { for (unsigned int x = 0; x < tiles.size(); x++) {
prev_tiles.push_back(tiles[x].back()); prev_tiles.push_back(tiles[x].back());
} }
const std::vector<Tile> new_tiles = generate_tiles(prev_tiles); const std::vector<Tile> new_tiles = generate_tiles(prev_tiles);
for (unsigned int x = 0; x < tiles.size(); x++) { for (unsigned int x = 0; x < tiles.size(); x++) {
tiles[x].push_back(new_tiles[x]); tiles[x].push_back(new_tiles[x]);
} }
} }
} }
void Map::draw(const double player_x, const double player_y) const void Map::draw(const double player_x, const double player_y) const
{ {
for (unsigned int tile_x = 0; tile_x < tiles.size(); tile_x++) { for (unsigned int tile_x = 0; tile_x < tiles.size(); tile_x++) {
for (unsigned int tile_y = 0; tile_y < tiles[tile_x].size(); tile_y++) { for (unsigned int tile_y = 0; tile_y < tiles[tile_x].size(); tile_y++) {
int screen_x = (int)(tile_x * tile_size + tile_offset_x * tile_size + renderer->screen_width / 2.0 - player_x); int screen_x = (int)(tile_x * tile_size + tile_offset_x * tile_size + renderer->screen_width / 2.0 - player_x);
int screen_y = (int)(tile_y * tile_size + tile_offset_y * tile_size + renderer->screen_height / 2.0 - player_y); int screen_y = (int)(tile_y * tile_size + tile_offset_y * tile_size + renderer->screen_height / 2.0 - player_y);
if ( if (
screen_x < -tile_size || screen_y < -tile_size || screen_x < -tile_size || screen_y < -tile_size ||
screen_x > renderer->screen_width || screen_y > renderer->screen_height screen_x > renderer->screen_width || screen_y > renderer->screen_height
) { ) {
continue; continue;
} }
switch (tiles[tile_x][tile_y]) { switch (tiles[tile_x][tile_y]) {
case Tile::grass: renderer->draw_sprite(*grass_sprite, screen_x, screen_y); break; case Tile::grass: renderer->draw_sprite(*grass_sprite, screen_x, screen_y); break;
case Tile::path: renderer->draw_sprite(*path_sprite, screen_x, screen_y); break; case Tile::path: renderer->draw_sprite(*path_sprite, screen_x, screen_y); break;
} }
} }
} }
} }

22
src/Map.hpp
View File

@ -10,25 +10,25 @@
class Map class Map
{ {
private: private:
GameRenderer *renderer; GameRenderer *renderer;
std::vector<std::vector<Tile>> tiles; std::vector<std::vector<Tile>> tiles;
std::unique_ptr<Sprite> grass_sprite, path_sprite; std::unique_ptr<Sprite> grass_sprite, path_sprite;
[[nodiscard]] std::vector<Tile> generate_tiles(const std::vector<Tile> &prev_tiles) const; [[nodiscard]] std::vector<Tile> generate_tiles(const std::vector<Tile> &prev_tiles) const;
public: public:
double tile_offset_x; double tile_offset_x;
double tile_offset_y; double tile_offset_y;
int tile_size; int tile_size;
Map(GameRenderer *renderer, int tile_size); Map(GameRenderer *renderer, int tile_size);
~Map() = default; ~Map() = default;
void draw(double player_x, double player_y) const; void draw(double player_x, double player_y) const;
void check_bounds(double player_x, double player_y); void check_bounds(double player_x, double player_y);
}; };
#endif #endif

30
src/Player.cpp
View File

@ -4,28 +4,28 @@
Player::Player(GameRenderer *renderer) : renderer(renderer) Player::Player(GameRenderer *renderer) : renderer(renderer)
{ {
hero_sprite = renderer->load_sprite("./assets/hero_front.png", 40, 40); hero_sprite = renderer->load_sprite("./assets/hero_front.png", 40, 40);
bow_sprite = renderer->load_sprite("./assets/bow_arrow.png", 22, 32); bow_sprite = renderer->load_sprite("./assets/bow_arrow.png", 22, 32);
} }
void Player::draw() const void Player::draw() const
{ {
renderer->draw_sprite( renderer->draw_sprite(
*hero_sprite, *hero_sprite,
renderer->screen_width / 2 - hero_sprite->width / 2, renderer->screen_width / 2 - hero_sprite->width / 2,
renderer->screen_height / 2 - hero_sprite->height / 2 renderer->screen_height / 2 - hero_sprite->height / 2
); );
renderer->draw_sprite_rotated( renderer->draw_sprite_rotated(
*bow_sprite, *bow_sprite,
(int)(renderer->screen_width / 2 - bow_sprite->width / 2 + std::cos(angle) * 30), (int)(renderer->screen_width / 2 - bow_sprite->width / 2 + std::cos(angle) * 30),
(int)(renderer->screen_height / 2 - bow_sprite->height / 2 + std::sin(angle) * 30), (int)(renderer->screen_height / 2 - bow_sprite->height / 2 + std::sin(angle) * 30),
angle * 180 / std::numbers::pi angle * 180 / std::numbers::pi
); );
} }
void Player::update() void Player::update()
{ {
x += x_vel; x += x_vel;
y += y_vel; y += y_vel;
} }

24
src/Player.hpp
View File

@ -7,27 +7,27 @@
class Player class Player
{ {
private: private:
GameRenderer *renderer; GameRenderer *renderer;
std::unique_ptr<Sprite> hero_sprite, bow_sprite; std::unique_ptr<Sprite> hero_sprite, bow_sprite;
public: public:
double x = 0; double x = 0;
double y = 0; double y = 0;
double x_vel = 0; double x_vel = 0;
double y_vel = 0; double y_vel = 0;
double angle = 0.0; double angle = 0.0;
static constexpr double speed = 1.5; static constexpr double speed = 1.5;
Player(GameRenderer *renderer); Player(GameRenderer *renderer);
~Player() = default; ~Player() = default;
void draw() const; void draw() const;
void update(); void update();
}; };
#endif #endif

4
src/Sprite.cpp
View File

@ -4,10 +4,10 @@
Sprite::Sprite(SDL_Renderer *renderer, const std::string &file, int width, int height) : width(width), height(height) Sprite::Sprite(SDL_Renderer *renderer, const std::string &file, int width, int height) : width(width), height(height)
{ {
texture = IMG_LoadTexture(renderer, file.c_str()); texture = IMG_LoadTexture(renderer, file.c_str());
} }
Sprite::~Sprite() Sprite::~Sprite()
{ {
SDL_DestroyTexture(texture); SDL_DestroyTexture(texture);
} }

18
src/Sprite.hpp
View File

@ -6,18 +6,18 @@
class Sprite { class Sprite {
public: public:
SDL_Texture *texture; SDL_Texture *texture;
int width; int width;
int height; int height;
Sprite(SDL_Renderer *renderer, const std::string &file, int width, int height); Sprite(SDL_Renderer *renderer, const std::string &file, int width, int height);
~Sprite(); ~Sprite();
Sprite(const Sprite&) = delete; Sprite(const Sprite&) = delete;
Sprite operator=(const Sprite&) = delete; Sprite operator=(const Sprite&) = delete;
Sprite(Sprite&&) = delete; Sprite(Sprite&&) = delete;
Sprite operator=(Sprite&&) = delete; Sprite operator=(Sprite&&) = delete;
}; };
#endif #endif

4
src/Tile.hpp
View File

@ -3,8 +3,8 @@
enum class Tile enum class Tile
{ {
grass, grass,
path, path,
}; };
#endif #endif

18
src/Zombo.cpp
View File

@ -2,19 +2,19 @@
void Zombo::update(const double player_x, const double player_y) void Zombo::update(const double player_x, const double player_y)
{ {
double angle = std::atan2(player_y - y, player_x - x); double angle = std::atan2(player_y - y, player_x - x);
x += std::cos(angle) * speed; x += std::cos(angle) * speed;
y += std::sin(angle) * speed; y += std::sin(angle) * speed;
} }
void Zombo::draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const void Zombo::draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const
{ {
int draw_x = (int)(x - sprite.width / 2 + renderer->screen_width / 2 - player_x); int draw_x = (int)(x - sprite.width / 2 + renderer->screen_width / 2 - player_x);
int draw_y = (int)(y - sprite.height / 2 + renderer->screen_height / 2 - player_y); int draw_y = (int)(y - sprite.height / 2 + renderer->screen_height / 2 - player_y);
if (x < player_x) if (x < player_x)
renderer->draw_sprite(sprite, draw_x, draw_y); renderer->draw_sprite(sprite, draw_x, draw_y);
else else
renderer->draw_sprite_flipped(sprite, draw_x, draw_y); renderer->draw_sprite_flipped(sprite, draw_x, draw_y);
} }

12
src/Zombo.hpp
View File

@ -8,17 +8,17 @@
class Zombo class Zombo
{ {
private: private:
double x; double x;
double y; double y;
static constexpr double speed = 0.5; static constexpr double speed = 0.5;
public: public:
Zombo(const double x, const double y) : x(x), y(y) {} Zombo(const double x, const double y) : x(x), y(y) {}
void update(double player_x, double player_y); void update(double player_x, double player_y);
void draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const; void draw(const GameRenderer *renderer, const Sprite &sprite, double player_x, double player_y) const;
}; };
#endif #endif