relation/server/imserver/metamgr.cc

#include "precompile.h"

#include <algorithm>

#include <a8/stringlist.h>
#include <a8/csvreader.h>

#include "framework/cpp/utils.h"

#include "metamgr.h"
#include "app.h"
#include "jsondatamgr.h"

#define METAMGR_READ(field_name, def_val) MetaMgr::Instance()->field_name = \
        a8::XValue(MetaMgr::Instance()->GetSysParamAsString(#field_name, #def_val));

#define METAMGR_READ_STR(field_name, def_val) MetaMgr::Instance()->field_name = \
        a8::XValue(MetaMgr::Instance()->GetSysParamAsString(#field_name, def_val)).GetString();

static bool PureEnglishName(const std::string& role_name)
{
    for (size_t i = 0; i < role_name.size(); i++) {
        if (role_name[i] >= 0 && role_name[i] <= 127) {
            continue;
        } else {
            return false;
        }
    }
    return true;
}

class MetaDataLoader
{
public:
    std::list<metatable::Guild> guild_meta_list;
    std::list<MetaData::Guild> guild_list;
    std::list<metatable::Text> text_meta_list;

    std::map<int, MetaData::Guild*> guild_hash;
    std::map<std::string, std::string> text_hash;

    std::map<size_t, std::map<std::string, std::string> > dirty_words;

    void Load()
    {
        if (!f8::IsOnlineEnv()) {
            if (f8::IsTestEnv()) {
                res_path = a8::Format("/root/pub/%d/%d/conf_test/game%d/imserver.test/res%d/",
                                      {
                                       GAME_ID,
                                       App::Instance()->instance_id,
                                       GAME_ID,
                                       App::Instance()->instance_id
                                      });
            } else {
                res_path = a8::Format("/root/pub/%d/%d/conf_test/game%d/imserver.dev/res%d/",
                                      {
                                       GAME_ID,
                                       App::Instance()->instance_id,
                                       GAME_ID,
                                       App::Instance()->instance_id
                                      });
            }
        } else {
            res_path = "../res/";
        }
        f8::ReadCsvMetaFile(res_path + "Clan@Clan.csv", guild_meta_list);
        f8::ReadCsvMetaFile(res_path + "text@text.csv", text_meta_list);
        LoadDirtyWordTable();
        BindToMetaData();
        Check();
    }

private:

    void LoadDirtyWordTable()
    {
        a8::CsvReader reader;
        reader.Load(res_path + "dirtyWord@dirtyWord.csv");
        while (reader.NextLine()) {
            std::string strword = reader.GetValue("word").GetString();
            if (strword == " " || strword.empty()) { //忽略空格
                continue;
            }
            auto itr = dirty_words.find(strword.size());
            if (dirty_words.find(strword.size()) != dirty_words.end()) {
                itr->second[strword] = strword;
            } else {
                std::map<std::string, std::string> words;
                words[strword] = strword;
                dirty_words[strword.size()] = words;
            }
        }
    }

    void Check()
    {
    }

    void BindToMetaData()
    {
        for (auto& meta : guild_meta_list) {
            MetaData::Guild& item = a8::FastAppend(guild_list);
            item.i = &meta;
            item.Init();
            guild_hash[item.i->grade()] = &item;
        }

       for (auto& meta : text_meta_list) {
           text_hash[meta.textid()] = meta.text();
       }

    }

private:
    std::string res_path;
};

void MetaMgr::Init()
{
    loader_ = new MetaDataLoader();
    loader_->Load();
}

void MetaMgr::UnInit()
{
    delete loader_;
    loader_ = nullptr;
}

void MetaMgr::Reload()
{
    delete loader_;
    loader_ = nullptr;

    loader_ = new MetaDataLoader();
    loader_->Load();
}

MetaData::Guild* MetaMgr::GetGuild(int guild_lv)
{
    auto itr = loader_->guild_hash.find(guild_lv);
    if (itr != loader_->guild_hash.end()) {
        return itr->second;
    } else {
        return nullptr;
    }
}

std::string MetaMgr::ReplaceDirtyWord(const std::string& text, char c)
{
    std::string result;
    result.reserve(text.size());
    for (size_t i = 0; i < text.size(); i++) {
        bool found = false;
        for (auto itr = loader_->dirty_words.begin(); itr != loader_->dirty_words.end(); ++itr) {
            if (itr->first <= text.size() - i) {
                std::string substr = text.substr(i, itr->first);
                // 如果是纯英文，则先转为小写，根据策划说明，屏蔽字大小写不敏感
                if (PureEnglishName(substr)) {
                    transform(substr.begin(), substr.end(), substr.begin(), ::tolower);
                }
                if (substr.size() > 0 && itr->second.find(substr) != itr->second.end()) {
                    int str_len = a8::GetUtf8Length(substr.c_str());
                    for (int j = 0; j < str_len; j++) {
                        result.push_back(c);
                    }
                    i += substr.size() - 1;
                    found = true;
                    break;
                }
            }
        }//endfor map
        if (!found) {
            result.push_back(text[i]);
        }
    }
    return result;
}

std::string MetaMgr::GetText(const std::string& textid, const std::string& def_text)
{
    auto itr = loader_->text_hash.find(textid);
    return itr != loader_->text_hash.end() ? itr->second : def_text;
}