MultiverseAPI - Memory Manager

    class MULTIVERSE_API MemoryManager {
    public:

        // -- Resolves the address of a LEA instruction --
        // Param 1: Address of LEA instruction
        static uintptr_t ResolveLeaAddress(uintptr_t leaAddress);

        // -- Resolves the address of a CALL instruction --
        // Param 1: Address of CALL instruction
        static uintptr_t ResolveCallAddress(uintptr_t addressOfCall);

        // -- Resolves a relative address --
        // Param 1: Address of relative instruction
        static uintptr_t ResolveRelativeAddress(uintptr_t relativeAddress);

        // -- Returns the value of an Address --
        // Param 1: Memory Address
        template <typename T>
        static T Dereference(T address) {
            return *(T*)address;
        }

        /// -- Dereference a multi-level pointer -
        // Param 1: basePointerAddress
        // Param 2: The Offsets of the Multi-level pointer
        // Param 3: The level of the Multi-level pointer
        static uintptr_t DerefMultiLevelPointer(uintptr_t basePointerAddress, uintptr_t offsets[], int pointerLevel);

        /// - NOP (No Operation) Bytes Internally (Useful for internal hacks) -
        // Param 1: Memory Address
        // Param 2: Size of bytes to NOP
        static void NopInternal(char* address, unsigned int size);

        /// - NOP (No Operation) Bytes Externally (Useful for external hacks) -
        // Param 1: Memory Address
        // Param 2: Size of bytes to NOP
        static void NopExternal(char* address, unsigned int size, HANDLE processHandle);

        /// - Clears a String in memory -
        // Param 1: address - Memory Address of String
        // Param 2: stringLength - (Number of Characters in String to clear)
        static void ClearString(uintptr_t address, SIZE_T stringLength);

        // - Sets/Writes Bytes in Memory ( useful for patching instructions, etc... ) -
        // Param 1: Memory Address - Starting Point
        // Param 2: int/hex value to write (for patching)
        // Param 3: Size of bytes to copy the value of Param 2 to
        static void WriteBytes(uintptr_t address, int value, SIZE_T size);

        // - Sets/Writes Bytes in Memory ( useful for patching instructions, etc... ) -
        // Param 1: Memory Address - Starting Point
        // Param 2: bytes values to write (for patching) - eg. { 0xE2, 0xA7, 0x36, 0xC0 }
        static void WriteBytes(uintptr_t address, std::vector<unsigned int> value);

        /// - Sets/Writes a string to memory -
        // Param 1: Memory Address
        // Param 2: String to write
        static void WriteString(char* address, char* newString);

        /// - Reads a string from memory -
        // Param 1: Memory Address of String
        static char* ReadString(uintptr_t address);

        // -- Compares Two String Values in memory against each other --
        // Param 1: Memory Address of String
        // Param 2: String to search for to compare
        static bool StringCompare(char* address, const char* stringToCompareAgainst);

        // -- Compares Two String Values in memory against each other --
        // Param 1: Memory Address of String
        // Param 2: Offset to Accumulate with address (use 0x0 for no additional offset)
        // Param 3: String to search for to compare
        static bool StringCompare(char* address, int offset, const char* stringToCompareAgainst);

        // -- Compares Two String Values in memory against each other --
        // Param 1: Memory Address of String
        // Param 2: Offset to Accumulate with address (use 0x0 for no additional offset)
        // Param 3: OffsetEnum::Add = Increment Offset | OffsetEnum::Subtract = Decrement Offset
        // Param 4: String to search for to compare
        static bool StringCompare(char* address, int offset, OffsetEnum offsetEnum, const char* stringToCompareAgainst);

        // -- Compare Two Memory Values against each other --
        // Param 1: Memory Address
        // Param 2: Offset to Accumulate with address (use 0x0 for no additional offset)
        // Param 3: OffsetEnum::Add = Increment Offset | OffsetEnum::Subtract = Decrement Offset
        // Param 4: Value to search for
        template <typename T>
        static bool CompareMemoryValue(uintptr_t address, int offset, OffsetEnum offsetEnum, T value) {

            uintptr_t addressWithOffset{};

            if (offsetEnum = OffsetEnum::Add)
                addressWithOffset = (uintptr_t)address + offset;

            if (offsetEnum = OffsetEnum::Subtract)
                addressWithOffset = (uintptr_t)address - offset;

            if (*(T*)(addressWithOffset) == (T)value)
                return true;
            else
                return false;
        }

        // -- Alters protection flags at a memory location & writes to it --
        // Param 1: Memory Address
        // Param 2: size of dataType
        // Param 3: Value to write
        template <typename T>
        void WriteMemSafe(uintptr_t address, const int blockSize, T value) {

            DWORD oldProtect{};
            if (VirtualProtect((LPVOID)address, blockSize, PAGE_EXECUTE_READWRITE, &oldProtect)) {
                *(uintptr_t*)(address) = value;
            }
        }

        // -- Alters protection flags at a memory location & writes to it --
        // Param 1: Memory Address
        // Param 2: the number of bytes to jump after the address of Param 1
        // Param 3: size of dataType
        // Param 4: Value to write
        template <typename T>
        void WriteMemSafe(uintptr_t address, const int offset, const int blockSize, T value) {

            DWORD oldProtect{};
            if (VirtualProtect((LPVOID)address + offset, blockSize, PAGE_EXECUTE_READWRITE, &oldProtect)) {
                *(uintptr_t*)(address)+offset = value;
            }
        }

        // - Sets/Writes a value to a memory address -
        // Param 1: Memory Address
        // Param 2: Value to set
        template <typename T>
        static uintptr_t SetValue(uintptr_t address, T valueToSet) {
            //memory.write<T>(address, valueToSet); // External
            *(T*)address = valueToSet;
            return address;
        }

        // - Sets/Writes a colour to a memory addresses -
        // Param 1: address - memory address of Colour
        // Param 2: Colour to set - eg. #B0807D49
        static uintptr_t SetColour(uintptr_t address, std::string colourToSet);

        // - Sets/Writes to the memory addresses of a 'Float Array' -
        // Param 1: Address - The address of the float Array
        // Param 2: value to set - eg. { 1.f, 2.f, 3.f, 4.f }
        static void WriteFloatArray(uintptr_t address, std::vector<float> valueToSet);

        // - Sets/Writes to the memory addresses of an 'Int Array' -
        // Param 1: Address - The address of the Int Array
        // Param 2: value to set - eg. { 1, 2, 3, 4 }
        static void WriteIntArray(uintptr_t address, std::vector<int> valueToSet);

        // - Sets/Writes to the memory addresses of a 'Bool Array' -
        // Param 1: Address - The address of the Bool Array
        // Param 2: value to set - eg. { false, true, false, true }
        static void WriteBoolArray(uintptr_t address, std::vector<bool> valueToSet);

        // - Gets the memory addresses of a 'Colour' in memory -
        // Param 1: address - memory address of Colour
        static std::string GetHexColour(uintptr_t address);

        // - Logs a hooked function's parameter, for a specified number of cycles o -
        // Param 1: functionName (user defined)
        // Param 2: argumentName (user defined)
        // Param 3: numberOfCycles - The number of cycles to be run through the hook that calls this function (user defined)
        // Param 4: argument - the argument to print
        // Param 5: printInHexadecimal: Whether to print in hex or not
        template <typename T>
        void PrintHookArgument(const char* functionName, const char* argumentName, int numberOfCycles, T argument, bool printInHexadecimal) {

            static int cycle{};
            if (cycle <= numberOfCycles && printInHexadecimal)
                std::cout << argumentName << " of cycle " << cycle << " in " << functionName << " is: " << std::hex << argument << std::endl;

            if (cycle <= numberOfCycles && !printInHexadecimal)
                std::cout << argumentName << " of cycle " << cycle << " in " << functionName << " is: " << argument << std::endl;
            cycle++;
        }

    };
    inline MemoryManager g_MemoryManager;