public void WriteGlowObject(GlowObjectDefinition def, int index)
{
byte[] data = def.GetBytes();
byte[] writeData = new byte[GlowObjectDefinition.GetSize() - 14];
Array.Copy(data, 4, writeData, 0, writeData.Length);
int glowAddr = WinAPI.ReadInt32(scanner.Process.Handle, dllClientAddress + GameOffsets.CL_GLOWMANAGER);
WinAPI.WriteMemory(scanner.Process.Handle, glowAddr + GlowObjectDefinition.GetSize() * index + 4, writeData, writeData.Length);
}
public void EncolorObject(GlowObjectDefinition obj, Color color, int index)
{
obj.m_bRenderWhenOccluded = 1;
obj.m_bRenderWhenUnoccluded = 0;
obj.m_bFullBloom = 0;
obj.a = color.A;
obj.r = color.R;
obj.g = color.G;
obj.b = color.B;
WriteElement(obj, index);
}
public void WriteElement(GlowObjectDefinition obj, int index)
{
if (Array.Length <= index)
{
return;
}
try
{
int address = glowManager.m_pGlowArray + RPMLazyArray <GlowObjectDefinition> .Size * index;
Program.Hack.Memory.Write <GlowObjectDefinition>(address, obj, 0x04, 0x14); //colors
Program.Hack.Memory.Write <GlowObjectDefinition>(address, obj, 0x24, 0x03); //flags
}catch { }
}
private void DrawEntity(WindowRenderTarget device, Player currentPlayer, Entity entity)
{
if (entity == null)
{
return;
}
if (entity.Address == currentPlayer.Address)
{
return;
}
if (!entity.IsValid())
{
return;
}
//if (!Geometry.PointSeesPoint(currentPlayer.Vector2, entity.Vector2, Player.FOV_DEGREE, currentPlayer.Yaw))
// return;
Color brushColor = lifeBarForeground;
Vector2 point = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, entity.Vector3);
if (point == Vector2.Zero)
{
return;
}
Vector3 entPoint = entity.Vector3;
float distance = Geometry.GetDistanceToPoint(currentPlayer.Vector3, entity.Vector3);
float distanceMeter = currentPlayer.DistanceToOtherEntityInMetres(entity);
float boxBorder = 6400f / distance;
float scale = 0.5f / distanceMeter;
float rectX = point.X, rectY = point.Y, rectW = 24f * scale, rectH = 24f * scale;
switch (entity.ClassID)
{
case Data.Enums.ClassID.Weapon:
brushColor = Color.Green;
if (csgo.GetValue <YesNo>("espDrawWeapons") == YesNo.No)
{
return;
}
if (entity.OwnerEntity != -1)
{
return;
}
break;
case Data.Enums.ClassID.Hostage:
brushColor = Color.LemonChiffon;
return;
case Data.Enums.ClassID.C4:
if (currentPlayer.Index == entity.OwnerEntity)
{
return;
}
brushColor = Color.DarkRed;
//if (entity.OwnerEntity > -1 && entity.OwnerEntity < csgo.Players.Length - 1)
//{
// point = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, csgo.Players[entity.OwnerEntity - 1].Skeleton.Spine4);
// rectX = point.X;
// rectY = point.Y;
// FillEllipse(device, Color.DarkRed * 0.25f, point.X, point.Y, csgo.ScreenSize.Height / 2f, csgo.ScreenSize.Height / 2f, true);
// entPoint = csgo.Players[entity.OwnerEntity - 1].Skeleton.Spine4;
//}
break;
case Data.Enums.ClassID.PlantedC4:
brushColor = Color.DarkRed;
//FillEllipse(device, Color.DarkRed * 0.25f, point.X, point.Y, csgo.ScreenSize.Height / 2f, csgo.ScreenSize.Height / 2f, true);
break;
default:
return;
}
if (entity.ClassID == Data.Enums.ClassID.Chicken || entity.ClassID == Data.Enums.ClassID.Hostage)
{
//Paint bones
//List<Vector3> allBones = new List<Vector3>();
//if (distanceMeter < 20)
// allBones.AddRange(entity.Skeleton.Arms);
//allBones.AddRange(entity.Skeleton.Legs);
//allBones.AddRange(entity.Skeleton.Spine);
//allBones.Add(entity.Skeleton.Neck);
//for (int i = allBones.Count - 1; i >= 0; i--)
// if (allBones[i] == Vector3.Zero)
// allBones.RemoveAt(i);
//Vector2[] all = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, allBones.ToArray());
//allBones.Clear();
//allBones = null;
//rectX = GetSmallestX(all);
//rectW = GetBiggestX(all);
//rectY = GetSmallestY(all);
//rectH = GetBiggestY(all);
//rectW -= rectX;
//rectH -= rectY;
}
rectX -= boxBorder;
rectY -= boxBorder;
rectW += boxBorder * 2f;
rectH += boxBorder * 2f;
#region glow
if (csgo.GetValue <YesNo>("espGlowEnabled") == YesNo.Yes)
{
if (csgo.GlowObjects != null)
{
CSGOGameController controller = (CSGOGameController)Program.GameController;
int idx = controller.MemoryUpdater.GetGlowObjectByAddress((int)entity.Address);
if (idx != -1)
{
GlowObjectDefinition def = csgo.GlowObjects[idx];
def.a = 1f;// (float)(brushColor.A / 255f);
def.r = (float)(brushColor.R / 255f);
def.g = (float)(brushColor.G / 255f);
def.b = (float)(brushColor.B / 255f);
def.m_bRenderWhenOccluded = true;
def.m_bRenderWhenUnoccluded = true;
controller.MemoryUpdater.WriteGlowObject(def, idx);
}
}
}
#endregion
if (point != Vector2.Zero)
{
#region box
if (csgo.GetValue <OnOff>("espDrawBox") == OnOff.On)
{
//Draw box
DrawW2SBox(device,
brushColor,
entPoint - Vector3.UnitZ * 8,
16f,
16f,
entity.Yaw + 45f,
15f / distanceMeter);
}
#endregion
#region distance
if (csgo.GetValue <OnOff>("espDrawDistance") == OnOff.On)
{
////Draw text
DrawText(device,
foreColor,
backColor,
rectX,
rectY + rectH,
100f,
20f,
1f,
1f,
Math.Round(distanceMeter, 0).ToString() + "m",
FactoryManager.GetFont("smallSegoe"));
}
#endregion
string name = entity.Name;
if (
entity.ClassID != Data.Enums.ClassID.Chicken &&
entity.ClassID != Data.Enums.ClassID.Hostage &&
entity.ClassID != Data.Enums.ClassID.CSPlayer &&
entity.ClassID != Data.Enums.ClassID.Weapon &&
entity.ClassID != Data.Enums.ClassID.C4 &&
entity.ClassID != Data.Enums.ClassID.PlantedC4)
{
name = String.Format("{0} (ID#{1})", name, entity.ClassID);
}
DrawText(device,
foreColor,
backColor,
rectX,
rectY - 20f,
100f,
20f,
1f,
1f,
name,
FactoryManager.GetFont("smallSegoe"));
}
}
private void DrawPlayer(WindowRenderTarget device, Player currentPlayer, Player player)
{
if (player == null)
{
return;
}
if (player.Index == currentPlayer.Index)
{
return;
}
if (!player.IsValid())
{
return;
}
if (csgo.GetValue <Target>("espDrawTarget") == Target.Enemies && player.InTeam == currentPlayer.InTeam)
{
return;
}
if (csgo.GetValue <Target>("espDrawTarget") == Target.Allies && player.InTeam != currentPlayer.InTeam)
{
return;
}
player.CheckYaw();
Vector2 point = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, (player.Vector3));
if (point == Vector2.Zero)
{
return;
}
float distance = Geometry.GetDistanceToPoint(currentPlayer.Vector3, player.Vector3);
float height = 36000f / distance;
float width = 18100f / distance;
Color colorPlayer = player.InTeam == Team.Terrorists ?
(player.SeenBy(currentPlayer) ? colorTSpotted : colorT) :
(player.SeenBy(currentPlayer) ? colorCTSpotted : colorCT);
float distanceMeter = currentPlayer.DistanceToOtherEntityInMetres(player);
float head = 3200f / distance;
float boxBorder = 6400f / distance;
bool highlighted = csgo.Highlighted[player.Index - 1];
//Paint bones
List <Vector3> allBones = new List <Vector3>();
allBones.AddRange(player.Skeleton.Legs);
allBones.AddRange(player.Skeleton.Spine);
allBones.Add(player.Skeleton.HeadEnd);
Vector2[] all = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, allBones.ToArray());
foreach (Vector2 vec in all)
{
if (vec == Vector2.Zero)
{
return;
}
}
Vector2[] arms = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, player.Skeleton.Arms);
Vector2[] legs = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, player.Skeleton.Legs);
Vector2[] spine = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, player.Skeleton.Spine);
allBones.Clear();
allBones = null;
float rectX = GetSmallestX(all) + 5, rectW = GetBiggestX(all) + 5, rectY = GetSmallestY(all) + 5, rectH = GetBiggestY(all) + 5;
//rectW -= rectX;
rectH -= rectY;
rectW = rectH * 0.3f;
rectX = point.X - rectW / 2f;
#region glow
if (csgo.GetValue <YesNo>("espGlowEnabled") == YesNo.Yes)
{
if (csgo.GlowObjects != null)
{
CSGOGameController controller = (CSGOGameController)Program.GameController;
int idx = controller.MemoryUpdater.GetGlowObjectByAddress((int)player.Address);
if (idx != -1)
{
GlowObjectDefinition def = csgo.GlowObjects[idx];
def.a = (float)(colorPlayer.A / 255f);
def.r = (float)(colorPlayer.R / 255f);
def.g = (float)(colorPlayer.G / 255f);
def.b = (float)(colorPlayer.B / 255f);
def.m_bRenderWhenOccluded = true;
def.m_bRenderWhenUnoccluded = true;
def.m_bFullBloom = false;
if (csgo.GetValue <YesNo>("espGlowFadingEnabled") == YesNo.Yes)
{
float dist = currentPlayer.DistanceToOtherEntityInMetres(player);
float range = csgo.GetValue <float>("espGlowFadingDistance");
if (dist <= range)
{
def.a = 1f - 1f / range * dist;
controller.MemoryUpdater.WriteGlowObject(def, idx);
}
}
else
{
controller.MemoryUpdater.WriteGlowObject(def, idx);
}
}
}
}
#endregion
#region skeleton
if (csgo.GetValue <OnOff>("espDrawSkeleton") == OnOff.On)
{
if (distanceMeter < 20)
{
DrawBones(device,
colorPlayer,
arms,
1.5f,
player.InTeam
);
}
DrawBones(device,
colorPlayer,
legs,
1.5f,
player.InTeam
);
DrawBones(device,
colorPlayer,
spine,
1.5f,
player.InTeam
);
}
if (player.Skeleton.AllBones != null)
{
for (int i = 0; i < player.Skeleton.AllBones.Length; i++)
{
Vector2 boneHead = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, player.Skeleton.AllBones[i]);
DrawText(device,
foreColor,
backColor,
boneHead.X,
boneHead.Y,
100f,
20f,
1f,
1f,
i.ToString(),
FactoryManager.GetFont("largeSegoe"));
}
}
#endregion
#region lines
if (csgo.GetValue <OnOff>("espDrawLines") == OnOff.On)
{
Color color = colorPlayer;
if (!player.IsSpotted)
{
color *= 0.5f;
}
else
{
color *= (0.75f + 0.25f * GetColorMultiplier());
}
FillPolygon(device,
color,
new Vector2(csgo.ScreenSize.Width / 2f, csgo.ScreenSize.Height),
new Vector2(point.X - width / 2f, point.Y),
new Vector2(point.X + width / 2f, point.Y));
}
#endregion
#region box
//Draw box
if (csgo.GetValue <OnOff>("espDrawBox") == OnOff.On)
{
this.DrawRectangle(device,
colorPlayer,
rectX,
rectY,
rectW,
rectH,
1f);
}
#endregion
#region circle
if (csgo.GetValue <OnOff>("espDrawCircle") == OnOff.On)
{
Vector3[] circPoints = Geometry.Create3DFlatCircle(
player.Vector3,
32f + (player.IsSpotted ? 16f * GetColorMultiplier() : 0f),
32);
Vector2[] scrCircPoints = Geometry.WorldToScreen(csgo.ViewMatrix, csgo.ScreenSize, circPoints);
DrawLines(device, colorPlayer, 15f / distanceMeter, scrCircPoints);
}
#endregion
#region distance
if (csgo.GetValue <OnOff>("espDrawDistance") == OnOff.On)
{
string distString = Math.Round(distanceMeter, 0).ToString() + "m";
RectangleF distSize = Control.MeasureString(this.Font, distString);
//Draw text
DrawText(device,
foreColor,
backColor,
rectX + rectW / 2f - distSize.Width / 2f,
rectY + rectH,
100f,
20f,
1f,
1f,
distString,
FactoryManager.GetFont("smallSegoe"));
}
#endregion
#region highlight
if (highlighted)
{
float size = (float)Math.Max(rectW + boxBorder, rectH + boxBorder) * 2f;
Color color = (colorPlayer) * (0.5f + 0.5f * GetColorMultiplier());
FillEllipse(
device,
color * 0.5f,
rectX + rectW / 2f,
rectY + rectH / 2f,
size,
size,
true);
DrawEllipse(device,
color, //* (DateTime.Now.Millisecond % 1000f / 1000f),
rectX + rectW / 2f,
rectY + rectH / 2f,
size,
size,
true,
1.5f);
}
#endregion
#region name
if (csgo.GetValue <OnOff>("espDrawName") == OnOff.On)
{
////Name
//DrawText(device,
// foreColor,
// backColor,
// rectX + rectW,
// rectY - boxBorder,
// 100f,
// 20f,
// 1f,
// 1f,
// (player.IsDormant ? "[DORMANT] " : "") + player.Name,
// FactoryManager.GetFont("smallSegoe"));
////Info
//string weaponInfo = "-";
//if (player.WeaponIndex >= 0 && player.WeaponIndex < csgo.Entities.Length)
//{
// if (csgo.Entities[player.WeaponIndex] != null)
// weaponInfo = csgo.Entities[player.WeaponIndex].Name;
//}
//string data = String.Format(
//"Weapon: {0}",
// /*player.Health, player.Armor,*/ weaponInfo);
//if (csgo.GetValue<OnOff>("espDrawDetails") == OnOff.On)
// data = String.Format("{0}\n" +
// "Balance: ${1}\n" +
// "Kills: {2}\n" +
// "Assists: {3}\n" +
// "Deaths: {4}\n" +
// "Score: {5}",
// data, player.Money, player.Kills, player.Assists, player.Deaths, player.Score);
//DrawText(device,
// foreColor,
// backColor,
// rectX + rectW,
// rectY - boxBorder + 16f,
// 100f,
// 20f,
// 1f,
// 1f,
// data,
// FactoryManager.GetFont("tinySegoe"));
string weaponInfo = "-";
if (player.WeaponIndex >= 0 && player.WeaponIndex < csgo.Entities.Length)
{
if (csgo.Entities[player.WeaponIndex] != null)
{
weaponInfo = csgo.Entities[player.WeaponIndex].Name;
}
}
string str = string.Format("{0}\n[{1}]", player.Name, weaponInfo);
RectangleF size = Control.MeasureString(this.Font, str);
//Name
DrawText(device,
foreColor,
backColor,
rectX + rectW / 2f - size.Width / 2f,
rectY - 40,
100f,
20f,
2f,
2f,
str,
FactoryManager.GetFont("smallSegoe"));
}
#endregion
#region health
if (csgo.GetValue <OnOff>("espDrawHealth") == OnOff.On)
{
////HP
//FillRectangle(device,
// lifeBarBackground,
// rectX,
// rectY - lifeBarHeight * 3f,
// width, //rectW,
// lifeBarHeight /*10f*/);
//FillRectangle(device,
// lifeBarForeground,
// rectX,
// rectY - lifeBarHeight * 3f,
// /*rectW*/ width / 100f * player.Health,
// lifeBarHeight /*10f*/);
//DrawText(device,
// lifeBarForeground,
// backColor,
// rectX + width,
// rectY - lifeBarHeight * 3f - 2f,
// 100f,
// 20f,
// 1f,
// 1f,
// player.Health.ToString(),
// FactoryManager.GetFont("miniSegoe"));
////Armor
//FillRectangle(device,
// lifeBarBackground,
// rectX,
// rectY - lifeBarHeight * 2f,
// width, //rectW,
// lifeBarHeight /*10f*/);
//FillRectangle(device,
// viewColorOutline,
// rectX,
// rectY - lifeBarHeight * 2f,
// /*rectW*/ width / 100f * player.Armor,
// lifeBarHeight /*10f*/);
//DrawText(device,
// viewColorOutline,
// backColor,
// rectX + width,
// rectY - lifeBarHeight * 2f - 2f,
// 100f,
// 20f,
// 1f,
// 1f,
// player.Armor.ToString(),
// FactoryManager.GetFont("miniSegoe"));
//HP
FillRectangle(device,
lifeBarBackground,
rectX - lifeBarWidth,
rectY,
lifeBarWidth, //rectW,
rectH /*10f*/);
FillRectangle(device,
lifeBarForeground,
rectX - lifeBarWidth,
rectY,
lifeBarWidth,
rectH / 100f * player.Health /*10f*/);
DrawText(device,
lifeBarForeground,
backColor,
rectX - lifeBarWidth,
rectY + rectH,
100f,
20f,
1f,
1f,
player.Health.ToString(),
FactoryManager.GetFont("miniSegoe"));
//Armor
FillRectangle(device,
lifeBarBackground,
rectX + rectW,
rectY,
lifeBarWidth, //rectW,
rectH /*10f*/);
FillRectangle(device,
viewColorOutline,
rectX + rectW,
rectY,
lifeBarWidth,
rectH / 100f * player.Armor /*10f*/);
DrawText(device,
viewColorOutline,
backColor,
rectX + rectW,
rectY + rectH,
100f,
20f,
1f,
1f,
player.Armor.ToString(),
FactoryManager.GetFont("miniSegoe"));
}
#endregion
#region rank
if (player.Rank > 0)
{
//Scaling
float boxWidth = rectW, boxHeight = rectW * aspect;
/*
* Args:
* 1 actual bitmap
* 2 destination-rectangle
* 3 opacity
* 4 interpolation mode
* 5 source-rectangle - easy access using rank as index
*/
if (ranksBmp != null)
{
device.DrawBitmap(
ranksBmp,
new RectangleF(point.X - boxWidth / 2f, point.Y + 20f, boxWidth, boxHeight),
0.7f,
BitmapInterpolationMode.Linear,
new RectangleF(0f, 80f * (player.Rank - 1), 200f, 80f));
if (boxWidth > 50f)
{
DrawText(device, foreColor, point.X - boxWidth / 2f, point.Y + 20f + boxHeight + 4f, 200f, 100f, string.Format("MM-wins: {0}", player.Wins.ToString()), this.Font);
}
}
}
#endregion
}
public override void OnUpdaterTick()
{
if (Program.GameImplementation == null)
{
return;
}
if (Program.GameController == null)
{
return;
}
if (!Program.GameController.IsGameRunning)
{
return;
}
if (!Program.GameController.IsInGame)
{
return;
}
CSGOImplementation csgo = ((CSGOImplementation)Program.GameImplementation);
IntPtr handle = Program.GameImplementation.GameController.Process.Handle;
//Get addresses
if (!updatedOffsets)
{
FindOffsets();
}
entityListAddress = dllClientAddress + GameOffsets.CL_ENTITY_LIST;
localAddress = WinAPI.ReadInt32(handle, dllClientAddress + GameOffsets.CL_LOCAL_BASE_ENTITY);
radarAddress = WinAPI.ReadInt32(handle, dllClientAddress + GameOffsets.CL_RADAR_BASE);
radarAddress = WinAPI.ReadInt32(handle, radarAddress + GameOffsets.CL_RADAR_OFFSET); //B658BEC
scoreBoardAddress = WinAPI.ReadInt32(handle, dllClientAddress + GameOffsets.CL_SCRBRD_BASE);
enginePointer = WinAPI.ReadInt32(handle, dllEngineAddress + GameOffsets.EN_ENGINE_POINTER);
csgo.SignOnState = (SignOnState)WinAPI.ReadInt32(handle, enginePointer + GameOffsets.EN_SIGNONSTATE);
if (csgo.SignOnState < SignOnState.SIGNONSTATE_PRESPAWN || csgo.SignOnState > SignOnState.SIGNONSTATE_FULL)
{
return;
}
//General
csgo.ScreenSize = new SharpDX.Size2(Program.GameController.WindowArea.Width, Program.GameController.WindowArea.Height);
int targetIndex = WinAPI.ReadInt32(handle, localAddress + GameOffsets.CL_LOCAL_CROSSHAIR_TARGET);
Matrix4x4 viewMatrix = Matrix4x4.ReadMatrix(handle, dllClientAddress + GameOffsets.CL_LOCAL_VIEWMATRIX);
bool c4Planted = false;
//Refresh players
if (Environment.TickCount - newPlayers >= 1000)
{
newPlayers = Environment.TickCount;
csgo.Players = null;
csgo.Entities = null;
}
//Read scrbrd-data
byte[] scrbrdData = WinAPI.ReadMemory(handle, scoreBoardAddress, 0x1C38);
if (csgo.ScrBrdArmor == null)
{
csgo.ScrBrdArmor = new int[MAX_PLAYERS];
}
if (csgo.ScrBrdAssists == null)
{
csgo.ScrBrdAssists = new int[MAX_PLAYERS];
}
if (csgo.ScrBrdDeaths == null)
{
csgo.ScrBrdDeaths = new int[MAX_PLAYERS];
}
if (csgo.ScrBrdHealth == null)
{
csgo.ScrBrdHealth = new int[MAX_PLAYERS];
}
if (csgo.ScrBrdKills == null)
{
csgo.ScrBrdKills = new int[MAX_PLAYERS];
}
if (csgo.ScrBrdScore == null)
{
csgo.ScrBrdScore = new int[MAX_PLAYERS];
}
if (csgo.ScrBrdRanks == null)
{
csgo.ScrBrdRanks = new int[MAX_PLAYERS];
}
if (csgo.ScrBrdWins == null)
{
csgo.ScrBrdWins = new int[MAX_PLAYERS];
}
for (int i = 0; i < MAX_PLAYERS; i++)
{
csgo.ScrBrdArmor[i] = BitConverter.ToInt32(scrbrdData, GameOffsets.CL_SCRBRD_ARMOR + 4 * i);
csgo.ScrBrdAssists[i] = BitConverter.ToInt32(scrbrdData, GameOffsets.CL_SCRBRD_ASSISTS + 4 * i);
csgo.ScrBrdDeaths[i] = BitConverter.ToInt32(scrbrdData, GameOffsets.CL_SCRBRD_DEATHS + 4 * i);
csgo.ScrBrdHealth[i] = BitConverter.ToInt32(scrbrdData, GameOffsets.CL_SCRBRD_HEALTH + 4 * i);
csgo.ScrBrdKills[i] = BitConverter.ToInt32(scrbrdData, GameOffsets.CL_SCRBRD_KILLS + 4 * i);
csgo.ScrBrdScore[i] = BitConverter.ToInt32(scrbrdData, GameOffsets.CL_SCRBRD_SCORE + 4 * i);
csgo.ScrBrdRanks[i] = BitConverter.ToInt32(scrbrdData, GameOffsets.CL_SCRBRD_RANKING + 4 * i);
csgo.ScrBrdWins[i] = BitConverter.ToInt32(scrbrdData, GameOffsets.CL_SCRBRD_WINS + 4 * i);
}
//Read players & entities
if (csgo.Players == null)
{
csgo.Players = new Player[MAX_PLAYERS];
}
if (csgo.Entities == null)
{
csgo.Entities = new Entity[MAX_ENTITIES - MAX_PLAYERS];
}
int maxIndex = 2048;// = WinAPI.ReadInt32(handle, entityListAddress + 0x4);
//maxIndex -= entityListAddress;
//maxIndex /= GameOffsets.CL_ENTITY_SIZE;
byte[] entityList = WinAPI.ReadMemory(handle, entityListAddress, maxIndex * GameOffsets.CL_ENTITY_SIZE);
for (int i = 0; i < maxIndex; i++)
{
try
{
int address = BitConverter.ToInt32(entityList, GameOffsets.CL_ENTITY_SIZE * i);
if (address != 0)
{
if (i < 64)
{
if (csgo.Players[i] == null)
{
csgo.Players[i] = new Player(address, radarAddress + GameOffsets.CL_RADAR_SIZE * i, i + 1);
}
else
{
csgo.Players[i].Update(address, radarAddress + GameOffsets.CL_RADAR_SIZE * i, i + 1);
}
}
else
{
if (csgo.Entities[i - csgo.Players.Length] == null)
{
csgo.Entities[i - csgo.Players.Length] = new Entity(address, radarAddress, i);
}
else
{
csgo.Entities[i - csgo.Players.Length].Update(address, radarAddress, i);
}
//if (!entityClasses.ContainsKey(csgo.Entities[i - csgo.Players.Length].ClassIDInt))
// entityClasses.Add(csgo.Entities[i - csgo.Players.Length].ClassIDInt, csgo.Entities[i - csgo.Players.Length].Name);
if (!csgo.Entities[i - csgo.Players.Length].IsValid())
{
csgo.Entities[i - csgo.Players.Length] = null;
}
else
if (csgo.Entities[i - csgo.Players.Length].ClassID == ClassID.PlantedC4)
{
c4Planted = true;
}
}
}
} catch { }
}
//Get weaponID
long weaponHandle = WinAPI.ReadInt32(handle, localAddress + GameOffsets.CL_LOCAL_ACTIVE_WEAPON);
long weaponIDFirst = weaponHandle & 0xFFF;
long weaponBase = WinAPI.ReadInt32(handle, entityListAddress + ((weaponIDFirst - 1) * 0x10));
int weaponID = WinAPI.ReadInt32(handle, weaponBase + GameOffsets.CL_LOCAL_WEAPON_ID);
float accuracyPenality = WinAPI.ReadFloat(handle, weaponBase + GameOffsets.CL_LOCAL_WEAPON_ACCURACYPENALITY);
//int weaponShotsFired = WinAPI.ReadInt32(handle, localPlayer + GameOffsets.CL_LOCAL_WEAPON_SHOTS_FIRED);
//Debug.WriteLine(accuracyPenality);
ZoomLevel zoom = (ZoomLevel)WinAPI.ReadMemory(handle, weaponBase + GameOffsets.CL_LOCAL_WEAPON_ZOOM, 1)[0];
bool isReloading = WinAPI.ReadMemory(handle, weaponBase + GameOffsets.CL_LOCAL_WEAPON_RELOAD, 1)[0] == 1;
//Get clips
long clip1 = WinAPI.ReadInt32(handle, dllClientAddress + GameOffsets.CL_RADAR_BASE);
long clip2 = WinAPI.ReadInt32(handle, clip1 + GameOffsets.CL_WEAPON_OFFSET);
int weaponClip1 = WinAPI.ReadInt32(handle, clip2 + GameOffsets.CL_WEAPON_AMMO_PRIM);
int weaponClip2 = WinAPI.ReadInt32(handle, clip2 + GameOffsets.CL_WEAPON_AMMO_SEC);
//Angles
csgo.ViewAngles = ReadAngle(handle, enginePointer + GameOffsets.EN_VIEWANGLE_X);
csgo.ViewOffset = ReadAngle(handle, localAddress + GameOffsets.CL_LOCAL_VIEWOFFSET);
//overwrite data
csgo.LocalPlayer = FindLocalPlayer(csgo.Players, localAddress);
if (targetIndex > 0 && targetIndex <= 64)
{
csgo.TargetPlayer = csgo.Players[targetIndex - 1];
}
else
{
csgo.TargetPlayer = null;
}
csgo.TargetIndex = targetIndex;
if (csgo.C4Planted != c4Planted)
{
csgo.C4Planted = c4Planted;
csgo.C4PlantTime = Environment.TickCount;
}
csgo.AccuracyPenality = accuracyPenality;
csgo.C4Timer = WinAPI.ReadFloat(handle, dllClientAddress + GameOffsets.CL_NETVAR_MPC4TIMER);
csgo.ServerMap = WinAPI.ReadString(handle, dllClientAddress + GameOffsets.CL_SRV_BASE + GameOffsets.CL_SRV_MAP, 32, Encoding.ASCII);
csgo.ServerIP = WinAPI.ReadString(handle, dllClientAddress + GameOffsets.CL_SRV_BASE + GameOffsets.CL_SRV_IP, 32, Encoding.ASCII);
csgo.ServerName = WinAPI.ReadString(handle, dllClientAddress + GameOffsets.CL_SRV_BASE + GameOffsets.CL_SRV_Name, 32, Encoding.ASCII);
csgo.IsReloading = isReloading;
csgo.IsShooting = WinAPI.ReadMemory(handle, dllClientAddress + GameOffsets.CL_LOCAL_BUTTONS_ATTACK, 1)[0] == 5;
csgo.ViewMatrix = viewMatrix;
csgo.WeaponClip1 = weaponClip1;
csgo.WeaponClip2 = weaponClip2;
csgo.WeaponFireRate = WeaponHandler.Instance.GetWeaponFireRate(weaponID);
csgo.WeaponName = WeaponHandler.Instance.GetWeaponName(weaponID);
csgo.WeaponType = WeaponHandler.Instance.GetWeaponType(weaponID);
csgo.FlashMaxAlpha = WinAPI.ReadFloat(handle, localAddress + GameOffsets.CL_LOCAL_FLASH_MAX_ALPHA);
csgo.FlashMaxDuration = WinAPI.ReadFloat(handle, localAddress + GameOffsets.CL_LOCAL_FLASH_MAX_DURATION);
//csgo.WeaponShotsFired = weaponShotsFired;
csgo.ZoomLevel = zoom;
csgo.FirstPersonSpectator = false;
csgo.Spectators.Clear();
if (csgo.LocalPlayer != null)
{
foreach (Player player in csgo.Players)
{
if (player == null)
{
continue;
}
if (player.SpectatorTarget == csgo.LocalPlayer.Index)
{
csgo.Spectators.Add(player);
if (player.SpectatorView == Data.Enums.SpectatorView.Ego)
{
csgo.FirstPersonSpectator = true;
}
}
}
}
if (csgo.LocalPlayer == null)
{
return;
}
if (csgo.GetValue <YesNo>("miscBunnyHopEnabled") == YesNo.Yes)
{
if (WinAPI.GetKeyDown(System.Windows.Forms.Keys.Space))
{
int addrJmp = dllClientAddress + GameOffsets.CL_LOCAL_BUTTONS_JUMP;
//Test stuff
if (csgo.LocalPlayer.State == PlayerState.Jump)// && WinAPI.GetKeyDown(System.Windows.Forms.Keys.Up))
{
byte[] buffer = BitConverter.GetBytes(4);
WinAPI.WriteMemory(handle, addrJmp, buffer, buffer.Length);
}
else if (csgo.LocalPlayer.State == PlayerState.Stand)
{
byte[] buffer2 = BitConverter.GetBytes(5);
WinAPI.WriteMemory(handle, addrJmp, buffer2, buffer2.Length);
}
}
}
if (csgo.GetValue <YesNo>("miscAutoPistolEnabled") == YesNo.Yes)
{
if (WinAPI.GetKeyDown(System.Windows.Forms.Keys.LButton) && csgo.WeaponType == WeaponType.Pistol)
{
IntPtr bytesWritten = IntPtr.Zero;
int addrJmp = dllClientAddress + GameOffsets.CL_LOCAL_BUTTONS_ATTACK;
int val = WinAPI.ReadInt32(handle, addrJmp);
if (val == 0)
{
WinAPI.WriteMemory(handle, addrJmp, BitConverter.GetBytes(1), 4);
}
else
{
WinAPI.WriteMemory(handle, addrJmp, BitConverter.GetBytes(0), 4);
}
}
}
//Glow-stuff
int glowAddr = WinAPI.ReadInt32(handle, dllClientAddress + GameOffsets.CL_GLOWMANAGER);
int objectCount = WinAPI.ReadInt32(handle, dllClientAddress + GameOffsets.CL_GLOWMANAGER + 4);
GlowObjectDefinition[] glowObjects = new GlowObjectDefinition[objectCount];
byte[] glowObjectData = WinAPI.ReadMemory(handle, glowAddr, GlowObjectDefinition.GetSize() * objectCount);
for (int i = 0; i < glowObjects.Length; i++)
{
byte[] subData = new byte[GlowObjectDefinition.GetSize()];
Array.Copy(glowObjectData, GlowObjectDefinition.GetSize() * i, subData, 0, GlowObjectDefinition.GetSize());
glowObjects[i] = WinAPI.GetStructure <GlowObjectDefinition>(subData);
}
csgo.GlowObjects = glowObjects;
tick++;
}