public static Angles getCurrentAngles(VAMemory vam, int engine)
{
float x = vam.ReadFloat((IntPtr)(vam.ReadInt32((IntPtr)(engine + Offsets.oClientState)) + Offsets.oViewAngles));
float y = vam.ReadFloat((IntPtr)(vam.ReadInt32((IntPtr)(engine + Offsets.oClientState)) + Offsets.oViewAngles + 4));
return(new Angles(x, y));
}
public static Vector3 getPlayerVectorByIndex(VAMemory vam, int bClient, int index)
{
float x = 0f, y = 0f, z = 0f;
//get enemy coords;
int PtrToPIC = vam.ReadInt32((IntPtr)(bClient + Offsets.oEntityList + (index) * Offsets.oEntityLoopDistance));
if (PtrToPIC != 0)
{
x = vam.ReadFloat((IntPtr)(PtrToPIC + Offsets.vecOrigin));
y = vam.ReadFloat((IntPtr)(PtrToPIC + Offsets.vecOrigin + 4));
z = vam.ReadFloat((IntPtr)(PtrToPIC + Offsets.vecOrigin + 8));
if (x == 0 || y == 0 || z == 0)
{
x = 99999999f;
y = 99999999f;
z = 99999999f;
}
return(new Vector3(x, y, z));
}
else
{
return(new Vector3(999999f, 999999f, 999999f));
}
}
public void Init()
{
//sets and reads base values
vam.processName = "1964";
OrigCam = vam.ReadFloat((IntPtr)(PlyYCam - 0x80000000 + EmuOffset));
OrigSize = vam.ReadFloat((IntPtr)(PlyHeight - 0x80000000 + EmuOffset));
}
public static Vector3 getLocalPlayerPosition(VAMemory vam, int bClient)
{
int playerIndex = vam.ReadInt32((IntPtr)(vam.ReadInt32((IntPtr)(bClient + Offsets.oLocalPlayer)) + 0x64));
int start = vam.ReadInt32((IntPtr)(bClient + Offsets.oEntityList + (playerIndex - 1) * Offsets.oEntityLoopDistance));
float x = vam.ReadFloat((IntPtr)(start + Offsets.vecOrigin));
float y = vam.ReadFloat((IntPtr)(start + Offsets.vecOrigin + 4));
float z = vam.ReadFloat((IntPtr)(start + Offsets.vecOrigin + 8));
return(new Vector3(x, y, z));
}
private void button2_Click(object sender, EventArgs e)
{
int LocalPlayer = vam.ReadInt32((IntPtr)BASE);
int HPAdress = LocalPlayer + health;
int hpRead = vam.ReadInt32((IntPtr)HPAdress);
string showHPRead = hpRead.ToString();
label2.Text = showHPRead;
int APAdress = LocalPlayer + health;
int apRead = vam.ReadInt32((IntPtr)APAdress);
string showAPRead = apRead.ToString();
label4.Text = showAPRead;
IntPtr xBase = Process.GetProcessesByName("ac_client").FirstOrDefault().MainModule.BaseAddress + 0x000987A4;
IntPtr xoff = IntPtr.Add((IntPtr)vam.ReadInt32(xBase), 0x4);
float readX = vam.ReadFloat((IntPtr)xoff);
string showReadx = readX.ToString();
label6.Text = showReadx;
IntPtr yBase = Process.GetProcessesByName("ac_client").FirstOrDefault().MainModule.BaseAddress + 0x00007738;
IntPtr yoff = IntPtr.Add((IntPtr)vam.ReadInt32(yBase), 0x0);
float ready = vam.ReadFloat((IntPtr)yoff);
string showReady = ready.ToString();
label8.Text = showReady;
IntPtr zBase = Process.GetProcessesByName("ac_client").FirstOrDefault().MainModule.BaseAddress + 0x00006FFC;
IntPtr zoff = IntPtr.Add((IntPtr)vam.ReadInt32(zBase), 0x0);
float readz = vam.ReadFloat((IntPtr)zoff);
string showReadz = readz.ToString();
label10.Text = showReadz;
}
static float ReadMemoryFloat(int pid, UInt64 address)//example for read float
{
vam.WriteInt32(bAddress + offset_pid, pid);
vam.WriteUInt64(bAddress + offset_memAddress, address);
vam.WriteInt32(bAddress + offset_typeReq, 3);
return(vam.ReadFloat(bAddress + offset_fRetAnswer));
}
void noflash()
{
int localPlayer = vam.ReadInt32((IntPtr)bClient + Offsets.oLocalPlayer);
if (noflashtoggle)
{
if (vam.ReadFloat((IntPtr)localPlayer + Offsets.oFlashMaxAlpha) > 0.0f)
{
vam.WriteFloat((IntPtr)localPlayer + Offsets.oFlashMaxAlpha, 0.0f);
}
}
else if (vam.ReadFloat((IntPtr)localPlayer + Offsets.oFlashMaxAlpha) < 0f + float.Epsilonh)
{
vam.WriteFloat((IntPtr)localPlayer + Offsets.oFlashMaxAlpha, 255.0f);
}
}
public static Angles GetPunch(int playerIndex, VAMemory vam, int bClient)
{
int start = vam.ReadInt32((IntPtr)(bClient + Offsets.oEntityList + (playerIndex * Offsets.oEntityLoopDistance)));
if (start != 0)
{
float x = 0;
float y = 0;
x = vam.ReadFloat((IntPtr)(start + Offsets.dwPunchOffset));
y = vam.ReadFloat((IntPtr)(start + Offsets.dwPunchOffset + 4));
return(new Angles(x, y));
}
else
{
return(new Angles(999f, 999f));
}
}
public List <EntityData> BuildEnemyList(int playercount, int enemyteamnumber, VAMemory vam, Int32 baseaddress) //returns an list of floats arranged in (x, y, z) * number of players
{
Int32 a_playerobject;
float entityx;
float entityy;
float entityz;
int entityhealth;
int team;
int entitynumber;
List <EntityData> retlist = new List <EntityData>();
//iterate through the entitylist for the players and skipping local player
for (int i = 0; i < playercount; i++)
{
//read the player object address
a_playerobject = vam.ReadInt32((IntPtr)baseaddress + a_entitylist + (0x10 * (i)));
entityx = vam.ReadFloat((IntPtr)a_playerobject + o_coordinates);
entityy = vam.ReadFloat((IntPtr)a_playerobject + o_coordinates + 0x4);
entityz = vam.ReadFloat((IntPtr)a_playerobject + o_coordinates + 0x8);
entityhealth = vam.ReadInt32((IntPtr)a_playerobject + o_health);
team = vam.ReadInt32((IntPtr)a_playerobject + o_teamnumber);
entitynumber = vam.ReadInt32((IntPtr)a_playerobject + o_entitynumber);
//add to the return list
if (team == enemyteamnumber)
{
retlist.Add((new EntityData(entityx, entityy, entityz, entityhealth, team, entitynumber)));
}
if (showdebugmessages)
{
System.Console.WriteLine("Entity Pointer: 0x" + (baseaddress + a_entitylist + (0x10 * (i))).ToString("X"));
System.Console.WriteLine("Entity Object Address: 0x" + a_playerobject.ToString("X"));
System.Console.WriteLine("Entity X: " + entityx);
System.Console.WriteLine("Entity Y: " + entityy);
System.Console.WriteLine("Entity Z: " + entityz);
}
}
return(retlist);
}
public static Vector3 GetBonePosition(int boneIndex, int PlayerNumber, int bClient, VAMemory vam)
{
int BaseEntity = GetBaseEntity(PlayerNumber, bClient, vam);
if (BaseEntity != 0)
{
int BoneMatrix = vam.ReadInt32((IntPtr)(BaseEntity + Offsets.dwBoneMatrix));
int hp = vam.ReadInt32((IntPtr)(BaseEntity + Offsets.oHealth));
if (BoneMatrix != 0 && hp > 0)
{
float x = vam.ReadFloat((IntPtr)(BoneMatrix + 0x30 * boneIndex + 0x0C));
float y = vam.ReadFloat((IntPtr)(BoneMatrix + 0x30 * boneIndex + 0x1C));
float z = vam.ReadFloat((IntPtr)(BoneMatrix + 0x30 * boneIndex + 0x2C));
return(new Vector3(x, y, z));
}
return(new Vector3(99999f, 99999f, 99999f));
}
return(new Vector3(99999f, 99999f, 99999f));
}
static void Main(string[] args)
{
Chroma.Instance.Keyboard.SetAll(Color.Black);
Console.WriteLine("");
Console.ForegroundColor = ConsoleColor.Cyan;
VAMemory mem = new VAMemory("starwarsbattlefront");
ColorManager.CRenderer CR = new CRenderer();
for (;;)
{
Int64 pGameContext = mem.ReadInt64((IntPtr)(0x142AE8080));
Int64 pPlayerManager = mem.ReadInt64((IntPtr)(pGameContext + 0x68));
Int64 pLocalPlayer = mem.ReadInt64((IntPtr)(pPlayerManager + 0x550));
Int64 pLocalSoldier = mem.ReadInt64((IntPtr)(pLocalPlayer + 0x2cb8));
Int64 pHealthComponent = mem.ReadInt64((IntPtr)(pLocalSoldier + 0x198));
float pHealth = mem.ReadFloat((IntPtr)(pHealthComponent + 0x20));
float pHealthMax = mem.ReadFloat((IntPtr)(pHealthComponent + 0x24));
int health = (int)((pHealth / pHealthMax) * 100);
Int64 pAimer = mem.ReadInt64((IntPtr)(pLocalSoldier + 0x5e0));
Int64 pWeap = mem.ReadInt64((IntPtr)(pAimer + 0x1b8));
Int64 pPrimary = mem.ReadInt64((IntPtr)(pWeap + 0x5130));
float Heat = mem.ReadFloat((IntPtr)(pPrimary + 0x1c8));
int heat = (int)(100 - (Heat * 100));
// Console.WriteLine(heat);
CR.DrawHeat(health, true);
// Console.WriteLine(pHealthMax);
/*if (GetAsyncKeyState(Keys.Up)) health += 5;
* if (GetAsyncKeyState(Keys.Down)) health -= 5;
* if (health > 100) health = 100;
* if (health < 0) health = 0;*/
CR.DrawHealth(heat, true);
Thread.Sleep(100);
}
}
private static void NFMain()
{
while (true)
{
int SPLR = mem.ReadInt32((IntPtr)BaseAddress + Offsets.LP);
float FLA = SPLR + Offsets.FLA;
if (mem.ReadFloat((IntPtr)FLA) > 0f)
{
mem.WriteFloat((IntPtr)FLA, 0f);
}
}
}
private void timer3_Tick(object sender, EventArgs e)
{
Process[] isprocessRunning = Process.GetProcessesByName("SCP - Containment Breach");
if (isprocessRunning.Length > 0)
{
foreach (Process process in isprocessRunning)
{
ProcessModuleCollection oModules = process.Modules;
baseAddress = process.MainModule.BaseAddress;
}
if (baseAddress != null)
{
VAMemory vars = new VAMemory(processName);
timer1.Start();
OnOffLabel.Text = "On";
OnOffLabel.ForeColor = System.Drawing.Color.LawnGreen;
mainAddress = vars.ReadInt32((IntPtr)baseAddress + 0x000f5400);
Offset98 = vars.ReadInt32((IntPtr)mainAddress + 0x98);
Godmode = vars.ReadInt32((IntPtr)Offset98 + 0x5b0);
Noclip = vars.ReadInt32((IntPtr)Offset98 + 0x5b4);
InfStam = vars.ReadInt32((IntPtr)Offset98 + 0x924);
InfBlink = vars.ReadInt32((IntPtr)Offset98 + 0x390);
Notarget = vars.ReadInt32((IntPtr)Offset98 + 0xfd4);
Debughud = vars.ReadInt32((IntPtr)Offset98 + 0xad0);
Camerafog = vars.ReadFloat((IntPtr)Offset98 + 0xb68);
WireframeOffset1 = vars.ReadInt32((IntPtr)mainAddress + 0xfdc);
Wireframe = vars.ReadInt32((IntPtr)WireframeOffset1 + 0x23f);
Bloodloss = vars.ReadFloat((IntPtr)Offset98 + 0x3f0);
SCP008State = vars.ReadFloat((IntPtr)Offset98 + 0x3f4);
Injuries = vars.ReadFloat((IntPtr)Offset98 + 0x3ec);
RDC = vars.ReadInt32((IntPtr)Offset98 + 0x12e8);
PlayerOffset1 = vars.ReadInt32((IntPtr)mainAddress + 0x160);
PlayerOffset2 = vars.ReadInt32((IntPtr)PlayerOffset1 + 0x140);
PlayerX = vars.ReadFloat((IntPtr)PlayerOffset2 + 0x40);
PlayerY = vars.ReadFloat((IntPtr)PlayerOffset2 + 0x44);
PlayerZ = vars.ReadFloat((IntPtr)PlayerOffset2 + 0x48);
}
}
else
{
timer1.Stop();
OnOffLabel.Text = "Off";
OnOffLabel.ForeColor = System.Drawing.Color.DarkRed;
}
}
public T ReadValue <T>(IntPtr baseAddress, int[] offsetArr)
{
var pointer = GetPointer(baseAddress, offsetArr);
if (typeof(T).Equals(typeof(int)))
{
return((T)Convert.ChangeType(vam.ReadInt32(pointer), typeof(T)));
}
else if (typeof(T).Equals(typeof(double)))
{
return((T)Convert.ChangeType(vam.ReadDouble(pointer), typeof(T)));
}
else if (typeof(T).Equals(typeof(float)))
{
return((T)Convert.ChangeType(vam.ReadFloat(pointer), typeof(T)));
}
return(default);
public static Vector3 getEntityEyePosition(VAMemory vam, int bClient, int index)
{
int start = vam.ReadInt32((IntPtr)(bClient + Offsets.oEntityList + index * Offsets.oEntityLoopDistance));
float x = vam.ReadFloat((IntPtr)(start + Offsets.vecOrigin));
float y = vam.ReadFloat((IntPtr)(start + Offsets.vecOrigin + 4));
float z = vam.ReadFloat((IntPtr)(start + Offsets.vecOrigin + 8));
x += vam.ReadFloat((IntPtr)(start + m_vecViewOffset));
y += vam.ReadFloat((IntPtr)(start + m_vecViewOffset + 4));
z += vam.ReadFloat((IntPtr)(start + m_vecViewOffset + 8));
return(new Vector3(x, y, z));
}
/// <summary>The main entry point for the application.</summary>
static void Main(string[] args)
{
Application.EnableVisualStyles();
Application.SetCompatibleTextRenderingDefault(false);
var f = new Form1();
f.Show();
VAMemory vam = new VAMemory("ac_client");
int localplayer = vam.ReadInt32((IntPtr)Pbase);
while (f.Visible) //loop while form is not closed
{
int address = localplayer + fly;
float aimlock = vam.ReadFloat((IntPtr)address);
vam.WriteFloat((IntPtr)address, -5);
address = localplayer + Health;
vam.WriteInt32((IntPtr)address, 1337);
address = localplayer + mgammo;
vam.WriteInt32((IntPtr)address, +1337);
Application.DoEvents(); //Yield control to the message loop
}
}
private float SetHealth(VAMemory vMemory, int healthFinalAddress, float healthOriginal)
{
float health = vMemory.ReadFloat((IntPtr)healthFinalAddress + 0x18); // 808 // 288
Invoke(new Action(() =>
{
lblHealth.Text = health.ToString();
}));
if (chkHealth.Checked)
{
if (health > healthOriginal)
{
healthOriginal = health;
}
vMemory.WriteFloat((IntPtr)healthFinalAddress + 0x18, healthOriginal); // 808 // 288
}
else
{
healthOriginal = health;
}
return(healthOriginal);
}
public static void ToggleBrightness()
{
//Search for float. If brightness is 66 than the float will be between .66 and .68
//036542E8 20 C10 B0 138 F0
int staticPointerOffset = 0x036542E8;
int[] offsets = new int[] { 0x20, 0xC10, 0xB0, 0x138, 0xF0 };
// while (true)
// {
var pointer = FindPointer(baseAddress, staticPointerOffset, offsets);
var value = vam.ReadFloat(pointer);
Console.WriteLine(value);
if (value > 1)
{
vam.WriteFloat(pointer, 1);
return;
}
vam.WriteFloat(pointer, 15);
// }
}
private void IntervalEvent(Object source, ElapsedEventArgs e)
{
if (!connected)
{
return;
}
valX = vam.ReadFloat(BaseX);
valY = vam.ReadFloat(BaseY);
valZ = vam.ReadFloat(BaseZ);
valMX = vam.ReadFloat(BaseMX);
valMY = vam.ReadFloat(BaseMY);
valMZ = vam.ReadFloat(BaseMZ);
valSX = vam.ReadFloat(BaseSX);
valSY = vam.ReadFloat(BaseSY);
valSZ = vam.ReadFloat(BaseSZ);
valAX = vam.ReadFloat(BaseAX);
valAY = vam.ReadFloat(BaseAY);
ui.updateAllValues();
if (lockedX)
{
vam.WriteFloat(BaseX, valLockX);
vam.WriteFloat(BaseSX, valLockSX);
}
if (lockedY)
{
vam.WriteFloat(BaseY, valLockY);
vam.WriteFloat(BaseSY, valLockSY);
}
if (lockedZ)
{
vam.WriteFloat(BaseZ, valLockZ);
vam.WriteFloat(BaseSZ, valLockSZ);
}
if (lockedSX)
{
vam.WriteFloat(BaseSX, valLockSX);
}
if (lockedSY)
{
vam.WriteFloat(BaseSY, valLockSY);
}
if (lockedSZ)
{
vam.WriteFloat(BaseSZ, valLockSZ);
}
if (moonjump && !singleJump)
{
if (valSY > 0)
{
vam.WriteFloat(BaseSY, 5000f);
singleJump = true;
}
}
if (valSY == 0)
{
singleJump = false;
}
if (singleJump)
{
if (valSY < -2880)
{
vam.WriteFloat(BaseSY, -2830);
}
}
if (superSpeed)
{
if (currentKeys.Contains(KeyboardHook.VK.VK_W) && currentKeys.Contains(KeyboardHook.VK.VK_D))
{
turnValue = 45;
}
else if (currentKeys.Contains(KeyboardHook.VK.VK_W) && currentKeys.Contains(KeyboardHook.VK.VK_A))
{
turnValue = 315;
}
else if (currentKeys.Contains(KeyboardHook.VK.VK_S) && currentKeys.Contains(KeyboardHook.VK.VK_D))
{
turnValue = 135;
}
else if (currentKeys.Contains(KeyboardHook.VK.VK_S) && currentKeys.Contains(KeyboardHook.VK.VK_A))
{
turnValue = 225;
}
else if (currentKeys.Contains(KeyboardHook.VK.VK_W))
{
turnValue = 0;
}
else if (currentKeys.Contains(KeyboardHook.VK.VK_A))
{
turnValue = 270;
}
else if (currentKeys.Contains(KeyboardHook.VK.VK_S))
{
turnValue = 180;
}
else if (currentKeys.Contains(KeyboardHook.VK.VK_D))
{
turnValue = 90;
}
if (currentKeys.Contains(KeyboardHook.VK.VK_W) || currentKeys.Contains(KeyboardHook.VK.VK_A) || currentKeys.Contains(KeyboardHook.VK.VK_S) || currentKeys.Contains(KeyboardHook.VK.VK_D))
{
vam.WriteFloat(BaseSX, (float)Math.Cos((Math.PI / 180) * (valAX + turnValue)) * 5000);
vam.WriteFloat(BaseSZ, (float)Math.Sin((Math.PI / 180) * (valAX + turnValue)) * 5000);
}
else
{
if (!lockedSX)
{
vam.WriteFloat(BaseSX, 0);
}
if (!lockedSZ)
{
vam.WriteFloat(BaseSZ, 0);
}
}
}
if (flyMode)
{
if (currentKeys.Contains(KeyboardHook.VK.VK_SPACE))
{
valLockY += 100;
}
if (currentKeys.Contains(KeyboardHook.VK.VK_LSHIFT))
{
valLockY -= 100;
}
vam.WriteFloat(BaseSX, 0);
vam.WriteFloat(BaseSY, 0);
vam.WriteFloat(BaseSZ, 0);
if (currentKeys.Contains(KeyboardHook.VK.VK_W))
{
valX = (((float)Math.Cos((Math.PI / 180) * valAX) * 100) + valX);
valZ = (((float)Math.Sin((Math.PI / 180) * valAX) * 100) + valZ);
}
if (currentKeys.Contains(KeyboardHook.VK.VK_A))
{
valX = (((float)Math.Sin((Math.PI / 180) * valAX) * 100) + valX);
valZ = (((float)Math.Cos((Math.PI / 180) * valAX) * -100) + valZ);
}
if (currentKeys.Contains(KeyboardHook.VK.VK_S))
{
valX = (((float)Math.Cos((Math.PI / 180) * valAX) * -100) + valX);
valZ = (((float)Math.Sin((Math.PI / 180) * valAX) * -100) + valZ);
}
if (currentKeys.Contains(KeyboardHook.VK.VK_D))
{
valX = (((float)Math.Sin((Math.PI / 180) * valAX) * -100) + valX);
valZ = (((float)Math.Cos((Math.PI / 180) * valAX) * 100) + valZ);
}
vam.WriteFloat(BaseX, valX);
vam.WriteFloat(BaseZ, valZ);
vam.WriteFloat(BaseY, valLockY);
}
if (lowGravity && valSY <= -500)
{
vam.WriteFloat(BaseSY, -400);
}
int newHash = calculateHashOfValues();
if (hashOfValues == newHash)
{
checkCounter++;
}
hashOfValues = newHash;
if (checkCounter >= 150)
{
checkCounter = 0;
setupAddresses();
}
}
public float getValueFloat(IntPtr address)
{
return(vam.ReadFloat(address));
}
private static IntPtr HookCallback(int nCode, IntPtr wParam, IntPtr lParam)
{
if (!Vam.CheckProcess())
{
UnhookWindowsHookEx(_hookID);
Environment.Exit(0);
}
if (nCode >= 0 && wParam == (IntPtr)WM_KEYDOWN)
{
int vkCode = Marshal.ReadInt32(lParam);
if (vkCode == (int)KeyDefinitions.F1 || vkCode == (int)KeyDefinitions.F2 || vkCode == (int)KeyDefinitions.F3 ||
vkCode == (int)KeyDefinitions.F4)
{
int baseAddressX = Vam.ReadInt32((IntPtr)(Vam.getBaseAddress + 0x00383200));
int offsetsAddedX = Vam.ReadInt32((IntPtr)baseAddressX + 0x0);
offsetsAddedX = Vam.ReadInt32((IntPtr)offsetsAddedX + 0x10);
float x = Vam.ReadFloat((IntPtr)offsetsAddedX + 0x40);
int baseAddressY = Vam.ReadInt32((IntPtr)(Vam.getBaseAddress + 0x00386AE0));
int offsetsAddedY = Vam.ReadInt32((IntPtr)baseAddressY + 0x0);
float y = Vam.ReadFloat((IntPtr)offsetsAddedY + 0x44);
int baseAddressZ = Vam.ReadInt32((IntPtr)(Vam.getBaseAddress + 0x00383200));
int offsetsAddedZ = Vam.ReadInt32((IntPtr)baseAddressZ + 0x10);
offsetsAddedZ = Vam.ReadInt32((IntPtr)offsetsAddedZ + 0x18);
offsetsAddedZ = Vam.ReadInt32((IntPtr)offsetsAddedZ + 0x10);
float z = Vam.ReadFloat((IntPtr)offsetsAddedZ + 0x48);
Form1 form = (Form1)Application.OpenForms["Form1"];
if (vkCode == (int)KeyDefinitions.F1 || vkCode == (int)KeyDefinitions.F3)
{
if (vkCode == (int)KeyDefinitions.F1)
{
form.label10.Text = x.ToString();
form.label11.Text = y.ToString();
form.label12.Text = z.ToString();
}
else if (vkCode == (int)KeyDefinitions.F3)
{
form.label13.Text = x.ToString();
form.label14.Text = y.ToString();
form.label15.Text = z.ToString();
}
}
else if (vkCode == (int)KeyDefinitions.F2 || vkCode == (int)KeyDefinitions.F4)
{
if (vkCode == (int)KeyDefinitions.F2)
{
Vam.WriteFloat((IntPtr)offsetsAddedX + 0x40, float.Parse(form.label10.Text));
Vam.WriteFloat((IntPtr)offsetsAddedY + 0x44, float.Parse(form.label11.Text));
Vam.WriteFloat((IntPtr)offsetsAddedZ + 0x48, float.Parse(form.label12.Text));
}
else
{
Vam.WriteFloat((IntPtr)offsetsAddedX + 0x40, float.Parse(form.label13.Text));
Vam.WriteFloat((IntPtr)offsetsAddedY + 0x44, float.Parse(form.label14.Text));
Vam.WriteFloat((IntPtr)offsetsAddedZ + 0x48, float.Parse(form.label15.Text));
}
}
}
}
return(CallNextHookEx(_hookID, nCode, wParam, lParam));
}
private void updateHealth_Tick(object sender, EventArgs e)
{
float health = vam.ReadFloat((IntPtr)aHealth);
label2.Text = Convert.ToString(health);
}
public float GetPlayerX(VAMemory vam, int localplayeraddr) //front to back
{
float x = vam.ReadFloat((IntPtr)localplayeraddr + o_coordinates);
return(x);
}
public float GetPlayerY(VAMemory vam, int localplayeraddr) //side to side
{
float y = vam.ReadFloat((IntPtr)localplayeraddr + o_coordinates + 4);
return(y);
}
public float GetPlayerZ(VAMemory vam, int localplayeraddr) //up and down
{
float z = vam.ReadFloat((IntPtr)localplayeraddr + o_coordinates + 8);
return(z);
}
public float GetPlayerPitch(VAMemory vam, int localplayeraddr) //up and down
{
float pitch = vam.ReadFloat((IntPtr)localplayeraddr + o_viewangle_pitch);
return(pitch);
}
public float GetPlayerYaw(VAMemory vam, int localplayeraddr) //up and down
{
float yaw = vam.ReadFloat((IntPtr)localplayeraddr + o_viewangle_yaw);
return(yaw);
}
public Vector GetPlayerPosition()
{
Vector player;
player.x = vam.ReadFloat((IntPtr)d.localPlayer + Netvars.m_vecOrigin + 0x0) + vam.ReadFloat((IntPtr)d.localPlayer + Netvars.m_vecViewOffset + 0x0);
player.y = vam.ReadFloat((IntPtr)d.localPlayer + Netvars.m_vecOrigin + 0x4) + vam.ReadFloat((IntPtr)d.localPlayer + Netvars.m_vecViewOffset + 0x4);
player.z = vam.ReadFloat((IntPtr)d.localPlayer + Netvars.m_vecOrigin + 0x8) + vam.ReadFloat((IntPtr)d.localPlayer + Netvars.m_vecViewOffset + 0x8);
return(player);
}
public float ReadFloat(int offsets)
{
return(vam.ReadFloat((IntPtr)offsets));
}