From dbefa17a534500522a174e9906d8923445c16e79 Mon Sep 17 00:00:00 2001 From: Kargatum Date: Sun, 28 Feb 2021 20:37:03 +0700 Subject: [PATCH] feat(Core/Config): rework config and delete ACE inherited (#4608) --- CMakeLists.txt | 1 + src/cmake/compiler/clang/settings.cmake | 24 + src/cmake/macros/ConfigInstall.cmake | 90 ++ src/common/Configuration/Config.cpp | 489 ++++++----- src/common/Configuration/Config.h | 74 +- src/common/Logging/Log.cpp | 46 +- src/common/Navigation/DetourExtended.cpp | 1 - src/common/Utilities/StringConvert.h | 259 ++++++ src/common/Utilities/StringFormat.cpp | 40 + src/common/Utilities/StringFormat.h | 15 +- src/common/Utilities/Types.h | 63 ++ src/common/Utilities/Util.cpp | 12 +- src/common/Utilities/Util.h | 3 +- src/common/Utilities/advstd.h | 31 + src/server/authserver/CMakeLists.txt | 26 +- src/server/authserver/Main.cpp | 31 +- src/server/authserver/Server/AuthSocket.cpp | 8 +- src/server/game/AI/CoreAI/PetAI.cpp | 1 - .../game/Entities/Creature/Creature.cpp | 1 - src/server/game/Entities/Object/Object.cpp | 1 - src/server/game/Guilds/Guild.cpp | 2 +- src/server/game/Maps/Map.cpp | 1 - .../MovementGenerators/PathGenerator.cpp | 1 - .../TargetedMovementGenerator.cpp | 2 - .../TargetedMovementGenerator.h | 1 - src/server/game/Server/Protocol/PacketLog.cpp | 4 +- src/server/game/Server/WorldSocketMgr.cpp | 8 +- src/server/game/Warden/WardenCheckMgr.cpp | 1 - src/server/game/World/World.cpp | 808 +++++++++--------- src/server/worldserver/CMakeLists.txt | 50 +- .../worldserver/CommandLine/CliRunnable.cpp | 2 +- src/server/worldserver/Main.cpp | 7 +- src/server/worldserver/Master.cpp | 38 +- .../worldserver/RemoteAccess/RARunnable.cpp | 6 +- .../worldserver/RemoteAccess/RASocket.cpp | 2 +- src/server/worldserver/worldserver.conf.dist | 7 +- 36 files changed, 1340 insertions(+), 816 deletions(-) create mode 100644 src/cmake/macros/ConfigInstall.cmake create mode 100644 src/common/Utilities/StringConvert.h create mode 100644 src/common/Utilities/StringFormat.cpp create mode 100644 src/common/Utilities/Types.h create mode 100644 src/common/Utilities/advstd.h diff --git a/CMakeLists.txt b/CMakeLists.txt index ebe5c1217..f21ef8cbf 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -97,6 +97,7 @@ include(ConfigureBaseTargets) include(CheckPlatform) include(GroupSources) include(AutoCollect) +include(ConfigInstall) CU_RUN_HOOK("AFTER_LOAD_CMAKE_MODULES") diff --git a/src/cmake/compiler/clang/settings.cmake b/src/cmake/compiler/clang/settings.cmake index dda5966f0..32234085c 100644 --- a/src/cmake/compiler/clang/settings.cmake +++ b/src/cmake/compiler/clang/settings.cmake @@ -8,6 +8,30 @@ target_compile_definitions(acore-compile-option-interface INTERFACE -D_BUILD_DIRECTIVE="${CMAKE_BUILD_TYPE}") +# This tests for a bug in clang-7 that causes linkage to fail for 64-bit from_chars (in some configurations) +# If the clang requirement is bumped to >= clang-8, you can remove this check, as well as +# the associated ifdef block in src/common/Utilities/StringConvert.h +include(CheckCXXSourceCompiles) + +check_cxx_source_compiles(" +#include +#include +int main() +{ + uint64_t n; + char const c[] = \"0\"; + std::from_chars(c, c+1, n); + return static_cast(n); +} +" CLANG_HAVE_PROPER_CHARCONV) + +if (NOT CLANG_HAVE_PROPER_CHARCONV) + message(STATUS "Clang: Detected from_chars bug for 64-bit integers, workaround enabled") + target_compile_definitions(acore-compile-option-interface + INTERFACE + -DACORE_NEED_CHARCONV_WORKAROUND) +endif() + if(WITH_WARNINGS) target_compile_options(acore-warning-interface INTERFACE diff --git a/src/cmake/macros/ConfigInstall.cmake b/src/cmake/macros/ConfigInstall.cmake new file mode 100644 index 000000000..dd1236882 --- /dev/null +++ b/src/cmake/macros/ConfigInstall.cmake @@ -0,0 +1,90 @@ +# +# Copyright (C) 2016+ AzerothCore , released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3 +# Copyright (C) 2021+ WarheadCore +# + +# +# Use it like: +# CopyDefaultConfig(worldserver) +# + +function(CopyDefaultConfig servertype) + if(WIN32) + if("${CMAKE_MAKE_PROGRAM}" MATCHES "MSBuild") + add_custom_command(TARGET ${servertype} + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/bin/$(ConfigurationName)/configs") + add_custom_command(TARGET ${servertype} + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/${servertype}.conf.dist" "${CMAKE_BINARY_DIR}/bin/$(ConfigurationName)/configs") + elseif(MINGW) + add_custom_command(TARGET ${servertype} + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/bin/configs") + add_custom_command(TARGET ${servertype} + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy "${CMAKE_CURRENT_SOURCE_DIR}/${servertype}.conf.dist ${CMAKE_BINARY_DIR}/bin/configs") + endif() + endif() + + if(UNIX) + install(FILES "${servertype}.conf.dist" DESTINATION "${CONF_DIR}") + elseif(WIN32) + install(FILES "${servertype}.conf.dist" DESTINATION "${CMAKE_INSTALL_PREFIX}/configs") + endif() +endfunction() + +# +# Use it like: +# CopyModuleConfig("warhead.conf.dist") +# + +function(CopyModuleConfig configDir) + set(postPath "configs/modules") + + if(WIN32) + if("${CMAKE_MAKE_PROGRAM}" MATCHES "MSBuild") + add_custom_command(TARGET worldserver + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/bin/$(ConfigurationName)/${postPath}") + add_custom_command(TARGET worldserver + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy "${configDir}" "${CMAKE_BINARY_DIR}/bin/$(ConfigurationName)/${postPath}") + elseif(MINGW) + add_custom_command(TARGET worldserver + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E make_directory "${CMAKE_BINARY_DIR}/bin/${postPath}") + add_custom_command(TARGET worldserver + POST_BUILD + COMMAND ${CMAKE_COMMAND} -E copy "${configDir} ${CMAKE_BINARY_DIR}/bin/${postPath}") + endif() + endif() + + if(UNIX) + install(FILES "${configDir}" DESTINATION "${CONF_DIR}/modules") + elseif(WIN32) + install(FILES "${configDir}" DESTINATION "${CMAKE_INSTALL_PREFIX}/${postPath}") + endif() + unset(postPath) +endfunction() + +# +# Use it like: +# CollectModulesConfig() +# + +function(CollectModulesConfig) + message(STATUS "* Modules config list:") + + CU_GET_GLOBAL("MODULE_CONFIG_FILE_LIST") + + foreach(configFile ${MODULE_CONFIG_FILE_LIST}) + CopyModuleConfig(${configFile}) + get_filename_component(file_name ${configFile} NAME) + set(CONFIG_LIST ${CONFIG_LIST}${file_name},) + message(STATUS " |- ${file_name}") + endforeach() + + message("") + add_definitions(-DCONFIG_FILE_LIST=$<1:"${CONFIG_LIST}">) +endfunction() diff --git a/src/common/Configuration/Config.cpp b/src/common/Configuration/Config.cpp index 819ed2146..253fbf18c 100644 --- a/src/common/Configuration/Config.cpp +++ b/src/common/Configuration/Config.cpp @@ -1,284 +1,295 @@ /* - * Copyright (C) 2016+ AzerothCore , released under GNU GPL v2 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-GPL2 - * Copyright (C) 2008-2016 TrinityCore - * Copyright (C) 2005-2009 MaNGOS + * Copyright (C) 2016+ AzerothCore , released under GNU GPL v2 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-GPL2 + * Copyright (C) 2021+ WarheadCore */ #include "Config.h" -#include "Errors.h" #include "Log.h" +#include "StringConvert.h" +#include "StringFormat.h" #include "Util.h" -#include -#include #include +#include +#include namespace { - std::unique_ptr _config; - std::vector _modulesConfigFiles; - std::string _initConfigFile; + std::string _filename; + std::vector _additonalFiles; + std::vector _args; + std::unordered_map _configOptions; std::mutex _configLock; - // Defined here as it must not be exposed to end-users. - bool GetValueHelper(const char* name, ACE_TString& result) + void AddKey(std::string const& optionName, std::string const& optionKey, bool replace = true) { - std::lock_guard guard(_configLock); - - if (!_config.get()) - return false; - - ACE_TString section_name; - ACE_Configuration_Section_Key section_key; - const ACE_Configuration_Section_Key& root_key = _config->root_section(); - - int i = 0; - - while (!_config->enumerate_sections(root_key, i, section_name)) + auto const& itr = _configOptions.find(optionName); + if (itr != _configOptions.end()) { - _config->open_section(root_key, section_name.c_str(), 0, section_key); + if (!replace) + { + sLog->outError("> Config: Option '%s' is exist! Option key - '%s'", optionName.c_str(), itr->second.c_str()); + return; + } - if (!_config->get_string_value(section_key, name, result)) - return true; + _configOptions.erase(optionName); + } - ++i; + _configOptions.emplace(optionName, optionKey); + + //sLog->outError("> Config: Add '%s' - '%s'\n", optionName.c_str(), optionKey.c_str()); + } + + void ParseFile(std::string const& file) + { + std::ifstream in(file); + + if (in.fail()) + throw ConfigException(acore::StringFormat("Config::LoadFile: Failed open file '%s'", file.c_str())); + + uint32 count = 0; + + while (in.good()) + { + std::string line; + std::getline(in, line); + + if (line.empty()) + continue; + + line = acore::String::Reduce(line); + + // comments + if (line[0] == '#' || line[0] == '[') + continue; + + auto const equal_pos = line.find('='); + + if (equal_pos == std::string::npos || equal_pos == line.length()) + return; + + auto entry = acore::String::Reduce(line.substr(0, equal_pos)); + auto value = acore::String::Reduce(line.substr(equal_pos + 1)); + + value.erase(std::remove(value.begin(), value.end(), '"'), value.end()); + + AddKey(entry, value); + + count++; + } + + if (!count) + throw ConfigException(acore::StringFormat("Config::LoadFile: Empty file '%s'", file.c_str())); + } + + bool LoadFile(std::string const& file) + { + try + { + ParseFile(file); + return true; + } + catch (const std::exception& e) + { + sLog->outError("> Config: %s", e.what()); } return false; } } +bool ConfigMgr::LoadInitial(std::string const& file) +{ + std::lock_guard lock(_configLock); + _configOptions.clear(); + return LoadFile(file); +} + +bool ConfigMgr::LoadAdditionalFile(std::string file) +{ + std::lock_guard lock(_configLock); + return LoadFile(file); +} + ConfigMgr* ConfigMgr::instance() { static ConfigMgr instance; return &instance; } -bool ConfigMgr::LoadInitial(std::string const& file) -{ - ASSERT(file.c_str()); - - std::lock_guard guard(_configLock); - - _config.reset(new ACE_Configuration_Heap()); - if (!_config->open()) - if (LoadData(file)) - return true; - - _config.reset(); - return false; -} - -bool ConfigMgr::LoadMore(std::string const& file) -{ - ASSERT(file.c_str()); - ASSERT(_config); - - std::lock_guard guard(_configLock); - - return LoadData(file); -} - bool ConfigMgr::Reload() { if (!LoadAppConfigs()) return false; - LoadModulesConfigs(); - - return true; + return LoadModulesConfigs(); } -bool ConfigMgr::LoadData(std::string const& file) +template +T ConfigMgr::GetValueDefault(std::string const& name, T const& def, bool showLogs /*= true*/) const { - ACE_Ini_ImpExp config_importer(*_config.get()); - if (!config_importer.import_config(file.c_str())) - return true; - - return false; -} - -std::string ConfigMgr::GetStringDefault(std::string const& name, const std::string& def, bool logUnused /*= true*/) -{ - ACE_TString val; - - if (GetValueHelper(name.c_str(), val)) + auto const& itr = _configOptions.find(name); + if (itr == _configOptions.end()) { - std::string value = val.c_str(); - value.erase(std::remove(value.begin(), value.end(), '"'), value.end()); - return value; - } - else - { - if (logUnused) - sLog->outError("-> Not found option '%s'. The default value is used (%s)", name.c_str(), def.c_str()); - - return def; - } -} - -bool ConfigMgr::GetBoolDefault(std::string const& name, bool def, bool logUnused /*= true*/) -{ - ACE_TString val; - - if (!GetValueHelper(name.c_str(), val)) - { - if (logUnused) - def ? sLog->outError("-> Not found option '%s'. The default value is used (Yes)", name.c_str()) : sLog->outError("-> Not found option '%s'. The default value is used (No)", name.c_str()); - - return def; - } - - return StringToBool(val.c_str()); -} - -int ConfigMgr::GetIntDefault(std::string const& name, int def, bool logUnused /*= true*/) -{ - ACE_TString val; - - if (GetValueHelper(name.c_str(), val)) - return std::stoi(val.c_str()); - else - { - if (logUnused) - sLog->outError("-> Not found option '%s'. The default value is used (%i)", name.c_str(), def); - - return def; - } -} - -float ConfigMgr::GetFloatDefault(std::string const& name, float def, bool logUnused /*= true*/) -{ - ACE_TString val; - - if (GetValueHelper(name.c_str(), val)) - return std::stof(val.c_str()); - else - { - if (logUnused) - sLog->outError("-> Not found option '%s'. The default value is used (%f)", name.c_str(), def); - - return def; - } -} - -std::list ConfigMgr::GetKeysByString(std::string const& name) -{ - std::lock_guard guard(_configLock); - - std::list keys; - if (!_config.get()) - return keys; - - ACE_TString section_name; - ACE_Configuration_Section_Key section_key; - const ACE_Configuration_Section_Key& root_key = _config->root_section(); - - int i = 0; - - while (!_config->enumerate_sections(root_key, i++, section_name)) - { - _config->open_section(root_key, section_name.c_str(), 0, section_key); - - ACE_TString key_name; - ACE_Configuration::VALUETYPE type; - - int j = 0; - - while (!_config->enumerate_values(section_key, j++, key_name, type)) + if (showLogs) { - std::string temp = key_name.c_str(); - - if (temp.find(name) != std::string::npos) - keys.push_back(temp); + sLog->outError("> Config: Missing name %s in config, add \"%s = %s\"", + name.c_str(), name.c_str(), acore::ToString(def).c_str()); } + + return def; } + auto value = acore::StringTo(itr->second); + if (!value) + { + if (showLogs) + { + sLog->outError("> Config: Bad value defined for name '%s', going to use '%s' instead", + name.c_str(), acore::ToString(def).c_str()); + } + + return def; + } + + return *value; +} + +template<> +std::string ConfigMgr::GetValueDefault(std::string const& name, std::string const& def, bool showLogs /*= true*/) const +{ + auto const& itr = _configOptions.find(name); + if (itr == _configOptions.end()) + { + if (showLogs) + { + sLog->outError("> Config: Missing name %s in config, add \"%s = %s\"", + name.c_str(), name.c_str(), def.c_str()); + } + + return def; + } + + return itr->second; +} + +template +T ConfigMgr::GetOption(std::string const& name, T const& def, bool showLogs /*= true*/) const +{ + return GetValueDefault(name, def, showLogs); +} + +template<> +bool ConfigMgr::GetOption(std::string const& name, bool const& def, bool showLogs /*= true*/) const +{ + std::string val = GetValueDefault(name, std::string(def ? "1" : "0"), showLogs); + + auto boolVal = acore::StringTo(val); + if (!boolVal) + { + if (showLogs) + { + sLog->outError("> Config: Bad value defined for name '%s', going to use '%s' instead", + name.c_str(), def ? "true" : "false"); + } + + return def; + } + + return *boolVal; +} + +std::vector ConfigMgr::GetKeysByString(std::string const& name) +{ + std::lock_guard lock(_configLock); + + std::vector keys; + + for (auto const& [optionName, key] : _configOptions) + if (!optionName.compare(0, name.length(), name)) + keys.emplace_back(optionName); + return keys; } -void ConfigMgr::SetConfigList(std::string const& fileName, std::string const& modulesConfigList /*= ""*/) +std::string const& ConfigMgr::GetFilename() { - _initConfigFile = fileName; - - if (modulesConfigList.empty()) - return; - - // Clean config list before load - _modulesConfigFiles.clear(); - - Tokenizer configFileList(modulesConfigList, ','); - for (auto const& itr : configFileList) - _modulesConfigFiles.push_back(itr); + std::lock_guard lock(_configLock); + return _filename; } -bool ConfigMgr::LoadAppConfigs(std::string const& applicationName /*= "worldserver"*/) +std::vector const& ConfigMgr::GetArguments() const +{ + return _args; +} + +std::string const ConfigMgr::GetConfigPath() +{ + std::lock_guard lock(_configLock); + +#if AC_PLATFORM == AC_PLATFORM_WINDOWS + return "configs/"; +#else + return std::string(_CONF_DIR) + "/"; +#endif +} + +void ConfigMgr::Configure(std::string const& initFileName, std::vector args, std::string const& modulesConfigList /*= ""*/) +{ + _filename = initFileName; + _args = std::move(args); + + // Add modules config if exist + if (!modulesConfigList.empty()) + { + Tokenizer configFileList(modulesConfigList, ','); + for (auto const& itr : configFileList) + _additonalFiles.emplace_back(std::string(itr)); + } +} + +bool ConfigMgr::LoadAppConfigs() { // #1 - Load init config file .conf.dist - if (!sConfigMgr->LoadInitial(_initConfigFile + ".dist")) - { - printf("Load config error. Invalid or missing dist configuration file: %s", std::string(_initConfigFile + ".dist").c_str()); - printf("Verify that the file exists and has \'[%s]' written in the top of the file!", applicationName.c_str()); + if (!LoadInitial(_filename + ".dist")) return false; - } // #2 - Load .conf file - if (!sConfigMgr->LoadMore(_initConfigFile)) - { - sLog->outString(); - sLog->outString("Load config error. Invalid or missing configuration file: %s", _initConfigFile.c_str()); - sLog->outString("Verify that the file exists and has \'[%s]' written in the top of the file!", applicationName.c_str()); + if (!LoadAdditionalFile(_filename)) return false; - } return true; } bool ConfigMgr::LoadModulesConfigs() { - // If not modules config - load failed - if (_modulesConfigFiles.empty()) - return false; + if (_additonalFiles.empty()) + return true; // Start loading module configs - std::unordered_map moduleConfigFiles; + std::vector moduleConfigFiles; + std::string const& moduleConfigPath = GetConfigPath() + "modules/"; + bool isExistDefaultConfig = true; + bool isExistDistConfig = true; - moduleConfigFiles.clear(); - - std::string configPath = _CONF_DIR; - - for (auto const& itr : _modulesConfigFiles) + for (auto const& distFileName : _additonalFiles) { - bool IsExistDefaultConfig = true; - bool IsExistDistConfig = true; + std::string defaultFileName = distFileName; - std::string moduleName = itr; - std::string configFile = std::string(itr) + std::string(".conf"); - std::string defaultConfig = configPath + "/" + configFile; - -#if AC_PLATFORM == AC_PLATFORM_WINDOWS - defaultConfig = configFile; -#endif - - std::string ConfigFileDist = defaultConfig + std::string(".dist"); + if (!defaultFileName.empty()) + defaultFileName.erase(defaultFileName.end() - 5, defaultFileName.end()); // Load .conf.dist config - if (!sConfigMgr->LoadMore(ConfigFileDist.c_str())) - { - sLog->outError("> Invalid or missing dist configuration file: %s", ConfigFileDist.c_str()); - IsExistDistConfig = false; - } + if (!LoadAdditionalFile(moduleConfigPath + distFileName)) + isExistDistConfig = false; // Load .conf config - if (!sConfigMgr->LoadMore(defaultConfig.c_str())) - IsExistDefaultConfig = false; + if (!LoadAdditionalFile(moduleConfigPath + defaultFileName)) + isExistDefaultConfig = false; - // #1 - Not exist .conf and exist .conf.dist - if (!IsExistDefaultConfig && IsExistDistConfig) - moduleConfigFiles.insert(std::make_pair(moduleName, ConfigFileDist)); - else if (!IsExistDefaultConfig && !IsExistDistConfig) // #2 - Not exist .conf and not exist .conf.dist - moduleConfigFiles.insert(std::make_pair(moduleName, "default hardcoded settings")); - else if (IsExistDefaultConfig && IsExistDistConfig) - moduleConfigFiles.insert(std::make_pair(moduleName, defaultConfig)); + if (isExistDefaultConfig && isExistDistConfig) + moduleConfigFiles.emplace_back(defaultFileName); + else if (!isExistDefaultConfig && isExistDistConfig) + moduleConfigFiles.emplace_back(distFileName); } // If module configs not exist - no load @@ -287,12 +298,60 @@ bool ConfigMgr::LoadModulesConfigs() // Print modules configurations sLog->outString(); - sLog->outString("Using configuration for modules:"); + sLog->outString("Using modules configuration:"); for (auto const& itr : moduleConfigFiles) - sLog->outString("> Module (%s) using (%s)", itr.first.c_str(), itr.second.c_str()); + sLog->outString("> %s", itr.c_str()); - sLog->outString(); + sLog->outString(""); return true; } + +/* + * Deprecated geters. This geters will be deleted + */ + +// @deprecated DO NOT USE - use GetOption instead. +std::string ConfigMgr::GetStringDefault(std::string const& name, const std::string& def, bool showLogs /*= true*/) +{ + return GetOption(name, def, showLogs); +} + +// @deprecated DO NOT USE - use GetOption instead. +bool ConfigMgr::GetBoolDefault(std::string const& name, bool def, bool showLogs /*= true*/) +{ + return GetOption(name, def, showLogs); +} + +// @deprecated DO NOT USE - use GetOption instead. +int ConfigMgr::GetIntDefault(std::string const& name, int def, bool showLogs /*= true*/) +{ + return GetOption(name, def, showLogs); +} + +// @deprecated DO NOT USE - use GetOption instead. +float ConfigMgr::GetFloatDefault(std::string const& name, float def, bool showLogs /*= true*/) +{ + return GetOption(name, def, showLogs); +} + +/* + * End deprecated geters + */ + +#define TEMPLATE_CONFIG_OPTION(__typename) \ + template __typename ConfigMgr::GetOption<__typename>(std::string const& name, __typename const& def, bool showLogs /*= true*/) const; + +TEMPLATE_CONFIG_OPTION(std::string) +TEMPLATE_CONFIG_OPTION(uint8) +TEMPLATE_CONFIG_OPTION(int8) +TEMPLATE_CONFIG_OPTION(uint16) +TEMPLATE_CONFIG_OPTION(int16) +TEMPLATE_CONFIG_OPTION(uint32) +TEMPLATE_CONFIG_OPTION(int32) +TEMPLATE_CONFIG_OPTION(uint64) +TEMPLATE_CONFIG_OPTION(int64) +TEMPLATE_CONFIG_OPTION(float) + +#undef TEMPLATE_CONFIG_OPTION diff --git a/src/common/Configuration/Config.h b/src/common/Configuration/Config.h index 56cade006..f736f18df 100644 --- a/src/common/Configuration/Config.h +++ b/src/common/Configuration/Config.h @@ -1,13 +1,15 @@ /* - * Copyright (C) 2016+ AzerothCore , released under GNU GPL v2 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-GPL2 - * Copyright (C) 2008-2016 TrinityCore - * Copyright (C) 2005-2009 MaNGOS + * Copyright (C) 2016+ AzerothCore , released under GNU GPL v2 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-GPL2 + * Copyright (C) 2021+ WarheadCore */ #ifndef CONFIG_H #define CONFIG_H -#include "Common.h" +#include "Define.h" +#include +#include +#include class ConfigMgr { @@ -17,40 +19,60 @@ class ConfigMgr ~ConfigMgr() = default; public: + bool LoadAppConfigs(); + bool LoadModulesConfigs(); + void Configure(std::string const& initFileName, std::vector args, std::string const& modulesConfigList = ""); + static ConfigMgr* instance(); - /// Method used only for loading main configuration files (authserver.conf and worldserver.conf) - bool LoadInitial(std::string const& file); - - /** - * This method loads additional configuration files - * It is recommended to use this method in WorldScript::OnConfigLoad hooks - * - * @return true if loading was successful - */ - bool LoadMore(std::string const& file); - bool Reload(); - bool LoadAppConfigs(std::string const& applicationName = "worldserver"); - bool LoadModulesConfigs(); + std::string const& GetFilename(); + std::string const GetConfigPath(); + std::vector const& GetArguments() const; + std::vector GetKeysByString(std::string const& name); - std::string GetStringDefault(std::string const& name, const std::string& def, bool logUnused = true); - bool GetBoolDefault(std::string const& name, bool def, bool logUnused = true); - int GetIntDefault(std::string const& name, int def, bool logUnused = true); - float GetFloatDefault(std::string const& name, float def, bool logUnused = true); + template + T GetOption(std::string const& name, T const& def, bool showLogs = true) const; - std::list GetKeysByString(std::string const& name); + /* + * Deprecated geters. This geters will be deleted + */ + + // @deprecated DO NOT USE - use GetOption instead. + std::string GetStringDefault(std::string const& name, const std::string& def, bool showLogs = true); + + // @deprecated DO NOT USE - use GetOption instead. + bool GetBoolDefault(std::string const& name, bool def, bool showLogs = true); + + // @deprecated DO NOT USE - use GetOption instead. + int GetIntDefault(std::string const& name, int def, bool showLogs = true); + + // @deprecated DO NOT USE - use GetOption instead. + float GetFloatDefault(std::string const& name, float def, bool showLogs = true); + + /* + * End deprecated geters + */ bool isDryRun() { return dryRun; } void setDryRun(bool mode) { dryRun = mode; } - void SetConfigList(std::string const& fileName, std::string const& modulesConfigList = ""); - private: - bool dryRun = false; + /// Method used only for loading main configuration files (authserver.conf and worldserver.conf) + bool LoadInitial(std::string const& file); + bool LoadAdditionalFile(std::string file); - bool LoadData(std::string const& file); + template + T GetValueDefault(std::string const& name, T const& def, bool showLogs = true) const; + + bool dryRun = false; +}; + +class ConfigException : public std::length_error +{ +public: + explicit ConfigException(std::string const& message) : std::length_error(message) { } }; #define sConfigMgr ConfigMgr::instance() diff --git a/src/common/Logging/Log.cpp b/src/common/Logging/Log.cpp index d1598d5fc..42bdc4552 100644 --- a/src/common/Logging/Log.cpp +++ b/src/common/Logging/Log.cpp @@ -93,16 +93,16 @@ void Log::SetLogFileLevel(char* Level) void Log::Initialize() { /// Check whether we'll log GM commands/RA events/character outputs/chat stuffs - m_dbChar = sConfigMgr->GetBoolDefault("LogDB.Char", false, false); - m_dbRA = sConfigMgr->GetBoolDefault("LogDB.RA", false, false); - m_dbGM = sConfigMgr->GetBoolDefault("LogDB.GM", false, false); - m_dbChat = sConfigMgr->GetBoolDefault("LogDB.Chat", false, false); + m_dbChar = sConfigMgr->GetOption("LogDB.Char", false, false); + m_dbRA = sConfigMgr->GetOption("LogDB.RA", false, false); + m_dbGM = sConfigMgr->GetOption("LogDB.GM", false, false); + m_dbChat = sConfigMgr->GetOption("LogDB.Chat", false, false); /// Realm must be 0 by default SetRealmID(0); /// Common log files data - m_logsDir = sConfigMgr->GetStringDefault("LogsDir", "", false); + m_logsDir = sConfigMgr->GetOption("LogsDir", "", false); if (!m_logsDir.empty()) if ((m_logsDir.at(m_logsDir.length() - 1) != '/') && (m_logsDir.at(m_logsDir.length() - 1) != '\\')) m_logsDir.push_back('/'); @@ -111,18 +111,18 @@ void Log::Initialize() /// Open specific log files logfile = openLogFile("LogFile", "LogTimestamp", "w"); - InitColors(sConfigMgr->GetStringDefault("LogColors", "", false)); + InitColors(sConfigMgr->GetOption("LogColors", "", false)); - m_gmlog_per_account = sConfigMgr->GetBoolDefault("GmLogPerAccount", false, false); + m_gmlog_per_account = sConfigMgr->GetOption("GmLogPerAccount", false, false); if (!m_gmlog_per_account) gmLogfile = openLogFile("GMLogFile", "GmLogTimestamp", "a"); else { // GM log settings for per account case - m_gmlog_filename_format = sConfigMgr->GetStringDefault("GMLogFile", "", false); + m_gmlog_filename_format = sConfigMgr->GetOption("GMLogFile", "", false); if (!m_gmlog_filename_format.empty()) { - bool m_gmlog_timestamp = sConfigMgr->GetBoolDefault("GmLogTimestamp", false, false); + bool m_gmlog_timestamp = sConfigMgr->GetOption("GmLogTimestamp", false, false); size_t dot_pos = m_gmlog_filename_format.find_last_of('.'); if (dot_pos != m_gmlog_filename_format.npos) @@ -153,19 +153,19 @@ void Log::Initialize() miscLogFile = fopen((m_logsDir + "Misc.log").c_str(), "a"); // Main log file settings - m_logLevel = sConfigMgr->GetIntDefault("LogLevel", LOGL_NORMAL, false); - m_logFileLevel = sConfigMgr->GetIntDefault("LogFileLevel", LOGL_NORMAL, false); - m_dbLogLevel = sConfigMgr->GetIntDefault("DBLogLevel", LOGL_NORMAL, false); - m_sqlDriverQueryLogging = sConfigMgr->GetBoolDefault("SQLDriverQueryLogging", false, false); + m_logLevel = sConfigMgr->GetOption("LogLevel", LOGL_NORMAL, false); + m_logFileLevel = sConfigMgr->GetOption("LogFileLevel", LOGL_NORMAL, false); + m_dbLogLevel = sConfigMgr->GetOption("DBLogLevel", LOGL_NORMAL, false); + m_sqlDriverQueryLogging = sConfigMgr->GetOption("SQLDriverQueryLogging", false, false); - m_DebugLogMask = DebugLogFilters(sConfigMgr->GetIntDefault("DebugLogMask", LOG_FILTER_NONE, false)); + m_DebugLogMask = DebugLogFilters(sConfigMgr->GetOption("DebugLogMask", LOG_FILTER_NONE, false)); // Char log settings - m_charLog_Dump = sConfigMgr->GetBoolDefault("CharLogDump", false, false); - m_charLog_Dump_Separate = sConfigMgr->GetBoolDefault("CharLogDump.Separate", false, false); + m_charLog_Dump = sConfigMgr->GetOption("CharLogDump", false, false); + m_charLog_Dump_Separate = sConfigMgr->GetOption("CharLogDump.Separate", false, false); if (m_charLog_Dump_Separate) { - m_dumpsDir = sConfigMgr->GetStringDefault("CharLogDump.SeparateDir", "", false); + m_dumpsDir = sConfigMgr->GetOption("CharLogDump.SeparateDir", "", false); if (!m_dumpsDir.empty()) if ((m_dumpsDir.at(m_dumpsDir.length() - 1) != '/') && (m_dumpsDir.at(m_dumpsDir.length() - 1) != '\\')) m_dumpsDir.push_back('/'); @@ -174,20 +174,20 @@ void Log::Initialize() void Log::ReloadConfig() { - m_logLevel = sConfigMgr->GetIntDefault("LogLevel", LOGL_NORMAL); - m_logFileLevel = sConfigMgr->GetIntDefault("LogFileLevel", LOGL_NORMAL); - m_dbLogLevel = sConfigMgr->GetIntDefault("DBLogLevel", LOGL_NORMAL); + m_logLevel = sConfigMgr->GetOption("LogLevel", LOGL_NORMAL); + m_logFileLevel = sConfigMgr->GetOption("LogFileLevel", LOGL_NORMAL); + m_dbLogLevel = sConfigMgr->GetOption("DBLogLevel", LOGL_NORMAL); - m_DebugLogMask = DebugLogFilters(sConfigMgr->GetIntDefault("DebugLogMask", LOG_FILTER_NONE)); + m_DebugLogMask = DebugLogFilters(sConfigMgr->GetOption("DebugLogMask", LOG_FILTER_NONE)); } FILE* Log::openLogFile(char const* configFileName, char const* configTimeStampFlag, char const* mode) { - std::string logfn = sConfigMgr->GetStringDefault(configFileName, "", false); + std::string logfn = sConfigMgr->GetOption(configFileName, "", false); if (logfn.empty()) return NULL; - if (configTimeStampFlag && sConfigMgr->GetBoolDefault(configTimeStampFlag, false, false)) + if (configTimeStampFlag && sConfigMgr->GetOption(configTimeStampFlag, false, false)) { size_t dot_pos = logfn.find_last_of("."); if (dot_pos != logfn.npos) diff --git a/src/common/Navigation/DetourExtended.cpp b/src/common/Navigation/DetourExtended.cpp index b3bae8756..5f2db49a6 100644 --- a/src/common/Navigation/DetourExtended.cpp +++ b/src/common/Navigation/DetourExtended.cpp @@ -6,7 +6,6 @@ #include "DetourCommon.h" #include "Geometry.h" - float dtQueryFilterExt::getCost(const float* pa, const float* pb, const dtPolyRef /*prevRef*/, const dtMeshTile* /*prevTile*/, const dtPoly* /*prevPoly*/, const dtPolyRef /*curRef*/, const dtMeshTile* /*curTile*/, const dtPoly* curPoly, diff --git a/src/common/Utilities/StringConvert.h b/src/common/Utilities/StringConvert.h new file mode 100644 index 000000000..66eaaf7a4 --- /dev/null +++ b/src/common/Utilities/StringConvert.h @@ -0,0 +1,259 @@ +/* + * Copyright (C) 2016+ AzerothCore , released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3 + * Copyright (C) 2021+ WarheadCore + */ + +#ifndef _ACORE_STRINGCONVERT_H_ +#define _ACORE_STRINGCONVERT_H_ + +#include "Define.h" +#include "Errors.h" +#include "Optional.h" +#include "Types.h" +#include "Util.h" +#include +#include +#include +#include + +namespace acore::Impl::StringConvertImpl +{ + template struct For + { + static_assert(acore::dependant_false_v, "Unsupported type used for ToString or StringTo"); + }; + + template + struct For && !std::is_same_v>> + { + static Optional FromString(std::string_view str, int base = 10) + { + if (base == 0) + { + if (StringEqualI(str.substr(0, 2), "0x")) + { + base = 16; + str.remove_prefix(2); + } + else if (StringEqualI(str.substr(0, 2), "0b")) + { + base = 2; + str.remove_prefix(2); + } + else + base = 10; + + if (str.empty()) + return std::nullopt; + } + + char const* const start = str.data(); + char const* const end = (start + str.length()); + + T val; + std::from_chars_result const res = std::from_chars(start, end, val, base); + if ((res.ptr == end) && (res.ec == std::errc())) + return val; + else + return std::nullopt; + } + + static std::string ToString(T val) + { + std::string buf(20,'\0'); /* 2^64 is 20 decimal characters, -(2^63) is 20 including the sign */ + char* const start = buf.data(); + char* const end = (start + buf.length()); + std::to_chars_result const res = std::to_chars(start, end, val); + ASSERT(res.ec == std::errc()); + buf.resize(res.ptr - start); + return buf; + } + }; + +#ifdef ACORE_NEED_CHARCONV_WORKAROUND + /* + If this is defined, std::from_chars will cause linkage errors for 64-bit types. + (This is a bug in clang-7.) + + If the clang requirement is bumped to >= clang-8, remove this ifdef block and its + associated check in cmake/compiler/clang/settings.cmake + */ + template <> + struct For + { + static Optional FromString(std::string_view str, int base = 10) + { + if (str.empty()) + return std::nullopt; + try + { + size_t n; + uint64 val = std::stoull(std::string(str), &n, base); + if (n != str.length()) + return std::nullopt; + return val; + } + catch (...) { return std::nullopt; } + } + + static std::string ToString(uint64 val) + { + return std::to_string(val); + } + }; + + template <> + struct For + { + static Optional FromString(std::string_view str, int base = 10) + { + try { + if (str.empty()) + return std::nullopt; + size_t n; + int64 val = std::stoll(std::string(str), &n, base); + if (n != str.length()) + return std::nullopt; + return val; + } + catch (...) { return std::nullopt; } + } + + static std::string ToString(int64 val) + { + return std::to_string(val); + } + }; +#endif + + template <> + struct For + { + static Optional FromString(std::string_view str, int strict = 0) /* this is int to match the signature for "proper" integral types */ + { + if (strict) + { + if (str == "1") + return true; + if (str == "0") + return false; + return std::nullopt; + } + else + { + if ((str == "1") || StringEqualI(str, "y") || StringEqualI(str, "on") || StringEqualI(str, "yes") || StringEqualI(str, "true")) + return true; + if ((str == "0") || StringEqualI(str, "n") || StringEqualI(str, "off") || StringEqualI(str, "no") || StringEqualI(str, "false")) + return false; + return std::nullopt; + } + } + + static std::string ToString(bool val) + { + return (val ? "1" : "0"); + } + }; + +#if AC_COMPILER == AC_COMPILER_MICROSOFT + template + struct For>> + { + static Optional FromString(std::string_view str, std::chars_format fmt = std::chars_format()) + { + if (str.empty()) + return std::nullopt; + + if (fmt == std::chars_format()) + { + if (StringEqualI(str.substr(0, 2), "0x")) + { + fmt = std::chars_format::hex; + str.remove_prefix(2); + } + else + fmt = std::chars_format::general; + + if (str.empty()) + return std::nullopt; + } + + char const* const start = str.data(); + char const* const end = (start + str.length()); + + T val; + std::from_chars_result const res = std::from_chars(start, end, val, fmt); + if ((res.ptr == end) && (res.ec == std::errc())) + return val; + else + return std::nullopt; + } + + // this allows generic converters for all numeric types (easier templating!) + static Optional FromString(std::string_view str, int base) + { + if (base == 16) + return FromString(str, std::chars_format::hex); + else if (base == 10) + return FromString(str, std::chars_format::general); + else + return FromString(str, std::chars_format()); + } + + static std::string ToString(T val) + { + return std::to_string(val); + } + }; +#else + // @todo replace this once libc++ supports double args to from_chars + template + struct For>> + { + static Optional FromString(std::string_view str, int base = 0) + { + try { + if (str.empty()) + return std::nullopt; + + if ((base == 10) && StringEqualI(str.substr(0, 2), "0x")) + return std::nullopt; + + std::string tmp; + if (base == 16) + tmp.append("0x"); + tmp.append(str); + + size_t n; + T val = static_cast(std::stold(tmp, &n)); + if (n != tmp.length()) + return std::nullopt; + return val; + } + catch (...) { return std::nullopt; } + } + + static std::string ToString(T val) + { + return std::to_string(val); + } + }; +#endif +} + +namespace acore +{ + template + Optional StringTo(std::string_view str, Params&&... params) + { + return acore::Impl::StringConvertImpl::For::FromString(str, std::forward(params)...); + } + + template + std::string ToString(Type&& val, Params&&... params) + { + return acore::Impl::StringConvertImpl::For>::ToString(std::forward(val), std::forward(params)...); + } +} + +#endif // _ACORE_STRINGCONVERT_H_ diff --git a/src/common/Utilities/StringFormat.cpp b/src/common/Utilities/StringFormat.cpp new file mode 100644 index 000000000..64d3a2212 --- /dev/null +++ b/src/common/Utilities/StringFormat.cpp @@ -0,0 +1,40 @@ +/* + * Copyright (C) 2016+ AzerothCore , released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3 + * Copyright (C) 2021+ WarheadCore + */ + +#include "StringFormat.h" + +// Taken from https://stackoverflow.com/a/1798170 +std::string acore::String::Trim(std::string const& str, std::string_view whitespace /*= " \t"*/) +{ + const auto strBegin = str.find_first_not_of(whitespace); + if (strBegin == std::string::npos) + return ""; // no content + + auto const strEnd = str.find_last_not_of(whitespace); + auto const strRange = strEnd - strBegin + 1; + + return str.substr(strBegin, strRange); +} + +std::string acore::String::Reduce(std::string const& str, std::string_view fill /*= " "*/, std::string_view whitespace /*= " \t"*/) +{ + // trim first + auto result = Trim(str, whitespace); + + // replace sub ranges + auto beginSpace = result.find_first_of(whitespace); + while (beginSpace != std::string::npos) + { + const auto endSpace = result.find_first_not_of(whitespace, beginSpace); + const auto range = endSpace - beginSpace; + + result.replace(beginSpace, range, fill); + + const auto newStart = beginSpace + fill.length(); + beginSpace = result.find_first_of(whitespace, newStart); + } + + return result; +} diff --git a/src/common/Utilities/StringFormat.h b/src/common/Utilities/StringFormat.h index 99197ef75..0af0e492e 100644 --- a/src/common/Utilities/StringFormat.h +++ b/src/common/Utilities/StringFormat.h @@ -1,13 +1,14 @@ /* - * Copyright (C) 2016+ AzerothCore , released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3 + * Copyright (C) 2016+ AzerothCore , released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3 + * Copyright (C) 2021+ WarheadCore * Copyright (C) 2008-2016 TrinityCore * Copyright (C) 2005-2009 MaNGOS */ -#ifndef __STRING_FORMAT_H__ -#define __STRING_FORMAT_H__ +#ifndef _STRING_FORMAT_H_ +#define _STRING_FORMAT_H_ -#include "fmt/printf.h" +#include namespace acore { @@ -39,4 +40,10 @@ namespace acore } } +namespace acore::String +{ + std::string Trim(std::string const& str, std::string_view whitespace = " \t"); + std::string Reduce(std::string const& str, std::string_view fill = " ", std::string_view whitespace = " \t"); +} + #endif diff --git a/src/common/Utilities/Types.h b/src/common/Utilities/Types.h new file mode 100644 index 000000000..622809376 --- /dev/null +++ b/src/common/Utilities/Types.h @@ -0,0 +1,63 @@ +/* + * Copyright (C) 2016+ AzerothCore , released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3 + * Copyright (C) 2021+ WarheadCore + */ + +#ifndef _TYPES_H_ +#define _TYPES_H_ + +#include "advstd.h" + +namespace acore +{ + // end "iterator" tag for find_type_if + struct find_type_end; + + template typename Check, typename... Ts> + struct find_type_if; + + template typename Check> + struct find_type_if + { + using type = find_type_end; + }; + + template typename Check, typename T1, typename... Ts> + struct find_type_if : std::conditional_t::value, advstd::type_identity, find_type_if> + { + }; + + /* + Utility to find a type matching predicate (Check) in a given type list (Ts) + Evaluates to first type matching predicate or find_type_end + Check must be a type that contains static bool ::value, _v aliases don't work + + template + struct Example + { + using TupleArg = acore::find_type_if_t; + + bool HasTuple() + { + return !std::is_same_v; + } + }; + + Example, char> example; + example.HasTuple() == true; // TupleArg is std::tuple + + Example example2; + example2.HasTuple() == false; // TupleArg is acore::find_type_end + */ + + template typename Check, typename... Ts> + using find_type_if_t = typename find_type_if::type; + + template + struct dependant_false { static constexpr bool value = false; }; + + template + constexpr bool dependant_false_v = dependant_false::value; +} + +#endif // _TYPES_H_ diff --git a/src/common/Utilities/Util.cpp b/src/common/Utilities/Util.cpp index 526ac26eb..268bd9876 100644 --- a/src/common/Utilities/Util.cpp +++ b/src/common/Utilities/Util.cpp @@ -682,15 +682,13 @@ void HexStrToByteArray(std::string const& str, uint8* out, bool reverse /*= fals } } -bool StringToBool(std::string const& str) -{ - std::string lowerStr = str; - std::transform(str.begin(), str.end(), lowerStr.begin(), ::tolower); - return lowerStr == "1" || lowerStr == "true" || lowerStr == "yes"; -} - bool StringContainsStringI(std::string const& haystack, std::string const& needle) { return haystack.end() != std::search(haystack.begin(), haystack.end(), needle.begin(), needle.end(), [](char c1, char c2) { return std::toupper(c1) == std::toupper(c2); }); } + +bool StringEqualI(std::string_view a, std::string_view b) +{ + return std::equal(a.begin(), a.end(), b.begin(), b.end(), [](char c1, char c2) { return std::tolower(c1) == std::tolower(c2); }); +} diff --git a/src/common/Utilities/Util.h b/src/common/Utilities/Util.h index 962e5600b..68aa8e8df 100644 --- a/src/common/Utilities/Util.h +++ b/src/common/Utilities/Util.h @@ -343,9 +343,10 @@ std::string GetAddressString(ACE_INET_Addr const& addr); uint32 CreatePIDFile(const std::string& filename); uint32 GetPID(); +bool StringEqualI(std::string_view str1, std::string_view str2); + std::string ByteArrayToHexStr(uint8 const* bytes, uint32 length, bool reverse = false); void HexStrToByteArray(std::string const& str, uint8* out, bool reverse = false); -bool StringToBool(std::string const& str); bool StringContainsStringI(std::string const& haystack, std::string const& needle); template diff --git a/src/common/Utilities/advstd.h b/src/common/Utilities/advstd.h new file mode 100644 index 000000000..04f5d0442 --- /dev/null +++ b/src/common/Utilities/advstd.h @@ -0,0 +1,31 @@ +/* + * Copyright (C) 2016+ AzerothCore , released under GNU AGPL v3 license: https://github.com/azerothcore/azerothcore-wotlk/blob/master/LICENSE-AGPL3 + * Copyright (C) 2021+ WarheadCore + */ + +#ifndef _ACORE_ADV_STD_H_ +#define _ACORE_ADV_STD_H_ + +#include +#include + +// this namespace holds implementations of upcoming stdlib features that our c++ version doesn't have yet +namespace advstd +{ + // C++20 advstd::remove_cvref_t + template + using remove_cvref_t = std::remove_cv_t>; + + // C++20 std::type_identity + template + struct type_identity + { + using type = T; + }; + + // C++20 std::type_identity_t + template + using type_identity_t = typename type_identity::type; +} + +#endif // _ADV_STD_H_ diff --git a/src/server/authserver/CMakeLists.txt b/src/server/authserver/CMakeLists.txt index 4ae0bab4c..4b249af1d 100644 --- a/src/server/authserver/CMakeLists.txt +++ b/src/server/authserver/CMakeLists.txt @@ -36,11 +36,6 @@ add_executable(authserver add_dependencies(authserver revision.h) -if(NOT WIN32) - set_target_properties(authserver PROPERTIES - COMPILE_DEFINITIONS _ACORE_REALM_CONFIG="${CONF_DIR}/authserver.conf") -endif() - target_link_libraries(authserver PUBLIC shared) @@ -62,28 +57,15 @@ set_target_properties(authserver FOLDER "server") -if( WIN32 ) - if ( MSVC ) - add_custom_command(TARGET authserver - POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/authserver.conf.dist ${CMAKE_BINARY_DIR}/bin/$(ConfigurationName)/ - ) - elseif ( MINGW ) - add_custom_command(TARGET authserver - POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/authserver.conf.dist ${CMAKE_BINARY_DIR}/bin/ - ) - endif() -endif() +# Install config +CopyDefaultConfig(authserver) -if( UNIX ) +if ( UNIX ) install(TARGETS authserver DESTINATION bin) -elseif( WIN32 ) +elseif ( WIN32 ) install(TARGETS authserver DESTINATION "${CMAKE_INSTALL_PREFIX}") endif() -install(FILES authserver.conf.dist DESTINATION ${CONF_DIR}) - # Generate precompiled header if (USE_COREPCH) add_cxx_pch(authserver ${PRIVATE_PCH_HEADER}) diff --git a/src/server/authserver/Main.cpp b/src/server/authserver/Main.cpp index 32799c76a..509d76c6d 100644 --- a/src/server/authserver/Main.cpp +++ b/src/server/authserver/Main.cpp @@ -74,7 +74,7 @@ void usage(const char* prog) extern int main(int argc, char** argv) { // Command line parsing to get the configuration file name - char const* configFile = _ACORE_REALM_CONFIG; + std::string configFile = sConfigMgr->GetConfigPath() + std::string(_ACORE_REALM_CONFIG); int count = 1; while (count < argc) { @@ -92,9 +92,10 @@ extern int main(int argc, char** argv) ++count; } - sConfigMgr->SetConfigList(std::string(configFile)); + // Add file and args in config + sConfigMgr->Configure(configFile, std::vector(argv, argv + argc)); - if (!sConfigMgr->LoadAppConfigs("authserver")) + if (!sConfigMgr->LoadAppConfigs()) return 1; sLog->outString("%s (authserver)", GitRevision::GetFullVersion()); @@ -115,7 +116,7 @@ extern int main(int argc, char** argv) sLog->outString(" AzerothCore 3.3.5a - www.azerothcore.org\n"); - sLog->outString("Using configuration file %s.", configFile); + sLog->outString("Using configuration file %s.", configFile.c_str()); sLog->outDetail("%s (Library: %s)", OPENSSL_VERSION_TEXT, SSLeay_version(SSLEAY_VERSION)); @@ -128,7 +129,7 @@ extern int main(int argc, char** argv) sLog->outBasic("Max allowed open files is %d", ACE::max_handles()); // authserver PID file creation - std::string pidFile = sConfigMgr->GetStringDefault("PidFile", ""); + std::string pidFile = sConfigMgr->GetOption("PidFile", ""); if (!pidFile.empty()) { if (uint32 pid = CreatePIDFile(pidFile)) @@ -149,7 +150,7 @@ extern int main(int argc, char** argv) sLog->SetRealmID(0); // ensure we've set realm to 0 (authserver realmid) // Get the list of realms for the server - sRealmList->Initialize(sConfigMgr->GetIntDefault("RealmsStateUpdateDelay", 20)); + sRealmList->Initialize(sConfigMgr->GetOption("RealmsStateUpdateDelay", 20)); if (sRealmList->size() == 0) { sLog->outError("No valid realms specified."); @@ -159,14 +160,14 @@ extern int main(int argc, char** argv) // Launch the listening network socket RealmAcceptor acceptor; - int32 rmport = sConfigMgr->GetIntDefault("RealmServerPort", 3724); + int32 rmport = sConfigMgr->GetOption("RealmServerPort", 3724); if (rmport < 0 || rmport > 0xFFFF) { sLog->outError("The specified RealmServerPort (%d) is out of the allowed range (1-65535)", rmport); return 1; } - std::string bind_ip = sConfigMgr->GetStringDefault("BindIP", "0.0.0.0"); + std::string bind_ip = sConfigMgr->GetOption("BindIP", "0.0.0.0"); ACE_INET_Addr bind_addr(uint16(rmport), bind_ip.c_str()); @@ -189,8 +190,8 @@ extern int main(int argc, char** argv) #if defined(_WIN32) || defined(__linux__) ///- Handle affinity for multiple processors and process priority - uint32 affinity = sConfigMgr->GetIntDefault("UseProcessors", 0); - bool highPriority = sConfigMgr->GetBoolDefault("ProcessPriority", false); + uint32 affinity = sConfigMgr->GetOption("UseProcessors", 0); + bool highPriority = sConfigMgr->GetOption("ProcessPriority", false); #ifdef _WIN32 // Windows @@ -255,11 +256,11 @@ extern int main(int argc, char** argv) #endif // maximum counter for next ping - uint32 numLoops = (sConfigMgr->GetIntDefault("MaxPingTime", 30) * (MINUTE * 1000000 / 100000)); + uint32 numLoops = (sConfigMgr->GetOption("MaxPingTime", 30) * (MINUTE * 1000000 / 100000)); uint32 loopCounter = 0; // possibly enable db logging; avoid massive startup spam by doing it here. - if (sConfigMgr->GetBoolDefault("EnableLogDB", false)) + if (sConfigMgr->GetOption("EnableLogDB", false)) { sLog->outString("Enabling database logging..."); sLog->SetLogDB(true); @@ -294,21 +295,21 @@ bool StartDB() { MySQL::Library_Init(); - std::string dbstring = sConfigMgr->GetStringDefault("LoginDatabaseInfo", ""); + std::string dbstring = sConfigMgr->GetOption("LoginDatabaseInfo", ""); if (dbstring.empty()) { sLog->outError("Database not specified"); return false; } - int32 worker_threads = sConfigMgr->GetIntDefault("LoginDatabase.WorkerThreads", 1); + int32 worker_threads = sConfigMgr->GetOption("LoginDatabase.WorkerThreads", 1); if (worker_threads < 1 || worker_threads > 32) { sLog->outError("Improper value specified for LoginDatabase.WorkerThreads, defaulting to 1."); worker_threads = 1; } - int32 synch_threads = sConfigMgr->GetIntDefault("LoginDatabase.SynchThreads", 1); + int32 synch_threads = sConfigMgr->GetOption("LoginDatabase.SynchThreads", 1); if (synch_threads < 1 || synch_threads > 32) { sLog->outError("Improper value specified for LoginDatabase.SynchThreads, defaulting to 1."); diff --git a/src/server/authserver/Server/AuthSocket.cpp b/src/server/authserver/Server/AuthSocket.cpp index 156a28a13..135474a6f 100644 --- a/src/server/authserver/Server/AuthSocket.cpp +++ b/src/server/authserver/Server/AuthSocket.cpp @@ -776,10 +776,10 @@ bool AuthSocket::_HandleLogonProof() sLog->outDebug(LOG_FILTER_NETWORKIO, "'%s:%d' [AuthChallenge] account %s tried to login with invalid password!", socket().getRemoteAddress().c_str(), socket().getRemotePort(), _login.c_str()); #endif - uint32 MaxWrongPassCount = sConfigMgr->GetIntDefault("WrongPass.MaxCount", 0); + uint32 MaxWrongPassCount = sConfigMgr->GetOption("WrongPass.MaxCount", 0); // We can not include the failed account login hook. However, this is a workaround to still log this. - if (sConfigMgr->GetBoolDefault("WrongPass.Logging", false)) + if (sConfigMgr->GetOption("WrongPass.Logging", false)) { PreparedStatement* logstmt = LoginDatabase.GetPreparedStatement(LOGIN_INS_FALP_IP_LOGGING); logstmt->setString(0, _login); @@ -805,8 +805,8 @@ bool AuthSocket::_HandleLogonProof() if (failed_logins >= MaxWrongPassCount) { - uint32 WrongPassBanTime = sConfigMgr->GetIntDefault("WrongPass.BanTime", 600); - bool WrongPassBanType = sConfigMgr->GetBoolDefault("WrongPass.BanType", false); + uint32 WrongPassBanTime = sConfigMgr->GetOption("WrongPass.BanTime", 600); + bool WrongPassBanType = sConfigMgr->GetOption("WrongPass.BanType", false); if (WrongPassBanType) { diff --git a/src/server/game/AI/CoreAI/PetAI.cpp b/src/server/game/AI/CoreAI/PetAI.cpp index 55d84681c..f2a73c360 100644 --- a/src/server/game/AI/CoreAI/PetAI.cpp +++ b/src/server/game/AI/CoreAI/PetAI.cpp @@ -336,7 +336,6 @@ void PetAI::UpdateAI(uint32 diff) delete itr->second; } - // Update speed as needed to prevent dropping too far behind and despawning me->UpdateSpeed(MOVE_RUN, true); me->UpdateSpeed(MOVE_WALK, true); diff --git a/src/server/game/Entities/Creature/Creature.cpp b/src/server/game/Entities/Creature/Creature.cpp index e96cc8c01..6d0c7020e 100644 --- a/src/server/game/Entities/Creature/Creature.cpp +++ b/src/server/game/Entities/Creature/Creature.cpp @@ -1839,7 +1839,6 @@ void Creature::LoadSpellTemplateImmunity() } } - bool Creature::IsImmunedToSpell(SpellInfo const* spellInfo) { if (!spellInfo) diff --git a/src/server/game/Entities/Object/Object.cpp b/src/server/game/Entities/Object/Object.cpp index bb9a2c7c3..806ccafb1 100644 --- a/src/server/game/Entities/Object/Object.cpp +++ b/src/server/game/Entities/Object/Object.cpp @@ -897,7 +897,6 @@ bool Object::PrintIndexError(uint32 index, bool set) const return false; } - bool Position::operator==(Position const& a) { return (G3D::fuzzyEq(a.m_positionX, m_positionX) && diff --git a/src/server/game/Guilds/Guild.cpp b/src/server/game/Guilds/Guild.cpp index 6fd9f5dd2..a1a15e340 100644 --- a/src/server/game/Guilds/Guild.cpp +++ b/src/server/game/Guilds/Guild.cpp @@ -2140,7 +2140,7 @@ bool Guild::Validate() _SetLeaderGUID(pLeader); // Check config if multiple guildmasters are allowed - if (!sConfigMgr->GetBoolDefault("Guild.AllowMultipleGuildMaster", 0)) + if (!sConfigMgr->GetOption("Guild.AllowMultipleGuildMaster", 0)) for (Members::iterator itr = m_members.begin(); itr != m_members.end(); ++itr) if (itr->second->GetRankId() == GR_GUILDMASTER && !itr->second->IsSamePlayer(m_leaderGuid)) itr->second->ChangeRank(GR_OFFICER); diff --git a/src/server/game/Maps/Map.cpp b/src/server/game/Maps/Map.cpp index cf1ef0809..e1aa1edab 100644 --- a/src/server/game/Maps/Map.cpp +++ b/src/server/game/Maps/Map.cpp @@ -2303,7 +2303,6 @@ bool Map::HasEnoughWater(WorldObject const* searcher, LiquidData liquidData) con return liquidData.level > INVALID_HEIGHT && liquidData.level > liquidData.depth_level && liquidData.level - liquidData.depth_level >= minHeightInWater; } - char const* Map::GetMapName() const { return i_mapEntry ? i_mapEntry->name[sWorld->GetDefaultDbcLocale()] : "UNNAMEDMAP\x0"; diff --git a/src/server/game/Movement/MovementGenerators/PathGenerator.cpp b/src/server/game/Movement/MovementGenerators/PathGenerator.cpp index 4ab95dbe6..c86106449 100644 --- a/src/server/game/Movement/MovementGenerators/PathGenerator.cpp +++ b/src/server/game/Movement/MovementGenerators/PathGenerator.cpp @@ -1131,7 +1131,6 @@ bool PathGenerator::IsSwimmableSegment(float const* v1, float const* v2, bool ch return IsSwimmableSegment(v1[2], v1[0], v1[1], v2[2], v2[0], v2[1], checkSwim); } - /** * @brief predict if a certain segment is underwater and the unit can swim * Must only be used for very short segments since this check doesn't work on diff --git a/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp b/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp index 8dd91e0fd..299fcbc81 100644 --- a/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp +++ b/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.cpp @@ -65,7 +65,6 @@ bool ChaseMovementGenerator::DoUpdate(T* owner, uint32 time_diff) (owner->CanFly()) ; // closes "bool forceDest", that way it is more appropriate, so we can comment out crap whenever we need to - Unit* target = i_target.getTarget(); bool const mutualChase = IsMutualChase(owner, target); @@ -272,7 +271,6 @@ bool FollowMovementGenerator::DoUpdate(T* owner, uint32 time_diff) (i_target->GetTypeId() == TYPEID_PLAYER && i_target->ToPlayer()->IsGameMaster()) // for .npc follow ; // closes "bool forceDest", that way it is more appropriate, so we can comment out crap whenever we need to - i_recheckDistance.Update(time_diff); if (i_recheckDistance.Passed()) { diff --git a/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.h b/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.h index 27a0d5b8c..db81359f5 100644 --- a/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.h +++ b/src/server/game/Movement/MovementGenerators/TargetedMovementGenerator.h @@ -23,7 +23,6 @@ protected: FollowerReference i_target; }; - template class ChaseMovementGenerator : public MovementGeneratorMedium>, public TargetedMovementGeneratorBase { diff --git a/src/server/game/Server/Protocol/PacketLog.cpp b/src/server/game/Server/Protocol/PacketLog.cpp index ce9d9c075..7717d36f5 100644 --- a/src/server/game/Server/Protocol/PacketLog.cpp +++ b/src/server/game/Server/Protocol/PacketLog.cpp @@ -30,13 +30,13 @@ PacketLog* PacketLog::instance() void PacketLog::Initialize() { - std::string logsDir = sConfigMgr->GetStringDefault("LogsDir", ""); + std::string logsDir = sConfigMgr->GetOption("LogsDir", ""); if (!logsDir.empty()) if ((logsDir.at(logsDir.length() - 1) != '/') && (logsDir.at(logsDir.length() - 1) != '\\')) logsDir.push_back('/'); - std::string logname = sConfigMgr->GetStringDefault("PacketLogFile", ""); + std::string logname = sConfigMgr->GetOption("PacketLogFile", ""); if (!logname.empty()) _file = fopen((logsDir + logname).c_str(), "wb"); } diff --git a/src/server/game/Server/WorldSocketMgr.cpp b/src/server/game/Server/WorldSocketMgr.cpp index ba4a575ed..29daa5c19 100644 --- a/src/server/game/Server/WorldSocketMgr.cpp +++ b/src/server/game/Server/WorldSocketMgr.cpp @@ -222,9 +222,9 @@ WorldSocketMgr* WorldSocketMgr::instance() int WorldSocketMgr::StartReactiveIO (uint16 port, const char* address) { - m_UseNoDelay = sConfigMgr->GetBoolDefault ("Network.TcpNodelay", true); + m_UseNoDelay = sConfigMgr->GetOption ("Network.TcpNodelay", true); - int num_threads = sConfigMgr->GetIntDefault ("Network.Threads", 1); + int num_threads = sConfigMgr->GetOption ("Network.Threads", 1); if (num_threads <= 0) { @@ -239,9 +239,9 @@ WorldSocketMgr::StartReactiveIO (uint16 port, const char* address) sLog->outBasic ("Max allowed socket connections %d", ACE::max_handles()); // -1 means use default - m_SockOutKBuff = sConfigMgr->GetIntDefault ("Network.OutKBuff", -1); + m_SockOutKBuff = sConfigMgr->GetOption ("Network.OutKBuff", -1); - m_SockOutUBuff = sConfigMgr->GetIntDefault ("Network.OutUBuff", 65536); + m_SockOutUBuff = sConfigMgr->GetOption ("Network.OutUBuff", 65536); if (m_SockOutUBuff <= 0) { diff --git a/src/server/game/Warden/WardenCheckMgr.cpp b/src/server/game/Warden/WardenCheckMgr.cpp index df3d37e83..37a45c933 100644 --- a/src/server/game/Warden/WardenCheckMgr.cpp +++ b/src/server/game/Warden/WardenCheckMgr.cpp @@ -238,4 +238,3 @@ WardenCheckResult const* WardenCheckMgr::GetWardenResultById(uint16 Id) return nullptr; } - diff --git a/src/server/game/World/World.cpp b/src/server/game/World/World.cpp index 42705b5ba..f8692b9ad 100644 --- a/src/server/game/World/World.cpp +++ b/src/server/game/World/World.cpp @@ -442,141 +442,141 @@ void World::LoadConfigSettings(bool reload) ///- Read the player limit and the Message of the day from the config file if (!reload) { - SetPlayerAmountLimit(sConfigMgr->GetIntDefault("PlayerLimit", 1000)); + SetPlayerAmountLimit(sConfigMgr->GetOption("PlayerLimit", 1000)); } - Motd::SetMotd(sConfigMgr->GetStringDefault("Motd", "Welcome to an AzerothCore server")); + Motd::SetMotd(sConfigMgr->GetOption("Motd", "Welcome to an AzerothCore server")); ///- Read ticket system setting from the config file - m_bool_configs[CONFIG_ALLOW_TICKETS] = sConfigMgr->GetBoolDefault("AllowTickets", true); - m_bool_configs[CONFIG_DELETE_CHARACTER_TICKET_TRACE] = sConfigMgr->GetBoolDefault("DeletedCharacterTicketTrace", false); + m_bool_configs[CONFIG_ALLOW_TICKETS] = sConfigMgr->GetOption("AllowTickets", true); + m_bool_configs[CONFIG_DELETE_CHARACTER_TICKET_TRACE] = sConfigMgr->GetOption("DeletedCharacterTicketTrace", false); ///- Get string for new logins (newly created characters) - SetNewCharString(sConfigMgr->GetStringDefault("PlayerStart.String", "")); + SetNewCharString(sConfigMgr->GetOption("PlayerStart.String", "")); ///- Send server info on login? - m_int_configs[CONFIG_ENABLE_SINFO_LOGIN] = sConfigMgr->GetIntDefault("Server.LoginInfo", 0); + m_int_configs[CONFIG_ENABLE_SINFO_LOGIN] = sConfigMgr->GetOption("Server.LoginInfo", 0); ///- Read all rates from the config file - rate_values[RATE_HEALTH] = sConfigMgr->GetFloatDefault("Rate.Health", 1); + rate_values[RATE_HEALTH] = sConfigMgr->GetOption("Rate.Health", 1); if (rate_values[RATE_HEALTH] < 0) { sLog->outError("Rate.Health (%f) must be > 0. Using 1 instead.", rate_values[RATE_HEALTH]); rate_values[RATE_HEALTH] = 1; } - rate_values[RATE_POWER_MANA] = sConfigMgr->GetFloatDefault("Rate.Mana", 1); + rate_values[RATE_POWER_MANA] = sConfigMgr->GetOption("Rate.Mana", 1); if (rate_values[RATE_POWER_MANA] < 0) { sLog->outError("Rate.Mana (%f) must be > 0. Using 1 instead.", rate_values[RATE_POWER_MANA]); rate_values[RATE_POWER_MANA] = 1; } - rate_values[RATE_POWER_RAGE_INCOME] = sConfigMgr->GetFloatDefault("Rate.Rage.Income", 1); - rate_values[RATE_POWER_RAGE_LOSS] = sConfigMgr->GetFloatDefault("Rate.Rage.Loss", 1); + rate_values[RATE_POWER_RAGE_INCOME] = sConfigMgr->GetOption("Rate.Rage.Income", 1); + rate_values[RATE_POWER_RAGE_LOSS] = sConfigMgr->GetOption("Rate.Rage.Loss", 1); if (rate_values[RATE_POWER_RAGE_LOSS] < 0) { sLog->outError("Rate.Rage.Loss (%f) must be > 0. Using 1 instead.", rate_values[RATE_POWER_RAGE_LOSS]); rate_values[RATE_POWER_RAGE_LOSS] = 1; } - rate_values[RATE_POWER_RUNICPOWER_INCOME] = sConfigMgr->GetFloatDefault("Rate.RunicPower.Income", 1); - rate_values[RATE_POWER_RUNICPOWER_LOSS] = sConfigMgr->GetFloatDefault("Rate.RunicPower.Loss", 1); + rate_values[RATE_POWER_RUNICPOWER_INCOME] = sConfigMgr->GetOption("Rate.RunicPower.Income", 1); + rate_values[RATE_POWER_RUNICPOWER_LOSS] = sConfigMgr->GetOption("Rate.RunicPower.Loss", 1); if (rate_values[RATE_POWER_RUNICPOWER_LOSS] < 0) { sLog->outError("Rate.RunicPower.Loss (%f) must be > 0. Using 1 instead.", rate_values[RATE_POWER_RUNICPOWER_LOSS]); rate_values[RATE_POWER_RUNICPOWER_LOSS] = 1; } - rate_values[RATE_POWER_FOCUS] = sConfigMgr->GetFloatDefault("Rate.Focus", 1.0f); - rate_values[RATE_POWER_ENERGY] = sConfigMgr->GetFloatDefault("Rate.Energy", 1.0f); + rate_values[RATE_POWER_FOCUS] = sConfigMgr->GetOption("Rate.Focus", 1.0f); + rate_values[RATE_POWER_ENERGY] = sConfigMgr->GetOption("Rate.Energy", 1.0f); - rate_values[RATE_SKILL_DISCOVERY] = sConfigMgr->GetFloatDefault("Rate.Skill.Discovery", 1.0f); + rate_values[RATE_SKILL_DISCOVERY] = sConfigMgr->GetOption("Rate.Skill.Discovery", 1.0f); - rate_values[RATE_DROP_ITEM_POOR] = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Poor", 1.0f); - rate_values[RATE_DROP_ITEM_NORMAL] = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Normal", 1.0f); - rate_values[RATE_DROP_ITEM_UNCOMMON] = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Uncommon", 1.0f); - rate_values[RATE_DROP_ITEM_RARE] = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Rare", 1.0f); - rate_values[RATE_DROP_ITEM_EPIC] = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Epic", 1.0f); - rate_values[RATE_DROP_ITEM_LEGENDARY] = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Legendary", 1.0f); - rate_values[RATE_DROP_ITEM_ARTIFACT] = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Artifact", 1.0f); - rate_values[RATE_DROP_ITEM_REFERENCED] = sConfigMgr->GetFloatDefault("Rate.Drop.Item.Referenced", 1.0f); - rate_values[RATE_DROP_ITEM_REFERENCED_AMOUNT] = sConfigMgr->GetFloatDefault("Rate.Drop.Item.ReferencedAmount", 1.0f); - rate_values[RATE_DROP_MONEY] = sConfigMgr->GetFloatDefault("Rate.Drop.Money", 1.0f); - rate_values[RATE_REWARD_BONUS_MONEY] = sConfigMgr->GetFloatDefault("Rate.RewardBonusMoney", 1.0f); - rate_values[RATE_XP_KILL] = sConfigMgr->GetFloatDefault("Rate.XP.Kill", 1.0f); - rate_values[RATE_XP_BG_KILL] = sConfigMgr->GetFloatDefault("Rate.XP.BattlegroundKill", 1.0f); - rate_values[RATE_XP_QUEST] = sConfigMgr->GetFloatDefault("Rate.XP.Quest", 1.0f); - rate_values[RATE_XP_EXPLORE] = sConfigMgr->GetFloatDefault("Rate.XP.Explore", 1.0f); - rate_values[RATE_XP_PET] = sConfigMgr->GetFloatDefault("Rate.XP.Pet", 1.0f); - rate_values[RATE_XP_PET_NEXT_LEVEL] = sConfigMgr->GetFloatDefault("Rate.Pet.LevelXP", 0.05f); - rate_values[RATE_REPAIRCOST] = sConfigMgr->GetFloatDefault("Rate.RepairCost", 1.0f); + rate_values[RATE_DROP_ITEM_POOR] = sConfigMgr->GetOption("Rate.Drop.Item.Poor", 1.0f); + rate_values[RATE_DROP_ITEM_NORMAL] = sConfigMgr->GetOption("Rate.Drop.Item.Normal", 1.0f); + rate_values[RATE_DROP_ITEM_UNCOMMON] = sConfigMgr->GetOption("Rate.Drop.Item.Uncommon", 1.0f); + rate_values[RATE_DROP_ITEM_RARE] = sConfigMgr->GetOption("Rate.Drop.Item.Rare", 1.0f); + rate_values[RATE_DROP_ITEM_EPIC] = sConfigMgr->GetOption("Rate.Drop.Item.Epic", 1.0f); + rate_values[RATE_DROP_ITEM_LEGENDARY] = sConfigMgr->GetOption("Rate.Drop.Item.Legendary", 1.0f); + rate_values[RATE_DROP_ITEM_ARTIFACT] = sConfigMgr->GetOption("Rate.Drop.Item.Artifact", 1.0f); + rate_values[RATE_DROP_ITEM_REFERENCED] = sConfigMgr->GetOption("Rate.Drop.Item.Referenced", 1.0f); + rate_values[RATE_DROP_ITEM_REFERENCED_AMOUNT] = sConfigMgr->GetOption("Rate.Drop.Item.ReferencedAmount", 1.0f); + rate_values[RATE_DROP_MONEY] = sConfigMgr->GetOption("Rate.Drop.Money", 1.0f); + rate_values[RATE_REWARD_BONUS_MONEY] = sConfigMgr->GetOption("Rate.RewardBonusMoney", 1.0f); + rate_values[RATE_XP_KILL] = sConfigMgr->GetOption("Rate.XP.Kill", 1.0f); + rate_values[RATE_XP_BG_KILL] = sConfigMgr->GetOption("Rate.XP.BattlegroundKill", 1.0f); + rate_values[RATE_XP_QUEST] = sConfigMgr->GetOption("Rate.XP.Quest", 1.0f); + rate_values[RATE_XP_EXPLORE] = sConfigMgr->GetOption("Rate.XP.Explore", 1.0f); + rate_values[RATE_XP_PET] = sConfigMgr->GetOption("Rate.XP.Pet", 1.0f); + rate_values[RATE_XP_PET_NEXT_LEVEL] = sConfigMgr->GetOption("Rate.Pet.LevelXP", 0.05f); + rate_values[RATE_REPAIRCOST] = sConfigMgr->GetOption("Rate.RepairCost", 1.0f); - rate_values[RATE_SELLVALUE_ITEM_POOR] = sConfigMgr->GetFloatDefault("Rate.SellValue.Item.Poor", 1.0f); - rate_values[RATE_SELLVALUE_ITEM_NORMAL] = sConfigMgr->GetFloatDefault("Rate.SellValue.Item.Normal", 1.0f); - rate_values[RATE_SELLVALUE_ITEM_UNCOMMON] = sConfigMgr->GetFloatDefault("Rate.SellValue.Item.Uncommon", 1.0f); - rate_values[RATE_SELLVALUE_ITEM_RARE] = sConfigMgr->GetFloatDefault("Rate.SellValue.Item.Rare", 1.0f); - rate_values[RATE_SELLVALUE_ITEM_EPIC] = sConfigMgr->GetFloatDefault("Rate.SellValue.Item.Epic", 1.0f); - rate_values[RATE_SELLVALUE_ITEM_LEGENDARY] = sConfigMgr->GetFloatDefault("Rate.SellValue.Item.Legendary", 1.0f); - rate_values[RATE_SELLVALUE_ITEM_ARTIFACT] = sConfigMgr->GetFloatDefault("Rate.SellValue.Item.Artifact", 1.0f); - rate_values[RATE_SELLVALUE_ITEM_HEIRLOOM] = sConfigMgr->GetFloatDefault("Rate.SellValue.Item.Heirloom", 1.0f); + rate_values[RATE_SELLVALUE_ITEM_POOR] = sConfigMgr->GetOption("Rate.SellValue.Item.Poor", 1.0f); + rate_values[RATE_SELLVALUE_ITEM_NORMAL] = sConfigMgr->GetOption("Rate.SellValue.Item.Normal", 1.0f); + rate_values[RATE_SELLVALUE_ITEM_UNCOMMON] = sConfigMgr->GetOption("Rate.SellValue.Item.Uncommon", 1.0f); + rate_values[RATE_SELLVALUE_ITEM_RARE] = sConfigMgr->GetOption("Rate.SellValue.Item.Rare", 1.0f); + rate_values[RATE_SELLVALUE_ITEM_EPIC] = sConfigMgr->GetOption("Rate.SellValue.Item.Epic", 1.0f); + rate_values[RATE_SELLVALUE_ITEM_LEGENDARY] = sConfigMgr->GetOption("Rate.SellValue.Item.Legendary", 1.0f); + rate_values[RATE_SELLVALUE_ITEM_ARTIFACT] = sConfigMgr->GetOption("Rate.SellValue.Item.Artifact", 1.0f); + rate_values[RATE_SELLVALUE_ITEM_HEIRLOOM] = sConfigMgr->GetOption("Rate.SellValue.Item.Heirloom", 1.0f); - rate_values[ RATE_BUYVALUE_ITEM_POOR] = sConfigMgr->GetFloatDefault("Rate.BuyValue.Item.Poor", 1.0f); - rate_values[ RATE_BUYVALUE_ITEM_NORMAL] = sConfigMgr->GetFloatDefault("Rate.BuyValue.Item.Normal", 1.0f); - rate_values[ RATE_BUYVALUE_ITEM_UNCOMMON] = sConfigMgr->GetFloatDefault("Rate.BuyValue.Item.Uncommon", 1.0f); - rate_values[ RATE_BUYVALUE_ITEM_RARE] = sConfigMgr->GetFloatDefault("Rate.BuyValue.Item.Rare", 1.0f); - rate_values[ RATE_BUYVALUE_ITEM_EPIC] = sConfigMgr->GetFloatDefault("Rate.BuyValue.Item.Epic", 1.0f); - rate_values[ RATE_BUYVALUE_ITEM_LEGENDARY] = sConfigMgr->GetFloatDefault("Rate.BuyValue.Item.Legendary", 1.0f); - rate_values[RATE_BUYVALUE_ITEM_ARTIFACT] = sConfigMgr->GetFloatDefault("Rate.BuyValue.Item.Artifact", 1.0f); - rate_values[RATE_BUYVALUE_ITEM_HEIRLOOM] = sConfigMgr->GetFloatDefault("Rate.BuyValue.Item.Heirloom", 1.0f); + rate_values[ RATE_BUYVALUE_ITEM_POOR] = sConfigMgr->GetOption("Rate.BuyValue.Item.Poor", 1.0f); + rate_values[ RATE_BUYVALUE_ITEM_NORMAL] = sConfigMgr->GetOption("Rate.BuyValue.Item.Normal", 1.0f); + rate_values[ RATE_BUYVALUE_ITEM_UNCOMMON] = sConfigMgr->GetOption("Rate.BuyValue.Item.Uncommon", 1.0f); + rate_values[ RATE_BUYVALUE_ITEM_RARE] = sConfigMgr->GetOption("Rate.BuyValue.Item.Rare", 1.0f); + rate_values[ RATE_BUYVALUE_ITEM_EPIC] = sConfigMgr->GetOption("Rate.BuyValue.Item.Epic", 1.0f); + rate_values[ RATE_BUYVALUE_ITEM_LEGENDARY] = sConfigMgr->GetOption("Rate.BuyValue.Item.Legendary", 1.0f); + rate_values[RATE_BUYVALUE_ITEM_ARTIFACT] = sConfigMgr->GetOption("Rate.BuyValue.Item.Artifact", 1.0f); + rate_values[RATE_BUYVALUE_ITEM_HEIRLOOM] = sConfigMgr->GetOption("Rate.BuyValue.Item.Heirloom", 1.0f); if (rate_values[RATE_REPAIRCOST] < 0.0f) { sLog->outError("Rate.RepairCost (%f) must be >=0. Using 0.0 instead.", rate_values[RATE_REPAIRCOST]); rate_values[RATE_REPAIRCOST] = 0.0f; } - rate_values[RATE_REPUTATION_GAIN] = sConfigMgr->GetFloatDefault("Rate.Reputation.Gain", 1.0f); - rate_values[RATE_REPUTATION_LOWLEVEL_KILL] = sConfigMgr->GetFloatDefault("Rate.Reputation.LowLevel.Kill", 1.0f); - rate_values[RATE_REPUTATION_LOWLEVEL_QUEST] = sConfigMgr->GetFloatDefault("Rate.Reputation.LowLevel.Quest", 1.0f); - rate_values[RATE_REPUTATION_RECRUIT_A_FRIEND_BONUS] = sConfigMgr->GetFloatDefault("Rate.Reputation.RecruitAFriendBonus", 0.1f); - rate_values[RATE_CREATURE_NORMAL_DAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Normal.Damage", 1.0f); - rate_values[RATE_CREATURE_ELITE_ELITE_DAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.Elite.Damage", 1.0f); - rate_values[RATE_CREATURE_ELITE_RAREELITE_DAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.RAREELITE.Damage", 1.0f); - rate_values[RATE_CREATURE_ELITE_WORLDBOSS_DAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.WORLDBOSS.Damage", 1.0f); - rate_values[RATE_CREATURE_ELITE_RARE_DAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.RARE.Damage", 1.0f); - rate_values[RATE_CREATURE_NORMAL_HP] = sConfigMgr->GetFloatDefault("Rate.Creature.Normal.HP", 1.0f); - rate_values[RATE_CREATURE_ELITE_ELITE_HP] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.Elite.HP", 1.0f); - rate_values[RATE_CREATURE_ELITE_RAREELITE_HP] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.RAREELITE.HP", 1.0f); - rate_values[RATE_CREATURE_ELITE_WORLDBOSS_HP] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.WORLDBOSS.HP", 1.0f); - rate_values[RATE_CREATURE_ELITE_RARE_HP] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.RARE.HP", 1.0f); - rate_values[RATE_CREATURE_NORMAL_SPELLDAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Normal.SpellDamage", 1.0f); - rate_values[RATE_CREATURE_ELITE_ELITE_SPELLDAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.Elite.SpellDamage", 1.0f); - rate_values[RATE_CREATURE_ELITE_RAREELITE_SPELLDAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.RAREELITE.SpellDamage", 1.0f); - rate_values[RATE_CREATURE_ELITE_WORLDBOSS_SPELLDAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.WORLDBOSS.SpellDamage", 1.0f); - rate_values[RATE_CREATURE_ELITE_RARE_SPELLDAMAGE] = sConfigMgr->GetFloatDefault("Rate.Creature.Elite.RARE.SpellDamage", 1.0f); - rate_values[RATE_CREATURE_AGGRO] = sConfigMgr->GetFloatDefault("Rate.Creature.Aggro", 1.0f); - rate_values[RATE_REST_INGAME] = sConfigMgr->GetFloatDefault("Rate.Rest.InGame", 1.0f); - rate_values[RATE_REST_OFFLINE_IN_TAVERN_OR_CITY] = sConfigMgr->GetFloatDefault("Rate.Rest.Offline.InTavernOrCity", 1.0f); - rate_values[RATE_REST_OFFLINE_IN_WILDERNESS] = sConfigMgr->GetFloatDefault("Rate.Rest.Offline.InWilderness", 1.0f); - rate_values[RATE_DAMAGE_FALL] = sConfigMgr->GetFloatDefault("Rate.Damage.Fall", 1.0f); - rate_values[RATE_AUCTION_TIME] = sConfigMgr->GetFloatDefault("Rate.Auction.Time", 1.0f); - rate_values[RATE_AUCTION_DEPOSIT] = sConfigMgr->GetFloatDefault("Rate.Auction.Deposit", 1.0f); - rate_values[RATE_AUCTION_CUT] = sConfigMgr->GetFloatDefault("Rate.Auction.Cut", 1.0f); - rate_values[RATE_HONOR] = sConfigMgr->GetFloatDefault("Rate.Honor", 1.0f); - rate_values[RATE_ARENA_POINTS] = sConfigMgr->GetFloatDefault("Rate.ArenaPoints", 1.0f); - rate_values[RATE_INSTANCE_RESET_TIME] = sConfigMgr->GetFloatDefault("Rate.InstanceResetTime", 1.0f); - rate_values[RATE_TALENT] = sConfigMgr->GetFloatDefault("Rate.Talent", 1.0f); + rate_values[RATE_REPUTATION_GAIN] = sConfigMgr->GetOption("Rate.Reputation.Gain", 1.0f); + rate_values[RATE_REPUTATION_LOWLEVEL_KILL] = sConfigMgr->GetOption("Rate.Reputation.LowLevel.Kill", 1.0f); + rate_values[RATE_REPUTATION_LOWLEVEL_QUEST] = sConfigMgr->GetOption("Rate.Reputation.LowLevel.Quest", 1.0f); + rate_values[RATE_REPUTATION_RECRUIT_A_FRIEND_BONUS] = sConfigMgr->GetOption("Rate.Reputation.RecruitAFriendBonus", 0.1f); + rate_values[RATE_CREATURE_NORMAL_DAMAGE] = sConfigMgr->GetOption("Rate.Creature.Normal.Damage", 1.0f); + rate_values[RATE_CREATURE_ELITE_ELITE_DAMAGE] = sConfigMgr->GetOption("Rate.Creature.Elite.Elite.Damage", 1.0f); + rate_values[RATE_CREATURE_ELITE_RAREELITE_DAMAGE] = sConfigMgr->GetOption("Rate.Creature.Elite.RAREELITE.Damage", 1.0f); + rate_values[RATE_CREATURE_ELITE_WORLDBOSS_DAMAGE] = sConfigMgr->GetOption("Rate.Creature.Elite.WORLDBOSS.Damage", 1.0f); + rate_values[RATE_CREATURE_ELITE_RARE_DAMAGE] = sConfigMgr->GetOption("Rate.Creature.Elite.RARE.Damage", 1.0f); + rate_values[RATE_CREATURE_NORMAL_HP] = sConfigMgr->GetOption("Rate.Creature.Normal.HP", 1.0f); + rate_values[RATE_CREATURE_ELITE_ELITE_HP] = sConfigMgr->GetOption("Rate.Creature.Elite.Elite.HP", 1.0f); + rate_values[RATE_CREATURE_ELITE_RAREELITE_HP] = sConfigMgr->GetOption("Rate.Creature.Elite.RAREELITE.HP", 1.0f); + rate_values[RATE_CREATURE_ELITE_WORLDBOSS_HP] = sConfigMgr->GetOption("Rate.Creature.Elite.WORLDBOSS.HP", 1.0f); + rate_values[RATE_CREATURE_ELITE_RARE_HP] = sConfigMgr->GetOption("Rate.Creature.Elite.RARE.HP", 1.0f); + rate_values[RATE_CREATURE_NORMAL_SPELLDAMAGE] = sConfigMgr->GetOption("Rate.Creature.Normal.SpellDamage", 1.0f); + rate_values[RATE_CREATURE_ELITE_ELITE_SPELLDAMAGE] = sConfigMgr->GetOption("Rate.Creature.Elite.Elite.SpellDamage", 1.0f); + rate_values[RATE_CREATURE_ELITE_RAREELITE_SPELLDAMAGE] = sConfigMgr->GetOption("Rate.Creature.Elite.RAREELITE.SpellDamage", 1.0f); + rate_values[RATE_CREATURE_ELITE_WORLDBOSS_SPELLDAMAGE] = sConfigMgr->GetOption("Rate.Creature.Elite.WORLDBOSS.SpellDamage", 1.0f); + rate_values[RATE_CREATURE_ELITE_RARE_SPELLDAMAGE] = sConfigMgr->GetOption("Rate.Creature.Elite.RARE.SpellDamage", 1.0f); + rate_values[RATE_CREATURE_AGGRO] = sConfigMgr->GetOption("Rate.Creature.Aggro", 1.0f); + rate_values[RATE_REST_INGAME] = sConfigMgr->GetOption("Rate.Rest.InGame", 1.0f); + rate_values[RATE_REST_OFFLINE_IN_TAVERN_OR_CITY] = sConfigMgr->GetOption("Rate.Rest.Offline.InTavernOrCity", 1.0f); + rate_values[RATE_REST_OFFLINE_IN_WILDERNESS] = sConfigMgr->GetOption("Rate.Rest.Offline.InWilderness", 1.0f); + rate_values[RATE_DAMAGE_FALL] = sConfigMgr->GetOption("Rate.Damage.Fall", 1.0f); + rate_values[RATE_AUCTION_TIME] = sConfigMgr->GetOption("Rate.Auction.Time", 1.0f); + rate_values[RATE_AUCTION_DEPOSIT] = sConfigMgr->GetOption("Rate.Auction.Deposit", 1.0f); + rate_values[RATE_AUCTION_CUT] = sConfigMgr->GetOption("Rate.Auction.Cut", 1.0f); + rate_values[RATE_HONOR] = sConfigMgr->GetOption("Rate.Honor", 1.0f); + rate_values[RATE_ARENA_POINTS] = sConfigMgr->GetOption("Rate.ArenaPoints", 1.0f); + rate_values[RATE_INSTANCE_RESET_TIME] = sConfigMgr->GetOption("Rate.InstanceResetTime", 1.0f); + rate_values[RATE_TALENT] = sConfigMgr->GetOption("Rate.Talent", 1.0f); if (rate_values[RATE_TALENT] < 0.0f) { sLog->outError("Rate.Talent (%f) must be > 0. Using 1 instead.", rate_values[RATE_TALENT]); rate_values[RATE_TALENT] = 1.0f; } - rate_values[RATE_MOVESPEED] = sConfigMgr->GetFloatDefault("Rate.MoveSpeed", 1.0f); + rate_values[RATE_MOVESPEED] = sConfigMgr->GetOption("Rate.MoveSpeed", 1.0f); if (rate_values[RATE_MOVESPEED] < 0) { sLog->outError("Rate.MoveSpeed (%f) must be > 0. Using 1 instead.", rate_values[RATE_MOVESPEED]); rate_values[RATE_MOVESPEED] = 1.0f; } for (uint8 i = 0; i < MAX_MOVE_TYPE; ++i) playerBaseMoveSpeed[i] = baseMoveSpeed[i] * rate_values[RATE_MOVESPEED]; - rate_values[RATE_CORPSE_DECAY_LOOTED] = sConfigMgr->GetFloatDefault("Rate.Corpse.Decay.Looted", 0.5f); + rate_values[RATE_CORPSE_DECAY_LOOTED] = sConfigMgr->GetOption("Rate.Corpse.Decay.Looted", 0.5f); - rate_values[RATE_TARGET_POS_RECALCULATION_RANGE] = sConfigMgr->GetFloatDefault("TargetPosRecalculateRange", 1.5f); + rate_values[RATE_TARGET_POS_RECALCULATION_RANGE] = sConfigMgr->GetOption("TargetPosRecalculateRange", 1.5f); if (rate_values[RATE_TARGET_POS_RECALCULATION_RANGE] < CONTACT_DISTANCE) { sLog->outError("TargetPosRecalculateRange (%f) must be >= %f. Using %f instead.", rate_values[RATE_TARGET_POS_RECALCULATION_RANGE], CONTACT_DISTANCE, CONTACT_DISTANCE); @@ -589,7 +589,7 @@ void World::LoadConfigSettings(bool reload) rate_values[RATE_TARGET_POS_RECALCULATION_RANGE] = NOMINAL_MELEE_RANGE; } - rate_values[RATE_DURABILITY_LOSS_ON_DEATH] = sConfigMgr->GetFloatDefault("DurabilityLoss.OnDeath", 10.0f); + rate_values[RATE_DURABILITY_LOSS_ON_DEATH] = sConfigMgr->GetOption("DurabilityLoss.OnDeath", 10.0f); if (rate_values[RATE_DURABILITY_LOSS_ON_DEATH] < 0.0f) { sLog->outError("DurabilityLoss.OnDeath (%f) must be >=0. Using 0.0 instead.", rate_values[RATE_DURABILITY_LOSS_ON_DEATH]); @@ -602,25 +602,25 @@ void World::LoadConfigSettings(bool reload) } rate_values[RATE_DURABILITY_LOSS_ON_DEATH] = rate_values[RATE_DURABILITY_LOSS_ON_DEATH] / 100.0f; - rate_values[RATE_DURABILITY_LOSS_DAMAGE] = sConfigMgr->GetFloatDefault("DurabilityLossChance.Damage", 0.5f); + rate_values[RATE_DURABILITY_LOSS_DAMAGE] = sConfigMgr->GetOption("DurabilityLossChance.Damage", 0.5f); if (rate_values[RATE_DURABILITY_LOSS_DAMAGE] < 0.0f) { sLog->outError("DurabilityLossChance.Damage (%f) must be >=0. Using 0.0 instead.", rate_values[RATE_DURABILITY_LOSS_DAMAGE]); rate_values[RATE_DURABILITY_LOSS_DAMAGE] = 0.0f; } - rate_values[RATE_DURABILITY_LOSS_ABSORB] = sConfigMgr->GetFloatDefault("DurabilityLossChance.Absorb", 0.5f); + rate_values[RATE_DURABILITY_LOSS_ABSORB] = sConfigMgr->GetOption("DurabilityLossChance.Absorb", 0.5f); if (rate_values[RATE_DURABILITY_LOSS_ABSORB] < 0.0f) { sLog->outError("DurabilityLossChance.Absorb (%f) must be >=0. Using 0.0 instead.", rate_values[RATE_DURABILITY_LOSS_ABSORB]); rate_values[RATE_DURABILITY_LOSS_ABSORB] = 0.0f; } - rate_values[RATE_DURABILITY_LOSS_PARRY] = sConfigMgr->GetFloatDefault("DurabilityLossChance.Parry", 0.05f); + rate_values[RATE_DURABILITY_LOSS_PARRY] = sConfigMgr->GetOption("DurabilityLossChance.Parry", 0.05f); if (rate_values[RATE_DURABILITY_LOSS_PARRY] < 0.0f) { sLog->outError("DurabilityLossChance.Parry (%f) must be >=0. Using 0.0 instead.", rate_values[RATE_DURABILITY_LOSS_PARRY]); rate_values[RATE_DURABILITY_LOSS_PARRY] = 0.0f; } - rate_values[RATE_DURABILITY_LOSS_BLOCK] = sConfigMgr->GetFloatDefault("DurabilityLossChance.Block", 0.05f); + rate_values[RATE_DURABILITY_LOSS_BLOCK] = sConfigMgr->GetOption("DurabilityLossChance.Block", 0.05f); if (rate_values[RATE_DURABILITY_LOSS_BLOCK] < 0.0f) { sLog->outError("DurabilityLossChance.Block (%f) must be >=0. Using 0.0 instead.", rate_values[RATE_DURABILITY_LOSS_BLOCK]); @@ -629,40 +629,40 @@ void World::LoadConfigSettings(bool reload) ///- Read other configuration items from the config file - m_bool_configs[CONFIG_DURABILITY_LOSS_IN_PVP] = sConfigMgr->GetBoolDefault("DurabilityLoss.InPvP", false); + m_bool_configs[CONFIG_DURABILITY_LOSS_IN_PVP] = sConfigMgr->GetOption("DurabilityLoss.InPvP", false); - m_int_configs[CONFIG_COMPRESSION] = sConfigMgr->GetIntDefault("Compression", 1); + m_int_configs[CONFIG_COMPRESSION] = sConfigMgr->GetOption("Compression", 1); if (m_int_configs[CONFIG_COMPRESSION] < 1 || m_int_configs[CONFIG_COMPRESSION] > 9) { sLog->outError("Compression level (%i) must be in range 1..9. Using default compression level (1).", m_int_configs[CONFIG_COMPRESSION]); m_int_configs[CONFIG_COMPRESSION] = 1; } - m_bool_configs[CONFIG_ADDON_CHANNEL] = sConfigMgr->GetBoolDefault("AddonChannel", true); - m_bool_configs[CONFIG_CLEAN_CHARACTER_DB] = sConfigMgr->GetBoolDefault("CleanCharacterDB", false); - m_int_configs[CONFIG_PERSISTENT_CHARACTER_CLEAN_FLAGS] = sConfigMgr->GetIntDefault("PersistentCharacterCleanFlags", 0); - m_int_configs[CONFIG_CHAT_CHANNEL_LEVEL_REQ] = sConfigMgr->GetIntDefault("ChatLevelReq.Channel", 1); - m_int_configs[CONFIG_CHAT_WHISPER_LEVEL_REQ] = sConfigMgr->GetIntDefault("ChatLevelReq.Whisper", 1); - m_int_configs[CONFIG_CHAT_SAY_LEVEL_REQ] = sConfigMgr->GetIntDefault("ChatLevelReq.Say", 1); - m_int_configs[CONFIG_PARTY_LEVEL_REQ] = sConfigMgr->GetIntDefault("PartyLevelReq", 1); - m_int_configs[CONFIG_TRADE_LEVEL_REQ] = sConfigMgr->GetIntDefault("LevelReq.Trade", 1); - m_int_configs[CONFIG_TICKET_LEVEL_REQ] = sConfigMgr->GetIntDefault("LevelReq.Ticket", 1); - m_int_configs[CONFIG_AUCTION_LEVEL_REQ] = sConfigMgr->GetIntDefault("LevelReq.Auction", 1); - m_int_configs[CONFIG_MAIL_LEVEL_REQ] = sConfigMgr->GetIntDefault("LevelReq.Mail", 1); - m_bool_configs[CONFIG_ALLOW_PLAYER_COMMANDS] = sConfigMgr->GetBoolDefault("AllowPlayerCommands", 1); - m_bool_configs[CONFIG_PRESERVE_CUSTOM_CHANNELS] = sConfigMgr->GetBoolDefault("PreserveCustomChannels", false); - m_int_configs[CONFIG_PRESERVE_CUSTOM_CHANNEL_DURATION] = sConfigMgr->GetIntDefault("PreserveCustomChannelDuration", 14); - m_int_configs[CONFIG_INTERVAL_SAVE] = sConfigMgr->GetIntDefault("PlayerSaveInterval", 15 * MINUTE * IN_MILLISECONDS); - m_int_configs[CONFIG_INTERVAL_DISCONNECT_TOLERANCE] = sConfigMgr->GetIntDefault("DisconnectToleranceInterval", 0); - m_bool_configs[CONFIG_STATS_SAVE_ONLY_ON_LOGOUT] = sConfigMgr->GetBoolDefault("PlayerSave.Stats.SaveOnlyOnLogout", true); + m_bool_configs[CONFIG_ADDON_CHANNEL] = sConfigMgr->GetOption("AddonChannel", true); + m_bool_configs[CONFIG_CLEAN_CHARACTER_DB] = sConfigMgr->GetOption("CleanCharacterDB", false); + m_int_configs[CONFIG_PERSISTENT_CHARACTER_CLEAN_FLAGS] = sConfigMgr->GetOption("PersistentCharacterCleanFlags", 0); + m_int_configs[CONFIG_CHAT_CHANNEL_LEVEL_REQ] = sConfigMgr->GetOption("ChatLevelReq.Channel", 1); + m_int_configs[CONFIG_CHAT_WHISPER_LEVEL_REQ] = sConfigMgr->GetOption("ChatLevelReq.Whisper", 1); + m_int_configs[CONFIG_CHAT_SAY_LEVEL_REQ] = sConfigMgr->GetOption("ChatLevelReq.Say", 1); + m_int_configs[CONFIG_PARTY_LEVEL_REQ] = sConfigMgr->GetOption("PartyLevelReq", 1); + m_int_configs[CONFIG_TRADE_LEVEL_REQ] = sConfigMgr->GetOption("LevelReq.Trade", 1); + m_int_configs[CONFIG_TICKET_LEVEL_REQ] = sConfigMgr->GetOption("LevelReq.Ticket", 1); + m_int_configs[CONFIG_AUCTION_LEVEL_REQ] = sConfigMgr->GetOption("LevelReq.Auction", 1); + m_int_configs[CONFIG_MAIL_LEVEL_REQ] = sConfigMgr->GetOption("LevelReq.Mail", 1); + m_bool_configs[CONFIG_ALLOW_PLAYER_COMMANDS] = sConfigMgr->GetOption("AllowPlayerCommands", 1); + m_bool_configs[CONFIG_PRESERVE_CUSTOM_CHANNELS] = sConfigMgr->GetOption("PreserveCustomChannels", false); + m_int_configs[CONFIG_PRESERVE_CUSTOM_CHANNEL_DURATION] = sConfigMgr->GetOption("PreserveCustomChannelDuration", 14); + m_int_configs[CONFIG_INTERVAL_SAVE] = sConfigMgr->GetOption("PlayerSaveInterval", 15 * MINUTE * IN_MILLISECONDS); + m_int_configs[CONFIG_INTERVAL_DISCONNECT_TOLERANCE] = sConfigMgr->GetOption("DisconnectToleranceInterval", 0); + m_bool_configs[CONFIG_STATS_SAVE_ONLY_ON_LOGOUT] = sConfigMgr->GetOption("PlayerSave.Stats.SaveOnlyOnLogout", true); - m_int_configs[CONFIG_MIN_LEVEL_STAT_SAVE] = sConfigMgr->GetIntDefault("PlayerSave.Stats.MinLevel", 0); + m_int_configs[CONFIG_MIN_LEVEL_STAT_SAVE] = sConfigMgr->GetOption("PlayerSave.Stats.MinLevel", 0); if (m_int_configs[CONFIG_MIN_LEVEL_STAT_SAVE] > MAX_LEVEL) { sLog->outError("PlayerSave.Stats.MinLevel (%i) must be in range 0..80. Using default, do not save character stats (0).", m_int_configs[CONFIG_MIN_LEVEL_STAT_SAVE]); m_int_configs[CONFIG_MIN_LEVEL_STAT_SAVE] = 0; } - m_int_configs[CONFIG_INTERVAL_MAPUPDATE] = sConfigMgr->GetIntDefault("MapUpdateInterval", 100); + m_int_configs[CONFIG_INTERVAL_MAPUPDATE] = sConfigMgr->GetOption("MapUpdateInterval", 100); if (m_int_configs[CONFIG_INTERVAL_MAPUPDATE] < MIN_MAP_UPDATE_DELAY) { sLog->outError("MapUpdateInterval (%i) must be greater %u. Use this minimal value.", m_int_configs[CONFIG_INTERVAL_MAPUPDATE], MIN_MAP_UPDATE_DELAY); @@ -671,98 +671,98 @@ void World::LoadConfigSettings(bool reload) if (reload) sMapMgr->SetMapUpdateInterval(m_int_configs[CONFIG_INTERVAL_MAPUPDATE]); - m_int_configs[CONFIG_INTERVAL_CHANGEWEATHER] = sConfigMgr->GetIntDefault("ChangeWeatherInterval", 10 * MINUTE * IN_MILLISECONDS); + m_int_configs[CONFIG_INTERVAL_CHANGEWEATHER] = sConfigMgr->GetOption("ChangeWeatherInterval", 10 * MINUTE * IN_MILLISECONDS); if (reload) { - uint32 val = sConfigMgr->GetIntDefault("WorldServerPort", 8085); + uint32 val = sConfigMgr->GetOption("WorldServerPort", 8085); if (val != m_int_configs[CONFIG_PORT_WORLD]) sLog->outError("WorldServerPort option can't be changed at worldserver.conf reload, using current value (%u).", m_int_configs[CONFIG_PORT_WORLD]); } else - m_int_configs[CONFIG_PORT_WORLD] = sConfigMgr->GetIntDefault("WorldServerPort", 8085); + m_int_configs[CONFIG_PORT_WORLD] = sConfigMgr->GetOption("WorldServerPort", 8085); - m_bool_configs[CONFIG_CLOSE_IDLE_CONNECTIONS] = sConfigMgr->GetBoolDefault("CloseIdleConnections", true); - m_int_configs[CONFIG_SOCKET_TIMEOUTTIME] = sConfigMgr->GetIntDefault("SocketTimeOutTime", 900000); - m_int_configs[CONFIG_SOCKET_TIMEOUTTIME_ACTIVE] = sConfigMgr->GetIntDefault("SocketTimeOutTimeActive", 60000); - m_int_configs[CONFIG_SESSION_ADD_DELAY] = sConfigMgr->GetIntDefault("SessionAddDelay", 10000); + m_bool_configs[CONFIG_CLOSE_IDLE_CONNECTIONS] = sConfigMgr->GetOption("CloseIdleConnections", true); + m_int_configs[CONFIG_SOCKET_TIMEOUTTIME] = sConfigMgr->GetOption("SocketTimeOutTime", 900000); + m_int_configs[CONFIG_SOCKET_TIMEOUTTIME_ACTIVE] = sConfigMgr->GetOption("SocketTimeOutTimeActive", 60000); + m_int_configs[CONFIG_SESSION_ADD_DELAY] = sConfigMgr->GetOption("SessionAddDelay", 10000); - m_float_configs[CONFIG_GROUP_XP_DISTANCE] = sConfigMgr->GetFloatDefault("MaxGroupXPDistance", 74.0f); - m_float_configs[CONFIG_MAX_RECRUIT_A_FRIEND_DISTANCE] = sConfigMgr->GetFloatDefault("MaxRecruitAFriendBonusDistance", 100.0f); + m_float_configs[CONFIG_GROUP_XP_DISTANCE] = sConfigMgr->GetOption("MaxGroupXPDistance", 74.0f); + m_float_configs[CONFIG_MAX_RECRUIT_A_FRIEND_DISTANCE] = sConfigMgr->GetOption("MaxRecruitAFriendBonusDistance", 100.0f); /// \todo Add MonsterSight in worldserver.conf or put it as define - m_float_configs[CONFIG_SIGHT_MONSTER] = sConfigMgr->GetFloatDefault("MonsterSight", 50); + m_float_configs[CONFIG_SIGHT_MONSTER] = sConfigMgr->GetOption("MonsterSight", 50); if (reload) { - uint32 val = sConfigMgr->GetIntDefault("GameType", 0); + uint32 val = sConfigMgr->GetOption("GameType", 0); if (val != m_int_configs[CONFIG_GAME_TYPE]) sLog->outError("GameType option can't be changed at worldserver.conf reload, using current value (%u).", m_int_configs[CONFIG_GAME_TYPE]); } else - m_int_configs[CONFIG_GAME_TYPE] = sConfigMgr->GetIntDefault("GameType", 0); + m_int_configs[CONFIG_GAME_TYPE] = sConfigMgr->GetOption("GameType", 0); if (reload) { - uint32 val = sConfigMgr->GetIntDefault("RealmZone", REALM_ZONE_DEVELOPMENT); + uint32 val = sConfigMgr->GetOption("RealmZone", REALM_ZONE_DEVELOPMENT); if (val != m_int_configs[CONFIG_REALM_ZONE]) sLog->outError("RealmZone option can't be changed at worldserver.conf reload, using current value (%u).", m_int_configs[CONFIG_REALM_ZONE]); } else - m_int_configs[CONFIG_REALM_ZONE] = sConfigMgr->GetIntDefault("RealmZone", REALM_ZONE_DEVELOPMENT); + m_int_configs[CONFIG_REALM_ZONE] = sConfigMgr->GetOption("RealmZone", REALM_ZONE_DEVELOPMENT); - m_int_configs[CONFIG_STRICT_PLAYER_NAMES] = sConfigMgr->GetIntDefault ("StrictPlayerNames", 0); - m_int_configs[CONFIG_STRICT_CHARTER_NAMES] = sConfigMgr->GetIntDefault ("StrictCharterNames", 0); - m_int_configs[CONFIG_STRICT_CHANNEL_NAMES] = sConfigMgr->GetIntDefault ("StrictChannelNames", 0); - m_int_configs[CONFIG_STRICT_PET_NAMES] = sConfigMgr->GetIntDefault ("StrictPetNames", 0); + m_int_configs[CONFIG_STRICT_PLAYER_NAMES] = sConfigMgr->GetOption ("StrictPlayerNames", 0); + m_int_configs[CONFIG_STRICT_CHARTER_NAMES] = sConfigMgr->GetOption ("StrictCharterNames", 0); + m_int_configs[CONFIG_STRICT_CHANNEL_NAMES] = sConfigMgr->GetOption ("StrictChannelNames", 0); + m_int_configs[CONFIG_STRICT_PET_NAMES] = sConfigMgr->GetOption ("StrictPetNames", 0); - m_bool_configs[CONFIG_ALLOW_TWO_SIDE_ACCOUNTS] = sConfigMgr->GetBoolDefault("AllowTwoSide.Accounts", true); - m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_CALENDAR] = sConfigMgr->GetBoolDefault("AllowTwoSide.Interaction.Calendar", false); - m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHAT] = sConfigMgr->GetBoolDefault("AllowTwoSide.Interaction.Chat", false); - m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL] = sConfigMgr->GetBoolDefault("AllowTwoSide.Interaction.Channel", false); - m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP] = sConfigMgr->GetBoolDefault("AllowTwoSide.Interaction.Group", false); - m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD] = sConfigMgr->GetBoolDefault("AllowTwoSide.Interaction.Guild", false); - m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION] = sConfigMgr->GetBoolDefault("AllowTwoSide.Interaction.Auction", false); - m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_MAIL] = sConfigMgr->GetBoolDefault("AllowTwoSide.Interaction.Mail", false); - m_bool_configs[CONFIG_ALLOW_TWO_SIDE_WHO_LIST] = sConfigMgr->GetBoolDefault("AllowTwoSide.WhoList", false); - m_bool_configs[CONFIG_ALLOW_TWO_SIDE_ADD_FRIEND] = sConfigMgr->GetBoolDefault("AllowTwoSide.AddFriend", false); - m_bool_configs[CONFIG_ALLOW_TWO_SIDE_TRADE] = sConfigMgr->GetBoolDefault("AllowTwoSide.trade", false); - m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_EMOTE] = sConfigMgr->GetBoolDefault("AllowTwoSide.Interaction.Emote", false); + m_bool_configs[CONFIG_ALLOW_TWO_SIDE_ACCOUNTS] = sConfigMgr->GetOption("AllowTwoSide.Accounts", true); + m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_CALENDAR] = sConfigMgr->GetOption("AllowTwoSide.Interaction.Calendar", false); + m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHAT] = sConfigMgr->GetOption("AllowTwoSide.Interaction.Chat", false); + m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_CHANNEL] = sConfigMgr->GetOption("AllowTwoSide.Interaction.Channel", false); + m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_GROUP] = sConfigMgr->GetOption("AllowTwoSide.Interaction.Group", false); + m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_GUILD] = sConfigMgr->GetOption("AllowTwoSide.Interaction.Guild", false); + m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_AUCTION] = sConfigMgr->GetOption("AllowTwoSide.Interaction.Auction", false); + m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_MAIL] = sConfigMgr->GetOption("AllowTwoSide.Interaction.Mail", false); + m_bool_configs[CONFIG_ALLOW_TWO_SIDE_WHO_LIST] = sConfigMgr->GetOption("AllowTwoSide.WhoList", false); + m_bool_configs[CONFIG_ALLOW_TWO_SIDE_ADD_FRIEND] = sConfigMgr->GetOption("AllowTwoSide.AddFriend", false); + m_bool_configs[CONFIG_ALLOW_TWO_SIDE_TRADE] = sConfigMgr->GetOption("AllowTwoSide.Trade", false); + m_bool_configs[CONFIG_ALLOW_TWO_SIDE_INTERACTION_EMOTE] = sConfigMgr->GetOption("AllowTwoSide.Interaction.Emote", false); - m_int_configs[CONFIG_MIN_PLAYER_NAME] = sConfigMgr->GetIntDefault ("MinPlayerName", 2); + m_int_configs[CONFIG_MIN_PLAYER_NAME] = sConfigMgr->GetOption ("MinPlayerName", 2); if (m_int_configs[CONFIG_MIN_PLAYER_NAME] < 1 || m_int_configs[CONFIG_MIN_PLAYER_NAME] > MAX_PLAYER_NAME) { sLog->outError("MinPlayerName (%i) must be in range 1..%u. Set to 2.", m_int_configs[CONFIG_MIN_PLAYER_NAME], MAX_PLAYER_NAME); m_int_configs[CONFIG_MIN_PLAYER_NAME] = 2; } - m_int_configs[CONFIG_MIN_CHARTER_NAME] = sConfigMgr->GetIntDefault ("MinCharterName", 2); + m_int_configs[CONFIG_MIN_CHARTER_NAME] = sConfigMgr->GetOption ("MinCharterName", 2); if (m_int_configs[CONFIG_MIN_CHARTER_NAME] < 1 || m_int_configs[CONFIG_MIN_CHARTER_NAME] > MAX_CHARTER_NAME) { sLog->outError("MinCharterName (%i) must be in range 1..%u. Set to 2.", m_int_configs[CONFIG_MIN_CHARTER_NAME], MAX_CHARTER_NAME); m_int_configs[CONFIG_MIN_CHARTER_NAME] = 2; } - m_int_configs[CONFIG_MIN_PET_NAME] = sConfigMgr->GetIntDefault ("MinPetName", 2); + m_int_configs[CONFIG_MIN_PET_NAME] = sConfigMgr->GetOption ("MinPetName", 2); if (m_int_configs[CONFIG_MIN_PET_NAME] < 1 || m_int_configs[CONFIG_MIN_PET_NAME] > MAX_PET_NAME) { sLog->outError("MinPetName (%i) must be in range 1..%u. Set to 2.", m_int_configs[CONFIG_MIN_PET_NAME], MAX_PET_NAME); m_int_configs[CONFIG_MIN_PET_NAME] = 2; } - m_int_configs[CONFIG_CHARTER_COST_GUILD] = sConfigMgr->GetIntDefault("Guild.CharterCost", 1000); - m_int_configs[CONFIG_CHARTER_COST_ARENA_2v2] = sConfigMgr->GetIntDefault("ArenaTeam.CharterCost.2v2", 800000); - m_int_configs[CONFIG_CHARTER_COST_ARENA_3v3] = sConfigMgr->GetIntDefault("ArenaTeam.CharterCost.3v3", 1200000); - m_int_configs[CONFIG_CHARTER_COST_ARENA_5v5] = sConfigMgr->GetIntDefault("ArenaTeam.CharterCost.5v5", 2000000); + m_int_configs[CONFIG_CHARTER_COST_GUILD] = sConfigMgr->GetOption("Guild.CharterCost", 1000); + m_int_configs[CONFIG_CHARTER_COST_ARENA_2v2] = sConfigMgr->GetOption("ArenaTeam.CharterCost.2v2", 800000); + m_int_configs[CONFIG_CHARTER_COST_ARENA_3v3] = sConfigMgr->GetOption("ArenaTeam.CharterCost.3v3", 1200000); + m_int_configs[CONFIG_CHARTER_COST_ARENA_5v5] = sConfigMgr->GetOption("ArenaTeam.CharterCost.5v5", 2000000); - m_int_configs[CONFIG_MAX_WHO_LIST_RETURN] = sConfigMgr->GetIntDefault("MaxWhoListReturns", 49); + m_int_configs[CONFIG_MAX_WHO_LIST_RETURN] = sConfigMgr->GetOption("MaxWhoListReturns", 49); - m_int_configs[CONFIG_CHARACTER_CREATING_DISABLED] = sConfigMgr->GetIntDefault("CharacterCreating.Disabled", 0); - m_int_configs[CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK] = sConfigMgr->GetIntDefault("CharacterCreating.Disabled.RaceMask", 0); + m_int_configs[CONFIG_CHARACTER_CREATING_DISABLED] = sConfigMgr->GetOption("CharacterCreating.Disabled", 0); + m_int_configs[CONFIG_CHARACTER_CREATING_DISABLED_RACEMASK] = sConfigMgr->GetOption("CharacterCreating.Disabled.RaceMask", 0); - m_int_configs[CONFIG_CHARACTER_CREATING_DISABLED_CLASSMASK] = sConfigMgr->GetIntDefault("CharacterCreating.Disabled.ClassMask", 0); + m_int_configs[CONFIG_CHARACTER_CREATING_DISABLED_CLASSMASK] = sConfigMgr->GetOption("CharacterCreating.Disabled.ClassMask", 0); - m_int_configs[CONFIG_CHARACTERS_PER_REALM] = sConfigMgr->GetIntDefault("CharactersPerRealm", 10); + m_int_configs[CONFIG_CHARACTERS_PER_REALM] = sConfigMgr->GetOption("CharactersPerRealm", 10); if (m_int_configs[CONFIG_CHARACTERS_PER_REALM] < 1 || m_int_configs[CONFIG_CHARACTERS_PER_REALM] > 10) { sLog->outError("CharactersPerRealm (%i) must be in range 1..10. Set to 10.", m_int_configs[CONFIG_CHARACTERS_PER_REALM]); @@ -770,23 +770,23 @@ void World::LoadConfigSettings(bool reload) } // must be after CONFIG_CHARACTERS_PER_REALM - m_int_configs[CONFIG_CHARACTERS_PER_ACCOUNT] = sConfigMgr->GetIntDefault("CharactersPerAccount", 50); + m_int_configs[CONFIG_CHARACTERS_PER_ACCOUNT] = sConfigMgr->GetOption("CharactersPerAccount", 50); if (m_int_configs[CONFIG_CHARACTERS_PER_ACCOUNT] < m_int_configs[CONFIG_CHARACTERS_PER_REALM]) { sLog->outError("CharactersPerAccount (%i) can't be less than CharactersPerRealm (%i).", m_int_configs[CONFIG_CHARACTERS_PER_ACCOUNT], m_int_configs[CONFIG_CHARACTERS_PER_REALM]); m_int_configs[CONFIG_CHARACTERS_PER_ACCOUNT] = m_int_configs[CONFIG_CHARACTERS_PER_REALM]; } - m_int_configs[CONFIG_HEROIC_CHARACTERS_PER_REALM] = sConfigMgr->GetIntDefault("HeroicCharactersPerRealm", 1); + m_int_configs[CONFIG_HEROIC_CHARACTERS_PER_REALM] = sConfigMgr->GetOption("HeroicCharactersPerRealm", 1); if (int32(m_int_configs[CONFIG_HEROIC_CHARACTERS_PER_REALM]) < 0 || m_int_configs[CONFIG_HEROIC_CHARACTERS_PER_REALM] > 10) { sLog->outError("HeroicCharactersPerRealm (%i) must be in range 0..10. Set to 1.", m_int_configs[CONFIG_HEROIC_CHARACTERS_PER_REALM]); m_int_configs[CONFIG_HEROIC_CHARACTERS_PER_REALM] = 1; } - m_int_configs[CONFIG_CHARACTER_CREATING_MIN_LEVEL_FOR_HEROIC_CHARACTER] = sConfigMgr->GetIntDefault("CharacterCreating.MinLevelForHeroicCharacter", 55); + m_int_configs[CONFIG_CHARACTER_CREATING_MIN_LEVEL_FOR_HEROIC_CHARACTER] = sConfigMgr->GetOption("CharacterCreating.MinLevelForHeroicCharacter", 55); - m_int_configs[CONFIG_SKIP_CINEMATICS] = sConfigMgr->GetIntDefault("SkipCinematics", 0); + m_int_configs[CONFIG_SKIP_CINEMATICS] = sConfigMgr->GetOption("SkipCinematics", 0); if (int32(m_int_configs[CONFIG_SKIP_CINEMATICS]) < 0 || m_int_configs[CONFIG_SKIP_CINEMATICS] > 2) { sLog->outError("SkipCinematics (%i) must be in range 0..2. Set to 0.", m_int_configs[CONFIG_SKIP_CINEMATICS]); @@ -795,12 +795,12 @@ void World::LoadConfigSettings(bool reload) if (reload) { - uint32 val = sConfigMgr->GetIntDefault("MaxPlayerLevel", DEFAULT_MAX_LEVEL); + uint32 val = sConfigMgr->GetOption("MaxPlayerLevel", DEFAULT_MAX_LEVEL); if (val != m_int_configs[CONFIG_MAX_PLAYER_LEVEL]) sLog->outError("MaxPlayerLevel option can't be changed at config reload, using current value (%u).", m_int_configs[CONFIG_MAX_PLAYER_LEVEL]); } else - m_int_configs[CONFIG_MAX_PLAYER_LEVEL] = sConfigMgr->GetIntDefault("MaxPlayerLevel", DEFAULT_MAX_LEVEL); + m_int_configs[CONFIG_MAX_PLAYER_LEVEL] = sConfigMgr->GetOption("MaxPlayerLevel", DEFAULT_MAX_LEVEL); if (m_int_configs[CONFIG_MAX_PLAYER_LEVEL] > MAX_LEVEL) { @@ -808,9 +808,9 @@ void World::LoadConfigSettings(bool reload) m_int_configs[CONFIG_MAX_PLAYER_LEVEL] = MAX_LEVEL; } - m_int_configs[CONFIG_MIN_DUALSPEC_LEVEL] = sConfigMgr->GetIntDefault("MinDualSpecLevel", 40); + m_int_configs[CONFIG_MIN_DUALSPEC_LEVEL] = sConfigMgr->GetOption("MinDualSpecLevel", 40); - m_int_configs[CONFIG_START_PLAYER_LEVEL] = sConfigMgr->GetIntDefault("StartPlayerLevel", 1); + m_int_configs[CONFIG_START_PLAYER_LEVEL] = sConfigMgr->GetOption("StartPlayerLevel", 1); if (m_int_configs[CONFIG_START_PLAYER_LEVEL] < 1) { sLog->outError("StartPlayerLevel (%i) must be in range 1..MaxPlayerLevel(%u). Set to 1.", m_int_configs[CONFIG_START_PLAYER_LEVEL], m_int_configs[CONFIG_MAX_PLAYER_LEVEL]); @@ -822,7 +822,7 @@ void World::LoadConfigSettings(bool reload) m_int_configs[CONFIG_START_PLAYER_LEVEL] = m_int_configs[CONFIG_MAX_PLAYER_LEVEL]; } - m_int_configs[CONFIG_START_HEROIC_PLAYER_LEVEL] = sConfigMgr->GetIntDefault("StartHeroicPlayerLevel", 55); + m_int_configs[CONFIG_START_HEROIC_PLAYER_LEVEL] = sConfigMgr->GetOption("StartHeroicPlayerLevel", 55); if (m_int_configs[CONFIG_START_HEROIC_PLAYER_LEVEL] < 1) { sLog->outError("StartHeroicPlayerLevel (%i) must be in range 1..MaxPlayerLevel(%u). Set to 55.", @@ -836,7 +836,7 @@ void World::LoadConfigSettings(bool reload) m_int_configs[CONFIG_START_HEROIC_PLAYER_LEVEL] = m_int_configs[CONFIG_MAX_PLAYER_LEVEL]; } - m_int_configs[CONFIG_START_PLAYER_MONEY] = sConfigMgr->GetIntDefault("StartPlayerMoney", 0); + m_int_configs[CONFIG_START_PLAYER_MONEY] = sConfigMgr->GetOption("StartPlayerMoney", 0); if (int32(m_int_configs[CONFIG_START_PLAYER_MONEY]) < 0) { sLog->outError("StartPlayerMoney (%i) must be in range 0..%u. Set to %u.", m_int_configs[CONFIG_START_PLAYER_MONEY], MAX_MONEY_AMOUNT, 0); @@ -849,14 +849,14 @@ void World::LoadConfigSettings(bool reload) m_int_configs[CONFIG_START_PLAYER_MONEY] = MAX_MONEY_AMOUNT; } - m_int_configs[CONFIG_MAX_HONOR_POINTS] = sConfigMgr->GetIntDefault("MaxHonorPoints", 75000); + m_int_configs[CONFIG_MAX_HONOR_POINTS] = sConfigMgr->GetOption("MaxHonorPoints", 75000); if (int32(m_int_configs[CONFIG_MAX_HONOR_POINTS]) < 0) { sLog->outError("MaxHonorPoints (%i) can't be negative. Set to 0.", m_int_configs[CONFIG_MAX_HONOR_POINTS]); m_int_configs[CONFIG_MAX_HONOR_POINTS] = 0; } - m_int_configs[CONFIG_START_HONOR_POINTS] = sConfigMgr->GetIntDefault("StartHonorPoints", 0); + m_int_configs[CONFIG_START_HONOR_POINTS] = sConfigMgr->GetOption("StartHonorPoints", 0); if (int32(m_int_configs[CONFIG_START_HONOR_POINTS]) < 0) { sLog->outError("StartHonorPoints (%i) must be in range 0..MaxHonorPoints(%u). Set to %u.", @@ -870,14 +870,14 @@ void World::LoadConfigSettings(bool reload) m_int_configs[CONFIG_START_HONOR_POINTS] = m_int_configs[CONFIG_MAX_HONOR_POINTS]; } - m_int_configs[CONFIG_MAX_ARENA_POINTS] = sConfigMgr->GetIntDefault("MaxArenaPoints", 10000); + m_int_configs[CONFIG_MAX_ARENA_POINTS] = sConfigMgr->GetOption("MaxArenaPoints", 10000); if (int32(m_int_configs[CONFIG_MAX_ARENA_POINTS]) < 0) { sLog->outError("MaxArenaPoints (%i) can't be negative. Set to 0.", m_int_configs[CONFIG_MAX_ARENA_POINTS]); m_int_configs[CONFIG_MAX_ARENA_POINTS] = 0; } - m_int_configs[CONFIG_START_ARENA_POINTS] = sConfigMgr->GetIntDefault("StartArenaPoints", 0); + m_int_configs[CONFIG_START_ARENA_POINTS] = sConfigMgr->GetOption("StartArenaPoints", 0); if (int32(m_int_configs[CONFIG_START_ARENA_POINTS]) < 0) { sLog->outError("StartArenaPoints (%i) must be in range 0..MaxArenaPoints(%u). Set to %u.", @@ -891,7 +891,7 @@ void World::LoadConfigSettings(bool reload) m_int_configs[CONFIG_START_ARENA_POINTS] = m_int_configs[CONFIG_MAX_ARENA_POINTS]; } - m_int_configs[CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL] = sConfigMgr->GetIntDefault("RecruitAFriend.MaxLevel", 60); + m_int_configs[CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL] = sConfigMgr->GetOption("RecruitAFriend.MaxLevel", 60); if (m_int_configs[CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL] > m_int_configs[CONFIG_MAX_PLAYER_LEVEL]) { sLog->outError("RecruitAFriend.MaxLevel (%i) must be in the range 0..MaxLevel(%u). Set to %u.", @@ -899,36 +899,36 @@ void World::LoadConfigSettings(bool reload) m_int_configs[CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL] = 60; } - m_int_configs[CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL_DIFFERENCE] = sConfigMgr->GetIntDefault("RecruitAFriend.MaxDifference", 4); - m_bool_configs[CONFIG_ALL_TAXI_PATHS] = sConfigMgr->GetBoolDefault("AllFlightPaths", false); - m_int_configs[CONFIG_INSTANT_TAXI] = sConfigMgr->GetIntDefault("InstantFlightPaths", 0); + m_int_configs[CONFIG_MAX_RECRUIT_A_FRIEND_BONUS_PLAYER_LEVEL_DIFFERENCE] = sConfigMgr->GetOption("RecruitAFriend.MaxDifference", 4); + m_bool_configs[CONFIG_ALL_TAXI_PATHS] = sConfigMgr->GetOption("AllFlightPaths", false); + m_int_configs[CONFIG_INSTANT_TAXI] = sConfigMgr->GetOption("InstantFlightPaths", 0); - m_bool_configs[CONFIG_INSTANCE_IGNORE_LEVEL] = sConfigMgr->GetBoolDefault("Instance.IgnoreLevel", false); - m_bool_configs[CONFIG_INSTANCE_IGNORE_RAID] = sConfigMgr->GetBoolDefault("Instance.IgnoreRaid", false); - m_bool_configs[CONFIG_INSTANCE_GMSUMMON_PLAYER] = sConfigMgr->GetBoolDefault("Instance.GMSummonPlayer", false); - m_bool_configs[CONFIG_INSTANCE_SHARED_ID] = sConfigMgr->GetBoolDefault("Instance.SharedNormalHeroicId", false); + m_bool_configs[CONFIG_INSTANCE_IGNORE_LEVEL] = sConfigMgr->GetOption("Instance.IgnoreLevel", false); + m_bool_configs[CONFIG_INSTANCE_IGNORE_RAID] = sConfigMgr->GetOption("Instance.IgnoreRaid", false); + m_bool_configs[CONFIG_INSTANCE_GMSUMMON_PLAYER] = sConfigMgr->GetOption("Instance.GMSummonPlayer", false); + m_bool_configs[CONFIG_INSTANCE_SHARED_ID] = sConfigMgr->GetOption("Instance.SharedNormalHeroicId", false); - m_int_configs[CONFIG_INSTANCE_RESET_TIME_HOUR] = sConfigMgr->GetIntDefault("Instance.ResetTimeHour", 4); - m_int_configs[CONFIG_INSTANCE_RESET_TIME_RELATIVE_TIMESTAMP] = sConfigMgr->GetIntDefault("Instance.ResetTimeRelativeTimestamp", 1135814400); - m_int_configs[CONFIG_INSTANCE_UNLOAD_DELAY] = sConfigMgr->GetIntDefault("Instance.UnloadDelay", 30 * MINUTE * IN_MILLISECONDS); + m_int_configs[CONFIG_INSTANCE_RESET_TIME_HOUR] = sConfigMgr->GetOption("Instance.ResetTimeHour", 4); + m_int_configs[CONFIG_INSTANCE_RESET_TIME_RELATIVE_TIMESTAMP] = sConfigMgr->GetOption("Instance.ResetTimeRelativeTimestamp", 1135814400); + m_int_configs[CONFIG_INSTANCE_UNLOAD_DELAY] = sConfigMgr->GetOption("Instance.UnloadDelay", 30 * MINUTE * IN_MILLISECONDS); - m_int_configs[CONFIG_MAX_PRIMARY_TRADE_SKILL] = sConfigMgr->GetIntDefault("MaxPrimaryTradeSkill", 2); - m_int_configs[CONFIG_MIN_PETITION_SIGNS] = sConfigMgr->GetIntDefault("MinPetitionSigns", 9); + m_int_configs[CONFIG_MAX_PRIMARY_TRADE_SKILL] = sConfigMgr->GetOption("MaxPrimaryTradeSkill", 2); + m_int_configs[CONFIG_MIN_PETITION_SIGNS] = sConfigMgr->GetOption("MinPetitionSigns", 9); if (m_int_configs[CONFIG_MIN_PETITION_SIGNS] > 9) { sLog->outError("MinPetitionSigns (%i) must be in range 0..9. Set to 9.", m_int_configs[CONFIG_MIN_PETITION_SIGNS]); m_int_configs[CONFIG_MIN_PETITION_SIGNS] = 9; } - m_int_configs[CONFIG_GM_LOGIN_STATE] = sConfigMgr->GetIntDefault("GM.LoginState", 2); - m_int_configs[CONFIG_GM_VISIBLE_STATE] = sConfigMgr->GetIntDefault("GM.Visible", 2); - m_int_configs[CONFIG_GM_CHAT] = sConfigMgr->GetIntDefault("GM.Chat", 2); - m_int_configs[CONFIG_GM_WHISPERING_TO] = sConfigMgr->GetIntDefault("GM.WhisperingTo", 2); + m_int_configs[CONFIG_GM_LOGIN_STATE] = sConfigMgr->GetOption("GM.LoginState", 2); + m_int_configs[CONFIG_GM_VISIBLE_STATE] = sConfigMgr->GetOption("GM.Visible", 2); + m_int_configs[CONFIG_GM_CHAT] = sConfigMgr->GetOption("GM.Chat", 2); + m_int_configs[CONFIG_GM_WHISPERING_TO] = sConfigMgr->GetOption("GM.WhisperingTo", 2); - m_int_configs[CONFIG_GM_LEVEL_IN_GM_LIST] = sConfigMgr->GetIntDefault("GM.InGMList.Level", SEC_ADMINISTRATOR); - m_int_configs[CONFIG_GM_LEVEL_IN_WHO_LIST] = sConfigMgr->GetIntDefault("GM.InWhoList.Level", SEC_ADMINISTRATOR); - m_bool_configs[CONFIG_GM_LOG_TRADE] = sConfigMgr->GetBoolDefault("GM.LogTrade", false); - m_int_configs[CONFIG_START_GM_LEVEL] = sConfigMgr->GetIntDefault("GM.StartLevel", 1); + m_int_configs[CONFIG_GM_LEVEL_IN_GM_LIST] = sConfigMgr->GetOption("GM.InGMList.Level", SEC_ADMINISTRATOR); + m_int_configs[CONFIG_GM_LEVEL_IN_WHO_LIST] = sConfigMgr->GetOption("GM.InWhoList.Level", SEC_ADMINISTRATOR); + m_bool_configs[CONFIG_GM_LOG_TRADE] = sConfigMgr->GetOption("GM.LogTrade", false); + m_int_configs[CONFIG_START_GM_LEVEL] = sConfigMgr->GetOption("GM.StartLevel", 1); if (m_int_configs[CONFIG_START_GM_LEVEL] < m_int_configs[CONFIG_START_PLAYER_LEVEL]) { sLog->outError("GM.StartLevel (%i) must be in range StartPlayerLevel(%u)..%u. Set to %u.", @@ -940,16 +940,16 @@ void World::LoadConfigSettings(bool reload) sLog->outError("GM.StartLevel (%i) must be in range 1..%u. Set to %u.", m_int_configs[CONFIG_START_GM_LEVEL], MAX_LEVEL, MAX_LEVEL); m_int_configs[CONFIG_START_GM_LEVEL] = MAX_LEVEL; } - m_bool_configs[CONFIG_ALLOW_GM_GROUP] = sConfigMgr->GetBoolDefault("GM.AllowInvite", false); - m_bool_configs[CONFIG_ALLOW_GM_FRIEND] = sConfigMgr->GetBoolDefault("GM.AllowFriend", false); - m_bool_configs[CONFIG_GM_LOWER_SECURITY] = sConfigMgr->GetBoolDefault("GM.LowerSecurity", false); - m_float_configs[CONFIG_CHANCE_OF_GM_SURVEY] = sConfigMgr->GetFloatDefault("GM.TicketSystem.ChanceOfGMSurvey", 50.0f); + m_bool_configs[CONFIG_ALLOW_GM_GROUP] = sConfigMgr->GetOption("GM.AllowInvite", false); + m_bool_configs[CONFIG_ALLOW_GM_FRIEND] = sConfigMgr->GetOption("GM.AllowFriend", false); + m_bool_configs[CONFIG_GM_LOWER_SECURITY] = sConfigMgr->GetOption("GM.LowerSecurity", false); + m_float_configs[CONFIG_CHANCE_OF_GM_SURVEY] = sConfigMgr->GetOption("GM.TicketSystem.ChanceOfGMSurvey", 50.0f); - m_int_configs[CONFIG_GROUP_VISIBILITY] = sConfigMgr->GetIntDefault("Visibility.GroupMode", 1); + m_int_configs[CONFIG_GROUP_VISIBILITY] = sConfigMgr->GetOption("Visibility.GroupMode", 1); - m_int_configs[CONFIG_MAIL_DELIVERY_DELAY] = sConfigMgr->GetIntDefault("MailDeliveryDelay", HOUR); + m_int_configs[CONFIG_MAIL_DELIVERY_DELAY] = sConfigMgr->GetOption("MailDeliveryDelay", HOUR); - m_int_configs[CONFIG_UPTIME_UPDATE] = sConfigMgr->GetIntDefault("UpdateUptimeInterval", 10); + m_int_configs[CONFIG_UPTIME_UPDATE] = sConfigMgr->GetOption("UpdateUptimeInterval", 10); if (int32(m_int_configs[CONFIG_UPTIME_UPDATE]) <= 0) { sLog->outError("UpdateUptimeInterval (%i) must be > 0, set to default 10.", m_int_configs[CONFIG_UPTIME_UPDATE]); @@ -963,7 +963,7 @@ void World::LoadConfigSettings(bool reload) } // log db cleanup interval - m_int_configs[CONFIG_LOGDB_CLEARINTERVAL] = sConfigMgr->GetIntDefault("LogDB.Opt.ClearInterval", 10); + m_int_configs[CONFIG_LOGDB_CLEARINTERVAL] = sConfigMgr->GetOption("LogDB.Opt.ClearInterval", 10); if (int32(m_int_configs[CONFIG_LOGDB_CLEARINTERVAL]) <= 0) { sLog->outError("LogDB.Opt.ClearInterval (%i) must be > 0, set to default 10.", m_int_configs[CONFIG_LOGDB_CLEARINTERVAL]); @@ -974,160 +974,160 @@ void World::LoadConfigSettings(bool reload) m_timers[WUPDATE_CLEANDB].SetInterval(m_int_configs[CONFIG_LOGDB_CLEARINTERVAL] * MINUTE * IN_MILLISECONDS); m_timers[WUPDATE_CLEANDB].Reset(); } - m_int_configs[CONFIG_LOGDB_CLEARTIME] = sConfigMgr->GetIntDefault("LogDB.Opt.ClearTime", 1209600); // 14 days default + m_int_configs[CONFIG_LOGDB_CLEARTIME] = sConfigMgr->GetOption("LogDB.Opt.ClearTime", 1209600); // 14 days default sLog->outString("Will clear `logs` table of entries older than %i seconds every %u minutes.", m_int_configs[CONFIG_LOGDB_CLEARTIME], m_int_configs[CONFIG_LOGDB_CLEARINTERVAL]); - m_int_configs[CONFIG_TELEPORT_TIMEOUT_NEAR] = sConfigMgr->GetIntDefault("TeleportTimeoutNear", 25); // pussywizard - m_int_configs[CONFIG_TELEPORT_TIMEOUT_FAR] = sConfigMgr->GetIntDefault("TeleportTimeoutFar", 45); // pussywizard - m_int_configs[CONFIG_MAX_ALLOWED_MMR_DROP] = sConfigMgr->GetIntDefault("MaxAllowedMMRDrop", 500); // pussywizard - m_bool_configs[CONFIG_ENABLE_LOGIN_AFTER_DC] = sConfigMgr->GetBoolDefault("EnableLoginAfterDC", true); // pussywizard - m_bool_configs[CONFIG_DONT_CACHE_RANDOM_MOVEMENT_PATHS] = sConfigMgr->GetBoolDefault("DontCacheRandomMovementPaths", true); // pussywizard + m_int_configs[CONFIG_TELEPORT_TIMEOUT_NEAR] = sConfigMgr->GetOption("TeleportTimeoutNear", 25); // pussywizard + m_int_configs[CONFIG_TELEPORT_TIMEOUT_FAR] = sConfigMgr->GetOption("TeleportTimeoutFar", 45); // pussywizard + m_int_configs[CONFIG_MAX_ALLOWED_MMR_DROP] = sConfigMgr->GetOption("MaxAllowedMMRDrop", 500); // pussywizard + m_bool_configs[CONFIG_ENABLE_LOGIN_AFTER_DC] = sConfigMgr->GetOption("EnableLoginAfterDC", true); // pussywizard + m_bool_configs[CONFIG_DONT_CACHE_RANDOM_MOVEMENT_PATHS] = sConfigMgr->GetOption("DontCacheRandomMovementPaths", true); // pussywizard - m_int_configs[CONFIG_SKILL_CHANCE_ORANGE] = sConfigMgr->GetIntDefault("SkillChance.Orange", 100); - m_int_configs[CONFIG_SKILL_CHANCE_YELLOW] = sConfigMgr->GetIntDefault("SkillChance.Yellow", 75); - m_int_configs[CONFIG_SKILL_CHANCE_GREEN] = sConfigMgr->GetIntDefault("SkillChance.Green", 25); - m_int_configs[CONFIG_SKILL_CHANCE_GREY] = sConfigMgr->GetIntDefault("SkillChance.Grey", 0); + m_int_configs[CONFIG_SKILL_CHANCE_ORANGE] = sConfigMgr->GetOption("SkillChance.Orange", 100); + m_int_configs[CONFIG_SKILL_CHANCE_YELLOW] = sConfigMgr->GetOption("SkillChance.Yellow", 75); + m_int_configs[CONFIG_SKILL_CHANCE_GREEN] = sConfigMgr->GetOption("SkillChance.Green", 25); + m_int_configs[CONFIG_SKILL_CHANCE_GREY] = sConfigMgr->GetOption("SkillChance.Grey", 0); - m_int_configs[CONFIG_SKILL_CHANCE_MINING_STEPS] = sConfigMgr->GetIntDefault("SkillChance.MiningSteps", 75); - m_int_configs[CONFIG_SKILL_CHANCE_SKINNING_STEPS] = sConfigMgr->GetIntDefault("SkillChance.SkinningSteps", 75); + m_int_configs[CONFIG_SKILL_CHANCE_MINING_STEPS] = sConfigMgr->GetOption("SkillChance.MiningSteps", 75); + m_int_configs[CONFIG_SKILL_CHANCE_SKINNING_STEPS] = sConfigMgr->GetOption("SkillChance.SkinningSteps", 75); - m_bool_configs[CONFIG_SKILL_PROSPECTING] = sConfigMgr->GetBoolDefault("SkillChance.Prospecting", false); - m_bool_configs[CONFIG_SKILL_MILLING] = sConfigMgr->GetBoolDefault("SkillChance.Milling", false); + m_bool_configs[CONFIG_SKILL_PROSPECTING] = sConfigMgr->GetOption("SkillChance.Prospecting", false); + m_bool_configs[CONFIG_SKILL_MILLING] = sConfigMgr->GetOption("SkillChance.Milling", false); - m_int_configs[CONFIG_SKILL_GAIN_CRAFTING] = sConfigMgr->GetIntDefault("SkillGain.Crafting", 1); + m_int_configs[CONFIG_SKILL_GAIN_CRAFTING] = sConfigMgr->GetOption("SkillGain.Crafting", 1); - m_int_configs[CONFIG_SKILL_GAIN_DEFENSE] = sConfigMgr->GetIntDefault("SkillGain.Defense", 1); + m_int_configs[CONFIG_SKILL_GAIN_DEFENSE] = sConfigMgr->GetOption("SkillGain.Defense", 1); - m_int_configs[CONFIG_SKILL_GAIN_GATHERING] = sConfigMgr->GetIntDefault("SkillGain.Gathering", 1); + m_int_configs[CONFIG_SKILL_GAIN_GATHERING] = sConfigMgr->GetOption("SkillGain.Gathering", 1); - m_int_configs[CONFIG_SKILL_GAIN_WEAPON] = sConfigMgr->GetIntDefault("SkillGain.Weapon", 1); + m_int_configs[CONFIG_SKILL_GAIN_WEAPON] = sConfigMgr->GetOption("SkillGain.Weapon", 1); - m_int_configs[CONFIG_MAX_OVERSPEED_PINGS] = sConfigMgr->GetIntDefault("MaxOverspeedPings", 2); + m_int_configs[CONFIG_MAX_OVERSPEED_PINGS] = sConfigMgr->GetOption("MaxOverspeedPings", 2); if (m_int_configs[CONFIG_MAX_OVERSPEED_PINGS] != 0 && m_int_configs[CONFIG_MAX_OVERSPEED_PINGS] < 2) { sLog->outError("MaxOverspeedPings (%i) must be in range 2..infinity (or 0 to disable check). Set to 2.", m_int_configs[CONFIG_MAX_OVERSPEED_PINGS]); m_int_configs[CONFIG_MAX_OVERSPEED_PINGS] = 2; } - m_bool_configs[CONFIG_SAVE_RESPAWN_TIME_IMMEDIATELY] = sConfigMgr->GetBoolDefault("SaveRespawnTimeImmediately", true); - m_bool_configs[CONFIG_WEATHER] = sConfigMgr->GetBoolDefault("ActivateWeather", true); + m_bool_configs[CONFIG_SAVE_RESPAWN_TIME_IMMEDIATELY] = sConfigMgr->GetOption("SaveRespawnTimeImmediately", true); + m_bool_configs[CONFIG_WEATHER] = sConfigMgr->GetOption("ActivateWeather", true); - m_int_configs[CONFIG_DISABLE_BREATHING] = sConfigMgr->GetIntDefault("DisableWaterBreath", SEC_CONSOLE); + m_int_configs[CONFIG_DISABLE_BREATHING] = sConfigMgr->GetOption("DisableWaterBreath", SEC_CONSOLE); - m_bool_configs[CONFIG_ALWAYS_MAX_SKILL_FOR_LEVEL] = sConfigMgr->GetBoolDefault("AlwaysMaxSkillForLevel", false); + m_bool_configs[CONFIG_ALWAYS_MAX_SKILL_FOR_LEVEL] = sConfigMgr->GetOption("AlwaysMaxSkillForLevel", false); if (reload) { - uint32 val = sConfigMgr->GetIntDefault("Expansion", 2); + uint32 val = sConfigMgr->GetOption("Expansion", 2); if (val != m_int_configs[CONFIG_EXPANSION]) sLog->outError("Expansion option can't be changed at worldserver.conf reload, using current value (%u).", m_int_configs[CONFIG_EXPANSION]); } else - m_int_configs[CONFIG_EXPANSION] = sConfigMgr->GetIntDefault("Expansion", 2); + m_int_configs[CONFIG_EXPANSION] = sConfigMgr->GetOption("Expansion", 2); - m_int_configs[CONFIG_CHATFLOOD_MESSAGE_COUNT] = sConfigMgr->GetIntDefault("ChatFlood.MessageCount", 10); - m_int_configs[CONFIG_CHATFLOOD_MESSAGE_DELAY] = sConfigMgr->GetIntDefault("ChatFlood.MessageDelay", 1); - m_int_configs[CONFIG_CHATFLOOD_MUTE_TIME] = sConfigMgr->GetIntDefault("ChatFlood.MuteTime", 10); - m_bool_configs[CONFIG_CHAT_MUTE_FIRST_LOGIN] = sConfigMgr->GetBoolDefault("Chat.MuteFirstLogin", false); - m_int_configs[CONFIG_CHAT_TIME_MUTE_FIRST_LOGIN] = sConfigMgr->GetIntDefault("Chat.MuteTimeFirstLogin", 120); + m_int_configs[CONFIG_CHATFLOOD_MESSAGE_COUNT] = sConfigMgr->GetOption("ChatFlood.MessageCount", 10); + m_int_configs[CONFIG_CHATFLOOD_MESSAGE_DELAY] = sConfigMgr->GetOption("ChatFlood.MessageDelay", 1); + m_int_configs[CONFIG_CHATFLOOD_MUTE_TIME] = sConfigMgr->GetOption("ChatFlood.MuteTime", 10); + m_bool_configs[CONFIG_CHAT_MUTE_FIRST_LOGIN] = sConfigMgr->GetOption("Chat.MuteFirstLogin", false); + m_int_configs[CONFIG_CHAT_TIME_MUTE_FIRST_LOGIN] = sConfigMgr->GetOption("Chat.MuteTimeFirstLogin", 120); - m_int_configs[CONFIG_EVENT_ANNOUNCE] = sConfigMgr->GetIntDefault("Event.Announce", 0); + m_int_configs[CONFIG_EVENT_ANNOUNCE] = sConfigMgr->GetOption("Event.Announce", 0); - m_float_configs[CONFIG_CREATURE_FAMILY_FLEE_ASSISTANCE_RADIUS] = sConfigMgr->GetFloatDefault("CreatureFamilyFleeAssistanceRadius", 30.0f); - m_float_configs[CONFIG_CREATURE_FAMILY_ASSISTANCE_RADIUS] = sConfigMgr->GetFloatDefault("CreatureFamilyAssistanceRadius", 10.0f); - m_int_configs[CONFIG_CREATURE_FAMILY_ASSISTANCE_DELAY] = sConfigMgr->GetIntDefault("CreatureFamilyAssistanceDelay", 1500); - m_int_configs[CONFIG_CREATURE_FAMILY_FLEE_DELAY] = sConfigMgr->GetIntDefault("CreatureFamilyFleeDelay", 7000); + m_float_configs[CONFIG_CREATURE_FAMILY_FLEE_ASSISTANCE_RADIUS] = sConfigMgr->GetOption("CreatureFamilyFleeAssistanceRadius", 30.0f); + m_float_configs[CONFIG_CREATURE_FAMILY_ASSISTANCE_RADIUS] = sConfigMgr->GetOption("CreatureFamilyAssistanceRadius", 10.0f); + m_int_configs[CONFIG_CREATURE_FAMILY_ASSISTANCE_DELAY] = sConfigMgr->GetOption("CreatureFamilyAssistanceDelay", 1500); + m_int_configs[CONFIG_CREATURE_FAMILY_FLEE_DELAY] = sConfigMgr->GetOption("CreatureFamilyFleeDelay", 7000); - m_int_configs[CONFIG_WORLD_BOSS_LEVEL_DIFF] = sConfigMgr->GetIntDefault("WorldBossLevelDiff", 3); + m_int_configs[CONFIG_WORLD_BOSS_LEVEL_DIFF] = sConfigMgr->GetOption("WorldBossLevelDiff", 3); - m_bool_configs[CONFIG_QUEST_ENABLE_QUEST_TRACKER] = sConfigMgr->GetBoolDefault("Quests.EnableQuestTracker", false); + m_bool_configs[CONFIG_QUEST_ENABLE_QUEST_TRACKER] = sConfigMgr->GetOption("Quests.EnableQuestTracker", false); // note: disable value (-1) will assigned as 0xFFFFFFF, to prevent overflow at calculations limit it to max possible player level MAX_LEVEL(100) - m_int_configs[CONFIG_QUEST_LOW_LEVEL_HIDE_DIFF] = sConfigMgr->GetIntDefault("Quests.LowLevelHideDiff", 4); + m_int_configs[CONFIG_QUEST_LOW_LEVEL_HIDE_DIFF] = sConfigMgr->GetOption("Quests.LowLevelHideDiff", 4); if (m_int_configs[CONFIG_QUEST_LOW_LEVEL_HIDE_DIFF] > MAX_LEVEL) m_int_configs[CONFIG_QUEST_LOW_LEVEL_HIDE_DIFF] = MAX_LEVEL; - m_int_configs[CONFIG_QUEST_HIGH_LEVEL_HIDE_DIFF] = sConfigMgr->GetIntDefault("Quests.HighLevelHideDiff", 7); + m_int_configs[CONFIG_QUEST_HIGH_LEVEL_HIDE_DIFF] = sConfigMgr->GetOption("Quests.HighLevelHideDiff", 7); if (m_int_configs[CONFIG_QUEST_HIGH_LEVEL_HIDE_DIFF] > MAX_LEVEL) m_int_configs[CONFIG_QUEST_HIGH_LEVEL_HIDE_DIFF] = MAX_LEVEL; - m_bool_configs[CONFIG_QUEST_IGNORE_RAID] = sConfigMgr->GetBoolDefault("Quests.IgnoreRaid", false); - m_bool_configs[CONFIG_QUEST_IGNORE_AUTO_ACCEPT] = sConfigMgr->GetBoolDefault("Quests.IgnoreAutoAccept", false); - m_bool_configs[CONFIG_QUEST_IGNORE_AUTO_COMPLETE] = sConfigMgr->GetBoolDefault("Quests.IgnoreAutoComplete", false); + m_bool_configs[CONFIG_QUEST_IGNORE_RAID] = sConfigMgr->GetOption("Quests.IgnoreRaid", false); + m_bool_configs[CONFIG_QUEST_IGNORE_AUTO_ACCEPT] = sConfigMgr->GetOption("Quests.IgnoreAutoAccept", false); + m_bool_configs[CONFIG_QUEST_IGNORE_AUTO_COMPLETE] = sConfigMgr->GetOption("Quests.IgnoreAutoComplete", false); - m_int_configs[CONFIG_RANDOM_BG_RESET_HOUR] = sConfigMgr->GetIntDefault("Battleground.Random.ResetHour", 6); + m_int_configs[CONFIG_RANDOM_BG_RESET_HOUR] = sConfigMgr->GetOption("Battleground.Random.ResetHour", 6); if (m_int_configs[CONFIG_RANDOM_BG_RESET_HOUR] > 23) { sLog->outError("Battleground.Random.ResetHour (%i) can't be load. Set to 6.", m_int_configs[CONFIG_RANDOM_BG_RESET_HOUR]); m_int_configs[CONFIG_RANDOM_BG_RESET_HOUR] = 6; } - m_int_configs[CONFIG_CALENDAR_DELETE_OLD_EVENTS_HOUR] = sConfigMgr->GetIntDefault("Calendar.DeleteOldEventsHour", 6); + m_int_configs[CONFIG_CALENDAR_DELETE_OLD_EVENTS_HOUR] = sConfigMgr->GetOption("Calendar.DeleteOldEventsHour", 6); if (m_int_configs[CONFIG_CALENDAR_DELETE_OLD_EVENTS_HOUR] > 23) { sLog->outError("Calendar.DeleteOldEventsHour (%i) can't be load. Set to 6.", m_int_configs[CONFIG_CALENDAR_DELETE_OLD_EVENTS_HOUR]); m_int_configs[CONFIG_CALENDAR_DELETE_OLD_EVENTS_HOUR] = 6; } - m_int_configs[CONFIG_GUILD_RESET_HOUR] = sConfigMgr->GetIntDefault("Guild.ResetHour", 6); + m_int_configs[CONFIG_GUILD_RESET_HOUR] = sConfigMgr->GetOption("Guild.ResetHour", 6); if (m_int_configs[CONFIG_GUILD_RESET_HOUR] > 23) { sLog->outError("Guild.ResetHour (%i) can't be load. Set to 6.", m_int_configs[CONFIG_GUILD_RESET_HOUR]); m_int_configs[CONFIG_GUILD_RESET_HOUR] = 6; } - m_int_configs[CONFIG_GUILD_BANK_INITIAL_TABS] = sConfigMgr->GetIntDefault("Guild.BankInitialTabs", 0); - m_int_configs[CONFIG_GUILD_BANK_TAB_COST_0] = sConfigMgr->GetIntDefault("Guild.BankTabCost0", 1000000); - m_int_configs[CONFIG_GUILD_BANK_TAB_COST_1] = sConfigMgr->GetIntDefault("Guild.BankTabCost1", 2500000); - m_int_configs[CONFIG_GUILD_BANK_TAB_COST_2] = sConfigMgr->GetIntDefault("Guild.BankTabCost2", 5000000); - m_int_configs[CONFIG_GUILD_BANK_TAB_COST_3] = sConfigMgr->GetIntDefault("Guild.BankTabCost3", 10000000); - m_int_configs[CONFIG_GUILD_BANK_TAB_COST_4] = sConfigMgr->GetIntDefault("Guild.BankTabCost4", 25000000); - m_int_configs[CONFIG_GUILD_BANK_TAB_COST_5] = sConfigMgr->GetIntDefault("Guild.BankTabCost5", 50000000); + m_int_configs[CONFIG_GUILD_BANK_INITIAL_TABS] = sConfigMgr->GetOption("Guild.BankInitialTabs", 0); + m_int_configs[CONFIG_GUILD_BANK_TAB_COST_0] = sConfigMgr->GetOption("Guild.BankTabCost0", 1000000); + m_int_configs[CONFIG_GUILD_BANK_TAB_COST_1] = sConfigMgr->GetOption("Guild.BankTabCost1", 2500000); + m_int_configs[CONFIG_GUILD_BANK_TAB_COST_2] = sConfigMgr->GetOption("Guild.BankTabCost2", 5000000); + m_int_configs[CONFIG_GUILD_BANK_TAB_COST_3] = sConfigMgr->GetOption("Guild.BankTabCost3", 10000000); + m_int_configs[CONFIG_GUILD_BANK_TAB_COST_4] = sConfigMgr->GetOption("Guild.BankTabCost4", 25000000); + m_int_configs[CONFIG_GUILD_BANK_TAB_COST_5] = sConfigMgr->GetOption("Guild.BankTabCost5", 50000000); - m_bool_configs[CONFIG_DETECT_POS_COLLISION] = sConfigMgr->GetBoolDefault("DetectPosCollision", true); + m_bool_configs[CONFIG_DETECT_POS_COLLISION] = sConfigMgr->GetOption("DetectPosCollision", true); - m_bool_configs[CONFIG_RESTRICTED_LFG_CHANNEL] = sConfigMgr->GetBoolDefault("Channel.RestrictedLfg", true); - m_bool_configs[CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL] = sConfigMgr->GetBoolDefault("Channel.SilentlyGMJoin", false); + m_bool_configs[CONFIG_RESTRICTED_LFG_CHANNEL] = sConfigMgr->GetOption("Channel.RestrictedLfg", true); + m_bool_configs[CONFIG_SILENTLY_GM_JOIN_TO_CHANNEL] = sConfigMgr->GetOption("Channel.SilentlyGMJoin", false); - m_bool_configs[CONFIG_TALENTS_INSPECTING] = sConfigMgr->GetBoolDefault("TalentsInspecting", true); - m_bool_configs[CONFIG_CHAT_FAKE_MESSAGE_PREVENTING] = sConfigMgr->GetBoolDefault("ChatFakeMessagePreventing", false); - m_int_configs[CONFIG_CHAT_STRICT_LINK_CHECKING_SEVERITY] = sConfigMgr->GetIntDefault("ChatStrictLinkChecking.Severity", 0); - m_int_configs[CONFIG_CHAT_STRICT_LINK_CHECKING_KICK] = sConfigMgr->GetIntDefault("ChatStrictLinkChecking.Kick", 0); + m_bool_configs[CONFIG_TALENTS_INSPECTING] = sConfigMgr->GetOption("TalentsInspecting", true); + m_bool_configs[CONFIG_CHAT_FAKE_MESSAGE_PREVENTING] = sConfigMgr->GetOption("ChatFakeMessagePreventing", false); + m_int_configs[CONFIG_CHAT_STRICT_LINK_CHECKING_SEVERITY] = sConfigMgr->GetOption("ChatStrictLinkChecking.Severity", 0); + m_int_configs[CONFIG_CHAT_STRICT_LINK_CHECKING_KICK] = sConfigMgr->GetOption("ChatStrictLinkChecking.Kick", 0); - m_int_configs[CONFIG_CORPSE_DECAY_NORMAL] = sConfigMgr->GetIntDefault("Corpse.Decay.NORMAL", 60); - m_int_configs[CONFIG_CORPSE_DECAY_RARE] = sConfigMgr->GetIntDefault("Corpse.Decay.RARE", 300); - m_int_configs[CONFIG_CORPSE_DECAY_ELITE] = sConfigMgr->GetIntDefault("Corpse.Decay.ELITE", 300); - m_int_configs[CONFIG_CORPSE_DECAY_RAREELITE] = sConfigMgr->GetIntDefault("Corpse.Decay.RAREELITE", 300); - m_int_configs[CONFIG_CORPSE_DECAY_WORLDBOSS] = sConfigMgr->GetIntDefault("Corpse.Decay.WORLDBOSS", 3600); + m_int_configs[CONFIG_CORPSE_DECAY_NORMAL] = sConfigMgr->GetOption("Corpse.Decay.NORMAL", 60); + m_int_configs[CONFIG_CORPSE_DECAY_RARE] = sConfigMgr->GetOption("Corpse.Decay.RARE", 300); + m_int_configs[CONFIG_CORPSE_DECAY_ELITE] = sConfigMgr->GetOption("Corpse.Decay.ELITE", 300); + m_int_configs[CONFIG_CORPSE_DECAY_RAREELITE] = sConfigMgr->GetOption("Corpse.Decay.RAREELITE", 300); + m_int_configs[CONFIG_CORPSE_DECAY_WORLDBOSS] = sConfigMgr->GetOption("Corpse.Decay.WORLDBOSS", 3600); - m_int_configs[CONFIG_DEATH_SICKNESS_LEVEL] = sConfigMgr->GetIntDefault ("Death.SicknessLevel", 11); - m_bool_configs[CONFIG_DEATH_CORPSE_RECLAIM_DELAY_PVP] = sConfigMgr->GetBoolDefault("Death.CorpseReclaimDelay.PvP", true); - m_bool_configs[CONFIG_DEATH_CORPSE_RECLAIM_DELAY_PVE] = sConfigMgr->GetBoolDefault("Death.CorpseReclaimDelay.PvE", true); - m_bool_configs[CONFIG_DEATH_BONES_WORLD] = sConfigMgr->GetBoolDefault("Death.Bones.World", true); - m_bool_configs[CONFIG_DEATH_BONES_BG_OR_ARENA] = sConfigMgr->GetBoolDefault("Death.Bones.BattlegroundOrArena", true); + m_int_configs[CONFIG_DEATH_SICKNESS_LEVEL] = sConfigMgr->GetOption ("Death.SicknessLevel", 11); + m_bool_configs[CONFIG_DEATH_CORPSE_RECLAIM_DELAY_PVP] = sConfigMgr->GetOption("Death.CorpseReclaimDelay.PvP", true); + m_bool_configs[CONFIG_DEATH_CORPSE_RECLAIM_DELAY_PVE] = sConfigMgr->GetOption("Death.CorpseReclaimDelay.PvE", true); + m_bool_configs[CONFIG_DEATH_BONES_WORLD] = sConfigMgr->GetOption("Death.Bones.World", true); + m_bool_configs[CONFIG_DEATH_BONES_BG_OR_ARENA] = sConfigMgr->GetOption("Death.Bones.BattlegroundOrArena", true); - m_bool_configs[CONFIG_DIE_COMMAND_MODE] = sConfigMgr->GetBoolDefault("Die.Command.Mode", true); + m_bool_configs[CONFIG_DIE_COMMAND_MODE] = sConfigMgr->GetOption("Die.Command.Mode", true); // always use declined names in the russian client m_bool_configs[CONFIG_DECLINED_NAMES_USED] = - (m_int_configs[CONFIG_REALM_ZONE] == REALM_ZONE_RUSSIAN) ? true : sConfigMgr->GetBoolDefault("DeclinedNames", false); + (m_int_configs[CONFIG_REALM_ZONE] == REALM_ZONE_RUSSIAN) ? true : sConfigMgr->GetOption("DeclinedNames", false); - m_float_configs[CONFIG_LISTEN_RANGE_SAY] = sConfigMgr->GetFloatDefault("ListenRange.Say", 25.0f); - m_float_configs[CONFIG_LISTEN_RANGE_TEXTEMOTE] = sConfigMgr->GetFloatDefault("ListenRange.TextEmote", 25.0f); - m_float_configs[CONFIG_LISTEN_RANGE_YELL] = sConfigMgr->GetFloatDefault("ListenRange.Yell", 300.0f); + m_float_configs[CONFIG_LISTEN_RANGE_SAY] = sConfigMgr->GetOption("ListenRange.Say", 25.0f); + m_float_configs[CONFIG_LISTEN_RANGE_TEXTEMOTE] = sConfigMgr->GetOption("ListenRange.TextEmote", 25.0f); + m_float_configs[CONFIG_LISTEN_RANGE_YELL] = sConfigMgr->GetOption("ListenRange.Yell", 300.0f); - m_bool_configs[CONFIG_BATTLEGROUND_DISABLE_QUEST_SHARE_IN_BG] = sConfigMgr->GetBoolDefault("Battleground.DisableQuestShareInBG", false); - m_bool_configs[CONFIG_BATTLEGROUND_DISABLE_READY_CHECK_IN_BG] = sConfigMgr->GetBoolDefault("Battleground.DisableReadyCheckInBG", false); - m_bool_configs[CONFIG_BATTLEGROUND_CAST_DESERTER] = sConfigMgr->GetBoolDefault("Battleground.CastDeserter", true); - m_bool_configs[CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_ENABLE] = sConfigMgr->GetBoolDefault("Battleground.QueueAnnouncer.Enable", false); - m_bool_configs[CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_PLAYERONLY] = sConfigMgr->GetBoolDefault("Battleground.QueueAnnouncer.PlayerOnly", false); - m_bool_configs[CONFIG_BATTLEGROUND_STORE_STATISTICS_ENABLE] = sConfigMgr->GetBoolDefault("Battleground.StoreStatistics.Enable", false); - m_bool_configs[CONFIG_BATTLEGROUND_TRACK_DESERTERS] = sConfigMgr->GetBoolDefault("Battleground.TrackDeserters.Enable", false); - m_int_configs[CONFIG_BATTLEGROUND_PREMATURE_FINISH_TIMER] = sConfigMgr->GetIntDefault ("Battleground.PrematureFinishTimer", 5 * MINUTE * IN_MILLISECONDS); - m_int_configs[CONFIG_BATTLEGROUND_INVITATION_TYPE] = sConfigMgr->GetIntDefault("Battleground.InvitationType", 0); - m_int_configs[CONFIG_BATTLEGROUND_PREMADE_GROUP_WAIT_FOR_MATCH] = sConfigMgr->GetIntDefault ("Battleground.PremadeGroupWaitForMatch", 30 * MINUTE * IN_MILLISECONDS); - m_bool_configs[CONFIG_BG_XP_FOR_KILL] = sConfigMgr->GetBoolDefault("Battleground.GiveXPForKills", false); - m_int_configs[CONFIG_BATTLEGROUND_REPORT_AFK_TIMER] = sConfigMgr->GetIntDefault("Battleground.ReportAFK.Timer", 4); - m_int_configs[CONFIG_BATTLEGROUND_REPORT_AFK] = sConfigMgr->GetIntDefault("Battleground.ReportAFK", 3); + m_bool_configs[CONFIG_BATTLEGROUND_DISABLE_QUEST_SHARE_IN_BG] = sConfigMgr->GetOption("Battleground.DisableQuestShareInBG", false); + m_bool_configs[CONFIG_BATTLEGROUND_DISABLE_READY_CHECK_IN_BG] = sConfigMgr->GetOption("Battleground.DisableReadyCheckInBG", false); + m_bool_configs[CONFIG_BATTLEGROUND_CAST_DESERTER] = sConfigMgr->GetOption("Battleground.CastDeserter", true); + m_bool_configs[CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_ENABLE] = sConfigMgr->GetOption("Battleground.QueueAnnouncer.Enable", false); + m_bool_configs[CONFIG_BATTLEGROUND_QUEUE_ANNOUNCER_PLAYERONLY] = sConfigMgr->GetOption("Battleground.QueueAnnouncer.PlayerOnly", false); + m_bool_configs[CONFIG_BATTLEGROUND_STORE_STATISTICS_ENABLE] = sConfigMgr->GetOption("Battleground.StoreStatistics.Enable", false); + m_bool_configs[CONFIG_BATTLEGROUND_TRACK_DESERTERS] = sConfigMgr->GetOption("Battleground.TrackDeserters.Enable", false); + m_int_configs[CONFIG_BATTLEGROUND_PREMATURE_FINISH_TIMER] = sConfigMgr->GetOption ("Battleground.PrematureFinishTimer", 5 * MINUTE * IN_MILLISECONDS); + m_int_configs[CONFIG_BATTLEGROUND_INVITATION_TYPE] = sConfigMgr->GetOption("Battleground.InvitationType", 0); + m_int_configs[CONFIG_BATTLEGROUND_PREMADE_GROUP_WAIT_FOR_MATCH] = sConfigMgr->GetOption ("Battleground.PremadeGroupWaitForMatch", 30 * MINUTE * IN_MILLISECONDS); + m_bool_configs[CONFIG_BG_XP_FOR_KILL] = sConfigMgr->GetOption("Battleground.GiveXPForKills", false); + m_int_configs[CONFIG_BATTLEGROUND_REPORT_AFK_TIMER] = sConfigMgr->GetOption("Battleground.ReportAFK.Timer", 4); + m_int_configs[CONFIG_BATTLEGROUND_REPORT_AFK] = sConfigMgr->GetOption("Battleground.ReportAFK", 3); if (m_int_configs[CONFIG_BATTLEGROUND_REPORT_AFK] < 1) { sLog->outError("Battleground.ReportAFK (%d) must be >0. Using 3 instead.", m_int_configs[CONFIG_BATTLEGROUND_REPORT_AFK]); @@ -1138,38 +1138,38 @@ void World::LoadConfigSettings(bool reload) sLog->outError("Battleground.ReportAFK (%d) must be <10. Using 3 instead.", m_int_configs[CONFIG_BATTLEGROUND_REPORT_AFK]); m_int_configs[CONFIG_BATTLEGROUND_REPORT_AFK] = 3; } - m_int_configs[CONFIG_BATTLEGROUND_PLAYER_RESPAWN] = sConfigMgr->GetIntDefault("Battleground.PlayerRespawn", 30); + m_int_configs[CONFIG_BATTLEGROUND_PLAYER_RESPAWN] = sConfigMgr->GetOption("Battleground.PlayerRespawn", 30); if (m_int_configs[CONFIG_BATTLEGROUND_PLAYER_RESPAWN] < 3) { sLog->outError("Battleground.PlayerRespawn (%i) must be >2. Using 30 instead.", m_int_configs[CONFIG_BATTLEGROUND_PLAYER_RESPAWN]); m_int_configs[CONFIG_BATTLEGROUND_PLAYER_RESPAWN] = 30; } - m_int_configs[CONFIG_BATTLEGROUND_BUFF_RESPAWN] = sConfigMgr->GetIntDefault("Battleground.BuffRespawn", 180); + m_int_configs[CONFIG_BATTLEGROUND_BUFF_RESPAWN] = sConfigMgr->GetOption("Battleground.BuffRespawn", 180); if (m_int_configs[CONFIG_BATTLEGROUND_BUFF_RESPAWN] < 1) { sLog->outError("Battleground.BuffRespawn (%i) must be >0. Using 180 instead.", m_int_configs[CONFIG_BATTLEGROUND_BUFF_RESPAWN]); m_int_configs[CONFIG_BATTLEGROUND_BUFF_RESPAWN] = 180; } - m_int_configs[CONFIG_ARENA_MAX_RATING_DIFFERENCE] = sConfigMgr->GetIntDefault ("Arena.MaxRatingDifference", 150); - m_int_configs[CONFIG_ARENA_RATING_DISCARD_TIMER] = sConfigMgr->GetIntDefault ("Arena.RatingDiscardTimer", 10 * MINUTE * IN_MILLISECONDS); - m_bool_configs[CONFIG_ARENA_AUTO_DISTRIBUTE_POINTS] = sConfigMgr->GetBoolDefault("Arena.AutoDistributePoints", false); - m_int_configs[CONFIG_ARENA_AUTO_DISTRIBUTE_INTERVAL_DAYS] = sConfigMgr->GetIntDefault ("Arena.AutoDistributeInterval", 7); // pussywizard: spoiled by implementing constant day and hour, always 7 now - m_int_configs[CONFIG_ARENA_GAMES_REQUIRED] = sConfigMgr->GetIntDefault ("Arena.GamesRequired", 10); - m_int_configs[CONFIG_ARENA_SEASON_ID] = sConfigMgr->GetIntDefault ("Arena.ArenaSeason.ID", 1); - m_int_configs[CONFIG_ARENA_START_RATING] = sConfigMgr->GetIntDefault ("Arena.ArenaStartRating", 0); - m_int_configs[CONFIG_ARENA_START_PERSONAL_RATING] = sConfigMgr->GetIntDefault ("Arena.ArenaStartPersonalRating", 1000); - m_int_configs[CONFIG_ARENA_START_MATCHMAKER_RATING] = sConfigMgr->GetIntDefault ("Arena.ArenaStartMatchmakerRating", 1500); - m_bool_configs[CONFIG_ARENA_SEASON_IN_PROGRESS] = sConfigMgr->GetBoolDefault("Arena.ArenaSeason.InProgress", true); - m_float_configs[CONFIG_ARENA_WIN_RATING_MODIFIER_1] = sConfigMgr->GetFloatDefault("Arena.ArenaWinRatingModifier1", 48.0f); - m_float_configs[CONFIG_ARENA_WIN_RATING_MODIFIER_2] = sConfigMgr->GetFloatDefault("Arena.ArenaWinRatingModifier2", 24.0f); - m_float_configs[CONFIG_ARENA_LOSE_RATING_MODIFIER] = sConfigMgr->GetFloatDefault("Arena.ArenaLoseRatingModifier", 24.0f); - m_float_configs[CONFIG_ARENA_MATCHMAKER_RATING_MODIFIER] = sConfigMgr->GetFloatDefault("Arena.ArenaMatchmakerRatingModifier", 24.0f); - m_bool_configs[CONFIG_ARENA_QUEUE_ANNOUNCER_ENABLE] = sConfigMgr->GetBoolDefault ("Arena.QueueAnnouncer.Enable", false); + m_int_configs[CONFIG_ARENA_MAX_RATING_DIFFERENCE] = sConfigMgr->GetOption ("Arena.MaxRatingDifference", 150); + m_int_configs[CONFIG_ARENA_RATING_DISCARD_TIMER] = sConfigMgr->GetOption ("Arena.RatingDiscardTimer", 10 * MINUTE * IN_MILLISECONDS); + m_bool_configs[CONFIG_ARENA_AUTO_DISTRIBUTE_POINTS] = sConfigMgr->GetOption("Arena.AutoDistributePoints", false); + m_int_configs[CONFIG_ARENA_AUTO_DISTRIBUTE_INTERVAL_DAYS] = sConfigMgr->GetOption ("Arena.AutoDistributeInterval", 7); // pussywizard: spoiled by implementing constant day and hour, always 7 now + m_int_configs[CONFIG_ARENA_GAMES_REQUIRED] = sConfigMgr->GetOption ("Arena.GamesRequired", 10); + m_int_configs[CONFIG_ARENA_SEASON_ID] = sConfigMgr->GetOption ("Arena.ArenaSeason.ID", 1); + m_int_configs[CONFIG_ARENA_START_RATING] = sConfigMgr->GetOption ("Arena.ArenaStartRating", 0); + m_int_configs[CONFIG_ARENA_START_PERSONAL_RATING] = sConfigMgr->GetOption ("Arena.ArenaStartPersonalRating", 1000); + m_int_configs[CONFIG_ARENA_START_MATCHMAKER_RATING] = sConfigMgr->GetOption ("Arena.ArenaStartMatchmakerRating", 1500); + m_bool_configs[CONFIG_ARENA_SEASON_IN_PROGRESS] = sConfigMgr->GetOption("Arena.ArenaSeason.InProgress", true); + m_float_configs[CONFIG_ARENA_WIN_RATING_MODIFIER_1] = sConfigMgr->GetOption("Arena.ArenaWinRatingModifier1", 48.0f); + m_float_configs[CONFIG_ARENA_WIN_RATING_MODIFIER_2] = sConfigMgr->GetOption("Arena.ArenaWinRatingModifier2", 24.0f); + m_float_configs[CONFIG_ARENA_LOSE_RATING_MODIFIER] = sConfigMgr->GetOption("Arena.ArenaLoseRatingModifier", 24.0f); + m_float_configs[CONFIG_ARENA_MATCHMAKER_RATING_MODIFIER] = sConfigMgr->GetOption("Arena.ArenaMatchmakerRatingModifier", 24.0f); + m_bool_configs[CONFIG_ARENA_QUEUE_ANNOUNCER_ENABLE] = sConfigMgr->GetOption ("Arena.QueueAnnouncer.Enable", false); - m_bool_configs[CONFIG_OFFHAND_CHECK_AT_SPELL_UNLEARN] = sConfigMgr->GetBoolDefault("OffhandCheckAtSpellUnlearn", true); + m_bool_configs[CONFIG_OFFHAND_CHECK_AT_SPELL_UNLEARN] = sConfigMgr->GetOption("OffhandCheckAtSpellUnlearn", true); - if (int32 clientCacheId = sConfigMgr->GetIntDefault("ClientCacheVersion", 0)) + if (int32 clientCacheId = sConfigMgr->GetOption("ClientCacheVersion", 0)) { // overwrite DB/old value if (clientCacheId > 0) @@ -1181,17 +1181,17 @@ void World::LoadConfigSettings(bool reload) sLog->outError("ClientCacheVersion can't be negative %d, ignored.", clientCacheId); } - m_int_configs[CONFIG_INSTANT_LOGOUT] = sConfigMgr->GetIntDefault("InstantLogout", SEC_MODERATOR); + m_int_configs[CONFIG_INSTANT_LOGOUT] = sConfigMgr->GetOption("InstantLogout", SEC_MODERATOR); - m_int_configs[CONFIG_GUILD_EVENT_LOG_COUNT] = sConfigMgr->GetIntDefault("Guild.EventLogRecordsCount", GUILD_EVENTLOG_MAX_RECORDS); + m_int_configs[CONFIG_GUILD_EVENT_LOG_COUNT] = sConfigMgr->GetOption("Guild.EventLogRecordsCount", GUILD_EVENTLOG_MAX_RECORDS); if (m_int_configs[CONFIG_GUILD_EVENT_LOG_COUNT] > GUILD_EVENTLOG_MAX_RECORDS) m_int_configs[CONFIG_GUILD_EVENT_LOG_COUNT] = GUILD_EVENTLOG_MAX_RECORDS; - m_int_configs[CONFIG_GUILD_BANK_EVENT_LOG_COUNT] = sConfigMgr->GetIntDefault("Guild.BankEventLogRecordsCount", GUILD_BANKLOG_MAX_RECORDS); + m_int_configs[CONFIG_GUILD_BANK_EVENT_LOG_COUNT] = sConfigMgr->GetOption("Guild.BankEventLogRecordsCount", GUILD_BANKLOG_MAX_RECORDS); if (m_int_configs[CONFIG_GUILD_BANK_EVENT_LOG_COUNT] > GUILD_BANKLOG_MAX_RECORDS) m_int_configs[CONFIG_GUILD_BANK_EVENT_LOG_COUNT] = GUILD_BANKLOG_MAX_RECORDS; //visibility on continents - m_MaxVisibleDistanceOnContinents = sConfigMgr->GetFloatDefault("Visibility.Distance.Continents", DEFAULT_VISIBILITY_DISTANCE); + m_MaxVisibleDistanceOnContinents = sConfigMgr->GetOption("Visibility.Distance.Continents", DEFAULT_VISIBILITY_DISTANCE); if (m_MaxVisibleDistanceOnContinents < 45 * sWorld->getRate(RATE_CREATURE_AGGRO)) { sLog->outError("Visibility.Distance.Continents can't be less max aggro radius %f", 45 * sWorld->getRate(RATE_CREATURE_AGGRO)); @@ -1204,7 +1204,7 @@ void World::LoadConfigSettings(bool reload) } //visibility in instances - m_MaxVisibleDistanceInInstances = sConfigMgr->GetFloatDefault("Visibility.Distance.Instances", DEFAULT_VISIBILITY_INSTANCE); + m_MaxVisibleDistanceInInstances = sConfigMgr->GetOption("Visibility.Distance.Instances", DEFAULT_VISIBILITY_INSTANCE); if (m_MaxVisibleDistanceInInstances < 45 * sWorld->getRate(RATE_CREATURE_AGGRO)) { sLog->outError("Visibility.Distance.Instances can't be less max aggro radius %f", 45 * sWorld->getRate(RATE_CREATURE_AGGRO)); @@ -1217,7 +1217,7 @@ void World::LoadConfigSettings(bool reload) } //visibility in BG/Arenas - m_MaxVisibleDistanceInBGArenas = sConfigMgr->GetFloatDefault("Visibility.Distance.BGArenas", DEFAULT_VISIBILITY_BGARENAS); + m_MaxVisibleDistanceInBGArenas = sConfigMgr->GetOption("Visibility.Distance.BGArenas", DEFAULT_VISIBILITY_BGARENAS); if (m_MaxVisibleDistanceInBGArenas < 45 * sWorld->getRate(RATE_CREATURE_AGGRO)) { sLog->outError("Visibility.Distance.BGArenas can't be less max aggro radius %f", 45 * sWorld->getRate(RATE_CREATURE_AGGRO)); @@ -1230,18 +1230,18 @@ void World::LoadConfigSettings(bool reload) } ///- Load the CharDelete related config options - m_int_configs[CONFIG_CHARDELETE_METHOD] = sConfigMgr->GetIntDefault("CharDelete.Method", 0); - m_int_configs[CONFIG_CHARDELETE_MIN_LEVEL] = sConfigMgr->GetIntDefault("CharDelete.MinLevel", 0); - m_int_configs[CONFIG_CHARDELETE_KEEP_DAYS] = sConfigMgr->GetIntDefault("CharDelete.KeepDays", 30); + m_int_configs[CONFIG_CHARDELETE_METHOD] = sConfigMgr->GetOption("CharDelete.Method", 0); + m_int_configs[CONFIG_CHARDELETE_MIN_LEVEL] = sConfigMgr->GetOption("CharDelete.MinLevel", 0); + m_int_configs[CONFIG_CHARDELETE_KEEP_DAYS] = sConfigMgr->GetOption("CharDelete.KeepDays", 30); ///- Load the ItemDelete related config options - m_bool_configs[CONFIG_ITEMDELETE_METHOD] = sConfigMgr->GetBoolDefault("ItemDelete.Method", 0); - m_bool_configs[CONFIG_ITEMDELETE_VENDOR] = sConfigMgr->GetBoolDefault("ItemDelete.Vendor", 0); - m_int_configs[CONFIG_ITEMDELETE_QUALITY] = sConfigMgr->GetIntDefault("ItemDelete.Quality", 3); - m_int_configs[CONFIG_ITEMDELETE_ITEM_LEVEL] = sConfigMgr->GetIntDefault("ItemDelete.ItemLevel", 80); + m_bool_configs[CONFIG_ITEMDELETE_METHOD] = sConfigMgr->GetOption("ItemDelete.Method", 0); + m_bool_configs[CONFIG_ITEMDELETE_VENDOR] = sConfigMgr->GetOption("ItemDelete.Vendor", 0); + m_int_configs[CONFIG_ITEMDELETE_QUALITY] = sConfigMgr->GetOption("ItemDelete.Quality", 3); + m_int_configs[CONFIG_ITEMDELETE_ITEM_LEVEL] = sConfigMgr->GetOption("ItemDelete.ItemLevel", 80); ///- Read the "Data" directory from the config file - std::string dataPath = sConfigMgr->GetStringDefault("DataDir", "./"); + std::string dataPath = sConfigMgr->GetOption("DataDir", "./"); if (dataPath.empty() || (dataPath.at(dataPath.length() - 1) != '/' && dataPath.at(dataPath.length() - 1) != '\\')) dataPath.push_back('/'); @@ -1265,11 +1265,11 @@ void World::LoadConfigSettings(bool reload) sLog->outString("Using DataDir %s", m_dataPath.c_str()); } - m_bool_configs[CONFIG_VMAP_INDOOR_CHECK] = sConfigMgr->GetBoolDefault("vmap.enableIndoorCheck", 0); - bool enableIndoor = sConfigMgr->GetBoolDefault("vmap.enableIndoorCheck", true); - bool enableLOS = sConfigMgr->GetBoolDefault("vmap.enableLOS", true); - bool enableHeight = sConfigMgr->GetBoolDefault("vmap.enableHeight", true); - bool enablePetLOS = sConfigMgr->GetBoolDefault("vmap.petLOS", true); + m_bool_configs[CONFIG_VMAP_INDOOR_CHECK] = sConfigMgr->GetOption("vmap.enableIndoorCheck", 0); + bool enableIndoor = sConfigMgr->GetOption("vmap.enableIndoorCheck", true); + bool enableLOS = sConfigMgr->GetOption("vmap.enableLOS", true); + bool enableHeight = sConfigMgr->GetOption("vmap.enableHeight", true); + bool enablePetLOS = sConfigMgr->GetOption("vmap.petLOS", true); if (!enableHeight) sLog->outError("VMap height checking disabled! Creatures movements and other various things WILL be broken! Expect no support."); @@ -1278,60 +1278,60 @@ void World::LoadConfigSettings(bool reload) VMAP::VMapFactory::createOrGetVMapManager()->setEnableHeightCalc(enableHeight); sLog->outString("WORLD: VMap support included. LineOfSight:%i, getHeight:%i, indoorCheck:%i PetLOS:%i", enableLOS, enableHeight, enableIndoor, enablePetLOS); - m_bool_configs[CONFIG_PET_LOS] = sConfigMgr->GetBoolDefault("vmap.petLOS", true); - m_bool_configs[CONFIG_START_ALL_SPELLS] = sConfigMgr->GetBoolDefault("PlayerStart.CustomSpells", false); - m_int_configs[CONFIG_HONOR_AFTER_DUEL] = sConfigMgr->GetIntDefault("HonorPointsAfterDuel", 0); - m_bool_configs[CONFIG_START_ALL_EXPLORED] = sConfigMgr->GetBoolDefault("PlayerStart.MapsExplored", false); - m_bool_configs[CONFIG_START_ALL_REP] = sConfigMgr->GetBoolDefault("PlayerStart.AllReputation", false); - m_bool_configs[CONFIG_ALWAYS_MAXSKILL] = sConfigMgr->GetBoolDefault("AlwaysMaxWeaponSkill", false); - m_bool_configs[CONFIG_PVP_TOKEN_ENABLE] = sConfigMgr->GetBoolDefault("PvPToken.Enable", false); - m_int_configs[CONFIG_PVP_TOKEN_MAP_TYPE] = sConfigMgr->GetIntDefault("PvPToken.MapAllowType", 4); - m_int_configs[CONFIG_PVP_TOKEN_ID] = sConfigMgr->GetIntDefault("PvPToken.ItemID", 29434); - m_int_configs[CONFIG_PVP_TOKEN_COUNT] = sConfigMgr->GetIntDefault("PvPToken.ItemCount", 1); + m_bool_configs[CONFIG_PET_LOS] = sConfigMgr->GetOption("vmap.petLOS", true); + m_bool_configs[CONFIG_START_ALL_SPELLS] = sConfigMgr->GetOption("PlayerStart.CustomSpells", false); + m_int_configs[CONFIG_HONOR_AFTER_DUEL] = sConfigMgr->GetOption("HonorPointsAfterDuel", 0); + m_bool_configs[CONFIG_START_ALL_EXPLORED] = sConfigMgr->GetOption("PlayerStart.MapsExplored", false); + m_bool_configs[CONFIG_START_ALL_REP] = sConfigMgr->GetOption("PlayerStart.AllReputation", false); + m_bool_configs[CONFIG_ALWAYS_MAXSKILL] = sConfigMgr->GetOption("AlwaysMaxWeaponSkill", false); + m_bool_configs[CONFIG_PVP_TOKEN_ENABLE] = sConfigMgr->GetOption("PvPToken.Enable", false); + m_int_configs[CONFIG_PVP_TOKEN_MAP_TYPE] = sConfigMgr->GetOption("PvPToken.MapAllowType", 4); + m_int_configs[CONFIG_PVP_TOKEN_ID] = sConfigMgr->GetOption("PvPToken.ItemID", 29434); + m_int_configs[CONFIG_PVP_TOKEN_COUNT] = sConfigMgr->GetOption("PvPToken.ItemCount", 1); if (m_int_configs[CONFIG_PVP_TOKEN_COUNT] < 1) m_int_configs[CONFIG_PVP_TOKEN_COUNT] = 1; - m_bool_configs[CONFIG_NO_RESET_TALENT_COST] = sConfigMgr->GetBoolDefault("NoResetTalentsCost", false); - m_int_configs[CONFIG_TOGGLE_XP_COST] = sConfigMgr->GetIntDefault("ToggleXP.Cost", 100000); - m_bool_configs[CONFIG_SHOW_KICK_IN_WORLD] = sConfigMgr->GetBoolDefault("ShowKickInWorld", false); - m_bool_configs[CONFIG_SHOW_MUTE_IN_WORLD] = sConfigMgr->GetBoolDefault("ShowMuteInWorld", false); - m_bool_configs[CONFIG_SHOW_BAN_IN_WORLD] = sConfigMgr->GetBoolDefault("ShowBanInWorld", false); - m_int_configs[CONFIG_INTERVAL_LOG_UPDATE] = sConfigMgr->GetIntDefault("RecordUpdateTimeDiffInterval", 300000); - m_int_configs[CONFIG_MIN_LOG_UPDATE] = sConfigMgr->GetIntDefault("MinRecordUpdateTimeDiff", 100); - m_int_configs[CONFIG_NUMTHREADS] = sConfigMgr->GetIntDefault("MapUpdate.Threads", 1); - m_int_configs[CONFIG_MAX_RESULTS_LOOKUP_COMMANDS] = sConfigMgr->GetIntDefault("Command.LookupMaxResults", 0); + m_bool_configs[CONFIG_NO_RESET_TALENT_COST] = sConfigMgr->GetOption("NoResetTalentsCost", false); + m_int_configs[CONFIG_TOGGLE_XP_COST] = sConfigMgr->GetOption("ToggleXP.Cost", 100000); + m_bool_configs[CONFIG_SHOW_KICK_IN_WORLD] = sConfigMgr->GetOption("ShowKickInWorld", false); + m_bool_configs[CONFIG_SHOW_MUTE_IN_WORLD] = sConfigMgr->GetOption("ShowMuteInWorld", false); + m_bool_configs[CONFIG_SHOW_BAN_IN_WORLD] = sConfigMgr->GetOption("ShowBanInWorld", false); + m_int_configs[CONFIG_INTERVAL_LOG_UPDATE] = sConfigMgr->GetOption("RecordUpdateTimeDiffInterval", 300000); + m_int_configs[CONFIG_MIN_LOG_UPDATE] = sConfigMgr->GetOption("MinRecordUpdateTimeDiff", 100); + m_int_configs[CONFIG_NUMTHREADS] = sConfigMgr->GetOption("MapUpdate.Threads", 1); + m_int_configs[CONFIG_MAX_RESULTS_LOOKUP_COMMANDS] = sConfigMgr->GetOption("Command.LookupMaxResults", 0); // chat logging - m_bool_configs[CONFIG_CHATLOG_CHANNEL] = sConfigMgr->GetBoolDefault("ChatLogs.Channel", false); - m_bool_configs[CONFIG_CHATLOG_WHISPER] = sConfigMgr->GetBoolDefault("ChatLogs.Whisper", false); - m_bool_configs[CONFIG_CHATLOG_SYSCHAN] = sConfigMgr->GetBoolDefault("ChatLogs.SysChan", false); - m_bool_configs[CONFIG_CHATLOG_PARTY] = sConfigMgr->GetBoolDefault("ChatLogs.Party", false); - m_bool_configs[CONFIG_CHATLOG_RAID] = sConfigMgr->GetBoolDefault("ChatLogs.Raid", false); - m_bool_configs[CONFIG_CHATLOG_GUILD] = sConfigMgr->GetBoolDefault("ChatLogs.Guild", false); - m_bool_configs[CONFIG_CHATLOG_PUBLIC] = sConfigMgr->GetBoolDefault("ChatLogs.Public", false); - m_bool_configs[CONFIG_CHATLOG_ADDON] = sConfigMgr->GetBoolDefault("ChatLogs.Addon", false); - m_bool_configs[CONFIG_CHATLOG_BGROUND] = sConfigMgr->GetBoolDefault("ChatLogs.BattleGround", false); + m_bool_configs[CONFIG_CHATLOG_CHANNEL] = sConfigMgr->GetOption("ChatLogs.Channel", false); + m_bool_configs[CONFIG_CHATLOG_WHISPER] = sConfigMgr->GetOption("ChatLogs.Whisper", false); + m_bool_configs[CONFIG_CHATLOG_SYSCHAN] = sConfigMgr->GetOption("ChatLogs.SysChan", false); + m_bool_configs[CONFIG_CHATLOG_PARTY] = sConfigMgr->GetOption("ChatLogs.Party", false); + m_bool_configs[CONFIG_CHATLOG_RAID] = sConfigMgr->GetOption("ChatLogs.Raid", false); + m_bool_configs[CONFIG_CHATLOG_GUILD] = sConfigMgr->GetOption("ChatLogs.Guild", false); + m_bool_configs[CONFIG_CHATLOG_PUBLIC] = sConfigMgr->GetOption("ChatLogs.Public", false); + m_bool_configs[CONFIG_CHATLOG_ADDON] = sConfigMgr->GetOption("ChatLogs.Addon", false); + m_bool_configs[CONFIG_CHATLOG_BGROUND] = sConfigMgr->GetOption("ChatLogs.BattleGround", false); // Warden - m_bool_configs[CONFIG_WARDEN_ENABLED] = sConfigMgr->GetBoolDefault("Warden.Enabled", false); - m_int_configs[CONFIG_WARDEN_NUM_MEM_CHECKS] = sConfigMgr->GetIntDefault("Warden.NumMemChecks", 3); - m_int_configs[CONFIG_WARDEN_NUM_LUA_CHECKS] = sConfigMgr->GetIntDefault("Warden.NumLuaChecks", 1); - m_int_configs[CONFIG_WARDEN_NUM_OTHER_CHECKS] = sConfigMgr->GetIntDefault("Warden.NumOtherChecks", 7); - m_int_configs[CONFIG_WARDEN_CLIENT_BAN_DURATION] = sConfigMgr->GetIntDefault("Warden.BanDuration", 86400); - m_int_configs[CONFIG_WARDEN_CLIENT_CHECK_HOLDOFF] = sConfigMgr->GetIntDefault("Warden.ClientCheckHoldOff", 30); - m_int_configs[CONFIG_WARDEN_CLIENT_FAIL_ACTION] = sConfigMgr->GetIntDefault("Warden.ClientCheckFailAction", 0); - m_int_configs[CONFIG_WARDEN_CLIENT_RESPONSE_DELAY] = sConfigMgr->GetIntDefault("Warden.ClientResponseDelay", 600); + m_bool_configs[CONFIG_WARDEN_ENABLED] = sConfigMgr->GetOption("Warden.Enabled", false); + m_int_configs[CONFIG_WARDEN_NUM_MEM_CHECKS] = sConfigMgr->GetOption("Warden.NumMemChecks", 3); + m_int_configs[CONFIG_WARDEN_NUM_LUA_CHECKS] = sConfigMgr->GetOption("Warden.NumLuaChecks", 1); + m_int_configs[CONFIG_WARDEN_NUM_OTHER_CHECKS] = sConfigMgr->GetOption("Warden.NumOtherChecks", 7); + m_int_configs[CONFIG_WARDEN_CLIENT_BAN_DURATION] = sConfigMgr->GetOption("Warden.BanDuration", 86400); + m_int_configs[CONFIG_WARDEN_CLIENT_CHECK_HOLDOFF] = sConfigMgr->GetOption("Warden.ClientCheckHoldOff", 30); + m_int_configs[CONFIG_WARDEN_CLIENT_FAIL_ACTION] = sConfigMgr->GetOption("Warden.ClientCheckFailAction", 0); + m_int_configs[CONFIG_WARDEN_CLIENT_RESPONSE_DELAY] = sConfigMgr->GetOption("Warden.ClientResponseDelay", 600); // Dungeon finder - m_int_configs[CONFIG_LFG_OPTIONSMASK] = sConfigMgr->GetIntDefault("DungeonFinder.OptionsMask", 3); + m_int_configs[CONFIG_LFG_OPTIONSMASK] = sConfigMgr->GetOption("DungeonFinder.OptionsMask", 3); // Max instances per hour - m_int_configs[CONFIG_MAX_INSTANCES_PER_HOUR] = sConfigMgr->GetIntDefault("AccountInstancesPerHour", 5); + m_int_configs[CONFIG_MAX_INSTANCES_PER_HOUR] = sConfigMgr->GetOption("AccountInstancesPerHour", 5); // AutoBroadcast - m_bool_configs[CONFIG_AUTOBROADCAST] = sConfigMgr->GetBoolDefault("AutoBroadcast.On", false); - m_int_configs[CONFIG_AUTOBROADCAST_CENTER] = sConfigMgr->GetIntDefault("AutoBroadcast.Center", 0); - m_int_configs[CONFIG_AUTOBROADCAST_INTERVAL] = sConfigMgr->GetIntDefault("AutoBroadcast.Timer", 60000); + m_bool_configs[CONFIG_AUTOBROADCAST] = sConfigMgr->GetOption("AutoBroadcast.On", false); + m_int_configs[CONFIG_AUTOBROADCAST_CENTER] = sConfigMgr->GetOption("AutoBroadcast.Center", 0); + m_int_configs[CONFIG_AUTOBROADCAST_INTERVAL] = sConfigMgr->GetOption("AutoBroadcast.Timer", 60000); if (reload) { m_timers[WUPDATE_AUTOBROADCAST].SetInterval(m_int_configs[CONFIG_AUTOBROADCAST_INTERVAL]); @@ -1339,79 +1339,79 @@ void World::LoadConfigSettings(bool reload) } // MySQL ping time interval - m_int_configs[CONFIG_DB_PING_INTERVAL] = sConfigMgr->GetIntDefault("MaxPingTime", 30); + m_int_configs[CONFIG_DB_PING_INTERVAL] = sConfigMgr->GetOption("MaxPingTime", 30); // misc - m_bool_configs[CONFIG_PDUMP_NO_PATHS] = sConfigMgr->GetBoolDefault("PlayerDump.DisallowPaths", true); - m_bool_configs[CONFIG_PDUMP_NO_OVERWRITE] = sConfigMgr->GetBoolDefault("PlayerDump.DisallowOverwrite", true); - m_bool_configs[CONFIG_ENABLE_MMAPS] = sConfigMgr->GetBoolDefault("MoveMaps.Enable", true); + m_bool_configs[CONFIG_PDUMP_NO_PATHS] = sConfigMgr->GetOption("PlayerDump.DisallowPaths", true); + m_bool_configs[CONFIG_PDUMP_NO_OVERWRITE] = sConfigMgr->GetOption("PlayerDump.DisallowOverwrite", true); + m_bool_configs[CONFIG_ENABLE_MMAPS] = sConfigMgr->GetOption("MoveMaps.Enable", true); MMAP::MMapFactory::InitializeDisabledMaps(); // Wintergrasp - m_bool_configs[CONFIG_WINTERGRASP_ENABLE] = sConfigMgr->GetBoolDefault("Wintergrasp.Enable", false); - m_int_configs[CONFIG_WINTERGRASP_PLR_MAX] = sConfigMgr->GetIntDefault("Wintergrasp.PlayerMax", 100); - m_int_configs[CONFIG_WINTERGRASP_PLR_MIN] = sConfigMgr->GetIntDefault("Wintergrasp.PlayerMin", 0); - m_int_configs[CONFIG_WINTERGRASP_PLR_MIN_LVL] = sConfigMgr->GetIntDefault("Wintergrasp.PlayerMinLvl", 77); - m_int_configs[CONFIG_WINTERGRASP_BATTLETIME] = sConfigMgr->GetIntDefault("Wintergrasp.BattleTimer", 30); - m_int_configs[CONFIG_WINTERGRASP_NOBATTLETIME] = sConfigMgr->GetIntDefault("Wintergrasp.NoBattleTimer", 150); - m_int_configs[CONFIG_WINTERGRASP_RESTART_AFTER_CRASH] = sConfigMgr->GetIntDefault("Wintergrasp.CrashRestartTimer", 10); + m_bool_configs[CONFIG_WINTERGRASP_ENABLE] = sConfigMgr->GetOption("Wintergrasp.Enable", false); + m_int_configs[CONFIG_WINTERGRASP_PLR_MAX] = sConfigMgr->GetOption("Wintergrasp.PlayerMax", 100); + m_int_configs[CONFIG_WINTERGRASP_PLR_MIN] = sConfigMgr->GetOption("Wintergrasp.PlayerMin", 0); + m_int_configs[CONFIG_WINTERGRASP_PLR_MIN_LVL] = sConfigMgr->GetOption("Wintergrasp.PlayerMinLvl", 77); + m_int_configs[CONFIG_WINTERGRASP_BATTLETIME] = sConfigMgr->GetOption("Wintergrasp.BattleTimer", 30); + m_int_configs[CONFIG_WINTERGRASP_NOBATTLETIME] = sConfigMgr->GetOption("Wintergrasp.NoBattleTimer", 150); + m_int_configs[CONFIG_WINTERGRASP_RESTART_AFTER_CRASH] = sConfigMgr->GetOption("Wintergrasp.CrashRestartTimer", 10); - m_int_configs[CONFIG_BIRTHDAY_TIME] = sConfigMgr->GetIntDefault("BirthdayTime", 1222964635); - m_bool_configs[CONFIG_MINIGOB_MANABONK] = sConfigMgr->GetBoolDefault("Minigob.Manabonk.Enable", true); + m_int_configs[CONFIG_BIRTHDAY_TIME] = sConfigMgr->GetOption("BirthdayTime", 1222964635); + m_bool_configs[CONFIG_MINIGOB_MANABONK] = sConfigMgr->GetOption("Minigob.Manabonk.Enable", true); - m_bool_configs[CONFIG_ENABLE_CONTINENT_TRANSPORT] = sConfigMgr->GetBoolDefault("IsContinentTransport.Enabled", true); - m_bool_configs[CONFIG_ENABLE_CONTINENT_TRANSPORT_PRELOADING] = sConfigMgr->GetBoolDefault("IsPreloadedContinentTransport.Enabled", false); + m_bool_configs[CONFIG_ENABLE_CONTINENT_TRANSPORT] = sConfigMgr->GetOption("IsContinentTransport.Enabled", true); + m_bool_configs[CONFIG_ENABLE_CONTINENT_TRANSPORT_PRELOADING] = sConfigMgr->GetOption("IsPreloadedContinentTransport.Enabled", false); - m_bool_configs[CONFIG_IP_BASED_ACTION_LOGGING] = sConfigMgr->GetBoolDefault("Allow.IP.Based.Action.Logging", false); + m_bool_configs[CONFIG_IP_BASED_ACTION_LOGGING] = sConfigMgr->GetOption("Allow.IP.Based.Action.Logging", false); // Whether to use LoS from game objects - m_bool_configs[CONFIG_CHECK_GOBJECT_LOS] = sConfigMgr->GetBoolDefault("CheckGameObjectLoS", true); + m_bool_configs[CONFIG_CHECK_GOBJECT_LOS] = sConfigMgr->GetOption("CheckGameObjectLoS", true); - m_bool_configs[CONFIG_CALCULATE_CREATURE_ZONE_AREA_DATA] = sConfigMgr->GetBoolDefault("Calculate.Creature.Zone.Area.Data", false); - m_bool_configs[CONFIG_CALCULATE_GAMEOBJECT_ZONE_AREA_DATA] = sConfigMgr->GetBoolDefault("Calculate.Gameoject.Zone.Area.Data", false); + m_bool_configs[CONFIG_CALCULATE_CREATURE_ZONE_AREA_DATA] = sConfigMgr->GetOption("Calculate.Creature.Zone.Area.Data", false); + m_bool_configs[CONFIG_CALCULATE_GAMEOBJECT_ZONE_AREA_DATA] = sConfigMgr->GetOption("Calculate.Gameoject.Zone.Area.Data", false); // Player can join LFG anywhere - m_bool_configs[CONFIG_LFG_LOCATION_ALL] = sConfigMgr->GetBoolDefault("LFG.Location.All", false); + m_bool_configs[CONFIG_LFG_LOCATION_ALL] = sConfigMgr->GetOption("LFG.Location.All", false); // Prevent players AFK from being logged out - m_int_configs[CONFIG_AFK_PREVENT_LOGOUT] = sConfigMgr->GetIntDefault("PreventAFKLogout", 0); + m_int_configs[CONFIG_AFK_PREVENT_LOGOUT] = sConfigMgr->GetOption("PreventAFKLogout", 0); // Preload all grids of all non-instanced maps - m_bool_configs[CONFIG_PRELOAD_ALL_NON_INSTANCED_MAP_GRIDS] = sConfigMgr->GetBoolDefault("PreloadAllNonInstancedMapGrids", false); + m_bool_configs[CONFIG_PRELOAD_ALL_NON_INSTANCED_MAP_GRIDS] = sConfigMgr->GetOption("PreloadAllNonInstancedMapGrids", false); // ICC buff override - m_int_configs[CONFIG_ICC_BUFF_HORDE] = sConfigMgr->GetIntDefault("ICC.Buff.Horde", 73822); - m_int_configs[CONFIG_ICC_BUFF_ALLIANCE] = sConfigMgr->GetIntDefault("ICC.Buff.Alliance", 73828); + m_int_configs[CONFIG_ICC_BUFF_HORDE] = sConfigMgr->GetOption("ICC.Buff.Horde", 73822); + m_int_configs[CONFIG_ICC_BUFF_ALLIANCE] = sConfigMgr->GetOption("ICC.Buff.Alliance", 73828); - m_bool_configs[CONFIG_SET_ALL_CREATURES_WITH_WAYPOINT_MOVEMENT_ACTIVE] = sConfigMgr->GetBoolDefault("SetAllCreaturesWithWaypointMovementActive", false); + m_bool_configs[CONFIG_SET_ALL_CREATURES_WITH_WAYPOINT_MOVEMENT_ACTIVE] = sConfigMgr->GetOption("SetAllCreaturesWithWaypointMovementActive", false); // packet spoof punishment - m_int_configs[CONFIG_PACKET_SPOOF_POLICY] = sConfigMgr->GetIntDefault("PacketSpoof.Policy", (uint32)WorldSession::DosProtection::POLICY_KICK); - m_int_configs[CONFIG_PACKET_SPOOF_BANMODE] = sConfigMgr->GetIntDefault("PacketSpoof.BanMode", (uint32)0); + m_int_configs[CONFIG_PACKET_SPOOF_POLICY] = sConfigMgr->GetOption("PacketSpoof.Policy", (uint32)WorldSession::DosProtection::POLICY_KICK); + m_int_configs[CONFIG_PACKET_SPOOF_BANMODE] = sConfigMgr->GetOption("PacketSpoof.BanMode", (uint32)0); if (m_int_configs[CONFIG_PACKET_SPOOF_BANMODE] > 1) m_int_configs[CONFIG_PACKET_SPOOF_BANMODE] = (uint32)0; - m_int_configs[CONFIG_PACKET_SPOOF_BANDURATION] = sConfigMgr->GetIntDefault("PacketSpoof.BanDuration", 86400); + m_int_configs[CONFIG_PACKET_SPOOF_BANDURATION] = sConfigMgr->GetOption("PacketSpoof.BanDuration", 86400); // Random Battleground Rewards - m_int_configs[CONFIG_BG_REWARD_WINNER_HONOR_FIRST] = sConfigMgr->GetIntDefault("Battleground.RewardWinnerHonorFirst", 30); - m_int_configs[CONFIG_BG_REWARD_WINNER_ARENA_FIRST] = sConfigMgr->GetIntDefault("Battleground.RewardWinnerArenaFirst", 25); - m_int_configs[CONFIG_BG_REWARD_WINNER_HONOR_LAST] = sConfigMgr->GetIntDefault("Battleground.RewardWinnerHonorLast", 15); - m_int_configs[CONFIG_BG_REWARD_WINNER_ARENA_LAST] = sConfigMgr->GetIntDefault("Battleground.RewardWinnerArenaLast", 0); - m_int_configs[CONFIG_BG_REWARD_LOSER_HONOR_FIRST] = sConfigMgr->GetIntDefault("Battleground.RewardLoserHonorFirst", 5); - m_int_configs[CONFIG_BG_REWARD_LOSER_HONOR_LAST] = sConfigMgr->GetIntDefault("Battleground.RewardLoserHonorLast", 5); + m_int_configs[CONFIG_BG_REWARD_WINNER_HONOR_FIRST] = sConfigMgr->GetOption("Battleground.RewardWinnerHonorFirst", 30); + m_int_configs[CONFIG_BG_REWARD_WINNER_ARENA_FIRST] = sConfigMgr->GetOption("Battleground.RewardWinnerArenaFirst", 25); + m_int_configs[CONFIG_BG_REWARD_WINNER_HONOR_LAST] = sConfigMgr->GetOption("Battleground.RewardWinnerHonorLast", 15); + m_int_configs[CONFIG_BG_REWARD_WINNER_ARENA_LAST] = sConfigMgr->GetOption("Battleground.RewardWinnerArenaLast", 0); + m_int_configs[CONFIG_BG_REWARD_LOSER_HONOR_FIRST] = sConfigMgr->GetOption("Battleground.RewardLoserHonorFirst", 5); + m_int_configs[CONFIG_BG_REWARD_LOSER_HONOR_LAST] = sConfigMgr->GetOption("Battleground.RewardLoserHonorLast", 5); - m_int_configs[CONFIG_WAYPOINT_MOVEMENT_STOP_TIME_FOR_PLAYER] = sConfigMgr->GetIntDefault("WaypointMovementStopTimeForPlayer", 120); + m_int_configs[CONFIG_WAYPOINT_MOVEMENT_STOP_TIME_FOR_PLAYER] = sConfigMgr->GetOption("WaypointMovementStopTimeForPlayer", 120); - m_int_configs[CONFIG_NPC_EVADE_IF_NOT_REACHABLE] = sConfigMgr->GetIntDefault("NpcEvadeIfTargetIsUnreachable", 5); - m_int_configs[CONFIG_NPC_REGEN_TIME_IF_NOT_REACHABLE_IN_RAID] = sConfigMgr->GetIntDefault("NpcRegenHPTimeIfTargetIsUnreachable", 10); - m_bool_configs[CONFIG_REGEN_HP_CANNOT_REACH_TARGET_IN_RAID] = sConfigMgr->GetBoolDefault("NpcRegenHPIfTargetIsUnreachable", true); + m_int_configs[CONFIG_NPC_EVADE_IF_NOT_REACHABLE] = sConfigMgr->GetOption("NpcEvadeIfTargetIsUnreachable", 5); + m_int_configs[CONFIG_NPC_REGEN_TIME_IF_NOT_REACHABLE_IN_RAID] = sConfigMgr->GetOption("NpcRegenHPTimeIfTargetIsUnreachable", 10); + m_bool_configs[CONFIG_REGEN_HP_CANNOT_REACH_TARGET_IN_RAID] = sConfigMgr->GetOption("NpcRegenHPIfTargetIsUnreachable", true); //Debug - m_bool_configs[CONFIG_DEBUG_BATTLEGROUND] = sConfigMgr->GetBoolDefault("Debug.Battleground", false); - m_bool_configs[CONFIG_DEBUG_ARENA] = sConfigMgr->GetBoolDefault("Debug.Arena", false); + m_bool_configs[CONFIG_DEBUG_BATTLEGROUND] = sConfigMgr->GetOption("Debug.Battleground", false); + m_bool_configs[CONFIG_DEBUG_ARENA] = sConfigMgr->GetOption("Debug.Arena", false); - m_int_configs[CONFIG_GM_LEVEL_CHANNEL_MODERATION] = sConfigMgr->GetIntDefault("Channel.ModerationGMLevel", 1); + m_int_configs[CONFIG_GM_LEVEL_CHANNEL_MODERATION] = sConfigMgr->GetOption("Channel.ModerationGMLevel", 1); // call ScriptMgr if we're reloading the configuration sScriptMgr->OnAfterConfigLoad(reload); @@ -2082,7 +2082,7 @@ void World::SetInitialWorldSettings() sLog->outString(); // possibly enable db logging; avoid massive startup spam by doing it here. - if (sConfigMgr->GetBoolDefault("EnableLogDB", false)) + if (sConfigMgr->GetOption("EnableLogDB", false)) { sLog->outString("Enabling database logging..."); sLog->SetLogDB(true); @@ -2097,7 +2097,7 @@ void World::SetInitialWorldSettings() void World::DetectDBCLang() { - uint8 m_lang_confid = sConfigMgr->GetIntDefault("DBC.Locale", 255); + uint8 m_lang_confid = sConfigMgr->GetOption("DBC.Locale", 255); if (m_lang_confid != 255 && m_lang_confid >= TOTAL_LOCALES) { @@ -2145,7 +2145,7 @@ void World::LoadAutobroadcasts() m_Autobroadcasts.clear(); m_AutobroadcastsWeights.clear(); - uint32 realmId = sConfigMgr->GetIntDefault("RealmID", 0); + uint32 realmId = sConfigMgr->GetOption("RealmID", 0); PreparedStatement* stmt = LoginDatabase.GetPreparedStatement(LOGIN_SEL_AUTOBROADCAST); stmt->setInt32(0, realmId); PreparedQueryResult result = LoginDatabase.Query(stmt); diff --git a/src/server/worldserver/CMakeLists.txt b/src/server/worldserver/CMakeLists.txt index d4e20b90c..a249c8501 100644 --- a/src/server/worldserver/CMakeLists.txt +++ b/src/server/worldserver/CMakeLists.txt @@ -32,11 +32,6 @@ GroupSources(${CMAKE_CURRENT_SOURCE_DIR}) add_executable(worldserver ${PRIVATE_SOURCES}) -if(NOT WIN32) - set_target_properties(worldserver PROPERTIES - COMPILE_DEFINITIONS _ACORE_CORE_CONFIG="${CONF_DIR}/worldserver.conf") -endif() - add_dependencies(worldserver revision.h) if(UNIX AND NOT NOJEM) @@ -73,19 +68,9 @@ set_target_properties(worldserver FOLDER "server") -if( WIN32 ) - if ( MSVC ) - add_custom_command(TARGET worldserver - POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/worldserver.conf.dist ${CMAKE_BINARY_DIR}/bin/$(ConfigurationName)/ - ) - elseif ( MINGW ) - add_custom_command(TARGET worldserver - POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/worldserver.conf.dist ${CMAKE_BINARY_DIR}/bin/ - ) - endif() -endif() +# Install config +CopyDefaultConfig(worldserver) +CollectModulesConfig() if( UNIX ) install(TARGETS worldserver DESTINATION bin) @@ -93,38 +78,9 @@ elseif( WIN32 ) install(TARGETS worldserver DESTINATION "${CMAKE_INSTALL_PREFIX}") endif() -install(FILES worldserver.conf.dist DESTINATION ${CONF_DIR}) - # Generate precompiled header if( USE_COREPCH ) add_cxx_pch(worldserver ${PRIVATE_PCH_HEADER}) endif() -# handle config file -CU_GET_GLOBAL("MODULE_CONFIG_FILE_LIST") -FOREACH(configFile ${MODULE_CONFIG_FILE_LIST}) -if( WIN32 ) - if ( MSVC ) - add_custom_command(TARGET worldserver - POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy "${configFile}" ${CMAKE_BINARY_DIR}/bin/$(ConfigurationName)/ - ) - elseif ( MINGW ) - add_custom_command(TARGET worldserver - POST_BUILD - COMMAND ${CMAKE_COMMAND} -E copy "${configFile}" ${CMAKE_BINARY_DIR}/bin/ - ) - endif() -endif() -install(FILES "${configFile}" DESTINATION ${CONF_DIR}) -ENDFOREACH() - -CU_GET_GLOBAL("MODULE_CONFIG_FILE_LIST") -FOREACH(configFile ${MODULE_CONFIG_FILE_LIST}) - get_filename_component(file_name ${configFile} NAME_WE) - set(CONFIG_LIST ${CONFIG_LIST}${file_name},) -ENDFOREACH() -add_definitions(-DCONFIG_FILE_LIST=$<1:"${CONFIG_LIST}">) -# end handle config file - CU_RUN_HOOK("AFTER_WORLDSERVER_CMAKE") diff --git a/src/server/worldserver/CommandLine/CliRunnable.cpp b/src/server/worldserver/CommandLine/CliRunnable.cpp index b84b7352e..611fe5e2f 100644 --- a/src/server/worldserver/CommandLine/CliRunnable.cpp +++ b/src/server/worldserver/CommandLine/CliRunnable.cpp @@ -126,7 +126,7 @@ void CliRunnable::run() rl_event_hook = cli_hook_func; #endif - if (sConfigMgr->GetBoolDefault("BeepAtStart", true)) + if (sConfigMgr->GetOption("BeepAtStart", true)) printf("\a"); // \a = Alert // print this here the first time diff --git a/src/server/worldserver/Main.cpp b/src/server/worldserver/Main.cpp index 9629ac98d..26090e3e4 100644 --- a/src/server/worldserver/Main.cpp +++ b/src/server/worldserver/Main.cpp @@ -59,7 +59,7 @@ void usage(const char* prog) extern int main(int argc, char** argv) { ///- Command line parsing to get the configuration file name - char const* configFile = _ACORE_CORE_CONFIG; + std::string configFile = sConfigMgr->GetConfigPath() + std::string(_ACORE_CORE_CONFIG); int c = 1; while (c < argc) { @@ -116,12 +116,13 @@ extern int main(int argc, char** argv) ++c; } - sConfigMgr->SetConfigList(std::string(configFile), std::string(CONFIG_FILE_LIST)); + // Add file and args in config + sConfigMgr->Configure(configFile, std::vector(argv, argv + argc), CONFIG_FILE_LIST); if (!sConfigMgr->LoadAppConfigs()) return 1; - sLog->outString("Using configuration file %s.", configFile); + sLog->outString("Using configuration file %s.", configFile.c_str()); sLog->outString("Using SSL version: %s (library: %s)", OPENSSL_VERSION_TEXT, SSLeay_version(SSLEAY_VERSION)); sLog->outString("Using ACE version: %s", ACE_VERSION); diff --git a/src/server/worldserver/Master.cpp b/src/server/worldserver/Master.cpp index cda2cf098..7f7caff49 100644 --- a/src/server/worldserver/Master.cpp +++ b/src/server/worldserver/Master.cpp @@ -136,7 +136,7 @@ int Master::Run() sLog->outString(" AzerothCore 3.3.5a - www.azerothcore.org\n"); /// worldserver PID file creation - std::string pidFile = sConfigMgr->GetStringDefault("PidFile", ""); + std::string pidFile = sConfigMgr->GetOption("PidFile", ""); if (!pidFile.empty()) { if (uint32 pid = CreatePIDFile(pidFile)) @@ -185,9 +185,9 @@ int Master::Run() acore::Thread* cliThread = nullptr; #ifdef _WIN32 - if (sConfigMgr->GetBoolDefault("Console.Enable", true) && (m_ServiceStatus == -1)/* need disable console in service mode*/) + if (sConfigMgr->GetOption("Console.Enable", true) && (m_ServiceStatus == -1)/* need disable console in service mode*/) #else - if (sConfigMgr->GetBoolDefault("Console.Enable", true)) + if (sConfigMgr->GetOption("Console.Enable", true)) #endif { ///- Launch CliRunnable thread @@ -203,8 +203,8 @@ int Master::Run() #if defined(_WIN32) || defined(__linux__) ///- Handle affinity for multiple processors and process priority - uint32 affinity = sConfigMgr->GetIntDefault("UseProcessors", 0); - bool highPriority = sConfigMgr->GetBoolDefault("ProcessPriority", false); + uint32 affinity = sConfigMgr->GetOption("UseProcessors", 0); + bool highPriority = sConfigMgr->GetOption("ProcessPriority", false); #ifdef _WIN32 // Windows @@ -270,16 +270,16 @@ int Master::Run() // Start soap serving thread acore::Thread* soapThread = nullptr; - if (sConfigMgr->GetBoolDefault("SOAP.Enabled", false)) + if (sConfigMgr->GetOption("SOAP.Enabled", false)) { ACSoapRunnable* runnable = new ACSoapRunnable(); - runnable->SetListenArguments(sConfigMgr->GetStringDefault("SOAP.IP", "127.0.0.1"), uint16(sConfigMgr->GetIntDefault("SOAP.Port", 7878))); + runnable->SetListenArguments(sConfigMgr->GetOption("SOAP.IP", "127.0.0.1"), uint16(sConfigMgr->GetOption("SOAP.Port", 7878))); soapThread = new acore::Thread(runnable); } // Start up freeze catcher thread acore::Thread* freezeThread = nullptr; - if (uint32 freezeDelay = sConfigMgr->GetIntDefault("MaxCoreStuckTime", 0)) + if (uint32 freezeDelay = sConfigMgr->GetOption("MaxCoreStuckTime", 0)) { FreezeDetectorRunnable* runnable = new FreezeDetectorRunnable(freezeDelay * 1000); freezeThread = new acore::Thread(runnable); @@ -288,7 +288,7 @@ int Master::Run() ///- Launch the world listener socket uint16 worldPort = uint16(sWorld->getIntConfig(CONFIG_PORT_WORLD)); - std::string bindIp = sConfigMgr->GetStringDefault("BindIP", "0.0.0.0"); + std::string bindIp = sConfigMgr->GetOption("BindIP", "0.0.0.0"); if (sWorldSocketMgr->StartNetwork(worldPort, bindIp.c_str()) == -1) { sLog->outError("Failed to start network"); @@ -398,14 +398,14 @@ bool Master::_StartDB() std::string dbstring; uint8 async_threads, synch_threads; - dbstring = sConfigMgr->GetStringDefault("WorldDatabaseInfo", ""); + dbstring = sConfigMgr->GetOption("WorldDatabaseInfo", ""); if (dbstring.empty()) { sLog->outError("World database not specified in configuration file"); return false; } - async_threads = uint8(sConfigMgr->GetIntDefault("WorldDatabase.WorkerThreads", 1)); + async_threads = uint8(sConfigMgr->GetOption("WorldDatabase.WorkerThreads", 1)); if (async_threads < 1 || async_threads > 32) { sLog->outError("World database: invalid number of worker threads specified. " @@ -413,7 +413,7 @@ bool Master::_StartDB() return false; } - synch_threads = uint8(sConfigMgr->GetIntDefault("WorldDatabase.SynchThreads", 1)); + synch_threads = uint8(sConfigMgr->GetOption("WorldDatabase.SynchThreads", 1)); ///- Initialise the world database if (!WorldDatabase.Open(dbstring, async_threads, synch_threads)) { @@ -422,14 +422,14 @@ bool Master::_StartDB() } ///- Get character database info from configuration file - dbstring = sConfigMgr->GetStringDefault("CharacterDatabaseInfo", ""); + dbstring = sConfigMgr->GetOption("CharacterDatabaseInfo", ""); if (dbstring.empty()) { sLog->outError("Character database not specified in configuration file"); return false; } - async_threads = uint8(sConfigMgr->GetIntDefault("CharacterDatabase.WorkerThreads", 1)); + async_threads = uint8(sConfigMgr->GetOption("CharacterDatabase.WorkerThreads", 1)); if (async_threads < 1 || async_threads > 32) { sLog->outError("Character database: invalid number of worker threads specified. " @@ -437,7 +437,7 @@ bool Master::_StartDB() return false; } - synch_threads = uint8(sConfigMgr->GetIntDefault("CharacterDatabase.SynchThreads", 2)); + synch_threads = uint8(sConfigMgr->GetOption("CharacterDatabase.SynchThreads", 2)); ///- Initialise the Character database if (!CharacterDatabase.Open(dbstring, async_threads, synch_threads)) @@ -447,14 +447,14 @@ bool Master::_StartDB() } ///- Get login database info from configuration file - dbstring = sConfigMgr->GetStringDefault("LoginDatabaseInfo", ""); + dbstring = sConfigMgr->GetOption("LoginDatabaseInfo", ""); if (dbstring.empty()) { sLog->outError("Login database not specified in configuration file"); return false; } - async_threads = uint8(sConfigMgr->GetIntDefault("LoginDatabase.WorkerThreads", 1)); + async_threads = uint8(sConfigMgr->GetOption("LoginDatabase.WorkerThreads", 1)); if (async_threads < 1 || async_threads > 32) { sLog->outError("Login database: invalid number of worker threads specified. " @@ -462,7 +462,7 @@ bool Master::_StartDB() return false; } - synch_threads = uint8(sConfigMgr->GetIntDefault("LoginDatabase.SynchThreads", 1)); + synch_threads = uint8(sConfigMgr->GetOption("LoginDatabase.SynchThreads", 1)); ///- Initialise the login database if (!LoginDatabase.Open(dbstring, async_threads, synch_threads)) { @@ -471,7 +471,7 @@ bool Master::_StartDB() } ///- Get the realm Id from the configuration file - realmID = sConfigMgr->GetIntDefault("RealmID", 0); + realmID = sConfigMgr->GetOption("RealmID", 0); if (!realmID) { sLog->outError("Realm ID not defined in configuration file"); diff --git a/src/server/worldserver/RemoteAccess/RARunnable.cpp b/src/server/worldserver/RemoteAccess/RARunnable.cpp index 8e02fe628..b7cb7accf 100644 --- a/src/server/worldserver/RemoteAccess/RARunnable.cpp +++ b/src/server/worldserver/RemoteAccess/RARunnable.cpp @@ -43,13 +43,13 @@ RARunnable::~RARunnable() void RARunnable::run() { - if (!sConfigMgr->GetBoolDefault("Ra.Enable", false)) + if (!sConfigMgr->GetOption("Ra.Enable", false)) return; ACE_Acceptor acceptor; - uint16 raPort = uint16(sConfigMgr->GetIntDefault("Ra.Port", 3443)); - std::string stringIp = sConfigMgr->GetStringDefault("Ra.IP", "0.0.0.0"); + uint16 raPort = uint16(sConfigMgr->GetOption("Ra.Port", 3443)); + std::string stringIp = sConfigMgr->GetOption("Ra.IP", "0.0.0.0"); ACE_INET_Addr listenAddress(raPort, stringIp.c_str()); if (acceptor.open(listenAddress, m_Reactor) == -1) diff --git a/src/server/worldserver/RemoteAccess/RASocket.cpp b/src/server/worldserver/RemoteAccess/RASocket.cpp index 8891e3cb5..cbc993dcf 100644 --- a/src/server/worldserver/RemoteAccess/RASocket.cpp +++ b/src/server/worldserver/RemoteAccess/RASocket.cpp @@ -23,7 +23,7 @@ RASocket::RASocket() { - _minLevel = uint8(sConfigMgr->GetIntDefault("RA.MinLevel", 3)); + _minLevel = uint8(sConfigMgr->GetOption("RA.MinLevel", 3)); _commandExecuting = false; } diff --git a/src/server/worldserver/worldserver.conf.dist b/src/server/worldserver/worldserver.conf.dist index 6a736e937..8e9a5beba 100644 --- a/src/server/worldserver/worldserver.conf.dist +++ b/src/server/worldserver/worldserver.conf.dist @@ -1967,7 +1967,6 @@ NpcEvadeIfTargetIsUnreachable = 5 NpcRegenHPIfTargetIsUnreachable = 1 - # NpcRegenHPTimeIfTargetIsUnreachable # Description: Specifies the time (in seconds) that a creature whom target # is unreachable in raid to end up regenerate health. @@ -2768,16 +2767,16 @@ Battleground.QueueAnnouncer.PlayerOnly = 0 # Default: 300000 - (Enabled, 5 minutes) # 0 - (Disabled, Not recommended) -BattleGround.PrematureFinishTimer = 300000 +Battleground.PrematureFinishTimer = 300000 # -# BattleGround.PremadeGroupWaitForMatch +# Battleground.PremadeGroupWaitForMatch # Description: Time (in milliseconds) a pre-made group has to wait for matching group of the # other faction. # Default: 1800000 - (Enabled, 30 minutes) # 0 - (Disabled, Not recommended) -BattleGround.PremadeGroupWaitForMatch = 1800000 +Battleground.PremadeGroupWaitForMatch = 1800000 # # Battleground.GiveXPForKills