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
{
renderer->draw_sprite_rotated(
sprite,
(int)(x - sprite.width / 2 + renderer->screen_width / 2 - player_x),
(int)(y - sprite.height / 2 + renderer->screen_height / 2 - player_y),
angle * 180 / std::numbers::pi
);
renderer->draw_sprite_rotated(
sprite,
(int)(x - sprite.width / 2 + renderer->screen_width / 2 - player_x),
(int)(y - sprite.height / 2 + renderer->screen_height / 2 - player_y),
angle * 180 / std::numbers::pi
);
}
void Arrow::update()
{
x += std::cos(angle) * speed;
y += std::sin(angle) * speed;
x += std::cos(angle) * speed;
y += std::sin(angle) * speed;
}

14
src/Arrow.hpp
View File

@ -8,18 +8,18 @@
class Arrow
{
private:
double x;
double y;
double angle;
double x;
double y;
double angle;
static constexpr int speed = 5;
static constexpr int speed = 5;
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

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)
{
arrow_sprite = renderer.load_sprite("./assets/arrow.png", 22, 8);
zombo_sprite = renderer.load_sprite("./assets/zombo.png", 40, 40);
arrow_sprite = renderer.load_sprite("./assets/arrow.png", 22, 8);
zombo_sprite = renderer.load_sprite("./assets/zombo.png", 40, 40);
}
void Game::update(std::stop_token stop_token)
{
while (!stop_token.stop_requested()) {
game_mutex.lock();
while (!stop_token.stop_requested()) {
game_mutex.lock();
ticks++;
ticks++;
player.update();
player.update();
for (Arrow &arrow : arrows) {
arrow.update();
}
for (Arrow &arrow : arrows) {
arrow.update();
}
for (Zombo &zombo : zombos) {
zombo.update(player.x, player.y);
}
for (Zombo &zombo : zombos) {
zombo.update(player.x, player.y);
}
if (ticks % 100 == 0 && zombos.size() < 20) {
zombos.emplace_back(20.0, 20.0);
}
if (ticks % 100 == 0 && zombos.size() < 20) {
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()
{
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) {
zombo.draw(&renderer, *zombo_sprite, player.x, player.y);
}
for (const Zombo &zombo : zombos) {
zombo.draw(&renderer, *zombo_sprite, player.x, player.y);
}
for (const Arrow &arrow : arrows) {
arrow.draw(&renderer, *arrow_sprite, player.x, player.y);
}
for (const Arrow &arrow : arrows) {
arrow.draw(&renderer, *arrow_sprite, player.x, player.y);
}
player.draw();
player.draw();
renderer.flush();
renderer.flush();
}
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) {
SDL_Event e;
SDL_WaitEvent(&e);
while (true) {
SDL_Event e;
SDL_WaitEvent(&e);
if (e.type == SDL_QUIT) {
break;
}
if (e.type == SDL_QUIT) {
break;
}
if (e.type == SDL_KEYDOWN) {
switch (e.key.keysym.sym) {
case SDLK_RIGHT:
case SDLK_d:
player.x_vel = player.speed;
break;
case SDLK_LEFT:
case SDLK_a:
player.x_vel = -player.speed;
break;
case SDLK_DOWN:
case SDLK_s:
player.y_vel = player.speed;
break;
case SDLK_UP:
case SDLK_w:
player.y_vel = -player.speed;
break;
}
}
if (e.type == SDL_KEYDOWN) {
switch (e.key.keysym.sym) {
case SDLK_RIGHT:
case SDLK_d:
player.x_vel = player.speed;
break;
case SDLK_LEFT:
case SDLK_a:
player.x_vel = -player.speed;
break;
case SDLK_DOWN:
case SDLK_s:
player.y_vel = player.speed;
break;
case SDLK_UP:
case SDLK_w:
player.y_vel = -player.speed;
break;
}
}
if (e.type == SDL_KEYUP) {
switch (e.key.keysym.sym) {
case SDLK_RIGHT:
case SDLK_d:
case SDLK_LEFT:
case SDLK_a:
player.x_vel = 0;
break;
case SDLK_DOWN:
case SDLK_s:
case SDLK_UP:
case SDLK_w:
player.y_vel = 0;
break;
}
}
if (e.type == SDL_KEYUP) {
switch (e.key.keysym.sym) {
case SDLK_RIGHT:
case SDLK_d:
case SDLK_LEFT:
case SDLK_a:
player.x_vel = 0;
break;
case SDLK_DOWN:
case SDLK_s:
case SDLK_UP:
case SDLK_w:
player.y_vel = 0;
break;
}
}
if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == 1) {
arrows.emplace_back(player.x, player.y, player.angle);
}
if (e.type == SDL_MOUSEBUTTONDOWN && e.button.button == 1) {
arrows.emplace_back(player.x, player.y, player.angle);
}
int 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);
int 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);
draw();
}
draw();
}
}

26
src/Game.hpp
View File

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

30
src/GameRenderer.hpp
View File

@ -9,32 +9,32 @@
class GameRenderer
{
private:
SDL_Renderer *renderer;
SDL_Window *window;
SDL_Renderer *renderer;
SDL_Window *window;
std::string title;
std::string title;
public:
int screen_width;
int screen_height;
int screen_width;
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"
Map::Map(GameRenderer *renderer, int tile_size) :
renderer(renderer),
tile_size(tile_size),
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_y(-renderer->screen_height / tile_size / 2.0)
renderer(renderer),
tile_size(tile_size),
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_y(-renderer->screen_height / tile_size / 2.0)
{
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);
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);
// Create horizontal starting path
int y = renderer->screen_height / tile_size / 2;
for (unsigned int x = 0; x < tiles.size(); x++) {
if (rand() % 2 == 0) y += rand() % 3 - 1;
// Create horizontal starting path
int y = renderer->screen_height / tile_size / 2;
for (unsigned int x = 0; x < tiles.size(); x++) {
if (rand() % 2 == 0) y += rand() % 3 - 1;
tiles[x][y] = Tile::path;
}
tiles[x][y] = Tile::path;
}
// Create vertical starting path
int x = renderer->screen_width / tile_size / 2;
for (unsigned int y = 0; y < tiles[x].size(); y++) {
if (rand() % 2 == 0) x += rand() % 3 - 1;
// Create vertical starting path
int x = renderer->screen_width / tile_size / 2;
for (unsigned int y = 0; y < tiles[x].size(); y++) {
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> 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;
for (unsigned int i = 0; i < prev_tiles.size(); i++) {
if (prev_tiles[i] == Tile::path) path_idx = i;
}
int path_idx = 0;
for (unsigned int i = 0; i < prev_tiles.size(); 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)
{
// Generate to the left
if (tile_offset_x * tile_size + renderer->screen_width > player_x) {
const std::vector<Tile> new_tiles = generate_tiles(tiles[0]);
tiles.insert(tiles.begin(), new_tiles);
tile_offset_x--;
}
// Generate to the left
if (tile_offset_x * tile_size + renderer->screen_width > player_x) {
const std::vector<Tile> new_tiles = generate_tiles(tiles[0]);
tiles.insert(tiles.begin(), new_tiles);
tile_offset_x--;
}
// Generate upwards
if (tile_offset_y * tile_size + renderer->screen_height > player_y) {
std::vector<Tile> prev_tiles;
for (unsigned int x = 0; x < tiles.size(); x++) {
prev_tiles.push_back(tiles[x][0]);
}
// Generate upwards
if (tile_offset_y * tile_size + renderer->screen_height > player_y) {
std::vector<Tile> prev_tiles;
for (unsigned int x = 0; x < tiles.size(); x++) {
prev_tiles.push_back(tiles[x][0]);
}
const std::vector<Tile> new_tiles = generate_tiles(prev_tiles);
for (unsigned int x = 0; x < tiles.size(); x++) {
tiles[x].insert(tiles[x].begin(), new_tiles[x]);
}
const std::vector<Tile> new_tiles = generate_tiles(prev_tiles);
for (unsigned int x = 0; x < tiles.size(); x++) {
tiles[x].insert(tiles[x].begin(), new_tiles[x]);
}
tile_offset_y--;
}
tile_offset_y--;
}
// Generate to the right
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());
tiles.push_back(new_tiles);
}
// Generate to the right
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());
tiles.push_back(new_tiles);
}
// Generate downwards
if (player_y > tile_offset_y * tile_size + (double)tiles[0].size() * tile_size - renderer->screen_height / 2) {
std::vector<Tile> prev_tiles;
for (unsigned int x = 0; x < tiles.size(); x++) {
prev_tiles.push_back(tiles[x].back());
}
// Generate downwards
if (player_y > tile_offset_y * tile_size + (double)tiles[0].size() * tile_size - renderer->screen_height / 2) {
std::vector<Tile> prev_tiles;
for (unsigned int x = 0; x < tiles.size(); x++) {
prev_tiles.push_back(tiles[x].back());
}
const std::vector<Tile> new_tiles = generate_tiles(prev_tiles);
for (unsigned int x = 0; x < tiles.size(); x++) {
tiles[x].push_back(new_tiles[x]);
}
}
const std::vector<Tile> new_tiles = generate_tiles(prev_tiles);
for (unsigned int x = 0; x < tiles.size(); x++) {
tiles[x].push_back(new_tiles[x]);
}
}
}
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_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_y = (int)(tile_y * tile_size + tile_offset_y * tile_size + renderer->screen_height / 2.0 - player_y);
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++) {
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);
if (
screen_x < -tile_size || screen_y < -tile_size ||
screen_x > renderer->screen_width || screen_y > renderer->screen_height
) {
continue;
}
if (
screen_x < -tile_size || screen_y < -tile_size ||
screen_x > renderer->screen_width || screen_y > renderer->screen_height
) {
continue;
}
switch (tiles[tile_x][tile_y]) {
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;
}
}
}
switch (tiles[tile_x][tile_y]) {
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;
}
}
}
}

22
src/Map.hpp
View File

@ -10,25 +10,25 @@
class Map
{
private:
GameRenderer *renderer;
std::vector<std::vector<Tile>> tiles;
GameRenderer *renderer;
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:
double tile_offset_x;
double tile_offset_y;
int tile_size;
double tile_offset_x;
double tile_offset_y;
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

30
src/Player.cpp
View File

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

26
src/Player.hpp
View File

@ -7,27 +7,27 @@
class Player
{
private:
GameRenderer *renderer;
std::unique_ptr<Sprite> hero_sprite, bow_sprite;
GameRenderer *renderer;
std::unique_ptr<Sprite> hero_sprite, bow_sprite;
public:
double x = 0;
double y = 0;
double x = 0;
double y = 0;
double x_vel = 0;
double y_vel = 0;
double x_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)
{
texture = IMG_LoadTexture(renderer, file.c_str());
texture = IMG_LoadTexture(renderer, file.c_str());
}
Sprite::~Sprite()
{
SDL_DestroyTexture(texture);
SDL_DestroyTexture(texture);
}

18
src/Sprite.hpp
View File

@ -6,18 +6,18 @@
class Sprite {
public:
SDL_Texture *texture;
int width;
int height;
SDL_Texture *texture;
int width;
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 operator=(const Sprite&) = delete;
Sprite(Sprite&&) = delete;
Sprite operator=(Sprite&&) = delete;
Sprite(const Sprite&) = delete;
Sprite operator=(const Sprite&) = delete;
Sprite(Sprite&&) = delete;
Sprite operator=(Sprite&&) = delete;
};
#endif

6
src/Tile.hpp
View File

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

18
src/Zombo.cpp
View File

@ -2,19 +2,19 @@
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;
y += std::sin(angle) * speed;
x += std::cos(angle) * speed;
y += std::sin(angle) * speed;
}
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_y = (int)(y - sprite.height / 2 + renderer->screen_height / 2 - player_y);
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);
if (x < player_x)
renderer->draw_sprite(sprite, draw_x, draw_y);
else
renderer->draw_sprite_flipped(sprite, draw_x, draw_y);
if (x < player_x)
renderer->draw_sprite(sprite, draw_x, draw_y);
else
renderer->draw_sprite_flipped(sprite, draw_x, draw_y);
}

12
src/Zombo.hpp
View File

@ -8,17 +8,17 @@
class Zombo
{
private:
double x;
double y;
double x;
double y;
static constexpr double speed = 0.5;
static constexpr double speed = 0.5;
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