Core/Chat: Load chat language data from db2 and implement serverside chat translations

1 files changed, 234 insertions, 0 deletions

diff --git a/src/server/game/Chat/LanguageMgr.cpp b/src/server/game/Chat/LanguageMgr.cpp
new file mode 100644
index 00000000000..acbd76f0a56
--- /dev/null
+++ b/src/server/game/Chat/LanguageMgr.cpp
@@ -0,0 +1,234 @@
+/*
+ * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
+ *
+ * This program is free software; you can redistribute it and/or modify it
+ * under the terms of the GNU General Public License as published by the
+ * Free Software Foundation; either version 2 of the License, or (at your
+ * option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but WITHOUT
+ * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
+ * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
+ * more details.
+ *
+ * You should have received a copy of the GNU General Public License along
+ * with this program. If not, see <http://www.gnu.org/licenses/>.
+ */
+
+#include "LanguageMgr.h"
+#include "DB2Stores.h"
+#include "Log.h"
+#include "SpellInfo.h"
+#include "SpellMgr.h"
+#include "Timer.h"
+
+#include <sstream>
+
+LanguageMgr::LanguageMgr() : _langsMap(), _wordsMap() { }
+
+LanguageMgr::~LanguageMgr()
+{
+    _langsMap.clear();
+    _wordsMap.clear();
+}
+
+LanguageMgr* LanguageMgr::instance()
+{
+    static LanguageMgr instance;
+    return &instance;
+}
+
+void LanguageMgr::LoadSpellEffectLanguage(SpellEffectEntry const* spellEffect)
+{
+    ASSERT(spellEffect && spellEffect->Effect == SPELL_EFFECT_LANGUAGE);
+
+    uint32 languageId = uint32(spellEffect->EffectMiscValue[0]);
+    auto iter = _langsMap.find(languageId);
+    if (iter == _langsMap.end())
+    {
+        TC_LOG_WARN("languages.spell", "LoadSpellEffectLanguage called on Spell %u with language %u which does not exist in Language.db2!",
+            spellEffect->SpellID, languageId);
+        return;
+    }
+    LanguageDesc& desc = iter->second;
+    desc.SpellId = spellEffect->SpellID;
+}
+
+uint32 LanguageMgr::GetSpellLanguage(uint32 spellId) const
+{
+    if (SpellInfo const* spellInfo = sSpellMgr->GetSpellInfo(spellId, DIFFICULTY_NONE))
+    {
+        SpellEffectInfoVector const& effects = spellInfo->GetEffects();
+        if (effects.size() != 1 || effects[0]->Effect != SPELL_EFFECT_LANGUAGE)
+            TC_LOG_WARN("languages.spell", "Invalid language spell %u. Expected 1 effect with SPELL_EFFECT_LANGUAGE", spellId);
+        else
+            return effects[0]->MiscValue;
+    }
+    return 0;
+}
+
+bool LanguageMgr::IsRelevantLanguageSkill(SkillLineEntry const* skillLineEntry) const
+{
+    if (!skillLineEntry)
+        return false;
+
+    SkillRaceClassInfoEntry const* entry = sDB2Manager.GetAvailableSkillRaceClassInfo(skillLineEntry->ID);
+    return entry != nullptr;
+}
+
+void LanguageMgr::LoadLanguages()
+{
+    uint32 oldMSTime = getMSTime();
+
+    // Load languages from Languages.db2. Just the id, we don't need the name
+    for (LanguagesEntry const* langEntry : sLanguagesStore)
+        _langsMap.emplace(langEntry->ID, LanguageDesc());
+
+    // Add the languages used in code in case they don't exist
+    _langsMap.emplace(LANG_UNIVERSAL, LanguageDesc());
+    _langsMap.emplace(LANG_ADDON, LanguageDesc());
+    _langsMap.emplace(LANG_ADDON_LOGGED, LanguageDesc());
+
+    // Log load time
+    TC_LOG_INFO("server.loading", ">> Loaded %u languages in %u ms", uint32(_langsMap.size()), GetMSTimeDiffToNow(oldMSTime));
+}
+
+void LanguageMgr::LoadLanguagesSkills()
+{
+    uint32 oldMSTime = getMSTime();
+
+    uint32 count = 0;
+    for (SkillLineEntry const* skillLineEntry : sSkillLineStore)
+    {
+        if (skillLineEntry->CategoryID != SKILL_CATEGORY_LANGUAGES)
+            continue;
+
+        if (!IsRelevantLanguageSkill(skillLineEntry))
+            continue;
+
+        std::vector<SkillLineAbilityEntry const*> const* skills = sDB2Manager.GetSkillLineAbilitiesBySkill(skillLineEntry->ID);
+
+        // We're expecting only 1 skill
+        if (skills->size() != 1)
+            TC_LOG_WARN("server.loading", "Found language skill line with %u spells. Expected 1. Will use 1st if available", uint32(skills->size()));
+
+        if (SkillLineAbilityEntry const* ability = skills->empty() ? nullptr : skills->at(0))
+        {
+            if (uint32 languageId = GetSpellLanguage(ability->Spell))
+            {
+                auto iter = _langsMap.find(languageId);
+                if (iter == _langsMap.cend())
+                    TC_LOG_WARN("server.loading", "Spell %u has language %u, which doesn't exist in Languages.db2", ability->Spell, languageId);
+                else
+                {
+                    iter->second.SpellId = ability->Spell;
+                    iter->second.SkillId = skillLineEntry->ID;
+                    ++count;
+                }
+            }
+        }
+    }
+
+    // Languages that don't have skills will be added in SpellMgr::LoadSpellInfoStore() (e.g. LANG_ZOMBIE, LANG_SHATH_YAR)
+
+    // Log load time
+    TC_LOG_INFO("server.loading", ">> Loaded %u languages skills in %u ms", count, GetMSTimeDiffToNow(oldMSTime));
+}
+
+void LanguageMgr::LoadLanguagesWords()
+{
+    uint32 oldMSTime = getMSTime();
+
+    uint32 wordsNum = 0;
+    for (LanguageWordsEntry const* wordEntry : sLanguageWordsStore)
+    {
+        uint8 length = std::min(18U, uint32(strlen(wordEntry->Word)));
+
+        WordKey key = WordKey(wordEntry->LanguageID, length);
+
+        auto result = _wordsMap.insert(std::make_pair(key, WordList()));
+        result.first->second.push_back(wordEntry->Word);
+        ++wordsNum;
+    }
+
+    // log load time
+    TC_LOG_INFO("server.loading", ">> Loaded %u word groups from %u words in %u ms", uint32(_wordsMap.size()), wordsNum, GetMSTimeDiffToNow(oldMSTime));
+}
+
+LanguageMgr::WordList const* LanguageMgr::FindWordGroup(uint32 language, uint32 wordLen) const
+{
+    WordsMap::const_iterator iter = _wordsMap.find(WordKey(language, wordLen));
+    if (iter != _wordsMap.end())
+        return &(iter->second);
+    return nullptr;
+}
+
+std::string LanguageMgr::Translate(std::string const& msg, uint32 sourcePlayerLanguage) const
+{
+    std::stringstream result;
+    Tokenizer tokens(msg, ' ');
+    bool first = true;
+    for (char const* str : tokens)
+    {
+        const char* nextPart = str;
+        uint32 wordLen = std::min(18U, (uint32)strlen(str));
+        LanguageMgr::WordList const* wordGroup = FindWordGroup(sourcePlayerLanguage, wordLen);
+        if (!wordGroup)
+            nextPart = "";
+        else
+        {
+            uint32 wordHash = SStrHash(str, true);
+            uint8 idxInsideGroup = wordHash % wordGroup->size();
+            nextPart = wordGroup->at(idxInsideGroup);
+        }
+
+        if (first)
+            first = false;
+        else
+            result << " ";
+
+        result << nextPart;
+    }
+    return result.str();
+}
+
+static char upper_backslash(char c) { return c == '/' ? '\\' : toupper(c); }
+
+static uint32 const s_hashtable[16] = {
+    0x486E26EE, 0xDCAA16B3, 0xE1918EEF, 0x202DAFDB,
+    0x341C7DC7, 0x1C365303, 0x40EF2D37, 0x65FD5E49,
+    0xD6057177, 0x904ECE93, 0x1C38024F, 0x98FD323B,
+    0xE3061AE7, 0xA39B0FA1, 0x9797F25F, 0xE4444563,
+};
+
+uint32 LanguageMgr::SStrHash(char const* string, bool caseInsensitive, uint32 seed) const
+{
+    ASSERT(string);
+
+    uint32 shift = 0xEEEEEEEE;
+    while (*string) {
+        char c = *string++;
+
+        if (caseInsensitive)
+            c = upper_backslash(c);
+
+        seed = (s_hashtable[c >> 4] - s_hashtable[c & 0xF]) ^ (shift + seed);
+        shift = c + seed + 33 * shift + 3;
+    }
+
+    return seed ? seed : 1;
+}
+
+bool LanguageMgr::IsLanguageExist(uint32 languageId) const
+{
+    auto iter = _langsMap.find(languageId);
+    return iter != _langsMap.cend();
+}
+
+LanguageDesc const* LanguageMgr::GetLanguageDescById(uint32 languageId) const
+{
+    auto iter = _langsMap.find(languageId);
+    if (iter == _langsMap.cend())
+        return nullptr;
+    return &(iter->second);
+}