BoardManager Class Reference

#include <BoardManager.h>

Inheritance diagram for BoardManager:

Collaboration diagram for BoardManager:

Public Member Functions
	BoardManager (flecs::world ecs, std::weak_ptr< NetworkManager > network_manager, std::shared_ptr< IdentityManager > identity_manager, std::shared_ptr< DirectoryWindow > map_directory, std::shared_ptr< DirectoryWindow > marker_directory)
	~BoardManager ()
void	renderBoard (VertexArray &va, IndexBuffer &ib, Shader &shader, Shader &grid_shader, Renderer &renderer)
void	renderToolbar (const ImVec2 &window_position)
void	resetCamera ()
flecs::entity	createMarker (const std::string &imageFilePath, GLuint textureId, glm::vec2 position, glm::vec2 size)
void	deleteMarker (flecs::entity markerEntity)
void	handleMarkerDragging (glm::vec2 mousePos)
bool	isMouseOverMarker (glm::vec2 mousePos)
bool	canMoveMarker (const MarkerComponent *mc, flecs::entity markerEnt) const
glm::vec2	computeMarkerDrawSize_ARFit (const TextureComponent &tex, float basePx, float scale)
flecs::entity	createFogOfWar (glm::vec2 startPos, glm::vec2 size)
void	deleteFogOfWar (flecs::entity fogEntity)
void	handleFogCreation (glm::vec2 end_world_position)
void	panBoard (glm::vec2 currentMousePos)
Tool	getCurrentTool () const
void	setCurrentTool (Tool newTool)
bool	isBoardActive ()
flecs::entity	createBoard (std::string board_name, std::string map_image_path, GLuint texture_id, glm::vec2 size)
void	closeBoard ()
void	setActiveBoard (flecs::entity board_entity)
bool	isEditWindowOpen () const
void	renderEditWindow ()
void	renderCameraWindow ()
void	startMouseDrag (glm::vec2 mousePos, bool draggingMarker)
void	endMouseDrag ()
glm::vec2	getMouseStartPosition () const
bool	isPanning ()
bool	isDraggingMarker (bool local_drag_only=true)
flecs::entity	getEntityAtMousePosition (glm::vec2 mouse_position)
flecs::entity	findBoardById (uint64_t boardId)
bool	shouldSendMarkerMove (uint64_t markerId) const
uint64_t	generateUniqueId ()
flecs::entity	findEntityById (uint64_t target_id)
glm::vec2	snapToGrid (glm::vec2 raw_world_pos)
void	renderGridWindow ()
void	sendGameState ()
void	sendEntityUpdate (flecs::entity entity)
flecs::entity	getActiveBoard () const
void	loadActiveBoard (const std::string &filePath)
void	saveActiveBoard (const std::string &filePath)
void	saveActiveBoard (std::filesystem::path &filePath)
bool	isCreatingFog () const
bool	getShowEditWindow () const
void	setShowEditWindow (bool show, flecs::entity edit_entity=flecs::entity())
BoardImageData	LoadTextureFromMemory (const unsigned char *bytes, size_t sizeBytes)
void	killIfMouseUp (bool isMouseDown)
void	resnapAllMarkersToNearest (const Grid &grid)
void	onUsernameChanged (const std::string &uniqueId, const std::string &newUsername)

Public Attributes
std::string	board_name
std::shared_ptr< DirectoryWindow >	map_directory
std::shared_ptr< DirectoryWindow >	marker_directory
Camera	camera

Private Attributes
bool	showEditWindow = false
bool	showGridSettings = false
bool	showCameraSettings = false
float	markerBasePx = 50.0f
flecs::entity	edit_window_entity = flecs::entity()
std::weak_ptr< NetworkManager >	network_manager
std::shared_ptr< IdentityManager >	identity_manager
glm::vec2	mouse_start_screen_pos
glm::vec2	mouse_start_world_pos
glm::vec2	mouse_current_world_pos
flecs::world	ecs
flecs::entity	active_board = flecs::entity()
flecs::entity	grid_entity = flecs::entity()
bool	is_creating_fog = false
Tool	currentTool
Tool	previousTool

Detailed Description

Definition at line 168 of file BoardManager.h.

Constructor & Destructor Documentation

BoardManager()

BoardManager::BoardManager	(	flecs::world	ecs,
		std::weak_ptr< NetworkManager >	network_manager,
		std::shared_ptr< IdentityManager >	identity_manager,
		std::shared_ptr< DirectoryWindow >	map_directory,
		std::shared_ptr< DirectoryWindow >	marker_directory )

Definition at line 35 of file BoardManager.cpp.

                                                                                                                                                                                                                                      :
    ecs(ecs), camera(), identity_manager(identity_manager), currentTool(Tool::MOVE), mouse_start_screen_pos({0, 0}), mouse_start_world_pos({0, 0}), mouse_current_world_pos({0, 0}), marker_directory(marker_directory), map_directory(map_directory), network_manager(network_manager)
{
 
    std::filesystem::path map_path = std::filesystem::path(map_directory->directoryPath);
    std::filesystem::path base_path = map_path.parent_path();
    std::filesystem::path marker_directory_path = base_path / "Markers";
 
    marker_directory->directoryName = "MarkerDiretory";
    marker_directory->directoryPath = marker_directory_path.string();
    marker_directory->startMonitoring();
    marker_directory->generateTextureIDs();
}

~BoardManager()

BoardManager::~BoardManager

(

)

Definition at line 49 of file BoardManager.cpp.

{
}

Member Function Documentation

canMoveMarker()

bool BoardManager::canMoveMarker	(	const MarkerComponent *	mc,
		flecs::entity	markerEnt ) const

Definition at line 710 of file BoardManager.cpp.

{
    if (!mc || !markerEnt.is_valid())
        return false;
 
    auto nm = network_manager.lock();
    if (!nm)
        return false;
 
    // Disallow if being dragged by anyone
    if (markerEnt.has<Identifier>())
    {
        const auto mid = markerEnt.get<Identifier>()->id;
        if (nm->isMarkerBeingDragged(mid))
            return false;
    }
 
    const auto role = nm->getPeerRole();
    if (role == Role::GAMEMASTER)
        return true;
 
    if (mc->locked)
        return false;
 
    if (mc->allowAllPlayersMove)
        return true;
 
    const std::string unique_id = identity_manager->myUniqueId();
    if (!mc->ownerUniqueId.empty() && mc->ownerUniqueId == unique_id)
        return true;
 
    //if (auto vis = markerEnt.get<Visibility>(); vis && !vis->isVisible)
    //{
    //    // Compute marker AABB
    //    auto pos = markerEnt.get<Position>();
    //    auto siz = markerEnt.get<Size>();
    //    if (pos && siz)
    //    {
    //        const float mx1 = pos->x - siz->width * 0.5f;
    //        const float mx2 = pos->x + siz->width * 0.5f;
    //        const float my1 = pos->y - siz->height * 0.5f;
    //        const float my2 = pos->y + siz->height * 0.5f;
 
    //        bool covered = false;
    //        active_board.children([&](flecs::entity child)
    //                              {
    //            if (!child.has<FogOfWar>()) return;
    //            if (auto fvis = child.get<Visibility>(); !fvis || !fvis->isVisible) return; // fog must be visible
 
    //            auto fpos = child.get<Position>();
    //            auto fsz  = child.get<Size>();
    //            if (!fpos || !fsz) return;
 
    //            const float fx1 = fpos->x - fsz->width * 0.5f;
    //            const float fx2 = fpos->x + fsz->width * 0.5f;
    //            const float fy1 = fpos->y - fsz->height * 0.5f;
    //            const float fy2 = fpos->y + fsz->height * 0.5f;
 
    //            // full containment
    //            if (mx1 >= fx1 && mx2 <= fx2 && my1 >= fy1 && my2 <= fy2)
    //                covered = true; });
    //        if (covered)
    //            return true;
    //    }
    //}
 
    return false;
}

Here is the caller graph for this function:

closeBoard()

void BoardManager::closeBoard

(

)

Definition at line 58 of file BoardManager.cpp.

{
    active_board = flecs::entity();
}

computeMarkerDrawSize_ARFit()

glm::vec2 BoardManager::computeMarkerDrawSize_ARFit	(	const TextureComponent &	tex,
		float	basePx,
		float	scale )

Definition at line 394 of file BoardManager.cpp.

{
    const glm::vec2 texPx = tex.size; // original pixels stored in your TextureComponent
    if (texPx.x <= 0.0f || texPx.y <= 0.0f)
    {
        const float box = basePx * scale;
        return {box, box};
    }
    const float box = basePx * scale;
    const float s = std::min(box / texPx.x, box / texPx.y);
    return texPx * s; // scaled to fit inside the box, AR preserved
}

Here is the caller graph for this function:

createBoard()

flecs::entity BoardManager::createBoard	(	std::string	board_name,
		std::string	map_image_path,
		GLuint	texture_id,
		glm::vec2	size )

Definition at line 63 of file BoardManager.cpp.

{
    auto board = ecs.entity()
                     .set(Identifier{generateUniqueId()})
                     .set(Board{board_name})
                     .set(Panning{false})
                     .set(Grid{{0, 0}, 50.0f, false, false, false, 0.5f})
                     .set(TextureComponent{texture_id, map_image_path, size})
                     .set(Size{size.x, size.y});
    setActiveBoard(board);
    return board;
}

Here is the call graph for this function:

createFogOfWar()

flecs::entity BoardManager::createFogOfWar	(	glm::vec2	startPos,
		glm::vec2	size )

Definition at line 1127 of file BoardManager.cpp.

{
    auto nm = network_manager.lock();
    if (!nm)
        throw std::exception("[BoardManager] Network Manager expired!!");
 
    auto fog = ecs.entity()
                   .set(Identifier{generateUniqueId()})
                   .set(Position{startPos.x, startPos.y})
                   .set(Size{size.x, size.y})
                   .set(Visibility{true});
 
    fog.add<FogOfWar>();
    fog.add(flecs::ChildOf, active_board);
 
    auto board_id = active_board.get<Identifier>()->id;
    nm->broadcastFog(board_id, fog);
 
    return fog;
}

Here is the call graph for this function:

Here is the caller graph for this function:

createMarker()

flecs::entity BoardManager::createMarker	(	const std::string &	imageFilePath,
		GLuint	textureId,
		glm::vec2	position,
		glm::vec2	size )

Definition at line 541 of file BoardManager.cpp.

{
    auto nm = network_manager.lock();
    if (!nm)
        throw std::exception("[BoardManager] Network Manager expired!!");
 
    auto markerScale = marker_directory->getGlobalSizeSlider();
    auto texture_marker = TextureComponent{textureId, imageFilePath, size};
    const glm::vec2 drawSz = computeMarkerDrawSize_ARFit(texture_marker, markerBasePx, markerScale);
 
    flecs::entity marker = ecs.entity()
                               .set(Identifier{generateUniqueId()})
                               .set(Position{position.x, position.y}) //World Position
                               .set(Size{drawSz.x, drawSz.y})
                               .set(texture_marker)
                               .set(Visibility{true})
                               .set(MarkerComponent{"", "", false, false})
                               .set(Moving{false});
 
    marker.add(flecs::ChildOf, active_board);
 
    auto board_id = active_board.get<Identifier>()->id;
    nm->broadcastMarker(board_id, marker);
    return marker;
}

Here is the call graph for this function:

deleteFogOfWar()

void BoardManager::deleteFogOfWar

(

flecs::entity

fogEntity

)

Definition at line 1122 of file BoardManager.cpp.

{
    fogEntity.destruct();
}

deleteMarker()

void BoardManager::deleteMarker

(

flecs::entity

markerEntity

)

Definition at line 567 of file BoardManager.cpp.

{
    markerEntity.destruct();
}

endMouseDrag()

void BoardManager::endMouseDrag

(

)

Definition at line 975 of file BoardManager.cpp.

{
    if (!active_board.is_valid())
        return;
 
    active_board.set<Panning>({false});
    auto nm = network_manager.lock();
    if (!nm)
        throw std::exception("[BoardManager] Network Manager expired!!");
 
    const Grid* grid = active_board.get<Grid>();
    const bool canSnap = (grid && grid->snap_to_grid && grid->cell_size > 0.0f);
 
    ecs.defer_begin();
    ecs.each([&](flecs::entity entity, const MarkerComponent& marker, Moving& moving, Position& pos)
             {
        if (!entity.has(flecs::ChildOf, active_board)) return;
        if (!moving.isDragging) return;
 
        const auto mid = entity.get<Identifier>()->id;
        if (!nm->amIDragging(mid))
            return; // skip markers dragged by others
 
        if (canSnap)
        {
            glm::vec2 snapped = snapToSquareCenter(glm::vec2(pos.x, pos.y), grid->offset, grid->cell_size);
            pos.x = snapped.x;
            pos.y = snapped.y;
        }
 
        moving.isDragging = false;
  
        const auto bid = active_board.get<Identifier>()->id;
 
        nm->markDraggingLocal(mid, false);      // <- local registry
        nm->broadcastMarkerMoveState(bid, entity); // end (isDragging=false + final pos)broadcastMarkerUpdate(bid, entity); // <- final pos + mov=false
        nm->forceCloseDrag(mid); });
 
    ecs.defer_end();
    is_creating_fog = false;
}

Here is the call graph for this function:

findBoardById()

flecs::entity BoardManager::findBoardById

(

uint64_t

boardId

)

Definition at line 1763 of file BoardManager.cpp.

{
    flecs::entity result;
    ecs.each([&](flecs::entity e, const Board& b, const Identifier& id)
             {
    Logger::instance().log("localtunnel", Logger::Level::Info, "Board Name:  " + b.board_name);
        if (e.is_valid() && id.id == boardId) {
            result = e;
            Logger::instance().log("localtunnel", Logger::Level::Info, "Found Board By ID!!");
        } });
 
    return result; // will be invalid if not found
}

Here is the call graph for this function:

findEntityById()

flecs::entity BoardManager::findEntityById

(

uint64_t

target_id

)

Definition at line 665 of file BoardManager.cpp.

{
    flecs::entity result;
 
    // Iterate over all entities with Identifier component
    ecs.each<Identifier>([&](flecs::entity e, Identifier& identifier)
                         {
        if (identifier.id == target_id) {
            result = e;  // Store matching entity
        } });
 
    return result; // Returns the found entity, or an empty entity if not found
}

generateUniqueId()

uint64_t BoardManager::generateUniqueId

(

)

Definition at line 585 of file BoardManager.cpp.

{
    // 64-bit Snowflake layout:
    // [ 42 bits timestamp(ms since 2020-01-01 UTC) ][ 10 bits node ][ 12 bits sequence ]
    static constexpr uint64_t TS_BITS = 42;
    static constexpr uint64_t NODE_BITS = 10;
    static constexpr uint64_t SEQ_BITS = 12;
 
    static constexpr uint64_t TS_MASK = (1ULL << TS_BITS) - 1;
    static constexpr uint64_t NODE_MASK = (1ULL << NODE_BITS) - 1;
    static constexpr uint64_t SEQ_MASK = (1ULL << SEQ_BITS) - 1;
 
    // Custom epoch: 2020-01-01T00:00:00Z in UNIX ms
    static constexpr int64_t EPOCH_MS = 1577836800000LL;
 
    // Derive a stable 10-bit node id for this process/machine (once).
    // Try COMPUTERNAME/HOSTNAME; fallback to random.
    static const uint16_t NODE_ID = []() -> uint16_t
    {
        std::string basis;
        if (const char* cn = std::getenv("COMPUTERNAME"); cn && *cn)
            basis = cn;
        else if (const char* hn = std::getenv("HOSTNAME"); hn && *hn)
            basis = hn;
        else
        {
            std::random_device rd;
            basis = std::to_string(rd());
        }
        uint64_t h = std::hash<std::string>{}(basis);
        // xor-fold a bit to mix high/low
        h ^= (h >> 33) ^ (h >> 17) ^ (h >> 9);
        return static_cast<uint16_t>(h) & NODE_MASK; // 10 bits
    }();
 
    // Per-process state
    static std::atomic<uint64_t> lastMs{0};
    static std::atomic<uint16_t> seq{0};
 
    // Current ms since custom epoch
    const auto nowEpoch = std::chrono::time_point_cast<std::chrono::milliseconds>(
                              std::chrono::system_clock::now())
                              .time_since_epoch()
                              .count();
    uint64_t nowMs = (nowEpoch >= EPOCH_MS) ? static_cast<uint64_t>(nowEpoch - EPOCH_MS) : 0ULL;
 
    uint64_t last = lastMs.load(std::memory_order_relaxed);
    if (nowMs == last)
    {
        // Same millisecond -> increment sequence (12 bits)
        uint16_t s = static_cast<uint16_t>(seq.fetch_add(1, std::memory_order_relaxed)) & SEQ_MASK;
        if (s == 0)
        {
            // Overflowed the 12-bit sequence; wait for the next millisecond
            do
            {
                std::this_thread::yield();
                const auto now2 = std::chrono::time_point_cast<std::chrono::milliseconds>(
                                      std::chrono::system_clock::now())
                                      .time_since_epoch()
                                      .count();
                nowMs = (now2 >= EPOCH_MS) ? static_cast<uint64_t>(now2 - EPOCH_MS) : 0ULL;
            } while (nowMs == last);
            lastMs.store(nowMs, std::memory_order_relaxed);
            seq.store(0, std::memory_order_relaxed);
            s = 0;
        }
        // Pack: (ts << (10+12)) | (node << 12) | seq
        return ((nowMs & TS_MASK) << (NODE_BITS + SEQ_BITS)) | ((static_cast<uint64_t>(NODE_ID) & NODE_MASK) << SEQ_BITS) | (static_cast<uint64_t>(s) & SEQ_MASK);
    }
    else
    {
        // New millisecond -> reset sequence
        lastMs.store(nowMs, std::memory_order_relaxed);
        seq.store(0, std::memory_order_relaxed);
        return ((nowMs & TS_MASK) << (NODE_BITS + SEQ_BITS)) | ((static_cast<uint64_t>(NODE_ID) & NODE_MASK) << SEQ_BITS) | 0ULL;
    }
}

Here is the caller graph for this function:

getActiveBoard()

flecs::entity BoardManager::getActiveBoard

(

)

const

Definition at line 1323 of file BoardManager.cpp.

{
    return active_board;
}

Here is the caller graph for this function:

getCurrentTool()

Tool BoardManager::getCurrentTool

(

)

const

Definition at line 1174 of file BoardManager.cpp.

{
    return currentTool;
}

getEntityAtMousePosition()

flecs::entity BoardManager::getEntityAtMousePosition

(

glm::vec2

mouse_position

)

Definition at line 1184 of file BoardManager.cpp.

{
 
    auto entity_at_mouse = flecs::entity();
    ecs.defer_begin();
    ecs.each([&](flecs::entity entity, const Position& entity_pos, const Size& entity_size)
             {
        const bool isMarker = entity.has<MarkerComponent>();
        if (isMarker) {
            glm::vec2 world_position = mouse_position;
        
            if (entity.has(flecs::ChildOf, active_board)) {
 
                bool withinXBounds = (world_position.x >= (entity_pos.x - entity_size.width / 2)) &&
                    (world_position.x <= (entity_pos.x + entity_size.width / 2));
 
                bool withinYBounds = (world_position.y >= (entity_pos.y - entity_size.height / 2)) &&
                    (world_position.y <= (entity_pos.y + entity_size.height / 2));
 
                if (withinXBounds && withinYBounds) {
                    entity_at_mouse = entity;
                }
            }
 
        } });
    ecs.defer_end();
 
    if (entity_at_mouse.is_valid())
        return entity_at_mouse;
 
    ecs.defer_begin();
    ecs.each([&](flecs::entity entity, const Position& entity_pos, const Size& entity_size)
             {
        
        glm::vec2 world_position = mouse_position;
        
        if (entity.has(flecs::ChildOf, active_board)) {
 
            bool withinXBounds = (world_position.x >= (entity_pos.x - entity_size.width / 2)) &&
                (world_position.x <= (entity_pos.x + entity_size.width / 2));
 
            bool withinYBounds = (world_position.y >= (entity_pos.y - entity_size.height / 2)) &&
                (world_position.y <= (entity_pos.y + entity_size.height / 2));
 
            if (withinXBounds && withinYBounds) {
                entity_at_mouse = entity;
            }
        } });
    ecs.defer_end();
    return entity_at_mouse;
}

Here is the caller graph for this function:

getMouseStartPosition()

glm::vec2 BoardManager::getMouseStartPosition

(

)

const

Definition at line 1102 of file BoardManager.cpp.

{
    return mouse_start_world_pos;
}

Here is the caller graph for this function:

getShowEditWindow()

bool BoardManager::getShowEditWindow ( ) const

inline

Definition at line 244 of file BoardManager.h.

    {
        return showEditWindow;
    };

handleFogCreation()

void BoardManager::handleFogCreation

(

glm::vec2

end_world_position

)

Definition at line 1148 of file BoardManager.cpp.

{
    glm::vec2 start_world_position = getMouseStartPosition();
 
    // Calculate size
    glm::vec2 size = end_world_position - start_world_position; //glm::abs(end_world_position - start_world_position);  // Make sure size is positive
    glm::vec2 corrected_start_position;
    if (size.x < 0)
    {
        corrected_start_position.x = end_world_position.x + glm::abs(size.x) / 2;
    }
    else
    {
        corrected_start_position.x = start_world_position.x + size.x / 2;
    }
    if (size.y < 0)
    {
        corrected_start_position.y = end_world_position.y + glm::abs(size.y) / 2;
    }
    else
    {
        corrected_start_position.y = start_world_position.y + size.y / 2;
    }
    createFogOfWar(corrected_start_position, glm::abs(size));
}

Here is the call graph for this function:

handleMarkerDragging()

void BoardManager::handleMarkerDragging

(

glm::vec2

mousePos

)

Definition at line 1017 of file BoardManager.cpp.

{
    auto nm = network_manager.lock();
    if (!nm)
        throw std::exception("[BoardManager] Network Manager expired!!");
 
    ecs.defer_begin();
    ecs.each([&](flecs::entity entity, const MarkerComponent& marker, Moving& moving, Position& position)
             {
        if (!entity.has(flecs::ChildOf, active_board)) return;
        if (!moving.isDragging) return;
 
        if (!entity.has<Identifier>())
            return;
        const auto mid = entity.get<Identifier>()->id;
 
        // Only advance locally if I am the drag owner (prevents flicker)
        if (!nm->amIDragging(mid))
            return;
 
        glm::vec2 delta = world_position - mouse_start_world_pos;
        position.x += delta.x;
        position.y += delta.y;
        mouse_start_world_pos = world_position;
 
        const auto id = entity.get<Identifier>()->id;
        if (shouldSendMarkerMove(id))
        {
            //Logger::instance().log("localtunnel", Logger::Level::Info, "broadcastMarkerMove!");
            nm->broadcastMarkerMove(active_board.get<Identifier>()->id, entity);
        } });
    ecs.defer_end();
}

Here is the call graph for this function:

isBoardActive()

bool BoardManager::isBoardActive

(

)

Definition at line 53 of file BoardManager.cpp.

{
    return active_board.is_valid();
}

isCreatingFog()

bool BoardManager::isCreatingFog ( ) const

inline

Definition at line 240 of file BoardManager.h.

    {
        return is_creating_fog;
    };

isDraggingMarker()

bool BoardManager::isDraggingMarker

(

bool

local_drag_only = true

)

Definition at line 1073 of file BoardManager.cpp.

{
    auto nm = network_manager.lock();
    if (!nm)
        return false;
 
    bool any = false;
 
    ecs.defer_begin();
    ecs.each([&](flecs::entity e, const MarkerComponent&, const Moving& mv, const Identifier& id)
             {
        if (any) return; // early out from further work in this lambda (flecs will still loop, but we do nothing)
        if (!e.has(flecs::ChildOf, active_board)) return;
        if (!mv.isDragging) return;
 
        if (local_drag_only)
        {
            if (nm->amIDragging(id.id))
                any = true; // found a local-owned drag
        }
        else
        {
            any = true;     // any drag at all
        } });
    ecs.defer_end();
 
    return any;
}

Here is the caller graph for this function:

isEditWindowOpen()

bool BoardManager::isEditWindowOpen

(

)

const

Definition at line 1328 of file BoardManager.cpp.

{
    return showEditWindow;
}

isMouseOverMarker()

bool BoardManager::isMouseOverMarker

(

glm::vec2

mousePos

)

Definition at line 886 of file BoardManager.cpp.

{
    bool hovered = false;
    ecs.defer_begin();
    ecs.each([&](flecs::entity entity, const MarkerComponent& marker_component, const Position& markerPos, const Size& markerSize, Moving& moving)
             {
 
        if (entity.has(flecs::ChildOf, active_board)) {
            bool withinXBounds = (world_position.x >= (markerPos.x - markerSize.width / 2)) &&
                (world_position.x <= (markerPos.x + markerSize.width / 2));
 
            bool withinYBounds = (world_position.y >= (markerPos.y - markerSize.height / 2)) &&
                (world_position.y <= (markerPos.y + markerSize.height / 2));
 
            if (!(withinXBounds && withinYBounds))
                return;
            if (!canMoveMarker(&marker_component, entity))
                return;
 
            //moving.isDragging = true;
            hovered = true;
            //if (auto nm = network_manager.lock())
            //{
            //    if (entity.has<Identifier>() && active_board.has<Identifier>())
            //    {
            //        const auto bid = active_board.get<Identifier>()->id;
            //        const auto mid = entity.get<Identifier>()->id;
 
            //        nm->markDraggingLocal(mid, true);       
            //        nm->broadcastMarkerMoveState(bid, entity); 
            //    }
            //}
        } });
    ecs.defer_end();
 
    return hovered;
}

isPanning()

bool BoardManager::isPanning

(

)

Definition at line 1067 of file BoardManager.cpp.

{
    const Panning* panning = active_board.get<Panning>();
    return panning->isPanning;
}

killIfMouseUp()

void BoardManager::killIfMouseUp

(

bool

isMouseDown

)

Definition at line 781 of file BoardManager.cpp.

{
    if (isMouseDown)
        return;
 
    // Ensure panning is off
    if (active_board.is_valid())
        active_board.set<Panning>({false});
 
    auto nm = network_manager.lock();
 
    // If some marker still locally dragging (UI glitch), force-end it now
    ecs.defer_begin();
    ecs.each([&](flecs::entity entity, MarkerComponent& mc, Moving& moving, Position& pos)
             {
        if (!entity.has(flecs::ChildOf, active_board))
            return;
        if (!moving.isDragging)
            return;
        const auto mid = entity.get<Identifier>()->id;
        if (!nm->amIDragging(mid))
            return; // skip markers dragged by others
 
        moving.isDragging = false;
 
        const auto bid = active_board.get<Identifier>()->id;
 
        nm->markDraggingLocal(mid, false);
        nm->broadcastMarkerMoveState(bid, entity); // end (final)
        nm->forceCloseDrag(mid); });
 
    ecs.defer_end();
}

loadActiveBoard()

void BoardManager::loadActiveBoard

(

const std::string &

filePath

)

Definition at line 1288 of file BoardManager.cpp.

{
    std::ifstream inFile(board_file_path, std::ios::binary);
    if (inFile)
    {
        std::vector<uint8_t> buffer((std::istreambuf_iterator<char>(inFile)), std::istreambuf_iterator<char>());
        inFile.close();
 
        size_t offset = 0;
        active_board = Serializer::deserializeBoardEntity(buffer, offset, ecs);
        auto texture = active_board.get_mut<TextureComponent>();
        auto map_image = map_directory->getImageByPath(texture->image_path);
        texture->textureID = map_image.textureID;
        texture->size = map_image.size;
 
        ecs.defer_begin();
        active_board.children([&](flecs::entity child)
                              {
            if (child.has<MarkerComponent>()) {
                auto child_texture = child.get_mut<TextureComponent>();
                auto marker_image = marker_directory->getImageByPath(child_texture->image_path);
                child_texture->textureID = marker_image.textureID;
                child_texture->size = marker_image.size;
            } });
        ecs.defer_end();
 
        setActiveBoard(active_board);
        std::cout << "Board loaded successfully from " << board_file_path << std::endl;
    }
    else
    {
        std::cerr << "Failed to load board from " << board_file_path << std::endl;
    }
}

Here is the call graph for this function:

LoadTextureFromMemory()

BoardImageData BoardManager::LoadTextureFromMemory	(	const unsigned char *	bytes,
		size_t	sizeBytes )

Definition at line 1777 of file BoardManager.cpp.

{
    if (!bytes || sizeBytes == 0)
    {
        std::cerr << "LoadTextureFromMemory: empty buffer\n";
        return BoardImageData{};
    }
 
    // stb_image: ensure vertical flip matches your expectations
    stbi_set_flip_vertically_on_load(0);
 
    int width = 0, height = 0, nrChannels = 0;
    uint8_t* data = stbi_load_from_memory(bytes, (int)sizeBytes, &width, &height, &nrChannels, 4);
    if (!data)
    {
        std::cerr << "LoadTextureFromMemory: decode failed\n";
        return BoardImageData{};
    }
 
    GLuint tex = 0;
    glGenTextures(1, &tex);
    glBindTexture(GL_TEXTURE_2D, tex);
 
    glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA8, width, height,
                 0, GL_RGBA, GL_UNSIGNED_BYTE, data);
 
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
    stbi_image_free(data);
    return BoardImageData(tex, glm::vec2(width, height), /*path*/ "");
}

onUsernameChanged()

void BoardManager::onUsernameChanged	(	const std::string &	uniqueId,
		const std::string &	newUsername )

Definition at line 1236 of file BoardManager.cpp.

{
    // Update all markers owned by uniqueId: only the DISPLAY name changes.
    ecs.each([&](flecs::entity e, MarkerComponent& mc)
             {
        // you will add/keep ownerUniqueId in MarkerComponent:
        // struct MarkerComponent {
        //   std::string ownerUniqueId;      // authoritative owner
        //   std::string ownerPeerUsername;  // purely visual
        //   bool allowAllPlayersMove = false;
        //   bool locked = false;
        // };
 
        if (mc.ownerUniqueId == uniqueId)
            mc.ownerPeerUsername = newUsername; });
 
    // If you draw any overlays/caches of names, invalidate them here (optional).
}

panBoard()

void BoardManager::panBoard

(

glm::vec2

currentMousePos

)

Definition at line 1107 of file BoardManager.cpp.

{
    glm::vec2 delta_screen = mouse_start_screen_pos - current_mouse_fbo_pos;
    float world_scale_factor = camera.getZoom();
    glm::vec2 delta_world = delta_screen / world_scale_factor;
    camera.pan(delta_world);
    mouse_start_screen_pos = current_mouse_fbo_pos;
}

Here is the call graph for this function:

renderBoard()

void BoardManager::renderBoard	(	VertexArray &	va,
		IndexBuffer &	ib,
		Shader &	shader,
		Shader &	grid_shader,
		Renderer &	renderer )

Definition at line 407 of file BoardManager.cpp.

{
    auto nm = network_manager.lock();
    if (!nm)
        throw std::exception("[BoardManager] Network Manager expired!!");
 
    const TextureComponent* texture = active_board.get<TextureComponent>();
    if (texture->textureID != 0)
    {
        const Board* board = active_board.get<Board>();
        const Grid* grid = active_board.get<Grid>();
        const Size* size = active_board.get<Size>();
 
        glm::mat4 viewMatrix = camera.getViewMatrix(); // Obtém a matriz de visualização da câmera (pan/zoom)
        glm::mat4 projection = camera.getProjectionMatrix();
        glm::mat4 board_model = glm::translate(glm::mat4(1.0f), glm::vec3(0.0f, 0.0f, 0.0f));
        board_model = glm::scale(board_model, glm::vec3(size->width, size->height, 1.0f));
 
        shader.Bind();
        shader.SetUniformMat4f("projection", projection);
        shader.SetUniformMat4f("view", viewMatrix);
        shader.SetUniformMat4f("model", board_model);
        shader.SetUniform1f("u_Alpha", 1.0f);
        shader.SetUniform1i("u_UseTexture", 1);
        shader.SetUniform1i("u_Texture", 0);
        shader.Unbind();
 
        GLCall(glActiveTexture(GL_TEXTURE0));
        GLCall(glBindTexture(GL_TEXTURE_2D, texture->textureID));
 
        renderer.Draw(va, ib, shader);
 
        if (grid)
        {
            if (grid->visible)
            {
                grid_shader.Bind();
                grid_shader.SetUniformMat4f("projection", projection);
                grid_shader.SetUniformMat4f("view", viewMatrix);
                grid_shader.SetUniformMat4f("model", board_model); // Grid model is the same as the board
                grid_shader.SetUniform1i("grid_type", grid->is_hex ? 1 : 0);
                grid_shader.SetUniform1f("cell_size", grid->cell_size);
                grid_shader.SetUniform2f("grid_offset", grid->offset.x, grid->offset.y);
                grid_shader.SetUniform1f("opacity", grid->opacity);
                grid_shader.Unbind();
 
                renderer.Draw(va, ib, grid_shader);
            }
        }
 
        ecs.defer_begin(); // Start deferring modifications
        active_board.children([&](flecs::entity child)
                              {
            if (child.has<MarkerComponent>()) {
                const TextureComponent* texture_marker = child.get<TextureComponent>();
                if (texture_marker->textureID != 0) {
                    const Position* position_marker = child.get<Position>();
                    const Visibility* visibility_marker = child.get<Visibility>();
                    const Size* size_marker = child.get<Size>();
 
                    glm::mat4 marker_model = glm::translate(glm::mat4(1.0f), glm::vec3(position_marker->x, position_marker->y, 0.0f));
                    marker_model = glm::scale(marker_model, glm::vec3(size_marker->width, size_marker->height, 1.0f));
 
                    //glm::mat4 mvp = projection * viewMatrix * marker_model; //Calculate Screen Position(Can use method to standize it, but alter to return the MVP
                    float alpha = 1.0f;
                    if (!visibility_marker->isVisible) {
                        if (nm->getPeerRole() == Role::GAMEMASTER)
                        {
                            alpha = 0.5f;
                        }
                        else {
                            alpha = 0.0f;
                        }
                    }
 
                    shader.Bind();
                    shader.SetUniformMat4f("projection", projection);
                    shader.SetUniformMat4f("view", viewMatrix);
                    shader.SetUniformMat4f("model", marker_model);
                    shader.SetUniform1f("u_Alpha", alpha);
                    shader.SetUniform1i("u_Texture", 0);
                    shader.SetUniform1i("u_UseTexture", 1);
                    shader.Unbind();
 
                    GLCall(glActiveTexture(GL_TEXTURE0));
                    GLCall(glBindTexture(GL_TEXTURE_2D, texture_marker->textureID));
 
                    renderer.Draw(va, ib, shader);
                }
            }
 
            if (child.has<FogOfWar>()) {
                const Position* position_marker = child.get<Position>();
                const Visibility* visibility_marker = child.get<Visibility>();
                const TextureComponent* texture_marker = child.get<TextureComponent>();
                const Size* size_marker = child.get<Size>();
 
                glm::mat4 fog_model = glm::translate(glm::mat4(1.0f), glm::vec3(position_marker->x, position_marker->y, 0.0f));
                fog_model = glm::scale(fog_model, glm::vec3(size_marker->width, size_marker->height, 1.0f));
 
                float alpha = 1.0f;
              
                if (!visibility_marker->isVisible) {
                    if (nm->getPeerRole() == Role::GAMEMASTER) {
                        alpha = 0.3f;
                    }
                    else
                    {
                        alpha = 0.0f;
                    }
                }
                else
                {
                    if (nm->getPeerRole() == Role::GAMEMASTER)
                    {
                        alpha = 0.6f;
                    }
                }
 
                shader.Bind();
                shader.SetUniformMat4f("projection", projection);
                shader.SetUniformMat4f("view", viewMatrix);
                shader.SetUniformMat4f("model", fog_model);
                shader.SetUniform1f("u_Alpha", alpha);
                shader.SetUniform1i("u_UseTexture", 0);
                shader.Unbind();
 
                renderer.Draw(va, ib, shader);
 
            } });
        ecs.defer_end();
    }
}

Here is the call graph for this function:

renderCameraWindow()

void BoardManager::renderCameraWindow

(

)

Definition at line 1626 of file BoardManager.cpp.

{
    // Check if the window should be shown
    if (!showCameraSettings)
    {
        return;
    }
 
    // Begin the ImGui window
    auto mouse_pos = ImGui::GetMousePos();
    ImGui::SetNextWindowPos(ImVec2(mouse_pos.x, mouse_pos.y + ImGui::GetFrameHeightWithSpacing()), ImGuiCond_Appearing);
    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.0f, 0.1f, 0.2f, 1.0f)); // Set the background color (RGBA)
    ImGui::Begin("Camera", &showCameraSettings, ImGuiWindowFlags_AlwaysAutoResize);
    ImGui::PopStyleColor();
    auto zoom = camera.getZoom();
 
    ImGui::Text("Zoom Buttons");
    if (ImGui::Button("-"))
    {
        zoom = zoom - 0.01f;
    }
    ImGui::SameLine();
    if (ImGui::Button("+"))
    {
        zoom = zoom + 0.01f;
    }
 
    ImGui::Separator();
    ImGui::SliderFloat("Zoom Slider", &zoom, 0.1f, 10.0f);
    camera.setZoom(zoom);
    ImGui::Separator();
    if (ImGui::Button("Reset Camera"))
    {
        resetCamera();
    }
 
    ImGui::End();
}

Here is the call graph for this function:

Here is the caller graph for this function:

renderEditWindow()

void BoardManager::renderEditWindow

(

)

Definition at line 1333 of file BoardManager.cpp.

{
    bool is_hovered = false;
    // Get the current mouse position to set the window position
    ImVec2 mousePos = ImGui::GetMousePos();
    ImGui::SetNextWindowPos(mousePos, ImGuiCond_Appearing);
    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.2f, 0.3f, 0.4f, 1.0f)); // Set the background color (RGBA)
    ImGui::Begin("EditEntity", &showEditWindow, ImGuiWindowFlags_AlwaysAutoResize | ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoMove);
 
    // Retrieve the Size and Visibility components of the entity
    is_hovered = ImGui::IsWindowHovered();
    auto is_popup_open = false;
    if (edit_window_entity.has<Size>() && edit_window_entity.has<Visibility>())
    {
        auto nm = network_manager.lock();
        auto boardEnt = getActiveBoard();
 
        auto size = edit_window_entity.get_mut<Size>();             // Mutable access to the size
        auto visibility = edit_window_entity.get_mut<Visibility>(); // Mutable access to the visibility
 
        ImGui::BeginGroup();
        if (ImGui::Button("+ Size"))
        {
            if (nm && boardEnt.is_valid())
            {
                size->width = size->width * 1.1;
                size->height = size->height * 1.1; // Adjust height proportionally to the width
                if (edit_window_entity.has<MarkerComponent>())
                {
                    nm->broadcastMarkerUpdate(boardEnt.get<Identifier>()->id, edit_window_entity);
                }
                else if (edit_window_entity.has<FogOfWar>())
                {
                    nm->broadcastFogUpdate(boardEnt.get<Identifier>()->id, edit_window_entity);
                }
            }
        }
        ImGui::SameLine();
        if (ImGui::Button("- Size"))
        {
            if (nm && boardEnt.is_valid())
            {
                size->width = size->width * 0.90;
                size->height = size->height * 0.90; // Adjust height proportionally to the width
                if (edit_window_entity.has<MarkerComponent>())
                {
                    nm->broadcastMarkerUpdate(boardEnt.get<Identifier>()->id, edit_window_entity);
                }
                else if (edit_window_entity.has<FogOfWar>())
                {
                    nm->broadcastFogUpdate(boardEnt.get<Identifier>()->id, edit_window_entity);
                }
            }
        }
 
        ImGui::EndGroup();
        // Checkbox for visibility change
        auto vis_temp = visibility->isVisible;
        if (ImGui::Checkbox("Visible", &vis_temp))
        {
            if (nm && boardEnt.is_valid())
            {
                visibility->isVisible = vis_temp;
                if (edit_window_entity.has<MarkerComponent>())
                {
                    nm->broadcastMarkerUpdate(boardEnt.get<Identifier>()->id, edit_window_entity);
                }
                else if (edit_window_entity.has<FogOfWar>())
                {
                    nm->broadcastFogUpdate(boardEnt.get<Identifier>()->id, edit_window_entity);
                }
            }
        }
 
        ImGui::Separator();
 
        // Button to delete the entity (with a confirmation popup)
 
        if (ImGui::Button("Delete"))
        {
            ImGui::OpenPopup("Confirm Delete");
            is_popup_open = true;
        }
 
        if (ImGui::IsPopupOpen("Confirm Delete"))
            is_popup_open = true;
        if (ImGui::BeginPopupModal("Confirm Delete", nullptr, ImGuiWindowFlags_AlwaysAutoResize))
        {
            ImGui::Text("Are you sure you want to delete this entity?");
            ImGui::Separator();
 
            if (ImGui::Button("Yes", ImVec2(120, 0)))
            {
                if (edit_window_entity.is_alive())
                {
                    if (nm && boardEnt.is_valid())
                    {
                        if (edit_window_entity.has<MarkerComponent>())
                        {
                            nm->broadcastMarkerDelete(boardEnt.get<Identifier>()->id, edit_window_entity);
                        }
                        else if (edit_window_entity.has<FogOfWar>())
                        {
                            nm->broadcastFogDelete(boardEnt.get<Identifier>()->id, edit_window_entity);
                        }
                        edit_window_entity.destruct(); // Delete the entity
                        showEditWindow = false;
                    }
                }
                ImGui::CloseCurrentPopup(); // Close the popup after deletion
            }
            ImGui::SameLine();
            if (ImGui::Button("No", ImVec2(120, 0)))
            {
                ImGui::CloseCurrentPopup(); // Close the popup without deletion
            }
            ImGui::EndPopup();
        }
    }
    else
    {
        ImGui::Text("Invalid entity or missing components!");
    }
    // --- Ownership (only for markers) ---
    if (edit_window_entity.is_valid() && edit_window_entity.has<MarkerComponent>())
    {
        auto nm = network_manager.lock();
        auto mc = edit_window_entity.get_mut<MarkerComponent>();
        auto idm = identity_manager; // you already have this in BoardManager
 
        ImGui::Separator();
        ImGui::TextUnformatted("Owner");
        ImGui::Spacing();
 
        // Build options as (uniqueId, displayName). Index 0 = (none)
        struct Opt
        {
            std::string uid;
            std::string label;
        };
        std::vector<Opt> options;
        options.push_back(Opt{"", "(none)"}); // index 0
 
        // Collect connected peers -> uniqueId (dedup by uid)
        std::set<std::string> seenUids;
        if (nm && idm)
        {
            for (auto& [peerId, link] : nm->getPeers())
            {
                if (!link)
                    continue;
                auto uidOpt = idm->uniqueForPeer(peerId);
                if (!uidOpt || uidOpt->empty())
                    continue;
 
                const std::string& uid = *uidOpt;
                if (!seenUids.insert(uid).second)
                    continue; // dedup
 
                // label = current username for that uid
                std::string label = idm->usernameForUnique(uid);
                if (label.empty())
                    label = uid.substr(0, std::min<size_t>(8, uid.size()));
                options.push_back(Opt{uid, label});
            }
        }
 
        // If current owner is offline, include them so the selection stays visible
        if (idm && !mc->ownerUniqueId.empty() && !seenUids.count(mc->ownerUniqueId))
        {
            std::string label = idm->usernameForUnique(mc->ownerUniqueId);
            if (label.empty())
                label = mc->ownerUniqueId.substr(0, std::min<size_t>(8, mc->ownerUniqueId.size()));
            options.push_back(Opt{mc->ownerUniqueId, label});
        }
 
        // Find current selection by ownerUniqueId
        int selectedIndex = 0;
        for (int i = 1; i < (int)options.size(); ++i)
            if (options[i].uid == mc->ownerUniqueId)
            {
                selectedIndex = i;
                break;
            }
 
        // Pagination (unchanged UI)
        static int ownerPage = 0;
        const int rowsPerPage = 6;
        const int totalRows = (int)options.size();
        const int totalPages = (totalRows + rowsPerPage - 1) / rowsPerPage;
        ownerPage = std::clamp(ownerPage, 0, std::max(0, totalPages - 1));
        auto ToggleRow = [&](const char* label, bool selected, int id) -> bool
        {
            ImGui::PushID(id);
            if (selected)
            {
                ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.20f, 0.50f, 0.80f, 1.0f));
                ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.25f, 0.55f, 0.85f, 1.0f));
                ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.15f, 0.45f, 0.75f, 1.0f));
            }
            else
            {
                ImGui::PushStyleColor(ImGuiCol_Button, ImVec4(0.25f, 0.28f, 0.32f, 1.0f));
                ImGui::PushStyleColor(ImGuiCol_ButtonHovered, ImVec4(0.30f, 0.33f, 0.38f, 1.0f));
                ImGui::PushStyleColor(ImGuiCol_ButtonActive, ImVec4(0.22f, 0.25f, 0.29f, 1.0f));
            }
            bool clicked = ImGui::Button(label, ImVec2(-FLT_MIN, 0));
            ImGui::PopStyleColor(3);
            ImGui::PopID();
            return clicked;
        };
 
        const int start = ownerPage * rowsPerPage;
        const int end = std::min(start + rowsPerPage, totalRows);
 
        // Render visible rows
        for (int i = start; i < end; ++i)
        {
            const bool isSel = (selectedIndex == i);
            const char* label = options[i].label.c_str();
            if (ToggleRow(label, isSel, i))
            {
                selectedIndex = i;
 
                // APPLY IMMEDIATELY (no "Apply Ownership" button)
                const std::string prevOwnerUid = mc->ownerUniqueId;
                mc->ownerUniqueId = options[i].uid; // << authoritative owner
                mc->ownerPeerUsername.clear();
                if (idm && !mc->ownerUniqueId.empty())
                    mc->ownerPeerUsername = idm->usernameForUnique(mc->ownerUniqueId); // display only
 
                // If owner changed, clear drag state so new owner can take over smoothly
                if (edit_window_entity.has<Identifier>() && nm)
                {
                    const auto mid = edit_window_entity.get<Identifier>()->id;
                    if (prevOwnerUid != mc->ownerUniqueId)
                        nm->clearDragState(mid); // small helper: drag_.erase(mid)
                }
 
                // Broadcast the change now
                if (nm)
                {
                    auto boardEnt = getActiveBoard();
                    if (boardEnt.is_valid())
                        nm->broadcastMarkerUpdate(boardEnt.get<Identifier>()->id, edit_window_entity);
                }
            }
        }
 
        // Pagination controls
        if (totalPages > 1)
        {
            ImGui::Spacing();
            ImGui::BeginDisabled(ownerPage <= 0);
            if (ImGui::Button("< Prev"))
                ownerPage--;
            ImGui::EndDisabled();
            ImGui::SameLine();
            ImGui::Text("Page %d / %d", ownerPage + 1, std::max(1, totalPages));
            ImGui::SameLine();
            ImGui::BeginDisabled(ownerPage >= totalPages - 1);
            if (ImGui::Button("Next >"))
                ownerPage++;
            ImGui::EndDisabled();
        }
 
        // Flags — apply immediately when toggled
        bool flagsChanged = false;
        flagsChanged |= ImGui::Checkbox("Allow all players to move", &mc->allowAllPlayersMove);
        flagsChanged |= ImGui::Checkbox("Locked (players cannot move)", &mc->locked);
        if (flagsChanged && nm)
        {
            auto boardEnt = getActiveBoard();
            if (boardEnt.is_valid())
                nm->broadcastMarkerUpdate(boardEnt.get<Identifier>()->id, edit_window_entity);
        }
    }
 
    ImGui::End();
    ImGui::PopStyleColor(); // Restore the original background color
 
    if (!is_hovered && ImGui::IsMouseClicked(ImGuiMouseButton_Left) && !is_popup_open)
    {
        showEditWindow = false;
    }
 
    if (!showEditWindow)
    {
        edit_window_entity = flecs::entity();
    }
    //close edit window when clicking outside it
}

Here is the call graph for this function:

renderGridWindow()

void BoardManager::renderGridWindow

(

)

Definition at line 1665 of file BoardManager.cpp.

{
    // Check if the window should be shown
    if (!showGridSettings)
    {
        return;
    }
 
    // Begin the ImGui window
    auto mouse_pos = ImGui::GetMousePos();
    ImGui::SetNextWindowPos(ImVec2(mouse_pos.x, mouse_pos.y + ImGui::GetFrameHeightWithSpacing()), ImGuiCond_Appearing);
    ImGui::PushStyleColor(ImGuiCol_WindowBg, ImVec4(0.0f, 0.1f, 0.2f, 1.0f)); // Set the background color (RGBA)
    ImGui::Begin("Grid", &showGridSettings, ImGuiWindowFlags_AlwaysAutoResize);
 
    ImGui::PopStyleColor();
    // Get a mutable reference to the Grid component from the active board
    auto grid = active_board.get_mut<Grid>();
    bool changed = false;
 
    if (grid)
    {
        // --- BOOLEAN CHECKBOXES ---
        changed |= ImGui::Checkbox("Visible", &grid->visible);
        changed |= ImGui::Checkbox("Snap to Grid", &grid->snap_to_grid);
        //ImGui::Checkbox("Hexagonal Grid", &grid->is_hex);
 
        // --- FLOAT SLIDERS ---
        changed |= ImGui::SliderFloat("Cell Size", &grid->cell_size, 10.0f, 200.0f);
        ImGui::SameLine();
        if (ImGui::Button("-##size"))
        {
            grid->cell_size = grid->cell_size - 0.01f;
            changed = true;
        }
        ImGui::SameLine();
        if (ImGui::Button("+##size"))
        {
            grid->cell_size = grid->cell_size + 0.01f;
            changed = true;
        }
        // --- OFFSET CONTROLS (SIMPLIFIED WITH SLIDERS) ---
        ImGui::Text("Grid Offset");
        changed |= ImGui::SliderFloat("Offset X", &grid->offset.x, -500.0f, 500.0f);
        ImGui::SameLine();
        if (ImGui::Button("-##offsetx"))
        {
            grid->offset.x = grid->offset.x - 0.01f;
            changed = true;
        }
        ImGui::SameLine();
        if (ImGui::Button("+##offsetx"))
        {
            grid->offset.x = grid->offset.x + 0.01f;
            changed = true;
        }
        changed |= ImGui::SliderFloat("Offset Y", &grid->offset.y, -500.0f, 500.0f);
 
        ImGui::SameLine();
        if (ImGui::Button("-##offsety"))
        {
            grid->offset.y = grid->offset.y - 0.01f;
            changed = true;
        }
        ImGui::SameLine();
        if (ImGui::Button("+##offsety"))
        {
            grid->offset.y = grid->offset.y + 0.01f;
            changed = true;
        }
 
        // Button to reset the offset
        if (ImGui::Button("Reset Offset"))
        {
            grid->offset = glm::vec2(0.0f);
            changed = true;
        }
 
        if (changed)
        {
            if (grid->snap_to_grid)
            {
                resnapAllMarkersToNearest(*grid);
            }
            if (auto nm = network_manager.lock())
            {
                if (active_board.has<Identifier>())
                    nm->broadcastGridUpdate(active_board.get<Identifier>()->id, active_board);
            }
        }
    }
    else
    {
        ImGui::Text("Active board entity does not have a Grid component.");
    }
 
    ImGui::End();
}

Here is the call graph for this function:

Here is the caller graph for this function:

renderToolbar()

void BoardManager::renderToolbar

(

const ImVec2 &

window_position

)

Definition at line 204 of file BoardManager.cpp.

{
    ImGuiWindowFlags toolbar_child_flags =
        ImGuiWindowFlags_NoCollapse | ImGuiWindowFlags_NoDocking | ImGuiWindowFlags_NoMove |
        ImGuiWindowFlags_NoResize | ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_NoTitleBar |
        ImGuiWindowFlags_AlwaysAutoResize;
 
    auto panel_color = ImVec4(0.18f, 0.22f, 0.27f, 1.00f); // toolbar panel
    auto bg_color = ImVec4(0.12f, 0.14f, 0.17f, 1.00f);
    auto old_bg_color = ImVec4(0.2f, 0.3f, 0.4f, 1.0f);
 
    auto green_light_color = ImVec4(0.55f, 0.95f, 0.65f, 1.00f);
    auto green_mid_color = ImVec4(0.20f, 0.75f, 0.35f, 1.00f);
    auto green_dark_color = ImVec4(0.12f, 0.45f, 0.22f, 1.00f);
    auto mint_color = ImVec4(0.50f, 0.95f, 0.85f, 1.00f);
 
    auto blue_light_color = ImVec4(0.55f, 0.75f, 1.00f, 1.00f);
    auto blue_mid_color = ImVec4(0.28f, 0.50f, 0.92f, 1.00f);
    auto blue_dark_color = ImVec4(0.15f, 0.30f, 0.55f, 1.00f);
 
    auto purple_color = ImVec4(0.70f, 0.45f, 0.95f, 1.00f);
    auto violet_color = ImVec4(0.55f, 0.35f, 0.85f, 1.00f);
    auto mid_purple_color = ImVec4(0.45f, 0.28f, 0.70f, 1.00f);
 
    auto orange_color = ImVec4(0.98f, 0.60f, 0.20f, 1.00f);
    auto amber_color = ImVec4(1.00f, 0.78f, 0.25f, 1.00f);
    auto yellow_color = ImVec4(0.95f, 0.90f, 0.30f, 1.00f);
 
    auto button_toggled_color = amber_color;
    auto button_toggled_hover = orange_color;
    auto button_toggled_active = yellow_color;
 
    auto button_untoggled_color = blue_mid_color;
    auto button_untoggled_hover = blue_light_color;
    auto button_untoggled_active = yellow_color;
 
    auto button_popup_color = green_dark_color;
    auto button_popup_hover = green_mid_color;
    auto button_popup_active = mint_color;
 
    ImGui::SetCursorPos(window_position);
 
    ImVec2 toolbar_size = ImVec2(0, 0); // Auto-size to content
 
    // -------- Hotkeys (before rendering) ------------------------------------
    auto nm = network_manager.lock();
    if (!nm)
        throw std::exception("[BoardManager] NetworkManager Expired");
 
    ImGuiIO& io = ImGui::GetIO();
    bool isGM = (nm->getPeerRole() == Role::GAMEMASTER);
    bool allowHotkeys = !UiTypingGuard::IsTyping();
 
    // We need a tiny bit of state for Space-hold override
    static bool s_spaceHoldActive = false;
    static Tool s_spaceReturnTool = Tool::MOVE; // Tool to restore on Space release
 
    // Helper to change tool and always record previousTool
    auto setTool = [&](Tool t)
    {
        if (currentTool != t)
        {
            previousTool = currentTool; // remember where we came from
            currentTool = t;
        }
    };
 
    if (allowHotkeys)
    {
        // Space: press => temp Move; release => restore the tool that was active at press time
        if (ImGui::IsKeyPressed(ImGuiKey_Space))
        {
            if (!s_spaceHoldActive)
            {
                s_spaceHoldActive = true;
                s_spaceReturnTool = currentTool; // snapshot tool active at press time
                if (currentTool != Tool::MOVE)
                {
                    currentTool = Tool::MOVE;
                }
            }
        }
        if (s_spaceHoldActive && ImGui::IsKeyReleased(ImGuiKey_Space))
        {
            s_spaceHoldActive = false;
            currentTool = s_spaceReturnTool; // restore exactly what was active at press time
        }
 
        // Regular hotkeys (don’t fire while Space-hold is active)
        if (!s_spaceHoldActive)
        {
            if (ImGui::IsKeyPressed(ImGuiKey_M))
                setTool(Tool::MOVE);
            if (isGM && ImGui::IsKeyPressed(ImGuiKey_F))
                setTool(Tool::FOG);
            if (isGM && ImGui::IsKeyPressed(ImGuiKey_S))
                setTool(Tool::SELECT);
 
            if (ImGui::IsKeyPressed(ImGuiKey_C))
                showCameraSettings = !showCameraSettings;
 
            if (isGM && ImGui::IsKeyPressed(ImGuiKey_G))
                showGridSettings = !showGridSettings;
 
            if (ImGui::IsKeyPressed(ImGuiKey_Q))
                std::swap(currentTool, previousTool);
        }
    }
    // -------------------------------------------------------------------------
 
    ImGui::PushStyleColor(ImGuiCol_WindowBg, panel_color);
    ImGui::BeginChild("ToolbarChild", toolbar_size, false, toolbar_child_flags);
 
    // Tool: Previous (Q)
    ImGui::PushStyleColor(ImGuiCol_Button, purple_color);
    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, violet_color);
    ImGui::PushStyleColor(ImGuiCol_ButtonActive, mid_purple_color);
    if (ImGui::Button("Prev.(Q)", ImVec2(65, 40)))
    {
        std::swap(currentTool, previousTool);
    }
    ImGui::PopStyleColor(3);
    ImGui::SameLine();
 
    // Tool: Move (M)
    ImGui::PushStyleColor(ImGuiCol_Button, currentTool == Tool::MOVE ? button_toggled_color : button_untoggled_color);
    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, currentTool == Tool::MOVE ? button_toggled_hover : button_untoggled_hover);
    ImGui::PushStyleColor(ImGuiCol_ButtonActive, currentTool == Tool::MOVE ? button_toggled_active : button_untoggled_active);
    if (ImGui::Button("  Move (M)\n(Hold Space)", ImVec2(100, 40)))
    {
        setTool(Tool::MOVE);
    }
    ImGui::PopStyleColor(3);
    ImGui::SameLine();
 
    if (isGM)
    {
        // Tool: Fog (F)
        ImGui::PushStyleColor(ImGuiCol_Button, currentTool == Tool::FOG ? button_toggled_color : button_untoggled_color);
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, currentTool == Tool::FOG ? button_toggled_hover : button_untoggled_hover);
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, currentTool == Tool::FOG ? button_toggled_active : button_untoggled_active);
        if (ImGui::Button("Fog (F)", ImVec2(100, 40)))
        {
            setTool(Tool::FOG);
        }
        ImGui::PopStyleColor(3);
        ImGui::SameLine();
 
        // Tool: Select (S)
        ImGui::PushStyleColor(ImGuiCol_Button, currentTool == Tool::SELECT ? button_toggled_color : button_untoggled_color);
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, currentTool == Tool::SELECT ? button_toggled_hover : button_untoggled_hover);
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, currentTool == Tool::SELECT ? button_toggled_active : button_untoggled_active);
        if (ImGui::Button("Select (S)", ImVec2(100, 40)))
        {
            setTool(Tool::SELECT);
        }
        ImGui::PopStyleColor(3);
        ImGui::SameLine();
    }
 
    // Camera Settings (no hotkey here)
    ImGui::PushStyleColor(ImGuiCol_Button, button_popup_color);
    ImGui::PushStyleColor(ImGuiCol_ButtonHovered, button_popup_hover);
    ImGui::PushStyleColor(ImGuiCol_ButtonActive, button_popup_active);
    if (ImGui::Button("Camera Settings (C)", ImVec2(150, 40)))
    {
        showCameraSettings = !showCameraSettings;
    }
    ImGui::PopStyleColor(3);
 
    if (isGM)
    {
        ImGui::SameLine();
        ImGui::PushStyleColor(ImGuiCol_Button, button_popup_color);
        ImGui::PushStyleColor(ImGuiCol_ButtonHovered, button_popup_hover);
        ImGui::PushStyleColor(ImGuiCol_ButtonActive, button_popup_active);
        if (ImGui::Button("Grid Settings (G)", ImVec2(150, 40)))
        {
            showGridSettings = !showGridSettings;
        }
        ImGui::PopStyleColor(3);
    }
 
    ImGui::PopStyleColor(); // toolbar bg
    ImGui::EndChild();
 
    renderGridWindow();
    renderCameraWindow();
}

Here is the call graph for this function:

resetCamera()

void BoardManager::resetCamera

(

)

Definition at line 1116 of file BoardManager.cpp.

{
    camera.setPosition(glm::vec2(0.0f, 0.0f));
    camera.setZoom(1.0f);
}

Here is the call graph for this function:

Here is the caller graph for this function:

resnapAllMarkersToNearest()

void BoardManager::resnapAllMarkersToNearest

(

const Grid &

grid

)

Definition at line 837 of file BoardManager.cpp.

{
    if (grid.cell_size <= 0.0f)
        return;
 
    auto nm = network_manager.lock();
 
    ecs.defer_begin();
    active_board.children([&](flecs::entity e)
                          {
        if (!e.has<MarkerComponent>()) return;
 
        Position* pos = e.get_mut<Position>();
        if (!pos) return;
 
        glm::vec2 p(pos->x, pos->y);
        glm::vec2 goal = snapToSquareCenter(p, grid.offset, grid.cell_size);
 
        // Only write if it actually changes (avoid network spam)
        if (glm::any(glm::epsilonNotEqual(p, goal, glm::vec2(1e-4f)))) {
            pos->x = goal.x;
            pos->y = goal.y;
 
            // If you're broadcasting grid-driven corrections:
            if (nm && e.has<Identifier>()) {
                const auto bid = active_board.get<Identifier>()->id;
                nm->broadcastMarkerUpdate(bid, e); // or your existing "final pos" message
            }
        } });
    ecs.defer_end();
}

Here is the call graph for this function:

Here is the caller graph for this function:

saveActiveBoard() [1/2]

void BoardManager::saveActiveBoard

(

const std::string &

filePath

)

saveActiveBoard() [2/2]

void BoardManager::saveActiveBoard

(

std::filesystem::path &

filePath

)

Definition at line 1257 of file BoardManager.cpp.

{
    if (!active_board.is_alive())
    {
        std::cerr << "No active board to save." << std::endl;
        return;
    }
    auto board = active_board.get<Board>();
    if (!std::filesystem::exists(board_directory_path))
    {
        std::filesystem::create_directory(board_directory_path);
    }
 
    auto board_file_path = board_directory_path / (board->board_name + ".runic");
 
    std::vector<uint8_t> buffer;
    Serializer::serializeBoardEntity(buffer, active_board, ecs);
 
    std::ofstream outFile(board_file_path, std::ios::binary);
    if (outFile)
    {
        outFile.write(reinterpret_cast<const char*>(buffer.data()), buffer.size());
        outFile.close();
        std::cout << "Board saved successfully to " << board_directory_path << std::endl;
    }
    else
    {
        std::cerr << "Failed to save board to " << board_directory_path << std::endl;
    }
}

Here is the call graph for this function:

sendEntityUpdate()

void BoardManager::sendEntityUpdate

(

flecs::entity

entity

)

sendGameState()

void BoardManager::sendGameState

(

)

setActiveBoard()

void BoardManager::setActiveBoard

(

flecs::entity

board_entity

)

Definition at line 76 of file BoardManager.cpp.

{
    active_board = board_entity;
    auto nm = network_manager.lock();
    if (!nm)
        if (nm->getPeerRole() == Role::GAMEMASTER)
            nm->broadcastBoard(active_board);
}

Here is the caller graph for this function:

setCurrentTool()

void BoardManager::setCurrentTool

(

Tool

newTool

)

Definition at line 1179 of file BoardManager.cpp.

{
    currentTool = newTool;
}

setShowEditWindow()

void BoardManager::setShowEditWindow ( bool show, flecs::entity edit_entity = flecs::entity() )

inline

Definition at line 248 of file BoardManager.h.

    {
        if (showEditWindow && edit_window_entity.is_valid())
            return;
        showEditWindow = show;
        edit_window_entity = edit_entity;
    };

shouldSendMarkerMove()

bool BoardManager::shouldSendMarkerMove

(

uint64_t

markerId

)

const

Definition at line 1051 of file BoardManager.cpp.

{
    using namespace std::chrono;
    static std::unordered_map<uint64_t, steady_clock::time_point> lastSent;
    static constexpr auto kMinInterval = milliseconds(33); // ~30 Hz. Use 50ms for ~20 Hz if you prefer.
 
    const auto now = steady_clock::now();
    auto it = lastSent.find(markerId);
    if (it == lastSent.end() || (now - it->second) >= kMinInterval)
    {
        lastSent[markerId] = now;
        return true; // allow this send
    }
    return false; // too soon, skip this tick
}

Here is the caller graph for this function:

snapToGrid()

glm::vec2 BoardManager::snapToGrid

(

glm::vec2

raw_world_pos

)

startMouseDrag()

void BoardManager::startMouseDrag	(	glm::vec2	mousePos,
		bool	draggingMarker )

Definition at line 924 of file BoardManager.cpp.

{
    mouse_start_world_pos = mousePos;
    mouse_start_screen_pos = camera.worldToScreenPosition(mousePos);
 
    if (currentTool == Tool::MOVE)
    {
        if (draggingMap)
        {
            active_board.set<Panning>({true});
            return;
        }
 
        // Marker drag start:
        auto ent = getEntityAtMousePosition(mousePos);
        if (!ent.is_valid() || !ent.has<MarkerComponent>() || !ent.has<Moving>() || !ent.has<Identifier>())
            return;
 
        auto nm = network_manager.lock();
        if (!nm)
            return;
 
        const auto mid = ent.get<Identifier>()->id;
 
        // Do NOT start if someone else is already dragging this marker.
        if (nm->isMarkerBeingDragged(mid) && !nm->amIDragging(mid))
            return;
 
        // Optional: prevent starting a second local drag (you said players shouldn’t drag 2 markers)
        if (isDraggingMarker())
            return;
 
        if (!canMoveMarker(ent.get<MarkerComponent>(), ent))
            return;
 
        // Local start
        ent.set<Moving>(Moving{true});
        nm->markDraggingLocal(mid, true);
 
        if (active_board.has<Identifier>())
        {
            const auto bid = active_board.get<Identifier>()->id;
            nm->broadcastMarkerMoveState(bid, ent); // START (isDragging=true)
        }
    }
    else if (currentTool == Tool::FOG)
    {
        is_creating_fog = true;
    }
}

Here is the call graph for this function:

Member Data Documentation

active_board

flecs::entity BoardManager::active_board = flecs::entity()

private

Definition at line 280 of file BoardManager.h.

board_name

std::string BoardManager::board_name

Definition at line 235 of file BoardManager.h.

camera

Camera BoardManager::camera

Definition at line 238 of file BoardManager.h.

currentTool

Tool BoardManager::currentTool

private

Definition at line 284 of file BoardManager.h.

ecs

flecs::world BoardManager::ecs

private

Definition at line 279 of file BoardManager.h.

edit_window_entity

flecs::entity BoardManager::edit_window_entity = flecs::entity()

private

Definition at line 270 of file BoardManager.h.

grid_entity

flecs::entity BoardManager::grid_entity = flecs::entity()

private

Definition at line 281 of file BoardManager.h.

identity_manager

std::shared_ptr<IdentityManager> BoardManager::identity_manager

private

Definition at line 272 of file BoardManager.h.

is_creating_fog

bool BoardManager::is_creating_fog = false

private

Definition at line 283 of file BoardManager.h.

map_directory

std::shared_ptr<DirectoryWindow> BoardManager::map_directory

Definition at line 236 of file BoardManager.h.

marker_directory

std::shared_ptr<DirectoryWindow> BoardManager::marker_directory

Definition at line 237 of file BoardManager.h.

markerBasePx

float BoardManager::markerBasePx = 50.0f

private

Definition at line 269 of file BoardManager.h.

mouse_current_world_pos

glm::vec2 BoardManager::mouse_current_world_pos

private

Definition at line 277 of file BoardManager.h.

mouse_start_screen_pos

glm::vec2 BoardManager::mouse_start_screen_pos

private

Definition at line 275 of file BoardManager.h.

mouse_start_world_pos

glm::vec2 BoardManager::mouse_start_world_pos

private

Definition at line 276 of file BoardManager.h.

network_manager

std::weak_ptr<NetworkManager> BoardManager::network_manager

private

Definition at line 271 of file BoardManager.h.

previousTool

Tool BoardManager::previousTool

private

Definition at line 285 of file BoardManager.h.

showCameraSettings

bool BoardManager::showCameraSettings = false

private

Definition at line 268 of file BoardManager.h.

showEditWindow

bool BoardManager::showEditWindow = false

private

Definition at line 266 of file BoardManager.h.

showGridSettings

bool BoardManager::showGridSettings = false

private

Definition at line 267 of file BoardManager.h.

---

The documentation for this class was generated from the following files:

• include/BoardManager.h
• src/BoardManager.cpp