feat(Core/BasicEvents): Add the possibility to group BasicEvents (#15369)

src/common/Utilities/EventProcessor.cpp

@@ -75,7 +75,7 @@ void EventProcessor::Update(uint32 p_time)
 
         // Reschedule non deletable events to be checked at
         // the next update tick
-        AddEvent(event, CalculateTime(1), false);
+        AddEvent(event, CalculateTime(1), false, 0);
     }
 }
 
@@ -111,11 +111,33 @@ void EventProcessor::KillAllEvents(bool force)
         m_events.clear();
 }
 
-void EventProcessor::AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime)
+void EventProcessor::CancelEventGroup(uint8 group)
+{
+    for (auto itr = m_events.begin(); itr != m_events.end();)
+    {
+        if (itr->second->m_eventGroup != group)
+        {
+            continue;
+        }
+
+        // Abort events which weren't aborted already
+        if (!itr->second->IsAborted())
+        {
+            itr->second->SetAborted();
+            itr->second->Abort(m_time);
+        }
+
+        delete itr->second;
+        itr = m_events.erase(itr);
+    }
+}
+
+void EventProcessor::AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime, uint8 eventGroup)
 {
     if (set_addtime)
         Event->m_addTime = m_time;
     Event->m_execTime = e_time;
+    Event->m_eventGroup = eventGroup;
     m_events.insert(std::pair<uint64, BasicEvent*>(e_time, Event));
 }
 

src/common/Utilities/EventProcessor.h

@@ -69,6 +69,7 @@ class BasicEvent
         // these can be used for time offset control
         uint64 m_addTime{0};                                   // time when the event was added to queue, filled by event handler
         uint64 m_execTime{0};                                  // planned time of next execution, filled by event handler
+        uint8 m_eventGroup{0};
 };
 
 template<typename T>
@@ -101,11 +102,16 @@ class EventProcessor
 
         void Update(uint32 p_time);
         void KillAllEvents(bool force);
-        void AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime = true);
+        void AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime = true) { AddEvent(Event, e_time, set_addtime, 0); };
+        void AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime, uint8 eventGroup);
         template<typename T>
         is_lambda_event<T> AddEvent(T&& event, Milliseconds e_time, bool set_addtime = true) { AddEvent(new LambdaBasicEvent<T>(std::move(event)), e_time, set_addtime); }
-        void AddEventAtOffset(BasicEvent* event, Milliseconds offset) { AddEvent(event, CalculateTime(offset.count())); }
+        void AddEventAtOffset(BasicEvent* event, Milliseconds offset) { AddEvent(event, CalculateTime(offset.count()), true, 0); }
-        void AddEventAtOffset(BasicEvent* event, Milliseconds offset, Milliseconds offset2) { AddEvent(event, CalculateTime(randtime(offset, offset2).count())); }
+        void AddEventAtOffset(BasicEvent* event, Milliseconds offset, Milliseconds offset2) { AddEvent(event, CalculateTime(randtime(offset, offset2).count()), true, false); }
+        template<typename T>
+        is_lambda_event<T> AddEventAtOffset(T&& event, Milliseconds offset, uint8 eventGroup) { AddEvent(new LambdaBasicEvent<T>(std::move(event)), CalculateTime(offset.count()), true, eventGroup); };
+        template<typename T>
+        is_lambda_event<T> AddEventAtOffset(T&& event, Milliseconds offset, Milliseconds offset2, uint8 eventGroup) { AddEvent(new LambdaBasicEvent<T>(std::move(event)), CalculateTime(randtime(offset, offset2).count()), true, eventGroup); };
         template<typename T>
         is_lambda_event<T> AddEventAtOffset(T&& event, Milliseconds offset) { AddEventAtOffset(new LambdaBasicEvent<T>(std::move(event)), offset); }
         template<typename T>
@@ -116,6 +122,8 @@ class EventProcessor
         //calculates next queue tick time
         [[nodiscard]] uint64 CalculateQueueTime(uint64 delay) const;
 
+        void CancelEventGroup(uint8 group);
+
     protected:
         uint64 m_time{0};
         EventList m_events;