feat: add MenuConsole and related classes

Author: shad0wshayd3

include/RE/B/BSStringT.h

@@ -4,90 +4,15 @@
 
 namespace RE
 {
-	template <class T, std::uint32_t N>
-	class DynamicMemoryManagementPol
-	{
-	public:
-		using value_type = T;
-
-		constexpr DynamicMemoryManagementPol() noexcept = default;
-		DynamicMemoryManagementPol(const DynamicMemoryManagementPol&) = default;
-		DynamicMemoryManagementPol(DynamicMemoryManagementPol&&) = default;
-		~DynamicMemoryManagementPol() = default;
-
-		DynamicMemoryManagementPol& operator=(const DynamicMemoryManagementPol&) = default;
-		DynamicMemoryManagementPol& operator=(DynamicMemoryManagementPol&&) = default;
-
-		[[nodiscard]] value_type* allocate(std::uint32_t a_num)
-		{
-			if (a_num > N) {
-				return 0;
-			}
-
-			auto size = a_num * sizeof(value_type);
-			auto mem = malloc<value_type>(size);
-			std::memset(mem, 0, size);
-			return mem;
-		}
-
-		void deallocate(value_type* a_ptr) { free(a_ptr); }
-	};
-
-	template <class T, std::uint32_t N>
-	class FixedLengthMemoryManagementPol
-	{
-	public:
-		using value_type = T;
-
-		constexpr FixedLengthMemoryManagementPol() noexcept = default;
-
-		FixedLengthMemoryManagementPol(const FixedLengthMemoryManagementPol& a_rhs) { copy_from(a_rhs); }
-		FixedLengthMemoryManagementPol(FixedLengthMemoryManagementPol&& a_rhs) { copy_from(a_rhs); }
-
-		~FixedLengthMemoryManagementPol() = default;
-
-		FixedLengthMemoryManagementPol& operator=(const FixedLengthMemoryManagementPol& a_rhs)
-		{
-			if (this != std::addressof(a_rhs)) {
-				copy_from(a_rhs);
-			}
-			return *this;
-		}
-
-		FixedLengthMemoryManagementPol& operator=(FixedLengthMemoryManagementPol&& a_rhs)
-		{
-			if (this != std::addressof(a_rhs)) {
-				copy_from(a_rhs);
-			}
-			return *this;
-		}
-
-		[[nodiscard]] value_type* allocate(std::uint32_t a_num)
-		{
-			return a_num > N ? 0 : _buffer;
-		}
-
-		void deallocate(value_type*) { return; }
-
-	private:
-		void copy_from(const FixedLengthMemoryManagementPol& a_rhs)
-		{
-			std::memcpy(_buffer, a_rhs._buffer, sizeof(value_type) * N);
-		}
-
-		value_type _buffer[N]{ 0 };  // 00
-	};
-
-	template <class CharT, std::uint32_t N, template <class, std::uint32_t> class Allocator>
-	class BSStringT : public Allocator<CharT, N>
+	template <class CharT>
+	class BSStringT
 	{
 	private:
-		static constexpr auto MAX = static_cast<std::uint16_t>(N);
+		static constexpr auto MAX{ static_cast<std::uint16_t>(-1) };
 
 	public:
 		using value_type = CharT;
 		using traits_type = std::char_traits<value_type>;
-		using allocator_type = Allocator<value_type, N>;
 		using size_type = std::uint16_t;
 		using reference = value_type&;
 		using const_reference = const value_type&;
@@ -99,14 +24,12 @@ namespace RE
 			clear();
 		}
 
-		BSStringT(const BSStringT& a_rhs) :
-			allocator_type(a_rhs)
+		BSStringT(const BSStringT& a_rhs)
 		{
 			set_cstr(a_rhs.c_str());
 		}
 
 		BSStringT(BSStringT&& a_rhs) :
-			allocator_type(std::move(a_rhs)),
 			_data(a_rhs._data),
 			_size(a_rhs._size),
 			_capacity(a_rhs._capacity)
@@ -135,7 +58,6 @@ namespace RE
 		BSStringT& operator=(const BSStringT& a_rhs)
 		{
 			if (this != std::addressof(a_rhs)) {
-				static_cast<allocator_type&>(*this) = a_rhs;
 				set_cstr(a_rhs.c_str());
 			}
 			return *this;
@@ -144,8 +66,6 @@ namespace RE
 		BSStringT& operator=(BSStringT&& a_rhs)
 		{
 			if (this != std::addressof(a_rhs)) {
-				static_cast<allocator_type&>(*this) = std::move(a_rhs);
-
 				_data = a_rhs._data;
 				a_rhs._data = nullptr;
 
@@ -225,19 +145,29 @@ namespace RE
 
 		[[nodiscard]] static int strnicmp(const wchar_t* a_lhs, const wchar_t* a_rhs, std::size_t len) { return _wcsnicmp(a_lhs, a_rhs, len); }
 
-		[[nodiscard]] pointer allocate(std::uint32_t a_num) { return allocator_type::allocate(a_num); }
+		[[nodiscard]] pointer allocate(size_type a_num)
+		{
+			if (a_num > MAX) {
+				return 0;
+			}
+
+			auto size = a_num * sizeof(value_type);
+			auto mem = malloc<value_type>(size);
+			std::memset(mem, 0, size);
+			return mem;
+		}
 
-		void deallocate(pointer a_ptr) { allocator_type::deallocate(a_ptr); }
+		void deallocate(pointer a_ptr) { free(a_ptr); }
 
-		bool set_cstr(const_pointer a_str, std::uint32_t a_len = 0)
+		bool set_cstr(const_pointer a_str, size_type a_len = 0)
 		{
-			auto len = static_cast<std::uint16_t>(a_len);
+			auto len = static_cast<size_type>(a_len);
 			if (_data == a_str) {
 				return true;
 			}
 
 			if (len == 0) {
-				len = static_cast<std::uint16_t>(traits_type::length(a_str));
+				len = static_cast<size_type>(traits_type::length(a_str));
 			}
 
 			const size_type newSize = len > MAX ? MAX : len;
@@ -269,12 +199,18 @@ namespace RE
 		static constexpr value_type EMPTY[]{ 0 };
 
 		// members
-		pointer       _data{ nullptr };  // ?? (00)
-		size_type     _size{ 0 };        // ?? (08)
-		size_type     _capacity{ 0 };    // ?? (0A)
-		std::uint32_t _pad0C{ 0 };       // ?? (0C)
+		pointer       _data{ nullptr };  // 00
+		size_type     _size{ 0 };        // 08
+		size_type     _capacity{ 0 };    // 0A
+		std::uint32_t _pad0C{ 0 };       // 0C
 	};
 
-	using BSString = BSStringT<char, static_cast<std::uint32_t>(-1), DynamicMemoryManagementPol>;
+	using BSString = BSStringT<char>;
 	static_assert(sizeof(BSString) == 0x10);
+
+	using BSStringC = BSStringT<char>;
+	static_assert(sizeof(BSStringC) == 0x10);
+
+	using BSStringW = BSStringT<wchar_t>;
+	static_assert(sizeof(BSStringW) == 0x10);
 }

include/RE/IDs.h

@@ -12,6 +12,12 @@ namespace RE::ID
 		inline constexpr REL::Offset Singleton{ 0x8FE1E10 };
 	}
 
+	namespace MenuConsole
+	{
+		inline constexpr REL::Offset Instance{ 0x665C360 };
+		inline constexpr REL::Offset PrintLine{ 0x665C580 };
+	}
+
 	namespace Setting
 	{
 		inline constexpr REL::Offset SetString{ 0x6710B70 };

include/RE/M/MenuConsole.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "RE/B/BSStringT.h"
+#include "RE/N/NiTList.h"
+
+namespace RE
+{
+	class ScriptCompiler;
+
+	class MenuConsole
+	{
+	public:
+		static MenuConsole* Instance(bool a_create)
+		{
+			using func_t = decltype(&MenuConsole::Instance);
+			static REL::Relocation<func_t> func{ ID::MenuConsole::Instance };
+			return func(a_create);
+		}
+
+		void PrintLine(const char* a_string, va_list a_args)
+		{
+			using func_t = void(MenuConsole::*)(const char*, va_list);
+			static REL::Relocation<func_t> func{ ID::MenuConsole::PrintLine };
+			return func(this, a_string, a_args);
+		}
+
+		void PrintLine(const char* a_string, ...)
+		{
+			va_list args;
+			va_start(args, a_string);
+			PrintLine(a_string, args);
+			va_end(args);
+		}
+
+		// members
+		ScriptCompiler* consoleCompiler;
+		NiTList<BSString> strings;
+		NiTList<BSString> inputs;
+		std::int32_t inputsPos;
+		std::int32_t numStrings;
+		std::int32_t lastString;
+		bool lastMenuMode;
+		std::uint8_t visible;
+		bool isActive;
+	};
+	static_assert(sizeof(MenuConsole) == 0x58);
+}

include/RE/N/NiTList.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include "RE/N/NiTDefaultAllocator.h"
+#include "RE/N/NiTPointerListBase.h"
+
+namespace RE
+{
+    template <class T>
+	class NiTList :
+		public NiTPointerListBase<NiTDefaultAllocator<T>, T>
+	{
+	public:
+		// override
+		virtual ~NiTList();  // 00
+	};
+	static_assert(sizeof(NiTList<void*>) == 0x20);
+}

include/RE/N/NiTListBase.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "RE/N/NiTDefaultAllocator.h"
+#include "RE/N/NiTListItem.h"
+
+namespace RE
+{
+    template <class Allocator, class T>
+	class NiTListBase
+	{
+	public:
+		struct AntiBloatAllocator
+		{
+		public:
+			// members
+			std::uint32_t count;  // 00
+		};
+		static_assert(sizeof(AntiBloatAllocator) == 0x04);
+
+		// add
+		virtual ~NiTListBase();                        // 00
+		virtual NiTListItem<T>* NewItem() = 0;         // 01
+		virtual void DeleteItem(NiTListItem<T>*) = 0;  // 02
+
+		// members
+		NiTListItem<T>* head;                       // 08
+		NiTListItem<T>* tail;                       // 10
+		NiTListBase::AntiBloatAllocator allocator;  // 18
+	};
+	static_assert(sizeof(NiTListBase<NiTDefaultAllocator<void*>, void*>) == 0x20);
+}

include/RE/N/NiTListItem.h

@@ -0,0 +1,15 @@
+#pragma once
+
+namespace RE
+{
+    template <class T>
+    class NiTListItem
+    {
+    public:
+        // members
+        NiTListItem<T>* next;  // 00
+        NiTListItem<T>* prev;  // 08
+        T element;             // 10
+    };
+    static_assert(sizeof(NiTListItem<void*>) == 0x18);
+}

include/RE/N/NiTPointerListBase.h

@@ -0,0 +1,20 @@
+#pragma once
+
+#include "RE/N/NiTDefaultAllocator.h"
+#include "RE/N/NiTListBase.h"
+#include "RE/N/NiTListItem.h"
+
+namespace RE
+{
+    template <class Allocator, class T>
+	class NiTPointerListBase :
+		public NiTListBase<Allocator, T>
+	{
+	public:
+		// override
+		virtual ~NiTPointerListBase();                      // 00
+		virtual NiTListItem<T>* NewItem() override;         // 01
+		virtual void DeleteItem(NiTListItem<T>*) override;  // 02
+	};
+	static_assert(sizeof(NiTPointerListBase<NiTDefaultAllocator<void*>, void*>) == 0x20);
+}