//Calculate Pointer
public 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)
{
ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iTemporaryAddress, bBuffer, 4, out ptrBytesRead);
iTemporaryAddress = Conversions.Conversions.HexToInt(CreateAddress(bBuffer)) + iOffsets[i];
return(iTemporaryAddress);
}
else if (i == 0)
{
ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iMemoryAddress, bBuffer, 4, out ptrBytesRead);
iTemporaryAddress = Conversions.Conversions.HexToInt(CreateAddress(bBuffer)) + iOffsets[0];
}
else
{
ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iTemporaryAddress, bBuffer, 4, out ptrBytesRead);
iTemporaryAddress = Conversions.Conversions.HexToInt(CreateAddress(bBuffer)) + iOffsets[i];
}
}
return(0);
}
public Byte[] ReadAOB(IntPtr iMemoryAddress, uint iBytesToRead)
{
byte[] bBuffer = new byte[iBytesToRead];
IntPtr ptrBytesRead;
ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, iMemoryAddress, bBuffer, iBytesToRead, out ptrBytesRead);
return(bBuffer);
}
public byte[] ReadMemory(IntPtr memoryaddress, uint bytesToRead, out int bytesRead)
{
byte[] buffer = new byte[bytesToRead];
IntPtr pBytesRead;
int returned = ProcessMemoryReaderApi.ReadProcessMemory(handle, memoryaddress, buffer, bytesToRead, out pBytesRead);
bytesRead = pBytesRead.ToInt32();
return(buffer);
}
public byte[] ReadProcessMemory(IntPtr MemoryAddress, UInt64 bytesToRead, out Int64 bytesRead, byte[] buffer)
{
IntPtr ptrBytesRead = new IntPtr();
int rval = ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, MemoryAddress, buffer, bytesToRead, out ptrBytesRead);
bytesRead = ptrBytesRead.ToInt64();
return(buffer);
}
public int ReadProcessInt(IntPtr MemoryAddress)
{
byte[] buffer = new byte[4];
IntPtr ptrBytesRead;
ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, MemoryAddress, buffer, 4, out ptrBytesRead);
return(BitConverter.ToInt32(buffer, 0));
}
public byte[] ReadProcessMemory(IntPtr MemoryAddress, uint bytesToRead, out int bytesRead)
{
byte[] buffer = new byte[bytesToRead];
IntPtr ptrBytesRead;
int code = ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, MemoryAddress, buffer, bytesToRead, out ptrBytesRead);
bytesRead = ptrBytesRead.ToInt32();
return(buffer);
}
public string ReadProcessMemoryString(IntPtr MemoryAddress, uint bytesToRead, out int bytesRead)
{
byte[] buffer = new byte[bytesToRead];
IntPtr ptrBytesRead;
ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, MemoryAddress, buffer, bytesToRead, out ptrBytesRead);
bytesRead = ptrBytesRead.ToInt32();
return(System.Text.Encoding.Default.GetString(buffer));
}
public double ReadDouble(UInt64 iMemoryAddress)
{
byte[] bBuffer = new byte[8]; IntPtr ptrBytesRead;
int iReturn = ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iMemoryAddress, bBuffer, 8, out ptrBytesRead);
if (iReturn == 0)
{
return(0);
}
else
{
return(BitConverter.ToDouble(bBuffer, 0));
}
}
public Int32 ReadInt32(UInt64 iMemoryAddress)
{
byte[] bBuffer = new byte[4]; IntPtr ptrBytesRead;
int iReturn = ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iMemoryAddress, bBuffer, 4, out ptrBytesRead);
if (iReturn == 0)
{
return(0);
}
else
{
return(BitConverter.ToInt32(bBuffer, 0));
}
}
public SByte ReadSByte(UInt64 iMemoryAddress)
{
byte[] bBuffer = new byte[1]; IntPtr ptrBytesRead;
int iReturn = ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iMemoryAddress, bBuffer, 1, out ptrBytesRead);
if (iReturn == 0)
{
return(0);
}
else
{
return((SByte)bBuffer[0]);
}
}
public int ReadProcessMemory(IntPtr MemoryAddress, UInt64 bytesToRead, out Int64 bytesRead, byte[] buffer)
{
IntPtr ptrBytesRead = new IntPtr();
int rval = ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, MemoryAddress, buffer, bytesToRead, out ptrBytesRead);
if (rval == 1)
{
bytesRead = ptrBytesRead.ToInt64();
}
else
{
bytesRead = 0;
}
return(rval);
}
public String ReadString(UInt64 iMemoryAddress, uint iTextLength, int iMode = 0)
{
byte[] bBuffer = new byte[iTextLength]; IntPtr ptrBytesRead;
ProcessMemoryReaderApi.ReadProcessMemory(m_hProcess, (IntPtr)iMemoryAddress, bBuffer, iTextLength, out ptrBytesRead);
if (iMode == 0)
{
return(Encoding.UTF8.GetString(bBuffer));
}
else if (iMode == 1)
{
return(BitConverter.ToString(bBuffer).Replace("-", ""));
}
else
{
return("");
}
}
private void timer3_Tick(object sender, EventArgs e)
{
IntPtr bytesRead;
byte[] buffer = new byte[8];
//actual aimbot code for horizontal plane
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, xMouseAddr, buffer, (uint)buffer.Length, out bytesRead);
playerYaw = BitConverter.ToSingle(buffer, 0);
directionLabel.Text = playerYaw.ToString();
byte[] binNewYaw = BitConverter.GetBytes(yawAngle - readWriteXMouseDiff);
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, writableXMouseAddr, binNewYaw, (uint)binNewYaw.Length, out bytesRead);
//aimbot code for vertical plane
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, yMouseAddr, buffer, (uint)buffer.Length, out bytesRead);
playerPitch = BitConverter.ToSingle(buffer, 0);
byte[] binNewPitch = BitConverter.GetBytes(pitchAngle + 2 - readWriteYMouseDiff);
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, writableYMouseAddr, binNewPitch, (uint)binNewPitch.Length, out bytesRead);
}
/// <summary>This function will read an from memory using the given parameters.</summary>
/// <param name="lpBaseAddress">The address you want to read.</param>
/// <param name="type">The type of variable you are wanting to read.</param>
/// <param name="size">The number of bytes to be read.</param>
/// <param name="lpNumberOfBytesRead">The number of bytes actually read.</param>
/// <returns>An object with the results of the read.</returns>
public static object Read(UIntPtr lpBaseAddress, Type type, uint size, out IntPtr bytesRead)
{
// The array of bytes for the returned data to be stored in.
byte[] buffer = new byte[size];
bytesRead = IntPtr.Zero;
// Calls the c api for reading from memory.
if (Process.GameRunning && Convert.ToBoolean(ProcessMemoryReaderApi.ReadProcessMemory(Voodoo.Process.Handle, lpBaseAddress, buffer, size, out bytesRead)))
{
// This handles the different types of variables.
switch (Type.GetTypeCode(type))
{
// Handles if the memory to be read is an int
case TypeCode.Int32:
return(System.BitConverter.ToInt32(buffer, 0));
// Handles if the memory to be read is an int16
case TypeCode.Int16:
return(System.BitConverter.ToInt16(buffer, 0));
// Handles if the memory to be read is a string
case TypeCode.String:
return(Encoding.Unicode.GetString(buffer));
// Handles if the memory to be read is a single (float)
case TypeCode.Single:
return(System.BitConverter.ToSingle(buffer, 0));
case TypeCode.UInt32:
return(System.BitConverter.ToUInt32(buffer, 0));
// Handles if the memory to be read is a byte
case TypeCode.Byte:
return(buffer[0]);
// Handles if the memory to be read is a type that isn't supported.
default:
return(new object());
}
}
else
{
// This handles the different types of variables.
switch (Type.GetTypeCode(type))
{
// Handles if the memory to be read is an int
case TypeCode.Int32:
return(int.MaxValue);
// Handles if the memory to be read is an int16
case TypeCode.Int16:
return(Int16.MaxValue);
// Handles if the memory to be read is a string
case TypeCode.String:
return(string.Empty);
// Handles if the memory to be read is a single (float)
case TypeCode.Single:
return(float.MaxValue);
case TypeCode.UInt32:
return(uint.MaxValue);
// Handles if the memory to be read is a byte
case TypeCode.Byte:
return(byte.MaxValue);
// Handles if the memory to be read is a type that isn't supported.
default:
return(new object());
}
}
}
private void timer1_Tick(object sender, EventArgs e)
{
//All of this code is what shows the player's position in the app window.
IntPtr processHandle = ProcessMemoryReaderApi.OpenProcess(ProcessMemoryReaderApi.PROCESS_VM_READ, 0, (uint)process.Id);
IntPtr bytesRead = (IntPtr)0;
byte[] buffer = new byte[8];
uint size = (uint)buffer.Length;
ProcessMemoryReaderApi.ReadProcessMemory(processHandle, xPosAddr, buffer, (uint)buffer.Length, out bytesRead);
xPosLabel.Text = BitConverter.ToSingle(buffer, 0).ToString();
ProcessMemoryReaderApi.ReadProcessMemory(processHandle, yPosAddr, buffer, (uint)buffer.Length, out bytesRead);
yPosLabel.Text = BitConverter.ToSingle(buffer, 0).ToString();
ProcessMemoryReaderApi.ReadProcessMemory(processHandle, zPosAddr, buffer, (uint)buffer.Length, out bytesRead);
zPosLabel.Text = BitConverter.ToSingle(buffer, 0).ToString();
ProcessMemoryReaderApi.ReadProcessMemory(processHandle, healthAddr, buffer, (uint)buffer.Length, out bytesRead);
healthLabel.Text = "2147483647 / 100";
//starting here is aimbot math
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, xPosAddr, buffer, (uint)buffer.Length, out bytesRead);
float x1 = BitConverter.ToSingle(buffer, 0);
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, enemyXPosAddr, buffer, (uint)buffer.Length, out bytesRead);
float x2 = BitConverter.ToSingle(buffer, 0);
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, zPosAddr, buffer, (uint)buffer.Length, out bytesRead);
float z1 = BitConverter.ToSingle(buffer, 0);
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, enemyZPosAddr, buffer, (uint)buffer.Length, out bytesRead);
float z2 = BitConverter.ToSingle(buffer, 0);
slope = ((z2 - z1) / (x2 - x1));
yawAngle = (float)(Math.Atan2((z2 - z1), (x2 - x1)) * (180 / Math.PI));
slopeLabel.Text = slope.ToString();
angleLabel.Text = yawAngle.ToString();
distance = (float)(Math.Sqrt(Math.Pow((x2 - x1), 2) + Math.Pow((z2 - z1), 2)));
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, yPosAddr, buffer, (uint)buffer.Length, out bytesRead);
playerHeight = BitConverter.ToSingle(buffer, 0);
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, enemyYPosAddr, buffer, (uint)buffer.Length, out bytesRead);
enemyHeight = BitConverter.ToSingle(buffer, 0);
heightDifference = playerHeight - enemyHeight;
pitchAngle = (float)((Math.Atan2(heightDifference, distance)) * (180 / Math.PI));
//This code gives the player infinite health
byte[] healthValue = BitConverter.GetBytes(2147483647);
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, healthAddr, healthValue, 4, out bytesRead);
//This code gives the player infinite primary ammo
byte[] fourByteBuffer = new byte[4];
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, primaryAmmoAddrPointer, fourByteBuffer, (uint)fourByteBuffer.Length, out bytesRead);
primaryAmmoAddr = (IntPtr)(BitConverter.ToInt32(fourByteBuffer, 0) + 0x44C);
byte[] ammoValue = BitConverter.GetBytes(2147483647);
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, primaryAmmoAddr, ammoValue, 4, out bytesRead);
}
protected override void WndProc(ref Message m)
{
const int WM_HOTKEY = 0x0312;
if (m.Msg == WM_HOTKEY)
{
if (m.WParam == (IntPtr)1)
{
IntPtr bytesRead;
byte[] bufferX = new byte[8];
byte[] bufferY = new byte[8];
byte[] bufferZ = new byte[8];
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, xPosAddr, bufferX, (uint)bufferX.Length, out bytesRead);
savedXPos1 = bufferX;
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, yPosAddr, bufferY, (uint)bufferY.Length, out bytesRead);
savedYPos1 = bufferY;
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, zPosAddr, bufferZ, (uint)bufferZ.Length, out bytesRead);
savedZPos1 = bufferZ;
}
else if (m.WParam == (IntPtr)2)
{
IntPtr store;
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, xPosAddr, savedXPos1, 8, out store);
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, yPosAddr, savedYPos1, 8, out store);
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, zPosAddr, savedZPos1, 8, out store);
}
else if (m.WParam == (IntPtr)3)
{
IntPtr bytesRead;
IntPtr store;
byte[] buffer = new byte[8];
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, yPosAddr, buffer, (uint)buffer.Length, out bytesRead);
byte[] currentY = buffer;
float floatY = BitConverter.ToSingle(currentY, 0);
float addedY = floatY + 300;
byte[] newY = BitConverter.GetBytes(addedY);
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, yPosAddr, newY, 8, out store);
byte[] accelerationY = { 0x00000000 };
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, yVelocityAddr, accelerationY, 4, out store);
}
else if (m.WParam == (IntPtr)4)
{
IntPtr store;
byte[] accelerationY = { 0x00 };
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, yVelocityAddr, accelerationY, 4, out store);
}
else if (m.WParam == (IntPtr)5)
{
IntPtr processHandle = ProcessMemoryReaderApi.OpenProcess(ProcessMemoryReaderApi.PROCESS_VM_READ, 0, (uint)process.Id);
IntPtr bytesRead = (IntPtr)0;
byte[] bufferX = new byte[8];
byte[] bufferY = new byte[8];
byte[] bufferZ = new byte[8];
ProcessMemoryReaderApi.ReadProcessMemory(processHandle, xPosAddr, bufferX, (uint)bufferX.Length, out bytesRead);
savedXPos2 = bufferX;
ProcessMemoryReaderApi.ReadProcessMemory(processHandle, yPosAddr, bufferY, (uint)bufferY.Length, out bytesRead);
savedYPos2 = bufferY;
ProcessMemoryReaderApi.ReadProcessMemory(processHandle, zPosAddr, bufferZ, (uint)bufferZ.Length, out bytesRead);
savedZPos2 = bufferZ;
}
else if (m.WParam == (IntPtr)6)
{
IntPtr store = (IntPtr)0;
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, xPosAddr, savedXPos2, 8, out store);
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, yPosAddr, savedYPos2, 8, out store);
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, zPosAddr, savedZPos2, 8, out store);
}
else if (m.WParam == (IntPtr)7)
{
byte[] buffer = new byte[8];
IntPtr store;
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, xMouseAddr, buffer, 8, out store);
float direction = BitConverter.ToSingle(buffer, 0);
if (direction > -45 && direction < 45)
{
//xPos will increase
IntPtr processHandle = ProcessMemoryReaderApi.OpenProcess(ProcessMemoryReaderApi.PROCESS_VM_READ, 0, (uint)process.Id);
IntPtr bytesRead = (IntPtr)0;
buffer = new byte[8];
ProcessMemoryReaderApi.ReadProcessMemory(processHandle, xPosAddr, buffer, (uint)buffer.Length, out bytesRead);
float movement = BitConverter.ToSingle(buffer, 0) + 200;
byte[] finalMovement = BitConverter.GetBytes(movement);
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, xPosAddr, finalMovement, (uint)finalMovement.Length, out bytesRead);
}
else if (direction < -45 && direction > -135)
{
//zPos will decrease
IntPtr processHandle = ProcessMemoryReaderApi.OpenProcess(ProcessMemoryReaderApi.PROCESS_VM_READ, 0, (uint)process.Id);
IntPtr bytesRead = (IntPtr)0;
buffer = new byte[8];
ProcessMemoryReaderApi.ReadProcessMemory(processHandle, zPosAddr, buffer, (uint)buffer.Length, out bytesRead);
float movement = BitConverter.ToSingle(buffer, 0) - 200;
byte[] finalMovement = BitConverter.GetBytes(movement);
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, zPosAddr, finalMovement, (uint)finalMovement.Length, out bytesRead);
}
else if ((direction < -135 && direction > -179.99999999) || (direction > 135 && direction < 179.99999999))
{
//xPos will decrease
IntPtr processHandle = ProcessMemoryReaderApi.OpenProcess(ProcessMemoryReaderApi.PROCESS_VM_READ, 0, (uint)process.Id);
IntPtr bytesRead = (IntPtr)0;
buffer = new byte[8];
ProcessMemoryReaderApi.ReadProcessMemory(processHandle, xPosAddr, buffer, (uint)buffer.Length, out bytesRead);
float movement = BitConverter.ToSingle(buffer, 0) - 200;
byte[] finalMovement = BitConverter.GetBytes(movement);
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, xPosAddr, finalMovement, (uint)finalMovement.Length, out bytesRead);
}
else if (direction > 45 && direction < 135)
{
//zPos will increase
IntPtr processHandle = ProcessMemoryReaderApi.OpenProcess(ProcessMemoryReaderApi.PROCESS_VM_READ, 0, (uint)process.Id);
IntPtr bytesRead = (IntPtr)0;
buffer = new byte[8];
ProcessMemoryReaderApi.ReadProcessMemory(processHandle, zPosAddr, buffer, (uint)buffer.Length, out bytesRead);
float movement = BitConverter.ToSingle(buffer, 0) + 200;
byte[] finalMovement = BitConverter.GetBytes(movement);
ProcessMemoryReaderApi.WriteProcessMemory(process.Handle, zPosAddr, finalMovement, (uint)finalMovement.Length, out bytesRead);
}
}
else if (m.WParam == (IntPtr)8)
{
if (aimbotIsOn == true)
{
timer3.Enabled = false;
aimbotIsOn = false;
}
else
{
timer3.Enabled = true;
aimbotIsOn = true;
//defining the difference between the readable and writable X address values.
IntPtr bytesRead;
byte[] buffer = new byte[8];
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, xMouseAddr, buffer, (uint)buffer.Length, out bytesRead);
float readXMouseValue = BitConverter.ToSingle(buffer, 0);
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, writableXMouseAddr, buffer, (uint)buffer.Length, out bytesRead);
float writeXMouseValue = BitConverter.ToSingle(buffer, 0);
readWriteXMouseDiff = readXMouseValue - writeXMouseValue;
//defining the difference between the readable and writable Y address value
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, yMouseAddr, buffer, (uint)buffer.Length, out bytesRead);
float readYMouseValue = BitConverter.ToSingle(buffer, 0);
ProcessMemoryReaderApi.ReadProcessMemory(process.Handle, writableYMouseAddr, buffer, (uint)buffer.Length, out bytesRead);
float writeYMouseValue = BitConverter.ToSingle(buffer, 0);
readWriteYMouseDiff = readYMouseValue - writeYMouseValue;
}
}
else if (m.WParam == (IntPtr)9)
{
}
}
base.WndProc(ref m);
}
