[MOD] Community Code/Offset List - 1.8.5

using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Globalization;
using System.Linq;
using System.Runtime.InteropServices;
using System.Text;

namespace XeClutch
{
    class MemoryHelper
    {
        // Structures
        public struct Vector3
        {
            public float x, y, z;
        }

        // Variables
        public bool m_Attached;
        public IntPtr m_Handle;
        public Process m_Process;
        public string m_ProcessName;

        // Kernel Imports
        [DllImport("kernel32.dll")]
        static extern bool ReadProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, [Out] byte[] lpBuffer, int dwSize, out int lpNumberOfBytesRead);
        [DllImport("kernel32.dll")]
        static extern bool WriteProcessMemory(IntPtr hProcess, IntPtr lpBaseAddress, byte[] lpBuffer, int nSize, out int lpNumberOfBytesWritten);
        [DllImport("kernel32.dll")]
        static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId);
        [DllImport("kernel32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool CloseHandle(IntPtr hObject);

        // Constructor
        public MemoryHelper(string szProcessName)
        {
            m_Attached = false;
            m_Handle = IntPtr.Zero;
            m_Process = null;
            m_ProcessName = szProcessName;
        }

        // Methods
        public bool Attach(int AccessFlag)
        {
            Process[] processes = Process.GetProcessesByName(m_ProcessName);
            if (processes.Length != 1)
                return (m_Attached = false);
            m_Process = processes[0];
            m_Handle = OpenProcess((int)AccessFlag, true, m_Process.Id);
            return (m_Attached = true);
        }
        public bool Detach()
        {
            try
            {
                CloseHandle(m_Handle);
                return true;
            }
            catch
            {
                return false;
            }
        }
        public void PatchCall(uint address, uint calladdress)
        {
            byte[] final = { 0xE8, 0x00, 0x00, 0x00, 0x00 };
            uint buffer = 0xFFFFFFFF - (address - calladdress);
            if (calladdress > (address - 5))
                buffer = calladdress - (address + 5);
            Array.Copy(BitConverter.GetBytes(buffer), 0, final, 1, 4);
            WriteBytes(address, final);
        }
        public void PatchJump(uint address, uint jumpaddress)
        {
            byte[] final = { 0xE9, 0x00, 0x00, 0x00, 0x00 };
            uint buffer = 0xFFFFFFFF - (address - jumpaddress);
            if (jumpaddress > (address - 5))
                buffer = jumpaddress - (address + 5);
            Array.Copy(BitConverter.GetBytes(buffer), 0, final, 1, 4);
            WriteBytes(address, final);
        }
        public byte ReadByte(uint address)
        {
            return ReadBytes(address, 1)[0];
        }
        public byte[] ReadBytes(uint address, int len)
        {
            int buffer = 0;
            byte[] output = new byte[len];
            bool worked = ReadProcessMemory(m_Handle, (IntPtr)address, output, len, out buffer);
            int err = Marshal.GetLastWin32Error();
            return output;
        }
        public float ReadFloat(uint address)
        {
            return BitConverter.ToSingle(ReadBytes(address, 4), 0);
        }
        public string ReadString(uint address, int len)
        {
            return Encoding.ASCII.GetString(ReadBytes(address, len));
        }
        public uint ReadUInt32(uint address)
        {
            return BitConverter.ToUInt32(ReadBytes(address, 4), 0);
        }
        public Vector3 ReadVector3(uint address)
        {
            Vector3 ret;
            ret.x = ReadFloat(address);
            ret.y = ReadFloat(address + 4);
            ret.z = ReadFloat(address + 8);
            return ret;
        }
        public uint SearchBytes(uint address, int len, byte[] data)
        {
            byte[] bytes = ReadBytes(address, len);
            string bytestosearch = "";
            string bytesscanning = "";
            foreach (byte b in data)
                bytestosearch += b.ToString("X2");
            for (uint i = 0; i < (len - data.Length); i++)
            {
                bytesscanning = "";
                for (int j = 0; j < data.Length; i++)
                    bytesscanning += bytes[i + j].ToString("X2");
                if (bytesscanning == bytestosearch)
                    return address + i;
            }
            return 0;
        }
        public uint SearchFloat(uint address, int len, float data)
        {
            return SearchBytes(address, len, BitConverter.GetBytes(data));
        }
        public uint SearchString(uint address, int len, string data)
        {
            return SearchBytes(address, len, Encoding.ASCII.GetBytes(data));
        }
        public uint SearchUInt32(uint address, int len, uint data)
        {
            return SearchBytes(address, len, BitConverter.GetBytes(data));
        }
        public void WriteByte(uint address, byte data)
        {
            WriteBytes(address, new byte[] { data });
        }
        public void WriteBytes(uint address, byte[] data)
        {
            int buffer = 0;
            WriteProcessMemory(m_Handle, (IntPtr)address, data, data.Length, out buffer);
        }
        public void WriteFloat(uint address, float data)
        {
            WriteBytes(address, BitConverter.GetBytes(data));
        }
        public void WriteNOP(uint address, int len)
        {
            byte[] nop = new byte[len];
            for (int i = 0; i < len; i++)
                nop[i] = 0x90;
            WriteBytes(address, nop);
        }
        public void WriteString(uint address, string data)
        {
            WriteBytes(address, Encoding.ASCII.GetBytes(data));
        }
        public void WriteUInt32(uint address, uint data)
        {
            WriteBytes(address, BitConverter.GetBytes(data));
        }
        public void WriteVector3(uint address, Vector3 data)
        {
            WriteFloat(address, data.x);
            WriteFloat(address + 4, data.y);
            WriteFloat(address + 8, data.z);
        }
    }
}