ChatManager Class Reference

#include <ChatManager.h>

Inheritance diagram for ChatManager:

Collaboration diagram for ChatManager:

Public Member Functions
	ChatManager (std::weak_ptr< NetworkManager > nm, std::shared_ptr< IdentityManager > identity_manager)
void	setNetwork (std::weak_ptr< NetworkManager > nm)
void	setActiveGameTable (uint64_t tableId, const std::string &gameTableName)
bool	hasCurrent () const
bool	saveCurrent ()
bool	loadCurrent ()
void	applyReady (const msg::ReadyMessage &m)
void	pushMessageLocal (uint64_t groupId, const std::string &fromPeer, const std::string &username, const std::string &text, double ts, bool incoming)
void	render ()
void	writeGroupsToSnapshotGT (std::vector< unsigned char > &buf) const
void	readGroupsFromSnapshotGT (const std::vector< unsigned char > &buf, size_t &off)
ChatGroupModel *	getGroup (uint64_t id)
void	replaceUsernameForUnique (const std::string &uniqueId, const std::string &newUsername)
void	tryHandleSlashCommand (uint64_t threadId, const std::string &input)
std::set< std::string >	resolvePeerIdsForParticipants (const std::set< std::string > &participantUids) const
bool	isMeParticipantOf (const ChatGroupModel &g) const

Public Attributes
uint64_t	currentTableId_ = 0
std::string	currentTableName_

Static Public Attributes
static constexpr uint64_t	generalGroupId_ = 1

Private Member Functions
ImU32	getUsernameColor (const std::string &name) const
void	renderColoredUsername (const std::string &name) const
void	renderPlainMessage (const std::string &text) const
std::filesystem::path	chatFilePathFor (uint64_t tableId, const std::string &name) const
void	ensureGeneral ()
void	markGroupRead (uint64_t groupId)
void	emitGroupCreate (const ChatGroupModel &g)
void	emitGroupUpdate (const ChatGroupModel &g)
void	emitGroupDelete (uint64_t groupId)
void	emitChatMessageFrame (uint64_t groupId, const std::string &username, const std::string &text, uint64_t ts)
void	emitGroupLeave (uint64_t groupId)
void	renderEditGroupPopup ()
void	renderLeftPanel (float width)
void	renderRightPanel (float leftPanelWidth)
void	renderCreateGroupPopup ()
void	renderDeleteGroupPopup ()
void	renderDicePopup ()
bool	saveLog (std::vector< uint8_t > &buf) const
bool	loadLog (const std::vector< uint8_t > &buf)
uint64_t	makeGroupIdFromName (const std::string &name) const

Static Private Member Functions
static ChatMessageModel::Kind	classifyMessage (const std::string &s)
static double	nowSec ()
static ImVec4	HSVtoRGB (float h, float s, float v)

Private Attributes
std::shared_ptr< IdentityManager >	identity_manager
std::unordered_map< uint64_t, ChatGroupModel >	groups_
uint64_t	activeGroupId_ = generalGroupId_
std::array< char, 512 >	input_ {}
bool	focusInput_ = false
bool	followScroll_ = true
bool	jumpToBottom_ = false
bool	chatWindowFocused_ = false
bool	openCreatePopup_ = false
bool	openDeletePopup_ = false
bool	openDicePopup_ = false
std::array< char, 128 >	newGroupName_ {}
std::set< std::string >	newGroupSel_
float	leftWidth_ = 170.0f
bool	openEditPopup_ = false
uint64_t	editGroupId_ = 0
std::array< char, 128 >	editGroupName_ {}
std::set< std::string >	editGroupSel_
int	diceN_ = 1
int	diceSides_ = 20
int	diceMod_ = 0
bool	diceModPerDie_ = false
std::weak_ptr< NetworkManager >	network_
std::unordered_map< std::string, ImU32 >	nameColorCache_

Detailed Description

Definition at line 49 of file ChatManager.h.

Constructor & Destructor Documentation

ChatManager()

ChatManager::ChatManager ( std::weak_ptr< NetworkManager > nm, std::shared_ptr< IdentityManager > identity_manager )

explicit

Definition at line 40 of file ChatManager.cpp.

                                                                                                        :
    network_(std::move(nm)), identity_manager(identity_manager) {}

Member Function Documentation

applyReady()

void ChatManager::applyReady

(

const msg::ReadyMessage &

m

)

Definition at line 243 of file ChatManager.cpp.

{
    using K = msg::DCType;
 
    switch (m.kind)
    {
        case K::ChatGroupCreate:
        {
            if (!m.tableId || !m.threadId)
                return;
            if (*m.tableId != currentTableId_)
                return;
 
            ChatGroupModel g;
            g.id = *m.threadId;
            g.name = m.name.value_or("Group");
 
            // derive owner uniqueId (best-effort)
            std::string ownerUid;
            if (identity_manager)
                ownerUid = identity_manager->uniqueForPeer(m.fromPeerId).value_or("Player");
            g.ownerUniqueId = ownerUid;
 
            if (m.participants)
                g.participants = *m.participants;
 
            auto it = groups_.find(g.id);
            if (it == groups_.end())
                groups_.emplace(g.id, std::move(g));
            else
            {
                it->second.name = g.name;
                it->second.participants = std::move(g.participants);
                // keep existing ownerUniqueId if you want
            }
 
            Logger::instance().log("chat", Logger::Level::Info, "RX GroupCreate id=" + std::to_string(*m.threadId) + " name=" + m.name.value_or("Group"));
            break;
        }
 
        case K::ChatGroupUpdate:
        {
            if (!m.tableId || !m.threadId)
                return;
            if (*m.tableId != currentTableId_)
                return;
 
            auto* g = getGroup(*m.threadId);
            if (!g)
            {
                ChatGroupModel stub;
                stub.id = *m.threadId;
                stub.name = m.name.value_or("Group");
                if (m.participants)
                    stub.participants = *m.participants;
 
                // best-effort owner
                if (identity_manager)
                    stub.ownerUniqueId = identity_manager->uniqueForPeer(m.fromPeerId).value_or("Player");
 
                groups_.emplace(stub.id, std::move(stub));
            }
            else
            {
                if (m.name)
                    g->name = *m.name;
                if (m.participants)
                    g->participants = *m.participants;
            }
            break;
        }
 
        case K::ChatGroupDelete:
        {
            if (!m.tableId || !m.threadId)
                return;
            if (*m.tableId != currentTableId_)
                return;
            if (*m.threadId == generalGroupId_)
                return; // never delete General
 
            if (auto* g = getGroup(*m.threadId))
            {
                // permission: only owner can delete
                const std::string reqOwner =
                    identity_manager ? identity_manager->uniqueForPeer(m.fromPeerId).value_or("Player") : std::string{};
                if (!g->ownerUniqueId.empty() && g->ownerUniqueId == reqOwner)
                {
                    groups_.erase(*m.threadId);
                    if (activeGroupId_ == *m.threadId)
                        activeGroupId_ = generalGroupId_;
                }
            }
            break;
        }
 
        case K::ChatMessage:
        {
            if (!m.tableId || !m.threadId || !m.ts || !m.name || !m.text)
                return;
            if (*m.tableId != currentTableId_)
                return;
 
            // map sender to uniqueId if possible (if ReadyMessage.userPeerId later carries it, use that)
            std::string senderUid =
                identity_manager ? identity_manager->uniqueForPeer(m.fromPeerId).value_or("Player") : std::string{};
 
            // inline append to include senderUniqueId
            ChatMessageModel msg;
            msg.kind = classifyMessage(*m.text);
            msg.senderUniqueId = senderUid;
            msg.username = *m.name;
            msg.content = *m.text;
            msg.ts = (double)*m.ts;
 
            auto* g = getGroup(*m.threadId);
            if (!g)
            {
                ChatGroupModel stub;
                stub.id = *m.threadId;
                stub.name = "(pending?)";
                groups_.emplace(stub.id, std::move(stub));
                g = getGroup(*m.threadId);
            }
            g->messages.push_back(std::move(msg));
 
            const bool isActive = (activeGroupId_ == *m.threadId);
            if (!isActive || !chatWindowFocused_ || !followScroll_)
                g->unread = std::min<uint32_t>(g->unread + 1, 999u);
            break;
        }
 
        default:
            break;
    }
}

Here is the call graph for this function:

chatFilePathFor()

std::filesystem::path ChatManager::chatFilePathFor ( uint64_t tableId, const std::string & name ) const

private

Definition at line 78 of file ChatManager.cpp.

{
    auto gametables_folder = PathManager::getGameTablesPath();
    auto gametable_name_folder = gametables_folder / name;
    return gametable_name_folder / std::filesystem::path(name + "_" + std::to_string(tableId) + "_chatgroups.runic");
}

Here is the call graph for this function:

Here is the caller graph for this function:

classifyMessage()

ChatMessageModel::Kind ChatManager::classifyMessage ( const std::string & s )

staticprivate

Definition at line 30 of file ChatManager.cpp.

{
    if (ends_with_icase(s, ".png") || ends_with_icase(s, ".jpg") || ends_with_icase(s, ".jpeg"))
        return ChatMessageModel::Kind::IMAGE;
    if (s.rfind("http://", 0) == 0 || s.rfind("https://", 0) == 0)
        return ChatMessageModel::Kind::LINK;
    return ChatMessageModel::Kind::TEXT;
}

Here is the call graph for this function:

Here is the caller graph for this function:

emitChatMessageFrame()

void ChatManager::emitChatMessageFrame ( uint64_t groupId, const std::string & username, const std::string & text, uint64_t ts )

private

Definition at line 489 of file ChatManager.cpp.

{
    auto nm = network_.lock();
    if (!nm || !hasCurrent())
        return;
 
    auto it = groups_.find(groupId);
    if (it == groups_.end())
        return;
 
    const auto& parts = it->second.participants;
    auto j = msg::makeChatMessage(currentTableId_, groupId, ts, username, text);
    if (groupId == generalGroupId_)
    {
        nm->broadcastChatJson(j);
        return;
    }
    auto targets = resolvePeerIdsForParticipants(parts);
    if (!targets.empty())
        nm->sendChatJsonTo(targets, j);
}

Here is the call graph for this function:

Here is the caller graph for this function:

emitGroupCreate()

void ChatManager::emitGroupCreate ( const ChatGroupModel & g )

private

Definition at line 428 of file ChatManager.cpp.

{
    auto nm = network_.lock();
    if (!nm || !hasCurrent())
        return;
 
    auto j = msg::makeChatGroupCreate(currentTableId_, g.id, g.name, g.participants);
 
    if (g.id == generalGroupId_)
    {
        nm->broadcastChatJson(j);
        return;
    }
 
    auto targets = resolvePeerIdsForParticipants(g.participants);
    if (!targets.empty())
        nm->sendChatJsonTo(targets, j);
}

Here is the call graph for this function:

Here is the caller graph for this function:

emitGroupDelete()

void ChatManager::emitGroupDelete ( uint64_t groupId )

private

Definition at line 466 of file ChatManager.cpp.

{
    auto nm = network_.lock();
    if (!nm || !hasCurrent())
        return;
 
    if (groupId == generalGroupId_)
        return;
 
    auto it = groups_.find(groupId);
    if (it == groups_.end())
        return;
 
    const auto& g = it->second;
 
    auto j = msg::makeChatGroupDelete(currentTableId_, groupId);
 
    auto targets = resolvePeerIdsForParticipants(g.participants);
 
    if (!targets.empty())
        nm->sendChatJsonTo(targets, j);
}

Here is the call graph for this function:

Here is the caller graph for this function:

emitGroupLeave()

void ChatManager::emitGroupLeave ( uint64_t groupId )

private

Definition at line 511 of file ChatManager.cpp.

{
    auto nm = network_.lock();
    if (!nm || !hasCurrent())
        return;
 
    // General cannot be “left”
    if (groupId == generalGroupId_)
        return;
 
    auto it = groups_.find(groupId);
    if (it == groups_.end())
        return;
 
    auto& g = it->second;
    if (!identity_manager)
        return;
 
    const std::string meUid = identity_manager->myUniqueId();
 
    // Owner cannot leave their own group
    if (!g.ownerUniqueId.empty() && g.ownerUniqueId == meUid)
        return;
 
    // Remove me locally
    g.participants.erase(meUid);
 
    // Broadcast updated participants (re-using ChatGroupUpdate)
    auto j = msg::makeChatGroupUpdate(currentTableId_, g.id, g.name, g.participants);
    auto targets = resolvePeerIdsForParticipants(g.participants);
    if (!targets.empty())
        nm->sendChatJsonTo(targets, j);
 
    // UX: if I’m no longer in it, stop showing it as active
    if (activeGroupId_ == groupId && g.participants.count(meUid) == 0)
        activeGroupId_ = generalGroupId_;
}

Here is the call graph for this function:

Here is the caller graph for this function:

emitGroupUpdate()

void ChatManager::emitGroupUpdate ( const ChatGroupModel & g )

private

Definition at line 447 of file ChatManager.cpp.

{
    auto nm = network_.lock();
    if (!nm || !hasCurrent())
        return;
 
    auto j = msg::makeChatGroupUpdate(currentTableId_, g.id, g.name, g.participants);
 
    if (g.id == generalGroupId_)
    {
        nm->broadcastChatJson(j);
        return;
    }
 
    auto targets = resolvePeerIdsForParticipants(g.participants);
    if (!targets.empty())
        nm->sendChatJsonTo(targets, j);
}

Here is the call graph for this function:

Here is the caller graph for this function:

ensureGeneral()

void ChatManager::ensureGeneral ( )

private

Definition at line 65 of file ChatManager.cpp.

{
    if (groups_.find(generalGroupId_) == groups_.end())
    {
        ChatGroupModel g;
        g.id = generalGroupId_;
        g.name = "General";
        g.ownerUniqueId.clear(); // nobody “owns” General
        groups_.emplace(g.id, std::move(g));
    }
}

Here is the caller graph for this function:

getGroup()

ChatGroupModel * ChatManager::getGroup

(

uint64_t

id

)

Definition at line 238 of file ChatManager.cpp.

{
    auto it = groups_.find(id);
    return it == groups_.end() ? nullptr : &it->second;
}

Here is the caller graph for this function:

getUsernameColor()

ImU32 ChatManager::getUsernameColor ( const std::string & name ) const

private

Definition at line 684 of file ChatManager.cpp.

{
    // C++14-friendly: no init-statement in if
    auto it = nameColorCache_.find(name);
    if (it != nameColorCache_.end())
        return it->second;
 
    // hash -> hue
    std::hash<std::string> H;
    uint64_t hv = H(name) ^ 0x9E3779B97F4A7C15ull;
    float hue = (float)((hv % 10000) / 10000.0f); // [0,1)
 
    // avoid a narrow hue band if desired
    if (hue > 0.12f && hue < 0.18f)
        hue += 0.08f;
    if (hue >= 1.0f)
        hue -= 1.0f;
 
    const float sat = 0.65f;
    const float val = 0.90f;
 
    ImVec4 rgb = HSVtoRGB(hue, sat, val);
    ImU32 col = ImGui::GetColorU32(rgb);
 
    nameColorCache_.emplace(name, col);
    return col;
}

Here is the call graph for this function:

Here is the caller graph for this function:

hasCurrent()

bool ChatManager::hasCurrent ( ) const

inline

Definition at line 59 of file ChatManager.h.

    {
        return currentTableId_ != 0;
    }

Here is the caller graph for this function:

HSVtoRGB()

ImVec4 ChatManager::HSVtoRGB ( float h, float s, float v )

staticprivate

Definition at line 637 of file ChatManager.cpp.

{
    if (s <= 0.0f)
        return ImVec4(v, v, v, 1.0f);
    h = std::fmodf(h, 1.0f) * 6.0f; // [0,6)
    int i = (int)h;
    float f = h - (float)i;
    float p = v * (1.0f - s);
    float q = v * (1.0f - s * f);
    float t = v * (1.0f - s * (1.0f - f));
    float r = 0, g = 0, b = 0;
    switch (i)
    {
        case 0:
            r = v;
            g = t;
            b = p;
            break;
        case 1:
            r = q;
            g = v;
            b = p;
            break;
        case 2:
            r = p;
            g = v;
            b = t;
            break;
        case 3:
            r = p;
            g = q;
            b = v;
            break;
        case 4:
            r = t;
            g = p;
            b = v;
            break;
        default:
            r = v;
            g = p;
            b = q;
            break;
    }
    return ImVec4(r, g, b, 1.0f);
}

Here is the caller graph for this function:

isMeParticipantOf()

bool ChatManager::isMeParticipantOf

(

const ChatGroupModel &

g

)

const

Definition at line 230 of file ChatManager.cpp.

{
    if (!identity_manager)
        return false;
    const std::string meUid = identity_manager->myUniqueId();
    return g.participants.count(meUid) > 0;
}

Here is the caller graph for this function:

loadCurrent()

bool ChatManager::loadCurrent

(

)

Definition at line 190 of file ChatManager.cpp.

{
    if (!hasCurrent())
        return false;
    auto p = chatFilePathFor(currentTableId_, currentTableName_);
    if (!std::filesystem::exists(p))
    {
        ensureGeneral();
        return false;
    }
 
    try
    {
        std::ifstream is(p, std::ios::binary);
        is.seekg(0, std::ios::end);
        auto sz = is.tellg();
        is.seekg(0, std::ios::beg);
        std::vector<uint8_t> buf((size_t)sz);
        if (sz > 0)
            is.read((char*)buf.data(), sz);
        return loadLog(buf);
    }
    catch (...)
    {
        ensureGeneral();
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

loadLog()

bool ChatManager::loadLog ( const std::vector< uint8_t > & buf )

private

Definition at line 114 of file ChatManager.cpp.

{
    size_t off = 0;
    auto magic = Serializer::deserializeString(buf, off);
    if (magic != "RUNIC-CHAT-GROUPS")
        return false;
 
    int version = Serializer::deserializeInt(buf, off);
 
    groups_.clear();
    int count = Serializer::deserializeInt(buf, off);
    for (int i = 0; i < count; ++i)
    {
        ChatGroupModel g;
        g.id = Serializer::deserializeUInt64(buf, off);
        g.name = Serializer::deserializeString(buf, off);
 
        if (version >= 2)
            g.ownerUniqueId = Serializer::deserializeString(buf, off);
        else
        {
            // v1 had ownerPeerId; read it and keep as ownerUniqueId (best-effort: it used to be peerId)
            const std::string legacyOwner = Serializer::deserializeString(buf, off);
            g.ownerUniqueId = legacyOwner; // you can map through IdentityManager if you persisted mapping
        }
 
        int pc = Serializer::deserializeInt(buf, off);
        for (int k = 0; k < pc; ++k)
            g.participants.insert(Serializer::deserializeString(buf, off));
 
        int mc = Serializer::deserializeInt(buf, off);
        for (int m = 0; m < mc; ++m)
        {
            ChatMessageModel msg;
            msg.kind = (ChatMessageModel::Kind)Serializer::deserializeInt(buf, off);
 
            if (version >= 2)
                msg.senderUniqueId = Serializer::deserializeString(buf, off);
            else
                msg.senderUniqueId.clear();
 
            msg.username = Serializer::deserializeString(buf, off);
            msg.content = Serializer::deserializeString(buf, off);
            msg.ts = (double)Serializer::deserializeUInt64(buf, off);
            g.messages.push_back(std::move(msg));
        }
 
        g.unread = (uint32_t)Serializer::deserializeInt(buf, off);
        groups_.emplace(g.id, std::move(g));
    }
 
    ensureGeneral();
    if (groups_.find(activeGroupId_) == groups_.end())
        activeGroupId_ = generalGroupId_;
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

makeGroupIdFromName()

uint64_t ChatManager::makeGroupIdFromName ( const std::string & name ) const

private

Definition at line 220 of file ChatManager.cpp.

{
    std::hash<std::string> H;
    uint64_t id = H(name);
    if (id == 0 || id == generalGroupId_)
        id ^= 0x9E3779B97F4A7C15ull;
    return id;
}

Here is the caller graph for this function:

markGroupRead()

void ChatManager::markGroupRead ( uint64_t groupId )

private

Definition at line 1627 of file ChatManager.cpp.

{
    if (auto* g = getGroup(groupId))
        g->unread = 0;
}

Here is the call graph for this function:

Here is the caller graph for this function:

nowSec()

double ChatManager::nowSec ( )

staticprivate

Definition at line 16 of file ChatManager.cpp.

{
    return (double)std::time(nullptr);
}

Here is the caller graph for this function:

pushMessageLocal()

void ChatManager::pushMessageLocal	(	uint64_t	groupId,
		const std::string &	fromPeer,
		const std::string &	username,
		const std::string &	text,
		double	ts,
		bool	incoming )

Definition at line 381 of file ChatManager.cpp.

{
    ChatMessageModel msg;
    msg.kind = classifyMessage(text);
    msg.username = username;
    msg.content = text;
    msg.ts = ts;
 
    if (incoming)
    {
        // map from transport peer -> stable uniqueId (best effort)
        msg.senderUniqueId = identity_manager ? identity_manager->uniqueForPeer(fromPeer).value_or("Player") : std::string{};
    }
    else
    {
        // local user’s unique id
        msg.senderUniqueId = identity_manager ? identity_manager->myUniqueId() : std::string{};
    }
 
    auto* g = getGroup(groupId);
    if (!g)
    {
        ChatGroupModel stub;
        stub.id = groupId;
        stub.name = "(pending?)";
        groups_.emplace(groupId, std::move(stub));
        g = getGroup(groupId);
    }
 
    g->messages.push_back(std::move(msg));
 
    const bool isActive = (activeGroupId_ == groupId);
    if (!isActive || !chatWindowFocused_ || !followScroll_)
        g->unread = std::min<uint32_t>(g->unread + 1, 999u);
 
    Logger::instance().log("chat", Logger::Level::Info,
                           "LOCAL append gid=" + std::to_string(groupId) + " user=" + username +
                               " text=\"" + text + "\"");
}

Here is the call graph for this function:

Here is the caller graph for this function:

readGroupsFromSnapshotGT()

void ChatManager::readGroupsFromSnapshotGT	(	const std::vector< unsigned char > &	buf,
		size_t &	off )

render()

void ChatManager::render

(

)

Definition at line 604 of file ChatManager.cpp.

{
    if (!hasCurrent())
        return;
 
    ImGui::Begin("ChatWindow");
    chatWindowFocused_ = ImGui::IsWindowFocused(ImGuiFocusedFlags_ChildWindows | ImGuiFocusedFlags_RootWindow);
 
    const float leftWmin = 170.0f;
 
    const float fullW = ImGui::GetContentRegionAvail().x;
    const float fullH = ImGui::GetContentRegionAvail().y;
 
    ImGui::BeginChild("Left", ImVec2(leftWidth_, 0), true, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_AlwaysAutoResize);
    renderLeftPanel(leftWidth_);
    ImGui::EndChild();
 
    ImGui::SameLine();
    ImGui::InvisibleButton("##splitter", ImVec2(6, fullH));
    if (ImGui::IsItemActive())
    {
        leftWidth_ += ImGui::GetIO().MouseDelta.x;
        leftWidth_ = std::clamp(leftWidth_, leftWmin, fullW - 240.0f);
    }
    ImGui::SameLine();
 
    ImGui::BeginChild("Right", ImVec2(0, 0), true, ImGuiWindowFlags_NoScrollbar | ImGuiWindowFlags_AlwaysAutoResize);
    renderRightPanel(leftWidth_);
    ImGui::EndChild();
 
    ImGui::End();
}

Here is the call graph for this function:

renderColoredUsername()

void ChatManager::renderColoredUsername ( const std::string & name ) const

private

Definition at line 712 of file ChatManager.cpp.

{
    const ImU32 col = getUsernameColor(name);
    ImGui::PushStyleColor(ImGuiCol_Text, col);
    ImGui::TextUnformatted(name.c_str());
    ImGui::PopStyleColor();
}

Here is the call graph for this function:

Here is the caller graph for this function:

renderCreateGroupPopup()

void ChatManager::renderCreateGroupPopup ( )

private

Definition at line 1109 of file ChatManager.cpp.

{
    if (ImGui::BeginPopupModal("CreateGroup", nullptr, ImGuiWindowFlags_AlwaysAutoResize))
    {
        ImGui::TextUnformatted("Group name (unique):");
        ImGui::InputText("##gname", newGroupName_.data(), (int)newGroupName_.size());
        UiTypingGuard::TrackThisInput();
        // list peers
        ImGui::Separator();
        ImGui::TextUnformatted("Participants:");
        if (auto nm = network_.lock())
        {
            for (auto& [pid, link] : nm->getPeers())
            {
                // 🔸 map peerId -> uniqueId for selection storage
                std::string uid = identity_manager
                                      ? identity_manager->uniqueForPeer(pid).value_or(std::string{})
                                      : std::string{};
 
                if (uid.empty())
                    continue; // not bound yet; skip or show disabled if you prefer
 
                bool checked = newGroupSel_.count(uid) > 0; // 🔸 store UNIQUE IDs
                const std::string dn = nm->displayNameForPeer(pid);
                std::string label = dn.empty() ? pid : (dn + " (" + pid + ")");
                if (ImGui::Checkbox(label.c_str(), &checked))
                {
                    if (checked)
                        newGroupSel_.insert(uid); // 🔸 insert UID
                    else
                        newGroupSel_.erase(uid); // 🔸 erase UID
                }
            }
        }
 
        // ensure name unique
        bool nameTaken = false;
        std::string desired = newGroupName_.data();
        if (!desired.empty())
        {
            for (auto& [id, g] : groups_)
                if (g.name == desired)
                {
                    nameTaken = true;
                    break;
                }
        }
 
        ImGui::Separator();
        ImGui::BeginDisabled(desired.empty() || nameTaken);
        if (ImGui::Button("Create"))
        {
            ChatGroupModel g;
            g.name = desired;
            g.id = makeGroupIdFromName(g.name);
            g.participants = newGroupSel_; // 🔸 UNIQUE IDs
 
            if (identity_manager)
            {
                g.ownerUniqueId = identity_manager->myUniqueId();
                if (!g.ownerUniqueId.empty())
                    g.participants.insert(g.ownerUniqueId); // 🔸 owner always included (solo OK)
            }
 
            groups_.emplace(g.id, g);
            emitGroupCreate(g);
 
            activeGroupId_ = g.id;
            markGroupRead(g.id);
            focusInput_ = true;
            followScroll_ = true;
 
            newGroupSel_.clear();
            newGroupName_.fill('\0');
            ImGui::CloseCurrentPopup();
        }
        ImGui::EndDisabled();
 
        if (nameTaken)
            ImGui::TextColored(ImVec4(1, 0.4f, 0.2f, 1), "A group with that name already exists.");
 
        ImGui::SameLine();
        if (ImGui::Button("Cancel"))
        {
            newGroupSel_.clear();
            newGroupName_.fill('\0');
            ImGui::CloseCurrentPopup();
        }
        ImGui::EndPopup();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

renderDeleteGroupPopup()

void ChatManager::renderDeleteGroupPopup ( )

private

Definition at line 1448 of file ChatManager.cpp.

{
    if (ImGui::BeginPopupModal("DeleteGroup", nullptr, ImGuiWindowFlags_AlwaysAutoResize))
    {
        ImGui::TextUnformatted("Manage groups you participate in (General cannot be deleted/left).");
        ImGui::Separator();
 
        // Who am I and am I GM?
        std::string meUid = identity_manager ? identity_manager->myUniqueId() : "";
        bool iAmGM = false;
        if (auto nm = network_.lock())
        {
            // Use the accessor you actually have: getGMId() / gmId() / GMId() — pick the right one.
            // If your NetworkManager exposes a different name, change here only.
            const std::string gmUid = nm->getGMId(); // <-- adjust if needed in your codebase
            iAmGM = (!gmUid.empty() && !meUid.empty() && gmUid == meUid);
        }
 
        for (auto it = groups_.begin(); it != groups_.end(); /* ++ inside */)
        {
            const uint64_t id = it->first;
            ChatGroupModel& g = it->second;
 
            // Skip General
            if (id == generalGroupId_)
            {
                ++it;
                continue;
            }
 
            // Only show groups where I’m currently a participant (so I can Leave/Delete)
            const bool iParticipate = isMeParticipantOf(g);
 
            // Compute permissions
            const bool isOwner = (!g.ownerUniqueId.empty() && g.ownerUniqueId == meUid);
            const bool canDelete = isOwner;
            const bool canLeave = (iParticipate && !isOwner); // owners cannot leave by rule
 
            ImGui::PushID((int)id);
 
            // Row label
            ImGui::TextUnformatted(g.name.c_str());
            ImGui::SameLine();
 
            // DELETE button
            ImGui::BeginDisabled(!canDelete);
            if (ImGui::Button("Delete"))
            {
                // Emit delete to participants
                emitGroupDelete(id);
 
                // Remove locally
                if (activeGroupId_ == id)
                    activeGroupId_ = generalGroupId_;
                it = groups_.erase(it);
 
                ImGui::PopID();
                continue; // skip ++it
            }
            ImGui::EndDisabled();
 
            ImGui::SameLine();
 
            // LEAVE button
            ImGui::BeginDisabled(!canLeave);
            if (ImGui::Button("Leave"))
            {
                emitGroupLeave(id);
 
                // If I’m no longer a participant, optionally hide it locally right away
                if (!isMeParticipantOf(g))
                {
                    if (activeGroupId_ == id)
                        activeGroupId_ = generalGroupId_;
                    it = groups_.erase(it);
                    ImGui::PopID();
                    continue; // skip ++it
                }
            }
            ImGui::EndDisabled();
 
            // Helper hints
            if (!iParticipate)
            {
                ImGui::SameLine();
                ImGui::TextDisabled("(not a participant)");
            }
            else if (isOwner)
            {
                ImGui::SameLine();
                ImGui::TextDisabled("(owner)");
            }
            else if (iAmGM)
            {
                ImGui::SameLine();
                ImGui::TextDisabled("(GM)");
            }
 
            ImGui::PopID();
            ++it;
        }
 
        ImGui::Separator();
        if (ImGui::Button("Close"))
            ImGui::CloseCurrentPopup();
        ImGui::EndPopup();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

renderDicePopup()

void ChatManager::renderDicePopup ( )

private

Definition at line 1557 of file ChatManager.cpp.

{
    if (ImGui::BeginPopup("DiceRoller"))
    {
        ImGui::TextUnformatted("Dice Roller");
        ImGui::Separator();
 
        ImGui::InputInt("Number", &diceN_);
        UiTypingGuard::TrackThisInput();
        ImGui::InputInt("Sides", &diceSides_);
        UiTypingGuard::TrackThisInput();
        ImGui::InputInt("Modifier", &diceMod_);
        UiTypingGuard::TrackThisInput();
        ImGui::Checkbox("Apply modifier per die", &diceModPerDie_);
 
        if (ImGui::Button("d4"))
            diceSides_ = 4;
        ImGui::SameLine();
        if (ImGui::Button("d6"))
            diceSides_ = 6;
        ImGui::SameLine();
        if (ImGui::Button("d8"))
            diceSides_ = 8;
        ImGui::SameLine();
        if (ImGui::Button("d10"))
            diceSides_ = 10;
        ImGui::SameLine();
        if (ImGui::Button("d12"))
            diceSides_ = 12;
        ImGui::SameLine();
        if (ImGui::Button("d20"))
            diceSides_ = 20;
 
        ImGui::Separator();
        if (ImGui::Button("Roll"))
        {
            //int N = std::max(1, diceN_);
            //int M = std::max(1, diceSides_);
            //int K = diceModPerDie_ ? (diceMod_ * N) : diceMod_;
            //std::string text = "/roll " + std::to_string(N) + "d" + std::to_string(M) +
            //                   (K > 0 ? "+" + std::to_string(K) : (K < 0 ? std::string("-") + std::to_string(-K) : ""));
            //auto nm = network_.lock();
            //std::string uname = nm ? nm->getMyUsername() : "me";
            //if (uname.empty())
            //    uname = "me";
            // build slash command
            int mod = diceMod_;
            int N = std::max(1, diceN_);
            int M = std::max(1, diceSides_);
            // If per-die modifier, convert into +K where K = modifier * N for the final text.
            int K = diceModPerDie_ ? (mod * N) : mod;
            std::string cmd = "/roll " + std::to_string(N) + "d" + std::to_string(M);
            if (K > 0)
                cmd += "+" + std::to_string(K);
            else if (K < 0)
                cmd += "-" + std::to_string(-K);
            tryHandleSlashCommand(activeGroupId_, cmd);
 
            ImGui::CloseCurrentPopup();
        }
        ImGui::SameLine();
        if (ImGui::Button("Cancel"))
            ImGui::CloseCurrentPopup();
 
        ImGui::EndPopup();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

renderEditGroupPopup()

void ChatManager::renderEditGroupPopup ( )

private

Definition at line 1298 of file ChatManager.cpp.

{
    if (ImGui::BeginPopupModal("EditGroup", nullptr, ImGuiWindowFlags_AlwaysAutoResize))
    {
        ChatGroupModel* g = getGroup(editGroupId_);
        if (!g)
        {
            ImGui::TextDisabled("Group not found.");
            if (ImGui::Button("Close"))
                ImGui::CloseCurrentPopup();
            ImGui::EndPopup();
            return;
        }
 
        // Optional: only owner can edit
        auto nm = network_.lock();
        const std::string meUid = identity_manager ? identity_manager->myUniqueId() : "";
        const bool ownerOnly = true;
        const bool canEdit = !ownerOnly || (!g->ownerUniqueId.empty() && g->ownerUniqueId == meUid);
        if (!canEdit)
            ImGui::TextColored(ImVec4(1, 0.5f, 0.3f, 1), "Only the owner can edit this group.");
 
        ImGui::Separator();
        ImGui::TextUnformatted("Group name:");
        ImGui::BeginDisabled(!canEdit);
        ImGui::InputText("##edit_gname", editGroupName_.data(), (int)editGroupName_.size());
        UiTypingGuard::TrackThisInput();
        ImGui::EndDisabled();
 
        // Participants list (pre-checked)
        ImGui::Separator();
        ImGui::TextUnformatted("Participants:");
        if (nm)
        {
            ImGui::BeginDisabled(!canEdit);
            for (auto& [pid, link] : nm->getPeers())
            {
                // 🔸 map peerId -> uniqueId for selection storage
                std::string uid = identity_manager
                                      ? identity_manager->uniqueForPeer(pid).value_or(std::string{})
                                      : std::string{};
 
                if (uid.empty())
                    continue;
 
                bool checked = editGroupSel_.count(uid) > 0; // 🔸 use UID
                const std::string dn = nm->displayNameForPeer(pid);
                std::string label = dn.empty() ? pid : (dn + " (" + pid + ")");
                if (ImGui::Checkbox(label.c_str(), &checked))
                {
                    if (checked)
                        editGroupSel_.insert(uid); // 🔸 insert UID
                    else
                        editGroupSel_.erase(uid); // 🔸 erase UID
                }
            }
            ImGui::EndDisabled();
        }
 
        // Validate (unique name unless unchanged)
        bool nameTaken = false;
        const std::string desired = editGroupName_.data();
        if (desired.empty() == false && desired != g->name)
        {
            for (auto& [id, gg] : groups_)
                if (gg.name == desired)
                {
                    nameTaken = true;
                    break;
                }
        }
        if (nameTaken)
            ImGui::TextColored(ImVec4(1, 0.4f, 0.2f, 1), "A group with that name already exists.");
 
        ImGui::Separator();
        ImGui::BeginDisabled(!canEdit || desired.empty() || nameTaken);
        if (ImGui::Button("Update", ImVec2(120, 0)))
        {
            // Apply local changes
            g->name = desired;
            g->participants = editGroupSel_; // 🔸 UNIQUE IDs
 
            // Broadcast update
            emitGroupUpdate(*g);
 
            // nice UX
            activeGroupId_ = g->id;
            markGroupRead(g->id);
            focusInput_ = true;
            followScroll_ = true;
 
            ImGui::CloseCurrentPopup();
        }
        ImGui::EndDisabled();
 
        ImGui::SameLine();
        if (ImGui::Button("Close", ImVec2(120, 0)))
            ImGui::CloseCurrentPopup();
 
        ImGui::EndPopup();
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

renderLeftPanel()

void ChatManager::renderLeftPanel ( float width )

private

Definition at line 803 of file ChatManager.cpp.

{
    // Top actions
    if (ImGui::Button("New Group"))
        openCreatePopup_ = true;
    ImGui::SameLine();
    if (ImGui::Button("Delete Group"))
        openDeletePopup_ = true;
 
    // Enable edit only when there is a non-General active group
    bool canEdit = (activeGroupId_ != 0 && activeGroupId_ != generalGroupId_);
    ImGui::BeginDisabled(!canEdit);
    if (ImGui::Button("Edit Group"))
    {
        // seed edit state from the active group
        if (auto* g = getGroup(activeGroupId_))
        {
            editGroupId_ = g->id;
            editGroupSel_ = g->participants;
            std::fill(editGroupName_.begin(), editGroupName_.end(), '\0');
            std::snprintf(editGroupName_.data(), (int)editGroupName_.size(), "%s", g->name.c_str());
            openEditPopup_ = true;
        }
    }
 
    ImGui::EndDisabled();
 
    ImGui::Separator();
    ImGui::TextUnformatted("Chat Groups");
    ImGui::Separator();
 
    // Sorted by name; General at top
    std::vector<uint64_t> order;
    order.reserve(groups_.size());
    for (auto& [id, _] : groups_)
        order.push_back(id);
    std::sort(order.begin(), order.end(), [&](uint64_t a, uint64_t b)
              {
        if (a == generalGroupId_) return true;
        if (b == generalGroupId_) return false;
        return groups_[a].name < groups_[b].name; });
 
    for (auto id : order)
    {
        auto& g = groups_[id];
        const bool selected = (activeGroupId_ == id);
 
        ImGui::PushID((int)id);
        if (ImGui::Selectable(g.name.c_str(), selected, ImGuiSelectableFlags_SpanAllColumns, ImVec2(0, 0)))
        {
            activeGroupId_ = id;
            markGroupRead(id);
            focusInput_ = true;
            followScroll_ = true;
        }
 
        if (g.unread > 0)
        {
            ImVec2 min = ImGui::GetItemRectMin();
            ImVec2 max = ImGui::GetItemRectMax();
            ImVec2 size(max.x - min.x, max.y - min.y);
 
            char buf[16];
            if (g.unread < 100)
                std::snprintf(buf, sizeof(buf), "%u", g.unread);
            else
                std::snprintf(buf, sizeof(buf), "99+");
 
            ImVec2 txtSize = ImGui::CalcTextSize(buf);
            const float padX = 6.f, padY = 3.f;
            const float radius = (txtSize.y + padY * 2.f) * 0.5f;
            const float marginRight = 8.f;
            ImVec2 center(max.x - marginRight - radius, min.y + size.y * 0.5f);
 
            auto* dl = ImGui::GetWindowDrawList();
            ImU32 bg = ImGui::GetColorU32(ImVec4(0.10f, 0.70f, 0.30f, 1.0f));
            ImU32 fg = ImGui::GetColorU32(ImVec4(1, 1, 1, 1));
 
            ImVec2 badgeMin(center.x - std::max(radius, txtSize.x * 0.5f + padX), center.y - radius);
            ImVec2 badgeMax(center.x + std::max(radius, txtSize.x * 0.5f + padX), center.y + radius);
            dl->AddRectFilled(badgeMin, badgeMax, bg, radius);
            ImVec2 textPos(center.x - txtSize.x * 0.5f, center.y - txtSize.y * 0.5f);
            dl->AddText(textPos, fg, buf);
        }
        ImGui::PopID();
    }
 
    if (openCreatePopup_)
    {
        openCreatePopup_ = false;
        ImGui::OpenPopup("CreateGroup");
    }
    renderCreateGroupPopup();
 
    if (openDeletePopup_)
    {
        openDeletePopup_ = false;
        ImGui::OpenPopup("DeleteGroup");
    }
    renderDeleteGroupPopup();
 
    if (openEditPopup_)
    {
        openEditPopup_ = false;
        ImGui::OpenPopup("EditGroup");
    }
    renderEditGroupPopup();
}

Here is the call graph for this function:

Here is the caller graph for this function:

renderPlainMessage()

void ChatManager::renderPlainMessage ( const std::string & text ) const

private

Definition at line 720 of file ChatManager.cpp.

{
    ImGui::TextWrapped("%s", text.c_str());
}

Here is the caller graph for this function:

renderRightPanel()

void ChatManager::renderRightPanel ( float leftPanelWidth )

private

Definition at line 912 of file ChatManager.cpp.

{
    auto* g = getGroup(activeGroupId_);
    const float footerRowH = ImGui::GetFrameHeightWithSpacing() * 2.0f;
 
    ImVec2 avail = ImGui::GetContentRegionAvail();
    ImGui::BeginChild("Messages", ImVec2(0, avail.y - footerRowH), true, ImGuiWindowFlags_AlwaysVerticalScrollbar);
    if (g)
    {
        if (ImGui::GetScrollY() < ImGui::GetScrollMaxY() - 1.0f)
            followScroll_ = false;
 
        for (auto& m : g->messages)
        {
            renderColoredUsername(m.username);
 
            // separator
            ImGui::SameLine(0.0f, 6.0f);
            ImGui::TextUnformatted("-");
            ImGui::SameLine(0.0f, 6.0f);
 
            // message (wrapped). Put it in a child region so the wrap can use full width if you want,
            // but simplest is to just call TextWrapped now:
            // ensure we start from current cursor X (SameLine set it)
            ImGui::PushTextWrapPos(0);
            renderPlainMessage(m.content);
            ImGui::PopTextWrapPos();
        }
        if (followScroll_)
            ImGui::SetScrollHereY(1.0f);
        if (jumpToBottom_)
        {
            ImGui::SetScrollHereY(1.0f);
            jumpToBottom_ = false;
        }
    }
    ImGui::EndChild();
 
    // Footer input
    ImGui::BeginChild("Footer", ImVec2(0, 0), false, ImGuiWindowFlags_AlwaysAutoResize);
 
    if (focusInput_)
    {
        ImGui::SetKeyboardFocusHere();
        focusInput_ = false;
    }
 
    ImGuiInputTextFlags flags = ImGuiInputTextFlags_EnterReturnsTrue | ImGuiInputTextFlags_AllowTabInput;
    if (ImGui::InputText("##chat_input", input_.data(), (int)input_.size(), flags))
    {
        std::string text(input_.data());
        if (!text.empty() && g)
        {
            const uint64_t ts = (uint64_t)nowSec();
            auto nm = network_.lock();
            auto uname = nm ? nm->getMyUsername() : std::string("me");
            if (uname.empty())
                uname = "me";
 
            if (!text.empty() && text[0] == '/')
            {
                tryHandleSlashCommand(activeGroupId_, text);
            }
            else
            {
                emitChatMessageFrame(g->id, uname, text, ts);
                pushMessageLocal(g->id, "me", uname, text, (double)ts, false);
            }
 
            input_.fill('\0');
            followScroll_ = true;
            focusInput_ = true;
            markGroupRead(g->id);
        }
    }
    UiTypingGuard::TrackThisInput();
    ImGui::SameLine();
    if (ImGui::Button("Send") && g)
    {
        std::string text(input_.data());
        if (!text.empty())
        {
            const uint64_t ts = (uint64_t)nowSec();
            auto nm = network_.lock();
            auto uname = nm ? nm->getMyUsername() : std::string("me");
            if (uname.empty())
                uname = "me";
 
            emitChatMessageFrame(g->id, uname, text, ts);
            pushMessageLocal(g->id, "me", uname, text, (double)ts, false);
 
            input_.fill('\0');
            followScroll_ = true;
            markGroupRead(g->id);
        }
    }
 
    ImGui::BeginDisabled(followScroll_);
    if (ImGui::Button("Go to bottom"))
    {
        jumpToBottom_ = true;
    }
    ImGui::EndDisabled();
    ImGui::SameLine();
    if (ImGui::Button("Roll Dice"))
    {
        openDicePopup_ = true;
    }
    if (openDicePopup_)
    {
        openDicePopup_ = false;
        ImGui::OpenPopup("DiceRoller");
    }
    renderDicePopup();
 
    ImGui::EndChild();
}

Here is the call graph for this function:

Here is the caller graph for this function:

replaceUsernameForUnique()

void ChatManager::replaceUsernameForUnique	(	const std::string &	uniqueId,
		const std::string &	newUsername )

Definition at line 566 of file ChatManager.cpp.

{
    // update cached labels in message history for this author
    for (auto& [gid, g] : groups_)
    {
        // optional: if you show "owner" anywhere:
        if (g.ownerUniqueId == uniqueId)
        {
            // no change to g.name; but if you render "owned by X", use identity_ at draw time.
        }
 
        for (auto& m : g.messages)
        {
            if (m.senderUniqueId == uniqueId)
                m.username = newUsername; // cached label shown in UI
        }
    }
}

resolvePeerIdsForParticipants()

std::set< std::string > ChatManager::resolvePeerIdsForParticipants

(

const std::set< std::string > &

participantUids

)

const

Definition at line 549 of file ChatManager.cpp.

{
    std::set<std::string> out;
    auto nm = network_.lock();
    if (!nm || !identity_manager)
        return out;
 
    for (const auto& uid : participantUids)
    {
        if (auto pid = identity_manager->peerForUnique(uid); pid && !pid->empty())
        {
            out.insert(*pid);
        }
    }
    return out;
}

Here is the caller graph for this function:

saveCurrent()

bool ChatManager::saveCurrent

(

)

Definition at line 171 of file ChatManager.cpp.

{
    if (!hasCurrent())
        return false;
    try
    {
        std::vector<uint8_t> buf;
        saveLog(buf);
        auto p = chatFilePathFor(currentTableId_, currentTableName_);
        std::ofstream os(p, std::ios::binary | std::ios::trunc);
        os.write((const char*)buf.data(), (std::streamsize)buf.size());
        return true;
    }
    catch (...)
    {
        return false;
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

saveLog()

bool ChatManager::saveLog ( std::vector< uint8_t > & buf ) const

private

Definition at line 85 of file ChatManager.cpp.

{
    Serializer::serializeString(buf, "RUNIC-CHAT-GROUPS");
    Serializer::serializeInt(buf, 2); // <— version 2
 
    Serializer::serializeInt(buf, (int)groups_.size());
    for (auto& [id, g] : groups_)
    {
        Serializer::serializeUInt64(buf, g.id);
        Serializer::serializeString(buf, g.name);
        Serializer::serializeString(buf, g.ownerUniqueId); // <— changed
 
        Serializer::serializeInt(buf, (int)g.participants.size());
        for (auto& p : g.participants)
            Serializer::serializeString(buf, p); // your set contents (uniqueIds recommended)
 
        Serializer::serializeInt(buf, (int)g.messages.size());
        for (auto& m : g.messages)
        {
            Serializer::serializeInt(buf, (int)m.kind);
            Serializer::serializeString(buf, m.senderUniqueId); // <— NEW in v2
            Serializer::serializeString(buf, m.username);
            Serializer::serializeString(buf, m.content);
            Serializer::serializeUInt64(buf, (uint64_t)m.ts);
        }
        Serializer::serializeInt(buf, (int)g.unread);
    }
    return true;
}

Here is the call graph for this function:

Here is the caller graph for this function:

setActiveGameTable()

void ChatManager::setActiveGameTable	(	uint64_t	tableId,
		const std::string &	gameTableName )

Definition at line 48 of file ChatManager.cpp.

{
    if (currentTableId_ != 0)
        saveCurrent();
    currentTableId_ = tableId;
    currentTableName_ = gameTableName;
 
    groups_.clear();
    ensureGeneral();
 
    loadCurrent(); // will merge/overwrite groups_ from disk
 
    activeGroupId_ = generalGroupId_;
    focusInput_ = true;
    followScroll_ = true;
}

Here is the call graph for this function:

setNetwork()

void ChatManager::setNetwork

(

std::weak_ptr< NetworkManager >

nm

)

Definition at line 42 of file ChatManager.cpp.

{
    network_ = std::move(nm);
}

tryHandleSlashCommand()

void ChatManager::tryHandleSlashCommand	(	uint64_t	threadId,
		const std::string &	input )

Definition at line 725 of file ChatManager.cpp.

{
    // /roll NdM(+K)  e.g., /roll 4d6+2  or /roll 1d20-5
    if (input.rfind("/roll", 0) != 0)
        return;
 
    auto nm = network_.lock();
    if (!nm)
        return;
    auto uname = nm->getMyUsername();
    if (uname.empty())
        uname = "me";
 
    auto parseInt = [](const std::string& s, size_t& i) -> int
    {
        int v = 0;
        bool any = false;
        while (i < s.size() && std::isdigit((unsigned char)s[i]))
        {
            any = true;
            v = v * 10 + (s[i] - '0');
            ++i;
        }
        return any ? v : -1;
    };
 
    size_t i = 5;
    while (i < input.size() && std::isspace((unsigned char)input[i]))
        ++i;
 
    int N = parseInt(input, i);
    if (i >= input.size() || input[i] != 'd' || N <= 0)
    { /*invalid*/
        return;
    }
    ++i;
    int M = parseInt(input, i);
    if (M <= 0)
        return;
 
    int K = 0;
    if (i < input.size() && (input[i] == '+' || input[i] == '-'))
    {
        bool neg = (input[i] == '-');
        ++i;
        int Z = parseInt(input, i);
        if (Z > 0)
            K = neg ? -Z : Z;
    }
 
    std::mt19937 rng((uint32_t)std::random_device{}());
    std::uniform_int_distribution<int> dist(1, std::max(1, M));
 
    int total = 0;
    std::string rolls;
    for (int r = 0; r < N; ++r)
    {
        int die = dist(rng);
        total += die;
        if (!rolls.empty())
            rolls += ", ";
        rolls += std::to_string(die);
    }
 
    // This command outputs as a chat message from "me"
    const int modApplied = K;
    const int finalTotal = total + modApplied;
 
    const std::string text = "rolled " + std::to_string(N) + "d" + std::to_string(M) +
                             (diceModPerDie_ ? " (per-die mod " : " (mod ") +
                             std::to_string(modApplied) + ")" +
                             " => [" + rolls + "] = " + std::to_string(finalTotal);
 
    const uint64_t ts = (uint64_t)nowSec();
    emitChatMessageFrame(threadId, uname, text, ts);
    pushMessageLocal(threadId, "me", uname, text, (double)ts, /*incoming*/ false);
}

Here is the call graph for this function:

Here is the caller graph for this function:

writeGroupsToSnapshotGT()

void ChatManager::writeGroupsToSnapshotGT

(

std::vector< unsigned char > &

buf

)

const

Member Data Documentation

activeGroupId_

uint64_t ChatManager::activeGroupId_ = generalGroupId_

private

Definition at line 106 of file ChatManager.h.

chatWindowFocused_

bool ChatManager::chatWindowFocused_ = false

private

Definition at line 113 of file ChatManager.h.

currentTableId_

uint64_t ChatManager::currentTableId_ = 0

Definition at line 90 of file ChatManager.h.

currentTableName_

std::string ChatManager::currentTableName_

Definition at line 91 of file ChatManager.h.

diceMod_

int ChatManager::diceMod_ = 0

private

Definition at line 133 of file ChatManager.h.

diceModPerDie_

bool ChatManager::diceModPerDie_ = false

private

Definition at line 134 of file ChatManager.h.

diceN_

int ChatManager::diceN_ = 1

private

Definition at line 131 of file ChatManager.h.

diceSides_

int ChatManager::diceSides_ = 20

private

Definition at line 132 of file ChatManager.h.

editGroupId_

uint64_t ChatManager::editGroupId_ = 0

private

Definition at line 126 of file ChatManager.h.

editGroupName_

std::array<char, 128> ChatManager::editGroupName_ {}

private

Definition at line 127 of file ChatManager.h.

{};

editGroupSel_

std::set<std::string> ChatManager::editGroupSel_

private

Definition at line 128 of file ChatManager.h.

focusInput_

bool ChatManager::focusInput_ = false

private

Definition at line 110 of file ChatManager.h.

followScroll_

bool ChatManager::followScroll_ = true

private

Definition at line 111 of file ChatManager.h.

generalGroupId_

constexpr uint64_t ChatManager::generalGroupId_ = 1

staticconstexpr

Definition at line 89 of file ChatManager.h.

groups_

std::unordered_map<uint64_t, ChatGroupModel> ChatManager::groups_

private

Definition at line 105 of file ChatManager.h.

identity_manager

std::shared_ptr<IdentityManager> ChatManager::identity_manager

private

Definition at line 102 of file ChatManager.h.

input_

std::array<char, 512> ChatManager::input_ {}

private

Definition at line 109 of file ChatManager.h.

{};

jumpToBottom_

bool ChatManager::jumpToBottom_ = false

private

Definition at line 112 of file ChatManager.h.

leftWidth_

float ChatManager::leftWidth_ = 170.0f

private

Definition at line 123 of file ChatManager.h.

nameColorCache_

std::unordered_map<std::string, ImU32> ChatManager::nameColorCache_

mutableprivate

Definition at line 143 of file ChatManager.h.

network_

std::weak_ptr<NetworkManager> ChatManager::network_

private

Definition at line 137 of file ChatManager.h.

newGroupName_

std::array<char, 128> ChatManager::newGroupName_ {}

private

Definition at line 121 of file ChatManager.h.

{};

newGroupSel_

std::set<std::string> ChatManager::newGroupSel_

private

Definition at line 122 of file ChatManager.h.

openCreatePopup_

bool ChatManager::openCreatePopup_ = false

private

Definition at line 116 of file ChatManager.h.

openDeletePopup_

bool ChatManager::openDeletePopup_ = false

private

Definition at line 117 of file ChatManager.h.

openDicePopup_

bool ChatManager::openDicePopup_ = false

private

Definition at line 118 of file ChatManager.h.

openEditPopup_

bool ChatManager::openEditPopup_ = false

private

Definition at line 125 of file ChatManager.h.

---

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

• include/ChatManager.h
• src/ChatManager.cpp