jan.mrna/pathfinding_demo
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Compare commits

base: jan.mrna:master
Branches Tags
jan.mrna:master
jan.mrna:feature/collisions
jan.mrna:feature/pan_zoom
jan.mrna:win_build
..
compare: jan.mrna:win_build
Branches Tags
jan.mrna:feature/collisions
jan.mrna:master
jan.mrna:feature/pan_zoom
jan.mrna:win_build

No commits in common. "master" and "win_build" have entirely different histories.
master ... win_build

43 changed files with 1055 additions and 2868 deletions
Show Stats Expand all files Collapse all files

3
.gitignore vendored
View File

@ -1,5 +1,4 @@
tags
python/.ipynb_checkpoints
cpp/build
cpp/test
cpp/pathfinding
.aider*

65
README.md
View File

@ -1,15 +1,11 @@
# Pathfinding demo
![C++ pathfinding demo](./docs/img/screenshot_1.png)
**Work in progress**
This is a demo of pathfinding on a 2D grid. It consists of 2 main parts:
* python notes and implementation
* jupyter notebook file
* standalone python script
* C++ interactive demo
* C++ demo - **work in progress**
## Python
@ -21,34 +17,37 @@ Run `python pathfinding_demo.py`. Requires numpy and matplotlib to be installed.
Contains the same demo as the standalone script and some notes. Since Github supports Jupyter Notebooks now, you can go [directly to the file](./python/pathfinding_demo.ipynb).
## C++
Alternatively (or if you want to edit the file), you can use the [Jupyeter Lab on the official website](https://jupyter.org/try-jupyter/lab/):
Work in progress. At the moment Linux build only.
* click the icon "Upload files" (on the top of left sidebar)
* select pathfinding_demo.ipynb
* file should be now visible in the left sidebar. Double-click it and confirm default kernel selection
* run all the cells one by one (play button on the top) or run all of at once using menu "Run -> Run All Cells"
### Build
#### Install prerequisities
* SDL3
* SDL3-image
* GLEW
e.g. on Archlinux:
```
pacman -S glew sdl3 sdl3_image
```
#### Compile
In the [cpp](./cpp/) folder, run [make](./cpp/Makefile)
```
cd cpp/
make -j $(nproc)
```
### Run
Run the `pathfinding` binary in the [cpp](./cpp/) folder.
## TODO
- [x] python
- [x] get jupyter lab running
- [x] drawing utility
- [x] interface for pathfinding
- [x] research methods
- [x] implement methods
- [x] DFS
- [x] BFS
- [x] Dijsktra
- [x] GBFS
- [x] A*
- [x] performance measurement: time/visited nodes
- [x] finalize the script and copy back to the jupyter notebook
- [x] finish text on the page
- [x] create a dedicated python script
- [ ] C++
- [x] re-use 2D game engine
- [x] add tiles (with cost) to map
- [x] conversion functions from tile coords to world coords
- [x] drawing tiles
- [x] add "terrain tiles" with different costs
- [x] add mouse-click action
- [ ] add direct movement (through mouse click action, no pathfinding)
- [ ] implement pathfinding
- [ ] windows build?

47
cpp/Makefile
View File

@ -1,42 +1,9 @@
# ---------------------------------
# Generated by Kimi K2
#---------- configurable ----------
CXX := g++
CXXFLAGS := -Isrc -std=c++23 -Wall -Wextra -Wpedantic -ggdb3
LDFLAGS :=
LDLIBS := -lSDL3 -lSDL3_image -lGLEW -lGL
all: test pathfinding
# TODO add extra warnings
# TODO linter?
SRC_DIR := src
BUILD_DIR:= build
TARGET := pathfinding
TEST_TARGET := unittest
pathfinding: src/main.cpp src/array.hpp
g++ -Wall -ggdb3 -lSDL3 -lSDL3_image -std=c++23 -lGLEW -lGL -o pathfinding src/main.cpp
#----------------------------------
SOURCES := $(shell find $(SRC_DIR) -name '*.cpp')
OBJECTS := $(SOURCES:$(SRC_DIR)/%.cpp=$(BUILD_DIR)/%.o)
#----------------------------------
.PHONY: all clean test
all: $(TARGET)
test: $(TEST_TARGET)
./$(TEST_TARGET)
$(TEST_TARGET): test/test.cpp
$(CXX) -std=c++23 -lgtest -Isrc -o $@ $<
# link step
$(TARGET): $(OBJECTS)
$(CXX) $(LDFLAGS) -o $@ $^ $(LDLIBS)
# compile step
$(BUILD_DIR)/%.o: $(SRC_DIR)/%.cpp | $(BUILD_DIR)
@mkdir -p $(dir $@)
$(CXX) $(CXXFLAGS) -c -o $@ $<
$(BUILD_DIR):
mkdir -p $@
clean:
rm -rf $(BUILD_DIR) $(TARGET) $(TEST_TARGET)
test: src/test.cpp src/array.hpp
g++ -Wall -Wextra -Wpedantic -ggdb3 -std=c++23 -lgtest -o test src/test.cpp

BIN
cpp/resources/player.png
View File

Binary file not shown.
Side by Side Swipe Overlay

Before

Width:  |  Height:  |  Size: 3.9 KiB

After

Width:  |  Height:  |  Size: 10 KiB

45
cpp/src/camera.cpp
View File

@ -1,45 +0,0 @@
#include "camera.hpp"
#include "math.hpp"
#include "log.hpp"
// for now only pass-through placeholder functions,
// since we draw the whole map
void Camera::Pan(const WorldPos& delta)
{
m_Pan += (delta / m_Zoom);
}
void Camera::Zoom(float delta)
{
constexpr float ZOOM_SCALE = 0.1f;
m_Zoom += delta * ZOOM_SCALE;
LOG_DEBUG("Zoom: ", m_Zoom);
}
WindowPos Camera::WorldToWindow(WorldPos world) const
{
const auto& v = world + m_Pan;
return WindowPos{v[0], v[1]} * m_Zoom;
}
WorldPos Camera::WindowToWorld(WindowPos window) const
{
window /= m_Zoom;
return WorldPos{window[0], window[1]} - m_Pan;
}
WindowSize Camera::WorldToWindowSize(WorldSize world) const
{
const auto& v = world;
// no zoom yet, just pass-through
return WindowSize{v[0], v[1]} * m_Zoom;
}
WorldSize Camera::WindowToWorldSize(WindowSize window) const
{
window /= m_Zoom;
return WorldSize{window[0], window[1]};
}

23
cpp/src/camera.hpp
View File

@ -1,23 +0,0 @@
#pragma once
#include "math.hpp"
class Camera
{
public:
void Pan(const WorldPos& delta);
void Zoom(float delta);
WorldPos GetPan() const { return m_Pan; }
float GetZoom() const { return m_Zoom; }
WindowPos WorldToWindow(WorldPos) const;
WorldPos WindowToWorld(WindowPos) const;
WindowSize WorldToWindowSize(WorldSize) const;
WorldSize WindowToWorldSize(WindowSize) const;
private:
// TODO this should be replaced with a matrix
float m_Zoom = 1.0f;
WorldPos m_Pan;
};

66
cpp/src/entities.cpp
View File

@ -1,66 +0,0 @@
#include <memory>
#include "entities.hpp"
#include "log.hpp"
#include "math.hpp"
#include "sprite.hpp"
Entity::Entity(WorldPos position) : m_Position(position) {
LOG_DEBUG("spawning entity at position ", position);
}
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", "TILE"};
size_t idx = static_cast<size_t>(obj.GetType());
assert(idx < type_name.size());
os << type_name[idx];
return os;
}
void Entity::ZeroActualVelocityInDirection(WorldPos 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.
WorldPos e1 = direction.GetNormalized();
WorldPos e2 = e1.GetOrthogonal();
// 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);
}
}
void Entity::Update(float time_delta) {
m_Position += m_ActualVelocity * time_delta;
}
Player::Player() {
LOG_DEBUG(".");
if (m_Sprite == nullptr) {
LoadResources();
}
}
Sprite &Player::GetSprite() {
assert(m_Sprite != nullptr);
return *m_Sprite;
}
void Player::LoadResources() {
m_Sprite =
std::make_unique<Sprite>("resources/player.png", WorldPos{19.0f, 23.0f});
}
std::unique_ptr<Sprite> Player::m_Sprite;

85
cpp/src/entities.hpp
View File

@ -1,85 +0,0 @@
#pragma once
#include <array>
#include <cstdint>
#include <iostream>
#include <memory>
#include <string_view>
#include "log.hpp"
#include "math.hpp"
#include "sprite.hpp"
class Entity {
public:
enum class Type : std::uint8_t {
NONE,
PLAYER,
TILE,
COUNT // must be last
};
Entity(WorldPos position = {0.0f, 0.0f});
Entity(const Entity &) = delete;
Entity &operator=(const Entity &) = delete;
Entity(Entity &&) = delete;
Entity &operator=(Entity &&) = delete;
friend std::ostream &operator<<(std::ostream &os, const Entity &obj);
virtual Sprite &GetSprite() = 0;
virtual constexpr float GetCollisionRadius() const = 0;
virtual constexpr Type GetType() const = 0;
virtual bool IsMovable() const = 0;
virtual bool IsCollidable() const = 0;
virtual void Update(float time_delta);
virtual constexpr float GetCollisionRadiusSquared() const {
return GetCollisionRadius() * GetCollisionRadius();
}
void SetFlagExpired() { m_FlagExpired = true; }
bool IsFlaggedExpired() const { return m_FlagExpired; }
const WorldPos &GetPosition() const { return m_Position; }
void SetPosition(WorldPos new_pos) { m_Position = new_pos; }
const WorldPos &GetActualVelocity() const { return m_ActualVelocity; }
const WorldPos &GetRequestedVelocity() const { return m_RequestedVelocity; }
void SetActualVelocity(const WorldPos &new_velocity) {
m_ActualVelocity = new_velocity;
}
void SetRequestedVelocity(const WorldPos &new_velocity) {
m_RequestedVelocity = new_velocity;
}
void ZeroActualVelocityInDirection(WorldPos direction);
protected:
WorldPos m_Position;
WorldPos m_ActualVelocity;
WorldPos m_RequestedVelocity;
private:
bool m_FlagExpired = false;
static constexpr float m_CollisionRadiusSq = 1000.0f;
};
class Player final : public Entity {
public:
Player();
Sprite &GetSprite() override;
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();
static std::unique_ptr<Sprite> m_Sprite;
};

61
cpp/src/gameloop.cpp
View File

@ -1,61 +0,0 @@
#include <memory>
#include <thread>
#include "gameloop.hpp"
#include "log.hpp"
#include "math.hpp"
#include "pathfinder/base.hpp"
#include "pathfindingdemo.hpp"
#include "user_input.hpp"
#include "window.hpp"
void GameLoop::Draw() {
// draw the map (terrain tiles)
const Map &map = m_Game->GetMap();
const auto &tiles = map.GetMapTiles();
for (size_t row = 0; row < tiles.size(); row++) {
for (size_t col = 0; col < tiles[row].size(); col++) {
const auto &camera = m_Game->GetCamera();
const auto &position = camera.WorldToWindow(map.TileEdgeToWorld(
TilePos{static_cast<int32_t>(row), static_cast<int32_t>(col)}));
const auto &size = camera.WorldToWindowSize(map.GetTileSize());
// LOG_DEBUG("Drawing rect (", row, ", ", col, ")");
m_Window->DrawRect(position, size, tiles[row][col]->R, tiles[row][col]->G,
tiles[row][col]->B, tiles[row][col]->A);
}
}
// draw the path, if it exists
WorldPos start_pos = m_Game->GetPlayer()->GetPosition();
for (const auto &next_pos : m_Game->GetPath()) {
const auto &camera = m_Game->GetCamera();
m_Window->DrawLine(camera.WorldToWindow(start_pos),
camera.WorldToWindow(next_pos));
start_pos = next_pos;
}
// draw all the entities (player etc)
for (auto &entity : m_Game->GetEntities()) {
const auto &camera = m_Game->GetCamera();
m_Window->DrawSprite(camera.WorldToWindow(entity->GetPosition()),
entity->GetSprite(), camera.GetZoom());
}
}
// TODO rethink coupling and dependencies in the game loop class
void GameLoop::Run() {
LOG_INFO("Running the game");
while (!m_Game->IsExitRequested()) {
m_Game->HandleActions(m_UserInput->GetActions());
m_Game->UpdatePlayerVelocity();
// TODO measure fps, draw only if delay for target fps was reached
m_Window->ClearWindow();
Draw();
m_Window->Flush();
std::this_thread::sleep_for(std::chrono::milliseconds(30));
}
}

35
cpp/src/gameloop.hpp
View File

@ -1,35 +0,0 @@
#pragma once
#include <memory>
#include "pathfindingdemo.hpp"
#include "window.hpp"
#include "user_input.hpp"
class GameLoop {
public:
GameLoop() = default;
~GameLoop() = default;
GameLoop(const GameLoop&) = delete;
GameLoop(GameLoop&&) = delete;
GameLoop& operator=(const GameLoop&) = delete;
GameLoop& operator=(GameLoop&&) = delete;
void Run();
void SetGame(std::unique_ptr<PathFindingDemo> x) {
m_Game = std::move(x);
}
void SetWindow(std::unique_ptr<Window> x) { m_Window = std::move(x); }
void SetUserInput(std::unique_ptr<UserInput> x) {
m_UserInput = std::move(x);
}
private:
void Draw();
std::unique_ptr<PathFindingDemo> m_Game;
std::unique_ptr<Window> m_Window;
std::unique_ptr<UserInput> m_UserInput;
};

791
cpp/src/main.cpp
View File

@ -1,18 +1,785 @@
#include "gameloop.hpp"
#include "log.hpp"
#include "pathfindingdemo.hpp"
#include "user_input.hpp"
#include "window.hpp"
#include <cassert>
#include <chrono>
#include <cmath>
#include <cstdlib>
#include <expected>
#include <iostream>
#include <map>
#include <memory>
#include <thread>
#include <unordered_set>
#include <vector>
int main() {
#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 DrawRect(const Vec2D<float> &position, const Vec2D<float> size,
uint8_t R, uint8_t G, uint8_t B, uint8_t A) {
SDL_FRect rect = {position.x, position.y,
size.x, size.y};
SDL_SetRenderDrawColor(m_Renderer.get(), R, G, B, A);
SDL_RenderFillRect(m_Renderer.get(), &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, MOVE_TARGET};
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 if (event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
SDL_MouseButtonEvent mouse_event = event.button;
LOG_DEBUG("Mouse down: ", mouse_event.x, ", ", mouse_event.y);
m_Actions.emplace_back(UserAction::Type::MOVE_TARGET,
Vec2D<float>{mouse_event.x, mouse_event.y});
} 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 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>>;
struct Tile {
float cost;
uint8_t R, G, B, A;
};
static const std::map<std::string_view, Tile> tile_types = {
{"Grass", {1.0, 0, 200, 0, 255}},
{"Mud", {2.0, 100, 100, 100, 255}},
{"Road", {0.5, 200, 200, 200, 255}},
{"Water", {10.0, 0, 50, 200, 255}},
};
using TilePos = Vec2D<int>;
using WorldPos = Vec2D<float>;
class Map {
// TODO using = ... for tile vector
public:
static constexpr float TILE_SIZE = 100.0f; // tile size in world
Map(int width, int height) : m_Width(width), m_Height(height) {
bool sw = true;
LOG_DEBUG("width = ", width, " height = ", height);
m_Tiles = std::vector<std::vector<const Tile *>>{};
for (int i = 0; i < m_Width; i++) {
m_Tiles.push_back(std::vector<const Tile *>{});
for (int j = 0; j < m_Height; j++) {
if (sw)
m_Tiles[i].push_back(&tile_types.at("Grass"));
else
m_Tiles[i].push_back(&tile_types.at("Water"));
sw = !sw;
}
sw = !sw;
}
}
Map() : Map(0, 0) {}
const std::vector<std::vector<const Tile *>> &GetMapTiles() const {
return m_Tiles;
}
WorldPos TileToWorld(TilePos p) const {
return WorldPos{p.x * TILE_SIZE, p.y * TILE_SIZE};
}
TilePos WorldToTile(WorldPos p) const {
return TilePos{p.x / TILE_SIZE, p.y / TILE_SIZE};
}
Vec2D<float> GetTileSize() const {
return Vec2D<float>{TILE_SIZE, TILE_SIZE};
}
private:
// std::vector<std::vector<const Tile*>> m_Tiles;
std::vector<std::vector<const Tile *>> m_Tiles;
int m_Width = 0;
int m_Height = 0;
};
class PathFindingDemo {
public:
PathFindingDemo(int width, int height)
: m_Width(width), m_Height(height), // TODO delete width, height
m_Map(width, 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);
}
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);
} else if (action.type == UserAction::Type::MOVE_TARGET) {
TilePos p = m_Map.WorldToTile(action.Argument.position);
LOG_INFO("Move target: ", action.Argument.position, ", tile pos: ", p);
// TODO move
}
};
}
const Map &GetMap() const { return m_Map; }
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;
Map m_Map;
};
// 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();
// draw the map (terrain tiles)
const Map &map = m_Game->GetMap();
const auto &tiles = map.GetMapTiles();
for (int row = 0; row < tiles.size(); row++) {
for (int col = 0; col < tiles[row].size(); col++) {
// LOG_DEBUG("Drawing rect (", row, ", ", col, ")");
m_Window->DrawRect(
map.TileToWorld(TilePos{row, col}),
map.GetTileSize(), tiles[row][col]->R, tiles[row][col]->G,
tiles[row][col]->B, tiles[row][col]->A);
}
}
// draw all the entities (player etc)
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);
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;
@ -24,17 +791,23 @@ int main() {
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>(100, 100);
auto demo = std::make_unique<PathFindingDemo>(10, 10);
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();
return 0;
}

133
cpp/src/map.cpp
View File

@ -1,133 +0,0 @@
#include <cassert>
#include <vector>
#include "log.hpp"
#include "map.hpp"
#include "tile.hpp"
Map::Map(int rows, int cols) : m_Cols(cols), m_Rows(rows) {
LOG_DEBUG("cols = ", cols, " rows = ", rows);
m_Tiles = std::vector<std::vector<const Tile *>>{};
for (size_t row = 0; row < m_Rows; row++) {
m_Tiles.push_back(std::vector<const Tile *>{});
for (size_t col = 0; col < m_Cols; col++) {
m_Tiles[row].push_back(&tile_types.at(TileType::GRASS));
}
}
}
WorldPos Map::TileToWorld(TilePos p) const {
return WorldPos{(p.x() + 0.5f) * TILE_SIZE, (p.y() + 0.5f) * TILE_SIZE};
}
WorldPos Map::TileEdgeToWorld(TilePos p) const {
return WorldPos{p.x() * TILE_SIZE, p.y() * TILE_SIZE};
}
TilePos Map::WorldToTile(WorldPos p) const {
return TilePos{static_cast<int32_t>(p.x() / TILE_SIZE), static_cast<int32_t>(p.y() / TILE_SIZE)};
}
WorldSize Map::GetTileSize() const { return WorldSize{TILE_SIZE, TILE_SIZE}; }
const Tile *Map::GetTileAt(TilePos p) const {
assert(IsTilePosValid(p));
size_t row = p.x();
size_t col = p.y();
return m_Tiles[row][col];
}
const Tile *Map::GetTileAt(WorldPos p) const {
return GetTileAt(WorldToTile(p));
}
bool Map::IsTilePosValid(TilePos p) const {
if (p.x() < 0 || p.y() < 0)
return false;
size_t row = static_cast<size_t>(p.x());
size_t col = static_cast<size_t>(p.y());
return row < m_Tiles.size() && col < m_Tiles[0].size();
}
std::vector<TilePos> Map::GetNeighbors(TilePos center) const
{
std::vector<TilePos> neighbours;
neighbours.reserve(4);
std::array<TilePos, 4> candidates = {
center + TilePos{ 1, 0},
center + TilePos{-1, 0},
center + TilePos{ 0, 1},
center + TilePos{ 0, -1},
};
for (const auto& c : candidates) {
if (IsTilePosValid(c))
neighbours.push_back(c);
}
return neighbours;
}
void Map::PaintCircle(TilePos center, unsigned radius, TileType tile_type)
{
// get rectangle that wraps the circle
TilePos corner1 = TilePos{center.x() - static_cast<int32_t>(radius), center.y() - static_cast<int32_t>(radius)};
TilePos corner2 = TilePos{center.x() + static_cast<int32_t>(radius), center.y() + static_cast<int32_t>(radius)};
// iterate through all valid points, setting the type
const unsigned radius_squared = radius * radius;
for (int x = corner1.x(); x < corner2.x(); x++) {
for (int y = corner1.y(); y < corner2.y(); y++) {
TilePos current_tile = {x, y};
unsigned distance_squared = static_cast<unsigned>(center.DistanceTo(current_tile) * center.DistanceTo(current_tile));
if (IsTilePosValid(current_tile) && distance_squared < radius_squared)
{
// y is row, x is col
m_Tiles[y][x] = &tile_types.at(tile_type);
}
}
}
}
void Map::PaintLine(TilePos start_tile, TilePos stop_tile, double width, TileType tile_type)
{
const vec<double, 2> start{static_cast<double>(start_tile.x()), static_cast<double>(start_tile.y())};
const vec<double, 2> stop{static_cast<double>(stop_tile.x()), static_cast<double>(stop_tile.y())};
const double line_length = start.DistanceTo(stop);
const vec<double, 2> step = (stop - start) / line_length;
const vec<double, 2> ortho = step.GetOrthogonal();
LOG_DEBUG("step = ", step, " ortho = ", ortho);
for (double t = 0; t < line_length; t += 1.0) {
for (double ortho_t = 0; ortho_t < width; ortho_t += 0.1) {
auto tile_pos = start + step * t + ortho * ortho_t;
TilePos tile_pos_int{static_cast<int32_t>(tile_pos.x()), static_cast<int32_t>(tile_pos.y())};
if (IsTilePosValid(tile_pos_int)) {
size_t row = static_cast<size_t>(tile_pos.x());
size_t col = static_cast<size_t>(tile_pos.y());
m_Tiles[row][col] = &tile_types.at(tile_type);
}
}
}
}
void Map::PaintRectangle(TilePos first_corner, TilePos second_corner, TileType tile_type)
{
std::initializer_list<int> xvals = {first_corner.x(), second_corner.x()};
std::initializer_list<int> yvals = {first_corner.y(), second_corner.y()};
for (int x = std::min(xvals); x < std::max(xvals); x++) {
for (int y = std::min(yvals); y < std::max(yvals); y++) {
TilePos tile_pos{x,y};
LOG_DEBUG("tile_pos = ", tile_pos);
if (IsTilePosValid(tile_pos)) {
size_t row = static_cast<size_t>(tile_pos.x());
size_t col = static_cast<size_t>(tile_pos.y());
m_Tiles[row][col] = &tile_types.at(tile_type);
}
}
}
}

51
cpp/src/map.hpp
View File

@ -1,51 +0,0 @@
#pragma once
#include <vector>
#include "math.hpp"
#include "tile.hpp"
using TileGrid = std::vector<std::vector<const Tile *>>;
class Map {
public:
static constexpr float TILE_SIZE = 10.0f; // tile size in world
Map(int rows, int cols);
Map() : Map(0, 0) {}
Map(const Map&) = delete;
Map(Map&&) = delete;
Map& operator=(const Map&) = delete;
Map& operator=(Map&&) = delete;
const TileGrid &GetMapTiles() const { return m_Tiles; }
// coordinate conversion functions
WorldPos TileToWorld(TilePos p) const;
WorldPos TileEdgeToWorld(TilePos p) const;
TilePos WorldToTile(WorldPos p) const;
WorldSize GetTileSize() const;
const Tile *GetTileAt(TilePos p) const;
const Tile *GetTileAt(WorldPos p) const;
bool IsTilePosValid(TilePos p) const;
// methods for drawing on the map
void PaintCircle(TilePos center, unsigned radius, TileType tile_type);
void PaintLine(TilePos start, TilePos stop, double width, TileType tile_type);
void PaintRectangle(TilePos first_corner, TilePos second_corner, TileType tile_type);
std::vector<TilePos> GetNeighbors(TilePos center) const;
float GetCost(TilePos pos) const { return GetTileAt(pos)->cost; }
template <typename T> double GetTileVelocityCoeff(T p) const {
return 1.0 / GetTileAt(p)->cost;
}
private:
TileGrid m_Tiles;
size_t m_Cols = 0;
size_t m_Rows = 0;
};

446
cpp/src/math.hpp
View File

@ -1,397 +1,93 @@
#pragma once
#include <algorithm>
#include <cassert>
#include <cmath>
#include <concepts>
#include <initializer_list>
#include <iostream>
#include <numeric>
#include <ranges>
#include <utility>
#include <functional>
#ifdef _WIN32
#include <numbers>
#define M_PI std::numbers::pi
// TODO use std::numbers::pi instead of M_PI
#endif
template <typename T>
requires std::floating_point<T>
static inline bool equalEpsilon(const T &a, const T &b) {
constexpr auto epsilon = []() {
if constexpr (std::is_same_v<T, float>) {
return T{1e-5};
} else {
return T{1e-12}; // double, long double
}
}();
if (a == b) {
// handle special cases: bit equality, Inf...
return true;
}
return std::abs(a - b) < epsilon;
}
struct Any {};
template <typename T, size_t N, typename Tag = Any> class vec {
template <typename T> struct Vec2D {
public:
vec() : m_Array{} {}
Vec2D() = default;
~Vec2D() = default;
template <typename... ArgsT>
requires(std::same_as<ArgsT, T> && ...) && (sizeof...(ArgsT) == N)
vec(ArgsT... args) : m_Array{args...} {}
//
// Access to elements & data
//
const T &operator[](size_t index) const {
// we leave run-time checks to the underlying std::array
return m_Array[index];
Vec2D &operator+=(const Vec2D &other) {
x += other.x;
y += other.y;
return *this;
}
T &operator[](size_t index) {
// we leave run-time checks to the underlying std::array
return m_Array[index];
friend Vec2D operator+(const Vec2D &a, const Vec2D &b) {
return Vec2D{a.x + b.x, a.y + b.y};
}
friend Vec2D operator-(const Vec2D &a, const Vec2D &b) {
return Vec2D{a.x - b.x, a.y - b.y};
}
friend std::ostream &operator<<(std::ostream &os, const vec &obj) {
os << "( ";
for (const auto &element : obj.m_Array) {
os << element << " ";
friend Vec2D operator*(float k, const Vec2D &v) {
return Vec2D{k * v.x, k * v.y};
}
Vec2D operator*(float b) const { return Vec2D{b * x, b * y}; }
T distance_squared(const Vec2D &other) const {
T dx = x - other.x;
T dy = y - other.y;
return dx * dx + dy * dy;
}
T distance(const Vec2D &other) const
requires std::floating_point<T>
{
return sqrt(distance_squared(other));
}
void normalize()
requires std::floating_point<T>
{
auto length = sqrt(x * x + y * y);
if (length < 1e-6) {
x = y = 0;
} else {
x /= length;
y /= length;
}
os << ")";
}
Vec2D normalized()
requires std::floating_point<T>
{
Vec2D v(*this);
v.normalize();
return v;
}
Vec2D orthogonal()
{
Vec2D v(*this);
std::swap(v.x, v.y);
v.x = -v.x;
return v;
}
template <typename U> Vec2D(std::initializer_list<U> list) {
assert(list.size() == 2);
auto first_element = *list.begin();
auto second_element = *(list.begin() + 1);
x = static_cast<T>(first_element);
y = static_cast<T>(second_element);
}
T x, y;
friend std::ostream &operator<<(std::ostream &os, const Vec2D &obj) {
os << "( " << obj.x << ", " << obj.y << ")";
return os;
}
std::array<T,N>& Data() { return m_Array; }
//
// binary operators
//
friend bool operator==(const vec &a, const vec &b)
requires (std::is_integral_v<T>)
{
return std::ranges::equal(a.m_Array, b.m_Array);
}
friend bool operator==(const vec &a, const vec &b)
requires (std::is_floating_point_v<T>)
{
for (const auto &[u, v] : std::views::zip(a.m_Array, b.m_Array)) {
if (!equalEpsilon(u, v)) {
return false;
}
}
return true;
}
friend bool operator!=(const vec &a, const vec &b) { return !(a == b); }
friend vec operator+(const vec &a, const vec &b) {
vec<T, N, Tag> c;
std::ranges::transform(a.m_Array, b.m_Array, c.m_Array.begin(),
std::plus{});
return c;
}
friend vec operator-(const vec &a, const vec &b) {
vec<T, N, Tag> c;
std::ranges::transform(a.m_Array, b.m_Array, c.m_Array.begin(),
std::minus{});
return c;
}
friend vec operator*(const vec &a, const T &scalar) {
vec<T, N, Tag> c;
std::ranges::transform(a.m_Array, std::views::repeat(scalar),
c.m_Array.begin(), std::multiplies{});
return c;
}
friend vec operator*(const T &scalar, const vec &a) { return a * scalar; }
friend vec operator/(const vec &a, const T &scalar) {
vec<T, N, Tag> c;
std::ranges::transform(a.m_Array, std::views::repeat(scalar),
c.m_Array.begin(), std::divides{});
return c;
}
//
// compound-assignment operators
//
vec &operator+=(const vec &b) {
vec &a = *this;
std::ranges::transform(a.m_Array, b.m_Array, a.m_Array.begin(),
std::plus{});
return a;
}
vec &operator-=(const vec &b) {
vec &a = *this;
std::ranges::transform(a.m_Array, b.m_Array, a.m_Array.begin(),
std::minus{});
return a;
}
vec& operator/=(float scalar)
{
vec& a = *this;
auto b = std::views::repeat(scalar);
std::ranges::transform(a.m_Array, b, a.m_Array.begin(), std::divides{});
// TODO check all of this, could be done better with views instead of ranges?
return a;
}
//
// Utility functions
//
T LengthSquared() const {
return std::transform_reduce(m_Array.begin(), m_Array.end(), T{},
std::plus{}, [](T x) { return x * x; });
}
T Length() const { return std::sqrt(LengthSquared()); }
T DistanceTo(const vec &b) const {
const vec &a = *this;
return (a - b).Length();
}
//
// In-place vector operations
//
void Normalize() {
T length = Length();
if (equalEpsilon(length, T{0}))
return;
std::ranges::transform(m_Array, std::views::repeat(length), m_Array.begin(),
std::divides{});
}
//
// Methods returning new object
//
vec GetNormalized() const {
vec tmp = *this;
tmp.Normalize();
return tmp;
}
vec GetOrthogonal() const
requires(N == 2)
{
vec tmp = *this;
std::swap(tmp.m_Array[0], tmp.m_Array[1]);
tmp.m_Array[0] *= -1;
return tmp;
}
static T DotProduct(const vec& a, const vec& b)
{
return std::inner_product(
a.m_Array.begin(), a.m_Array.end(), b.m_Array.begin(),
T{}, std::plus{}, std::multiplies{});
}
T DotProduct(const vec& b) const
{
const auto& a = *this;
return DotProduct(a, b);
}
//
// Helpers
//
const T &x() const
requires(N >= 1)
{
return m_Array[0];
}
T &x()
requires(N >= 1)
{
return m_Array[0];
}
const T &y() const
requires(N >= 2)
{
return m_Array[1];
}
T &y()
requires(N >= 2)
{
return m_Array[1];
}
const T &z() const
requires(N >= 3)
{
return m_Array[2];
}
T &z()
requires(N >= 3)
{
return m_Array[2];
}
private:
std::array<T, N> m_Array;
};
//
// Aliases
//
using vec2 = vec<float, 2>;
using vec3 = vec<float, 3>;
using vec4 = vec<float, 4>;
using dvec2 = vec<double, 2>;
using dvec3 = vec<double, 3>;
using dvec4 = vec<double, 4>;
using ivec2 = vec<std::int32_t, 2>;
using ivec3 = vec<std::int32_t, 3>;
using ivec4 = vec<std::int32_t, 4>;
using uvec2 = vec<std::uint32_t, 2>;
using uvec3 = vec<std::uint32_t, 3>;
using uvec4 = vec<std::uint32_t, 4>;
// tags for differentiating between domains
struct WorldPosTag {};
struct WorldSizeTag {};
struct WindowPosTag {};
struct WindowSizeTag {};
struct TilePosTag {};
struct TileSizeTag {};
// types for each domain
using WorldPos = vec<float, 2, WorldPosTag>;
using WindowPos = vec<float, 2, WindowPosTag>;
using TilePos = vec<int32_t, 2, TilePosTag>;
// Size
using WorldSize = vec<float, 2, WorldSizeTag>;
using WindowSize = vec<float, 2, WindowSizeTag>;
using TileSize = vec<int32_t, 2, TileSizeTag>;
//
// Utils
//
struct TilePosHash {
std::size_t operator()(const TilePos &p) const noexcept {
std::size_t h1 = std::hash<int>{}(p.x());
std::size_t h2 = std::hash<int>{}(p.y());
return h1 ^ (h2 + 0x9e3779b9 + (h1 << 6) + (h1 >> 2));
}
};
//
// Matrix
//
// Collumn major square matrix
template <typename T, size_t N, typename Tag = Any>
class Matrix {
using vec_type = vec<T, N, Tag>;
public:
Matrix() = default;
// Initialization using flat array of N*N elements
template <typename Tarr, size_t M>
requires (M == N*N && std::same_as<Tarr, T>)
Matrix(std::array<Tarr,M> array) : m_Array{}
{
std::size_t idx = 0;
for (auto col : array | std::views::chunk(N))
{
std::ranges::copy(col, m_Array[idx++].Data().begin());
}
}
const vec_type& operator[](size_t index) const { return m_Array[index]; }
vec_type& operator[](size_t index) { return m_Array[index]; }
friend std::ostream &operator<<(std::ostream &os, const Matrix &obj)
{
os << "( ";
for (const auto &element : obj.m_Array) {
os << element << " ";
}
os << ")";
return os;
}
friend Matrix operator+(const Matrix& A, const Matrix& B)
{
Matrix C;
std::ranges::transform(A.m_Array, B.m_Array, C.m_Array.begin(), std::plus{});
return C;
}
friend Matrix operator-(const Matrix& A, const Matrix& B)
{
Matrix C;
std::ranges::transform(A.m_Array, B.m_Array, C.m_Array.begin(), std::minus{});
return C;
}
friend Matrix operator*(const Matrix& A, const Matrix& B)
{
Matrix C;
for (size_t i = 0; i < N; i++)
{
for (size_t j = 0; j < N; j++)
{
T sum = 0;
for (size_t k = 0; k < N; ++k) sum += A[i][k] * B[k][j];
C[i][j] = sum;
}
}
return C;
}
friend vec_type operator*(const Matrix& A, const vec_type& b)
{
// we assume that b is row vector
vec_type c;
for (size_t i = 0; i < N; i++)
{
c[i] = b.DotProduct(A[i]);
}
return c;
}
static constexpr Matrix Eye()
{
Matrix E;
for (size_t i = 0; i < N; i++)
{
E[i][i] = T{1};
}
return E;
}
private:
std::array<vec_type, N> m_Array;
};

0
cpp/src/pathfinder/astar.cpp
View File

0
cpp/src/pathfinder/astar.hpp
View File

22
cpp/src/pathfinder/base.cpp
View File

@ -1,22 +0,0 @@
#include <memory>
#include <cassert>
#include <queue>
#include "pathfinder/base.hpp"
#include "log.hpp"
#include "math.hpp"
namespace pathfinder {
PathFinderBase::PathFinderBase(const Map* map) : m_Map(map) {}
// LinearPathFinder also lives here, since it is too small to get it's
// own implementation file
Path LinearPathFinder::CalculatePath(WorldPos, WorldPos end) // first argument (start pos) not used
{
auto path = Path{end};
return path;
}
} // pathfinder namespace

52
cpp/src/pathfinder/base.hpp
View File

@ -1,52 +0,0 @@
#pragma once
#include <vector>
#include <memory>
#include <unordered_map>
#include "math.hpp"
#include "map.hpp"
namespace pathfinder {
using Path = std::vector<WorldPos>;
enum class PathFinderType {
LINEAR = 1,
BFS,
DIJKSTRA,
GBFS,
COUNT,
};
class PathFinderBase {
public:
PathFinderBase(const Map* m);
~PathFinderBase() = default;
PathFinderBase(const PathFinderBase&) = delete;
PathFinderBase(PathFinderBase&&) = delete;
PathFinderBase& operator=(const PathFinderBase&) = delete;
PathFinderBase& operator=(PathFinderBase&&) = delete;
virtual const std::string_view& GetName() const = 0;
virtual Path CalculatePath(WorldPos start, WorldPos end) = 0;
protected:
const Map* m_Map;
};
class LinearPathFinder : public PathFinderBase {
public:
LinearPathFinder(const Map* m): PathFinderBase(m) {}
Path CalculatePath(WorldPos start, WorldPos end) override;
const std::string_view& GetName() const override { return m_Name; }
private:
const std::string_view m_Name = "Linear Path";
};
} // pathfinder namespace

66
cpp/src/pathfinder/bfs.cpp
View File

@ -1,66 +0,0 @@
#include <queue>
#include "bfs.hpp"
#include "base.hpp"
#include "map.hpp"
#include "math.hpp"
namespace pathfinder {
Path BFS::CalculatePath(WorldPos start_world, WorldPos end_world) {
if (m_Map == nullptr) return {};
const TilePos start = m_Map->WorldToTile(start_world);
const TilePos end = m_Map->WorldToTile(end_world);
if (!m_Map->IsTilePosValid(start) || !m_Map->IsTilePosValid(end))
return {};
if (start == end) {
return {};
}
// clear previous run
m_CameFrom.clear();
m_Distance.clear();
std::queue<TilePos> frontier;
frontier.push(start);
m_CameFrom[start] = start;
m_Distance[start] = 0.0f;
// ---------------- build flow-field ----------------
bool early_exit = false;
while (!frontier.empty() && !early_exit) {
TilePos current = frontier.front();
frontier.pop();
for (TilePos next : m_Map->GetNeighbors(current)) {
if (m_CameFrom.find(next) == m_CameFrom.end()) { // not visited
frontier.push(next);
m_Distance[next] = m_Distance[current] + 1.0f;
m_CameFrom[next] = current;
if (next == end) { // early exit
early_exit = true;
break;
}
}
}
}
// --------------- reconstruct path -----------------
if (m_CameFrom.find(end) == m_CameFrom.end())
return {}; // end not reached
Path path;
TilePos cur = end;
path.push_back(m_Map->TileToWorld(cur));
while (cur != start) {
cur = m_CameFrom[cur];
path.push_back(m_Map->TileToWorld(cur));
}
std::reverse(path.begin(), path.end());
return path;
}
} // pathfinder namespace

25
cpp/src/pathfinder/bfs.hpp
View File

@ -1,25 +0,0 @@
#pragma once
#include <string_view>
#include <unordered_map>
#include "base.hpp"
#include "math.hpp"
namespace pathfinder {
class BFS: public PathFinderBase {
public:
BFS(const Map* m): PathFinderBase(m) {}
Path CalculatePath(WorldPos start, WorldPos end) override;
const std::string_view& GetName() const override { return m_Name; }
private:
const std::string_view m_Name = "Breadth First Search";
std::unordered_map<TilePos, double, TilePosHash> m_Distance;
std::unordered_map<TilePos, TilePos, TilePosHash> m_CameFrom;
};
}

73
cpp/src/pathfinder/dijkstra.cpp
View File

@ -1,73 +0,0 @@
#include <queue>
#include "dijkstra.hpp"
#include "base.hpp"
#include "utils.hpp"
#include "math.hpp"
#include "map.hpp"
namespace pathfinder {
Path Dijkstra::CalculatePath(WorldPos start_world, WorldPos end_world)
{
using QueueEntry = utils::QueueEntry;
if (!m_Map) return {};
const TilePos start = m_Map->WorldToTile(start_world);
const TilePos end = m_Map->WorldToTile(end_world);
if (!m_Map->IsTilePosValid(start) || !m_Map->IsTilePosValid(end))
return {};
if (start == end) return {};
// clear previous run
m_CameFrom.clear();
m_Cost.clear();
std::priority_queue<QueueEntry, std::vector<QueueEntry>, std::greater<>> frontier;
frontier.push({0.0f, start});
m_CameFrom[start] = start; // sentinel
m_Cost[start] = 0.0f;
while (!frontier.empty())
{
const QueueEntry current = frontier.top();
frontier.pop();
if (current.tile == end) // early exit
break;
for (TilePos next : m_Map->GetNeighbors(current.tile))
{
// cost of moving to neighbour (uniform 1.0 matches original BFS)
const float newCost = m_Cost[current.tile] + m_Map->GetCost(next);
if (!m_Cost.count(next) || newCost < m_Cost[next])
{
m_Cost[next] = newCost;
m_CameFrom[next] = current.tile;
frontier.push({newCost, next});
}
}
}
// reconstruct path
if (!m_CameFrom.count(end))
return {}; // goal never reached
Path path;
TilePos cur = end;
path.push_back(m_Map->TileToWorld(cur));
while (cur != start)
{
cur = m_CameFrom[cur];
path.push_back(m_Map->TileToWorld(cur));
}
std::reverse(path.begin(), path.end());
return path;
}
} // pathfinder namespace

26
cpp/src/pathfinder/dijkstra.hpp
View File

@ -1,26 +0,0 @@
#pragma once
#include <string_view>
#include <unordered_map>
#include "base.hpp"
#include "map.hpp"
#include "math.hpp"
namespace pathfinder {
class Dijkstra: public PathFinderBase {
public:
Dijkstra(const Map* m): PathFinderBase(m) {}
Path CalculatePath(WorldPos start, WorldPos end) override;
const std::string_view& GetName() const override { return m_Name; }
private:
const std::string_view m_Name = "Dijkstra's Algorithm";
std::unordered_map<TilePos, double, TilePosHash> m_Cost;
std::unordered_map<TilePos, TilePos, TilePosHash> m_CameFrom;
};
} // pathfinder namespace

71
cpp/src/pathfinder/gbfs.cpp
View File

@ -1,71 +0,0 @@
#include <queue>
#include "gbfs.hpp"
#include "base.hpp"
#include "math.hpp"
#include "map.hpp"
#include "pathfinder/utils.hpp"
namespace pathfinder {
float GBFS::Heuristic(const TilePos& a, const TilePos& b)
{
return static_cast<float>(std::abs(a.x() - b.x()) + std::abs(a.y() - b.y()));
}
Path GBFS::CalculatePath(WorldPos start_world, WorldPos end_world)
{
using QueueEntry = pathfinder::utils::QueueEntry;
if (!m_Map) return {};
const TilePos start = m_Map->WorldToTile(start_world);
const TilePos end = m_Map->WorldToTile(end_world);
if (!m_Map->IsTilePosValid(start) || !m_Map->IsTilePosValid(end))
return {};
if (start == end) return {};
m_CameFrom.clear();
std::priority_queue<QueueEntry, std::vector<QueueEntry>, std::greater<>> frontier;
frontier.push({Heuristic(start, end), start});
m_CameFrom[start] = start; // sentinel
while (!frontier.empty())
{
const QueueEntry current = frontier.top();
frontier.pop();
if (current.tile == end) // early exit
break;
for (TilePos next : m_Map->GetNeighbors(current.tile))
{
if (!m_CameFrom.count(next)) // not visited
{
m_CameFrom[next] = current.tile;
frontier.push({Heuristic(end, next), next});
}
}
}
// reconstruct path
if (!m_CameFrom.count(end))
return {}; // goal never reached
Path path;
TilePos cur = end;
path.push_back(m_Map->TileToWorld(cur));
while (cur != start)
{
cur = m_CameFrom[cur];
path.push_back(m_Map->TileToWorld(cur));
}
std::reverse(path.begin(), path.end());
return path;
}
} // pathfinder namespace

26
cpp/src/pathfinder/gbfs.hpp
View File

@ -1,26 +0,0 @@
#pragma once
#include <string_view>
#include <unordered_map>
#include "base.hpp"
#include "map.hpp"
#include "math.hpp"
namespace pathfinder {
class GBFS: public PathFinderBase {
public:
GBFS(const Map* m): PathFinderBase(m) {}
Path CalculatePath(WorldPos start, WorldPos end) override;
const std::string_view& GetName() const override { return m_Name; }
private:
static float Heuristic(const TilePos& a, const TilePos& b);
const std::string_view m_Name = "Greedy Best First Search";
std::unordered_map<TilePos, TilePos, TilePosHash> m_CameFrom;
};
} // pathfinder namespace

0
cpp/src/pathfinder/linear.cpp
View File

0
cpp/src/pathfinder/linear.hpp
View File

35
cpp/src/pathfinder/utils.cpp
View File

@ -1,35 +0,0 @@
#include <memory>
#include "utils.hpp"
#include "base.hpp"
#include "map.hpp"
#include "math.hpp"
#include "log.hpp"
#include "pathfinder/bfs.hpp"
#include "pathfinder/dijkstra.hpp"
#include "pathfinder/gbfs.hpp"
namespace pathfinder {
namespace utils {
std::unique_ptr<PathFinderBase> create(PathFinderType type, const Map* map) {
using namespace pathfinder;
switch (type) {
case PathFinderType::LINEAR:
return std::move(std::make_unique<LinearPathFinder>(map));
case PathFinderType::BFS:
return std::move(std::make_unique<BFS>(map));
case PathFinderType::DIJKSTRA:
return std::move(std::make_unique<Dijkstra>(map));
case PathFinderType::GBFS:
return std::move(std::make_unique<GBFS>(map));
case PathFinderType::COUNT:
LOG_WARNING("Incorrect pathfinder type");
return nullptr;
};
return nullptr;
}
} // utils namespace
} // pathfinding namespace

25
cpp/src/pathfinder/utils.hpp
View File

@ -1,25 +0,0 @@
#pragma once
#include <memory>
#include "pathfinder/base.hpp"
#include "map.hpp"
#include "math.hpp"
namespace pathfinder {
namespace utils {
struct QueueEntry
{
float cost;
TilePos tile;
// min-heap -> smallest cost on top
bool operator>(const QueueEntry& o) const noexcept { return cost > o.cost; }
};
std::unique_ptr<pathfinder::PathFinderBase> create(pathfinder::PathFinderType type, const Map* map);
} // utils namespace
} // pathfinding namespace

144
cpp/src/pathfindingdemo.cpp
View File

@ -1,144 +0,0 @@
#include <memory>
#include <optional>
#include <queue>
#include <vector>
#include "pathfindingdemo.hpp"
#include "entities.hpp"
#include "log.hpp"
#include "map.hpp"
#include "user_input.hpp"
#include "pathfinder/base.hpp"
#include "pathfinder/utils.hpp"
#include "tile.hpp"
PathFindingDemo::PathFindingDemo(int width, int height) :
m_Map(width, height)
{
LOG_DEBUG(".");
// set default pathfinder method
m_PathFinder = pathfinder::utils::create(pathfinder::PathFinderType::DIJKSTRA, (const Map*)&m_Map);
}
PathFindingDemo::~PathFindingDemo() { LOG_DEBUG("."); }
void PathFindingDemo::AddEntity(std::shared_ptr<Entity> e) {
// TODO emplace_back
m_Entities.push_back(e);
}
void PathFindingDemo::CreateMap() {
// lake
m_Map.PaintCircle(TilePos{50, 50}, 10, TileType::WATER);
m_Map.PaintCircle(TilePos{75, 100}, 50, TileType::WATER);
// river
m_Map.PaintLine(TilePos{0,0}, TilePos{100,100}, 3.0, TileType::WATER);
// road
m_Map.PaintLine(TilePos{17,6}, TilePos{100,6}, 5.0, TileType::ROAD);
m_Map.PaintLine(TilePos{10,17}, TilePos{10,100}, 5.0, TileType::ROAD);
m_Map.PaintLine(TilePos{20,10}, TilePos{10,20}, 5.0, TileType::ROAD);
// bridges
m_Map.PaintLine(TilePos{50,75}, TilePos{70,75}, 5.0, TileType::WOOD);
m_Map.PaintLine(TilePos{95,26}, TilePos{95,60}, 5.0, TileType::WOOD);
// island
m_Map.PaintRectangle(TilePos{70, 60}, TilePos{100,100}, TileType::GRASS);
// walls
m_Map.PaintLine(TilePos{71,60}, TilePos{90,60}, 1.0, TileType::WALL);
m_Map.PaintLine(TilePos{77,67}, TilePos{100,67}, 1.0, TileType::WALL);
m_Map.PaintLine(TilePos{71,60}, TilePos{71,75}, 1.0, TileType::WALL);
m_Map.PaintLine(TilePos{72,73}, TilePos{95,73}, 1.0, TileType::WALL);
m_Map.PaintLine(TilePos{95,73}, TilePos{95,90}, 1.0, TileType::WALL);
m_Map.PaintLine(TilePos{71,81}, TilePos{71,100}, 1.0, TileType::WALL);
m_Map.PaintLine(TilePos{72,81}, TilePos{90,81}, 1.0, TileType::WALL);
m_Map.PaintLine(TilePos{89,87}, TilePos{89,100}, 1.0, TileType::WALL);
m_Map.PaintLine(TilePos{84,81}, TilePos{84,96}, 1.0, TileType::WALL);
m_Map.PaintLine(TilePos{78,87}, TilePos{78,100}, 1.0, TileType::WALL);
// add player
m_Entities.clear();
m_Player = std::make_shared<Player>();
m_Player->SetPosition(m_Map.TileToWorld(TilePos{25, 20}));
m_Entities.push_back(m_Player);
}
WorldPos PathFindingDemo::GetRandomPosition() const {
return WorldPos{0.0f, 0.0f}; // totally random!
}
std::optional<WorldPos> PathFindingDemo::GetMoveTarget() {
WorldPos current_player_pos = GetPlayer()->GetPosition();
if (m_Path.empty()) {
return {};
}
WorldPos next_player_pos = m_Path.front();
if (current_player_pos.DistanceTo(next_player_pos) > 1.0) {
// target not reached yet
return next_player_pos;
}
// target reached, pop it
//m_MoveQueue.pop();
m_Path.erase(m_Path.begin());
// return nothing - if there's next point in the queue,
// we'll get it in the next iteration
return {};
}
void PathFindingDemo::UpdatePlayerVelocity() {
auto player = GetPlayer();
auto current_pos = player->GetPosition();
double tile_velocity_coeff = m_Map.GetTileVelocityCoeff(current_pos);
auto next_pos = GetMoveTarget();
WorldPos velocity = WorldPos{};
if (next_pos)
{
velocity = next_pos.value() - current_pos;
velocity.Normalize();
//LOG_DEBUG("I want to move to: ", next_pos.value(),
// ", velocity: ", velocity);
}
player->SetActualVelocity(velocity * tile_velocity_coeff);
float time_delta = 1.0f;
player->Update(time_delta);
}
void PathFindingDemo::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::SET_MOVE_TARGET)
{
WorldPos wp = m_Camera.WindowToWorld(action.Argument.position);
LOG_INFO("Calculating path to target: ", wp);
m_Path = m_PathFinder->CalculatePath(m_Player->GetPosition(), wp);
LOG_INFO("Done, path node count: ", m_Path.size());
}
else if (action.type == UserAction::Type::SELECT_PATHFINDER)
{
using namespace pathfinder;
PathFinderType type = static_cast<PathFinderType>(action.Argument.number);
m_PathFinder = pathfinder::utils::create(type, (const Map*)&m_Map);
LOG_INFO("Switched to path finding method: ", m_PathFinder->GetName());
}
else if (action.type == UserAction::Type::CAMERA_PAN)
{
const auto& window_pan = action.Argument.position;
WorldPos world_pan{window_pan.x(), window_pan.y()};
m_Camera.Pan(world_pan);
LOG_INFO("Camera pan delta: ", world_pan);
}
else if (action.type == UserAction::Type::CAMERA_ZOOM)
{
m_Camera.Zoom(action.Argument.float_number);
LOG_INFO("Camera zoom: ", action.Argument.float_number);
}
};
}

47
cpp/src/pathfindingdemo.hpp
View File

@ -1,47 +0,0 @@
#pragma once
#include <memory>
#include <optional>
#include <queue>
#include <vector>
#include "entities.hpp"
#include "log.hpp"
#include "map.hpp"
#include "user_input.hpp"
#include "pathfinder/base.hpp"
#include "camera.hpp"
class PathFindingDemo {
public:
PathFindingDemo(int width, int height);
~PathFindingDemo();
PathFindingDemo(const PathFindingDemo &m) = delete;
PathFindingDemo(PathFindingDemo &&m) = delete;
PathFindingDemo &operator=(const PathFindingDemo &) = delete;
PathFindingDemo &operator=(PathFindingDemo &&) = delete;
std::shared_ptr<Player> GetPlayer() { return m_Player; }
std::vector<std::shared_ptr<Entity>>& GetEntities() { return m_Entities; }
const Map& GetMap() const { return m_Map; }
const Camera& GetCamera() const { return m_Camera; }
const pathfinder::Path& GetPath() const { return m_Path; }
bool IsExitRequested() const { return m_ExitRequested; }
void AddEntity(std::shared_ptr<Entity> e);
void CreateMap();
std::optional<WorldPos> GetMoveTarget();
void UpdatePlayerVelocity();
void HandleActions(const std::vector<UserAction> &actions);
WorldPos GetRandomPosition() const;
private:
bool m_ExitRequested = false;
Map m_Map;
Camera m_Camera;
std::vector<std::shared_ptr<Entity>> m_Entities;
std::shared_ptr<Player> m_Player;
pathfinder::Path m_Path;
std::unique_ptr<pathfinder::PathFinderBase> m_PathFinder;
};

52
cpp/src/sprite.cpp
View File

@ -1,52 +0,0 @@
#include "sprite.hpp"
#include <SDL3/SDL.h>
#include <SDL3_image/SDL_image.h>
#include <cassert>
#include <memory>
#include <stdexcept>
#include <string>
#include "log.hpp"
#include "math.hpp"
Sprite::Sprite() : m_Texture(nullptr, SDL_DestroyTexture) {}
Sprite::Sprite(std::string path, WorldPos center) : Sprite() {
LoadImage(path, center);
}
Sprite::~Sprite() { LOG_DEBUG("."); }
void Sprite::LoadImage(std::string path, WorldPos image_center) {
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
void Sprite::SetRenderer(std::shared_ptr<SDL_Renderer> renderer) {
m_Renderer = renderer;
}
std::shared_ptr<SDL_Renderer> Sprite::m_Renderer = nullptr;

40
cpp/src/sprite.hpp
View File

@ -1,40 +0,0 @@
#pragma once
#include <SDL3/SDL.h>
#include <SDL3_image/SDL_image.h>
#include <cassert>
#include <memory>
#include <stdexcept>
#include <string>
#include "log.hpp"
#include "math.hpp"
class Sprite {
public:
Sprite();
~Sprite();
explicit Sprite(std::string path, WorldPos center = WorldPos{});
Sprite(const Sprite &) = delete;
Sprite &operator=(const Sprite &) = delete;
Sprite(Sprite &&) = delete;
Sprite &operator=(Sprite &&) = delete;
static void SetRenderer(std::shared_ptr<SDL_Renderer> renderer);
// GetTexture cannot return pointer to const, as SDL_RenderTexture modifies it
SDL_Texture *GetTexture() { return m_Texture.get(); }
WorldSize GetSize() const { return m_Size; }
WorldPos GetCenter() const { return m_ImageCenter; }
void LoadImage(std::string path, WorldPos image_center = WorldPos{});
private:
static std::shared_ptr<SDL_Renderer> m_Renderer;
std::unique_ptr<SDL_Texture, decltype(&SDL_DestroyTexture)> m_Texture;
WorldSize m_Size;
WorldPos m_ImageCenter;
float m_TextureWidth = 0;
float m_TextureHeight = 0;
};

158
cpp/src/test.cpp Normal file
View File

@ -0,0 +1,158 @@
#include <cassert>
#include <cmath>
#include <concepts>
#include <gtest/gtest.h>
#include <sstream>
#include <unordered_set>
#include "array.hpp"
#include "log.hpp"
#include "math.hpp"
// Vec2D Tests
TEST(Vec2D, DefaultConstruction) {
Vec2D<int> v;
// Default values are uninitialized, but we can test basic functionality
v.x = 0;
v.y = 0;
ASSERT_EQ(v.x, 0);
ASSERT_EQ(v.y, 0);
}
TEST(Vec2D, InitializerListConstruction) {
Vec2D<int> v{3, 4};
ASSERT_EQ(v.x, 3);
ASSERT_EQ(v.y, 4);
Vec2D<float> vf{1.5f, 2.5f};
ASSERT_FLOAT_EQ(vf.x, 1.5f);
ASSERT_FLOAT_EQ(vf.y, 2.5f);
// Test type conversion
Vec2D<float> vd{1, 2}; // int to float
ASSERT_FLOAT_EQ(vd.x, 1.0f);
ASSERT_FLOAT_EQ(vd.y, 2.0f);
}
TEST(Vec2D, Addition) {
Vec2D<int> a{1, 2};
Vec2D<int> b{3, 4};
Vec2D<int> c = a + b;
ASSERT_EQ(c.x, 4);
ASSERT_EQ(c.y, 6);
// Test that original vectors are unchanged
ASSERT_EQ(a.x, 1);
ASSERT_EQ(a.y, 2);
ASSERT_EQ(b.x, 3);
ASSERT_EQ(b.y, 4);
}
TEST(Vec2D, AdditionAssignment) {
Vec2D<int> a{1, 2};
Vec2D<int> b{3, 4};
a += b;
ASSERT_EQ(a.x, 4);
ASSERT_EQ(a.y, 6);
// Test that b is unchanged
ASSERT_EQ(b.x, 3);
ASSERT_EQ(b.y, 4);
}
TEST(Vec2D, ScalarMultiplication) {
Vec2D<int> v{2, 3};
Vec2D<int> result = v * 2.0f;
ASSERT_EQ(result.x, 4);
ASSERT_EQ(result.y, 6);
// Test with float vector
Vec2D<float> vf{1.5f, 2.5f};
Vec2D<float> resultf = vf * 2.0f;
ASSERT_FLOAT_EQ(resultf.x, 3.0f);
ASSERT_FLOAT_EQ(resultf.y, 5.0f);
}
TEST(Vec2D, Normalization) {
Vec2D<float> v{3.0f, 4.0f}; // Length = 5
v.normalize();
ASSERT_FLOAT_EQ(v.x, 0.6f);
ASSERT_FLOAT_EQ(v.y, 0.8f);
// Check that length is approximately 1
float length = sqrt(v.x * v.x + v.y * v.y);
ASSERT_NEAR(length, 1.0f, 1e-6f);
}
TEST(Vec2D, NormalizedCopy) {
Vec2D<float> v{3.0f, 4.0f};
Vec2D<float> normalized = v.normalized();
// Original should be unchanged
ASSERT_FLOAT_EQ(v.x, 3.0f);
ASSERT_FLOAT_EQ(v.y, 4.0f);
// Normalized copy should be unit length
ASSERT_FLOAT_EQ(normalized.x, 0.6f);
ASSERT_FLOAT_EQ(normalized.y, 0.8f);
float length =
sqrt(normalized.x * normalized.x + normalized.y * normalized.y);
ASSERT_NEAR(length, 1.0f, 1e-6f);
}
TEST(Vec2D, ZeroVectorNormalization) {
Vec2D<float> v{0.0f, 0.0f};
v.normalize();
ASSERT_FLOAT_EQ(v.x, 0.0f);
ASSERT_FLOAT_EQ(v.y, 0.0f);
// Test normalized() as well
Vec2D<float> v2{0.0f, 0.0f};
Vec2D<float> normalized = v2.normalized();
ASSERT_FLOAT_EQ(normalized.x, 0.0f);
ASSERT_FLOAT_EQ(normalized.y, 0.0f);
}
TEST(Vec2D, VerySmallVectorNormalization) {
Vec2D<float> v{1e-7f, 1e-7f}; // Very small vector
v.normalize();
// Should be treated as zero vector
ASSERT_FLOAT_EQ(v.x, 0.0f);
ASSERT_FLOAT_EQ(v.y, 0.0f);
}
TEST(Vec2D, OutputOperator) {
Vec2D<int> v{42, 24};
std::ostringstream oss;
oss << v;
ASSERT_EQ(oss.str(), "( 42, 24)");
}
TEST(Vec2D, ChainedOperations) {
Vec2D<float> a{1.0f, 2.0f};
Vec2D<float> b{3.0f, 4.0f};
// Test chaining: (a + b) * 2.0f
Vec2D<float> result = (a + b) * 2.0f;
ASSERT_FLOAT_EQ(result.x, 8.0f);
ASSERT_FLOAT_EQ(result.y, 12.0f);
// Test chaining with assignment
a += b;
a = a * 0.5f;
ASSERT_FLOAT_EQ(a.x, 2.0f);
ASSERT_FLOAT_EQ(a.y, 3.0f);
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

14
cpp/src/tile.cpp
View File

@ -1,14 +0,0 @@
#include <array>
#include <unordered_map>
#include "tile.hpp"
// we could use array here, but this is more explicit,
// and we don't access tile_types that often, so it should be ok
const std::unordered_map<TileType, Tile> tile_types = {
{ TileType::GRASS, Tile{1.0, 0, 200, 0, 255}},
{ TileType::WOOD, Tile{1.0, 132, 68, 0, 255}},
{ TileType::ROAD, Tile{0.5, 20, 20, 20, 255}},
{ TileType::WATER, Tile{10.0, 0, 50, 200, 255}},
{ TileType::WALL, Tile{1000.0, 144, 33, 0, 255}},
};

22
cpp/src/tile.hpp
View File

@ -1,22 +0,0 @@
#pragma once
#include <cstdint>
#include <map>
#include <string_view>
#include <array>
#include <unordered_map>
struct Tile {
float cost;
uint8_t R, G, B, A;
};
enum class TileType {
GRASS,
WOOD,
ROAD,
WATER,
WALL,
};
extern const std::unordered_map<TileType, Tile> tile_types;

133
cpp/src/user_input.cpp
View File

@ -1,133 +0,0 @@
#include <SDL3/SDL.h>
#include <expected>
#include <map>
#include <string>
#include <vector>
#include <unordered_set>
#include "user_input.hpp"
#include "log.hpp"
#include "math.hpp"
UserInput::UserInput()
: // pre-alloc some space
m_Actions(10) {
LOG_DEBUG(".");
};
UserInput::~UserInput() { LOG_DEBUG("."); };
std::expected<void, std::string> UserInput::Init() { return {}; }
void UserInput::GetActions_mouse(const SDL_Event& event)
{
static bool mouse_pan = false;
SDL_MouseButtonEvent mouse_event = event.button;
MouseButton button = static_cast<MouseButton>(mouse_event.button);
if (event.type == SDL_EVENT_MOUSE_BUTTON_DOWN)
{
if (button == MouseButton::LEFT)
{
LOG_DEBUG("Mouse down: ", mouse_event.x, ", ", mouse_event.y);
m_Actions.emplace_back(UserAction::Type::SET_MOVE_TARGET,
WindowPos{mouse_event.x, mouse_event.y});
}
else if (button == MouseButton::MIDDLE)
{
mouse_pan = true;
}
}
else if (event.type == SDL_EVENT_MOUSE_BUTTON_UP)
{
if (button == MouseButton::MIDDLE)
{
mouse_pan = false;
}
}
else if (event.type == SDL_EVENT_MOUSE_MOTION)
{
SDL_MouseMotionEvent motion_event = event.motion;
if (mouse_pan)
{
m_Actions.emplace_back(UserAction::Type::CAMERA_PAN,
WindowPos{motion_event.xrel, motion_event.yrel});
}
}
else if(event.type == SDL_EVENT_MOUSE_WHEEL)
{
SDL_MouseWheelEvent mouse_wheel = event.wheel;
m_Actions.emplace_back(UserAction::Type::CAMERA_ZOOM, mouse_wheel.y);
}
}
void UserInput::GetActions_keyboard(const SDL_Event& event)
{
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
return;
}
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);
return;
case '1':
case '2':
case '3':
case '4':
if (key_down) {
int selection = kbd_event.key - '0';
m_Actions.emplace_back(UserAction::Type::SELECT_PATHFINDER, selection);
LOG_INFO("Pathfinder selected: ", selection);
}
break;
default:
LOG_INFO("Key '", static_cast<char>(kbd_event.key), "' not mapped");
break;
}
}
const std::vector<UserAction>& UserInput::GetActions() {
static std::unordered_set<uint32_t> mouse_events = {
SDL_EVENT_MOUSE_MOTION,
SDL_EVENT_MOUSE_BUTTON_DOWN,
SDL_EVENT_MOUSE_BUTTON_UP,
SDL_EVENT_MOUSE_WHEEL,
SDL_EVENT_MOUSE_ADDED,
SDL_EVENT_MOUSE_REMOVED,
};
static std::unordered_set<uint32_t> keyboard_events = {
SDL_EVENT_KEY_DOWN,
SDL_EVENT_KEY_UP,
};
SDL_Event event;
m_Actions.clear();
while (SDL_PollEvent(&event))
{
if (keyboard_events.contains(event.type))
{
GetActions_keyboard(event);
}
else if (mouse_events.contains(event.type))
{
GetActions_mouse(event);
}
else
{
// TODO uncomment, for now too much noise
// LOG_WARNING("Action not processed");
}
}
return m_Actions;
}

57
cpp/src/user_input.hpp
View File

@ -1,57 +0,0 @@
#pragma once
#include <expected>
#include <string>
#include <vector>
#include "log.hpp"
#include "math.hpp"
// Seems like SDL doesn't have named constants for mouse button
enum class MouseButton { LEFT = 1, MIDDLE, RIGHT };
class UserAction {
public:
enum class Type { NONE, EXIT, SET_MOVE_TARGET, SELECT_PATHFINDER, CAMERA_PAN, CAMERA_ZOOM };
UserAction() : type(Type::NONE), Argument{.number = 0} {}
UserAction(Type t) : type(t), Argument{.number = 0} {}
UserAction(Type t, char key) : type(t), Argument{.key = key} {}
UserAction(Type t, WindowPos v) : type(t), Argument{.position = v} {}
UserAction(Type t, int32_t arg) : type(t), Argument{.number = arg} {}
UserAction(Type t, float arg) : type(t), Argument{.float_number = arg} {}
~UserAction() = default;
Type type;
union {
WindowPos position;
char key;
int32_t number;
float float_number;
} Argument;
// TODO use std::variant
//std::variant<WindowPos, char, int> Argument;
};
class UserInput {
public:
UserInput();
~UserInput();
UserInput(const UserInput &x) = delete;
UserInput(UserInput &&x) = delete;
UserInput &operator=(const UserInput &) = delete;
UserInput &operator=(UserInput &&) = delete;
std::expected<void, std::string> Init();
const std::vector<UserAction> &GetActions();
private:
std::vector<UserAction> m_Actions;
void GetActions_keyboard(const SDL_Event&);
void GetActions_mouse(const SDL_Event&);
};

118
cpp/src/window.cpp
View File

@ -1,118 +0,0 @@
#include <GL/glew.h>
#include <SDL3/SDL.h>
#include <SDL3/SDL_opengl.h>
#include <cmath>
#include <cstdlib>
#include <expected>
#include <memory>
#include <string>
#include "window.hpp"
#include "log.hpp"
#include "math.hpp"
#include "sprite.hpp"
Window::Window(int width, int height) : m_Width(width), m_Height(height) {
LOG_DEBUG(".");
}
std::expected<void, std::string> Window::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::~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 Window::DrawSprite(const WindowPos &position, Sprite &s, float scale) {
WorldSize size = s.GetSize() * scale;
WorldPos img_center = s.GetCenter() * scale;
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 Window::DrawRect(const WindowPos &position, const WindowSize size, uint8_t R,
uint8_t G, uint8_t B, uint8_t A) {
SDL_FRect rect = {position.x(), position.y(), size.x(), size.y()};
SDL_SetRenderDrawColor(m_Renderer.get(), R, G, B, A);
SDL_RenderFillRect(m_Renderer.get(), &rect);
}
void Window::ClearWindow() {
SDL_SetRenderDrawColor(m_Renderer.get(), 50, 50, 50, 255);
SDL_RenderClear(m_Renderer.get());
}
void Window::Flush() { SDL_RenderPresent(m_Renderer.get()); }
void Window::DrawCircle(const WindowPos &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))));
}
}
void Window::DrawLine(const WindowPos &A, const WindowPos &B)
{
SDL_SetRenderDrawColor(m_Renderer.get(), 255, 0, 0, 255);
SDL_RenderLine(m_Renderer.get(), A.x(), A.y(), B.x(), B.y());
}

40
cpp/src/window.hpp
View File

@ -1,40 +0,0 @@
#pragma once
#include <GL/glew.h>
#include <SDL3/SDL.h>
#include <SDL3/SDL_opengl.h>
#include <cmath>
#include <expected>
#include <memory>
#include <string>
#include "math.hpp"
#include "sprite.hpp"
class Window {
public:
Window(int width, int height);
~Window();
Window(const Window &x) = delete;
Window(Window &&x) = delete;
Window &operator=(const Window &) = delete;
Window &operator=(Window &&) = delete;
std::expected<void, std::string> Init();
void DrawSprite(const WindowPos &position, Sprite &s, float scale = 1.0f);
void DrawRect(const WindowPos &position, const WindowSize size, uint8_t R,
uint8_t G, uint8_t B, uint8_t A);
void ClearWindow();
void Flush();
void DrawCircle(const WindowPos &position, float radius);
void DrawLine(const WindowPos &A, const WindowPos &B);
private:
uint32_t m_Width;
uint32_t m_Height;
std::shared_ptr<SDL_Renderer> m_Renderer = nullptr;
SDL_Window *m_Window;
SDL_GLContext m_Context;
};

690
cpp/test/test.cpp
View File

@ -1,690 +0,0 @@
#include <cassert>
#include <cmath>
#include <concepts>
#include <gtest/gtest.h>
#include <sstream>
#include <unordered_set>
#include "log.hpp"
#include "math.hpp"
TEST(vec, DefaultConstruction) {
// Test that default-constucted vector
// has all elements equal to zero
vec3 v1;
ASSERT_EQ(v1[0], 0.0);
ASSERT_EQ(v1[1], 0.0);
ASSERT_EQ(v1[2], 0.0);
}
TEST(vec, GetElements) {
// Test operator[]
ivec3 v1{12, 34, 56};
ASSERT_EQ(v1[0], 12);
ASSERT_EQ(v1[1], 34);
ASSERT_EQ(v1[2], 56);
}
TEST(vec, equalEpsilon) {
// Test equalEpsilon
// TODO just an ad-hoc test,
// can possibly fail for other machines.
// This needs some work
vec3 v1{1.0f, 2.0f, 3.0f};
vec3 v2{0.999999f, 1.9999999f, 2.9999999f};
ASSERT_EQ(v1, v2);
}
TEST(vec, equalInt) {
ivec2 v1{1,2};
ivec2 v2{1,2};
ASSERT_EQ(v1, v2);
}
TEST(vec, nonEqualEpsilon) {
// Test operator!=
vec3 v1{1.0f, 2.0f, 3.0f};
vec3 v2{2.0f, 4.0f, 6.0f};
ASSERT_NE(v1, v2);
}
TEST(vec, LogPrint) {
// Test that logger can print the vector of different types
// and sizes
vec2 v2(1.2f, 3.4f);
vec3 v3(1.2f, 3.4f, 5.6f);
vec4 v4(1.2f, 3.4f, 5.6f, 7.8f);
dvec2 dv2(1.2, 3.4);
dvec3 dv3(1.2, 3.4, 5.6);
dvec4 dv4(1.2, 3.4, 5.6, 7.8);
ivec2 iv2(1, 3);
ivec3 iv3(1, 3, 5);
ivec4 iv4(1, 3, 5, 7);
uvec2 uv2(1u, 3u);
uvec3 uv3(1u, 3u, 5u);
uvec4 uv4(1u, 3u, 5u, 7u);
LOG_DEBUG("vec2 ", v2);
LOG_DEBUG("vec3 ", v3);
LOG_DEBUG("vec4 ", v4);
LOG_DEBUG("dvec2 ", dv2);
LOG_DEBUG("dvec3 ", dv3);
LOG_DEBUG("dvec4 ", dv4);
LOG_DEBUG("ivec2 ", iv2);
LOG_DEBUG("ivec3 ", iv3);
LOG_DEBUG("ivec4 ", iv4);
LOG_DEBUG("uvec2 ", uv2);
LOG_DEBUG("uvec3 ", uv3);
LOG_DEBUG("uvec4 ", uv4);
}
TEST(vec, Add)
{
// Test operator+ with float vectors
vec3 v1{1.0f, 2.0f, 3.0f};
vec3 v2{4.0f, 5.0f, 6.0f};
vec3 result = v1 + v2;
ASSERT_FLOAT_EQ(result[0], 5.0f);
ASSERT_FLOAT_EQ(result[1], 7.0f);
ASSERT_FLOAT_EQ(result[2], 9.0f);
// Test operator+ with integer vectors
ivec3 iv1{1, 2, 3};
ivec3 iv2{10, 20, 30};
ivec3 iresult = iv1 + iv2;
ASSERT_EQ(iresult[0], 11);
ASSERT_EQ(iresult[1], 22);
ASSERT_EQ(iresult[2], 33);
// Test that original vectors are unchanged
ASSERT_FLOAT_EQ(v1[0], 1.0f);
ASSERT_FLOAT_EQ(v1[1], 2.0f);
ASSERT_FLOAT_EQ(v1[2], 3.0f);
}
TEST(vec, Sub)
{
// Test operator- with float vectors
vec3 v1{5.0f, 7.0f, 9.0f};
vec3 v2{1.0f, 2.0f, 3.0f};
vec3 result = v1 - v2;
ASSERT_FLOAT_EQ(result[0], 4.0f);
ASSERT_FLOAT_EQ(result[1], 5.0f);
ASSERT_FLOAT_EQ(result[2], 6.0f);
// Test operator- with integer vectors
ivec3 iv1{30, 20, 10};
ivec3 iv2{5, 3, 1};
ivec3 iresult = iv1 - iv2;
ASSERT_EQ(iresult[0], 25);
ASSERT_EQ(iresult[1], 17);
ASSERT_EQ(iresult[2], 9);
// Test that original vectors are unchanged
ASSERT_FLOAT_EQ(v1[0], 5.0f);
ASSERT_FLOAT_EQ(v1[1], 7.0f);
ASSERT_FLOAT_EQ(v1[2], 9.0f);
// Test subtraction resulting in negative values
vec3 v3{1.0f, 2.0f, 3.0f};
vec3 v4{4.0f, 5.0f, 6.0f};
vec3 negative_result = v3 - v4;
ASSERT_FLOAT_EQ(negative_result[0], -3.0f);
ASSERT_FLOAT_EQ(negative_result[1], -3.0f);
ASSERT_FLOAT_EQ(negative_result[2], -3.0f);
}
TEST(vec, ScalarMultiplication)
{
// Test scalar * vector with float vectors
vec3 v1{2.0f, 3.0f, 4.0f};
vec3 result = v1 * 2.5f;
ASSERT_FLOAT_EQ(result[0], 5.0f);
ASSERT_FLOAT_EQ(result[1], 7.5f);
ASSERT_FLOAT_EQ(result[2], 10.0f);
// Test scalar * vector with integer vectors
ivec3 iv1{3, 5, 7};
ivec3 iresult = iv1 * 2;
ASSERT_EQ(iresult[0], 6);
ASSERT_EQ(iresult[1], 10);
ASSERT_EQ(iresult[2], 14);
// Test that original vector is unchanged
ASSERT_FLOAT_EQ(v1[0], 2.0f);
ASSERT_FLOAT_EQ(v1[1], 3.0f);
ASSERT_FLOAT_EQ(v1[2], 4.0f);
// Test multiplication by zero
vec3 v2{1.0f, 2.0f, 3.0f};
vec3 zero_result = v2 * 0.0f;
ASSERT_FLOAT_EQ(zero_result[0], 0.0f);
ASSERT_FLOAT_EQ(zero_result[1], 0.0f);
ASSERT_FLOAT_EQ(zero_result[2], 0.0f);
// Test multiplication by negative scalar (and different ordering)
vec3 v3{1.0f, -2.0f, 3.0f};
vec3 negative_result = -2.0f * v3;
ASSERT_FLOAT_EQ(negative_result[0], -2.0f);
ASSERT_FLOAT_EQ(negative_result[1], 4.0f);
ASSERT_FLOAT_EQ(negative_result[2], -6.0f);
}
TEST(vec, ScalarDivision)
{
// Test vector / scalar with float vectors
vec3 v1{10.0f, 15.0f, 20.0f};
vec3 result = v1 / 2.5f;
ASSERT_FLOAT_EQ(result[0], 4.0f);
ASSERT_FLOAT_EQ(result[1], 6.0f);
ASSERT_FLOAT_EQ(result[2], 8.0f);
// Test vector / scalar with integer vectors
ivec3 iv1{12, 18, 24};
ivec3 iresult = iv1 / 2;
ASSERT_EQ(iresult[0], 6);
ASSERT_EQ(iresult[1], 9);
ASSERT_EQ(iresult[2], 12);
// Test that original vector is unchanged
ASSERT_FLOAT_EQ(v1[0], 10.0f);
ASSERT_FLOAT_EQ(v1[1], 15.0f);
ASSERT_FLOAT_EQ(v1[2], 20.0f);
// Test division by negative scalar
vec3 v2{6.0f, -9.0f, 12.0f};
vec3 negative_result = v2 / -3.0f;
ASSERT_FLOAT_EQ(negative_result[0], -2.0f);
ASSERT_FLOAT_EQ(negative_result[1], 3.0f);
ASSERT_FLOAT_EQ(negative_result[2], -4.0f);
// Test division by fractional scalar
vec3 v3{1.0f, 2.0f, 3.0f};
vec3 fractional_result = v3 / 0.5f;
ASSERT_FLOAT_EQ(fractional_result[0], 2.0f);
ASSERT_FLOAT_EQ(fractional_result[1], 4.0f);
ASSERT_FLOAT_EQ(fractional_result[2], 6.0f);
}
TEST(vec, AdditionAssignment)
{
// Test operator+= with float vectors
vec3 v1{1.0f, 2.0f, 3.0f};
vec3 v2{4.0f, 5.0f, 6.0f};
v1 += v2;
ASSERT_FLOAT_EQ(v1[0], 5.0f);
ASSERT_FLOAT_EQ(v1[1], 7.0f);
ASSERT_FLOAT_EQ(v1[2], 9.0f);
// Test that v2 is unchanged
ASSERT_FLOAT_EQ(v2[0], 4.0f);
ASSERT_FLOAT_EQ(v2[1], 5.0f);
ASSERT_FLOAT_EQ(v2[2], 6.0f);
// Test operator+= with integer vectors
ivec3 iv1{10, 20, 30};
ivec3 iv2{1, 2, 3};
iv1 += iv2;
ASSERT_EQ(iv1[0], 11);
ASSERT_EQ(iv1[1], 22);
ASSERT_EQ(iv1[2], 33);
// Test chaining
vec3 v3{1.0f, 1.0f, 1.0f};
vec3 v4{2.0f, 2.0f, 2.0f};
vec3 v5{3.0f, 3.0f, 3.0f};
v3 += v4 += v5;
ASSERT_FLOAT_EQ(v3[0], 6.0f);
ASSERT_FLOAT_EQ(v3[1], 6.0f);
ASSERT_FLOAT_EQ(v3[2], 6.0f);
ASSERT_FLOAT_EQ(v4[0], 5.0f);
ASSERT_FLOAT_EQ(v4[1], 5.0f);
ASSERT_FLOAT_EQ(v4[2], 5.0f);
}
TEST(vec, SubtractionAssignment)
{
// Test operator-= with float vectors
vec3 v1{10.0f, 15.0f, 20.0f};
vec3 v2{3.0f, 5.0f, 7.0f};
v1 -= v2;
ASSERT_FLOAT_EQ(v1[0], 7.0f);
ASSERT_FLOAT_EQ(v1[1], 10.0f);
ASSERT_FLOAT_EQ(v1[2], 13.0f);
// Test that v2 is unchanged
ASSERT_FLOAT_EQ(v2[0], 3.0f);
ASSERT_FLOAT_EQ(v2[1], 5.0f);
ASSERT_FLOAT_EQ(v2[2], 7.0f);
// Test operator-= with integer vectors
ivec3 iv1{50, 40, 30};
ivec3 iv2{5, 10, 15};
iv1 -= iv2;
ASSERT_EQ(iv1[0], 45);
ASSERT_EQ(iv1[1], 30);
ASSERT_EQ(iv1[2], 15);
// Test subtraction resulting in negative values
vec3 v3{1.0f, 2.0f, 3.0f};
vec3 v4{4.0f, 5.0f, 6.0f};
v3 -= v4;
ASSERT_FLOAT_EQ(v3[0], -3.0f);
ASSERT_FLOAT_EQ(v3[1], -3.0f);
ASSERT_FLOAT_EQ(v3[2], -3.0f);
}
TEST(vec, LengthSquared)
{
// Test LengthSquared with float vectors
vec3 v1{3.0f, 4.0f, 0.0f};
ASSERT_FLOAT_EQ(v1.LengthSquared(), 25.0f); // 3² + 4² + 0² = 25
vec2 v2{1.0f, 1.0f};
ASSERT_FLOAT_EQ(v2.LengthSquared(), 2.0f); // 1² + 1² = 2
// Test with zero vector
vec3 zero{0.0f, 0.0f, 0.0f};
ASSERT_FLOAT_EQ(zero.LengthSquared(), 0.0f);
}
TEST(vec, Length)
{
// Test Length with float vectors
vec3 v1{3.0f, 4.0f, 0.0f};
ASSERT_FLOAT_EQ(v1.Length(), 5.0f); // sqrt(3² + 4² + 0²) = 5
vec2 v2{1.0f, 1.0f};
ASSERT_NEAR(v2.Length(), 1.414213f, 1e-5f); // sqrt(2) ≈ 1.414213
// Test with zero vector
vec3 zero{0.0f, 0.0f, 0.0f};
ASSERT_FLOAT_EQ(zero.Length(), 0.0f);
}
TEST(vec, Normalize)
{
// Test Normalize with float vectors
vec3 v1{3.0f, 4.0f, 0.0f};
v1.Normalize();
ASSERT_FLOAT_EQ(v1[0], 0.6f); // 3/5
ASSERT_FLOAT_EQ(v1[1], 0.8f); // 4/5
ASSERT_FLOAT_EQ(v1[2], 0.0f);
ASSERT_NEAR(v1.Length(), 1.0f, 1e-6f);
// Test with zero vector (may produce NaN - implementation dependent)
vec3 zero{0.0f, 0.0f, 0.0f};
zero.Normalize();
// Check if result is NaN (which is expected for zero vector normalization)
ASSERT_TRUE(zero[0] == 0.0f);
ASSERT_TRUE(zero[1] == 0.0f);
ASSERT_TRUE(zero[2] == 0.0f);
}
TEST(vec, GetNormalized)
{
// Test GetNormalized with float vectors
const vec3 v1{3.0f, 4.0f, 0.0f};
vec3 normalized = v1.GetNormalized();
// Original vector should be unchanged
ASSERT_FLOAT_EQ(v1[0], 3.0f);
ASSERT_FLOAT_EQ(v1[1], 4.0f);
ASSERT_FLOAT_EQ(v1[2], 0.0f);
// Normalized copy should be unit length
ASSERT_FLOAT_EQ(normalized[0], 0.6f); // 3/5
ASSERT_FLOAT_EQ(normalized[1], 0.8f); // 4/5
ASSERT_FLOAT_EQ(normalized[2], 0.0f);
ASSERT_NEAR(normalized.Length(), 1.0f, 1e-6f);
// Test with zero vector
vec3 zero{0.0f, 0.0f, 0.0f};
vec3 zero_normalized = zero.GetNormalized();
ASSERT_FLOAT_EQ(zero_normalized[0], 0.0f);
ASSERT_FLOAT_EQ(zero_normalized[1], 0.0f);
ASSERT_FLOAT_EQ(zero_normalized[2], 0.0f);
// Original zero vector should be unchanged
ASSERT_FLOAT_EQ(zero[0], 0.0f);
ASSERT_FLOAT_EQ(zero[1], 0.0f);
ASSERT_FLOAT_EQ(zero[2], 0.0f);
}
TEST(vec, GetOrthogonal)
{
const vec2 v1{5.0f, 1.0f};
auto v2 = v1.GetOrthogonal();
ASSERT_FLOAT_EQ(v2[0], -1.0f);
ASSERT_FLOAT_EQ(v2[1], 5.0f);
}
TEST(vec, DistanceTo)
{
// Test DistanceTo with 3D vectors
vec3 v1{0.0f, 0.0f, 0.0f};
vec3 v2{3.0f, 4.0f, 0.0f};
float distance = v1.DistanceTo(v2);
ASSERT_FLOAT_EQ(distance, 5.0f); // 3-4-5 triangle
// Distance should be symmetric
ASSERT_FLOAT_EQ(v2.DistanceTo(v1), distance);
// Test with 2D vectors
vec2 a{1.0f, 1.0f};
vec2 b{4.0f, 5.0f};
float distance_2d = a.DistanceTo(b);
ASSERT_FLOAT_EQ(distance_2d, 5.0f); // sqrt((4-1)² + (5-1)²) = sqrt(9+16) = 5
// Distance to self should be zero
ASSERT_FLOAT_EQ(v1.DistanceTo(v1), 0.0f);
ASSERT_FLOAT_EQ(a.DistanceTo(a), 0.0f);
// Test that original vectors are unchanged
ASSERT_FLOAT_EQ(v1[0], 0.0f);
ASSERT_FLOAT_EQ(v1[1], 0.0f);
ASSERT_FLOAT_EQ(v1[2], 0.0f);
ASSERT_FLOAT_EQ(v2[0], 3.0f);
ASSERT_FLOAT_EQ(v2[1], 4.0f);
ASSERT_FLOAT_EQ(v2[2], 0.0f);
}
TEST(vec, ChainedOperations) {
vec2 a{1.0f, 2.0f};
vec2 b{3.0f, 4.0f};
// Test chaining: (a + b) * 2.0f
auto result = (a + b) * 2.0f;
ASSERT_FLOAT_EQ(result[0], 8.0f);
ASSERT_FLOAT_EQ(result[1], 12.0f);
// Test chaining with assignment
a += b;
a = a * 0.5f;
ASSERT_FLOAT_EQ(a[0], 2.0f);
ASSERT_FLOAT_EQ(a[1], 3.0f);
}
TEST(Matrix, DefaultConstruction) {
// Test that default-constructed matrix has all elements equal to zero
Matrix<float, 2> m1;
ASSERT_FLOAT_EQ(m1[0][0], 0.0f);
ASSERT_FLOAT_EQ(m1[0][1], 0.0f);
ASSERT_FLOAT_EQ(m1[1][0], 0.0f);
ASSERT_FLOAT_EQ(m1[1][1], 0.0f);
}
TEST(Matrix, ArrayConstruction) {
// Test construction from array (column major)
Matrix<float, 2> m1(std::array<float, 4>{1.0f, 2.0f, 3.0f, 4.0f});
// Column 0: [1, 2]
ASSERT_FLOAT_EQ(m1[0][0], 1.0f);
ASSERT_FLOAT_EQ(m1[0][1], 2.0f);
// Column 1: [3, 4]
ASSERT_FLOAT_EQ(m1[1][0], 3.0f);
ASSERT_FLOAT_EQ(m1[1][1], 4.0f);
// Test with 3x3 matrix
Matrix<int, 3> m2(std::array<int, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9});
// Column 0: [1, 2, 3]
ASSERT_EQ(m2[0][0], 1);
ASSERT_EQ(m2[0][1], 2);
ASSERT_EQ(m2[0][2], 3);
// Column 1: [4, 5, 6]
ASSERT_EQ(m2[1][0], 4);
ASSERT_EQ(m2[1][1], 5);
ASSERT_EQ(m2[1][2], 6);
// Column 2: [7, 8, 9]
ASSERT_EQ(m2[2][0], 7);
ASSERT_EQ(m2[2][1], 8);
ASSERT_EQ(m2[2][2], 9);
}
TEST(Matrix, ElementAccess) {
// Test element access (both const and non-const)
Matrix<float, 2> m1(std::array<float, 4>{1.0f, 2.0f, 3.0f, 4.0f});
// Test const access
const Matrix<float, 2>& const_ref = m1;
ASSERT_FLOAT_EQ(const_ref[0][0], 1.0f);
ASSERT_FLOAT_EQ(const_ref[1][1], 4.0f);
// Test non-const access and modification
m1[0][0] = 10.0f;
m1[1][1] = 40.0f;
ASSERT_FLOAT_EQ(m1[0][0], 10.0f);
ASSERT_FLOAT_EQ(m1[1][1], 40.0f);
// Verify other elements unchanged
ASSERT_FLOAT_EQ(m1[0][1], 2.0f);
ASSERT_FLOAT_EQ(m1[1][0], 3.0f);
}
TEST(Matrix, Addition) {
// Test matrix addition
Matrix<float, 2> m1(std::array<float, 4>{1.0f, 2.0f, 3.0f, 4.0f});
Matrix<float, 2> m2(std::array<float, 4>{5.0f, 6.0f, 7.0f, 8.0f});
Matrix<float, 2> result = m1 + m2;
ASSERT_FLOAT_EQ(result[0][0], 6.0f); // 1 + 5
ASSERT_FLOAT_EQ(result[0][1], 8.0f); // 2 + 6
ASSERT_FLOAT_EQ(result[1][0], 10.0f); // 3 + 7
ASSERT_FLOAT_EQ(result[1][1], 12.0f); // 4 + 8
// Test that original matrices are unchanged
ASSERT_FLOAT_EQ(m1[0][0], 1.0f);
ASSERT_FLOAT_EQ(m1[1][1], 4.0f);
ASSERT_FLOAT_EQ(m2[0][0], 5.0f);
ASSERT_FLOAT_EQ(m2[1][1], 8.0f);
// Test with integer matrices
Matrix<int, 2> im1(std::array<int, 4>{1, 2, 3, 4});
Matrix<int, 2> im2(std::array<int, 4>{10, 20, 30, 40});
Matrix<int, 2> iresult = im1 + im2;
ASSERT_EQ(iresult[0][0], 11);
ASSERT_EQ(iresult[0][1], 22);
ASSERT_EQ(iresult[1][0], 33);
ASSERT_EQ(iresult[1][1], 44);
}
TEST(Matrix, Subtraction) {
// Test matrix subtraction
Matrix<float, 2> m1(std::array<float, 4>{10.0f, 8.0f, 6.0f, 4.0f});
Matrix<float, 2> m2(std::array<float, 4>{1.0f, 2.0f, 3.0f, 4.0f});
Matrix<float, 2> result = m1 - m2;
ASSERT_FLOAT_EQ(result[0][0], 9.0f); // 10 - 1
ASSERT_FLOAT_EQ(result[0][1], 6.0f); // 8 - 2
ASSERT_FLOAT_EQ(result[1][0], 3.0f); // 6 - 3
ASSERT_FLOAT_EQ(result[1][1], 0.0f); // 4 - 4
// Test that original matrices are unchanged
ASSERT_FLOAT_EQ(m1[0][0], 10.0f);
ASSERT_FLOAT_EQ(m1[1][1], 4.0f);
ASSERT_FLOAT_EQ(m2[0][0], 1.0f);
ASSERT_FLOAT_EQ(m2[1][1], 4.0f);
// Test subtraction resulting in negative values
Matrix<float, 2> m3(std::array<float, 4>{1.0f, 2.0f, 3.0f, 4.0f});
Matrix<float, 2> m4(std::array<float, 4>{5.0f, 6.0f, 7.0f, 8.0f});
Matrix<float, 2> negative_result = m3 - m4;
ASSERT_FLOAT_EQ(negative_result[0][0], -4.0f);
ASSERT_FLOAT_EQ(negative_result[0][1], -4.0f);
ASSERT_FLOAT_EQ(negative_result[1][0], -4.0f);
ASSERT_FLOAT_EQ(negative_result[1][1], -4.0f);
}
TEST(Matrix, MatrixMultiplication) {
// Test 2x2 matrix multiplication
Matrix<float, 2> m1(std::array<float, 4>{1.0f, 2.0f, 3.0f, 4.0f});
Matrix<float, 2> m2(std::array<float, 4>{5.0f, 6.0f, 7.0f, 8.0f});
Matrix<float, 2> result = m2 * m1;
ASSERT_FLOAT_EQ(result[0][0], 23.0f);
ASSERT_FLOAT_EQ(result[0][1], 34.0f);
ASSERT_FLOAT_EQ(result[1][0], 31.0f);
ASSERT_FLOAT_EQ(result[1][1], 46.0f);
// Test identity property: I * m = m
Matrix<float, 2> identity = Matrix<float, 2>::Eye();
Matrix<float, 2> identity_result = identity * m1;
ASSERT_FLOAT_EQ(identity_result[0][0], m1[0][0]);
ASSERT_FLOAT_EQ(identity_result[0][1], m1[0][1]);
ASSERT_FLOAT_EQ(identity_result[1][0], m1[1][0]);
ASSERT_FLOAT_EQ(identity_result[1][1], m1[1][1]);
// Test with 3x3 matrices
Matrix<int, 3> im1(std::array<int, 9>{1, 0, 0, 0, 1, 0, 0, 0, 1}); // Identity
Matrix<int, 3> im2(std::array<int, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9});
Matrix<int, 3> iresult = im1 * im2;
// Identity * matrix = matrix
ASSERT_EQ(iresult[0][0], 1);
ASSERT_EQ(iresult[0][1], 2);
ASSERT_EQ(iresult[0][2], 3);
ASSERT_EQ(iresult[1][0], 4);
ASSERT_EQ(iresult[1][1], 5);
ASSERT_EQ(iresult[1][2], 6);
ASSERT_EQ(iresult[2][0], 7);
ASSERT_EQ(iresult[2][1], 8);
ASSERT_EQ(iresult[2][2], 9);
}
TEST(Matrix, MatrixVectorMultiplication) {
// Test matrix-vector multiplication
Matrix<float, 2> m1(std::array<float, 4>{1.0f, 2.0f, 3.0f, 4.0f});
vec<float, 2> v1(2.0f, 3.0f);
vec<float, 2> result = m1 * v1;
ASSERT_FLOAT_EQ(result[0], 8.0f);
ASSERT_FLOAT_EQ(result[1], 18.0f);
// Test with 3x3 matrix and 3D vector
Matrix<int, 3> im1(std::array<int, 9>{1, 0, 0, 0, 1, 0, 0, 0, 1}); // Identity
vec<int, 3> iv1(5, 10, 15);
vec<int, 3> iresult = im1 * iv1;
// Identity * vector = vector
ASSERT_EQ(iresult[0], 5);
ASSERT_EQ(iresult[1], 10);
ASSERT_EQ(iresult[2], 15);
// Test that original matrix and vector are unchanged
ASSERT_FLOAT_EQ(m1[0][0], 1.0f);
ASSERT_FLOAT_EQ(v1[0], 2.0f);
ASSERT_FLOAT_EQ(v1[1], 3.0f);
}
TEST(Matrix, EyeIdentityMatrix) {
// Test 2x2 identity matrix
Matrix<float, 2> eye2 = Matrix<float, 2>::Eye();
ASSERT_FLOAT_EQ(eye2[0][0], 1.0f);
ASSERT_FLOAT_EQ(eye2[0][1], 0.0f);
ASSERT_FLOAT_EQ(eye2[1][0], 0.0f);
ASSERT_FLOAT_EQ(eye2[1][1], 1.0f);
// Test 3x3 identity matrix
Matrix<int, 3> eye3 = Matrix<int, 3>::Eye();
for (size_t i = 0; i < 3; ++i) {
for (size_t j = 0; j < 3; ++j) {
if (i == j) {
ASSERT_EQ(eye3[i][j], 1);
} else {
ASSERT_EQ(eye3[i][j], 0);
}
}
}
// Test 4x4 identity matrix
Matrix<double, 4> eye4 = Matrix<double, 4>::Eye();
for (size_t i = 0; i < 4; ++i) {
for (size_t j = 0; j < 4; ++j) {
if (i == j) {
ASSERT_DOUBLE_EQ(eye4[i][j], 1.0);
} else {
ASSERT_DOUBLE_EQ(eye4[i][j], 0.0);
}
}
}
}
TEST(Matrix, LogPrint) {
// Test that logger can print matrices of different types and sizes
Matrix<float, 2> m2(std::array<float, 4>{1.1f, 2.2f, 3.3f, 4.4f});
Matrix<int, 3> m3(std::array<int, 9>{1, 2, 3, 4, 5, 6, 7, 8, 9});
Matrix<double, 2> dm2(std::array<double, 4>{1.5, 2.5, 3.5, 4.5});
LOG_DEBUG("Matrix<float, 2> ", m2);
LOG_DEBUG("Matrix<int, 3> ", m3);
LOG_DEBUG("Matrix<double, 2> ", dm2);
}
TEST(Matrix, ChainedOperations) {
// Test chaining matrix operations
Matrix<float, 2> m1(std::array<float, 4>{1.0f, 2.0f, 3.0f, 4.0f});
Matrix<float, 2> m2(std::array<float, 4>{1.0f, 1.0f, 1.0f, 1.0f});
Matrix<float, 2> m3(std::array<float, 4>{2.0f, 0.0f, 0.0f, 2.0f});
// Test (m1 + m2) * m3
Matrix<float, 2> result = (m1 + m2) * m3;
// m1 + m2 = [2 4] m3 = [2 0] result = [4 8]
// [3 5] [0 2] [6 10]
ASSERT_FLOAT_EQ(result[0][0], 4.0f);
ASSERT_FLOAT_EQ(result[0][1], 6.0f);
ASSERT_FLOAT_EQ(result[1][0], 8.0f);
ASSERT_FLOAT_EQ(result[1][1], 10.0f);
// Test that original matrices are unchanged
ASSERT_FLOAT_EQ(m1[0][0], 1.0f);
ASSERT_FLOAT_EQ(m2[0][0], 1.0f);
ASSERT_FLOAT_EQ(m3[0][0], 2.0f);
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();
}

BIN
docs/img/screenshot_1.png
View File

Binary file not shown.
Side by Side

Before

Width:  |  Height:  |  Size: 6.9 KiB

40
vs/pathfinding_demo/pathfinding_demo.vcxproj
View File

@ -19,44 +19,12 @@
</ProjectConfiguration>
</ItemGroup>
<ItemGroup>
<ClCompile Include="..\..\cpp\src\camera.cpp" />
<ClCompile Include="..\..\cpp\src\entities.cpp" />
<ClCompile Include="..\..\cpp\src\gameloop.cpp" />
<ClCompile Include="..\..\cpp\src\main.cpp" />
<ClCompile Include="..\..\cpp\src\map.cpp" />
<ClCompile Include="..\..\cpp\src\pathfinder\astar.cpp" />
<ClCompile Include="..\..\cpp\src\pathfinder\base.cpp" />
<ClCompile Include="..\..\cpp\src\pathfinder\bfs.cpp" />
<ClCompile Include="..\..\cpp\src\pathfinder\dijkstra.cpp" />
<ClCompile Include="..\..\cpp\src\pathfinder\gbfs.cpp" />
<ClCompile Include="..\..\cpp\src\pathfinder\linear.cpp" />
<ClCompile Include="..\..\cpp\src\pathfinder\utils.cpp" />
<ClCompile Include="..\..\cpp\src\pathfindingdemo.cpp" />
<ClCompile Include="..\..\cpp\src\sprite.cpp" />
<ClCompile Include="..\..\cpp\src\tile.cpp" />
<ClCompile Include="..\..\cpp\src\user_input.cpp" />
<ClCompile Include="..\..\cpp\src\window.cpp" />
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\cpp\src\array.hpp" />
<ClInclude Include="..\..\cpp\src\camera.hpp" />
<ClInclude Include="..\..\cpp\src\entities.hpp" />
<ClInclude Include="..\..\cpp\src\gameloop.hpp" />
<ClInclude Include="..\..\cpp\src\log.hpp" />
<ClInclude Include="..\..\cpp\src\map.hpp" />
<ClInclude Include="..\..\cpp\src\math.hpp" />
<ClInclude Include="..\..\cpp\src\pathfinder\astar.hpp" />
<ClInclude Include="..\..\cpp\src\pathfinder\base.hpp" />
<ClInclude Include="..\..\cpp\src\pathfinder\bfs.hpp" />
<ClInclude Include="..\..\cpp\src\pathfinder\dijkstra.hpp" />
<ClInclude Include="..\..\cpp\src\pathfinder\gbfs.hpp" />
<ClInclude Include="..\..\cpp\src\pathfinder\linear.hpp" />
<ClInclude Include="..\..\cpp\src\pathfinder\utils.hpp" />
<ClInclude Include="..\..\cpp\src\pathfindingdemo.hpp" />
<ClInclude Include="..\..\cpp\src\sprite.hpp" />
<ClInclude Include="..\..\cpp\src\tile.hpp" />
<ClInclude Include="..\..\cpp\src\user_input.hpp" />
<ClInclude Include="..\..\cpp\src\window.hpp" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\glew\build\vc15\glew_static.vcxproj">
@ -128,7 +96,7 @@
<PreprocessorDefinitions>GLEW_STATIC</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpplatest</LanguageStandard>
<AdditionalIncludeDirectories>..\glew\include;..\SDL\include;..\SDL_image\include;..\;..\..\cpp\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>..\glew\include;..\SDL\include;..\SDL_image\include;..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -146,7 +114,7 @@
<PreprocessorDefinitions>GLEW_STATIC</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpplatest</LanguageStandard>
<AdditionalIncludeDirectories>..\glew\include;..\SDL\include;..\SDL_image\include;..\;..\..\cpp\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>..\glew\include;..\SDL\include;..\SDL_image\include;..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -164,7 +132,7 @@
<PreprocessorDefinitions>GLEW_STATIC</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpplatest</LanguageStandard>
<AdditionalIncludeDirectories>..\glew\include;..\SDL\include;..\SDL_image\include;..\;..\..\cpp\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>..\glew\include;..\SDL\include;..\SDL_image\include;..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>
@ -182,7 +150,7 @@
<PreprocessorDefinitions>GLEW_STATIC</PreprocessorDefinitions>
<ConformanceMode>true</ConformanceMode>
<LanguageStandard>stdcpplatest</LanguageStandard>
<AdditionalIncludeDirectories>..\glew\include;..\SDL\include;..\SDL_image\include;..\;..\..\cpp\src;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
<AdditionalIncludeDirectories>..\glew\include;..\SDL\include;..\SDL_image\include;..\;%(AdditionalIncludeDirectories)</AdditionalIncludeDirectories>
</ClCompile>
<Link>
<SubSystem>Console</SubSystem>

96
vs/pathfinding_demo/pathfinding_demo.vcxproj.filters
View File

@ -18,54 +18,6 @@
<ClCompile Include="..\..\cpp\src\main.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\window.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\user_input.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\tile.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\sprite.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\pathfindingdemo.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\map.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\gameloop.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\entities.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\camera.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\pathfinder\utils.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\pathfinder\linear.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\pathfinder\gbfs.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\pathfinder\dijkstra.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\pathfinder\bfs.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\pathfinder\base.cpp">
<Filter>Source Files</Filter>
</ClCompile>
<ClCompile Include="..\..\cpp\src\pathfinder\astar.cpp">
<Filter>Source Files</Filter>
</ClCompile>
</ItemGroup>
<ItemGroup>
<ClInclude Include="..\..\cpp\src\array.hpp">
@ -77,53 +29,5 @@
<ClInclude Include="..\..\cpp\src\math.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\camera.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\entities.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\gameloop.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\map.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\pathfindingdemo.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\sprite.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\tile.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\user_input.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\window.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\pathfinder\astar.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\pathfinder\base.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\pathfinder\bfs.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\pathfinder\dijkstra.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\pathfinder\gbfs.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\pathfinder\linear.hpp">
<Filter>Header Files</Filter>
</ClInclude>
<ClInclude Include="..\..\cpp\src\pathfinder\utils.hpp">
<Filter>Header Files</Filter>
</ClInclude>
</ItemGroup>
</Project>