WorldStateMgr.cpp

Go to the documentation of this file.

/*
 * This file is part of the TrinityCore Project. See AUTHORS file for Copyright information
 *
 * This program is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Public License as published by the
 * Free Software Foundation; either version 2 of the License, or (at your
 * option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but WITHOUT
 * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
 * FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
 * more details.
 *
 * You should have received a copy of the GNU General Public License along
 * with this program. If not, see <http://www.gnu.org/licenses/>.
 */
 
#include "WorldStateMgr.h"
#include "DB2Stores.h"
#include "DatabaseEnv.h"
#include "Log.h"
#include "Map.h"
#include "MapUtils.h"
#include "ObjectMgr.h"
#include "ScriptMgr.h"
#include "StringConvert.h"
#include "Util.h"
#include "World.h"
#include "WorldStatePackets.h"
 
namespace
{
constexpr int32 WORLDSTATE_ANY_MAP = -1;
struct Data
{
    std::unordered_map<int32, WorldStateTemplate> WorldStateTemplates;
    std::mutex RealmWorldStateValuesMutex;
    WorldStateValueContainer RealmWorldStateValues;
    std::unordered_set<WorldStateValueContainer::value_type const*> ChangedRealmWorldStates;
    std::vector<WorldPackets::WorldState::InitWorldStates::WorldStateInfo> RealmWorldStatePacketCache;
    std::unordered_map<int32, WorldStateValueContainer> WorldStatesByMap;
};
 
Data& GetData()
{
    static Data data;
    return data;
}
}
 
void WorldStateMgr::LoadFromDB()
{
    uint32 oldMSTime = getMSTime();
 
    //                                               0   1             2       3        4
    QueryResult result = WorldDatabase.Query("SELECT ID, DefaultValue, MapIDs, AreaIDs, ScriptName FROM world_state");
    if (!result)
        return;
 
    Data& data = GetData();
 
    do
    {
        Field* fields = result->Fetch();
 
        int32 id = fields[0].GetInt32();
        WorldStateTemplate& worldState = data.WorldStateTemplates[id];
        worldState.Id = id;
        worldState.DefaultValue = fields[1].GetInt32();
 
        std::string_view mapIds = fields[2].GetStringView();
        for (std::string_view mapIdToken : Trinity::Tokenize(mapIds, ',', false))
        {
            Optional<int32> mapId = Trinity::StringTo<int32>(mapIdToken);
            if (!mapId)
            {
                TC_LOG_ERROR("sql.sql", "Table `world_state` contains a world state {} with non-integer MapID ({}), map ignored",
                    id, mapIdToken);
                continue;
            }
 
            if (!sMapStore.LookupEntry(*mapId) && mapId != WORLDSTATE_ANY_MAP)
            {
                TC_LOG_ERROR("sql.sql", "Table `world_state` contains a world state {} with invalid MapID ({}), map ignored",
                    id, *mapId);
                continue;
            }
 
            worldState.MapIds.insert(*mapId);
        }
 
        if (!mapIds.empty() && worldState.MapIds.empty())
        {
            TC_LOG_ERROR("sql.sql", "Table `world_state` contains a world state {} with nonempty MapIDs ({}) but no valid map id was found, ignored",
                id, mapIds);
            continue;
        }
 
        std::string_view areaIds = fields[3].GetStringView();
        if (!worldState.MapIds.empty())
        {
            for (std::string_view areaIdToken : Trinity::Tokenize(areaIds, ',', false))
            {
                Optional<uint32> areaId = Trinity::StringTo<uint32>(areaIdToken);
                if (!areaId)
                {
                    TC_LOG_ERROR("sql.sql", "Table `world_state` contains a world state {} with non-integer AreaID ({}), area ignored",
                        id, areaIdToken);
                    continue;
                }
 
                AreaTableEntry const* areaTableEntry = sAreaTableStore.LookupEntry(*areaId);
                if (!areaTableEntry)
                {
                    TC_LOG_ERROR("sql.sql", "Table `world_state` contains a world state {} with invalid AreaID ({}), area ignored",
                        id, *areaId);
                    continue;
                }
 
                if (!worldState.MapIds.contains(areaTableEntry->ContinentID))
                {
                    TC_LOG_ERROR("sql.sql", "Table `world_state` contains a world state {} with AreaID ({}) not on any of required maps, area ignored",
                        id, *areaId);
                    continue;
                }
 
                worldState.AreaIds.insert(*areaId);
            }
 
            if (!areaIds.empty() && worldState.AreaIds.empty())
            {
                TC_LOG_ERROR("sql.sql", "Table `world_state` contains a world state {} with nonempty AreaIDs ({}) but no valid area id was found, ignored",
                    id, areaIds);
                continue;
            }
        }
        else if (!areaIds.empty())
        {
            TC_LOG_ERROR("sql.sql", "Table `world_state` contains a world state {} with nonempty AreaIDs ({}) but is a realm wide world state, area requirement ignored",
                id, areaIds);
        }
 
        worldState.ScriptId = sObjectMgr->GetScriptId(fields[4].GetStringView());
 
        if (!worldState.MapIds.empty())
        {
            for (int32 mapId : worldState.MapIds)
                data.WorldStatesByMap[mapId][id] = worldState.DefaultValue;
        }
        else
            data.RealmWorldStateValues[id] = worldState.DefaultValue;
 
    } while (result->NextRow());
 
    TC_LOG_INFO("server.loading", ">> Loaded {} world state templates {} ms", data.WorldStateTemplates.size(), GetMSTimeDiffToNow(oldMSTime));
 
    oldMSTime = getMSTime();
 
    result = CharacterDatabase.Query("SELECT Id, Value FROM world_state_value");
    uint32 savedValueCount = 0;
    if (result)
    {
        do
        {
            Field* fields = result->Fetch();
            int32 worldStateId = fields[0].GetInt32();
            WorldStateTemplate* worldState = Trinity::Containers::MapGetValuePtr(data.WorldStateTemplates, worldStateId);
            if (!worldState)
            {
                TC_LOG_ERROR("sql.sql", "Table `world_state_value` contains a value for unknown world state {}, ignored", worldStateId);
                continue;
            }
 
            int32 value = fields[1].GetInt32();
 
            if (!worldState->MapIds.empty())
            {
                for (int32 mapId : worldState->MapIds)
                    data.WorldStatesByMap[mapId][worldStateId] = value;
            }
            else
                data.RealmWorldStateValues[worldStateId] = value;
 
            ++savedValueCount;
        }
        while (result->NextRow());
    }
 
    TC_LOG_INFO("server.loading", ">> Loaded {} saved world state values {} ms", savedValueCount, GetMSTimeDiffToNow(oldMSTime));
}
 
void WorldStateMgr::Update()
{
    Data& data = GetData();
    if (!data.ChangedRealmWorldStates.empty())
    {
        data.RealmWorldStatePacketCache.clear();
        for (auto const& [worldStateId, value] : data.RealmWorldStateValues)
            data.RealmWorldStatePacketCache.emplace_back(worldStateId, value);
 
        // Broadcast update to all players on the server
        for (WorldStateValueContainer::value_type const* changedRealmWorldState : data.ChangedRealmWorldStates)
        {
            WorldPackets::WorldState::UpdateWorldState updateWorldState;
            updateWorldState.VariableID = changedRealmWorldState->first;
            updateWorldState.Value = changedRealmWorldState->second;
            updateWorldState.Hidden = false;
            sWorld->SendGlobalMessage(updateWorldState.Write());
        }
 
        data.ChangedRealmWorldStates.clear();
    }
}
 
WorldStateTemplate const* WorldStateMgr::GetWorldStateTemplate(int32 worldStateId)
{
    return Trinity::Containers::MapGetValuePtr(GetData().WorldStateTemplates, worldStateId);
}
 
int32 WorldStateMgr::GetValue(int32 worldStateId, Map const* map)
{
    WorldStateTemplate const* worldStateTemplate = GetWorldStateTemplate(worldStateId);
    if (!worldStateTemplate || worldStateTemplate->MapIds.empty())
    {
        Data& data = GetData();
        std::scoped_lock lock(data.RealmWorldStateValuesMutex);
        if (int32 const* value = Trinity::Containers::MapGetValuePtr(data.RealmWorldStateValues, worldStateId))
            return *value;
 
        return 0;
    }
 
    if (!map || (!worldStateTemplate->MapIds.contains(map->GetId()) && !worldStateTemplate->MapIds.contains(WORLDSTATE_ANY_MAP)))
        return 0;
 
    return map->GetWorldStateValue(worldStateId);
}
 
void WorldStateMgr::SetValue(int32 worldStateId, int32 value, bool hidden, Map* map)
{
    WorldStateTemplate const* worldStateTemplate = GetWorldStateTemplate(worldStateId);
    if (!worldStateTemplate || worldStateTemplate->MapIds.empty())
    {
        int32 oldValue;
        {
            Data& data = GetData();
            std::scoped_lock lock(data.RealmWorldStateValuesMutex);
            auto [itr, inserted] = data.RealmWorldStateValues.try_emplace(worldStateId, 0);
            oldValue = itr->second;
            if (oldValue == value && !inserted)
                return;
 
            itr->second = value;
            data.ChangedRealmWorldStates.insert(&*itr);
        }
 
        if (worldStateTemplate)
            sScriptMgr->OnWorldStateValueChange(worldStateTemplate, oldValue, value, nullptr);
 
        return;
    }
 
    if (!map || (!worldStateTemplate->MapIds.contains(map->GetId()) && !worldStateTemplate->MapIds.contains(WORLDSTATE_ANY_MAP)))
        return;
 
    map->SetWorldStateValue(worldStateId, value, hidden);
}
 
void WorldStateMgr::SaveValueInDb(int32 worldStateId, int32 value)
{
    if (!GetWorldStateTemplate(worldStateId))
        return;
 
    CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_REP_WORLD_STATE);
    stmt->setInt32(0, worldStateId);
    stmt->setInt32(1, value);
    CharacterDatabase.Execute(stmt);
}
 
void WorldStateMgr::SetValueAndSaveInDb(int32 worldStateId, int32 value, bool hidden, Map* map)
{
    SetValue(worldStateId, value, hidden, map);
    SaveValueInDb(worldStateId, value);
}
 
WorldStateValueContainer WorldStateMgr::GetInitialWorldStatesForMap(Map const* map)
{
    WorldStateValueContainer initialValues;
    Data& data = GetData();
    if (WorldStateValueContainer const* valuesTemplate = Trinity::Containers::MapGetValuePtr(data.WorldStatesByMap, map->GetId()))
        initialValues.insert(valuesTemplate->begin(), valuesTemplate->end());
 
    if (WorldStateValueContainer const* valuesTemplate = Trinity::Containers::MapGetValuePtr(data.WorldStatesByMap, WORLDSTATE_ANY_MAP))
        initialValues.insert(valuesTemplate->begin(), valuesTemplate->end());
 
    return initialValues;
}
 
void WorldStateMgr::FillInitialWorldStates(WorldPackets::WorldState::InitWorldStates& initWorldStates, Map const* map, uint32 playerAreaId)
{
    Data& data = GetData();
    initWorldStates.Worldstates.insert(initWorldStates.Worldstates.end(), data.RealmWorldStatePacketCache.begin(), data.RealmWorldStatePacketCache.end());
 
    for (auto const& [worldStateId, value] : map->GetWorldStateValues())
    {
        WorldStateTemplate const* worldStateTemplate = GetWorldStateTemplate(worldStateId);
        if (worldStateTemplate && !worldStateTemplate->AreaIds.empty())
        {
            bool isInAllowedArea = std::ranges::any_of(worldStateTemplate->AreaIds,
                [=](uint32 requiredAreaId) { return DB2Manager::IsInArea(playerAreaId, requiredAreaId); });
            if (!isInAllowedArea)
                continue;
        }
 
        initWorldStates.Worldstates.emplace_back(worldStateId, value);
    }
}