chat.h

Go to the documentation of this file.

#pragma once

#include "../Common/server.h" // MAX_ONLINEPLAYERS

#include <vector>

#define STORE_CHAT_SIZE 271 // includes 255 plus handle12, brackets2, colon1, space1
#define FORMAT_LINES 256 // controls how many we build for display in a vector, could be more because they are multi-line

class CHATCHANNEL
{
public:
        unsigned char seqplayer[MAX_ONLINEPLAYERS]; // sequential list of players
        bool dndplayer[MAX_ONLINEPLAYERS];
        short players;

        void AddPlayer(unsigned char tempplayer)
        {
                dndplayer[players] = false; // eventually retrieve this from the people manager persistent data
                seqplayer[players] = tempplayer;
                players++;
        }

        void RemovePlayer(short tempplayer)
        {
                short index = -1;
                for (short t = 0; t < players; t++)
                {
                        if (seqplayer[t] == tempplayer)
                        {
                                index = t;
                                break;
                        }
                }
                if (index == -1)
                        return;

                for (short t = index; t < players - 1; t++)
                {
                        seqplayer[t] = seqplayer[t + 1];
                        dndplayer[t] = dndplayer[t + 1];
                }
                players--;
        }

        // so we store all the chats as an array, one per element
        std::vector<std::wstring> chatline;
        std::vector<std::string> chatlineplayer;
        // we go through that list to make another array that has chatlinereference or placeholder based on width
        // ie                         |
        // [reskin]: howdy doody fresh and fruity
        // becomes
        // [reskin]: howdy doody fresh
        // BLANK LINE for and fruity
        std::vector<std::wstring> formatchatline;
        std::vector<std::string> formatchatlineplayer;
        unsigned char channel, owner; // which channel does this tab transmit/receive on
        bool dnd;
        WCHAR title[MAX_TAB_CHARS - 5] = {0};

        void RefreshChat(long columnWidth, int fontWidth)
        {
                const size_t maxChars = min(columnWidth / fontWidth, HELP_SIZE - 1);

                formatchatline.clear();
                formatchatlineplayer.clear();

                const auto totalLines = chatline.size();
                const auto start = static_cast<size_t>(max(0, (int)totalLines - FORMAT_LINES));
                for (auto pos = start; pos < totalLines; pos++) // these are all the chat lines in the backlog
                {
                        assert(pos < chatlineplayer.size());
                        formatchatlineplayer.emplace_back(chatlineplayer.at(pos));
                        
                        UINT startIndex = 0;
                        do
                        {
                                if (startIndex != 0) formatchatlineplayer.emplace_back("");
                                std::basic_string<wchar_t> substr = chatline.at(pos).substr(startIndex, maxChars);
                                if (substr.at(0) == 32)
                                {
                                        startIndex++;
                                        substr = chatline.at(pos).substr(startIndex, maxChars);
                                }

                                int backup = 0;
                                const size_t length = substr.length();
                                if (length == maxChars)
                                {
                                        size_t space = substr.find_last_of(L' '); // npos
                                        size_t hyphen = substr.find_last_of(L'-'); // 63
                                        if (space == std::string::npos) space = 0;
                                        if (hyphen == std::string::npos) hyphen = 0; else hyphen++;
                                        backup = length - max(space, hyphen); // so 128 - 110 = 18 which is within 20
                                        if (backup > 20)
                                                backup = 0;
                                }

                                formatchatline.emplace_back(substr.substr(0, length - backup));
                                startIndex += maxChars - backup;

                        } while (startIndex < chatline.at(pos).length());
                }
        }

        CHATCHANNEL()
        {
                channel = 0;
                owner = 0;
                players = 0;
                dnd = false;
                ZeroMemory(seqplayer, MAX_ONLINEPLAYERS);
                ZeroMemory(dndplayer, MAX_ONLINEPLAYERS);
        }
};