Merge branch '6.x' of https://github.com/TrinityCore/TrinityCore into legion

3 files changed, 100 insertions, 47 deletions

diff --git a/src/common/GitRevision.cpp b/src/common/GitRevision.cpp
index 2b4537db448..1f4c28cd310 100644
--- a/src/common/GitRevision.cpp
+++ b/src/common/GitRevision.cpp
@@ -46,19 +46,30 @@ char const* GitRevision::GetHotfixesDatabase()
     return _HOTFIXES_DATABASE;
 }
 
-#define _PACKAGENAME "TrinityCore"
-
-char const* GitRevision::GetFullVersion()
-{
 #if PLATFORM == PLATFORM_WINDOWS
-# ifdef _WIN64
-    return _PACKAGENAME " rev. " VER_PRODUCTVERSION_STR " (Win64, " _BUILD_DIRECTIVE ")";
-# else
-    return _PACKAGENAME " rev. " VER_PRODUCTVERSION_STR " (Win32, " _BUILD_DIRECTIVE ")";
-# endif
+#  ifdef _WIN64
+#    define TRINITY_PLATFORM_STR "Win64"
+#  else
+#    define TRINITY_PLATFORM_STR "Win32"
+#  endif
+#elif PLATFORM == PLATFORM_APPLE
+#  define TRINITY_PLATFORM_STR "MacOSX"
+#elif PLATFORM == PLATFORM_INTEL
+#  define TRINITY_PLATFORM_STR "Intel"
+#else // PLATFORM_UNIX
+#  define TRINITY_PLATFORM_STR "Unix"
+#endif
+
+#ifndef TRINITY_API_USE_DYNAMIC_LINKING
+#  define TRINITY_LINKAGE_TYPE_STR "Static"
 #else
-    return _PACKAGENAME " rev. " VER_PRODUCTVERSION_STR " (Unix, " _BUILD_DIRECTIVE ")";
+#  define TRINITY_LINKAGE_TYPE_STR "Dynamic"
 #endif
+
+char const* GitRevision::GetFullVersion()
+{
+  return "TrinityCore rev. " VER_PRODUCTVERSION_STR
+    " (" TRINITY_PLATFORM_STR ", " _BUILD_DIRECTIVE ", " TRINITY_LINKAGE_TYPE_STR ")";
 }
 
 char const* GitRevision::GetCompanyNameStr()
diff --git a/src/common/Utilities/EventProcessor.cpp b/src/common/Utilities/EventProcessor.cpp
index be74d58b790..2341d0a0872 100644
--- a/src/common/Utilities/EventProcessor.cpp
+++ b/src/common/Utilities/EventProcessor.cpp
@@ -17,11 +17,20 @@
  */
 
 #include "EventProcessor.h"
+#include "Errors.h"
 
-EventProcessor::EventProcessor()
+void BasicEvent::ScheduleAbort()
 {
-    m_time = 0;
-    m_aborting = false;
+    ASSERT(IsRunning()
+           && "Tried to scheduled the abortion of an event twice!");
+    m_abortState = AbortState::STATE_ABORT_SCHEDULED;
+}
+
+void BasicEvent::SetAborted()
+{
+    ASSERT(!IsAborted()
+           && "Tried to abort an already aborted event!");
+    m_abortState = AbortState::STATE_ABORTED;
 }
 
 EventProcessor::~EventProcessor()
@@ -39,55 +48,73 @@ void EventProcessor::Update(uint32 p_time)
     while (((i = m_events.begin()) != m_events.end()) && i->first <= m_time)
     {
         // get and remove event from queue
-        BasicEvent* Event = i->second;
+        BasicEvent* event = i->second;
         m_events.erase(i);
 
-        if (!Event->to_Abort)
+        if (event->IsRunning())
         {
-            if (Event->Execute(m_time, p_time))
+            if (event->Execute(m_time, p_time))
             {
                 // completely destroy event if it is not re-added
-                delete Event;
+                delete event;
             }
+            continue;
         }
-        else
+
+        if (event->IsAbortScheduled())
         {
-            Event->Abort(m_time);
-            delete Event;
+            event->Abort(m_time);
+            // Mark the event as aborted
+            event->SetAborted();
         }
+
+        if (event->IsDeletable())
+        {
+            delete event;
+            continue;
+        }
+
+        // Reschedule non deletable events to be checked at
+        // the next update tick
+        AddEvent(event, CalculateTime(1), false);
     }
 }
 
 void EventProcessor::KillAllEvents(bool force)
 {
-    // prevent event insertions
-    m_aborting = true;
-
-    // first, abort all existing events
-    for (EventList::iterator i = m_events.begin(); i != m_events.end();)
+    for (auto itr = m_events.begin(); itr != m_events.end();)
     {
-        EventList::iterator i_old = i;
-        ++i;
-
-        i_old->second->to_Abort = true;
-        i_old->second->Abort(m_time);
-        if (force || i_old->second->IsDeletable())
+        // Abort events which weren't aborted already
+        if (!itr->second->IsAborted())
         {
-            delete i_old->second;
+            itr->second->SetAborted();
+            itr->second->Abort(m_time);
+        }
 
-            if (!force)                                      // need per-element cleanup
-                m_events.erase (i_old);
+        // Skip non-deletable events when we are
+        // not forcing the event cancellation.
+        if (!force && !itr->second->IsDeletable())
+        {
+            ++itr;
+            continue;
         }
+
+        delete itr->second;
+
+        if (force)
+            ++itr; // Clear the whole container when forcing
+        else
+            itr = m_events.erase(itr);
     }
 
-    // fast clear event list (in force case)
     if (force)
         m_events.clear();
 }
 
 void EventProcessor::AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime)
 {
-    if (set_addtime) Event->m_addTime = m_time;
+    if (set_addtime)
+        Event->m_addTime = m_time;
     Event->m_execTime = e_time;
     m_events.insert(std::pair<uint64, BasicEvent*>(e_time, Event));
 }
@@ -96,4 +123,3 @@ uint64 EventProcessor::CalculateTime(uint64 t_offset) const
 {
     return(m_time + t_offset);
 }
-
diff --git a/src/common/Utilities/EventProcessor.h b/src/common/Utilities/EventProcessor.h
index e10558e6a21..57f3065f323 100644
--- a/src/common/Utilities/EventProcessor.h
+++ b/src/common/Utilities/EventProcessor.h
@@ -20,20 +20,27 @@
 #define __EVENTPROCESSOR_H
 
 #include "Define.h"
-
 #include <map>
 
+class EventProcessor;
+
 // Note. All times are in milliseconds here.
 
 class TC_COMMON_API BasicEvent
 {
+        friend class EventProcessor;
+
+        enum class AbortState : uint8
+        {
+            STATE_RUNNING,
+            STATE_ABORT_SCHEDULED,
+            STATE_ABORTED
+        };
+
     public:
         BasicEvent()
-        {
-            to_Abort = false;
-            m_addTime = 0;
-            m_execTime = 0;
-        }
+          : m_abortState(AbortState::STATE_RUNNING), m_addTime(0), m_execTime(0) { }
+
         virtual ~BasicEvent() { }                           // override destructor to perform some actions on event removal
 
         // this method executes when the event is triggered
@@ -45,8 +52,16 @@ class TC_COMMON_API BasicEvent
 
         virtual void Abort(uint64 /*e_time*/) { }           // this method executes when the event is aborted
 
-        bool to_Abort;                                      // set by externals when the event is aborted, aborted events don't execute
-        // and get Abort call when deleted
+        // Aborts the event at the next update tick
+        void ScheduleAbort();
+
+    private:
+        void SetAborted();
+        bool IsRunning() const { return (m_abortState == AbortState::STATE_RUNNING); }
+        bool IsAbortScheduled() const { return (m_abortState == AbortState::STATE_ABORT_SCHEDULED); }
+        bool IsAborted() const { return (m_abortState == AbortState::STATE_ABORTED); }
+
+        AbortState m_abortState;                            // set by externals when the event is aborted, aborted events don't execute
 
         // these can be used for time offset control
         uint64 m_addTime;                                   // time when the event was added to queue, filled by event handler
@@ -58,16 +73,17 @@ typedef std::multimap<uint64, BasicEvent*> EventList;
 class TC_COMMON_API EventProcessor
 {
     public:
-        EventProcessor();
+        EventProcessor() : m_time(0) { }
         ~EventProcessor();
 
         void Update(uint32 p_time);
         void KillAllEvents(bool force);
         void AddEvent(BasicEvent* Event, uint64 e_time, bool set_addtime = true);
         uint64 CalculateTime(uint64 t_offset) const;
+
     protected:
         uint64 m_time;
         EventList m_events;
-        bool m_aborting;
 };
+
 #endif