744 lines
21 KiB
C++
744 lines
21 KiB
C++
#include <cassert>
|
|
#include <chrono>
|
|
#include <cmath>
|
|
#include <cstdlib>
|
|
#include <expected>
|
|
#include <iostream>
|
|
#include <map>
|
|
#include <memory>
|
|
#include <thread>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
|
|
#include "array.hpp"
|
|
#include "log.hpp"
|
|
#include "math.hpp"
|
|
|
|
//
|
|
// Utils
|
|
//
|
|
|
|
//
|
|
// Math stuff
|
|
//
|
|
|
|
// Forward declarations
|
|
class Sprite;
|
|
class Sound;
|
|
class UserAction;
|
|
|
|
//
|
|
// UI stuff. This is the part directly dependent on the SDL
|
|
//
|
|
|
|
// containers
|
|
|
|
#include <GL/glew.h>
|
|
#include <SDL3/SDL.h>
|
|
#include <SDL3_image/SDL_image.h>
|
|
|
|
class Sound {
|
|
public:
|
|
Sound() { LOG_DEBUG("."); }
|
|
Sound(const Sound &x) { LOG_DEBUG("."); }
|
|
Sound(Sound &&x) noexcept { LOG_DEBUG("."); }
|
|
~Sound() { LOG_DEBUG("."); }
|
|
};
|
|
|
|
class AudioOutput {
|
|
public:
|
|
AudioOutput() { LOG_DEBUG("."); }
|
|
AudioOutput(const AudioOutput &x) = delete;
|
|
AudioOutput(AudioOutput &&x) = delete;
|
|
~AudioOutput() { LOG_DEBUG("."); }
|
|
|
|
std::expected<void, std::string> Init() {
|
|
LOG_INFO("Initialing audio output");
|
|
return {};
|
|
}
|
|
|
|
void PlaySound(Sound &s);
|
|
};
|
|
|
|
class Sprite {
|
|
public:
|
|
Sprite() : m_Texture(nullptr, SDL_DestroyTexture) {}
|
|
Sprite(std::string path, Vec2D<float> center) : Sprite() {
|
|
LoadImage(path, center);
|
|
}
|
|
int m_R = 0;
|
|
int m_G = 0;
|
|
int m_B = 0;
|
|
int m_A = 0;
|
|
Sprite(const Sprite &x) = delete;
|
|
Sprite(Sprite &&x) = delete;
|
|
~Sprite() { LOG_DEBUG("."); }
|
|
void LoadImage(std::string path, Vec2D<float> image_center = {0.0, 0.0}) {
|
|
LOG_INFO("Loading image ", path);
|
|
assert(m_Renderer != nullptr);
|
|
|
|
auto surface = std::unique_ptr<SDL_Surface, decltype(&SDL_DestroySurface)>(
|
|
IMG_Load(path.c_str()), SDL_DestroySurface);
|
|
|
|
if (surface == nullptr) {
|
|
LOG_ERROR("IMG_Load failed to load ", path);
|
|
throw std::runtime_error("Failed to load resources");
|
|
}
|
|
|
|
m_Texture = std::unique_ptr<SDL_Texture, decltype(&SDL_DestroyTexture)>(
|
|
SDL_CreateTextureFromSurface(m_Renderer.get(), surface.get()),
|
|
SDL_DestroyTexture);
|
|
if (m_Texture == nullptr) {
|
|
LOG_ERROR("SDL_CreateTextureFromSurface failed");
|
|
throw std::runtime_error("Failed to load resources");
|
|
}
|
|
float w, h;
|
|
SDL_GetTextureSize(m_Texture.get(), &w, &h);
|
|
m_Size = {w, h};
|
|
m_ImageCenter = image_center;
|
|
}
|
|
|
|
// Renderer is shared for all class instances - we need it in order
|
|
// to create textures from images
|
|
static void SetRenderer(std::shared_ptr<SDL_Renderer> renderer) {
|
|
m_Renderer = renderer;
|
|
}
|
|
|
|
// GetTexture cannot return pointer to const, as SDL_RenderTexture modifies it
|
|
SDL_Texture *GetTexture() { return m_Texture.get(); }
|
|
|
|
Vec2D<float> GetSize() const { return m_Size; }
|
|
Vec2D<float> GetCenter() const { return m_ImageCenter; }
|
|
|
|
private:
|
|
static std::shared_ptr<SDL_Renderer> m_Renderer;
|
|
std::unique_ptr<SDL_Texture, decltype(&SDL_DestroyTexture)> m_Texture;
|
|
Vec2D<float> m_Size;
|
|
Vec2D<float> m_ImageCenter;
|
|
float m_TextureWidth = 0;
|
|
float m_TextureHeight = 0;
|
|
};
|
|
std::shared_ptr<SDL_Renderer> Sprite::m_Renderer = nullptr;
|
|
|
|
// User interface classes
|
|
|
|
class Window {
|
|
public:
|
|
Window(const Window &x) = delete;
|
|
Window(Window &&x) = delete;
|
|
Window(int width, int height) : m_Width(width), m_Height(height) {
|
|
LOG_DEBUG(".");
|
|
}
|
|
|
|
std::expected<void, std::string> Init() {
|
|
LOG_DEBUG(".");
|
|
|
|
if (SDL_Init(SDL_INIT_VIDEO) == false) {
|
|
return std::unexpected(std::string("SDL could not initialize! Error: ") +
|
|
SDL_GetError());
|
|
}
|
|
m_Window = SDL_CreateWindow("SDL2 Window", m_Width, m_Height,
|
|
SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE);
|
|
if (m_Window == nullptr) {
|
|
std::atexit(SDL_Quit);
|
|
return std::unexpected(
|
|
std::string("Window could not be created! Error: ") + SDL_GetError());
|
|
}
|
|
|
|
m_Context = SDL_GL_CreateContext(m_Window);
|
|
if (m_Context == nullptr) {
|
|
SDL_DestroyWindow(m_Window);
|
|
std::atexit(SDL_Quit);
|
|
return std::unexpected(
|
|
std::string("GL context could not be created! Error: ") +
|
|
SDL_GetError());
|
|
}
|
|
|
|
if (glewInit() != GLEW_OK) {
|
|
SDL_GL_DestroyContext(m_Context);
|
|
SDL_DestroyWindow(m_Window);
|
|
std::atexit(SDL_Quit);
|
|
return std::unexpected("GLEW init failed!");
|
|
}
|
|
|
|
// Resize();
|
|
|
|
m_Renderer = std::shared_ptr<SDL_Renderer>(
|
|
SDL_CreateRenderer(m_Window, NULL), SDL_DestroyRenderer);
|
|
if (m_Renderer == nullptr) {
|
|
SDL_DestroyWindow(m_Window);
|
|
std::atexit(SDL_Quit);
|
|
return std::unexpected(
|
|
std::string("Renderer could not be created! Error: ") +
|
|
SDL_GetError());
|
|
}
|
|
|
|
// Set renderer to the Sprite class
|
|
Sprite::SetRenderer(m_Renderer);
|
|
|
|
// TODO this needs to be tied to map size
|
|
SDL_SetRenderScale(m_Renderer.get(), 1.0f, 1.0f);
|
|
|
|
return {};
|
|
}
|
|
|
|
~Window() {
|
|
// SDL_DestroyRenderer(m_Renderer); // handled by shared_ptr
|
|
SDL_GL_DestroyContext(m_Context);
|
|
SDL_DestroyWindow(m_Window);
|
|
std::atexit(SDL_Quit);
|
|
LOG_DEBUG(".");
|
|
}
|
|
|
|
void DrawSprite(const Vec2D<float> &position, Sprite &s) {
|
|
Vec2D<float> size = s.GetSize();
|
|
Vec2D<float> img_center = s.GetCenter();
|
|
SDL_FRect rect = {position.x - img_center.x, position.y - img_center.y,
|
|
size.x, size.y};
|
|
SDL_RenderTexture(m_Renderer.get(), s.GetTexture(), nullptr, &rect);
|
|
}
|
|
|
|
void ClearWindow() {
|
|
SDL_SetRenderDrawColor(m_Renderer.get(), 50, 50, 50, 255);
|
|
SDL_RenderClear(m_Renderer.get());
|
|
}
|
|
|
|
void Flush() { SDL_RenderPresent(m_Renderer.get()); }
|
|
|
|
void DrawCircle(const Vec2D<float> &position, float radius) {
|
|
int cx = static_cast<int>(position.x);
|
|
int cy = static_cast<int>(position.y);
|
|
SDL_SetRenderDrawColor(m_Renderer.get(), 255, 0, 0, 255);
|
|
for (int i = 0; i < 360; ++i) {
|
|
double a = i * M_PI / 180.0;
|
|
SDL_RenderPoint(m_Renderer.get(),
|
|
cx + static_cast<int>(std::round(radius * std::cos(a))),
|
|
cy + static_cast<int>(std::round(radius * std::sin(a))));
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<SDL_Renderer> m_Renderer = nullptr;
|
|
SDL_Window *m_Window;
|
|
SDL_GLContext m_Context;
|
|
|
|
private:
|
|
uint32_t m_Width;
|
|
uint32_t m_Height;
|
|
};
|
|
|
|
class UserAction {
|
|
public:
|
|
enum class Type { NONE, EXIT, MOVE, CROUCH, STAND, FIRE };
|
|
|
|
UserAction() = default;
|
|
|
|
UserAction(Type t) : type(t) {}
|
|
|
|
UserAction(Type t, char key) : type(t), Argument{.key = key} {}
|
|
|
|
UserAction(Type t, Vec2D<float> v) : type(t), Argument{.position = v} {}
|
|
|
|
~UserAction() = default;
|
|
|
|
Type type;
|
|
|
|
union {
|
|
Vec2D<float> position;
|
|
char key;
|
|
} Argument;
|
|
};
|
|
|
|
class UserInput {
|
|
public:
|
|
UserInput()
|
|
: // pre-alloc some space
|
|
m_Actions(10) {
|
|
LOG_DEBUG(".");
|
|
};
|
|
|
|
UserInput(const UserInput &x) = delete;
|
|
UserInput(UserInput &&x) = delete;
|
|
~UserInput() { LOG_DEBUG("."); };
|
|
|
|
std::expected<void, std::string> Init() { return {}; }
|
|
|
|
const std::vector<UserAction> &GetActions() {
|
|
m_Actions.clear();
|
|
static Vec2D<float> move_direction = {0.0f, 0.0f};
|
|
static bool send_move_action = false;
|
|
SDL_Event event;
|
|
|
|
while (SDL_PollEvent(&event)) {
|
|
if (event.type == SDL_EVENT_KEY_DOWN || event.type == SDL_EVENT_KEY_UP) {
|
|
bool key_down = event.type == SDL_EVENT_KEY_DOWN ? true : false;
|
|
SDL_KeyboardEvent kbd_event = event.key;
|
|
if (kbd_event.repeat) {
|
|
// SDL repeats KEY_DOWN if key is held down, we ignore that
|
|
continue;
|
|
}
|
|
LOG_DEBUG("Key '", static_cast<char>(kbd_event.key),
|
|
key_down ? "' down" : "' up");
|
|
|
|
switch (kbd_event.key) {
|
|
case 'q':
|
|
m_Actions.emplace_back(UserAction::Type::EXIT);
|
|
// further processing of inputs is not needed
|
|
return m_Actions;
|
|
case 'w':
|
|
case 's':
|
|
case 'a':
|
|
case 'd':
|
|
case SDLK_UP:
|
|
case SDLK_DOWN:
|
|
case SDLK_LEFT:
|
|
case SDLK_RIGHT: {
|
|
static std::map<char, Vec2D<float>> move_base{
|
|
{'w', {0.0, 1.0}},
|
|
{'s', {0.0, -1.0}},
|
|
{'a', {1.0, 0.0}},
|
|
{'d', {-1.0, 0.0}},
|
|
{static_cast<char>(SDLK_UP), {0.0, 1.0}},
|
|
{static_cast<char>(SDLK_DOWN), {0.0, -1.0}},
|
|
{static_cast<char>(SDLK_LEFT), {1.0, 0.0}},
|
|
{static_cast<char>(SDLK_RIGHT), {-1.0, 0.0}},
|
|
};
|
|
|
|
float direction = key_down ? -1.0f : 1.0f;
|
|
send_move_action = true;
|
|
move_direction += move_base[kbd_event.key] * direction;
|
|
break;
|
|
}
|
|
case SDLK_SPACE:
|
|
if (key_down)
|
|
m_Actions.emplace_back(UserAction::Type::FIRE);
|
|
break;
|
|
default:
|
|
LOG_INFO("Key '", static_cast<char>(kbd_event.key), "' not mapped");
|
|
break;
|
|
}
|
|
} else {
|
|
// TODO uncomment, for now too much noise
|
|
// LOG_WARNING("Action not processed");
|
|
}
|
|
}
|
|
if (send_move_action) {
|
|
m_Actions.emplace_back(UserAction::Type::MOVE,
|
|
move_direction.normalized());
|
|
send_move_action = false;
|
|
}
|
|
return m_Actions;
|
|
}
|
|
|
|
private:
|
|
std::vector<UserAction> m_Actions;
|
|
};
|
|
|
|
//
|
|
// Game classes
|
|
//
|
|
|
|
class Entity {
|
|
public:
|
|
enum class Type : std::uint8_t {
|
|
NONE,
|
|
PLAYER,
|
|
WALL,
|
|
TILE,
|
|
COUNT // must be last
|
|
};
|
|
|
|
Entity(Vec2D<float> position = {0.0f, 0.0f}) : m_Position(position) {
|
|
LOG_DEBUG("spawning entity at position ", position);
|
|
}
|
|
|
|
friend std::ostream &operator<<(std::ostream &os, const Entity &obj) {
|
|
static constexpr std::array<std::string_view,
|
|
static_cast<size_t>(Entity::Type::COUNT)>
|
|
type_name{"NONE", "PLAYER", "WALL", "TILE"};
|
|
size_t idx = static_cast<size_t>(obj.GetType());
|
|
assert(idx < type_name.size());
|
|
os << type_name[idx];
|
|
return os;
|
|
}
|
|
|
|
virtual Sprite &GetSprite() = 0;
|
|
virtual constexpr float GetCollisionRadius() const = 0;
|
|
virtual constexpr float GetCollisionRadiusSquared() {
|
|
return GetCollisionRadius() * GetCollisionRadius();
|
|
}
|
|
|
|
virtual constexpr Type GetType() const = 0;
|
|
void SetFlagExpired() { m_FlagExpired = true; }
|
|
bool IsFlaggedExpired() { return m_FlagExpired; }
|
|
|
|
const Vec2D<float> &GetPosition() const { return m_Position; }
|
|
void SetPosition(Vec2D<float> new_pos) { m_Position = new_pos; }
|
|
|
|
const Vec2D<float> &GetActualVelocity() const { return m_ActualVelocity; }
|
|
const Vec2D<float> &GetRequestedVelocity() const {
|
|
return m_RequestedVelocity;
|
|
}
|
|
void SetActualVelocity(const Vec2D<float> &new_velocity) {
|
|
m_ActualVelocity = new_velocity;
|
|
}
|
|
void SetRequestedVelocity(const Vec2D<float> &new_velocity) {
|
|
m_RequestedVelocity = new_velocity;
|
|
}
|
|
|
|
void ZeroActualVelocityInDirection(Vec2D<float> direction) {
|
|
// Vectors e1, e2 form the basis for a local coord system,
|
|
// where e1 is formed by the direction where we want to zero-out
|
|
// the velocity, and e2 is the orthogonal vector.
|
|
// Scalars q1, q2 are coordinates for e1, e2 basis.
|
|
Vec2D<float> e1 = direction.normalized();
|
|
Vec2D<float> e2 = e1.orthogonal();
|
|
|
|
// q1 * e1 + q2 * e2 = v, from this follows:
|
|
auto &v = GetActualVelocity();
|
|
float q2 = (v.y * e1.x - v.x * e1.y) / (e2.y * e1.x - e2.x * e1.y);
|
|
float q1 = (v.x - q2 * e2.x) / e1.x;
|
|
|
|
// We then zero-out the q1, but only if it's positive - meaning
|
|
// it is aiming in the direction of "direction", not out.
|
|
// (otherwise we're not able to move out from collision with
|
|
// another object)
|
|
if (q1 > 0.0f) {
|
|
SetActualVelocity(q2 * e2);
|
|
}
|
|
}
|
|
|
|
virtual void Update(float time_delta) {
|
|
m_Position += m_ActualVelocity * time_delta;
|
|
}
|
|
|
|
virtual bool IsMovable() const = 0;
|
|
virtual bool IsCollidable() const = 0;
|
|
|
|
protected:
|
|
Vec2D<float> m_Position;
|
|
Vec2D<float> m_ActualVelocity;
|
|
Vec2D<float> m_RequestedVelocity;
|
|
|
|
private:
|
|
bool m_FlagExpired = false;
|
|
static constexpr float m_CollisionRadiusSq = 1000.0f;
|
|
};
|
|
|
|
class Tile final : public Entity {
|
|
public:
|
|
constexpr float GetCollisionRadius() const override { return 50.0f; }
|
|
bool IsMovable() const override { return false; }
|
|
bool IsCollidable() const override { return false; }
|
|
};
|
|
|
|
class Wall final : public Entity {
|
|
public:
|
|
Wall(Vec2D<float> pos = {0.0f, 0.0f}) : Entity(pos) {
|
|
LOG_DEBUG(".");
|
|
if (m_Sprite == nullptr) {
|
|
LoadResources();
|
|
}
|
|
}
|
|
Wall(const Wall &x) = delete;
|
|
Wall(Wall &&x) = delete;
|
|
|
|
Sprite &GetSprite() override {
|
|
assert(m_Sprite != nullptr);
|
|
return *m_Sprite;
|
|
}
|
|
constexpr Entity::Type GetType() const override { return Entity::Type::WALL; }
|
|
constexpr float GetCollisionRadius() const override { return 50.0f; }
|
|
bool IsMovable() const override { return false; }
|
|
bool IsCollidable() const override { return true; }
|
|
|
|
private:
|
|
void LoadResources() {
|
|
m_Sprite = std::make_unique<Sprite>("resources/wall.png",
|
|
Vec2D<float>{50.0f, 50.0f});
|
|
}
|
|
static std::unique_ptr<Sprite> m_Sprite;
|
|
};
|
|
std::unique_ptr<Sprite> Wall::m_Sprite;
|
|
|
|
class Player final : public Entity {
|
|
public:
|
|
Player() {
|
|
LOG_DEBUG(".");
|
|
if (m_Sprite == nullptr) {
|
|
LoadResources();
|
|
}
|
|
}
|
|
Player(const Player &x) = delete;
|
|
Player(Player &&x) = delete;
|
|
|
|
Sprite &GetSprite() override {
|
|
assert(m_Sprite != nullptr);
|
|
return *m_Sprite;
|
|
}
|
|
|
|
constexpr Entity::Type GetType() const override {
|
|
return Entity::Type::PLAYER;
|
|
}
|
|
constexpr float GetCollisionRadius() const override { return 50.0f; }
|
|
bool IsMovable() const override { return true; }
|
|
bool IsCollidable() const override { return true; }
|
|
|
|
private:
|
|
void LoadResources() {
|
|
m_Sprite = std::make_unique<Sprite>("resources/player.png",
|
|
Vec2D<float>{38.0f, 46.0f});
|
|
}
|
|
static std::unique_ptr<Sprite> m_Sprite;
|
|
};
|
|
|
|
std::unique_ptr<Sprite> Player::m_Sprite;
|
|
|
|
using Collision = std::pair<std::shared_ptr<Entity>, std::shared_ptr<Entity>>;
|
|
|
|
|
|
class PathFindingDemo {
|
|
public:
|
|
PathFindingDemo(int width, int height) : m_Width(width), m_Height(height) {
|
|
LOG_DEBUG(".");
|
|
}
|
|
|
|
~PathFindingDemo() { LOG_DEBUG("."); }
|
|
|
|
PathFindingDemo(const PathFindingDemo &m) = delete;
|
|
PathFindingDemo(PathFindingDemo &&m) = delete;
|
|
|
|
void AddEntity(std::shared_ptr<Entity> e) {
|
|
// TODO emplace_back
|
|
m_Entities.push_back(e);
|
|
}
|
|
|
|
void CreateMap() {
|
|
m_Entities.clear();
|
|
m_Player = std::make_shared<Player>();
|
|
m_Player->SetPosition(Vec2D<float>{200.0f, 200.0f});
|
|
m_Entities.push_back(m_Player);
|
|
LOG_INFO("Re-creating random map");
|
|
// add some entities
|
|
size_t map_size_bricks = 8;
|
|
auto wall = std::make_shared<Wall>();
|
|
auto wall_size = wall->GetSprite().GetSize();
|
|
Vec2D<float> offset{100.0f, 100.0f};
|
|
for (size_t u = 0; u < map_size_bricks; u++) {
|
|
Vec2D<float> pos{offset.x + wall_size.x * u, offset.y};
|
|
m_Entities.push_back(std::make_shared<Wall>(pos));
|
|
}
|
|
for (size_t u = 1; u < map_size_bricks; u++) {
|
|
Vec2D<float> pos{offset.x, offset.y + u * wall_size.y};
|
|
m_Entities.push_back(std::make_shared<Wall>(pos));
|
|
}
|
|
for (size_t u = 0; u < map_size_bricks; u++) {
|
|
Vec2D<float> pos{offset.x + wall_size.x * u,
|
|
offset.y + map_size_bricks * wall_size.y};
|
|
m_Entities.push_back(std::make_shared<Wall>(pos));
|
|
}
|
|
for (size_t u = 0; u < map_size_bricks; u++) {
|
|
Vec2D<float> pos{offset.x + map_size_bricks * wall_size.x,
|
|
offset.y + u * wall_size.y};
|
|
m_Entities.push_back(std::make_shared<Wall>(pos));
|
|
}
|
|
}
|
|
|
|
std::shared_ptr<Player> GetPlayer() { return m_Player; }
|
|
|
|
Vec2D<float> GetRandomPosition() const { return Vec2D<float>{0.0, 0.0}; }
|
|
|
|
std::vector<std::shared_ptr<Entity>> &GetEntities() { return m_Entities; }
|
|
|
|
void UpdateEntities() {
|
|
float time_delta = 1.0f;
|
|
|
|
// Remove entities marked as expired and handle expiry logic (e.g. bomb
|
|
// exploding); for all other entities, reset the actual velocity to the
|
|
// requested; actual velocity will be updated later with collisions
|
|
for (auto &entity : m_Entities) {
|
|
if (entity->IsFlaggedExpired()) {
|
|
ExpiryGameLogic(*entity);
|
|
auto it = std::find(m_Entities.begin(), m_Entities.end(), entity);
|
|
if (it != m_Entities.end()) {
|
|
std::swap(*it, m_Entities.back());
|
|
m_Entities.pop_back();
|
|
}
|
|
} else {
|
|
// Actual velocity might be changed later by collisions
|
|
entity->SetActualVelocity(entity->GetRequestedVelocity());
|
|
}
|
|
}
|
|
|
|
// Handle collisions:
|
|
// - update actual velocity for colliding objects
|
|
// - handle collision logic
|
|
auto &collisions = GetEntityCollisions();
|
|
// LOG_DEBUG("number of collisions: ", collisions.size());
|
|
for (auto &collision : collisions) {
|
|
Entity &A = *std::get<0>(collision);
|
|
Entity &B = *std::get<1>(collision);
|
|
if (!A.IsMovable())
|
|
continue;
|
|
// modify actual speed
|
|
// LOG_DEBUG("Collision: A is ", A, ", B is ", B);
|
|
Vec2D<float> AB = B.GetPosition() - A.GetPosition();
|
|
A.ZeroActualVelocityInDirection(AB);
|
|
// handle logic
|
|
CollisionGameLogic(A, B);
|
|
}
|
|
|
|
// Update entities: this advances animations,
|
|
// internal timers, and updates positions (with velocity
|
|
// modified by the collision handling)
|
|
for (auto &entity : m_Entities) {
|
|
entity->Update(time_delta);
|
|
}
|
|
}
|
|
|
|
void CollisionGameLogic(Entity &A, Entity &B) {
|
|
// not used for path finding demo
|
|
}
|
|
|
|
void ExpiryGameLogic(Entity &entity)
|
|
{
|
|
// not used for path finding demo
|
|
}
|
|
|
|
const std::vector<Collision> &GetEntityCollisions() {
|
|
static std::vector<Collision> m_Collisions;
|
|
|
|
m_Collisions.clear();
|
|
for (const auto &entity_A : m_Entities) {
|
|
for (const auto &entity_B : m_Entities) {
|
|
if (entity_A == entity_B)
|
|
continue;
|
|
if (!entity_A->IsCollidable() || !entity_B->IsCollidable())
|
|
continue;
|
|
// check distance of player to given entity
|
|
auto position_A = entity_A->GetPosition();
|
|
auto position_B = entity_B->GetPosition();
|
|
auto distance_sq = position_A.distance_squared(position_B);
|
|
auto collision_distance_sq =
|
|
entity_A->GetCollisionRadiusSquared() +
|
|
entity_B->GetCollisionRadiusSquared() +
|
|
2 * entity_A->GetCollisionRadius() * entity_B->GetCollisionRadius();
|
|
// TODO use vector instructions
|
|
if (distance_sq < collision_distance_sq) {
|
|
m_Collisions.emplace_back(Collision(entity_A, entity_B));
|
|
}
|
|
}
|
|
}
|
|
return m_Collisions;
|
|
}
|
|
|
|
void HandleActions(const std::vector<UserAction> &actions) {
|
|
for (const auto &action : actions) {
|
|
if (action.type == UserAction::Type::EXIT) {
|
|
LOG_INFO("Exit requested");
|
|
m_ExitRequested = true;
|
|
} else if (action.type == UserAction::Type::FIRE) {
|
|
LOG_INFO("Fire");
|
|
//AddEntity(m_Player->CreateBomb());
|
|
} else if (action.type == UserAction::Type::MOVE) {
|
|
LOG_INFO("Move direction ", action.Argument.position);
|
|
m_Player->SetRequestedVelocity(action.Argument.position * 4.0f);
|
|
}
|
|
};
|
|
}
|
|
|
|
bool IsCollisionBoxVisible() const { return m_DrawCollisionBox; }
|
|
bool IsExitRequested() const { return m_ExitRequested; }
|
|
|
|
private:
|
|
int m_Width;
|
|
int m_Height;
|
|
bool m_ExitRequested = false;
|
|
bool m_DrawCollisionBox = true;
|
|
std::vector<std::shared_ptr<Entity>> m_Entities;
|
|
std::shared_ptr<Player> m_Player;
|
|
};
|
|
|
|
// GameLoop class handles user input and audio/video output,
|
|
// client side only. No game logic should be handled here.
|
|
|
|
class GameLoop {
|
|
public:
|
|
GameLoop() = default;
|
|
|
|
void Run() {
|
|
LOG_INFO("Running the game");
|
|
while (!m_Game->IsExitRequested()) {
|
|
m_Game->HandleActions(m_UserInput->GetActions());
|
|
m_Game->UpdateEntities();
|
|
|
|
m_Window->ClearWindow();
|
|
for (auto &entity : m_Game->GetEntities()) {
|
|
m_Window->DrawSprite(entity->GetPosition(), entity->GetSprite());
|
|
if (m_Game->IsCollisionBoxVisible()) {
|
|
m_Window->DrawCircle(entity->GetPosition(),
|
|
entity->GetCollisionRadius());
|
|
}
|
|
}
|
|
m_Window->Flush();
|
|
// TODO measure fps
|
|
std::this_thread::sleep_for(std::chrono::milliseconds(30));
|
|
}
|
|
}
|
|
|
|
inline void SetGame(std::unique_ptr<PathFindingDemo> x) { m_Game = std::move(x); }
|
|
inline void SetWindow(std::unique_ptr<Window> x) { m_Window = std::move(x); }
|
|
inline void SetUserInput(std::unique_ptr<UserInput> x) {
|
|
m_UserInput = std::move(x);
|
|
}
|
|
inline void SetAudioOutput(std::unique_ptr<AudioOutput> x) {
|
|
m_AudioOutput = std::move(x);
|
|
}
|
|
|
|
private:
|
|
std::unique_ptr<PathFindingDemo> m_Game;
|
|
std::unique_ptr<Window> m_Window;
|
|
std::unique_ptr<UserInput> m_UserInput;
|
|
std::unique_ptr<AudioOutput> m_AudioOutput;
|
|
};
|
|
|
|
int main(int argc, char **argv) {
|
|
constexpr int error = -1;
|
|
|
|
/*
|
|
* Initialize the input/output system
|
|
*/
|
|
|
|
auto window = std::make_unique<Window>(640, 480); // the holy resolution
|
|
// auto window_init = window->Init();
|
|
if (auto initialized = window->Init(); !initialized) {
|
|
LOG_ERROR(initialized.error());
|
|
return error;
|
|
}
|
|
|
|
auto user_input = std::make_unique<UserInput>();
|
|
if (auto initialized = user_input->Init(); !initialized) {
|
|
LOG_ERROR(initialized.error());
|
|
return error;
|
|
}
|
|
|
|
auto audio_output = std::make_unique<AudioOutput>();
|
|
if (auto initialized = audio_output->Init(); !initialized) {
|
|
LOG_ERROR(initialized.error());
|
|
return error;
|
|
}
|
|
|
|
/*
|
|
* Initialize the map and run the pathfinding demo
|
|
*/
|
|
|
|
auto demo = std::make_unique<PathFindingDemo>(50, 50);
|
|
demo->CreateMap();
|
|
|
|
auto game_loop = GameLoop{};
|
|
game_loop.SetWindow(std::move(window));
|
|
game_loop.SetUserInput(std::move(user_input));
|
|
game_loop.SetAudioOutput(std::move(audio_output));
|
|
game_loop.SetGame(std::move(demo));
|
|
game_loop.Run();
|
|
}
|