[Link]

com/foro/dota/the-international-2014-514369/76
using System;
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
using [Link];
namespace DotaHPLED
{
public partial class Form1 : Form
{
#region World Vars
Byte[] Queend = new Byte[] { 0x51, 0x75, 0x65, 0x00, 0x00, 0x80, 0xBF, 0
x00, 0x65, 0x6E, 0x64 };
int CurrentHealthOffset = 47;
int MaxHealthOffset = 51;
int DeadOffset = -22;
int TimerOffset = 12799;
Process Dota2;
IntPtr CHealthAddress;
IntPtr MHealthAddress;
IntPtr DeadAddress;
IntPtr TimerAddress;
const int PROCESS_WM_READ = 0x0010;
private volatile int _current = 0;
private volatile int _max = 1;
private volatile int _death = 0;
private volatile int _time = 0;
SerialPort ard = new SerialPort("COM3", 9600);
#endregion
#region Variable Accessors
public int CurrentHealth
{
get
{
return _current;
}
set
{
_current = value;
}
}
public int MaximumHealth
{
get
{
return _max;
}
set
{
_max = value;
}
}
public int DeathStatus
{
get
{
return _death;
}
set
{
_death = value;
}
}
public int RespawnTimer
{
get
{
return _time;
}
set
{
_time = value;
}
}
#endregion
#region Form Operations
public Form1()
{
InitializeComponent();
}
private void Form1_FormClosing(object sender, FormClosingEventArgs e)
{
[Link]();
[Link]();
}
private void Form1_Load(object sender, EventArgs e)
{
[Link] = 230;
//lights = new Button[] { light1, light2, light3, light4, light5, li
ght6, light7, light8, light9, light10 };
//offAll();
}
#endregion
#region Button Operations
private void findProcess_Click(object sender, EventArgs e)
{
Process[] tempList = [Link]("dota");
if ([Link] > 1)
{
[Link]("Multiple instances of Dota 2 found! Narrow thes
e down to one!");
}
else
{
Dota2 = tempList[0];
[Link] = "Yes";
[Link] = [Link]();
}
}
private void hookHealth_Click(object sender, EventArgs e)
{
[Link] = 270;
IntPtr QueendAddress = addressSearch(Dota2, Queend);
if ([Link]([Link]))
{
[Link] = 230;
[Link]("Failure to find");
}
else
{
CHealthAddress = new IntPtr(QueendAddress.ToInt32() + CurrentHea
lthOffset);
MHealthAddress = new IntPtr(QueendAddress.ToInt32() + MaxHealthO
ffset);
DeadAddress = new IntPtr(QueendAddress.ToInt32() + DeadOffset);
TimerAddress = new IntPtr(QueendAddress.ToInt32() + TimerOffset)
;
try
{
[Link]();
[Link] = "Online";
[Link] = [Link];
}
catch (Exception l)
{
[Link]("Unable to open Arduino port, please try aga
in.\n" + [Link]());
}
}
}
#endregion
#region Find Address
public IntPtr addressSearch(Process dota, byte[] toSearch)
{
IntPtr p = OpenProcess(0x10, true, [Link]); //0x10-read
[Link] = 270;
uint PTR = 0x03000000; //begin of memory
byte[] buff = new byte[[Link]];
int bytesRead;
while (PTR < 0x04000000) //end of memory // u can specify to read
less if u know he does not fill it all
{
ReadProcessMemory(p, new IntPtr(PTR), buff, [Link], out byt
esRead);
int testCase = SpecialByteCompare(buff, toSearch);
switch (testCase)
{
case 2:
return new IntPtr(PTR);
case 1:
PTR += (uint)[Link];
break;
case 0:
PTR += 0x1;
break;
case -1:
throw new ImpossibleExceptionException();
}
}
return [Link];
}
private static int SpecialByteCompare(byte[] comparingTo, byte[] compari
ngWith) //read memory, first byte array, second byte array, number of missing b
yte's
{
if ([Link] != ([Link]))
{
return -1;
}
if (![Link]<byte>(comparingWith[0]))
{
return 1;
}
for (int i = 0; i < [Link]; i++)
{
if (comparingTo[i] != comparingWith[i])
return 0;
}
return 2;
}
#region Imported
[DllImport("[Link]", SetLastError = true)]
[return: MarshalAs([Link])]
static extern bool CloseHandle(IntPtr hObject);
[DllImport("[Link]")]
public static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInher
itHandle, int dwProcessId);
[DllImport("[Link]", SetLastError = true)]
static extern bool ReadProcessMemory(
IntPtr hProcess,
IntPtr lpBaseAddress,
[Out] byte[] lpBuffer,
int dwSize,
out int lpNumberOfBytesRead
);
#endregion
#endregion
#region Thread
Watcher bob;
Thread voyeurThread;
//Goulding ellie;
//Thread lightsThread;
bool running = false;

delegate void SetTextCallback(int Chealth, int Mhealth, int Dead, int RT
ime);
public void updateNumbers(int Chealth, int Mhealth, int Dead, int RTime)
{
if ([Link] || [Link] || lab
[Link] || [Link])
{
SetTextCallback d = new SetTextCallback(updateNumbers);
[Link](d, new object[] { Chealth, Mhealth, Dead, RTime });
}
else
{
_current = Chealth;
_max = Mhealth;
_death = (Dead > 70000) ? 0 : 1;
_time = (RTime >= 0) ? RTime : 0;
[Link](_current.ToString()+";"+_max.ToString()+";"+_death.ToS
tring()+";"+_time.ToString());
[Link] = _current.ToString();
[Link] = _max.ToString();
[Link] = _death.ToString();
[Link] = _time.ToString();
[Link] = [Link]();
}
}
private void buttonBegin_Click(object sender, EventArgs e)
{
if (!running)
{
bob = new Watcher(Dota2, CHealthAddress, MHealthAddress, DeadAdd
ress, TimerAddress, this);
voyeurThread = new Thread([Link]);
[Link] = true;
[Link]();
//ellie = new Goulding(this);
//lightsThread = new Thread([Link]);
//[Link] = true;
//[Link]();
[Link] = "Stop Evaluation";
}
else
{
//[Link]();
//[Link]();
[Link]();
[Link]();
[Link] = "Begin Evaluation";
}
}
#endregion

#region Lights Functions
/*
Button[] lights;
public void turnOn(params int[] lightNumbers)
{
for (int i = 0; i < [Link]; i++)
{
lights[i].BackColor = [Link];
}
}
public void turnOff(params int[] lightNumbers)
{
for (int i = 0; i < [Link]; i++)
{
lights[i].BackColor = [Link];
}
}
public void onAll()
{
for (int i = 0; i < [Link]; i++)
{
lights[i].BackColor = [Link];
}
}
public void offAll()
{
for (int i = 0; i < [Link]; i++)
{
lights[i].BackColor = [Link];
}
}*/
#endregion
}
public class Watcher
{
Process Dota2;
IntPtr CHealthAddress;
IntPtr MHealthAddress;
IntPtr DeadAddress;
IntPtr TimerAddress;
Form1 Owner;
[DllImport("[Link]")]
public static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInher
itHandle, int dwProcessId);
[DllImport("[Link]", SetLastError = true)]
static extern bool ReadProcessMemory(
IntPtr hProcess,
IntPtr lpBaseAddress,
[Out] byte[] lpBuffer,
int dwSize,
out int lpNumberOfBytesRead
);
public Watcher(Process dota, IntPtr ch, IntPtr mh, IntPtr d, IntPtr t, F
orm1 _owner)
{
Dota2 = dota;
CHealthAddress = ch;
MHealthAddress = mh;
DeadAddress = d;
TimerAddress = t;
Owner = _owner;
}
private volatile bool working = true;
public void PleaseWatch()
{
IntPtr p = OpenProcess(0x10, true, [Link]); //0x10-read
int bytesRead = 0;
while (working)
{
byte[] currentHealth = new byte[4];
ReadProcessMemory(p, CHealthAddress, currentHealth, 4, out bytes
Read);
byte[] maxHealth = new byte[4];
ReadProcessMemory(p, MHealthAddress, maxHealth, 4, out bytesRead
);
byte[] deadStatus = new byte[4];
ReadProcessMemory(p, DeadAddress, deadStatus, 4, out bytesRead);
byte[] respawnTimer = new byte[4];
ReadProcessMemory(p, TimerAddress, respawnTimer, 4, out bytesRea
d);
[Link](BitConverter.ToInt32(currentHealth, 0), BitC
onverter.ToInt32(maxHealth, 0), BitConverter.ToInt32(deadStatus, 0), BitConverte
r.ToInt32(respawnTimer, 0));
[Link](20);
}
}
public void StopWatching()
{
working = false;
}
}
public class ImpossibleExceptionException : Exception
{
public ImpossibleExceptionException() { }
public ImpossibleExceptionException(String message) : base(message) { }
}
/*
public class Goulding
{
private Form1 _parent;
private volatile bool working = true;
public Goulding(Form1 parent)
{
_parent = parent;
}
public void repetition()
{
int lightsOn = 0;
int startRespawnTime = 0;
while (working)
{
if (_parent.DeathStatus == 0)
{
startRespawnTime = 0;
double frac = _parent.CurrentHealth / _parent.MaximumHealth;
int nowLights = (int)[Link](frac * 10);
if (nowLights > lightsOn)
{
int[] onCommand = new int[nowLights - lightsOn];
for(int i=0;i<[Link];i++)
{
onCommand[i] = lightsOn + i;
}
_parent.turnOn(onCommand);
}
else if(lightsOn > nowLights)
{
int[] offCommand = new int[lightsOn - nowLights];
for (int i = 0; i < [Link]; i++)
{
offCommand[i] = nowLights - i;
}
_parent.turnOff(offCommand);
}
}
else
{
if (startRespawnTime == 0)
{
startRespawnTime = _parent.RespawnTimer;
_parent.offAll();
}
}
}
}
public void stopRepetition()
{
working = false;
}
}
*/
}