private int CalculatePointer(int iMemoryAddress, int[] iOffsets)
{
int num = iOffsets.Length - 1;
byte[] bBuffer = new byte[4];
int num2 = 0;
if (num == 0)
{
num2 = iMemoryAddress;
}
for (int i = 0; i <= num; i++)
{
IntPtr ptr;
if (i == num)
{
MAPI.ReadProcessMemory(this.hReadProcess, (IntPtr)num2, bBuffer, 4, out ptr);
return(this.Dec(this.CreateAddress(bBuffer)) + iOffsets[i]);
}
if (i == 0)
{
MAPI.ReadProcessMemory(this.hReadProcess, (IntPtr)iMemoryAddress, bBuffer, 4, out ptr);
num2 = this.Dec(this.CreateAddress(bBuffer)) + iOffsets[0];
}
else
{
MAPI.ReadProcessMemory(this.hReadProcess, (IntPtr)num2, bBuffer, 4, out ptr);
num2 = this.Dec(this.CreateAddress(bBuffer)) + iOffsets[i];
}
}
return(0);
}
} /*
* private string CreateAddress(byte[] pBytes)
* {
* string sAddress = "";
*
* for (int i = 0; i < pBytes.Length; i++)
* {
* Console.WriteLine(String.Format("pBytes[{0}] = {1}, sAddress = {2}", i, pBytes[i], sAddress));
* sAddress = (pBytes[i] < 17) ? (String.Format("0{0}{1}", pBytes[i].ToString("X"), sAddress)) : (pBytes[i].ToString("X") + sAddress);
* }
* return sAddress;
* } */
//Calculate Pointer
private int CalculatePointer(int iMemoryAddress, int[] iOffsets)
{
int iPointerCount = iOffsets.Length - 1; IntPtr ptrBytesRead; byte[] bBuffer = new byte[4]; int iTemporaryAddress = 0;
if (iPointerCount == 0)
{
iTemporaryAddress = iMemoryAddress;
}
for (int i = 0; i <= iPointerCount; i++)
{
if (i == iPointerCount)
{
MAPI.ReadProcessMemory(hReadProcess, (IntPtr)iTemporaryAddress, bBuffer, 4, out ptrBytesRead);
iTemporaryAddress = Dec(CreateAddress(bBuffer)) + iOffsets[i];
return(iTemporaryAddress);
}
else if (i == 0)
{
MAPI.ReadProcessMemory(hReadProcess, (IntPtr)iMemoryAddress, bBuffer, 4, out ptrBytesRead);
iTemporaryAddress = Dec(CreateAddress(bBuffer)) + iOffsets[0];
}
else
{
MAPI.ReadProcessMemory(hReadProcess, (IntPtr)iTemporaryAddress, bBuffer, 4, out ptrBytesRead);
iTemporaryAddress = Dec(CreateAddress(bBuffer)) + iOffsets[i];
}
}
return(0);
}
//Write to Address
public bool Write(int iMemoryAddress, byte bByteToWrite)
{
byte[] bBuffer = { bByteToWrite }; IntPtr ptrBytesWritten;
MAPI.WriteProcessMemory(hReadProcess, (IntPtr)iMemoryAddress, bBuffer, 1, out ptrBytesWritten);
return(ptrBytesWritten.ToInt32() == 1);
}
public bool Write(int iMemoryAddress, byte[] bBytesToWrite)
{
IntPtr ptr;
MAPI.WriteProcessMemory(this.hReadProcess, (IntPtr)iMemoryAddress, bBytesToWrite, (uint)bBytesToWrite.Length, out ptr);
return(ptr.ToInt32() == bBytesToWrite.Length);
}
public bool Write(int iMemoryAddress, double iDoubleToWrite)
{
byte[] bBuffer = BitConverter.GetBytes(iDoubleToWrite); IntPtr ptrBytesWritten;
MAPI.WriteProcessMemory(hReadProcess, (IntPtr)iMemoryAddress, bBuffer, 8, out ptrBytesWritten);
return(ptrBytesWritten.ToInt32() == 8);
}
public string ReadText(int iMemoryAddress, int[] iOffsets, uint iStringLength, bool Unicode, int iMode = 0)
{
int iFinalAddress = CalculatePointer(iMemoryAddress, iOffsets);
byte[] bBuffer = new byte[iStringLength];
IntPtr ptrBytesRead;
MAPI.ReadProcessMemory(hReadProcess, (IntPtr)iFinalAddress, bBuffer, iStringLength, out ptrBytesRead);
if (Unicode)
{
return(Encoding.Unicode.GetString(bBuffer));
}
if (iMode == 0)
{
return(Encoding.UTF8.GetString(bBuffer));
}
else if (iMode == 1)
{
return(BitConverter.ToString(bBuffer).Replace("-", ""));
}
else
{
return("");
}
}
public byte[] ReadAOB(int iMemoryAddress, uint iBytesToRead)
{
byte[] bBuffer = new byte[iBytesToRead]; IntPtr ptrBytesRead;
MAPI.ReadProcessMemory(hReadProcess, (IntPtr)iMemoryAddress, bBuffer, iBytesToRead, out ptrBytesRead);
return(bBuffer);
}
public bool Write(int iMemoryAddress, int[] iOffsets, byte[] bBytesToWrite)
{
IntPtr ptr;
int num = this.CalculatePointer(iMemoryAddress, iOffsets);
MAPI.WriteProcessMemory(this.hReadProcess, (IntPtr)num, bBytesToWrite, (uint)bBytesToWrite.Length, out ptr);
return(ptr.ToInt32() == bBytesToWrite.Length);
}
public bool Write(int iMemoryAddress, double iDoubleToWrite)
{
IntPtr ptr;
byte[] bytes = BitConverter.GetBytes(iDoubleToWrite);
MAPI.WriteProcessMemory(this.hReadProcess, (IntPtr)iMemoryAddress, bytes, 8, out ptr);
return(ptr.ToInt32() == 8);
}
public bool Write(int iMemoryAddress, int[] iOffsets, byte[] bBytesToWrite)
{
int iFinalAddress = CalculatePointer(iMemoryAddress, iOffsets);
IntPtr ptrBytesWritten;
MAPI.WriteProcessMemory(hReadProcess, (IntPtr)iFinalAddress, bBytesToWrite, (uint)bBytesToWrite.Length, out ptrBytesWritten);
return(ptrBytesWritten.ToInt32() == bBytesToWrite.Length);
}
public bool Write(int iMemoryAddress, float iFloatToWrite)
{
IntPtr ptr;
byte[] bytes = BitConverter.GetBytes(iFloatToWrite);
MAPI.WriteProcessMemory(this.hReadProcess, (IntPtr)iMemoryAddress, bytes, 4, out ptr);
return(ptr.ToInt32() == 4);
}
public bool Write(int iMemoryAddress, byte bByteToWrite)
{
IntPtr ptr;
byte[] bBuffer = new byte[] { bByteToWrite };
MAPI.WriteProcessMemory(this.hReadProcess, (IntPtr)iMemoryAddress, bBuffer, 1, out ptr);
return(ptr.ToInt32() == 1);
}
public ushort ReadShort(int iMemoryAddress, int[] iOffsets)
{
IntPtr ptr;
int num = this.CalculatePointer(iMemoryAddress, iOffsets);
byte[] bBuffer = new byte[2];
MAPI.ReadProcessMemory(this.hReadProcess, (IntPtr)num, bBuffer, 2, out ptr);
return(BitConverter.ToUInt16(bBuffer, 0));
}
public long ReadLong(int iMemoryAddress, int[] iOffsets)
{
IntPtr ptr;
int num = this.CalculatePointer(iMemoryAddress, iOffsets);
byte[] bBuffer = new byte[8];
MAPI.ReadProcessMemory(this.hReadProcess, (IntPtr)num, bBuffer, 8, out ptr);
return(BitConverter.ToInt64(bBuffer, 0));
}
public bool Write(int iMemoryAddress, int[] iOffsets, double iDoubleToWrite)
{
int iFinalAddress = CalculatePointer(iMemoryAddress, iOffsets);
IntPtr ptrBytesWritten;
byte[] bBuffer = BitConverter.GetBytes(iDoubleToWrite);
MAPI.WriteProcessMemory(hReadProcess, (IntPtr)iFinalAddress, bBuffer, 8, out ptrBytesWritten);
return(ptrBytesWritten.ToInt32() == 8);
}
public bool Write(int iMemoryAddress, int[] iOffsets, float iFloatToWrite)
{
IntPtr ptr;
int num = this.CalculatePointer(iMemoryAddress, iOffsets);
byte[] bytes = BitConverter.GetBytes(iFloatToWrite);
MAPI.WriteProcessMemory(this.hReadProcess, (IntPtr)num, bytes, 4, out ptr);
return(ptr.ToInt32() == 4);
}
public float ReadFloat(int iMemoryAddress, int[] iOffsets)
{
IntPtr ptr;
int num = this.CalculatePointer(iMemoryAddress, iOffsets);
byte[] bBuffer = new byte[4];
MAPI.ReadProcessMemory(this.hReadProcess, (IntPtr)num, bBuffer, 4, out ptr);
return(BitConverter.ToSingle(bBuffer, 0));
}
public byte ReadByte(int iMemoryAddress, int[] iOffsets)
{
IntPtr ptr;
int num = this.CalculatePointer(iMemoryAddress, iOffsets);
byte[] bBuffer = new byte[1];
MAPI.ReadProcessMemory(this.hReadProcess, (IntPtr)num, bBuffer, 1, out ptr);
return(bBuffer[0]);
}
public byte[] ReadAOB(int iMemoryAddress, int[] iOffsets, uint iBytesToRead)
{
IntPtr ptr;
int num = this.CalculatePointer(iMemoryAddress, iOffsets);
byte[] bBuffer = new byte[1];
MAPI.ReadProcessMemory(this.hReadProcess, (IntPtr)num, bBuffer, iBytesToRead, out ptr);
return(bBuffer);
}
public bool Write(int iMemoryAddress, int[] iOffsets, byte bByteToWrite)
{
IntPtr ptr;
int num = this.CalculatePointer(iMemoryAddress, iOffsets);
byte[] bBuffer = new byte[] { bByteToWrite };
MAPI.WriteProcessMemory(this.hReadProcess, (IntPtr)num, bBuffer, 1, out ptr);
return(ptr.ToInt32() == 1);
}
public ushort ReadShort(int iMemoryAddress, int[] iOffsets)
{
int iFinalAddress = CalculatePointer(iMemoryAddress, iOffsets);
byte[] bBuffer = new byte[2];
IntPtr ptrBytesRead;
MAPI.ReadProcessMemory(hReadProcess, (IntPtr)iFinalAddress, bBuffer, 2, out ptrBytesRead);
return(BitConverter.ToUInt16(bBuffer, 0));
}
public float ReadFloat(int iMemoryAddress, int[] iOffsets)
{
int iFinalAddress = CalculatePointer(iMemoryAddress, iOffsets);
byte[] bBuffer = new byte[4];
IntPtr ptrBytesRead;
MAPI.ReadProcessMemory(hReadProcess, (IntPtr)iFinalAddress, bBuffer, 4, out ptrBytesRead);
return(BitConverter.ToSingle(bBuffer, 0));
}
public double ReadDouble(int iMemoryAddress, int[] iOffsets)
{
int iFinalAddress = CalculatePointer(iMemoryAddress, iOffsets);
byte[] bBuffer = new byte[8];
IntPtr ptrBytesRead;
MAPI.ReadProcessMemory(hReadProcess, (IntPtr)iFinalAddress, bBuffer, 8, out ptrBytesRead);
return(BitConverter.ToDouble(bBuffer, 0));
}
public byte[] ReadAOB(int iMemoryAddress, int[] iOffsets, uint iBytesToRead)
{
int iFinalAddress = CalculatePointer(iMemoryAddress, iOffsets);
byte[] bBuffer = new byte[1];
IntPtr ptrBytesRead;
MAPI.ReadProcessMemory(hReadProcess, (IntPtr)iFinalAddress, bBuffer, iBytesToRead, out ptrBytesRead);
return(bBuffer);
}
//Read from Pointer
public byte ReadByte(int iMemoryAddress, int[] iOffsets)
{
int iFinalAddress = CalculatePointer(iMemoryAddress, iOffsets);
byte[] bBuffer = new byte[1];
IntPtr ptrBytesRead;
MAPI.ReadProcessMemory(hReadProcess, (IntPtr)iFinalAddress, bBuffer, 1, out ptrBytesRead);
return(bBuffer[0]);
}
public uint ReadInt(int iMemoryAddress)
{
IntPtr ptr;
byte[] bBuffer = new byte[4];
if (MAPI.ReadProcessMemory(this.hReadProcess, (IntPtr)iMemoryAddress, bBuffer, 4, out ptr) == 0)
{
return(0);
}
return(BitConverter.ToUInt32(bBuffer, 0));
}
public float ReadFloat(int iMemoryAddress)
{
IntPtr ptr;
byte[] bBuffer = new byte[4];
if (MAPI.ReadProcessMemory(this.hReadProcess, (IntPtr)iMemoryAddress, bBuffer, 4, out ptr) == 0)
{
return(0f);
}
return(BitConverter.ToSingle(bBuffer, 0));
}
public ushort ReadShort(int iMemoryAddress)
{
IntPtr ptr;
byte[] bBuffer = new byte[2];
if (MAPI.ReadProcessMemory(this.hReadProcess, (IntPtr)iMemoryAddress, bBuffer, 2, out ptr) == 0)
{
return(0);
}
return(BitConverter.ToUInt16(bBuffer, 0));
}
public double ReadDouble(int iMemoryAddress)
{
IntPtr ptr;
byte[] bBuffer = new byte[8];
if (MAPI.ReadProcessMemory(this.hReadProcess, (IntPtr)iMemoryAddress, bBuffer, 8, out ptr) == 0)
{
return(0.0);
}
return(BitConverter.ToDouble(bBuffer, 0));
}
public long ReadLong(int iMemoryAddress)
{
IntPtr ptr;
byte[] bBuffer = new byte[8];
if (MAPI.ReadProcessMemory(this.hReadProcess, (IntPtr)iMemoryAddress, bBuffer, 8, out ptr) == 0)
{
return(0L);
}
return(BitConverter.ToInt64(bBuffer, 0));
}
