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

Merge pull request #32 from potatopplking/feature/positional_container

Browse Source 
Feature/positional container
This commit is contained in:
potatopplking
2025-10-31 17:39:53 +01:00
committed by GitHub
parent 3a8dce8996 9b4b852872
commit e00c02e176
38 changed files with 1811 additions and 635 deletions
Download Patch File Download Diff File Expand all files Collapse all files

297
.clang-format Normal file
View File

@@ -0,0 +1,297 @@
---
Language: Cpp
AccessModifierOffset: -2
AlignAfterOpenBracket: Align
AlignArrayOfStructures: None
AlignConsecutiveAssignments:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionDeclarations: false
AlignFunctionPointers: false
PadOperators: true
AlignConsecutiveBitFields:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionDeclarations: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveDeclarations:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionDeclarations: true
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveMacros:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionDeclarations: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveShortCaseStatements:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCaseArrows: false
AlignCaseColons: false
AlignConsecutiveTableGenBreakingDAGArgColons:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionDeclarations: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveTableGenCondOperatorColons:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionDeclarations: false
AlignFunctionPointers: false
PadOperators: false
AlignConsecutiveTableGenDefinitionColons:
Enabled: false
AcrossEmptyLines: false
AcrossComments: false
AlignCompound: false
AlignFunctionDeclarations: false
AlignFunctionPointers: false
PadOperators: false
AlignEscapedNewlines: Right
AlignOperands: Align
AlignTrailingComments:
Kind: Always
OverEmptyLines: 0
AllowAllArgumentsOnNextLine: true
AllowAllParametersOfDeclarationOnNextLine: true
AllowBreakBeforeNoexceptSpecifier: Never
AllowShortBlocksOnASingleLine: Never
AllowShortCaseExpressionOnASingleLine: true
AllowShortCaseLabelsOnASingleLine: false
AllowShortCompoundRequirementOnASingleLine: true
AllowShortEnumsOnASingleLine: true
AllowShortFunctionsOnASingleLine: All
AllowShortIfStatementsOnASingleLine: Never
AllowShortLambdasOnASingleLine: All
AllowShortLoopsOnASingleLine: false
AllowShortNamespacesOnASingleLine: false
AlwaysBreakAfterDefinitionReturnType: None
AlwaysBreakBeforeMultilineStrings: false
AttributeMacros:
- __capability
BinPackArguments: true
BinPackLongBracedList: true
BinPackParameters: BinPack
BitFieldColonSpacing: Both
BracedInitializerIndentWidth: -1
BraceWrapping:
AfterCaseLabel: false
AfterClass: false
AfterControlStatement: Never
AfterEnum: false
AfterExternBlock: false
AfterFunction: false
AfterNamespace: false
AfterObjCDeclaration: false
AfterStruct: false
AfterUnion: false
BeforeCatch: false
BeforeElse: false
BeforeLambdaBody: false
BeforeWhile: false
IndentBraces: false
SplitEmptyFunction: true
SplitEmptyRecord: true
SplitEmptyNamespace: true
BreakAdjacentStringLiterals: true
BreakAfterAttributes: Leave
BreakAfterJavaFieldAnnotations: false
BreakAfterReturnType: None
BreakArrays: true
BreakBeforeBinaryOperators: None
BreakBeforeConceptDeclarations: Always
BreakBeforeBraces: Attach
BreakBeforeInlineASMColon: OnlyMultiline
BreakBeforeTemplateCloser: false
BreakBeforeTernaryOperators: true
BreakBinaryOperations: Never
BreakConstructorInitializers: BeforeColon
BreakFunctionDefinitionParameters: false
BreakInheritanceList: BeforeColon
BreakStringLiterals: true
BreakTemplateDeclarations: MultiLine
ColumnLimit: 80
CommentPragmas: '^ IWYU pragma:'
CompactNamespaces: false
ConstructorInitializerIndentWidth: 4
ContinuationIndentWidth: 4
Cpp11BracedListStyle: true
DerivePointerAlignment: false
DisableFormat: false
EmptyLineAfterAccessModifier: Never
EmptyLineBeforeAccessModifier: LogicalBlock
EnumTrailingComma: Leave
ExperimentalAutoDetectBinPacking: false
FixNamespaceComments: true
ForEachMacros:
- foreach
- Q_FOREACH
- BOOST_FOREACH
IfMacros:
- KJ_IF_MAYBE
IncludeBlocks: Preserve
IncludeCategories:
- Regex: '^"(llvm|llvm-c|clang|clang-c)/'
Priority: 2
SortPriority: 0
CaseSensitive: false
- Regex: '^(<|"(gtest|gmock|isl|json)/)'
Priority: 3
SortPriority: 0
CaseSensitive: false
- Regex: '.*'
Priority: 1
SortPriority: 0
CaseSensitive: false
IncludeIsMainRegex: '(Test)?$'
IncludeIsMainSourceRegex: ''
IndentAccessModifiers: false
IndentCaseBlocks: false
IndentCaseLabels: false
IndentExportBlock: true
IndentExternBlock: AfterExternBlock
IndentGotoLabels: true
IndentPPDirectives: None
IndentRequiresClause: true
IndentWidth: 2
IndentWrappedFunctionNames: false
InsertBraces: false
InsertNewlineAtEOF: false
InsertTrailingCommas: None
IntegerLiteralSeparator:
Binary: 0
BinaryMinDigits: 0
Decimal: 0
DecimalMinDigits: 0
Hex: 0
HexMinDigits: 0
JavaScriptQuotes: Leave
JavaScriptWrapImports: true
KeepEmptyLines:
AtEndOfFile: false
AtStartOfBlock: true
AtStartOfFile: true
KeepFormFeed: false
LambdaBodyIndentation: Signature
LineEnding: DeriveLF
MacroBlockBegin: ''
MacroBlockEnd: ''
MainIncludeChar: Quote
MaxEmptyLinesToKeep: 1
NamespaceIndentation: None
ObjCBinPackProtocolList: Auto
ObjCBlockIndentWidth: 2
ObjCBreakBeforeNestedBlockParam: true
ObjCSpaceAfterProperty: false
ObjCSpaceBeforeProtocolList: true
OneLineFormatOffRegex: ''
PackConstructorInitializers: BinPack
PenaltyBreakAssignment: 2
PenaltyBreakBeforeFirstCallParameter: 19
PenaltyBreakBeforeMemberAccess: 150
PenaltyBreakComment: 300
PenaltyBreakFirstLessLess: 120
PenaltyBreakOpenParenthesis: 0
PenaltyBreakScopeResolution: 500
PenaltyBreakString: 1000
PenaltyBreakTemplateDeclaration: 10
PenaltyExcessCharacter: 1000000
PenaltyIndentedWhitespace: 0
PenaltyReturnTypeOnItsOwnLine: 60
PointerAlignment: Right
PPIndentWidth: -1
QualifierAlignment: Leave
ReferenceAlignment: Pointer
ReflowComments: Always
RemoveBracesLLVM: false
RemoveEmptyLinesInUnwrappedLines: false
RemoveParentheses: Leave
RemoveSemicolon: false
RequiresClausePosition: OwnLine
RequiresExpressionIndentation: OuterScope
SeparateDefinitionBlocks: Leave
ShortNamespaceLines: 1
SkipMacroDefinitionBody: false
SortIncludes:
Enabled: true
IgnoreCase: false
SortJavaStaticImport: Before
SortUsingDeclarations: LexicographicNumeric
SpaceAfterCStyleCast: false
SpaceAfterLogicalNot: false
SpaceAfterOperatorKeyword: false
SpaceAfterTemplateKeyword: true
SpaceAroundPointerQualifiers: Default
SpaceBeforeAssignmentOperators: true
SpaceBeforeCaseColon: false
SpaceBeforeCpp11BracedList: false
SpaceBeforeCtorInitializerColon: true
SpaceBeforeInheritanceColon: true
SpaceBeforeJsonColon: false
SpaceBeforeParens: ControlStatements
SpaceBeforeParensOptions:
AfterControlStatements: true
AfterForeachMacros: true
AfterFunctionDefinitionName: false
AfterFunctionDeclarationName: false
AfterIfMacros: true
AfterNot: false
AfterOverloadedOperator: false
AfterPlacementOperator: true
AfterRequiresInClause: false
AfterRequiresInExpression: false
BeforeNonEmptyParentheses: false
SpaceBeforeRangeBasedForLoopColon: true
SpaceBeforeSquareBrackets: false
SpaceInEmptyBlock: false
SpacesBeforeTrailingComments: 1
SpacesInAngles: Never
SpacesInContainerLiterals: true
SpacesInLineCommentPrefix:
Minimum: 1
Maximum: -1
SpacesInParens: Never
SpacesInParensOptions:
ExceptDoubleParentheses: false
InCStyleCasts: false
InConditionalStatements: false
InEmptyParentheses: false
Other: false
SpacesInSquareBrackets: false
Standard: Latest
StatementAttributeLikeMacros:
- Q_EMIT
StatementMacros:
- Q_UNUSED
- QT_REQUIRE_VERSION
TableGenBreakInsideDAGArg: DontBreak
TabWidth: 8
UseTab: Never
VerilogBreakBetweenInstancePorts: true
WhitespaceSensitiveMacros:
- BOOST_PP_STRINGIZE
- CF_SWIFT_NAME
- NS_SWIFT_NAME
- PP_STRINGIZE
- STRINGIZE
WrapNamespaceBodyWithEmptyLines: Leave
...

26
.clang-uml Normal file
View File

@@ -0,0 +1,26 @@
# When configuring with cmake, use:
# cmake -B build -DCMAKE_EXPORT_COMPILE_COMMANDS=ON -DCMAKE_BUILD_TYPE=Debug
compilation_database_dir: build
# Path to system header needs to be specified,
# you will probably need to modify this
add_compile_flags:
- '-I/usr/lib/clang/21/include'
output_directory: docs/diagrams
diagrams:
class_diagram:
type: class
glob:
- cpp/src/**/*.cpp
- cpp/src/**/*.hpp
include_diagram:
type: include
glob:
- cpp/src/**/*.cpp
# Include also external system headers
#generate_system_headers: true
include:
# Include only files belonging to these paths
paths:
- cpp/src

16
CMakeLists.txt
View File

@@ -49,6 +49,9 @@ else()
set(SDL3_TARGET ${SDL3_LIBRARIES})
set(SDL3_IMAGE_TARGET ${SDL3_image_LIBRARIES})
set(GLEW_TARGET GLEW::GLEW)
# Enable clang-tidy
set(CMAKE_CXX_CLANG_TIDY "clang-tidy")
endif()
# Include directories
@@ -185,7 +188,16 @@ if(MSVC)
set(CMAKE_CXX_FLAGS_RELWITHDEBINFO "/O2 /Zi /DNDEBUG")
set(CMAKE_CXX_FLAGS_MINSIZEREL "/O1 /DNDEBUG")
else()
# GCC/Clang flags
set(CMAKE_CXX_FLAGS_DEBUG "-g -O0")
# GCC/Clang flags with extended debugging symbols
set(CMAKE_CXX_FLAGS_DEBUG "-ggdb3 -O0")
set(CMAKE_CXX_FLAGS_RELEASE "-O3 -DNDEBUG")
# Formatting target (clang only)
add_custom_target(format
COMMAND clang-format -i ${MAIN_SOURCES} ${HEADERS}
)
endif()
list(TRANSFORM MAIN_SOURCES PREPEND "${CMAKE_SOURCE_DIR}/")
list(TRANSFORM HEADERS PREPEND "${CMAKE_SOURCE_DIR}/")

26
README.md
View File

@@ -2,8 +2,6 @@
![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
@@ -52,13 +50,21 @@ TODO
* SDL3
* SDL3-image
* GLEW
* gtest
e.g. on Archlinux:
```
pacman -S glew sdl3 sdl3_image
pacman -S glew sdl3 sdl3_image gtest
```
Optional dependencies for generating class and include diagrams:
* plantuml
* [clang-uml](https://github.com/bkryza/clang-uml)
clang-uml needs to be either installed from [AUR](https://aur.archlinux.org/packages/clang-uml) or built manually
#### Build
```bash
@@ -68,12 +74,22 @@ cmake --build build -j 16
Optionally you can also use options:
* `-DCMAKE_EXPORT_COMPILE_COMMANDS=ON` to enable compile database export
* `-DCMAKE_EXPORT_COMPILE_COMMANDS=ON` to enable compile database export (needed for class diagram generation)
* `-DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++` to use clang
```
cmake -B build -DCMAKE_EXPORT_COMPILE_COMMANDS=O -DCMAKE_C_COMPILER=clang -DCMAKE_CXX_COMPILER=clang++
``````
```
Run the `pathfinding` binary in the `build` folder.
#### Generate architecture diagrams
Build with `-DCMAKE_EXPORT_COMPILE_COMMANDS=ON`. Then in the root folder run:
```
clang-uml
plantuml -tsvg docs/diagrams/*.puml
```
The resulting svg files are located in [docs/diagrams/](./docs/diagrams/).

32
cpp/src/camera.cpp
View File

@@ -1,45 +1,35 @@
#include "camera.hpp"
#include "math.hpp"
#include "log.hpp"
#include "math.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::Pan(const WorldPos& delta)
{
m_Pan += (delta / m_Zoom);
}
void Camera::Zoom(float delta)
{
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;
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
{
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;
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]};
WorldSize Camera::WindowToWorldSize(WindowSize window) const {
window /= m_Zoom;
return WorldSize{window[0], window[1]};
}

17
cpp/src/camera.hpp
View File

@@ -2,28 +2,27 @@
#include "math.hpp"
class Camera
{
class Camera {
public:
void Pan(const WorldPos& delta);
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;
WindowPos WorldToWindow(WorldPos) const;
WorldPos WindowToWorld(WindowPos) const;
WindowSize WorldToWindowSize(WorldSize) const;
WorldSize WindowToWorldSize(WindowSize) const;
template <typename T>
requires std::floating_point<T>
requires std::floating_point<T>
T WindowToWorldSize(T window_size) const {
return window_size / static_cast<T>(m_Zoom);
}
template <typename T>
requires std::floating_point<T>
requires std::floating_point<T>
T WorldToWindowSize(T world_size) const {
return world_size * static_cast<T>(m_Zoom);
}

23
cpp/src/entities.cpp
View File

@@ -30,7 +30,8 @@ void Entity::ZeroActualVelocityInDirection(WorldPos direction) {
// 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 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
@@ -46,9 +47,8 @@ void Entity::Update(float time_delta) {
m_Position += m_ActualVelocity * time_delta;
}
std::optional<WorldPos> Entity::GetMoveTarget()
{
auto& path = GetPath();
std::optional<WorldPos> Entity::GetMoveTarget() {
auto &path = GetPath();
if (path.empty()) {
return {};
}
@@ -61,27 +61,24 @@ std::optional<WorldPos> Entity::GetMoveTarget()
return next_pos;
}
// target reached, pop it
//m_MoveQueue.pop();
// m_MoveQueue.pop();
path.erase(path.begin());
// return nothing - if there's next point in the queue,
// we'll get it in the next iteration
return {};
}
bool Entity::CollidesWith(const Entity& other) const
{
const auto& A = *this;
const auto& B = other;
bool Entity::CollidesWith(const Entity &other) const {
const auto &A = *this;
const auto &B = other;
auto position_A = A.GetPosition();
auto position_B = B.GetPosition();
auto distance_sq = position_A.DistanceSquared(position_B);
auto collision_distance_sq =
A.GetCollisionRadiusSquared() +
B.GetCollisionRadiusSquared() +
A.GetCollisionRadiusSquared() + B.GetCollisionRadiusSquared() +
2 * A.GetCollisionRadius() * B.GetCollisionRadius();
if (distance_sq < collision_distance_sq)
{
if (distance_sq < collision_distance_sq) {
return true;
}
return false;

12
cpp/src/entities.hpp
View File

@@ -4,13 +4,13 @@
#include <cstdint>
#include <iostream>
#include <memory>
#include <string_view>
#include <optional>
#include <string_view>
#include "log.hpp"
#include "math.hpp"
#include "sprite.hpp"
#include "pathfinder/base.hpp"
#include "sprite.hpp"
class Entity {
public:
@@ -58,12 +58,12 @@ public:
void ZeroActualVelocityInDirection(WorldPos direction);
const pathfinder::Path& GetPath() const { return m_Path; }
pathfinder::Path& GetPath() { return m_Path; }
void SetPath(pathfinder::Path& path) { m_Path = path; }
const pathfinder::Path &GetPath() const { return m_Path; }
pathfinder::Path &GetPath() { return m_Path; }
void SetPath(pathfinder::Path &path) { m_Path = path; }
std::optional<WorldPos> GetMoveTarget();
bool CollidesWith(const Entity& other) const;
bool CollidesWith(const Entity &other) const;
bool IsCollisionBoxVisible() const { return m_CollisionBoxVisible; }

34
cpp/src/gameloop.cpp
View File

@@ -21,18 +21,17 @@ void GameLoop::Draw() {
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->DrawFilledRect(position, size, tiles[row][col]->R, tiles[row][col]->G,
tiles[row][col]->B, tiles[row][col]->A);
m_Window->DrawFilledRect(position, size, tiles[row][col]->R,
tiles[row][col]->G, tiles[row][col]->B,
tiles[row][col]->A);
}
}
// draw the path, if it exists
for (const auto& entity : m_Game->GetEntities())
{
for (const auto &entity : m_Game->GetEntities()) {
WorldPos start_pos = entity->GetPosition();
for (const auto &next_pos : entity->GetPath())
{
for (const auto &next_pos : entity->GetPath()) {
const auto &camera = m_Game->GetCamera();
m_Window->DrawLine(camera.WorldToWindow(start_pos),
camera.WorldToWindow(next_pos));
@@ -44,29 +43,24 @@ void GameLoop::Draw() {
for (auto &entity : m_Game->GetEntities()) {
const auto &camera = m_Game->GetCamera();
auto entity_pos = camera.WorldToWindow(entity->GetPosition());
m_Window->DrawSprite(entity_pos,
entity->GetSprite(),
camera.GetZoom());
if (entity->IsCollisionBoxVisible())
{
float collision_radius = camera.WorldToWindowSize(entity->GetCollisionRadius());
m_Window->DrawSprite(entity_pos, entity->GetSprite(), camera.GetZoom());
if (entity->IsCollisionBoxVisible()) {
float collision_radius =
camera.WorldToWindowSize(entity->GetCollisionRadius());
m_Window->DrawCircle(entity_pos, collision_radius, 255, 0, 0);
}
if (entity->IsSelected())
{
float collision_radius = camera.WorldToWindowSize(entity->GetCollisionRadius());
if (entity->IsSelected()) {
float collision_radius =
camera.WorldToWindowSize(entity->GetCollisionRadius());
m_Window->DrawCircle(entity_pos, collision_radius, 0, 255, 0);
}
}
// draw the selection box, if present
if (m_Game->IsSelectionBoxActive())
{
const auto& [corner_pos, size] = m_Game->GetSelectionBoxPosSize();
if (m_Game->IsSelectionBoxActive()) {
const auto &[corner_pos, size] = m_Game->GetSelectionBoxPosSize();
m_Window->DrawRect(corner_pos, size, 200, 20, 20);
}
}
// TODO rethink coupling and dependencies in the game loop class

14
cpp/src/gameloop.hpp
View File

@@ -3,24 +3,22 @@
#include <memory>
#include "pathfindingdemo.hpp"
#include "window.hpp"
#include "user_input.hpp"
#include "window.hpp"
class GameLoop {
public:
GameLoop() = default;
~GameLoop() = default;
GameLoop(const GameLoop&) = delete;
GameLoop(GameLoop&&) = delete;
GameLoop& operator=(const GameLoop&) = delete;
GameLoop& operator=(GameLoop&&) = delete;
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 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);

6
cpp/src/log.hpp
View File

@@ -3,11 +3,11 @@
#include <iostream>
#if defined(__GNUC__) || defined(__clang__)
# define PRETTY_FUNC __PRETTY_FUNCTION__
#define PRETTY_FUNC __PRETTY_FUNCTION__
#elif defined(_MSC_VER)
# define PRETTY_FUNC __FUNCTION__
#define PRETTY_FUNC __FUNCTION__
#else
# define PRETTY_FUNC __func__
#define PRETTY_FUNC __func__
#endif
#define LOG_CRITICAL(...) Log::critical(PRETTY_FUNC, ": ", __VA_ARGS__)

59
cpp/src/map.cpp
View File

@@ -11,7 +11,7 @@ Map::Map(int rows, int cols) : m_Cols(cols), m_Rows(rows) {
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));
m_Tiles[row].push_back(&tile_types.at(TileType::GRASS));
}
}
}
@@ -25,7 +25,8 @@ WorldPos Map::TileEdgeToWorld(TilePos p) const {
}
TilePos Map::WorldToTile(WorldPos p) const {
return TilePos{static_cast<int32_t>(p.x() / TILE_SIZE), static_cast<int32_t>(p.y() / TILE_SIZE)};
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}; }
@@ -51,40 +52,38 @@ bool Map::IsTilePosValid(TilePos p) const {
return row < m_Tiles.size() && col < m_Tiles[0].size();
}
std::vector<TilePos> Map::GetNeighbors(TilePos center) const
{
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},
center + TilePos{1, 0},
center + TilePos{-1, 0},
center + TilePos{0, 1},
center + TilePos{0, -1},
};
for (const auto& c : candidates) {
for (const auto &c : candidates) {
if (IsTilePosValid(c))
neighbours.push_back(c);
neighbours.push_back(c);
}
return neighbours;
}
void Map::PaintCircle(TilePos center, unsigned radius, TileType tile_type)
{
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)};
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)
{
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);
}
@@ -92,19 +91,24 @@ void Map::PaintCircle(TilePos center, unsigned radius, TileType 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())};
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);
// NOLINTNEXTLINE(clang-analyzer-security.FloatLoopCounter)
for (double t = 0; t < line_length; t += 1.0) {
// NOLINTNEXTLINE(clang-analyzer-security.FloatLoopCounter)
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())};
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());
@@ -114,14 +118,13 @@ void Map::PaintLine(TilePos start_tile, TilePos stop_tile, double width, TileTyp
}
}
void Map::PaintRectangle(TilePos first_corner, TilePos second_corner, TileType 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};
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());

11
cpp/src/map.hpp
View File

@@ -14,10 +14,10 @@ public:
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;
Map(const Map &) = delete;
Map(Map &&) = delete;
Map &operator=(const Map &) = delete;
Map &operator=(Map &&) = delete;
const TileGrid &GetMapTiles() const { return m_Tiles; }
@@ -35,7 +35,8 @@ public:
// 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);
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; }

233
cpp/src/math.hpp
View File

@@ -4,12 +4,12 @@
#include <cassert>
#include <cmath>
#include <concepts>
#include <functional>
#include <initializer_list>
#include <iostream>
#include <numeric>
#include <ranges>
#include <utility>
#include <functional>
#ifdef _WIN32
#include <numbers>
@@ -37,6 +37,10 @@ static inline bool equalEpsilon(const T &a, const T &b) {
struct Any {};
template <typename T, size_t N, typename Tag = Any> class vec {
// Friend declaration for move constructor from different tag types
template <typename U, size_t M, typename OtherTag> friend class vec;
public:
vec() : m_Array{} {}
@@ -46,6 +50,9 @@ public:
vec(std::array<T, N> array) : m_Array{array} {}
template <typename OtherTag>
vec(vec<T, N, OtherTag> &&other) : m_Array{std::move(other.m_Array)} {}
//
// Access to elements & data
//
@@ -69,20 +76,20 @@ public:
return os;
}
std::array<T,N>& Data() { return m_Array; }
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>)
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>)
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)) {
@@ -101,6 +108,13 @@ public:
return c;
}
friend vec operator+(const vec &a, T b) {
vec<T, N, Tag> c;
std::ranges::transform(a.m_Array, std::views::repeat(b), 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(),
@@ -108,6 +122,13 @@ public:
return c;
}
friend vec operator-(const vec &a, T b) {
vec<T, N, Tag> c;
std::ranges::transform(a.m_Array, std::views::repeat(b), 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),
@@ -124,6 +145,13 @@ public:
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::divides{});
return c;
}
//
// compound-assignment operators
//
@@ -142,12 +170,12 @@ public:
return a;
}
vec& operator/=(float scalar)
{
vec& a = *this;
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?
// TODO check all of this, could be done better with views instead of
// ranges?
return a;
}
@@ -172,7 +200,6 @@ public:
return (a - b).LengthSquared();
}
//
// In-place vector operations
//
@@ -206,16 +233,14 @@ public:
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{});
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;
T DotProduct(const vec &b) const {
const auto &a = *this;
return DotProduct(a, b);
}
@@ -259,10 +284,27 @@ public:
return m_Array[2];
}
template <typename TargetTag>
vec<T,N,TargetTag> ChangeTag()
template <typename TargetTag> vec<T, N, TargetTag> ChangeTag() const & {
return vec<T, N, TargetTag>(m_Array);
}
template <typename TargetTag> vec<T, N, TargetTag> ChangeTag() && {
return vec<T, N, TargetTag>(std::move(*this));
}
// Structured binding support for N == 2
template <size_t I>
const T &get() const
requires(N == 2 && I < 2)
{
return vec<T,N,TargetTag>(m_Array);
return m_Array[I];
}
template <size_t I>
T &get()
requires(N == 2 && I < 2)
{
return m_Array[I];
}
private:
@@ -320,92 +362,101 @@ struct TilePosHash {
//
// Collumn major square matrix
template <typename T, size_t N, typename Tag = Any>
class Matrix {
template <typename T, size_t N, typename Tag = Any> class Matrix {
using vec_type = vec<T, N, Tag>;
using vec_type = vec<T, N, Tag>;
public:
Matrix() = default;
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());
}
// 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]; }
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 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::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 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 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;
}
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;
static constexpr Matrix Eye() {
Matrix E;
for (size_t i = 0; i < N; i++) {
E[i][i] = T{1};
}
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;
}
return E;
}
private:
std::array<vec_type, N> m_Array;
std::array<vec_type, N> m_Array;
};
// Structured binding support for vec<T, 2, Tag>
namespace std {
template <typename T, typename Tag>
struct tuple_size<vec<T, 2, Tag>> : integral_constant<size_t, 2> {};
template <size_t I, typename T, typename Tag>
struct tuple_element<I, vec<T, 2, Tag>> {
using type = T;
};
} // namespace std
// ADL-based get for structured bindings
template <size_t I, typename T, typename Tag>
const T &get(const vec<T, 2, Tag> &v) {
return v.template get<I>();
}
template <size_t I, typename T, typename Tag> T &get(vec<T, 2, Tag> &v) {
return v.template get<I>();
}

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

@@ -1,5 +1,5 @@
#include <memory>
#include <cassert>
#include <memory>
#include <queue>
#include "pathfinder/base.hpp"
@@ -9,14 +9,15 @@
namespace pathfinder {
PathFinderBase::PathFinderBase(const Map* map) : m_Map(map) {}
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
Path LinearPathFinder::CalculatePath(
WorldPos, WorldPos end) // first argument (start pos) not used
{
auto path = Path{end};
return path;
}
} // pathfinder namespace
} // namespace pathfinder

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

@@ -1,11 +1,11 @@
#pragma once
#include <vector>
#include <memory>
#include <unordered_map>
#include <vector>
#include "math.hpp"
#include "map.hpp"
#include "math.hpp"
namespace pathfinder {
@@ -21,32 +21,30 @@ enum class PathFinderType {
class PathFinderBase {
public:
PathFinderBase(const Map* m);
~PathFinderBase() = default;
PathFinderBase(const Map *m);
virtual ~PathFinderBase() = default;
PathFinderBase(const PathFinderBase&) = delete;
PathFinderBase(PathFinderBase&&) = delete;
PathFinderBase& operator=(const PathFinderBase&) = delete;
PathFinderBase& operator=(PathFinderBase&&) = delete;
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 const std::string_view &GetName() const = 0;
virtual Path CalculatePath(WorldPos start, WorldPos end) = 0;
protected:
const Map* m_Map;
const Map *m_Map;
};
class LinearPathFinder : public PathFinderBase {
class LinearPathFinder final : public PathFinderBase {
public:
LinearPathFinder(const Map* m): PathFinderBase(m) {}
LinearPathFinder(const Map *m) : PathFinderBase(m) {}
Path CalculatePath(WorldPos start, WorldPos end) override;
const std::string_view& GetName() const override { return m_Name; }
const std::string_view &GetName() const override { return m_Name; }
private:
const std::string_view m_Name = "Linear Path";
};
} // pathfinder namespace
} // namespace pathfinder

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

@@ -9,58 +9,59 @@
namespace pathfinder {
Path BFS::CalculatePath(WorldPos start_world, WorldPos end_world) {
if (m_Map == nullptr) return {};
if (m_Map == nullptr)
return {};
const TilePos start = m_Map->WorldToTile(start_world);
const TilePos end = m_Map->WorldToTile(end_world);
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();
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;
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();
// ---------------- 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;
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;
}
}
if (next == end) { // early exit
early_exit = true;
break;
}
}
}
}
// --------------- reconstruct path -----------------
if (m_CameFrom.find(end) == m_CameFrom.end())
return {}; // end not reached
// --------------- reconstruct path -----------------
if (m_CameFrom.find(end) == m_CameFrom.end())
return {}; // end not reached
Path path;
TilePos cur = end;
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));
while (cur != start) {
cur = m_CameFrom[cur];
path.push_back(m_Map->TileToWorld(cur));
}
std::reverse(path.begin(), path.end());
return path;
}
std::reverse(path.begin(), path.end());
return path;
}
} // pathfinder namespace
} // namespace pathfinder

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

@@ -9,12 +9,12 @@
namespace pathfinder {
class BFS: public PathFinderBase {
class BFS final : public PathFinderBase {
public:
BFS(const Map* m): PathFinderBase(m) {}
BFS(const Map *m) : PathFinderBase(m) {}
Path CalculatePath(WorldPos start, WorldPos end) override;
const std::string_view& GetName() const override { return m_Name; }
const std::string_view &GetName() const override { return m_Name; }
private:
const std::string_view m_Name = "Breadth First Search";
@@ -22,4 +22,4 @@ private:
std::unordered_map<TilePos, TilePos, TilePosHash> m_CameFrom;
};
}
} // namespace pathfinder

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

@@ -3,71 +3,69 @@
#include "dijkstra.hpp"
#include "base.hpp"
#include "utils.hpp"
#include "math.hpp"
#include "map.hpp"
#include "math.hpp"
#include "utils.hpp"
namespace pathfinder {
Path Dijkstra::CalculatePath(WorldPos start_world, WorldPos end_world)
{
Path Dijkstra::CalculatePath(WorldPos start_world, WorldPos end_world) {
using QueueEntry = utils::QueueEntry;
if (!m_Map) return {};
if (!m_Map)
return {};
const TilePos start = m_Map->WorldToTile(start_world);
const TilePos end = m_Map->WorldToTile(end_world);
const TilePos end = m_Map->WorldToTile(end_world);
if (!m_Map->IsTilePosValid(start) || !m_Map->IsTilePosValid(end))
return {};
if (start == end) return {};
return {};
if (start == end)
return {};
// clear previous run
m_CameFrom.clear();
m_Cost.clear();
std::priority_queue<QueueEntry, std::vector<QueueEntry>, std::greater<>> frontier;
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;
m_CameFrom[start] = start; // sentinel
m_Cost[start] = 0.0f;
while (!frontier.empty())
{
const QueueEntry current = frontier.top();
frontier.pop();
while (!frontier.empty()) {
const QueueEntry current = frontier.top();
frontier.pop();
if (current.tile == end) // early exit
break;
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);
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});
}
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
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));
while (cur != start) {
cur = m_CameFrom[cur];
path.push_back(m_Map->TileToWorld(cur));
}
std::reverse(path.begin(), path.end());
return path;
}
} // pathfinder namespace
} // namespace pathfinder

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

@@ -10,12 +10,12 @@
namespace pathfinder {
class Dijkstra: public PathFinderBase {
class Dijkstra final : public PathFinderBase {
public:
Dijkstra(const Map* m): PathFinderBase(m) {}
Dijkstra(const Map *m) : PathFinderBase(m) {}
Path CalculatePath(WorldPos start, WorldPos end) override;
const std::string_view& GetName() const override { return m_Name; }
const std::string_view &GetName() const override { return m_Name; }
private:
const std::string_view m_Name = "Dijkstra's Algorithm";
@@ -23,4 +23,4 @@ private:
std::unordered_map<TilePos, TilePos, TilePosHash> m_CameFrom;
};
} // pathfinder namespace
} // namespace pathfinder

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

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

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

@@ -10,17 +10,17 @@
namespace pathfinder {
class GBFS: public PathFinderBase {
class GBFS final : public PathFinderBase {
public:
GBFS(const Map* m): PathFinderBase(m) {}
GBFS(const Map *m) : PathFinderBase(m) {}
Path CalculatePath(WorldPos start, WorldPos end) override;
const std::string_view& GetName() const override { return m_Name; }
const std::string_view &GetName() const override { return m_Name; }
private:
static float Heuristic(const TilePos& a, const TilePos& b);
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
} // namespace pathfinder

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

@@ -3,9 +3,9 @@
#include "utils.hpp"
#include "base.hpp"
#include "log.hpp"
#include "map.hpp"
#include "math.hpp"
#include "log.hpp"
#include "pathfinder/bfs.hpp"
#include "pathfinder/dijkstra.hpp"
#include "pathfinder/gbfs.hpp"
@@ -13,23 +13,23 @@
namespace pathfinder {
namespace utils {
std::unique_ptr<PathFinderBase> create(PathFinderType type, const Map* map) {
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;
case PathFinderType::LINEAR:
return std::make_unique<LinearPathFinder>(map);
case PathFinderType::BFS:
return std::make_unique<BFS>(map);
case PathFinderType::DIJKSTRA:
return std::make_unique<Dijkstra>(map);
case PathFinderType::GBFS:
return std::make_unique<GBFS>(map);
case PathFinderType::COUNT:
LOG_WARNING("Incorrect pathfinder type");
return nullptr;
};
return nullptr;
}
} // utils namespace
} // pathfinding namespace
} // namespace utils
} // namespace pathfinder

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

@@ -10,16 +10,16 @@
namespace pathfinder {
namespace utils {
struct QueueEntry
{
float cost;
TilePos tile;
struct QueueEntry {
float cost;
TilePos tile;
// min-heap -> smallest cost on top
bool operator>(const QueueEntry& o) const noexcept { return cost > o.cost; }
// 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);
std::unique_ptr<pathfinder::PathFinderBase>
create(pathfinder::PathFinderType type, const Map *map);
} // utils namespace
} // pathfinding namespace
} // namespace utils
} // namespace pathfinder

173
cpp/src/pathfindingdemo.cpp
View File

@@ -8,17 +8,16 @@
#include "entities.hpp"
#include "log.hpp"
#include "map.hpp"
#include "user_input.hpp"
#include "pathfinder/base.hpp"
#include "pathfinder/utils.hpp"
#include "tile.hpp"
#include "user_input.hpp"
PathFindingDemo::PathFindingDemo(int width, int height) :
m_Map(width, height)
{
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);
m_PathFinder = pathfinder::utils::create(pathfinder::PathFinderType::DIJKSTRA,
(const Map *)&m_Map);
}
PathFindingDemo::~PathFindingDemo() { LOG_DEBUG("."); }
@@ -33,27 +32,27 @@ void PathFindingDemo::CreateMap() {
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);
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);
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);
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);
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);
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 some controllable entities
m_Entities.clear();
@@ -65,19 +64,16 @@ void PathFindingDemo::CreateMap() {
player2->SetPosition(m_Map.TileToWorld(TilePos{50, 20}));
AddEntity(player2);
for (int i = 0; i < 1; i++)
{
for (int j = 0; j < 10; j++)
{
for (int i = 0; i < 1; i++) {
for (int j = 0; j < 10; j++) {
auto p = std::make_shared<Player>();
p->SetPosition(m_Map.TileToWorld(TilePos{10+5*i, 40+5*j}));
p->SetPosition(m_Map.TileToWorld(TilePos{10 + 5 * i, 40 + 5 * j}));
AddEntity(p);
}
}
// select everything - TODO this is just temporary for testing
for (const auto& entity : m_Entities)
{
for (const auto &entity : m_Entities) {
m_SelectedEntities.push_back(entity);
}
}
@@ -86,23 +82,17 @@ WorldPos PathFindingDemo::GetRandomPosition() const {
return WorldPos{0.0f, 0.0f}; // totally random!
}
const std::vector<Collision>& PathFindingDemo::GetEntityCollisions()
{
const std::vector<Collision> &PathFindingDemo::GetEntityCollisions() {
static std::vector<Collision> m_Collisions;
m_Collisions.clear();
for (const auto &entity_A : m_Entities)
{
for (const auto &entity_B : m_Entities)
{
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;
if (entity_A->CollidesWith(*entity_B))
{
if (entity_A->CollidesWith(*entity_B)) {
// handle collision logic
m_Collisions.emplace_back(Collision(entity_A, entity_B));
}
@@ -111,37 +101,33 @@ const std::vector<Collision>& PathFindingDemo::GetEntityCollisions()
return m_Collisions;
}
// Update entity positions, handle collisions
void PathFindingDemo::UpdateWorld() {
float time_delta = 1.0f;
for (auto& entity : m_Entities)
{
for (auto &entity : m_Entities) {
// calculate the velocity
auto current_pos = entity->GetPosition();
double tile_velocity_coeff = m_Map.GetTileVelocityCoeff(current_pos);
auto next_pos = entity->GetMoveTarget();
WorldPos velocity = WorldPos{};
if (next_pos)
{
if (next_pos) {
velocity = next_pos.value() - current_pos;
velocity.Normalize();
//LOG_DEBUG("I want to move to: ", next_pos.value(),
// ", velocity: ", velocity);
// LOG_DEBUG("I want to move to: ", next_pos.value(),
// ", velocity: ", velocity);
}
entity->SetActualVelocity(velocity * tile_velocity_coeff);
for (const auto& collision : GetEntityCollisions())
{
// TODO this loop is quite "hot", is it good idea to use weak_ptr and promote it?
for (const auto &collision : GetEntityCollisions()) {
// TODO this loop is quite "hot", is it good idea to use weak_ptr and
// promote it?
auto weak_A = std::get<0>(collision);
auto weak_B = std::get<1>(collision);
auto A = weak_A.lock();
auto B = weak_B.lock();
if (A == nullptr || B == nullptr)
{
if (A == nullptr || B == nullptr) {
continue;
}
if (!A->IsMovable())
@@ -159,58 +145,43 @@ void PathFindingDemo::UpdateWorld() {
}
}
void PathFindingDemo::HandleActions(const std::vector<UserAction> &actions)
{
for (const auto &action : actions)
{
if (action.type == UserAction::Type::EXIT)
{
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)
{
} else if (action.type == UserAction::Type::SET_MOVE_TARGET) {
WorldPos target_pos = m_Camera.WindowToWorld(action.Argument.position);
for (auto& selected_entity : m_SelectedEntities)
{
for (auto &selected_entity : m_SelectedEntities) {
LOG_INFO("Calculating path to target: ", target_pos);
if (auto sp = selected_entity.lock())
{
auto path = m_PathFinder->CalculatePath(sp->GetPosition(), target_pos);
if (auto sp = selected_entity.lock()) {
auto path =
m_PathFinder->CalculatePath(sp->GetPosition(), target_pos);
sp->SetPath(path);
LOG_INFO("Done, path node count: ", path.size());
} else {
LOG_INFO("Cannot calculate path for destroyed entity (weak_ptr.lock() failed)");
LOG_INFO("Cannot calculate path for destroyed entity "
"(weak_ptr.lock() failed)");
}
}
}
else if (action.type == UserAction::Type::SELECT_PATHFINDER)
{
} 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);
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;
} 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)
{
} else if (action.type == UserAction::Type::CAMERA_ZOOM) {
m_Camera.Zoom(action.Argument.float_number);
LOG_INFO("Camera zoom: ", action.Argument.float_number);
}
else if (action.type == UserAction::Type::SELECTION_START)
{
} else if (action.type == UserAction::Type::SELECTION_START) {
m_SelectionBox.active = true;
m_SelectionBox.start = action.Argument.position;
m_SelectionBox.end = action.Argument.position;
}
else if (action.type == UserAction::Type::SELECTION_END)
{
} else if (action.type == UserAction::Type::SELECTION_END) {
m_SelectionBox.end = action.Argument.position;
m_SelectionBox.active = false;
auto diff = m_SelectionBox.end - m_SelectionBox.start;
@@ -219,9 +190,7 @@ void PathFindingDemo::HandleActions(const std::vector<UserAction> &actions)
WorldPos start = m_Camera.WindowToWorld(m_SelectionBox.start);
WorldPos end = m_Camera.WindowToWorld(m_SelectionBox.end);
SelectEntitiesInRectangle(start, end);
}
else if (action.type == UserAction::Type::SELECTION_CHANGE)
{
} else if (action.type == UserAction::Type::SELECTION_CHANGE) {
m_SelectionBox.end = action.Argument.position;
auto diff = m_SelectionBox.end - m_SelectionBox.start;
m_SelectionBox.size = diff.ChangeTag<WindowSizeTag>();
@@ -229,30 +198,25 @@ void PathFindingDemo::HandleActions(const std::vector<UserAction> &actions)
};
}
void PathFindingDemo::DeselectEntities()
{
std::for_each(m_SelectedEntities.begin(), m_SelectedEntities.end(), [](auto& x)
{
if (auto entity = x.lock())
entity->Deselect();
}
);
void PathFindingDemo::DeselectEntities() {
std::for_each(m_SelectedEntities.begin(), m_SelectedEntities.end(),
[](auto &x) {
if (auto entity = x.lock())
entity->Deselect();
});
m_SelectedEntities.clear();
}
void PathFindingDemo::SelectEntitiesInRectangle(WorldPos A, WorldPos B)
{
void PathFindingDemo::SelectEntitiesInRectangle(WorldPos A, WorldPos B) {
DeselectEntities();
// TODO use colliders for this
auto [x_min, x_max] = std::minmax(A.x(), B.x());
auto [y_min, y_max] = std::minmax(A.y(), B.y());
for (const auto& entity : m_Entities)
{
const auto& pos = entity->GetPosition();
for (const auto &entity : m_Entities) {
const auto &pos = entity->GetPosition();
bool x_in_range = x_min < pos.x() && pos.x() < x_max;
bool y_in_range = y_min < pos.y() && pos.y() < y_max;
if (x_in_range && y_in_range)
{
if (x_in_range && y_in_range) {
m_SelectedEntities.push_back(std::weak_ptr(entity));
entity->Select();
}
@@ -260,12 +224,9 @@ void PathFindingDemo::SelectEntitiesInRectangle(WorldPos A, WorldPos B)
LOG_INFO("Selected ", m_SelectedEntities.size(), " entities");
}
std::pair<WindowPos, WindowSize> PathFindingDemo::GetSelectionBoxPosSize()
{
const auto& pos = m_SelectionBox.start;
std::pair<WindowPos, WindowSize> PathFindingDemo::GetSelectionBoxPosSize() {
const auto &pos = m_SelectionBox.start;
WindowPos size_pos = m_SelectionBox.end - m_SelectionBox.start;
WindowSize size = size_pos.ChangeTag<WindowSizeTag>();
return std::pair(pos, size);
}

19
cpp/src/pathfindingdemo.hpp
View File

@@ -5,17 +5,16 @@
#include <queue>
#include <vector>
#include "camera.hpp"
#include "entities.hpp"
#include "log.hpp"
#include "map.hpp"
#include "user_input.hpp"
#include "pathfinder/base.hpp"
#include "camera.hpp"
#include "user_input.hpp"
using Collision = std::pair<std::weak_ptr<Entity>, std::weak_ptr<Entity>>;
struct SelectionBox
{
struct SelectionBox {
WindowPos start, end;
WindowSize size;
bool active;
@@ -31,9 +30,9 @@ public:
PathFindingDemo &operator=(const PathFindingDemo &) = delete;
PathFindingDemo &operator=(PathFindingDemo &&) = delete;
std::vector<std::shared_ptr<Entity>>& GetEntities() { return m_Entities; }
const Map& GetMap() const { return m_Map; }
const Camera& GetCamera() const { return m_Camera; }
std::vector<std::shared_ptr<Entity>> &GetEntities() { return m_Entities; }
const Map &GetMap() const { return m_Map; }
const Camera &GetCamera() const { return m_Camera; }
bool IsExitRequested() const { return m_ExitRequested; }
void AddEntity(std::shared_ptr<Entity> e);
@@ -46,10 +45,12 @@ public:
void DeselectEntities();
bool IsSelectionBoxActive() const { return m_SelectionBox.active; }
std::pair<WindowPos, WindowSize> GetSelectionBoxPosSize();
std::vector<std::weak_ptr<Entity>> GetSelectedEntities() { return m_SelectedEntities; }
std::vector<std::weak_ptr<Entity>> GetSelectedEntities() {
return m_SelectedEntities;
}
private:
const std::vector<Collision>& GetEntityCollisions();
const std::vector<Collision> &GetEntityCollisions();
bool m_ExitRequested = false;
Map m_Map;

256
cpp/src/positional_container.hpp Normal file
View File

@@ -0,0 +1,256 @@
#pragma once
#include <vector>
#include <memory>
#include <cstdlib>
#include <cmath>
#include <algorithm>
#include <iterator>
#include "math.hpp"
#include "log.hpp"
template <typename T>
concept HasPosition = requires(T t, WorldPos pos) {
{ t.GetPosition() } -> std::convertible_to<WorldPos>;
t.SetPosition(pos);
};
template <typename T>
concept HasCollisions = requires(T t) {
t.Dummy(); // TODO
};
template <typename T>
requires HasPosition<T>
class IPositionalContainer
{
public:
virtual ~IPositionalContainer() = default;
virtual bool Add(std::shared_ptr<T> t) = 0;
virtual std::vector<std::weak_ptr<T>> Get(const WorldPos& p, float radius) = 0;
virtual void UpdateAll() = 0;
virtual void Update(std::shared_ptr<T> item) = 0;
};
template <typename T>
class IColliderContainer : public IPositionalContainer<T>
{
public:
virtual std::vector<std::weak_ptr<T>> GetCollisions() = 0;
};
template <typename T>
class SimpleContainer : IPositionalContainer<T>
{
public:
bool Add(std::shared_ptr<T> t) override
{
m_Items.push_back(t);
return true;
}
std::vector<std::weak_ptr<T>> Get(const WorldPos& center, float radius) override
{
std::vector<std::weak_ptr<T>> matched_items;
for (const auto& item : m_Items)
{
if (center.DistanceTo(item->GetPosition()) < radius)
{
matched_items.push_back(item);
}
}
return matched_items;
}
// no update needed here, as we have no smart lookup scheme
void UpdateAll() override {}
void Update(std::shared_ptr<T>) override {}
private:
std::vector<std::shared_ptr<T>> m_Items;
};
template <class T>
class PositionalContainer : IPositionalContainer<T>
{
public:
PositionalContainer(const WorldSize& size, size_t chunks) :
m_GridSize{size},
m_GridStep{size / chunks},
m_ChunksPerAxis{chunks}
{
LOG_INFO("Size: ", m_GridSize, " step: ", m_GridStep);
m_Grid.reserve(chunks);
for (size_t i = 0; i < chunks; i++)
{
m_Grid.emplace_back(chunks);
for (size_t j = 0; j < chunks; j++)
{
m_Grid[i][j].reserve(16);
}
}
}
// calling Add on object that is already in the container is UB
bool Add(std::shared_ptr<T> item) override
{
const auto& world_pos = item->GetPosition();
if (!CheckBounds(world_pos))
{
return false;
}
m_Items.push_back(item);
auto coords = GetCoords(world_pos);
m_Grid[coords.x()][coords.y()].push_back(item);
m_ReverseGridLookup[item] = coords;
// TODO should we call Update instead?
//Update(item);
return true;
}
std::vector<std::weak_ptr<T>> Get(const WorldPos& center, float radius) override
{
vector_wptr output_vec{};
Get(output_vec, center, radius);
return output_vec;
}
void Get(std::vector<std::weak_ptr<T>>& output_vec, const WorldPos& corner, const WorldSize& size)
{
const WorldSize half_size = size / 2.0f;
const WorldPos center = corner + half_size.ChangeTag<WorldPos>();
float radius = half_size.x();
Get(output_vec, center, radius);
}
// TODO add those Get methods to the interface
void Get(std::vector<std::weak_ptr<T>>& output_vec, const WorldPos& center, float radius)
{
output_vec.clear();
const WorldPos corner_1 = center + radius;
const WorldPos corner_2 = center - radius;
const auto A = GetCoords(corner_1);
const auto B = GetCoords(corner_2);
auto [x_min_f, x_max_f] = std::minmax(A.x(), B.x());
auto [y_min_f, y_max_f] = std::minmax(A.y(), B.y());
size_t x_min = static_cast<size_t>(std::floor(x_min_f));
size_t x_max = static_cast<size_t>(std::ceil(x_max_f));
size_t y_min = static_cast<size_t>(std::floor(y_min_f));
size_t y_max = static_cast<size_t>(std::ceil(y_max_f));
for (size_t x = x_min; x <= x_max; x++)
{
for (size_t y = y_min; y <= y_max; y++)
{
if (!CheckBounds(x, y))
{
continue;
}
#if 0
// TODO this is approx 2x faster, but inserts items outside of radius;
// We can use this is a Get(rectangle) function
std::ranges::copy(m_Grid[x][y], std::back_inserter(output_vec));
#else
for (auto item_wptr : m_Grid[x][y])
{
if (auto shared = item_wptr.lock())
{
if (center.DistanceTo(shared->GetPosition()) < radius)
{
output_vec.push_back(item_wptr);
}
}
}
#endif
}
}
}
void UpdateAll() override
{
for (auto ptr : m_Items)
{
// TODO is this efficient? Maybe use const ref?
Update(ptr);
}
}
void Update(std::shared_ptr<T> item) override
{
coord_type current_coords = GetCoords(item->GetPosition());
coord_type last_known_coords = m_ReverseGridLookup[item];
if (current_coords == last_known_coords)
{
return;
}
vector_wptr& vec = m_Grid[last_known_coords.x()][last_known_coords.y()];
// remove the old weak ptr from the map
vec.erase(std::remove_if(vec.begin(), vec.end(),
[&](const std::weak_ptr<T>& w)
{
return !w.owner_before(item) && !item.owner_before(w);
}),
vec.end());
// add new weak ptr to the map
m_Grid[current_coords.x()][current_coords.y()].push_back(item);
}
private:
using coord_type = vec<size_t, 2>;
using vector_wptr = std::vector<std::weak_ptr<T>>;
using grid_type = std::vector<std::vector<vector_wptr>>;
coord_type GetCoords(const WorldPos &wp)
{
auto coord_float = wp / m_GridStep.ChangeTag<WorldPos>();
return coord_type{
static_cast<size_t>(coord_float.x()),
static_cast<size_t>(coord_float.y())
};
}
bool CheckBounds(size_t x, size_t y) const
{
bool x_in_bounds = x < m_Grid.size();
bool y_in_bounds = y < m_Grid.size();
return x_in_bounds && y_in_bounds;
}
bool CheckBounds(const WorldPos& pos) const
{
auto [x,y] = pos;
bool x_in_bounds = 0.0f < x && x < m_GridSize.x();
bool y_in_bounds = 0.0f < y && y < m_GridSize.y();
return x_in_bounds && y_in_bounds;
}
WorldSize m_GridSize;
WorldSize m_GridStep;
size_t m_ChunksPerAxis;
// TODO it would be better to have vector<T> - contiguous memory, more cache-friendly?
std::vector<std::shared_ptr<T>> m_Items;
grid_type m_Grid;
// normal lookup: WorldPos -> coord_type -> vector_wptr -> std::shared_ptr<T>
// reverse lookup: std::shared_ptr<T> -> vector_wptr -> coord_type
// we need the reverse lookup because T.GetPosition() may change and we need to delete
// the old weak_ptr from vector_wptr (without iterating through all of them).
// Also it might be useful to have T -> location lookup
// Note: hash of std::shared_ptr<T> may give us trouble if we free the memory and new one points
// to the same location, maybe it would be better to hash the object itself?
// TODO how about using counting bloom filter for this?
std::unordered_map<std::shared_ptr<T>, coord_type> m_ReverseGridLookup;
};

10
cpp/src/tile.cpp
View File

@@ -6,9 +6,9 @@
// 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}},
{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}},
};

2
cpp/src/tile.hpp
View File

@@ -1,9 +1,9 @@
#pragma once
#include <array>
#include <cstdint>
#include <map>
#include <string_view>
#include <array>
#include <unordered_map>
struct Tile {

127
cpp/src/user_input.cpp
View File

@@ -2,8 +2,8 @@
#include <expected>
#include <map>
#include <string>
#include <vector>
#include <unordered_set>
#include <vector>
#include "user_input.hpp"
@@ -20,130 +20,103 @@ UserInput::~UserInput() { LOG_DEBUG("."); };
std::expected<void, std::string> UserInput::Init() { return {}; }
void UserInput::GetActions_mouse(const SDL_Event& event)
{
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)
{
if (event.type == SDL_EVENT_MOUSE_BUTTON_DOWN) {
if (button == MouseButton::LEFT) {
LOG_DEBUG("Selection start at ", mouse_event.x, ", ", mouse_event.y);
m_SelectionActive = true;
m_Actions.emplace_back(UserAction::Type::SELECTION_START,
WindowPos{mouse_event.x, mouse_event.y});
}
else if (button == MouseButton::RIGHT)
{
} else if (button == MouseButton::RIGHT) {
LOG_DEBUG("Set move target to: ", 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)
{
} else if (button == MouseButton::MIDDLE) {
mouse_pan = true;
}
}
else if (event.type == SDL_EVENT_MOUSE_BUTTON_UP)
{
if (button == MouseButton::LEFT)
{
} else if (event.type == SDL_EVENT_MOUSE_BUTTON_UP) {
if (button == MouseButton::LEFT) {
LOG_DEBUG("Selection end at ", mouse_event.x, ", ", mouse_event.y);
m_SelectionActive = false;
m_Actions.emplace_back(UserAction::Type::SELECTION_END,
WindowPos{mouse_event.x, mouse_event.y});
}
if (button == MouseButton::MIDDLE)
{
if (button == MouseButton::MIDDLE) {
mouse_pan = false;
}
}
else if (event.type == SDL_EVENT_MOUSE_MOTION)
{
} else if (event.type == SDL_EVENT_MOUSE_MOTION) {
SDL_MouseMotionEvent motion_event = event.motion;
if (mouse_pan)
{
if (mouse_pan) {
m_Actions.emplace_back(UserAction::Type::CAMERA_PAN,
WindowPos{motion_event.xrel, motion_event.yrel});
}
if (m_SelectionActive)
{
if (m_SelectionActive) {
m_Actions.emplace_back(UserAction::Type::SELECTION_CHANGE,
WindowPos{mouse_event.x, mouse_event.y});
}
}
else if(event.type == SDL_EVENT_MOUSE_WHEEL)
{
} 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");
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;
}
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() {
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,
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_KEY_DOWN,
SDL_EVENT_KEY_UP,
};
SDL_Event event;
m_Actions.clear();
while (SDL_PollEvent(&event))
{
if (keyboard_events.contains(event.type))
{
while (SDL_PollEvent(&event)) {
if (keyboard_events.contains(event.type)) {
GetActions_keyboard(event);
}
else if (mouse_events.contains(event.type))
{
} else if (mouse_events.contains(event.type)) {
GetActions_mouse(event);
}
else
{
} else {
// TODO uncomment, for now too much noise
// LOG_WARNING("Action not processed");
}

10
cpp/src/user_input.hpp
View File

@@ -12,9 +12,7 @@ enum class MouseButton { LEFT = 1, MIDDLE, RIGHT };
class UserAction {
public:
enum class Type
{
enum class Type {
NONE,
EXIT,
SET_MOVE_TARGET,
@@ -44,7 +42,7 @@ public:
} Argument;
// TODO use std::variant
//std::variant<WindowPos, char, int> Argument;
// std::variant<WindowPos, char, int> Argument;
};
class UserInput {
@@ -65,6 +63,6 @@ private:
std::vector<UserAction> m_Actions;
bool m_SelectionActive = false;
void GetActions_keyboard(const SDL_Event&);
void GetActions_mouse(const SDL_Event&);
void GetActions_keyboard(const SDL_Event &);
void GetActions_mouse(const SDL_Event &);
};

18
cpp/src/window.cpp
View File

@@ -79,19 +79,20 @@ Window::~Window() {
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_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::DrawFilledRect(const WindowPos &position, const WindowSize size, uint8_t R,
uint8_t G, uint8_t B, uint8_t A) {
void Window::DrawFilledRect(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::DrawRect(const WindowPos &position, const WindowSize size, uint8_t R, uint8_t G, uint8_t B) {
void Window::DrawRect(const WindowPos &position, const WindowSize size,
uint8_t R, uint8_t G, uint8_t B) {
SDL_FRect rect = {position.x(), position.y(), size.x(), size.y()};
SDL_SetRenderDrawColor(m_Renderer.get(), R, G, B, 255);
SDL_RenderRect(m_Renderer.get(), &rect);
@@ -105,7 +106,8 @@ void Window::ClearWindow() {
void Window::Flush() { SDL_RenderPresent(m_Renderer.get()); }
// TODO use some struct for color
void Window::DrawCircle(const WindowPos &position, float radius, uint8_t R, uint8_t G, uint8_t B) {
void Window::DrawCircle(const WindowPos &position, float radius, uint8_t R,
uint8_t G, uint8_t B) {
int cx = static_cast<int>(position.x());
int cy = static_cast<int>(position.y());
SDL_SetRenderDrawColor(m_Renderer.get(), R, G, B, 255);
@@ -117,9 +119,7 @@ void Window::DrawCircle(const WindowPos &position, float radius, uint8_t R, uint
}
}
void Window::DrawLine(const WindowPos &A, const WindowPos &B)
{
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());
}

11
cpp/src/window.hpp
View File

@@ -23,12 +23,14 @@ public:
std::expected<void, std::string> Init();
void DrawSprite(const WindowPos &position, Sprite &s, float scale = 1.0f);
void DrawFilledRect(const WindowPos &position, const WindowSize size, uint8_t R,
uint8_t G, uint8_t B, uint8_t A);
void DrawRect(const WindowPos &position, const WindowSize size, uint8_t R, uint8_t G, uint8_t B);
void DrawFilledRect(const WindowPos &position, const WindowSize size,
uint8_t R, uint8_t G, uint8_t B, uint8_t A);
void DrawRect(const WindowPos &position, const WindowSize size, uint8_t R,
uint8_t G, uint8_t B);
void ClearWindow();
void Flush();
void DrawCircle(const WindowPos &position, float radius, uint8_t R, uint8_t G, uint8_t B);
void DrawCircle(const WindowPos &position, float radius, uint8_t R, uint8_t G,
uint8_t B);
void DrawLine(const WindowPos &A, const WindowPos &B);
private:
@@ -37,5 +39,4 @@ private:
std::shared_ptr<SDL_Renderer> m_Renderer = nullptr;
SDL_Window *m_Window;
SDL_GLContext m_Context;
};

187
cpp/test/collision_performance.cpp
View File

@@ -2,10 +2,11 @@
#include <chrono>
#include <iostream>
#include <iomanip>
#include <random>
#include <algorithm>
#include <set>
// TODO: Add necessary includes for collision testing
// #include "collision_shapes.hpp"
// #include "entities.hpp"
#include "positional_container.hpp"
/**
* @file collision_performance.cpp
@@ -74,33 +75,177 @@ void benchmark_function(const std::string& name, int iterations, Func func) {
<< " ops/sec" << std::endl;
}
// Example test function 1
void test_function_1() {
// TODO: Implement actual collision test
volatile int sum = 0;
for (int i = 0; i < 1000; ++i) {
sum += i;
}
/**
* @brief Simple dummy class that conforms to HasPosition concept
* Used for testing PositionalContainer without heavy dependencies
*/
class Dummy {
public:
Dummy() : m_Position{0.0f, 0.0f}, m_Id(next_id++) {}
Dummy(float x, float y) : m_Position{x, y}, m_Id(next_id++) {}
Dummy(WorldPos pos) : m_Position(pos), m_Id(next_id++) {}
WorldPos GetPosition() const { return m_Position; }
void SetPosition(WorldPos pos) { m_Position = pos; }
int GetId() const { return m_Id; }
private:
WorldPos m_Position;
int m_Id;
static int next_id;
};
int Dummy::next_id = 0;
/**
* @brief Helper function to generate random float in range [min, max]
*/
float random_float(std::mt19937& gen, float min, float max) {
std::uniform_real_distribution<float> dist(min, max);
return dist(gen);
}
// Example test function 2
void test_function_2() {
// TODO: Implement actual collision test
volatile int product = 1;
for (int i = 1; i < 100; ++i) {
product *= (i % 10 + 1);
/**
* @brief Compare two sets of weak_ptrs by comparing the IDs of the objects they point to
*/
bool compare_results(const std::vector<std::weak_ptr<Dummy>>& a,
const std::vector<std::weak_ptr<Dummy>>& b) {
std::set<int> ids_a, ids_b;
for (const auto& weak : a) {
if (auto shared = weak.lock()) {
ids_a.insert(shared->GetId());
}
}
for (const auto& weak : b) {
if (auto shared = weak.lock()) {
ids_b.insert(shared->GetId());
}
}
return ids_a == ids_b;
}
TEST(CollisionPerformance, CompareAlgorithms) {
TEST(CollisionPerformance, CompareContainers) {
std::cout << "\n=== Collision Performance Comparison ===\n" << std::endl;
const int iterations = 10000;
// Configuration
const int NUM_OBJECTS = 1000;
const int NUM_LOOKUPS = 100;
const float WORLD_SIZE = 1000.0f;
const float LOOKUP_RADIUS = 50.0f;
const size_t CHUNKS = 20;
benchmark_function("Algorithm 1 (test_function_1)", iterations, test_function_1);
benchmark_function("Algorithm 2 (test_function_2)", iterations, test_function_2);
// Random number generator
std::random_device rd;
std::mt19937 gen(rd());
// Create containers
PositionalContainer<Dummy> pos_cont{WorldSize{WORLD_SIZE, WORLD_SIZE}, CHUNKS};
SimpleContainer<Dummy> simp_cont;
// Create and add dummy objects with random positions
std::vector<std::shared_ptr<Dummy>> objects;
objects.reserve(NUM_OBJECTS);
std::cout << "Creating " << NUM_OBJECTS << " objects with random positions..." << std::endl;
for (int i = 0; i < NUM_OBJECTS; ++i) {
float x = random_float(gen, 10.0f, WORLD_SIZE - 10.0f);
float y = random_float(gen, 10.0f, WORLD_SIZE - 10.0f);
auto obj = std::make_shared<Dummy>(x, y);
objects.push_back(obj);
pos_cont.Add(obj);
simp_cont.Add(obj);
}
std::cout << "Objects created and added to containers." << std::endl;
// Generate random lookup positions
std::vector<WorldPos> lookup_positions;
lookup_positions.reserve(NUM_LOOKUPS);
for (int i = 0; i < NUM_LOOKUPS; ++i) {
float x = random_float(gen, 0.0f, WORLD_SIZE);
float y = random_float(gen, 0.0f, WORLD_SIZE);
lookup_positions.push_back(WorldPos{x, y});
}
// Benchmark SimpleContainer
double simple_total_time = 0.0;
std::vector<std::vector<std::weak_ptr<Dummy>>> simple_results;
simple_results.reserve(NUM_LOOKUPS);
std::cout << "\nBenchmarking SimpleContainer with " << NUM_LOOKUPS << " lookups..." << std::endl;
for (const auto& pos : lookup_positions) {
auto start = PerformanceTimer::Clock::now();
auto result = simp_cont.Get(pos, LOOKUP_RADIUS);
auto end = PerformanceTimer::Clock::now();
PerformanceTimer::Duration duration = end - start;
simple_total_time += duration.count();
simple_results.push_back(result);
}
double simple_avg_time = simple_total_time / NUM_LOOKUPS;
std::cout << std::fixed << std::setprecision(6)
<< "[BENCHMARK] SimpleContainer:\n"
<< " Total time: " << simple_total_time << " ms\n"
<< " Average time per lookup: " << simple_avg_time << " ms\n"
<< " Throughput: " << (NUM_LOOKUPS / (simple_total_time / 1000.0))
<< " lookups/sec" << std::endl;
// Benchmark PositionalContainer
double positional_total_time = 0.0;
std::vector<std::vector<std::weak_ptr<Dummy>>> positional_results;
positional_results.reserve(NUM_LOOKUPS);
std::cout << "\nBenchmarking PositionalContainer with " << NUM_LOOKUPS << " lookups..." << std::endl;
for (const auto& pos : lookup_positions) {
auto start = PerformanceTimer::Clock::now();
auto result = pos_cont.Get(pos, LOOKUP_RADIUS);
auto end = PerformanceTimer::Clock::now();
PerformanceTimer::Duration duration = end - start;
positional_total_time += duration.count();
positional_results.push_back(result);
}
double positional_avg_time = positional_total_time / NUM_LOOKUPS;
std::cout << std::fixed << std::setprecision(6)
<< "[BENCHMARK] PositionalContainer:\n"
<< " Total time: " << positional_total_time << " ms\n"
<< " Average time per lookup: " << positional_avg_time << " ms\n"
<< " Throughput: " << (NUM_LOOKUPS / (positional_total_time / 1000.0))
<< " lookups/sec" << std::endl;
// Verify results match
std::cout << "\nVerifying results correctness..." << std::endl;
int mismatches = 0;
for (size_t i = 0; i < NUM_LOOKUPS; ++i) {
if (!compare_results(simple_results[i], positional_results[i])) {
mismatches++;
std::cout << "Mismatch at lookup " << i
<< " (pos: " << lookup_positions[i] << ")" << std::endl;
}
}
if (mismatches == 0) {
std::cout << "✓ All " << NUM_LOOKUPS << " lookups produced identical results!" << std::endl;
} else {
std::cout << "✗ Found " << mismatches << " mismatches out of "
<< NUM_LOOKUPS << " lookups" << std::endl;
}
// Performance comparison
std::cout << "\n=== Performance Summary ===\n";
double speedup = simple_avg_time / positional_avg_time;
std::cout << std::fixed << std::setprecision(2)
<< "PositionalContainer is " << speedup << "x "
<< (speedup > 1.0 ? "faster" : "slower")
<< " than SimpleContainer" << std::endl;
std::cout << "\n======================================\n" << std::endl;
SUCCEED();
// Assertions
EXPECT_EQ(mismatches, 0) << "Results should match between containers";
EXPECT_GT(speedup, 1.0) << "PositionalContainer should be faster than SimpleContainer";
}

450
cpp/test/test.cpp
View File

@@ -7,6 +7,7 @@
#include "log.hpp"
#include "math.hpp"
#include "positional_container.hpp"
TEST(vec, DefaultConstruction) {
@@ -172,6 +173,86 @@ TEST(vec, Sub)
ASSERT_FLOAT_EQ(negative_result[2], -3.0f);
}
TEST(vec, ScalarAddition)
{
// Test operator+ with float vector and scalar
vec3 v1{1.0f, 2.0f, 3.0f};
vec3 result = v1 + 5.0f;
ASSERT_FLOAT_EQ(result[0], 6.0f);
ASSERT_FLOAT_EQ(result[1], 7.0f);
ASSERT_FLOAT_EQ(result[2], 8.0f);
// Test operator+ with integer vector and scalar
ivec3 iv1{10, 20, 30};
ivec3 iresult = iv1 + 5;
ASSERT_EQ(iresult[0], 15);
ASSERT_EQ(iresult[1], 25);
ASSERT_EQ(iresult[2], 35);
// Test that original vector is unchanged
ASSERT_FLOAT_EQ(v1[0], 1.0f);
ASSERT_FLOAT_EQ(v1[1], 2.0f);
ASSERT_FLOAT_EQ(v1[2], 3.0f);
// Test addition with negative scalar
vec3 v2{5.0f, 10.0f, 15.0f};
vec3 negative_result = v2 + (-3.0f);
ASSERT_FLOAT_EQ(negative_result[0], 2.0f);
ASSERT_FLOAT_EQ(negative_result[1], 7.0f);
ASSERT_FLOAT_EQ(negative_result[2], 12.0f);
// Test addition with zero
vec3 v3{1.0f, 2.0f, 3.0f};
vec3 zero_result = v3 + 0.0f;
ASSERT_FLOAT_EQ(zero_result[0], 1.0f);
ASSERT_FLOAT_EQ(zero_result[1], 2.0f);
ASSERT_FLOAT_EQ(zero_result[2], 3.0f);
}
TEST(vec, ScalarSubtraction)
{
// Test operator- with float vector and scalar
vec3 v1{10.0f, 15.0f, 20.0f};
vec3 result = v1 - 5.0f;
ASSERT_FLOAT_EQ(result[0], 5.0f);
ASSERT_FLOAT_EQ(result[1], 10.0f);
ASSERT_FLOAT_EQ(result[2], 15.0f);
// Test operator- with integer vector and scalar
ivec3 iv1{50, 40, 30};
ivec3 iresult = iv1 - 10;
ASSERT_EQ(iresult[0], 40);
ASSERT_EQ(iresult[1], 30);
ASSERT_EQ(iresult[2], 20);
// 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 subtraction with negative scalar (equivalent to addition)
vec3 v2{5.0f, 10.0f, 15.0f};
vec3 negative_result = v2 - (-3.0f);
ASSERT_FLOAT_EQ(negative_result[0], 8.0f);
ASSERT_FLOAT_EQ(negative_result[1], 13.0f);
ASSERT_FLOAT_EQ(negative_result[2], 18.0f);
// Test subtraction resulting in negative values
vec3 v3{1.0f, 2.0f, 3.0f};
vec3 negative_vals_result = v3 - 5.0f;
ASSERT_FLOAT_EQ(negative_vals_result[0], -4.0f);
ASSERT_FLOAT_EQ(negative_vals_result[1], -3.0f);
ASSERT_FLOAT_EQ(negative_vals_result[2], -2.0f);
}
TEST(vec, ScalarMultiplication)
{
// Test scalar * vector with float vectors
@@ -752,6 +833,375 @@ TEST(Matrix, ChainedOperations) {
ASSERT_FLOAT_EQ(m3[0][0], 2.0f);
}
// Helper class for SimpleContainer tests
class TestEntity {
public:
TestEntity() : m_Position(0.0f, 0.0f) {}
TestEntity(float x, float y) : m_Position(x, y) {}
TestEntity(WorldPos pos) : m_Position(pos) {}
WorldPos GetPosition() const { return m_Position; }
void SetPosition(WorldPos pos) { m_Position = pos; }
private:
WorldPos m_Position;
};
TEST(SimpleContainer, DefaultConstruction) {
// Test that SimpleContainer can be default constructed
SimpleContainer<TestEntity> container;
SUCCEED();
}
TEST(SimpleContainer, AddSingleItem) {
// Test adding a single item
SimpleContainer<TestEntity> container;
auto entity = std::make_shared<TestEntity>(5.0f, 10.0f);
container.Add(entity);
// Verify by getting items near the position
auto results = container.Get(WorldPos(5.0f, 10.0f), 1.0f);
ASSERT_EQ(results.size(), 1);
}
TEST(SimpleContainer, AddMultipleItems) {
// Test adding multiple items
SimpleContainer<TestEntity> container;
container.Add(std::make_shared<TestEntity>(0.0f, 0.0f));
container.Add(std::make_shared<TestEntity>(10.0f, 10.0f));
container.Add(std::make_shared<TestEntity>(20.0f, 20.0f));
// Verify by getting items near a position
auto results = container.Get(WorldPos(10.0f, 10.0f), 5.0f);
ASSERT_GE(results.size(), 1);
}
TEST(SimpleContainer, GetItemsInRadius) {
// Test getting items within a radius
SimpleContainer<TestEntity> container;
// Add items in a known pattern
container.Add(std::make_shared<TestEntity>(0.0f, 0.0f)); // At origin
container.Add(std::make_shared<TestEntity>(1.0f, 0.0f)); // 1 unit away
container.Add(std::make_shared<TestEntity>(0.0f, 1.0f)); // 1 unit away
container.Add(std::make_shared<TestEntity>(10.0f, 10.0f)); // Far away
// Get items within 2.0 units of origin
auto results = container.Get(WorldPos(0.0f, 0.0f), 2.0f);
// Should find the 3 nearby items (if Get is working correctly)
// Note: This depends on the actual implementation of Get
ASSERT_GE(results.size(), 0);
}
TEST(SimpleContainer, GetItemsEmptyContainer) {
// Test getting items from empty container
SimpleContainer<TestEntity> container;
auto results = container.Get(WorldPos(0.0f, 0.0f), 10.0f);
ASSERT_EQ(results.size(), 0);
}
TEST(SimpleContainer, WeakPtrValidAfterGet) {
// Test that weak_ptr returned from Get can be locked
SimpleContainer<TestEntity> container;
container.Add(std::make_shared<TestEntity>(5.0f, 5.0f));
auto results = container.Get(WorldPos(5.0f, 5.0f), 10.0f);
if (!results.empty()) {
auto locked = results[0].lock();
ASSERT_NE(locked, nullptr);
// Verify the position
WorldPos pos = locked->GetPosition();
ASSERT_FLOAT_EQ(pos.x(), 5.0f);
ASSERT_FLOAT_EQ(pos.y(), 5.0f);
}
}
TEST(SimpleContainer, UpdateAll) {
// Test that UpdateAll properly updates item positions
// For SimpleContainer, Update is a no-op but Get should still find moved items
SimpleContainer<TestEntity> container;
auto item1 = std::make_shared<TestEntity>(10.0f, 10.0f);
auto item2 = std::make_shared<TestEntity>(20.0f, 20.0f);
container.Add(item1);
container.Add(item2);
// Verify items exist at original positions
auto results_old1 = container.Get(WorldPos(10.0f, 10.0f), 1.0f);
auto results_old2 = container.Get(WorldPos(20.0f, 20.0f), 1.0f);
ASSERT_GE(results_old1.size(), 1);
ASSERT_GE(results_old2.size(), 1);
// Change positions
item1->SetPosition(WorldPos(50.0f, 50.0f));
item2->SetPosition(WorldPos(60.0f, 60.0f));
// Call UpdateAll
container.UpdateAll();
// For SimpleContainer, items should still be found at new positions
// (since Get checks actual item positions, not cached locations)
auto results_new1 = container.Get(WorldPos(50.0f, 50.0f), 1.0f);
auto results_new2 = container.Get(WorldPos(60.0f, 60.0f), 1.0f);
ASSERT_GE(results_new1.size(), 1);
ASSERT_GE(results_new2.size(), 1);
// Items should NOT be found at old positions anymore
auto results_old_check1 = container.Get(WorldPos(10.0f, 10.0f), 1.0f);
auto results_old_check2 = container.Get(WorldPos(20.0f, 20.0f), 1.0f);
ASSERT_EQ(results_old_check1.size(), 0);
ASSERT_EQ(results_old_check2.size(), 0);
}
TEST(SimpleContainer, Update) {
// Test that Update properly handles a single item position change
SimpleContainer<TestEntity> container;
auto item = std::make_shared<TestEntity>(15.0f, 15.0f);
container.Add(item);
// Verify item exists at original position
auto results_old = container.Get(WorldPos(15.0f, 15.0f), 1.0f);
ASSERT_GE(results_old.size(), 1);
// Change position
item->SetPosition(WorldPos(75.0f, 75.0f));
// Call Update
container.Update(item);
// Item should be found at new position
auto results_new = container.Get(WorldPos(75.0f, 75.0f), 1.0f);
ASSERT_GE(results_new.size(), 1);
// Item should NOT be found at old position
auto results_old_check = container.Get(WorldPos(15.0f, 15.0f), 1.0f);
ASSERT_EQ(results_old_check.size(), 0);
}
TEST(SimpleContainer, AddItemsWithSamePosition) {
// Test adding multiple items at the same position
SimpleContainer<TestEntity> container;
container.Add(std::make_shared<TestEntity>(5.0f, 5.0f));
container.Add(std::make_shared<TestEntity>(5.0f, 5.0f));
container.Add(std::make_shared<TestEntity>(5.0f, 5.0f));
auto results = container.Get(WorldPos(5.0f, 5.0f), 1.0f);
ASSERT_EQ(results.size(), 3);
}
TEST(PositionalContainer, DefaultConstruction) {
// Test that PositionalContainer can be constructed with size and chunks
WorldSize size(100.0f, 100.0f);
size_t chunks = 10;
PositionalContainer<TestEntity> container(size, chunks);
SUCCEED();
}
TEST(PositionalContainer, AddSingleItem) {
// Test adding a single item
WorldSize size(100.0f, 100.0f);
PositionalContainer<TestEntity> container(size, 10);
auto entity = std::make_shared<TestEntity>(5.0f, 10.0f);
container.Add(entity);
// Verify by getting items near the position
auto results = container.Get(WorldPos(5.0f, 10.0f), 1.0f);
ASSERT_GE(results.size(), 1);
}
TEST(PositionalContainer, AddMultipleItems) {
// Test adding multiple items
WorldSize size(100.0f, 100.0f);
PositionalContainer<TestEntity> container(size, 10);
container.Add(std::make_shared<TestEntity>(10.0f, 10.0f));
container.Add(std::make_shared<TestEntity>(20.0f, 20.0f));
container.Add(std::make_shared<TestEntity>(30.0f, 30.0f));
// Verify by getting items near a position
auto results = container.Get(WorldPos(20.0f, 20.0f), 5.0f);
ASSERT_GE(results.size(), 1);
}
TEST(PositionalContainer, GetItemsInRadius) {
// Test getting items within a radius
WorldSize size(100.0f, 100.0f);
PositionalContainer<TestEntity> container(size, 10);
// Add items in a known pattern
container.Add(std::make_shared<TestEntity>(50.0f, 50.0f)); // At center
container.Add(std::make_shared<TestEntity>(51.0f, 50.0f)); // 1 unit away
container.Add(std::make_shared<TestEntity>(50.0f, 51.0f)); // 1 unit away
container.Add(std::make_shared<TestEntity>(90.0f, 90.0f)); // Far away
// Get items within 2.0 units of center position
auto results = container.Get(WorldPos(50.0f, 50.0f), 2.0f);
// Should find the 3 nearby items
ASSERT_GE(results.size(), 0);
}
TEST(PositionalContainer, GetItemsEmptyContainer) {
// Test getting items from empty container
WorldSize size(100.0f, 100.0f);
PositionalContainer<TestEntity> container(size, 10);
auto results = container.Get(WorldPos(50.0f, 50.0f), 10.0f);
ASSERT_EQ(results.size(), 0);
}
TEST(PositionalContainer, WeakPtrValidAfterGet) {
// Test that weak_ptr returned from Get can be locked
WorldSize size(100.0f, 100.0f);
PositionalContainer<TestEntity> container(size, 10);
container.Add(std::make_shared<TestEntity>(50.0f, 50.0f));
auto results = container.Get(WorldPos(50.0f, 50.0f), 10.0f);
if (!results.empty()) {
auto locked = results[0].lock();
ASSERT_NE(locked, nullptr);
// Verify the position
WorldPos pos = locked->GetPosition();
ASSERT_FLOAT_EQ(pos.x(), 50.0f);
ASSERT_FLOAT_EQ(pos.y(), 50.0f);
}
}
TEST(PositionalContainer, UpdateAll) {
// Test that UpdateAll properly updates spatial index after position changes
WorldSize size(100.0f, 100.0f);
PositionalContainer<TestEntity> container(size, 10);
auto item1 = std::make_shared<TestEntity>(15.0f, 15.0f);
auto item2 = std::make_shared<TestEntity>(25.0f, 25.0f);
container.Add(item1);
container.Add(item2);
// Verify items exist at original positions
auto results_old1 = container.Get(WorldPos(15.0f, 15.0f), 2.0f);
auto results_old2 = container.Get(WorldPos(25.0f, 25.0f), 2.0f);
ASSERT_GE(results_old1.size(), 1);
ASSERT_GE(results_old2.size(), 1);
// Change positions to different grid chunks
item1->SetPosition(WorldPos(65.0f, 65.0f));
item2->SetPosition(WorldPos(75.0f, 75.0f));
// Call UpdateAll to refresh spatial index
container.UpdateAll();
// Items should be found at new positions
auto results_new1 = container.Get(WorldPos(65.0f, 65.0f), 2.0f);
auto results_new2 = container.Get(WorldPos(75.0f, 75.0f), 2.0f);
ASSERT_GE(results_new1.size(), 1);
ASSERT_GE(results_new2.size(), 1);
// Items should NOT be found at old positions anymore
auto results_old_check1 = container.Get(WorldPos(15.0f, 15.0f), 2.0f);
auto results_old_check2 = container.Get(WorldPos(25.0f, 25.0f), 2.0f);
ASSERT_EQ(results_old_check1.size(), 0);
ASSERT_EQ(results_old_check2.size(), 0);
}
TEST(PositionalContainer, Update) {
// Test that Update properly updates spatial index for a single item
WorldSize size(100.0f, 100.0f);
PositionalContainer<TestEntity> container(size, 10);
auto item = std::make_shared<TestEntity>(20.0f, 20.0f);
container.Add(item);
// Verify item exists at original position
auto results_old = container.Get(WorldPos(20.0f, 20.0f), 2.0f);
ASSERT_GE(results_old.size(), 1);
// Change position to different grid chunk
item->SetPosition(WorldPos(80.0f, 80.0f));
// Call Update to refresh spatial index
container.Update(item);
// Item should be found at new position
auto results_new = container.Get(WorldPos(80.0f, 80.0f), 2.0f);
ASSERT_GE(results_new.size(), 1);
// Item should NOT be found at old position
auto results_old_check = container.Get(WorldPos(20.0f, 20.0f), 2.0f);
ASSERT_EQ(results_old_check.size(), 0);
}
TEST(PositionalContainer, AddItemsWithSamePosition) {
// Test adding multiple items at the same position
WorldSize size(100.0f, 100.0f);
PositionalContainer<TestEntity> container(size, 10);
container.Add(std::make_shared<TestEntity>(50.0f, 50.0f));
container.Add(std::make_shared<TestEntity>(50.0f, 50.0f));
container.Add(std::make_shared<TestEntity>(50.0f, 50.0f));
auto results = container.Get(WorldPos(50.0f, 50.0f), 1.0f);
ASSERT_GE(results.size(), 0);
}
TEST(PositionalContainer, AddOutOfBounds) {
// Test adding items outside the grid bounds
WorldSize size(100.0f, 100.0f);
PositionalContainer<TestEntity> container(size, 10);
// Try to add items outside bounds
auto result1 = container.Add(std::make_shared<TestEntity>(-5.0f, 50.0f));
auto result2 = container.Add(std::make_shared<TestEntity>(105.0f, 50.0f));
auto result3 = container.Add(std::make_shared<TestEntity>(50.0f, -5.0f));
auto result4 = container.Add(std::make_shared<TestEntity>(50.0f, 105.0f));
// All should return false
ASSERT_FALSE(result1);
ASSERT_FALSE(result2);
ASSERT_FALSE(result3);
ASSERT_FALSE(result4);
}
TEST(PositionalContainer, GetOutOfBounds) {
// Test getting items with center or radius extending out of bounds
WorldSize size(100.0f, 100.0f);
PositionalContainer<TestEntity> container(size, 10);
container.Add(std::make_shared<TestEntity>(50.0f, 50.0f));
// Query that extends out of bounds should return empty
auto results = container.Get(WorldPos(95.0f, 95.0f), 10.0f);
ASSERT_EQ(results.size(), 0);
}
TEST(PositionalContainer, ItemsInDifferentChunks) {
// Test that items in different grid chunks can be retrieved correctly
WorldSize size(100.0f, 100.0f);
PositionalContainer<TestEntity> container(size, 10);
// Add items in different chunks (grid is 10x10, so each chunk is 10x10 units)
container.Add(std::make_shared<TestEntity>(15.0f, 15.0f)); // Chunk (1,1)
container.Add(std::make_shared<TestEntity>(25.0f, 25.0f)); // Chunk (2,2)
container.Add(std::make_shared<TestEntity>(75.0f, 75.0f)); // Chunk (7,7)
// Query in chunk (1,1)
auto results1 = container.Get(WorldPos(15.0f, 15.0f), 3.0f);
ASSERT_GE(results1.size(), 1);
// Query in chunk (7,7)
auto results2 = container.Get(WorldPos(75.0f, 75.0f), 3.0f);
ASSERT_GE(results2.size(), 1);
}
int main(int argc, char **argv) {
::testing::InitGoogleTest(&argc, argv);
return RUN_ALL_TESTS();

1
docs/diagrams/class_diagram.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 406 KiB

1
docs/diagrams/include_diagram.svg Normal file
View File

File diff suppressed because one or more lines are too long
Side by Side

After

Width:  |  Height:  |  Size: 93 KiB

9
scripts/pre-commit.sample Normal file
View File

@@ -0,0 +1,9 @@
#!/bin/sh
# Copy this file to .git/hooks
# Run clang-format before commiting
files=$(git diff --cached --name-only --diff-filter=ACM | grep -E '\.(cpp|hpp)$')
[ -z "$files" ] && exit 0
clang-format -i $files
git add $files