(adsbygoogle = window.adsbygoogle || []).push({}); class Offsets
{
public static uint

//G_Client
G_Client = 0x1780F28,
G_ClientSize = 0x5808,
ClientOrigin = 0x28,
ClientAngles = 0x56BC,
ClientTeam = 0x5504,
ClientIsAlive = 0x55D0,
ClientStance = 0xFC,

//Entity
G_Entity = 0x16B9F20,
G_EntitySize = 0x31C,
SetClientViewAngles = 0x1E1D90;


public class Funcs
{
public static float[] getPlayerPosition(int clientIndex)
{
float[] Position = Lib.ReadSingle(Offsets.Funcs.G_Client(clientIndex, Offsets.ClientOrigin), 3);
return Position;
}
public static uint G_Client(int clientIndex, uint Mod = 0x00)
{
return (Offsets.G_Client + (UInt32)Mod) + ((uint)clientIndex * 0x580;
}
public static uint G_Entity(int entityIndex, uint Mod = 0x00)
{
return (Offsets.G_Entity + (UInt32)Mod) + ((uint)entityIndex * 0x31C);
}
}
}

public static bool ClientIsSameTeam(int clientIndex, int otherPlayer)
{
return (Lib.ReadInt32(Offsets.Funcs.G_Client(clientIndex, Offsets.ClientTeam)) == Lib.ReadInt32(Offsets.Funcs.G_Client(otherPlayer, Offsets.ClientTeam)));
}
public static bool ClientIsInGame(int clientIndex)
{
return (Lib.ReadInt32(Offsets.Funcs.G_Client(clientIndex, 0x00)) != 0);
}
public static bool ClientIsAlive(int clientIndex)
{
return (Lib.ReadInt32(Offsets.Funcs.G_Client(clientIndex, Offsets.ClientIsAlive)) == 0);
}
public static float[] vectoangles(float[] Angles)
{
float forward;
float yaw, pitch;
float[] angles = new float[3];
if (Angles[1] == 0 && Angles[0] == 0)
{
yaw = 0;
if (Angles[2] > 0) pitch = 90f;
else pitch = 270f;
}
else
{
if (Angles[0] != -1) yaw = (float)(Math.Atan2((double)Angles[1], (double)Angles[0]) * 180f / Math.PI);
else if (Angles[1] > 0) yaw = 90f;
else yaw = 270;
if (yaw < 0) yaw += 360f;

forward = (float)Math.Sqrt((double)(Angles[0] * Angles[0] + Angles[1] * Angles[1]));
pitch = (float)(Math.Atan2((double)Angles[2], (double)forward) * 180f / Math.PI);
if (pitch < 0) pitch += 360f;
}
angles[0] = -pitch;
angles[1] = yaw;
angles[2] = 0;

return angles;
}
public static float[] getVector(float[] point1, float[] point2)
{
return new float[] { (point2[0] - point1[0]), (point2[1] - point1[1]), (point2[2] - point1[2]) };
}
public static float Distance3D(float[] point1, float[] point2)
{
float deltax = point2[0] - point1[0];
float deltay = point2[1] - point1[1];
float deltaz = point2[2] - point1[2];
return Convert.ToSingle(Math.Sqrt((deltax * deltax) + (deltay * deltay) + (deltaz * deltaz)));
}
public static float Distance2D(float[] point1, float[] point2)
{
float deltax = point2[0] - point1[0];
float deltaz = point2[1] - point1[1];
return Convert.ToSingle(Math.Sqrt((deltax * deltax) + (deltaz * deltaz)));
}
public static int GetNearestPlayer(int clientIndex)
{
int nearestClient = 0;
float nearestDistance = 99999999;
for (int i = 0; i < MenuBase.MaxClients; i++)
{
if (i != clientIndex)
{
if ((ClientIsInGame(i)) && ClientIsAlive(i))
{
if (Lib.ReadInt32(Offsets.Funcs.G_Client(clientIndex, Offsets.ClientTeam)) != 0)
{
if (!ClientIsSameTeam(clientIndex, i))
{
float Distance = Distance3D(Offsets.Funcs.getPlayerPosition(clientIndex), Offsets.Funcs.getPlayerPosition(i));
if (Distance < nearestDistance)
{
nearestDistance = Distance;
nearestClient = i;
}
}
}
else
{
float Distance = Distance3D(Offsets.Funcs.getPlayerPosition(clientIndex), Offsets.Funcs.getPlayerPosition(i));
if (Distance < nearestDistance)
{
nearestDistance = Distance;
nearestClient = i;
}
}
}
}
}
return nearestClient;
}

private static float CheckStance(int clientIndex)
{
Int32 CurrentStance = Lib.ReadByte(Offsets.Funcs.G_Client(clientIndex, Offsets.ClientStance + 0x03));
if (CurrentStance == 0x08 || CurrentStance == 0x0A || CurrentStance == 0x48 || CurrentStance == 0x4A)
{ return 44f; }
if (CurrentStance == 0x04 || CurrentStance == 0x06 || CurrentStance == 0x44 || CurrentStance == 0x46)
{ return 14f; }
return 0f;
}
private static float CheckStanceAttacker(int clientIndex)
{
Int32 CurrentStance = Lib.ReadByte(Offsets.Funcs.G_Client(clientIndex, Offsets.ClientStance + 0x03));
if (CurrentStance == 0x08 || CurrentStance == 0x0A || CurrentStance == 0x48 || CurrentStance == 0x4A)
{ return 46f; }
if (CurrentStance == 0x04 || CurrentStance == 0x06 || CurrentStance == 0x44 || CurrentStance == 0x46)
{ return 18f; }
return 0f;
}

private static void SetClientViewAngles(int clientIndex, int Victim)
{
float[] Vec = getVector(Offsets.Funcs.getPlayerPosition(clientIndex), Offsets.Funcs.getPlayerPosition(Victim));
Vec[2] -= CheckStance(Victim);
Vec[2] += CheckStanceAttacker(clientIndex);
float[] Angles = vectoangles(Vec);
setViewAngles((uint)clientIndex, Angles);
}
public static void setViewAngles(uint clientIndex, float[] Angles)
{
Lib.WriteSingle(0x10040000, Angles);
RPC.Call(Offsets.SetClientViewAngles, Offsets.Funcs.G_Entity((int)clientIndex), 0x10040000);
}​

Credits:diegootero

Mh

Thx brah<3

Someone make a tool of it?

mhm we need a tool

Lmfao...

then why dont you make one.

mmmmm #revolution v1
i dont need it but nice well done and tnx for the share

How do i Install This.
New to Modding
4.41 Jailbreak

lmao Its from shark..