Add QueueClass, replace EventList and EventClass::AddEvent

Author: ZivDero

EventClass.h

@@ -1,53 +1,32 @@
 #pragma once
 
 #include <ScenarioClass.h>
+#include <QueueClass.h>
 #include <TargetClass.h>
 #include <Unsorted.h>
 
 #pragma pack(push, 1)
-
-class EventClass;
-
-template<size_t Length>
-struct EventList
-{
-public:
-	int Count;
-	int Head;
-	int Tail;
-	EventClass List[Length];
-	int Timings[Length];
-};
-
 class EventClass
 {
 public:
 	DEFINE_ARRAY_REFERENCE(const char*, [47], EventNames, 0x0082091C)
 
-	DEFINE_REFERENCE(EventList<0x80>, OutList, 0x00A802C8)
-	DEFINE_REFERENCE(EventList<0x4000>, DoList, 0x008B41F8)
+	enum { MAX_EVENTS = 128 };
 
-	// If the event is a MegaMission, then add it to this list
-	DEFINE_REFERENCE(EventList<0x100>, MegaMissionList, 0x00A83ED0)
+	DEFINE_REFERENCE((QueueClass<EventClass, MAX_EVENTS>), OutList, 0x00A802C8)
+	DEFINE_REFERENCE((QueueClass<EventClass, MAX_EVENTS * 128>), DoList, 0x008B41F8)
+
+	// Seems to be some queue used internally, not added to from outside Execute_DoList
+	//DEFINE_REFERENCE((QueueClass<EventClass, MAX_EVENTS * 2>), SomeList, 0x00A83ED0)
 
 	// this points to CRCs from 0x100 last frames
 	DEFINE_ARRAY_REFERENCE(DWORD, [256], LatestFramesCRC, 0x00B04474)
 	DEFINE_REFERENCE(DWORD, CurrentFrameCRC, 0x00AC51FC)
 
+	[[deprecated("Use OutList.Add() instead.")]]
 	static bool AddEvent(const EventClass& event)
 	{
-		if (OutList.Count >= 128)
-			return false;
-
-		OutList.List[OutList.Tail] = event;
-
-#pragma warning(suppress: 4996)
-		OutList.Timings[OutList.Tail] = static_cast<int>(Imports::TimeGetTime()());
-
-		++OutList.Count;
-		OutList.Tail = (LOBYTE(OutList.Tail) + 1) & 127;
-
-		return true;
+		return OutList.Add(event);
 	}
 
 	explicit EventClass(int houseIndex, EventType eventType)

QueueClass.h

@@ -0,0 +1,139 @@
+/*******************************************************************************
+/*                     O P E N  S O U R C E  --  T S + +                      **
+/*******************************************************************************
+ *
+ *  @project       TS++
+ *
+ *  @file          QUEUE.H
+ *
+ *  @authors       CCHyper, ZivDero (adjustments for YR)
+ *
+ *  @brief         FIFO queue for events.
+ *
+ *  @license       TS++ 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
+ *                 3 of the License, or (at your option) any later version.
+ *
+ *                 TS++ 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/>.
+ *
+ ******************************************************************************/
+#pragma once
+
+#include <Unsorted.h>
+
+
+template<class T, int size>
+class QueueClass
+{
+public:
+	QueueClass();
+	~QueueClass() { }
+
+	T& operator[](int index);
+
+	T& First();
+	void Init();
+	int Next();
+	bool Add(const T& q);
+
+	int GetHead();
+	int GetTail();
+	T* GetArray();
+
+public:
+	int Count;
+
+private:
+	int Head;
+	int Tail;
+	T Array[size];
+	int Timings[size];
+};
+
+
+template<class T, int size>
+inline QueueClass<T, size>::QueueClass() :
+	Count(0)
+{
+	Init();
+}
+
+
+template<class T, int size>
+inline void QueueClass<T, size>::Init()
+{
+	Count = 0;
+	Head = 0;
+	Tail = 0;
+}
+
+
+template<class T, int size>
+inline bool QueueClass<T, size>::Add(const T& q)
+{
+	if (Count < size)
+	{
+		Array[Tail] = q;
+		#pragma warning(suppress: 4996)
+		Timings[Tail] = static_cast<int>(Imports::TimeGetTime()());
+		Tail = (Tail + 1) & (size - 1);
+		Count = Count + 1;
+		return true;
+	}
+	return false;
+}
+
+
+template<class T, int size>
+inline int QueueClass<T, size>::Next()
+{
+	if (Count)
+	{
+		Head = (Head + 1) & (size - 1);
+		Count = Count - 1;
+	}
+	return Count;
+}
+
+
+template<class T, int size>
+inline T& QueueClass<T, size>::operator[](int index)
+{
+	return Array[(Head + index) & (size - 1)];
+}
+
+
+template<class T, int size>
+inline T& QueueClass<T, size>::First()
+{
+	return Array[Head];
+}
+
+
+template<class T, int size>
+inline int QueueClass<T, size>::GetHead()
+{
+	return Head;
+}
+
+
+template<class T, int size>
+inline int QueueClass<T, size>::GetTail()
+{
+	return Tail;
+}
+
+
+template<class T, int size>
+inline T* QueueClass<T, size>::GetArray()
+{
+	return Array;
+}