nchebrov/azerothcore-wotlk
1
0
Fork 0
mirror of https://github.com/mod-playerbots/azerothcore-wotlk.git synced 2026-01-21 20:56:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

refactor(Core/World): Move various worldstate related functions to worldstate class. (#22086)

Browse Source
This commit is contained in:
Benjamin Jackson
2025-05-09 06:29:09 -04:00
committed by GitHub
parent 19d1595fc1
commit e6b203f184
12 changed files with 132 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

36
src/server/game/Battlefield/Zones/BattlefieldWG.cpp
View File

@@ -81,19 +81,19 @@ bool BattlefieldWG::SetupBattlefield()
SetGraveyardNumber(BATTLEFIELD_WG_GRAVEYARD_MAX);
// Load from db
if (!sWorld->getWorldState(WORLD_STATE_BATTLEFIELD_WG_ACTIVE) &&
!sWorld->getWorldState(WORLD_STATE_BATTLEFIELD_WG_DEFENDER) &&
!sWorld->getWorldState(ClockWorldState[0]))
if (!sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_ACTIVE) &&
!sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_DEFENDER) &&
!sWorldState->getWorldState(ClockWorldState[0]))
{
sWorld->setWorldState(WORLD_STATE_BATTLEFIELD_WG_ACTIVE, uint64(false));
sWorld->setWorldState(WORLD_STATE_BATTLEFIELD_WG_DEFENDER, uint64(urand(0, 1)));
sWorld->setWorldState(ClockWorldState[0], uint64(m_NoWarBattleTime));
sWorldState->setWorldState(WORLD_STATE_BATTLEFIELD_WG_ACTIVE, uint64(false));
sWorldState->setWorldState(WORLD_STATE_BATTLEFIELD_WG_DEFENDER, uint64(urand(0, 1)));
sWorldState->setWorldState(ClockWorldState[0], uint64(m_NoWarBattleTime));
}
m_isActive = bool(sWorld->getWorldState(WORLD_STATE_BATTLEFIELD_WG_ACTIVE));
m_DefenderTeam = TeamId(sWorld->getWorldState(WORLD_STATE_BATTLEFIELD_WG_DEFENDER));
m_isActive = bool(sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_ACTIVE));
m_DefenderTeam = TeamId(sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_DEFENDER));
m_Timer = sWorld->getWorldState(ClockWorldState[0]);
m_Timer = sWorldState->getWorldState(ClockWorldState[0]);
if (m_isActive)
{
m_isActive = false;
@@ -195,9 +195,9 @@ bool BattlefieldWG::Update(uint32 diff)
bool m_return = Battlefield::Update(diff);
if (m_saveTimer <= diff)
{
sWorld->setWorldState(WORLD_STATE_BATTLEFIELD_WG_ACTIVE, m_isActive);
sWorld->setWorldState(WORLD_STATE_BATTLEFIELD_WG_DEFENDER, m_DefenderTeam);
sWorld->setWorldState(ClockWorldState[0], m_Timer);
sWorldState->setWorldState(WORLD_STATE_BATTLEFIELD_WG_ACTIVE, m_isActive);
sWorldState->setWorldState(WORLD_STATE_BATTLEFIELD_WG_DEFENDER, m_DefenderTeam);
sWorldState->setWorldState(ClockWorldState[0], m_Timer);
m_saveTimer = 60 * IN_MILLISECONDS;
}
else
@@ -490,14 +490,14 @@ void BattlefieldWG::OnBattleEnd(bool endByTimer)
if (!endByTimer) // win alli/horde
{
uint32 const worldStateId = GetDefenderTeam() == TEAM_ALLIANCE ? WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_CAPTURED : WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_CAPTURED;
sWorld->setWorldState(worldStateId, sWorld->getWorldState(worldStateId) + 1);
sWorldState->setWorldState(worldStateId, sWorldState->getWorldState(worldStateId) + 1);
SendWarning((GetDefenderTeam() == TEAM_ALLIANCE) ? BATTLEFIELD_WG_TEXT_WIN_KEEP : (BATTLEFIELD_WG_TEXT_WIN_KEEP + 2));
}
else // defend alli/horde
{
uint32 const worldStateId = GetDefenderTeam() == TEAM_ALLIANCE ? WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_DEFENDED : WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_DEFENDED;
sWorld->setWorldState(worldStateId, sWorld->getWorldState(worldStateId) + 1);
sWorldState->setWorldState(worldStateId, sWorldState->getWorldState(worldStateId) + 1);
SendWarning((GetDefenderTeam() == TEAM_ALLIANCE) ? BATTLEFIELD_WG_TEXT_DEFEND_KEEP : (BATTLEFIELD_WG_TEXT_DEFEND_KEEP + 2));
}
@@ -959,10 +959,10 @@ void BattlefieldWG::FillInitialWorldStates(WorldPackets::WorldState::InitWorldSt
packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_VEHICLE_A, GetData(BATTLEFIELD_WG_DATA_VEHICLE_A));
packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_MAX_VEHICLE_A, GetData(BATTLEFIELD_WG_DATA_MAX_VEHICLE_A));
packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_DEFENDED, uint32(sWorld->getWorldState(WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_DEFENDED)));
packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_CAPTURED, uint32(sWorld->getWorldState(WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_CAPTURED)));
packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_DEFENDED, uint32(sWorld->getWorldState(WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_DEFENDED)));
packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_CAPTURED, uint32(sWorld->getWorldState(WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_CAPTURED)));
packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_DEFENDED, uint32(sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_DEFENDED)));
packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_CAPTURED, uint32(sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_CAPTURED)));
packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_DEFENDED, uint32(sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_HORDE_KEEP_DEFENDED)));
packet.Worldstates.emplace_back(WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_CAPTURED, uint32(sWorldState->getWorldState(WORLD_STATE_BATTLEFIELD_WG_ALLIANCE_KEEP_CAPTURED)));
for (GameObjectBuilding::const_iterator itr = BuildingsInZone.begin(); itr != BuildingsInZone.end(); ++itr)
packet.Worldstates.emplace_back((*itr)->m_WorldState, (*itr)->m_State);

7
src/server/game/Battlefield/Zones/BattlefieldWG.h
View File

@@ -21,6 +21,7 @@
#include "Battlefield.h"
#include "Log.h"
#include "World.h"
#include "WorldState.h"
#include "WorldStateDefines.h"
#include "WorldStatePackets.h"
@@ -1238,7 +1239,7 @@ struct BfWGGameObjectBuilding
break;
}
m_State = sWorld->getWorldState(m_WorldState);
m_State = sWorldState->getWorldState(m_WorldState);
if (gobj)
{
switch (m_State)
@@ -1418,7 +1419,7 @@ struct BfWGGameObjectBuilding
void Save()
{
sWorld->setWorldState(m_WorldState, m_State);
sWorldState->setWorldState(m_WorldState, m_State);
}
};
@@ -1503,7 +1504,7 @@ struct WGWorkshop
void Save()
{
sWorld->setWorldState(WorkshopsData[workshopId].worldstate, state);
sWorldState->setWorldState(WorkshopsData[workshopId].worldstate, state);
}
};

5
src/server/game/Battlegrounds/BattlegroundMgr.cpp
View File

@@ -47,6 +47,7 @@
#include "SharedDefines.h"
#include "World.h"
#include "WorldPacket.h"
#include "WorldState.h"
#include "WorldStateDefines.h"
#include <unordered_map>
@@ -183,7 +184,7 @@ void BattlegroundMgr::Update(uint32 diff)
{
sArenaTeamMgr->DistributeArenaPoints();
m_NextAutoDistributionTime = GameTime::GetGameTime() + Seconds(DAY * sWorld->getIntConfig(CONFIG_ARENA_AUTO_DISTRIBUTE_INTERVAL_DAYS));
sWorld->setWorldState(WORLD_STATE_CUSTOM_ARENA_DISTRIBUTION_TIME, m_NextAutoDistributionTime.count());
sWorldState->setWorldState(WORLD_STATE_CUSTOM_ARENA_DISTRIBUTION_TIME, m_NextAutoDistributionTime.count());
}
m_AutoDistributionTimeChecker = 600000; // 10 minutes check
}
@@ -562,7 +563,7 @@ void BattlegroundMgr::InitAutomaticArenaPointDistribution()
if (!sWorld->getBoolConfig(CONFIG_ARENA_AUTO_DISTRIBUTE_POINTS))
return;
Seconds wstime = Seconds(sWorld->getWorldState(WORLD_STATE_CUSTOM_ARENA_DISTRIBUTION_TIME));
Seconds wstime = Seconds(sWorldState->getWorldState(WORLD_STATE_CUSTOM_ARENA_DISTRIBUTION_TIME));
Seconds curtime = GameTime::GetGameTime();
LOG_INFO("server.loading", "Initializing Automatic Arena Point Distribution");

2
src/server/game/Conditions/ConditionMgr.cpp
View File

@@ -409,7 +409,7 @@ bool Condition::Meets(ConditionSourceInfo& sourceInfo)
}
case CONDITION_WORLD_STATE:
{
condMeets = ConditionValue2 == sWorld->getWorldState(ConditionValue1);
condMeets = ConditionValue2 == sWorldState->getWorldState(ConditionValue1);
break;
}
case CONDITION_PHASEMASK:

9
src/server/game/Events/GameEventMgr.cpp
View File

@@ -32,6 +32,7 @@
#include "UnitAI.h"
#include "World.h"
#include "WorldSessionMgr.h"
#include "WorldState.h"
#include "WorldStatePackets.h"
#include <time.h>
@@ -156,7 +157,7 @@ bool GameEventMgr::StartEvent(uint16 eventId, bool overwrite)
auto itr = _gameEventSeasonalQuestsMap.find(eventId);
if (itr != _gameEventSeasonalQuestsMap.end() && !itr->second.empty())
{
sWorld->setWorldState(eventId, GameTime::GetGameTime().count());
sWorldState->setWorldState(eventId, GameTime::GetGameTime().count());
}
return false;
@@ -198,7 +199,7 @@ void GameEventMgr::StopEvent(uint16 eventId, bool overwrite)
UnApplyEvent(eventId);
// When event is stopped, clean up its worldstate
sWorld->setWorldState(eventId, 0);
sWorldState->setWorldState(eventId, 0);
if (overwrite && !serverwide_evt)
{
@@ -1205,7 +1206,7 @@ uint32 GameEventMgr::Update() // return the next e
else
{
// If event is inactive, periodically clean up its worldstate
sWorld->setWorldState(itr, 0);
sWorldState->setWorldState(itr, 0);
if (IsActiveEvent(itr))
{
@@ -1296,7 +1297,7 @@ void GameEventMgr::ApplyNewEvent(uint16 eventId)
// If event's worldstate is 0, it means the event hasn't been started yet. In that case, reset seasonal quests.
// When event ends (if it expires or if it's stopped via commands) worldstate will be set to 0 again, ready for another seasonal quest reset.
if (sWorld->getWorldState(eventId) == 0)
if (sWorldState->getWorldState(eventId) == 0)
{
sWorld->ResetEventSeasonalQuests(eventId);
}

3
src/server/game/World/IWorld.h
View File

@@ -564,9 +564,6 @@ public:
[[nodiscard]] virtual float getFloatConfig(WorldFloatConfigs index) const = 0;
virtual void setIntConfig(WorldIntConfigs index, uint32 value) = 0;
[[nodiscard]] virtual uint32 getIntConfig(WorldIntConfigs index) const = 0;
virtual void setWorldState(uint32 index, uint64 value) = 0;
[[nodiscard]] virtual uint64 getWorldState(uint32 index) const = 0;
virtual void LoadWorldStates() = 0;
[[nodiscard]] virtual bool IsPvPRealm() const = 0;
[[nodiscard]] virtual bool IsFFAPvPRealm() const = 0;
virtual uint32 GetNextWhoListUpdateDelaySecs() = 0;

95
src/server/game/World/World.cpp
View File

@@ -1753,8 +1753,9 @@ void World::SetInitialWorldSettings()
LOG_INFO("server.loading", "Loading Creature Formations...");
sFormationMgr->LoadCreatureFormations();
LOG_INFO("server.loading", "Loading World States..."); // must be loaded before battleground, outdoor PvP and conditions
LoadWorldStates();
LOG_INFO("server.loading", "Loading WorldStates..."); // must be loaded before battleground, outdoor PvP and conditions
sWorldState->LoadWorldStates();
sWorldState->Load();
LOG_INFO("server.loading", "Loading Conditions...");
sConditionMgr->LoadConditions();
@@ -1896,9 +1897,6 @@ void World::SetInitialWorldSettings()
LOG_INFO("server.loading", "Loading Active Arena Season...");
sArenaSeasonMgr->LoadActiveSeason();
LOG_INFO("server.loading", "Loading WorldState...");
sWorldState->Load();
sTicketMgr->Initialize();
///- Initialize Battlegrounds
@@ -2517,67 +2515,67 @@ void World::_UpdateRealmCharCount(PreparedQueryResult resultCharCount,uint32 acc
void World::InitWeeklyQuestResetTime()
{
Seconds wstime = Seconds(sWorld->getWorldState(WORLD_STATE_CUSTOM_WEEKLY_QUEST_RESET_TIME));
Seconds wstime = Seconds(sWorldState->getWorldState(WORLD_STATE_CUSTOM_WEEKLY_QUEST_RESET_TIME));
_nextWeeklyQuestReset = wstime > 0s ? wstime : Seconds(Acore::Time::GetNextTimeWithDayAndHour(4, 6));
if (wstime == 0s)
{
sWorld->setWorldState(WORLD_STATE_CUSTOM_WEEKLY_QUEST_RESET_TIME, _nextWeeklyQuestReset.count());
sWorldState->setWorldState(WORLD_STATE_CUSTOM_WEEKLY_QUEST_RESET_TIME, _nextWeeklyQuestReset.count());
}
}
void World::InitDailyQuestResetTime()
{
Seconds wstime = Seconds(sWorld->getWorldState(WORLD_STATE_CUSTOM_DAILY_QUEST_RESET_TIME));
Seconds wstime = Seconds(sWorldState->getWorldState(WORLD_STATE_CUSTOM_DAILY_QUEST_RESET_TIME));
_nextDailyQuestReset = wstime > 0s ? wstime : Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, 6));
if (wstime == 0s)
{
sWorld->setWorldState(WORLD_STATE_CUSTOM_DAILY_QUEST_RESET_TIME, _nextDailyQuestReset.count());
sWorldState->setWorldState(WORLD_STATE_CUSTOM_DAILY_QUEST_RESET_TIME, _nextDailyQuestReset.count());
}
}
void World::InitMonthlyQuestResetTime()
{
Seconds wstime = Seconds(sWorld->getWorldState(WORLD_STATE_CUSTOM_MONTHLY_QUEST_RESET_TIME));
Seconds wstime = Seconds(sWorldState->getWorldState(WORLD_STATE_CUSTOM_MONTHLY_QUEST_RESET_TIME));
_nextMonthlyQuestReset = wstime > 0s ? wstime : Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, 6));
if (wstime == 0s)
{
sWorld->setWorldState(WORLD_STATE_CUSTOM_MONTHLY_QUEST_RESET_TIME, _nextMonthlyQuestReset.count());
sWorldState->setWorldState(WORLD_STATE_CUSTOM_MONTHLY_QUEST_RESET_TIME, _nextMonthlyQuestReset.count());
}
}
void World::InitRandomBGResetTime()
{
Seconds wstime = Seconds(sWorld->getWorldState(WORLD_STATE_CUSTOM_BG_DAILY_RESET_TIME));
Seconds wstime = Seconds(sWorldState->getWorldState(WORLD_STATE_CUSTOM_BG_DAILY_RESET_TIME));
_nextRandomBGReset = wstime > 0s ? wstime : Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, 6));
if (wstime == 0s)
{
sWorld->setWorldState(WORLD_STATE_CUSTOM_BG_DAILY_RESET_TIME, _nextRandomBGReset.count());
sWorldState->setWorldState(WORLD_STATE_CUSTOM_BG_DAILY_RESET_TIME, _nextRandomBGReset.count());
}
}
void World::InitCalendarOldEventsDeletionTime()
{
Seconds currentDeletionTime = Seconds(getWorldState(WORLD_STATE_CUSTOM_DAILY_CALENDAR_DELETION_OLD_EVENTS_TIME));
Seconds currentDeletionTime = Seconds(sWorldState->getWorldState(WORLD_STATE_CUSTOM_DAILY_CALENDAR_DELETION_OLD_EVENTS_TIME));
Seconds nextDeletionTime = currentDeletionTime > 0s ? currentDeletionTime : Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, getIntConfig(CONFIG_CALENDAR_DELETE_OLD_EVENTS_HOUR)));
if (currentDeletionTime == 0s)
{
sWorld->setWorldState(WORLD_STATE_CUSTOM_DAILY_CALENDAR_DELETION_OLD_EVENTS_TIME, nextDeletionTime.count());
sWorldState->setWorldState(WORLD_STATE_CUSTOM_DAILY_CALENDAR_DELETION_OLD_EVENTS_TIME, nextDeletionTime.count());
}
}
void World::InitGuildResetTime()
{
Seconds wstime = Seconds(getWorldState(WORLD_STATE_CUSTOM_GUILD_DAILY_RESET_TIME));
Seconds wstime = Seconds(sWorldState->getWorldState(WORLD_STATE_CUSTOM_GUILD_DAILY_RESET_TIME));
_nextGuildReset = wstime > 0s ? wstime : Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, 6));
if (wstime == 0s)
{
sWorld->setWorldState(WORLD_STATE_CUSTOM_GUILD_DAILY_RESET_TIME, _nextGuildReset.count());
sWorldState->setWorldState(WORLD_STATE_CUSTOM_GUILD_DAILY_RESET_TIME, _nextGuildReset.count());
}
}
@@ -2592,7 +2590,7 @@ void World::ResetDailyQuests()
itr->second->GetPlayer()->ResetDailyQuestStatus();
_nextDailyQuestReset = Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, 6));
sWorld->setWorldState(WORLD_STATE_CUSTOM_DAILY_QUEST_RESET_TIME, _nextDailyQuestReset.count());
sWorldState->setWorldState(WORLD_STATE_CUSTOM_DAILY_QUEST_RESET_TIME, _nextDailyQuestReset.count());
// change available dailies
sPoolMgr->ChangeDailyQuests();
@@ -2628,7 +2626,7 @@ void World::ResetWeeklyQuests()
itr->second->GetPlayer()->ResetWeeklyQuestStatus();
_nextWeeklyQuestReset = Seconds(Acore::Time::GetNextTimeWithDayAndHour(4, 6));
sWorld->setWorldState(WORLD_STATE_CUSTOM_WEEKLY_QUEST_RESET_TIME, _nextWeeklyQuestReset.count());
sWorldState->setWorldState(WORLD_STATE_CUSTOM_WEEKLY_QUEST_RESET_TIME, _nextWeeklyQuestReset.count());
// change available weeklies
sPoolMgr->ChangeWeeklyQuests();
@@ -2647,7 +2645,7 @@ void World::ResetMonthlyQuests()
itr->second->GetPlayer()->ResetMonthlyQuestStatus();
_nextMonthlyQuestReset = Seconds(Acore::Time::GetNextTimeWithMonthAndHour(-1, 6));
sWorld->setWorldState(WORLD_STATE_CUSTOM_MONTHLY_QUEST_RESET_TIME, _nextMonthlyQuestReset.count());
sWorldState->setWorldState(WORLD_STATE_CUSTOM_MONTHLY_QUEST_RESET_TIME, _nextMonthlyQuestReset.count());
}
void World::ResetEventSeasonalQuests(uint16 event_id)
@@ -2675,7 +2673,7 @@ void World::ResetRandomBG()
itr->second->GetPlayer()->SetRandomWinner(false);
_nextRandomBGReset = Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, 6));
sWorld->setWorldState(WORLD_STATE_CUSTOM_BG_DAILY_RESET_TIME, _nextRandomBGReset.count());
sWorldState->setWorldState(WORLD_STATE_CUSTOM_BG_DAILY_RESET_TIME, _nextRandomBGReset.count());
}
void World::CalendarDeleteOldEvents()
@@ -2683,7 +2681,7 @@ void World::CalendarDeleteOldEvents()
LOG_INFO("server.worldserver", "Calendar deletion of old events.");
_nextCalendarOldEventsDeletionTime = Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, getIntConfig(CONFIG_CALENDAR_DELETE_OLD_EVENTS_HOUR)));
sWorld->setWorldState(WORLD_STATE_CUSTOM_DAILY_CALENDAR_DELETION_OLD_EVENTS_TIME, _nextCalendarOldEventsDeletionTime.count());
sWorldState->setWorldState(WORLD_STATE_CUSTOM_DAILY_CALENDAR_DELETION_OLD_EVENTS_TIME, _nextCalendarOldEventsDeletionTime.count());
sCalendarMgr->DeleteOldEvents();
}
@@ -2692,7 +2690,7 @@ void World::ResetGuildCap()
LOG_INFO("server.worldserver", "Guild Daily Cap reset.");
_nextGuildReset = Seconds(Acore::Time::GetNextTimeWithDayAndHour(-1, 6));
sWorld->setWorldState(WORLD_STATE_CUSTOM_GUILD_DAILY_RESET_TIME, _nextGuildReset.count());
sWorldState->setWorldState(WORLD_STATE_CUSTOM_GUILD_DAILY_RESET_TIME, _nextGuildReset.count());
sGuildMgr->ResetTimes();
}
@@ -2725,57 +2723,6 @@ void World::UpdateAreaDependentAuras()
}
}
void World::LoadWorldStates()
{
uint32 oldMSTime = getMSTime();
QueryResult result = CharacterDatabase.Query("SELECT entry, value FROM worldstates");
if (!result)
{
LOG_WARN("server.loading", ">> Loaded 0 world states. DB table `worldstates` is empty!");
LOG_INFO("server.loading", " ");
return;
}
do
{
Field* fields = result->Fetch();
_worldstates[fields[0].Get<uint32>()] = fields[1].Get<uint32>();
} while (result->NextRow());
LOG_INFO("server.loading", ">> Loaded {} World States in {} ms", _worldstates.size(), GetMSTimeDiffToNow(oldMSTime));
LOG_INFO("server.loading", " ");
}
// Setting a worldstate will save it to DB
void World::setWorldState(uint32 index, uint64 timeValue)
{
auto const& it = _worldstates.find(index);
if (it != _worldstates.end())
{
CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_WORLDSTATE);
stmt->SetData(0, uint32(timeValue));
stmt->SetData(1, index);
CharacterDatabase.Execute(stmt);
}
else
{
CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_WORLDSTATE);
stmt->SetData(0, index);
stmt->SetData(1, uint32(timeValue));
CharacterDatabase.Execute(stmt);
}
_worldstates[index] = timeValue;
}
uint64 World::getWorldState(uint32 index) const
{
auto const& itr = _worldstates.find(index);
return itr != _worldstates.end() ? itr->second : 0;
}
void World::ProcessQueryCallbacks()
{
_queryProcessor.ProcessReadyCallbacks();

6
src/server/game/World/World.h
View File

@@ -241,10 +241,6 @@ public:
return index < INT_CONFIG_VALUE_COUNT ? _int_configs[index] : 0;
}
void setWorldState(uint32 index, uint64 value) override;
[[nodiscard]] uint64 getWorldState(uint32 index) const override;
void LoadWorldStates() override;
/// Are we on a "Player versus Player" server?
[[nodiscard]] bool IsPvPRealm() const override;
[[nodiscard]] bool IsFFAPvPRealm() const override;
@@ -318,8 +314,6 @@ private:
uint32 _int_configs[INT_CONFIG_VALUE_COUNT];
bool _bool_configs[BOOL_CONFIG_VALUE_COUNT];
float _float_configs[FLOAT_CONFIG_VALUE_COUNT];
typedef std::map<uint32, uint64> WorldStatesMap;
WorldStatesMap _worldstates;
AccountTypes _allowedSecurityLevel;
LocaleConstant _defaultDbcLocale; // from config for one from loaded DBC locales
uint32 _availableDbcLocaleMask; // by loaded DBC

52
src/server/game/World/WorldState.cpp
View File

@@ -95,6 +95,57 @@ void WorldState::Load()
HandleSunsReachSubPhaseTransition(m_sunsReachData.m_subphaseMask, true);
}
void WorldState::LoadWorldStates()
{
uint32 oldMSTime = getMSTime();
QueryResult result = CharacterDatabase.Query("SELECT entry, value FROM worldstates");
if (!result)
{
LOG_WARN("server.loading", ">> Loaded 0 world states. DB table `worldstates` is empty!");
LOG_INFO("server.loading", " ");
return;
}
do
{
Field* fields = result->Fetch();
_worldstates[fields[0].Get<uint32>()] = fields[1].Get<uint32>();
} while (result->NextRow());
LOG_INFO("server.loading", ">> Loaded {} World States in {} ms", _worldstates.size(), GetMSTimeDiffToNow(oldMSTime));
LOG_INFO("server.loading", " ");
}
// Setting a worldstate will save it to DB
void WorldState::setWorldState(uint32 index, uint64 timeValue)
{
auto const& it = _worldstates.find(index);
if (it != _worldstates.end())
{
CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_UPD_WORLDSTATE);
stmt->SetData(0, uint32(timeValue));
stmt->SetData(1, index);
CharacterDatabase.Execute(stmt);
}
else
{
CharacterDatabasePreparedStatement* stmt = CharacterDatabase.GetPreparedStatement(CHAR_INS_WORLDSTATE);
stmt->SetData(0, index);
stmt->SetData(1, uint32(timeValue));
CharacterDatabase.Execute(stmt);
}
_worldstates[index] = timeValue;
}
uint64 WorldState::getWorldState(uint32 index) const
{
auto const& itr = _worldstates.find(index);
return itr != _worldstates.end() ? itr->second : 0;
}
void WorldState::Save(WorldStateSaveIds saveId)
{
switch (saveId)
@@ -233,6 +284,7 @@ void WorldState::HandlePlayerEnterZone(Player* player, WorldStateZoneId zoneId)
break;
}
};
void WorldState::HandlePlayerLeaveZone(Player* player, WorldStateZoneId zoneId)
{
std::lock_guard<std::mutex> guard(_mutex);

5
src/server/game/World/WorldState.h
View File

@@ -177,6 +177,9 @@ class WorldState
virtual ~WorldState();
static WorldState* instance();
void Load();
void LoadWorldStates();
void setWorldState(uint32 index, uint64 value);
[[nodiscard]] uint64 getWorldState(uint32 index) const;
void Save(WorldStateSaveIds saveId);
void SaveHelper(std::string& stringToSave, WorldStateSaveIds saveId);
void HandlePlayerEnterZone(Player* player, WorldStateZoneId zoneId);
@@ -195,6 +198,8 @@ class WorldState
void HandleSunwellGateTransition(uint32 newGate);
void SetSunwellGateCounter(SunwellGateCounters index, uint32 value);
private:
typedef std::map<uint32, uint64> WorldStatesMap;
WorldStatesMap _worldstates;
void SendWorldstateUpdate(std::mutex& mutex, GuidVector const& guids, uint32 value, uint32 worldStateId);
void StopSunsReachPhase(bool forward);
void StartSunsReachPhase(bool initial = false);

17
src/server/scripts/OutdoorPvP/OutdoorPvPTF.cpp
View File

@@ -27,6 +27,7 @@
#include "World.h"
#include "WorldPacket.h"
#include "WorldSessionMgr.h"
#include "WorldState.h"
#include "WorldStatePackets.h"
OutdoorPvPTF::OutdoorPvPTF()
@@ -111,14 +112,14 @@ void OutdoorPvPTF::SendRemoveWorldStates(Player* player)
void OutdoorPvPTF::SaveRequiredWorldStates() const
{
sWorld->setWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
sWorld->setWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
sWorldState->setWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_H, m_HordeTowersControlled);
sWorldState->setWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_A, m_AllianceTowersControlled);
sWorld->setWorldState(WORLD_STATE_OPVP_TF_UI_TOWERS_CONTROLLED_DISPLAY, m_IsLocked);
sWorldState->setWorldState(WORLD_STATE_OPVP_TF_UI_TOWERS_CONTROLLED_DISPLAY, m_IsLocked);
// Save expiry as unix
uint32 const lockExpireTime = GameTime::GetGameTime().count() + (m_LockTimer / IN_MILLISECONDS);
sWorld->setWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_HOURS, lockExpireTime);
sWorldState->setWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_HOURS, lockExpireTime);
}
void OutdoorPvPTF::ResetZoneToTeamControlled(TeamId team)
@@ -335,7 +336,7 @@ bool OutdoorPvPTF::SetupOutdoorPvP()
m_AllianceTowersControlled = 0;
m_HordeTowersControlled = 0;
m_IsLocked = bool(sWorld->getWorldState(WORLD_STATE_OPVP_TF_UI_TOWERS_CONTROLLED_DISPLAY));
m_IsLocked = bool(sWorldState->getWorldState(WORLD_STATE_OPVP_TF_UI_TOWERS_CONTROLLED_DISPLAY));
m_JustLocked = false;
m_LockTimer = TF_LOCK_TIME;
m_LockTimerUpdate = 0;
@@ -359,14 +360,14 @@ bool OutdoorPvPTF::SetupOutdoorPvP()
{
// Core shutdown while locked -- init from latest known data in WorldState
// Convert from unix
int32 const lockRemainingTime = int32((sWorld->getWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_HOURS) - GameTime::GetGameTime().count()) * IN_MILLISECONDS);
int32 const lockRemainingTime = int32((sWorldState->getWorldState(WORLD_STATE_OPVP_TF_UI_LOCKED_TIME_HOURS) - GameTime::GetGameTime().count()) * IN_MILLISECONDS);
if (lockRemainingTime > 0)
{
m_LockTimer = lockRemainingTime;
RecalculateClientUILockTime();
uint32 const hordeTowers = uint32(sWorld->getWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_H));
uint32 const allianceTowers = uint32(sWorld->getWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_A));
uint32 const hordeTowers = uint32(sWorldState->getWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_H));
uint32 const allianceTowers = uint32(sWorldState->getWorldState(WORLD_STATE_OPVP_TF_UI_TOWER_COUNT_A));
TeamId const controllingTeam = hordeTowers > allianceTowers ? TEAM_HORDE : TEAM_ALLIANCE;
ResetZoneToTeamControlled(controllingTeam);

27
src/server/scripts/World/npcs_special.cpp
View File

@@ -34,6 +34,7 @@
#include "TaskScheduler.h"
#include "WaypointMgr.h"
#include "World.h"
#include "WorldState.h"
#include "WorldStateDefines.h"
/// @todo: this import is not necessary for compilation and marked as unused by the IDE
@@ -212,13 +213,13 @@ public:
npc_riggle_bassbaitAI(Creature* c) : ScriptedAI(c)
{
m_uiTimer = 0;
auto prevWinTime = sWorld->getWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_PREV_WIN_TIME);
auto prevWinTime = sWorldState->getWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_PREV_WIN_TIME);
if (GameTime::GetGameTime().count() - prevWinTime > DAY)
{
// reset all after 1 day
sWorld->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_EVENT_BEGIN, 1);
sWorld->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_POOLS_DESPAWN, 0);
sWorld->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_HAS_WINNER, 0);
sWorldState->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_EVENT_BEGIN, 1);
sWorldState->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_POOLS_DESPAWN, 0);
sWorldState->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_HAS_WINNER, 0);
}
}
@@ -226,16 +227,16 @@ public:
void CheckTournamentState() const
{
if (sGameEventMgr->IsActiveEvent(EVENT_FISHING_TURN_INS) && !sWorld->getWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_HAS_WINNER))
if (sGameEventMgr->IsActiveEvent(EVENT_FISHING_TURN_INS) && !sWorldState->getWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_HAS_WINNER))
{
if (!me->IsQuestGiver())
{
me->SetNpcFlag(UNIT_NPC_FLAG_QUESTGIVER);
}
if (sWorld->getWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_EVENT_BEGIN))
if (sWorldState->getWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_EVENT_BEGIN))
{
me->AI()->Talk(RIGGLE_SAY_START);
sWorld->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_EVENT_BEGIN, 0);
sWorldState->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_EVENT_BEGIN, 0);
}
}
else
@@ -248,14 +249,14 @@ public:
if (sGameEventMgr->IsActiveEvent(EVENT_FISHING_POOLS))
{
// enable announcement: when pools despawn
sWorld->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_POOLS_DESPAWN, 1);
sWorldState->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_POOLS_DESPAWN, 1);
}
else
{
if (sWorld->getWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_POOLS_DESPAWN))
if (sWorldState->getWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_POOLS_DESPAWN))
{
me->AI()->Talk(RIGGLE_SAY_POOLS_END);
sWorld->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_POOLS_DESPAWN, 0);
sWorldState->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_ANNOUNCE_POOLS_DESPAWN, 0);
}
}
}
@@ -281,7 +282,7 @@ public:
player->PrepareQuestMenu(creature->GetGUID());
}
if (sWorld->getWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_HAS_WINNER))
if (sWorldState->getWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_HAS_WINNER))
{
SendGossipMenuFor(player, GOSSIP_EVENT_OVER, creature->GetGUID());
}
@@ -298,8 +299,8 @@ public:
{
creature->RemoveNpcFlag(UNIT_NPC_FLAG_QUESTGIVER);
creature->AI()->Talk(RIGGLE_SAY_WINNER, player);
sWorld->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_PREV_WIN_TIME, GameTime::GetGameTime().count());
sWorld->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_HAS_WINNER, 1);
sWorldState->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_PREV_WIN_TIME, GameTime::GetGameTime().count());
sWorldState->setWorldState(WORLD_STATE_STRANGLETHORN_VALE_FISHING_HAS_WINNER, 1);
}
return true;
}