Bağırmada Sahte Bot Sistemi

#include "stdafx.h"
#include "char.h"
#include "char_manager.h"
#include "utils.h"
#include <fstream>
#include <string>
#include <vector>
#include <thread>
#include <chrono>
#include <unordered_map>
#include <atomic>
#include <algorithm>
#include <random>

struct FakeMessage
{
    std::string char_name;
    std::string message;
};

static std::vector<FakeMessage> g_fake_messages;
static std::unordered_map<std::string, CHARACTER*> g_dummy_characters;

static std::atomic<bool> g_auto_shout_enabled{ true };
static std::thread g_shout_thread;
static std::atomic<bool> g_thread_running{ false };

static const std::string g_txt_path = "/home/game/sahte_mesaj.txt";

void LoadFakeMessages()
{
    g_fake_messages.clear();

    std::ifstream file(g_txt_path);
    if (!file.is_open())
    {
        sys_err("SAHTE_MESAJ: Dosya acilamadi: %s", g_txt_path.c_str());
        return;
    }

    std::string line;
    while (std::getline(file, line))
    {
        size_t space_pos = line.find(' ');
        if (space_pos != std::string::npos)
        {
            std::string name = line.substr(0, space_pos);
            std::string msg = line.substr(space_pos + 1);

            if (!name.empty() && !msg.empty())
                g_fake_messages.push_back({ name, msg });
        }
    }

    sys_log(0, "SAHTE_MESAJ: %zu sahte mesaj yüklendi.", g_fake_messages.size());
}

CHARACTER* CreateDummyCharacter(const std::string& charName)
{
    auto it = g_dummy_characters.find(charName);
    if (it != g_dummy_characters.end())
        return it->second;

    CHARACTER_MANAGER& chm = CHARACTER_MANAGER::instance();
    CHARACTER* ch = chm.CreateCharacter();
    if (!ch)
    {
        sys_err("SAHTE_MESAJ: Dummy karakter yaratılamadı: %s", charName.c_str());
        return nullptr;
    }

    ch->SetName(charName.c_str());
    ch->SetDummy(true);
    ch->SetInvisible(true);
    ch->WarpSet(0, 100, 100);

    g_dummy_characters[charName] = ch;
    sys_log(0, "SAHTE_MESAJ: Dummy yaratıldı: %s", charName.c_str());
    return ch;
}

void SendFakeShout(const FakeMessage& fm)
{
    if (!g_auto_shout_enabled)
        return;

    CHARACTER* ch = CreateDummyCharacter(fm.char_name);
    if (ch)
    {
        ch->ChatPacket(CHAT_TYPE_SHOUT, fm.message.c_str());
        sys_log(0, "SAHTE_MESAJ: %s -> %s", fm.char_name.c_str(), fm.message.c_str());
    }
}

void AutoShoutLoop()
{
    LoadFakeMessages();

    g_thread_running = true;

    std::random_device rd;
    std::mt19937 g(rd());

    while (g_auto_shout_enabled)
    {
        std::vector<FakeMessage> shuffled = g_fake_messages;
        std::shuffle(shuffled.begin(), shuffled.end(), g);

        for (const auto& fm : shuffled)
        {
            SendFakeShout(fm);
            std::this_thread::sleep_for(std::chrono::milliseconds(100));
        }

        for (int i = 0; i < 15 && g_auto_shout_enabled; ++i)
            std::this_thread::sleep_for(std::chrono::seconds(1));
    }

    g_thread_running = false;
}

void StartAutoShout()
{
    if (g_thread_running)
        return;

    g_auto_shout_enabled = true;
    g_shout_thread = std::thread(AutoShoutLoop);
    g_shout_thread.detach();
}

void StopAutoShout()
{
    g_auto_shout_enabled = false;

    int wait = 0;
    while (g_thread_running && wait++ < 20)
        std::this_thread::sleep_for(std::chrono::milliseconds(100));
}

bool DummyCharacterRecvPrivateMessage(CHARACTER* ch, const char* fromName, const char* message)
{
    std::string chName = ch->GetName();

    if (g_dummy_characters.find(chName) != g_dummy_characters.end())
    {
        sys_log(0, "SAHTE_MESAJ PM (ignored): %s -> %s : %s", fromName, chName.c_str(), message);
        return true;
    }

    return false;
}

bool HandleAutoShoutCommand(CHARACTER* ch, const char* cmd)
{
    if (!ch->IsGM())
        return false;

    std::string command(cmd);

    if (command == "/reloadsahtemesaj")
    {
        LoadFakeMessages();
        ch->ChatPacket(CHAT_TYPE_INFO, "Sahte mesaj listesi yeniden yüklendi.");
        return true;
    }
    else if (command == "/sahtemesaj start")
    {
        StartAutoShout();
        ch->ChatPacket(CHAT_TYPE_INFO, "Sahte mesaj sistemi başlatıldı.");
        return true;
    }
    else if (command == "/sahtemesaj stop")
    {
        StopAutoShout();
        ch->ChatPacket(CHAT_TYPE_INFO, "Sahte mesaj sistemi durduruldu.");
        return true;
    }

    return false;
}

Char cpp Arat
bool do_chat(CHARACTER* ch, const char* cmd)
{
Fonksiyonun içine hemen başına ekle

if (HandleAutoShoutCommand(ch, cmd))
    return true;


Sonra tekrar char cpp arat
bool RecvWhisper(CHARACTER* ch, const char* fromName, const char* message)
{
Yine fonksiyonun hemen başına ekle


if (DummyCharacterRecvPrivateMessage(ch, fromName, message))
    return true;