Mirror/TrinityCore
1
0
Fork 0
mirror of https://github.com/TrinityCore/TrinityCore.git synced 2026-01-20 01:15:35 +01:00
Code Issues Packages Projects Releases Wiki Activity

Core/EventMap: Refactor and modernize EventMap (#29183)

Browse Source
This commit is contained in:
Kelno
2023-08-19 23:57:57 +02:00
committed by GitHub
parent 24359b0618
commit 1bea4aab45
2 changed files with 138 additions and 82 deletions
Download Patch File Download Diff File Expand all files Collapse all files

102
src/common/Utilities/EventMap.cpp
View File

@@ -22,40 +22,40 @@ void EventMap::Reset()
{
_eventMap.clear();
_time = TimePoint::min();
_phase = 0;
_phaseMask = 0;
}
void EventMap::SetPhase(uint8 phase)
void EventMap::SetPhase(PhaseIndex phase)
{
if (!phase)
_phase = 0;
else if (phase <= 8)
_phase = uint8(1 << (phase - 1));
_phaseMask = 0;
else if (phase <= sizeof(PhaseMask) * 8)
_phaseMask = PhaseMask(1u << (phase - 1u));
}
void EventMap::ScheduleEvent(uint32 eventId, Milliseconds time, uint32 group /*= 0*/, uint8 phase /*= 0*/)
void EventMap::ScheduleEvent(EventId eventId, Milliseconds time, GroupIndex group /*= 0*/, PhaseIndex phase /*= 0*/)
{
if (group && group <= 8)
eventId |= (1 << (group + 15));
if (group > sizeof(GroupMask) * 8)
return;
if (phase && phase <= 8)
eventId |= (1 << (phase + 23));
if (phase > sizeof(PhaseMask) * 8)
return;
_eventMap.insert(EventStore::value_type(_time + time, eventId));
_eventMap.insert(EventStore::value_type(_time + time, Event(eventId, group, phase)));
}
void EventMap::ScheduleEvent(uint32 eventId, Milliseconds minTime, Milliseconds maxTime, uint32 group /*= 0*/, uint32 phase /*= 0*/)
void EventMap::ScheduleEvent(EventId eventId, Milliseconds minTime, Milliseconds maxTime, GroupIndex group /*= 0*/, PhaseIndex phase /*= 0*/)
{
ScheduleEvent(eventId, randtime(minTime, maxTime), group, phase);
}
void EventMap::RescheduleEvent(uint32 eventId, Milliseconds time, uint32 group /*= 0*/, uint8 phase /*= 0*/)
void EventMap::RescheduleEvent(EventId eventId, Milliseconds time, GroupIndex group, PhaseIndex phase)
{
CancelEvent(eventId);
ScheduleEvent(eventId, time, group, phase);
}
void EventMap::RescheduleEvent(uint32 eventId, Milliseconds minTime, Milliseconds maxTime, uint32 group /*= 0*/, uint32 phase /*= 0*/)
void EventMap::RescheduleEvent(EventId eventId, Milliseconds minTime, Milliseconds maxTime, GroupIndex group /*= 0*/, PhaseIndex phase /*= 0*/)
{
RescheduleEvent(eventId, randtime(minTime, maxTime), group, phase);
}
@@ -70,20 +70,20 @@ void EventMap::Repeat(Milliseconds minTime, Milliseconds maxTime)
Repeat(randtime(minTime, maxTime));
}
uint32 EventMap::ExecuteEvent()
EventMap::EventId EventMap::ExecuteEvent()
{
while (!Empty())
{
EventStore::iterator itr = _eventMap.begin();
auto itr = _eventMap.begin();
if (itr->first > _time)
return 0;
else if (_phase && (itr->second & 0xFF000000) && !((itr->second >> 24) & _phase))
else if (_phaseMask && itr->second._phaseMask && !(itr->second._phaseMask & _phaseMask))
_eventMap.erase(itr);
else
{
uint32 eventId = (itr->second & 0x0000FFFF);
_lastEvent = itr->second; // include phase/group
auto eventId = itr->second._id;
_lastEvent = itr->second;
_eventMap.erase(itr);
return eventId;
}
@@ -98,7 +98,7 @@ void EventMap::DelayEvents(Milliseconds delay)
return;
EventStore delayed = std::move(_eventMap);
for (EventStore::iterator itr = delayed.begin(); itr != delayed.end();)
for (auto itr = delayed.begin(); itr != delayed.end();)
{
EventStore::node_type node = delayed.extract(itr++);
node.key() = node.key() + delay;
@@ -106,16 +106,16 @@ void EventMap::DelayEvents(Milliseconds delay)
}
}
void EventMap::DelayEvents(Milliseconds delay, uint32 group)
void EventMap::DelayEvents(Milliseconds delay, GroupIndex group)
{
if (!group || group > 8 || Empty())
if (!group || group > sizeof(GroupMask) * 8 || Empty())
return;
EventStore delayed;
for (EventStore::iterator itr = _eventMap.begin(); itr != _eventMap.end();)
for (auto itr = _eventMap.begin(); itr != _eventMap.end();)
{
if (itr->second & (1 << (group + 15)))
if (itr->second._groupMask & GroupMask(1u << (group - 1u)))
{
delayed.insert(EventStore::value_type(itr->first + delay, itr->second));
_eventMap.erase(itr++);
@@ -127,39 +127,65 @@ void EventMap::DelayEvents(Milliseconds delay, uint32 group)
_eventMap.insert(delayed.begin(), delayed.end());
}
void EventMap::CancelEvent(uint32 eventId)
void EventMap::SetMinimalDelay(EventId eventId, Milliseconds delay)
{
if (Empty())
return;
for (EventStore::iterator itr = _eventMap.begin(); itr != _eventMap.end();)
for (auto itr = _eventMap.begin(); itr != _eventMap.end();)
{
if (eventId == (itr->second & 0x0000FFFF))
_eventMap.erase(itr++);
else
++itr;
if (eventId == itr->second._id)
{
if (itr->first < (_time + delay))
{
_eventMap.insert(EventStore::value_type(_time + delay, itr->second));
itr = _eventMap.erase(itr);
continue;
}
}
++itr;
}
}
void EventMap::CancelEventGroup(uint32 group)
void EventMap::CancelEvent(EventId eventId)
{
if (!group || group > 8 || Empty())
if (Empty())
return;
for (EventStore::iterator itr = _eventMap.begin(); itr != _eventMap.end();)
for (auto itr = _eventMap.begin(); itr != _eventMap.end();)
{
if (itr->second & (1 << (group + 15)))
if (eventId == itr->second._id)
_eventMap.erase(itr++);
else
++itr;
}
}
Milliseconds EventMap::GetTimeUntilEvent(uint32 eventId) const
void EventMap::CancelEventGroup(GroupIndex group)
{
for (std::pair<TimePoint const, uint32> const& itr : _eventMap)
if (eventId == (itr.second & 0x0000FFFF))
return std::chrono::duration_cast<Milliseconds>(itr.first - _time);
if (!group || group > sizeof(GroupMask) * 8 || Empty())
return;
for (auto itr = _eventMap.begin(); itr != _eventMap.end();)
{
if (itr->second._groupMask & GroupMask(1u << (group - 1u)))
_eventMap.erase(itr++);
else
++itr;
}
}
Milliseconds EventMap::GetTimeUntilEvent(EventId eventId) const
{
for (auto const& [time, event] : _eventMap)
if (eventId == event._id)
return std::chrono::duration_cast<Milliseconds>(time - _time);
return Milliseconds::max();
}
bool EventMap::HasEventScheduled(EventId eventId) const
{
return GetTimeUntilEvent(eventId) != Milliseconds::max();
}

118
src/common/Utilities/EventMap.h
View File

@@ -15,8 +15,8 @@
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef _EVENT_MAP_H_
#define _EVENT_MAP_H_
#ifndef TRINITYCORE_EVENT_MAP_H
#define TRINITYCORE_EVENT_MAP_H
#include "Define.h"
#include "Duration.h"
@@ -24,21 +24,34 @@
class TC_COMMON_API EventMap
{
using EventId = uint16;
using GroupIndex = uint8;
using GroupMask = uint8;
using PhaseIndex = uint8;
using PhaseMask = uint8;
struct Event
{
Event() = default;
Event(EventId id, GroupIndex groupIndex, PhaseIndex phaseIndex) :
_id(id),
_groupMask(groupIndex ? GroupMask(1u << (groupIndex - 1u)) : 0u),
_phaseMask(phaseIndex ? PhaseMask(1u << (phaseIndex - 1u)) : 0u)
{
}
EventId _id = 0u;
GroupMask _groupMask = 0u;
PhaseMask _phaseMask = 0u;
};
/**
* Internal storage type.
* Key: Time as TimePoint when the event should occur.
* Value: The event data as uint32.
*
* Structure of event data:
* - Bit 0 - 15: Event Id.
* - Bit 16 - 23: Group
* - Bit 24 - 31: Phase
* - Pattern: 0xPPGGEEEE
*/
typedef std::multimap<TimePoint, uint32> EventStore;
* Internal storage type.
* Key: Time as TimePoint when the event should occur.
*/
using EventStore = std::multimap<TimePoint, Event>;
public:
EventMap() : _time(TimePoint::min()), _phase(0), _lastEvent(0) { }
EventMap() : _time(TimePoint::min()), _phaseMask(0) { }
/**
* @name Reset
@@ -70,9 +83,9 @@ public:
* @name GetPhaseMask
* @return Active phases as mask.
*/
uint8 GetPhaseMask() const
PhaseMask GetPhaseMask() const
{
return _phase;
return _phaseMask;
}
/**
@@ -89,50 +102,50 @@ public:
* @brief Sets the phase of the map (absolute).
* @param phase Phase which should be set. Values: 1 - 8. 0 resets phase.
*/
void SetPhase(uint8 phase);
void SetPhase(PhaseIndex phase);
/**
* @name AddPhase
* @brief Activates the given phase (bitwise).
* @brief Activates the given phase (absolute).
* @param phase Phase which should be activated. Values: 1 - 8
*/
void AddPhase(uint8 phase)
void AddPhase(PhaseIndex phase)
{
if (phase && phase <= 8)
_phase |= uint8(1 << (phase - 1));
if (phase && phase <= sizeof(PhaseMask) * 8)
_phaseMask |= PhaseMask(1u << (phase - 1u));
}
/**
* @name RemovePhase
* @brief Deactivates the given phase (bitwise).
* @brief Deactivates the given phase (absolute).
* @param phase Phase which should be deactivated. Values: 1 - 8.
*/
void RemovePhase(uint8 phase)
void RemovePhase(PhaseIndex phase)
{
if (phase && phase <= 8)
_phase &= uint8(~(1 << (phase - 1)));
if (phase && phase <= sizeof(PhaseMask) * 8)
_phaseMask &= PhaseMask(~(1u << (phase - 1u)));
}
/**
* @name ScheduleEvent
* @brief Schedules a new event. An existing event is not canceled.
* @brief Creates new event entry in map.
* @param eventId The id of the new event.
* @param time The time until the event occurs as std::chrono type.
* @param group The group which the event is associated to. Has to be between 1 and 8. 0 means it has no group.
* @param phase The phase in which the event can occur. Has to be between 1 and 8. 0 means it can occur in all phases.
*/
void ScheduleEvent(uint32 eventId, Milliseconds time, uint32 group = 0, uint8 phase = 0);
void ScheduleEvent(EventId eventId, Milliseconds time, GroupIndex group = 0u, PhaseIndex phase = 0u);
/**
* @name ScheduleEvent
* @brief Schedules a new event. An existing event is not canceled.
* @brief Creates new event entry in map.
* @param eventId The id of the new event.
* @param minTime The minimum time until the event occurs as std::chrono type.
* @param maxTime The maximum time until the event occurs as std::chrono type.
* @param group The group which the event is associated to. Has to be between 1 and 8. 0 means it has no group.
* @param phase The phase in which the event can occur. Has to be between 1 and 8. 0 means it can occur in all phases.
*/
void ScheduleEvent(uint32 eventId, Milliseconds minTime, Milliseconds maxTime, uint32 group = 0, uint32 phase = 0);
void ScheduleEvent(EventId eventId, Milliseconds minTime, Milliseconds maxTime, GroupIndex group = 0u, PhaseIndex phase = 0u);
/**
* @name RescheduleEvent
@@ -142,7 +155,7 @@ public:
* @param group The group which the event is associated to. Has to be between 1 and 8. 0 means it has no group.
* @param phase The phase in which the event can occur. Has to be between 1 and 8. 0 means it can occur in all phases.
*/
void RescheduleEvent(uint32 eventId, Milliseconds time, uint32 group = 0, uint8 phase = 0);
void RescheduleEvent(EventId eventId, Milliseconds time, GroupIndex group = 0u, PhaseIndex phase = 0u);
/**
* @name RescheduleEvent
@@ -153,7 +166,7 @@ public:
* @param group The group which the event is associated to. Has to be between 1 and 8. 0 means it has no group.
* @param phase The phase in which the event can occur. Has to be between 1 and 8. 0 means it can occur in all phases.
*/
void RescheduleEvent(uint32 eventId, Milliseconds minTime, Milliseconds maxTime, uint32 group = 0, uint32 phase = 0);
void RescheduleEvent(EventId eventId, Milliseconds minTime, Milliseconds maxTime, GroupIndex group = 0u, PhaseIndex phase = 0u);
/**
* @name RepeatEvent
@@ -172,10 +185,10 @@ public:
/**
* @name ExecuteEvent
* @brief Returns the next event to be executed and removes it from map.
* @brief Returns the next event to execute and removes it from map.
* @return Id of the event to execute.
*/
uint32 ExecuteEvent();
EventId ExecuteEvent();
/**
* @name DelayEvents
@@ -190,21 +203,29 @@ public:
* @param delay Amount of delay as std::chrono type.
* @param group Group of the events.
*/
void DelayEvents(Milliseconds delay, uint32 group);
void DelayEvents(Milliseconds delay, GroupIndex group);
/**
* @name SetMinimalDelay
* @brief Increase event delay if smaller than given delay.
* @param eventId The id of the event.
* @param delay Minimum delay for given event.
*/
void SetMinimalDelay(EventId eventId, Milliseconds delay);
/**
* @name CancelEvent
* @brief Cancels all events of the specified id.
* @param eventId Event id to cancel.
*/
void CancelEvent(uint32 eventId);
void CancelEvent(EventId eventId);
/**
* @name CancelEventGroup
* @brief Cancel events belonging to specified group.
* @param group Group to cancel.
*/
void CancelEventGroup(uint32 group);
void CancelEventGroup(GroupIndex group);
/**
* @name IsInPhase
@@ -212,18 +233,27 @@ public:
* @param phase Wanted phase.
* @return True, if phase of event map contains specified phase.
*/
bool IsInPhase(uint8 phase) const
bool IsInPhase(PhaseIndex phase) const
{
return phase <= 8 && (!phase || _phase & (1 << (phase - 1)));
return phase <= sizeof(PhaseIndex) * 8 && (!phase || _phaseMask & PhaseMask(1u << (phase - 1u)));
}
/**
* @name GetTimeUntilEvent
* @brief Returns time as std::chrono type until next event.
* @param eventId of the event.
* @param eventId The id of the event.
* @return Time of next event. If event is not scheduled returns Milliseconds::max()
* @return Time of next event.
*/
Milliseconds GetTimeUntilEvent(uint32 eventId) const;
Milliseconds GetTimeUntilEvent(EventId eventId) const;
/**
* @name HasEventScheduled
* @brief Returns whether an event is scheduled
* @param eventId The id of the event.
* @return True if event is scheduled
*/
bool HasEventScheduled(EventId eventId) const;
private:
/**
@@ -239,14 +269,14 @@ private:
TimePoint _time;
/**
* @name _phase
* @name _phaseMask
* @brief Phase mask of the event map.
*
* Contains the phases the event map is in. Multiple
* phases from 1 to 8 can be set with SetPhase or
* AddPhase. RemovePhase deactives a phase.
*/
uint8 _phase;
PhaseMask _phaseMask;
/**
* @name _eventMap
@@ -261,7 +291,7 @@ private:
* @name _lastEvent
* @brief Stores information on the most recently executed event
*/
uint32 _lastEvent;
Event _lastEvent;
};
#endif // _EVENT_MAP_H_
#endif // TRINITYCORE_EVENT_MAP_H