From 5eea71771752ab8cd3038c2544dfdc27f1150831 Mon Sep 17 00:00:00 2001 From: 7AM7 Date: Thu, 19 Mar 2020 23:40:22 +0200 Subject: [PATCH] Upload Files --- AimbotForm.cs | 387 ++++++++++++++++ Algorithms.cs | 250 ++++++++++ App.config | 6 + Classes.cs | 223 +++++++++ ESPForm.cs | 564 +++++++++++++++++++++++ FodyWeavers.xml | 4 + FodyWeavers.xsd | 111 +++++ MainForm.Designer.cs | 80 ++++ MainForm.cs | 520 +++++++++++++++++++++ MainForm.resx | 126 +++++ PUBESP.csproj | 145 ++++++ PUBESP.csproj.user | 6 + PUBESP.sln | 49 ++ Patterns.cs | 15 + Program.cs | 22 + Properties/AssemblyInfo.cs | 36 ++ Properties/Resources.Designer.cs | 63 +++ Properties/Resources.resx | 120 +++++ Properties/Settings.Designer.cs | 26 ++ Properties/Settings.settings | 7 + Properties/app.manifest | 69 +++ Settings.cs | 41 ++ Structs.cs | 83 ++++ Utilities.cs | 759 +++++++++++++++++++++++++++++++ dependencies/BypaPH.dll | Bin 0 -> 66560 bytes dependencies/kprocesshacker.sys | Bin 0 -> 40088 bytes packages.config | 10 + 27 files changed, 3722 insertions(+) create mode 100644 AimbotForm.cs create mode 100644 Algorithms.cs create mode 100644 App.config create mode 100644 Classes.cs create mode 100644 ESPForm.cs create mode 100644 FodyWeavers.xml create mode 100644 FodyWeavers.xsd create mode 100644 MainForm.Designer.cs create mode 100644 MainForm.cs create mode 100644 MainForm.resx create mode 100644 PUBESP.csproj create mode 100644 PUBESP.csproj.user create mode 100644 PUBESP.sln create mode 100644 Patterns.cs create mode 100644 Program.cs create mode 100644 Properties/AssemblyInfo.cs create mode 100644 Properties/Resources.Designer.cs create mode 100644 Properties/Resources.resx create mode 100644 Properties/Settings.Designer.cs create mode 100644 Properties/Settings.settings create mode 100644 Properties/app.manifest create mode 100644 Settings.cs create mode 100644 Structs.cs create mode 100644 Utilities.cs create mode 100644 dependencies/BypaPH.dll create mode 100644 dependencies/kprocesshacker.sys create mode 100644 packages.config diff --git a/AimbotForm.cs b/AimbotForm.cs new file mode 100644 index 0000000..93cf9cb --- /dev/null +++ b/AimbotForm.cs @@ -0,0 +1,387 @@ +using System; +using System.Text; +using GameOverlay.Drawing; +using GameOverlay.Windows; +using SharpDX; +using Point = GameOverlay.Drawing.Point; +using Color = GameOverlay.Drawing.Color; +using Rectangle = GameOverlay.Drawing.Rectangle; +using RawVector2 = SharpDX.Mathematics.Interop.RawVector2; +using ShpVector3 = SharpDX.Vector3; +using ShpVector2 = SharpDX.Vector2; +using System.Windows.Forms; + +namespace PUBGMESP +{ + public interface IAimbotForm + { + void Initialize(); + void Update(); + } + public class AimTarget + { + public ShpVector2 Screen2D; + public float CrosshairDistance; + public int uniqueID; + } + public class AimbotForm : IAimbotForm + { + public readonly OverlayWindow _window; + private readonly Graphics _graphics; + private readonly GameMemSearch _ueSearch; + + private Font _font; + private Font _infoFont; + private Font _bigfont; + private SolidBrush _black; + private SolidBrush _red; + private SolidBrush _green; + private SolidBrush _blue; + private SolidBrush _orange; + private SolidBrush _purple; + private SolidBrush _yellow; + private SolidBrush _white; + private SolidBrush _transparent; + private SolidBrush _txtBrush; + private SolidBrush[] _randomBrush; + private SolidBrush _boxBrush; + private int BestTargetUniqID = -1; + + private DisplayData _data; + private int playerCount; + + // offset + private int actorOffset, boneOffset, tmpOffset; + + + public AimbotForm(RECT rect, GameMemSearch ueSearch) + { + this._ueSearch = ueSearch; + + _window = new OverlayWindow(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top) + { + IsTopmost = true, + IsVisible = true + }; + + _window.SizeChanged += _window_SizeChanged; + + _graphics = new Graphics + { + MeasureFPS = true, + Height = _window.Height, + PerPrimitiveAntiAliasing = true, + TextAntiAliasing = true, + UseMultiThreadedFactories = false, + VSync = true, + Width = _window.Width, + WindowHandle = IntPtr.Zero + }; + + // offset + actorOffset = 320; + boneOffset = 1408; + tmpOffset = 776; + } + + ~AimbotForm() + { + _graphics.Dispose(); + _window.Dispose(); + } + + public void Initialize() + { + _window.CreateWindow(); + + _graphics.WindowHandle = _window.Handle; + _graphics.Setup(); + + _font = _graphics.CreateFont("Microsoft YaHei", 10); + _infoFont = _graphics.CreateFont("Microsoft YaHei", 12); + _bigfont = _graphics.CreateFont("Microsoft YaHei", 18, true); + + _black = _graphics.CreateSolidBrush(0, 0, 0); + _red = _graphics.CreateSolidBrush(255, 99, 71); + _green = _graphics.CreateSolidBrush(Color.Green); + _blue = _graphics.CreateSolidBrush(135, 206, 250); + _orange = _graphics.CreateSolidBrush(255, 97, 0); + _purple = _graphics.CreateSolidBrush(255, 105, 180); + _yellow = _graphics.CreateSolidBrush(255, 255, 0); + _white = _graphics.CreateSolidBrush(255, 255, 255); + _transparent = _graphics.CreateSolidBrush(0, 0, 0, 0); + _randomBrush = new SolidBrush[] + { + _orange,_red,_green,_blue,_yellow,_white,_purple + }; + _txtBrush = _graphics.CreateSolidBrush(0, 0, 0, 0.5f); + } + + public void UpdateData(DisplayData data) + { + _data = data; + } + + public void Update() + { + var gfx = _graphics; + gfx.BeginScene(); + gfx.ClearScene(_transparent); + + if (Settings.ShowMenu) + { + + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 + 115), "Aimbot Menu"); + if (Settings.aimEnabled) + { + DrawShadowText(gfx, _font, _red, new Point(20f, _window.Height / 2 + 130), "Aimbot ON (F5) : " + Settings.aimEnabled.ToString()); + } + else + { + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 + 130), "Aimbot OF (F5) : " + Settings.aimEnabled.ToString()); + } + if (Settings.bDrawFow) + { + DrawShadowText(gfx, _font, _red, new Point(20f, _window.Height / 2 + 145), "FOV SHOW (F6) : " + Settings.bDrawFow.ToString()); + } + else + { + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 + 145), "FOV HIDE (F6) : " + Settings.bDrawFow.ToString()); + } + + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 + 160), "┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈"); + } + + // Read View Matrix + long viewMatrixAddr = Mem.ReadMemory(Mem.ReadMemory(_data.ViewMatrixBase) + 32) + 512; + D3DMatrix viewMatrix = Algorithms.ReadViewMatrix(viewMatrixAddr); + + var AimTargets = new AimTarget[_data.Players.Length]; + float fClosestDist = -1; + // Draw Player ESP + if (Settings.PlayerESP) + { + for (int i = 0; i < _data.Players.Length; i++) + { + + var player = _data.Players[i]; + //if (player.Health <= 0) continue; + if (Algorithms.WorldToScreenPlayer(viewMatrix, player.Position, out ShpVector3 playerScreen, out int distance, _window.Width, _window.Height)) + { + // Too Far not render + if (distance > 500) continue; + float x = playerScreen.X; + float y = playerScreen.Y; + float h = playerScreen.Z; + float w = playerScreen.Z / 2; + + try + { + _boxBrush = _randomBrush[player.TeamID % 7]; + } + catch (IndexOutOfRangeException) + { + _boxBrush = _green; + } + //DrawShadowText(gfx,_font, _green, new Point((x - playerScreen.Z / 4) - 3, y - 15), player.Pose.ToString()); + + // Adjust Box + if (player.Pose == 1114636288) + { + y = playerScreen.Y + playerScreen.Z / 5; + h -= playerScreen.Z / 5; + } + if (player.Pose == 1112014848 || player.Status == 7) + { + y = playerScreen.Y + playerScreen.Z / 4; + h -= playerScreen.Z / 4; + } + + int ScreenCenterX = _window.Width / 2, ScreenCenterY = _window.Height / 2; + + if (Settings.aimEnabled) + { + long tmpAddv = Mem.ReadMemory(player.Address + tmpOffset); + long bodyAddv = tmpAddv + actorOffset; + long boneAddv = Mem.ReadMemory(tmpAddv + boneOffset) + 48; + ShpVector3 headPos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 5 * 48); + + headPos.Z += 7; + + var clampPos = headPos - player.Position; + bool w2sHead = Algorithms.WorldToScreen3DBox(viewMatrix, new ShpVector3(headPos.X, headPos.Y - (Settings.bPredict * 2), headPos.Z - (Settings.bYAxis * 8)), out ShpVector2 HeadPosition, _window.Width, _window.Height); + + AimTargets[i] = new AimTarget(); + AimTargets[i].Screen2D = HeadPosition; + AimTargets[i].uniqueID = player.TeamID; + AimTargets[i].CrosshairDistance = ShpVector2.Distance(HeadPosition, new ShpVector2(ScreenCenterX, ScreenCenterY)); + + if (BestTargetUniqID == -1) + { + if (Algorithms.isInside(ScreenCenterX, ScreenCenterY, Settings.bFovArray[Settings.bFovInt], AimTargets[i].Screen2D.X, AimTargets[i].Screen2D.Y)) + { + fClosestDist = AimTargets[i].CrosshairDistance; + BestTargetUniqID = AimTargets[i].uniqueID; + } + } + if (MainForm.GetAsyncKeyState(Settings.bAimKeys[Settings.bAimKeyINT])) + { + if (BestTargetUniqID != -1) + { + var best = FindAimTargetByUniqueID(AimTargets, BestTargetUniqID); + + if (best != null) + { + { + var roundPos = new ShpVector2((float)Math.Round(best.Screen2D.X), (float)Math.Round(best.Screen2D.Y)); + AimAtPosV2(roundPos.X, roundPos.Y, _window.Width, _window.Height, false); + + } + } + } + } + else + { + BestTargetUniqID = -1; + } + } + if (Settings.bDrawFow) + { + gfx.DrawCircle(_red, ScreenCenterX, ScreenCenterY, Settings.bFovArray[Settings.bFovInt], 2); + } + } + } + + gfx.EndScene(); + } + } + + private static AimTarget FindAimTargetByUniqueID(AimTarget[] array, int uniqueID) + { + var entityList = array; + for (int i = 0; i < entityList.Length; i++) + { + var current = entityList[i]; + if (current == null) + continue; + + if (current.uniqueID == uniqueID) + return current; + } + return null; + } + //uc port + private void AimAtPosV2(float x, float y, int Width, int Height , bool smooth) + { + int ScreenCenterX = Width / 2, ScreenCenterY = Height / 2; + + float AimSpeed = (float)Settings.bSmooth + 1f;; + float TargetX = 0; + float TargetY = 0; + + //X Axis + if (x != 0) + { + if (x > ScreenCenterX) + { + TargetX = -(ScreenCenterX - x); + TargetX /= AimSpeed; + if (TargetX + ScreenCenterX > ScreenCenterX * 2) TargetX = 0; + } + + if (x < ScreenCenterX) + { + TargetX = x - ScreenCenterX; + TargetX /= AimSpeed; + if (TargetX + ScreenCenterX < 0) TargetX = 0; + } + } + + //Y Axis + + if (y != 0) + { + if (y > ScreenCenterY) + { + TargetY = -(ScreenCenterY - y); + TargetY /= AimSpeed; + if (TargetY + ScreenCenterY > ScreenCenterY * 2) TargetY = 0; + } + + if (y < ScreenCenterY) + { + TargetY = y - ScreenCenterY; + TargetY /= AimSpeed; + if (TargetY + ScreenCenterY < 0) TargetY = 0; + } + } + + if (!smooth) + { + MainForm.mouse_event(1, (int)TargetX, (int)(TargetY), 0, UIntPtr.Zero); + return; + } + + TargetX /= 10; + TargetY /= 10; + + if (Math.Abs(TargetX) < 1) + { + if (TargetX > 0) + { + TargetX = 1; + } + if (TargetX < 0) + { + TargetX = -1; + } + } + if (Math.Abs(TargetY) < 1) + { + if (TargetY > 0) + { + TargetY = 1; + } + if (TargetY < 0) + { + TargetY = -1; + } + } + MainForm.mouse_event(1, (int)TargetX, (int)(TargetY), 0, UIntPtr.Zero); + } + + private void _window_SizeChanged(object sender, OverlaySizeEventArgs e) + { + if (_graphics == null) return; + + if (_graphics.IsInitialized) + { + _graphics.Resize(e.Width, e.Height); + } + else + { + _graphics.Width = e.Width; + _graphics.Height = e.Height; + } + } + + private void DrawShadowText(Graphics gfx, Font font, IBrush brush, Point pt, string txt) + { + var bpPt = new Point(pt.X - 1, pt.Y + 1); + //var bpPt2 = new Point(pt.X + 1, pt.Y - 1); + gfx.DrawText(font, _txtBrush, bpPt, txt); + //gfx.DrawText(font, _txtBrush, bpPt2, txt); + gfx.DrawText(font, brush, pt, txt); + + } + private void DrawShadowText(Graphics gfx, Font font, float fontSize, IBrush brush, Point pt, string txt) + { + var bpPt = new Point(); + bpPt.X = pt.X - 1; + bpPt.Y = pt.Y + 1; + gfx.DrawText(font, fontSize, _txtBrush, bpPt, txt); + gfx.DrawText(font, fontSize, brush, pt, txt); + } + } + +} diff --git a/Algorithms.cs b/Algorithms.cs new file mode 100644 index 0000000..55a7a90 --- /dev/null +++ b/Algorithms.cs @@ -0,0 +1,250 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; +using SharpDX; +using ShpVector3 = SharpDX.Vector3; +using ShpVector2 = SharpDX.Vector2; +namespace PUBGMESP +{ + internal class Algorithms + { + /// + /// Check if enemy is inside fov circle + /// + /// + /// + /// + /// + /// + /// + public static bool isInside(float circle_x, float circle_y, + float rad, float x, float y) + { + // Compare radius of circle with distance + // of its center from given point + if ((x - circle_x) * (x - circle_x) + + (y - circle_y) * (y - circle_y) <= rad * rad) + return true; + else + return false; + } + + /// + /// Get Distance Between Enemy And Player + /// + /// + /// + /// + /// + /// + public static double GetDistance(double x1, double y1, double x2, double y2) + { + return Math.Sqrt(Math.Pow((x2 - x1), 2) + Math.Pow((y2 - y1), 2)); + } + + /// + /// Read View Matrix + /// + /// + /// + public static D3DMatrix ReadViewMatrix(long vAddv) => Mem.ReadMemory(vAddv); + + /// + /// Read FTTransform + /// + /// + /// + public static FTTransform ReadFTTransform(long vAddv) => Mem.ReadMemory(vAddv); + + public static FTTransform2 ReadFTransform2(long vAddv) => Mem.ReadMemory(vAddv); + + /// + /// Get Bone's world position + /// + /// + /// + /// + public static ShpVector3 GetBoneWorldPosition(long actorAddv, long boneAddv) + { + + var bone = ReadFTransform2(boneAddv); + var actor = ReadFTransform2(actorAddv); + var boneMatrix = ToMatrixWithScale(bone.Translation, bone.Scale3D, bone.Rotation); + var componentToWorldMatrix = ToMatrixWithScale(actor.Translation, actor.Scale3D, actor.Rotation); + var newMatrix = MatrixMultiplication(boneMatrix, componentToWorldMatrix); + ShpVector3 bonePos = new ShpVector3(); + bonePos.X = newMatrix._41; + bonePos.Y = newMatrix._42; + bonePos.Z = newMatrix._43; + return bonePos; + } + + /// + /// To Matrix With Scale + /// + /// + /// + /// + /// + private static D3DMatrix ToMatrixWithScale(Vector3 translation, Vector3 scale, Vector4 rot) + { + D3DMatrix m = new D3DMatrix + { + _41 = translation.X, + _42 = translation.Y, + _43 = translation.Z + }; + + float x2 = rot.X + rot.X; + float y2 = rot.Y + rot.Y; + float z2 = rot.Z + rot.Z; + + float xx2 = rot.X * x2; + float yy2 = rot.Y * y2; + float zz2 = rot.Z * z2; + m._11 = (1.0f - (yy2 + zz2)) * scale.X; + m._22 = (1.0f - (xx2 + zz2)) * scale.Y; + m._33 = (1.0f - (xx2 + yy2)) * scale.Z; + + float yz2 = rot.Y * z2; + float wx2 = rot.W * x2; + m._32 = (yz2 - wx2) * scale.Z; + m._23 = (yz2 + wx2) * scale.Y; + + float xy2 = rot.X * y2; + float wz2 = rot.W * z2; + m._21 = (xy2 - wz2) * scale.Y; + m._12 = (xy2 + wz2) * scale.X; + + float xz2 = rot.X * z2; + float wy2 = rot.W * y2; + m._31 = (xz2 + wy2) * scale.Z; + m._13 = (xz2 - wy2) * scale.X; + + m._14 = 0.0f; + m._24 = 0.0f; + m._34 = 0.0f; + m._44 = 1.0f; + + return m; + } + + /// + /// D3DMatrix Mutiplication + /// + /// + /// + /// + public static D3DMatrix MatrixMultiplication(D3DMatrix pM1, D3DMatrix pM2) + { + D3DMatrix pOut = new D3DMatrix + { + _11 = pM1._11 * pM2._11 + pM1._12 * pM2._21 + pM1._13 * pM2._31 + pM1._14 * pM2._41, + _12 = pM1._11 * pM2._12 + pM1._12 * pM2._22 + pM1._13 * pM2._32 + pM1._14 * pM2._42, + _13 = pM1._11 * pM2._13 + pM1._12 * pM2._23 + pM1._13 * pM2._33 + pM1._14 * pM2._43, + _14 = pM1._11 * pM2._14 + pM1._12 * pM2._24 + pM1._13 * pM2._34 + pM1._14 * pM2._44, + _21 = pM1._21 * pM2._11 + pM1._22 * pM2._21 + pM1._23 * pM2._31 + pM1._24 * pM2._41, + _22 = pM1._21 * pM2._12 + pM1._22 * pM2._22 + pM1._23 * pM2._32 + pM1._24 * pM2._42, + _23 = pM1._21 * pM2._13 + pM1._22 * pM2._23 + pM1._23 * pM2._33 + pM1._24 * pM2._43, + _24 = pM1._21 * pM2._14 + pM1._22 * pM2._24 + pM1._23 * pM2._34 + pM1._24 * pM2._44, + _31 = pM1._31 * pM2._11 + pM1._32 * pM2._21 + pM1._33 * pM2._31 + pM1._34 * pM2._41, + _32 = pM1._31 * pM2._12 + pM1._32 * pM2._22 + pM1._33 * pM2._32 + pM1._34 * pM2._42, + _33 = pM1._31 * pM2._13 + pM1._32 * pM2._23 + pM1._33 * pM2._33 + pM1._34 * pM2._43, + _34 = pM1._31 * pM2._14 + pM1._32 * pM2._24 + pM1._33 * pM2._34 + pM1._34 * pM2._44, + _41 = pM1._41 * pM2._11 + pM1._42 * pM2._21 + pM1._43 * pM2._31 + pM1._44 * pM2._41, + _42 = pM1._41 * pM2._12 + pM1._42 * pM2._22 + pM1._43 * pM2._32 + pM1._44 * pM2._42, + _43 = pM1._41 * pM2._13 + pM1._42 * pM2._23 + pM1._43 * pM2._33 + pM1._44 * pM2._43, + _44 = pM1._41 * pM2._14 + pM1._42 * pM2._24 + pM1._43 * pM2._34 + pM1._44 * pM2._44 + }; + + return pOut; + } + + /// + /// Player's World To Screen Function + /// + /// + /// + /// + /// + /// + /// + public static bool WorldToScreenPlayer(D3DMatrix viewMatrix, ShpVector3 pos, out ShpVector3 screen, out int distance, int windowWidth, int windowHeight) + { + screen = new ShpVector3(); + //ScreenW = (GameViewMatrix._14 * _Enemy_Point.x) + (GameViewMatrix._24* _Enemy_Point.y) + (GameViewMatrix._34 * _Enemy_Point.z + GameViewMatrix._44); + float screenW = (viewMatrix._14 * pos.X) + (viewMatrix._24 * pos.Y) + (viewMatrix._34 * pos.Z + viewMatrix._44); + distance = (int)(screenW / 100); + if (screenW < 0.0001f) return false; + + // float ScreenY = (GameViewMatrix._12 * _Enemy_Point.x) + (GameViewMatrix._22 * _Enemy_Point.y) + (GameViewMatrix._32 * (_Enemy_Point.z + 85) + GameViewMatrix._42); + float screenY = (viewMatrix._12 * pos.X) + (viewMatrix._22 * pos.Y) + (viewMatrix._32 * (pos.Z + 85) + viewMatrix._42); + // float ScreenX = (GameViewMatrix._11 * _Enemy_Point.x) + (GameViewMatrix._21 * _Enemy_Point.y) + (GameViewMatrix._31 * _Enemy_Point.z + GameViewMatrix._41); + float screenX = (viewMatrix._11 * pos.X) + (viewMatrix._21 * pos.Y) + (viewMatrix._31 * pos.Z + viewMatrix._41); + screen.Y = (windowHeight / 2) - (windowHeight / 2) * screenY / screenW; + screen.X = (windowWidth / 2) + (windowWidth / 2) * screenX / screenW; + // float y1 = (pDxm->s_height / 2) - (GameViewMatrix._12*_Enemy_Point.x + GameViewMatrix._22 * _Enemy_Point.y + GameViewMatrix._32 *(_Enemy_Point.z - 95) + GameViewMatrix._42) *(pDxm->s_height / 2) / ScreenW; + float y1 = (windowHeight / 2) - (viewMatrix._12 * pos.X + viewMatrix._22 * pos.Y + viewMatrix._32 * (pos.Z - 95) + viewMatrix._42) * (windowHeight / 2) / screenW; + screen.Z = y1 - screen.Y; + return true; + } + + /// + /// Bone's World to Screen Function + /// + /// + /// + /// + /// + /// + /// + public static bool WorldToScreenBone(D3DMatrix viewMatrix, ShpVector3 pos, out ShpVector2 screen, out int distance, int windowWidth, int windowHeight) + => WorldToScreenItem(viewMatrix, pos, out screen, out distance, windowWidth, windowHeight); + + /// Item's World To Screen Function + /// + /// + /// + /// + /// + /// + /// + /// + public static bool WorldToScreenItem(D3DMatrix viewMatrix, ShpVector3 pos, out ShpVector2 screen, out int distance, int windowWidth, int windowHeight) + { + screen = new ShpVector2(); + float screenW = (viewMatrix._14 * pos.X) + (viewMatrix._24 * pos.Y) + (viewMatrix._34 * pos.Z + viewMatrix._44); + distance = (int)(screenW / 100); + if (screenW < 0.0001f) return false; + screenW = 1 / screenW; + float sightX = (windowWidth / 2); + float sightY = (windowHeight / 2); + screen.X = sightX + (viewMatrix._11 * pos.X + viewMatrix._21 * pos.Y + viewMatrix._31 * pos.Z + viewMatrix._41) * screenW * sightX; + screen.Y = sightY - (viewMatrix._12 * pos.X + viewMatrix._22 * pos.Y + viewMatrix._32 * pos.Z + viewMatrix._42) * screenW * sightY; + return !float.IsNaN(screen.X) && !float.IsNaN(screen.Y); + } + + + public static bool WorldToScreen3DBox(D3DMatrix viewMatrix, ShpVector3 position, out ShpVector2 res, int sw, int sh) + { + res.X = 0f; + res.Y = 0f; + D3DMatrix matrix = viewMatrix; + double num = (double)(position.X * matrix._14 + position.Y * matrix._24 + position.Z * matrix._34 + matrix._44); + if (num < 0.100000001490116) return false; + double num2 = (double)(position.X * matrix._11 + position.Y * matrix._21 + position.Z * matrix._31 + matrix._41); + double num3 = (double)(position.X * matrix._12 + position.Y * matrix._22 + position.Z * matrix._32 + matrix._42); + num2 /= num; + num3 /= num; + float num4 = (float)(sw / 2); + float num5 = (float)(sh / 2); + res.X = (float)((double)num4 * num2 + (num2 + (double)num4)); + res.Y = (float)(-(float)((double)num5 * num3) + (num3 + (double)num5)); + return !float.IsNaN(res.X) && !float.IsNaN(res.Y); + } + + + } +} diff --git a/App.config b/App.config new file mode 100644 index 0000000..ecdcf8a --- /dev/null +++ b/App.config @@ -0,0 +1,6 @@ + + + + + + diff --git a/Classes.cs b/Classes.cs new file mode 100644 index 0000000..6fffe5d --- /dev/null +++ b/Classes.cs @@ -0,0 +1,223 @@ +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Linq; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; +using SharpDX; +using ShpVector3 = SharpDX.Vector3; +using ShpVector2 = SharpDX.Vector2; +namespace PUBGMESP +{ + public class DisplayData + { + public long ViewMatrixBase; + public long myObjectAddress; + public PlayerData[] Players; + public ItemData[] Items; + public VehicleData[] Vehicles; + public BoxData[] Boxes; + public GrenadeData[] Grenades; + + public DisplayData(long viewMatrixBase,long myObjectAddress) + { + this.ViewMatrixBase = viewMatrixBase; + this.myObjectAddress = myObjectAddress; + } + } + + public class PlayerData + { + public string Type; + public long Address; + public int Status; + public ShpVector3 Position; + public int Pose; + public float Health; + public string Name; + public bool IsRobot; + public int TeamID; + public int IsTeam; + } + + public class ItemData + { + public Item Type; + public ShpVector3 Position; + public string Name; + } + + public class VehicleData + { + public Vehicle Type; + public ShpVector3 Position; + public string Name; + } + + public class BoxData + { + public string[] Items; + public ShpVector3 Position; + } + + public class GrenadeData + { + public Grenade Type; + public ShpVector3 Position; + } + + /// + /// Item Type + /// + public enum Item + { + [Description("Useless")] + Useless, + [Description("[Med] Enegy Drink")] + EnegyDrink, + [Description("[Med] Epinephrine")] + Epinephrine, + [Description("[Med] Pain Killer")] + PainKiller, + [Description("[Med] First Aid Kit")] + AidKit, + [Description("[Armor] Lv.3 Bag")] + BagLv3, + [Description("[Armor] Lv.2 Bag")] + BagLv2, + [Description("[Armor] Lv.2 Armor")] + ArmorLv2, + [Description("[Armor] Lv.3 Armor")] + ArmorLv3, + [Description("[Armor] Lv.3 Helmet")] + HelmetLv3, + [Description("[Armor] Lv.2 Helmet")] + HelmetLv2, + [Description("[Sniper] AWM")] + AWM, + [Description("[Rifle] SCAR-L")] + SCARL, + [Description("[Sniper] Kar-98")] + Kar98, + [Description("[Rifle] M762")] + M762, + [Description("[MachineGun] DP-28")] + DP28, + [Description("[Rifle] Groza")] + Groza, + [Description("[Rifle] AKM")] + AKM, + [Description("[Rifle] AUG")] + AUG, + [Description("[Rifle] QBZ")] + QBZ, + [Description("[MachineGun] M249")] + M249, + [Description("[Rifle] M4A1")] + M4A1, + [Description("[Ammo] 300 Magnum Ammo")] + AmmoMagnum, + [Description("[Ammo] 7.62 Ammo")] + Ammo762, + [Description("[Ammo] 5.56 Ammo")] + Ammo556, + [Description("[Scope] 4x Scope")] + Scope4x, + [Description("[Scope] 6x Scope")] + Scope6x, + [Description("[Scope] 8x Scope")] + Scope8x, + [Description("[Apendix] Rifle Silenter")] + RifleSilenter, + [Description("[Apendix] Rifle Rapid Expansion Magazine")] + RifleMagazine, + [Description("[Armor] Ghillie Suit")] + GhillieSuit, + [Description("[Pistol] Flare Gun")] + FlareGun, + [Description("[Sniper] M24")] + M24, + [Description("[Apendix] Sniper Silenter")] + SniperSilenter, + [Description("[Sniper] MK14")] + MK14, + [Description("[Sniper] SKS")] + SKS, + [Description("[Ammo] Grenade")] + Grenade + } + + /// + /// Grenade Type + /// + public enum Grenade + { + [Description("Unknown")] + Unknown, + [Description("Smoke Grenade")] + Smoke, + [Description("Cocktail Grenade")] + Burn, + [Description("Flash Grenade")] + Flash, + [Description("Fragment Grenade")] + Explode + } + + /// + /// Vehicle Type + /// + public enum Vehicle + { + [Description("Unknown")] + Unknown, + [Description("BRDM")] + BRDM, + [Description("Scooter")] + Scooter, + [Description("Motorcycle")] + Motorcycle, + [Description("MotorcycleCart")] + MotorcycleCart, + [Description("Snowmobile")] + Snowmobile, + [Description("Tuk")] + Tuk, + [Description("Buggy")] + Buggy, + [Description("Sports")] + Sports, + [Description("Dacia")] + Dacia, + [Description("Rony")] + Rony, + [Description("PickUp")] + PickUp, + [Description("UAZ")] + UAZ, + [Description("MiniBus")] + MiniBus, + [Description("PG117")] + PG117, + [Description("AquaRail")] + AquaRail, + [Description("AirPlane")] + BP_AirDropPlane_C + + } + + /// + /// Aimbot Position + /// + public enum AimPosition + { + [Description("Head")] + Head, + [Description("Chest")] + Chest, + [Description("Waist")] + Waist + } +} diff --git a/ESPForm.cs b/ESPForm.cs new file mode 100644 index 0000000..eff8619 --- /dev/null +++ b/ESPForm.cs @@ -0,0 +1,564 @@ +using System; +using System.Text; +using GameOverlay.Drawing; +using GameOverlay.Windows; +using SharpDX; +using Point = GameOverlay.Drawing.Point; +using Color = GameOverlay.Drawing.Color; +using Rectangle = GameOverlay.Drawing.Rectangle; +using RawVector2 = SharpDX.Mathematics.Interop.RawVector2; +using ShpVector3 = SharpDX.Vector3; +using ShpVector2 = SharpDX.Vector2; +namespace PUBGMESP +{ + public interface IESPForm + { + void Initialize(); + void Update(); + } + + public class ESPForm : IESPForm + { + public readonly OverlayWindow _window; + private readonly Graphics _graphics; + private readonly GameMemSearch _ueSearch; + + private Font _font; + private Font _infoFont; + private Font _bigfont; + private SolidBrush _black; + private SolidBrush _red; + private SolidBrush _green; + private SolidBrush _blue; + private SolidBrush _orange; + private SolidBrush _purple; + private SolidBrush _yellow; + private SolidBrush _white; + private SolidBrush _transparent; + private SolidBrush _txtBrush; + private SolidBrush[] _randomBrush; + private SolidBrush _boxBrush; + + + private DisplayData _data; + private int playerCount; + + // offset + private int actorOffset, boneOffset, tmpOffset; + + + public ESPForm(RECT rect, GameMemSearch ueSearch) + { + this._ueSearch = ueSearch; + + _window = new OverlayWindow(rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top) + { + IsTopmost = true, + IsVisible = true + }; + + _window.SizeChanged += _window_SizeChanged; + + _graphics = new Graphics + { + MeasureFPS = true, + Height = _window.Height, + PerPrimitiveAntiAliasing = true, + TextAntiAliasing = true, + UseMultiThreadedFactories = false, + VSync = true, + Width = _window.Width, + WindowHandle = IntPtr.Zero + }; + + // offset + actorOffset = 320; + boneOffset = 1408; + tmpOffset = 776; + } + + ~ESPForm() + { + _graphics.Dispose(); + _window.Dispose(); + } + + public void Initialize() + { + _window.CreateWindow(); + + _graphics.WindowHandle = _window.Handle; + _graphics.Setup(); + + _font = _graphics.CreateFont("Microsoft YaHei", 10); + _infoFont = _graphics.CreateFont("Microsoft YaHei", 12); + _bigfont = _graphics.CreateFont("Microsoft YaHei", 18, true); + + _black = _graphics.CreateSolidBrush(0, 0, 0); + _red = _graphics.CreateSolidBrush(255, 99, 71); + _green = _graphics.CreateSolidBrush(Color.Green); + _blue = _graphics.CreateSolidBrush(135, 206, 250); + _orange = _graphics.CreateSolidBrush(255, 97, 0); + _purple = _graphics.CreateSolidBrush(255, 105, 180); + _yellow = _graphics.CreateSolidBrush(255, 255, 0); + _white = _graphics.CreateSolidBrush(255, 255, 255); + _transparent = _graphics.CreateSolidBrush(0, 0, 0, 0); + _randomBrush = new SolidBrush[] + { + _orange,_red,_green,_blue,_yellow,_white,_purple + }; + _txtBrush = _graphics.CreateSolidBrush(0, 0, 0, 0.5f); + } + + public void UpdateData(DisplayData data) + { + _data = data; + } + + public void Update() + { + var gfx = _graphics; + gfx.BeginScene(); + gfx.ClearScene(_transparent); + // Draw FPS + //gfx.DrawTextWithBackground(_font, _red, _black, 10, 10, "FPS: " + gfx.FPS); + // Draw Menu + if (Settings.ShowMenu) + { + //gfx.FillRectangle(_menuBrush, 10f, _window.Height / 2 - 75, 180, _window.Height / 2 + 165); + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 - 65), " [ AM7 PUBG ] "); + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 - 50), "┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈"); + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 - 35), "ESP Menu"); + if (Settings.PlayerESP) + { + DrawShadowText(gfx, _font, _red, new Point(20f, _window.Height / 2 - 20), "Player ESP (Num1) : " + Settings.PlayerESP.ToString()); + } + else + { + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 - 20), "Player ESP (Num1) : " + Settings.PlayerESP.ToString()); + } + if (Settings.PlayerBox) + { + DrawShadowText(gfx, _font, _red, new Point(20f, _window.Height / 2 - 5), "Player Box (Num2) : " + Settings.PlayerBox.ToString()); + } + else + { + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 - 5), "Player Box (Num2) : " + Settings.PlayerBox.ToString()); + } + if (Settings.PlayerBone) + { + DrawShadowText(gfx, _font, _red, new Point(20f, _window.Height / 2 + 10), "Player Bone (Num3) : " + Settings.PlayerBone.ToString()); + } + else + { + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 + 10), "Player Bone (Num3) : " + Settings.PlayerBone.ToString()); + } + if (Settings.PlayerLines) + { + DrawShadowText(gfx, _font, _red, new Point(20f, _window.Height / 2 + 25), "Player Line (Num4) : " + Settings.PlayerLines.ToString()); + } + else + { + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 + 25), "Player Line (Num4) : " + Settings.PlayerLines.ToString()); + } + if (Settings.PlayerHealth) + { + DrawShadowText(gfx, _font, _red, new Point(20f, _window.Height / 2 + 40), "Player Health (Num5) : " + Settings.PlayerHealth.ToString()); + } + else + { + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 + 40), "Player Health (Num5) : " + Settings.PlayerHealth.ToString()); + } + if (Settings.ItemESP) + { + DrawShadowText(gfx, _font, _red, new Point(20f, _window.Height / 2 + 55), "Item ESP (Num6) : " + Settings.ItemESP.ToString()); + } + else + { + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 + 55), "Item ESP (Num6) : " + Settings.ItemESP.ToString()); + } + if (Settings.VehicleESP) + { + DrawShadowText(gfx, _font, _red, new Point(20f, _window.Height / 2 + 70), "Vehicle ESP (Num7) : " + Settings.VehicleESP.ToString()); + } + else + { + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 + 70), "Vehicle ESP (Num7) : " + Settings.VehicleESP.ToString()); + } + if (Settings.Player3dBox) + { + DrawShadowText(gfx, _font, _red, new Point(20f, _window.Height / 2 + 85), "Player 3D Box (Num8) : " + Settings.Player3dBox.ToString()); + } + else + { + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 + 85), "Player 3D Box (Num8) : " + Settings.Player3dBox.ToString()); + } + DrawShadowText(gfx, _font, _green, new Point(20f, _window.Height / 2 + 100), "┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈┈"); + } + if (_data.Players.Length > 0) + { + playerCount = _data.Players.Length; + DrawShadowText(gfx, _bigfont, _red, new Point(_window.Width / 2 - 40f, 40f), "Enemy near : " + playerCount); + } + // Read View Matrix + long viewMatrixAddr = Mem.ReadMemory(Mem.ReadMemory(_data.ViewMatrixBase) + 32) + 512; + D3DMatrix viewMatrix = Algorithms.ReadViewMatrix(viewMatrixAddr); + // Draw Player ESP + if (Settings.PlayerESP) + { + foreach (var player in _data.Players) + { + + //if (player.Health <= 0) continue; + if (Algorithms.WorldToScreenPlayer(viewMatrix, player.Position, out ShpVector3 playerScreen, out int distance, _window.Width, _window.Height)) + { + // Too Far not render + if (distance > 500) continue; + float x = playerScreen.X; + float y = playerScreen.Y; + float h = playerScreen.Z; + float w = playerScreen.Z / 2; + + try + { + _boxBrush = _randomBrush[player.TeamID % 7]; + } + catch (IndexOutOfRangeException) + { + _boxBrush = _green; + } + //DrawShadowText(gfx,_font, _green, new Point((x - playerScreen.Z / 4) - 3, y - 15), player.Pose.ToString()); + + // Adjust Box + if (player.Pose == 1114636288) + { + y = playerScreen.Y + playerScreen.Z / 5; + h -= playerScreen.Z / 5; + } + if (player.Pose == 1112014848 || player.Status == 7) + { + y = playerScreen.Y + playerScreen.Z / 4; + h -= playerScreen.Z / 4; + } + + // Draw Info + StringBuilder sb = new StringBuilder("["); + if (player.IsRobot) + sb.Append("[Bot] "); + sb.Append(player.Name); + DrawShadowText(gfx, _infoFont, _boxBrush, new Point(x + w / 2, y - 5), sb.ToString()); + // Draw Distance + sb = new StringBuilder("["); + sb.Append(distance).Append("M]"); + DrawShadowText(gfx, _font, _boxBrush, new Point(x + w / 2, y + 7), sb.ToString()); + + if (Settings.PlayerBox) + { + // Draw Box + gfx.DrawRectangle(_boxBrush, Rectangle.Create(x - playerScreen.Z / 4 - 3, y - 5, w + 3, h + 5), 1); + } + if (Settings.Player3dBox) + { + Draw3DBox(viewMatrix, player, playerScreen, _window.Width, _window.Height, 180f); + // Draw Box + //gfx.DrawRectangle(_boxBrush, Rectangle.Create(x - playerScreen.Z / 4 - 3, y - 5, w + 3, h + 5), 1); + } + if (Settings.PlayerBone) + { + // Draw Bone + long tmpAddv = Mem.ReadMemory(player.Address + tmpOffset); + long bodyAddv = tmpAddv + actorOffset; + long boneAddv = Mem.ReadMemory(tmpAddv + boneOffset) + 48; + DrawPlayerBone(bodyAddv, boneAddv, w, viewMatrix, _window.Width, _window.Height); + } + if (Settings.PlayerHealth) + { + // Draw Health + DrawPlayerBlood((x - playerScreen.Z / 4) - 8, y - 5, h + 5, 3, player.Health); + } + if (Settings.PlayerLines) + { + // Draw Line + gfx.DrawLine(_white, new Line(_window.Width / 2, 0, x, y), 2); + } + } + } + } + // Draw Item ESP + if (Settings.ItemESP) + { + foreach (var item in _data.Items) + { + if (Algorithms.WorldToScreenItem(viewMatrix, item.Position, out ShpVector2 itemScreen, out int distance, _window.Width, _window.Height)) + { + // Too Far not render + if (distance > 100) continue; + // Draw Item + string disStr = string.Format("[{0}m]", distance); + DrawShadowText(gfx, _font, _yellow, new Point(itemScreen.X, itemScreen.Y), item.Name); + DrawShadowText(gfx, _font, _yellow, new Point(itemScreen.X, itemScreen.Y + 10), disStr); + } + } + foreach (var box in _data.Boxes) + { + if (Algorithms.WorldToScreenItem(viewMatrix, box.Position, out ShpVector2 itemScreen, out int distance, _window.Width, _window.Height)) + { + // Too Far not render + if (distance > 100) continue; + DrawShadowText(gfx, _font, _yellow, new Point(itemScreen.X, itemScreen.Y), "Lootbox [" + distance.ToString() + "M]"); + } + } + } + // Draw Vehicle ESP + if (Settings.VehicleESP) + { + foreach (var car in _data.Vehicles) + { + if (Algorithms.WorldToScreenItem(viewMatrix, car.Position, out ShpVector2 carScreen, out int distance, _window.Width, _window.Height)) + { + // Too Far not render + if (distance > 300) continue; + string disStr = string.Format("[{0}m]", distance); + // Draw Car + DrawShadowText(gfx, _font, _blue, new Point(carScreen.X, carScreen.Y), car.Name); + DrawShadowText(gfx, _font, _blue, new Point(carScreen.X, carScreen.Y + 10), disStr); + } + } + } + // Grenade alert + foreach (var gre in _data.Grenades) + { + if (Algorithms.WorldToScreenItem(viewMatrix, gre.Position, out ShpVector2 greScreen, out int distance, _window.Width, _window.Height)) + { + DrawShadowText(gfx, _font, 15, _red, new Point(greScreen.X, greScreen.Y), string.Format("!!! {0} !!! [{1}M]", gre.Type.GetDescription(), distance)); + } + } + gfx.EndScene(); + } + private void Draw3DBox(D3DMatrix viewMatrix, PlayerData player, ShpVector3 playersc, int winWidth, int winHeight, float hei= 180f) + { + float num = 70f; + float num2 = 60f; + float num3 = 50f; + float num4 = 85f; + hei = 180f; + ShpVector3 vector = new ShpVector3(num3, -num2 / 2f, 0f); + ShpVector3 vector2 = new ShpVector3(num3, num2 / 2f, 0f); + ShpVector3 vector3 = new ShpVector3(num3 - num, num2 / 2f, 0f); + ShpVector3 vector4 = new ShpVector3(num3 - num, -num2 / 2f, 0f); + + Matrix matrix = Matrix.RotationZ((6.28318548f * (player.Position.Y ) / 180f / 2f)); + ShpVector3 vector5 = new ShpVector3(player.Position.X, player.Position.Y, player.Position.Z - num4); + vector = ShpVector3.TransformCoordinate(vector, matrix) + vector5; + vector2 = ShpVector3.TransformCoordinate(vector2, matrix) + vector5; + vector3 = ShpVector3.TransformCoordinate(vector3, matrix) + vector5; + vector4 = ShpVector3.TransformCoordinate(vector4, matrix) + vector5; + ShpVector2 vector6; + + if (!Algorithms.WorldToScreen3DBox(viewMatrix, vector, out vector6, winWidth, winHeight)) + return; + ShpVector2 vector7; + if (!Algorithms.WorldToScreen3DBox(viewMatrix, vector2, out vector7, winWidth, winHeight)) + return; + ShpVector2 vector8; + if (!Algorithms.WorldToScreen3DBox(viewMatrix, vector3, out vector8, winWidth, winHeight)) + return; + ShpVector2 vector9; + if (!Algorithms.WorldToScreen3DBox(viewMatrix, vector4, out vector9, winWidth, winHeight)) + return; + + RawVector2[] array = new RawVector2[] + { + vector6, + vector7, + vector8, + vector9, + vector6 + }; + DrawLines(array, _boxBrush); + vector.Z += hei; + + bool arg_240_0 = Algorithms.WorldToScreen3DBox(viewMatrix, vector, out vector6, winWidth, winHeight); + vector2.Z += hei; + bool flag = Algorithms.WorldToScreen3DBox(viewMatrix, vector2, out vector7, winWidth, winHeight); + vector3.Z += hei; + bool flag2 = Algorithms.WorldToScreen3DBox(viewMatrix, vector3, out vector8, winWidth, winHeight); + vector4.Z += hei; + bool flag3 = Algorithms.WorldToScreen3DBox(viewMatrix, vector4, out vector9, winWidth, winHeight); + if (!arg_240_0 || !flag || !flag2 || !flag3) + { + return; + } + RawVector2[] array2 = new RawVector2[] + { + vector6, + vector7, + vector8, + vector9, + vector6 + }; + DrawLines(array2, _boxBrush); + DrawLine(new RawVector2(array[0].X, array[0].Y), new RawVector2(array2[0].X, array2[0].Y), _boxBrush); + DrawLine(new RawVector2(array[1].X, array[1].Y), new RawVector2(array2[1].X, array2[1].Y), _boxBrush); + DrawLine(new RawVector2(array[2].X, array[2].Y), new RawVector2(array2[2].X, array2[2].Y), _boxBrush); + DrawLine(new RawVector2(array[3].X, array[3].Y), new RawVector2(array2[3].X, array2[3].Y), _boxBrush); + } + public void DrawLines( RawVector2[] point0, IBrush gxx) + { + if (point0.Length < 2) + { + return; + } + for (int i = 0; i < point0.Length - 1; i++) + { + DrawLine(point0[i], point0[i + 1], _boxBrush); + } + } + public void DrawLine(RawVector2 a, RawVector2 b, IBrush gcolr) + { + _graphics.DrawLine(_boxBrush, a.X, a.Y, b.X, b.Y, 1f); + } + private void DrawPlayerBone(long bodyAddv, long boneAddv, float w, D3DMatrix viewMatrix, int winWidth, int winHeight) + { + + float sightX = winWidth / 2, sightY = winHeight / 2; + + ShpVector3 headPos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 5 * 48); + headPos.Z += 7; + ShpVector2 head; + Algorithms.WorldToScreenBone(viewMatrix, headPos, out head, out int distance, winWidth, winHeight); + ShpVector2 neck = head; + ShpVector2 chest; + ShpVector3 chestPos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 4 * 48); + Algorithms.WorldToScreenBone(viewMatrix, chestPos, out chest, out distance, winWidth, winHeight); + ShpVector2 pelvis; + ShpVector3 pelvisPos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 1 * 48); + Algorithms.WorldToScreenBone(viewMatrix, pelvisPos, out pelvis, out distance, winWidth, winHeight); + ShpVector2 lSholder; + ShpVector3 lSholderPos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 11 * 48); + Algorithms.WorldToScreenBone(viewMatrix, lSholderPos, out lSholder, out distance, winWidth, winHeight); + ShpVector2 rSholder; + ShpVector3 rSholderPos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 32 * 48); + Algorithms.WorldToScreenBone(viewMatrix, rSholderPos, out rSholder, out distance, winWidth, winHeight); + ShpVector2 lElbow; + ShpVector3 lElbowPos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 12 * 48); + Algorithms.WorldToScreenBone(viewMatrix, lElbowPos, out lElbow, out distance, winWidth, winHeight); + ShpVector2 rElbow; + ShpVector3 rElbowPos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 33 * 48); + Algorithms.WorldToScreenBone(viewMatrix, rElbowPos, out rElbow, out distance, winWidth, winHeight); + ShpVector2 lWrist; + ShpVector3 lWristPos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 63 * 48); + Algorithms.WorldToScreenBone(viewMatrix, lWristPos, out lWrist, out distance, winWidth, winHeight); + ShpVector2 rWrist; + ShpVector3 rWristPos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 62 * 48); + Algorithms.WorldToScreenBone(viewMatrix, rWristPos, out rWrist, out distance, winWidth, winHeight); + ShpVector2 lThigh; + ShpVector3 lThighPos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 52 * 48); + Algorithms.WorldToScreenBone(viewMatrix, lThighPos, out lThigh, out distance, winWidth, winHeight); + ShpVector2 rThigh; + ShpVector3 rThighPos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 56 * 48); + Algorithms.WorldToScreenBone(viewMatrix, rThighPos, out rThigh, out distance, winWidth, winHeight); + ShpVector2 lKnee; + ShpVector3 lKneePos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 53 * 48); + Algorithms.WorldToScreenBone(viewMatrix, lKneePos, out lKnee, out distance, winWidth, winHeight); + ShpVector2 rKnee; + ShpVector3 rKneePos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 57 * 48); + Algorithms.WorldToScreenBone(viewMatrix, rKneePos, out rKnee, out distance, winWidth, winHeight); + ShpVector2 lAnkle; + ShpVector3 lAnklePos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 54 * 48); + Algorithms.WorldToScreenBone(viewMatrix, lAnklePos, out lAnkle, out distance, winWidth, winHeight); + ShpVector2 rAnkle; + ShpVector3 rAnklePos = Algorithms.GetBoneWorldPosition(bodyAddv, boneAddv + 58 * 48); + Algorithms.WorldToScreenBone(viewMatrix, rAnklePos, out rAnkle, out distance, winWidth, winHeight); + + if (head != null && chest != null && pelvis != null && lSholder != null + && rSholder != null && lElbow != null && rElbow != null && lWrist != null + && rWrist != null && lThigh != null && rThigh != null && lKnee != null + && rKnee != null && lAnkle != null && rAnkle != null) + { + + _graphics.DrawCircle(_white, new Circle(head.X, head.Y, w / 6), 1); + _graphics.DrawLine(_white, new Line(neck.X, neck.Y, chest.X, chest.Y), 1); + _graphics.DrawLine(_white, new Line(chest.X, chest.Y, pelvis.X, pelvis.Y), 1); + + _graphics.DrawLine(_white, new Line(chest.X, chest.Y, lSholder.X, lSholder.Y), 1); + _graphics.DrawLine(_white, new Line(chest.X, chest.Y, rSholder.X, rSholder.Y), 1); + + _graphics.DrawLine(_white, new Line(lSholder.X, lSholder.Y, lElbow.X, lElbow.Y), 1); + _graphics.DrawLine(_white, new Line(rSholder.X, rSholder.Y, rElbow.X, rElbow.Y), 1); + + _graphics.DrawLine(_white, new Line(lElbow.X, lElbow.Y, lWrist.X, lWrist.Y), 1); + _graphics.DrawLine(_white, new Line(rElbow.X, rElbow.Y, rWrist.X, rWrist.Y), 1); + + _graphics.DrawLine(_white, new Line(pelvis.X, pelvis.Y, lThigh.X, lThigh.Y), 1); + _graphics.DrawLine(_white, new Line(pelvis.X, pelvis.Y, rThigh.X, rThigh.Y), 1); + + _graphics.DrawLine(_white, new Line(lThigh.X, lThigh.Y, lKnee.X, lKnee.Y), 1); + _graphics.DrawLine(_white, new Line(rThigh.X, rThigh.Y, rKnee.X, rKnee.Y), 1); + + _graphics.DrawLine(_white, new Line(lKnee.X, lKnee.Y, lAnkle.X, lAnkle.Y), 1); + _graphics.DrawLine(_white, new Line(rKnee.X, rKnee.Y, rAnkle.X, rAnkle.Y), 1); + + } + } + + + private void DrawShadowText(Graphics gfx, Font font, IBrush brush, Point pt, string txt) + { + var bpPt = new Point(pt.X - 1, pt.Y + 1); + //var bpPt2 = new Point(pt.X + 1, pt.Y - 1); + gfx.DrawText(font, _txtBrush, bpPt, txt); + //gfx.DrawText(font, _txtBrush, bpPt2, txt); + gfx.DrawText(font, brush, pt, txt); + + } + private void DrawShadowText(Graphics gfx, Font font, float fontSize, IBrush brush, Point pt, string txt) + { + var bpPt = new Point(); + bpPt.X = pt.X - 1; + bpPt.Y = pt.Y + 1; + gfx.DrawText(font, fontSize, _txtBrush, bpPt, txt); + gfx.DrawText(font, fontSize, brush, pt, txt); + } + + private void DrawPlayerBlood(float x, float y, float h, float w, float fBlood) + { + if (fBlood > 70.0) + { + //FillRGB(x, y, 5, h, TextBlack); + //FillRGB(x, y, 5, h * fBlood / 100.0, TextGreen); + _graphics.FillRectangle(_black, Rectangle.Create(x, y, w, h)); + _graphics.FillRectangle(_green, Rectangle.Create(x, y, w, h * fBlood / 100)); + } + if (fBlood > 30.0 && fBlood <= 70.0) + { + //FillRGB(x, y, 5, h, TextBlack); + //FillRGB(x, y, 5, h * fBlood / 100.0, TextYellow); + _graphics.FillRectangle(_black, Rectangle.Create(x, y, w, h)); + _graphics.FillRectangle(_yellow, Rectangle.Create(x, y, w, h * fBlood / 100)); + } + if (fBlood > 0.0 && fBlood <= 30.0) + { + //FillRGB(x, y, 5, h, TextBlack); + //FillRGB(x, y, 5, h * fBlood / 100.0, TextRed); + _graphics.FillRectangle(_black, Rectangle.Create(x, y, w, h)); + _graphics.FillRectangle(_red, Rectangle.Create(x, y, w, h * fBlood / 100)); + } + } + + private void _window_SizeChanged(object sender, OverlaySizeEventArgs e) + { + if (_graphics == null) return; + + if (_graphics.IsInitialized) + { + _graphics.Resize(e.Width, e.Height); + } + else + { + _graphics.Width = e.Width; + _graphics.Height = e.Height; + } + } + } +} diff --git a/FodyWeavers.xml b/FodyWeavers.xml new file mode 100644 index 0000000..a5dcf04 --- /dev/null +++ b/FodyWeavers.xml @@ -0,0 +1,4 @@ + + + + \ No newline at end of file diff --git a/FodyWeavers.xsd b/FodyWeavers.xsd new file mode 100644 index 0000000..44a5374 --- /dev/null +++ b/FodyWeavers.xsd @@ -0,0 +1,111 @@ + + + + + + + + + + + + A list of assembly names to exclude from the default action of "embed all Copy Local references", delimited with line breaks + + + + + A list of assembly names to include from the default action of "embed all Copy Local references", delimited with line breaks. + + + + + A list of unmanaged 32 bit assembly names to include, delimited with line breaks. + + + + + A list of unmanaged 64 bit assembly names to include, delimited with line breaks. + + + + + The order of preloaded assemblies, delimited with line breaks. + + + + + + This will copy embedded files to disk before loading them into memory. This is helpful for some scenarios that expected an assembly to be loaded from a physical file. + + + + + Controls if .pdbs for reference assemblies are also embedded. + + + + + Embedded assemblies are compressed by default, and uncompressed when they are loaded. You can turn compression off with this option. + + + + + As part of Costura, embedded assemblies are no longer included as part of the build. This cleanup can be turned off. + + + + + Costura by default will load as part of the module initialization. This flag disables that behavior. Make sure you call CosturaUtility.Initialize() somewhere in your code. + + + + + Costura will by default use assemblies with a name like 'resources.dll' as a satellite resource and prepend the output path. This flag disables that behavior. + + + + + A list of assembly names to exclude from the default action of "embed all Copy Local references", delimited with | + + + + + A list of assembly names to include from the default action of "embed all Copy Local references", delimited with |. + + + + + A list of unmanaged 32 bit assembly names to include, delimited with |. + + + + + A list of unmanaged 64 bit assembly names to include, delimited with |. + + + + + The order of preloaded assemblies, delimited with |. + + + + + + + + 'true' to run assembly verification (PEVerify) on the target assembly after all weavers have been executed. + + + + + A comma-separated list of error codes that can be safely ignored in assembly verification. + + + + + 'false' to turn off automatic generation of the XML Schema file. + + + + + \ No newline at end of file diff --git a/MainForm.Designer.cs b/MainForm.Designer.cs new file mode 100644 index 0000000..1bd0e91 --- /dev/null +++ b/MainForm.Designer.cs @@ -0,0 +1,80 @@ +namespace PUBGMESP +{ + partial class MainForm + { + /// + /// 必需的设计器变量。 + /// + private System.ComponentModel.IContainer components = null; + + /// + /// 清理所有正在使用的资源。 + /// + /// 如果应释放托管资源，为 true；否则为 false。 + protected override void Dispose(bool disposing) + { + if (disposing && (components != null)) + { + components.Dispose(); + } + base.Dispose(disposing); + } + + #region Windows 窗体设计器生成的代码 + + /// + /// 设计器支持所需的方法 - 不要修改 + /// 使用代码编辑器修改此方法的内容。 + /// + private void InitializeComponent() + { + this.components = new System.ComponentModel.Container(); + this.Btn_Activate = new System.Windows.Forms.Button(); + this.LoopTimer = new System.Windows.Forms.Timer(this.components); + this.UpdateTimer = new System.Windows.Forms.Timer(this.components); + this.SuspendLayout(); + // + // Btn_Activate + // + this.Btn_Activate.Dock = System.Windows.Forms.DockStyle.Fill; + this.Btn_Activate.Font = new System.Drawing.Font("宋体", 9F, System.Drawing.FontStyle.Bold, System.Drawing.GraphicsUnit.Point, ((byte)(134))); + this.Btn_Activate.Location = new System.Drawing.Point(0, 0); + this.Btn_Activate.Name = "Btn_Activate"; + this.Btn_Activate.Size = new System.Drawing.Size(419, 47); + this.Btn_Activate.TabIndex = 0; + this.Btn_Activate.Text = "Inject"; + this.Btn_Activate.UseVisualStyleBackColor = true; + this.Btn_Activate.Click += new System.EventHandler(this.Btn_Activate_Click); + // + // LoopTimer + // + this.LoopTimer.Interval = 500; + this.LoopTimer.Tick += new System.EventHandler(this.Loop_Tick); + // + // UpdateTimer + // + this.UpdateTimer.Tick += new System.EventHandler(this.Update_Tick); + // + // MainForm + // + this.AutoScaleDimensions = new System.Drawing.SizeF(8F, 15F); + this.AutoScaleMode = System.Windows.Forms.AutoScaleMode.Font; + this.BackColor = System.Drawing.SystemColors.Control; + this.ClientSize = new System.Drawing.Size(419, 47); + this.Controls.Add(this.Btn_Activate); + this.FormBorderStyle = System.Windows.Forms.FormBorderStyle.FixedSingle; + this.Name = "MainForm"; + this.Text = "PUBGM HACK - [ AM7 ]"; + this.FormClosing += new System.Windows.Forms.FormClosingEventHandler(this.MainForm_FormClosing); + this.Load += new System.EventHandler(this.MainForm_Load); + this.ResumeLayout(false); + + } + + #endregion + private System.Windows.Forms.Button Btn_Activate; + private System.Windows.Forms.Timer LoopTimer; + private System.Windows.Forms.Timer UpdateTimer; + } +} + diff --git a/MainForm.cs b/MainForm.cs new file mode 100644 index 0000000..92c6575 --- /dev/null +++ b/MainForm.cs @@ -0,0 +1,520 @@ + +using System; +using System.Collections.Generic; +using System.ComponentModel; +using System.Data; +using System.Diagnostics; +using System.Drawing; +using System.IO; +using System.Linq; +using System.Runtime.InteropServices; +using System.Security; +using System.Text; +using System.Text.RegularExpressions; +using System.Threading; +using System.Threading.Tasks; +using System.Windows.Forms; +using static PUBGMESP.SigScanSharp; +using ShpVector3 = SharpDX.Vector3; +using ShpVector2 = SharpDX.Vector2; +namespace PUBGMESP +{ + public partial class MainForm : Form + { + #region Modules + SigScanSharp sigScan; + GameMemSearch ueSearch; + ESPForm espForm; + AimbotForm aimbotForm; + #endregion + + #region Variables + const string WINDOW_NAME = "腾讯手游助手【极速傲引擎】"; + const string WINDOW_NAME_G = "Gameloop【Turbo AOW Motoru】"; + IntPtr hwnd = IntPtr.Zero; + RECT rect; + long uWorld; + long uWorlds; + long uLevel; + long gNames; + long viewWorld; + long gameInstance; + long playerController; + long playerCarry; + int myTeamID; + long uMyself; + long myWorld; + long uCamera; + long uCursor; + long uMyObject; + Vector3 myObjectPos; + long entityEntry; + long entityCount; + #endregion + + public MainForm() + { + InitializeComponent(); + } + + private void MainForm_Load(object sender, EventArgs e) + { + } + + private void Btn_Activate_Click(object sender, EventArgs e) + { + // Enable Debug Privilige + EnableDebugPriv(); + // Get Window Handle + hwnd = FindWindow("TXGuiFoundation", "Gameloop【Turbo AOW Engine】"); + Console.WriteLine(hwnd); + if (hwnd == IntPtr.Zero) + { + hwnd = FindWindow("TXGuiFoundation", WINDOW_NAME_G); + if (hwnd == IntPtr.Zero) + { + MessageBox.Show("Please Open Emulator First!!!"); + return; + } + } + hwnd = FindWindowEx(hwnd, 0, "AEngineRenderWindowClass", "AEngineRenderWindow"); + + // Find true aow_exe process + var aowHandle = FindTrueAOWHandle(); + + // Initialize Memory + Mem.Initialize(aowHandle); + if (Mem.m_pProcessHandle == IntPtr.Zero) + { + MessageBox.Show("Error", "Cannot initialize simulator memory, please restart simulator then retry"); + return; + } + else + { + // Initialize SigScan + sigScan = new SigScanSharp(Mem.m_pProcessHandle); + } + + // Find UWorld Offset + ueSearch = new GameMemSearch(sigScan); + var cands = ueSearch.ViewWorldSearchCandidates(); + viewWorld = ueSearch.GetViewWorld(cands); + uWorld = viewWorld - 4217216; + gNames = viewWorld - 1638204; + if (uWorld > 0) + { + // Start Drawing ESP + LoopTimer.Enabled = true; + UpdateTimer.Enabled = true; + GetWindowRect(hwnd, out rect); + espForm = new ESPForm(rect, ueSearch); + aimbotForm = new AimbotForm(rect, ueSearch); + new Thread(ESPThread).Start(); + new Thread(AimbotThread).Start(); + new Thread(InfoThread).Start(); + Btn_Activate.Enabled = false; + Btn_Activate.Text = "Injected"; + } + else + { + MessageBox.Show("Unable to initialize, please check if simulator and game is running"); + } + } + + private void InfoThread() + { + // offset + int controllerOffset, posOffset, healthOffset, nameOffset, teamIDOffset, poseOffset, statusOffset; + controllerOffset = 96; + posOffset = 336; + healthOffset = 1912; + nameOffset = 1512; + teamIDOffset = 1552; + statusOffset = 868; + poseOffset = 288; + while (true) + { + // Read Basic Offset + uWorlds = Mem.ReadMemory(uWorld); + uLevel = Mem.ReadMemory(uWorlds + 32); + gameInstance = Mem.ReadMemory(uWorlds + 36); + playerController = Mem.ReadMemory(gameInstance + controllerOffset); + playerCarry = Mem.ReadMemory(playerController + 32); + uMyObject = Mem.ReadMemory(playerCarry + 788); + //uMyself = Mem.ReadMemory(uLevel + 124); + //uMyself = Mem.ReadMemory(uMyself + 36); + //uMyself = Mem.ReadMemory(uMyself + 312); + //uCamera = Mem.ReadMemory(playerCarry + 804) + 832; + //uCursor = playerCarry + 732; + //myWorld = Mem.ReadMemory(uMyObject + 312); + //myObjectPos = Mem.ReadMemory(myWorld + posOffset); + entityEntry = Mem.ReadMemory(uLevel + 112); + entityCount = Mem.ReadMemory(uLevel + 116); + // Initilize Display Data + DisplayData data = new DisplayData(viewWorld, uMyObject); + List playerList = new List(); + List itemList = new List(); + List vehicleList = new List(); + List boxList = new List(); + List grenadeList = new List(); + for (int i = 0; i < entityCount; i++) + { + long entityAddv = Mem.ReadMemory(entityEntry + i * 4); + long entityStruct = Mem.ReadMemory(entityAddv + 16); + string entityType = GameData.GetEntityType(gNames, entityStruct); + if (Settings.PlayerESP) + { + // if entity is player + if (GameData.IsPlayer(entityType)) + { + //Console.WriteLine(entityType); + long playerWorld = Mem.ReadMemory(entityAddv + 312); + // read player info + // dead player continue + int status = Mem.ReadMemory(playerWorld + statusOffset); + + if (status == 6) + continue; + // my team player continue + //int isTeam = Mem.ReadMemory(Mem.ReadMemory(Mem.ReadMemory(entityAddv + 724 + 4)) + 20); + //if (isTeam > 0) + // continue; + Mem.WriteMemory(Mem.ReadMemory(uMyObject + 2656) + 352, 300000); + + string name = Encoding.Unicode.GetString(Mem.ReadMemory(Mem.ReadMemory(entityAddv + nameOffset), 32)); + name = name.Substring(0, name.IndexOf('\0')); + PlayerData playerData = new PlayerData + { + Type = entityType, + Address = entityAddv, + Position = Mem.ReadMemory(playerWorld + posOffset), + Status = status, + Pose = Mem.ReadMemory(playerWorld + poseOffset), + IsRobot = Mem.ReadMemory(entityAddv + 692) == 0 ? true : false, + Health = Mem.ReadMemory(entityAddv + healthOffset), + Name = name, + TeamID = Mem.ReadMemory(entityAddv + teamIDOffset), + //IsTeam = isTeam + }; + if (playerData.Address == uMyObject || playerData.Address == uMyself) + { + myTeamID = playerData.TeamID; + continue; + } + if (playerData.TeamID == myTeamID) + continue; + //Console.WriteLine(entityType); + playerList.Add(playerData); + continue; + } + } + if (Settings.ItemESP) + { + // check if this entity is item + Item item = GameData.GetItemType(entityType); + if (item != Item.Useless) + { + // Read Item Info + ItemData itemData = new ItemData + { + Name = item.GetDescription(), + Position = Mem.ReadMemory(Mem.ReadMemory(entityAddv + 312) + posOffset), + Type = item + }; + itemList.Add(itemData); + } + // check if this entity is box + if (GameData.IsBox(entityType)) + { + // Read Box Info + long boxEntity = Mem.ReadMemory(entityAddv + 312); + BoxData boxData = new BoxData(); + boxData.Position = Mem.ReadMemory(boxEntity + posOffset); + boxList.Add(boxData); + continue; + } + } + if (Settings.VehicleESP) + { + Vehicle vehicle = GameData.GetVehicleType(entityType); + if (vehicle != Vehicle.Unknown) + { + // Read Vehicle Info + VehicleData vehicleData = new VehicleData + { + Position = Mem.ReadMemory(Mem.ReadMemory(entityAddv + 312) + posOffset), + Type = vehicle, + Name = vehicle.GetDescription() + }; + vehicleList.Add(vehicleData); + continue; + } + } + // check if the entity is a grenade + Grenade grenade = GameData.GetGrenadeType(entityType); + if (grenade != Grenade.Unknown) + { + long grenadeEntity = Mem.ReadMemory(entityAddv + 312); + GrenadeData greData = new GrenadeData + { + Type = grenade, + Position = Mem.ReadMemory(grenadeEntity + posOffset) + }; + grenadeList.Add(greData); + } + } + data.Players = playerList.ToArray(); + data.Items = itemList.ToArray(); + data.Vehicles = vehicleList.ToArray(); + data.Boxes = boxList.ToArray(); + data.Grenades = grenadeList.ToArray(); + espForm.UpdateData(data); + aimbotForm.UpdateData(data); + Thread.Sleep(10); + } + } + + private void ESPThread() + { + espForm.Initialize(); + while (true) + { + espForm.Update(); + //Thread.Sleep(10); + } + } + private void AimbotThread() + { + aimbotForm.Initialize(); + while (true) + { + aimbotForm.Update(); + //Thread.Sleep(10); + } + } + private IntPtr FindTrueAOWHandle() + { + IntPtr aowHandle = IntPtr.Zero; + uint maxThread = 0; + IntPtr handle = CreateToolhelp32Snapshot(0x2, 0); + if ((int)handle > 0) + { + ProcessEntry32 pe32 = new ProcessEntry32(); + pe32.dwSize = (uint)Marshal.SizeOf(pe32); + int bMore = Process32First(handle, ref pe32); + while (bMore == 1) + { + IntPtr temp = Marshal.AllocHGlobal((int)pe32.dwSize); + Marshal.StructureToPtr(pe32, temp, true); + ProcessEntry32 pe = (ProcessEntry32)Marshal.PtrToStructure(temp, typeof(ProcessEntry32)); + Marshal.FreeHGlobal(temp); + if (pe.szExeFile.Contains("aow_exe.exe") && pe.cntThreads > maxThread) + { + maxThread = pe.cntThreads; + aowHandle = (IntPtr)pe.th32ProcessID; + } + + bMore = Process32Next(handle, ref pe32); + } + CloseHandle(handle); + } + return aowHandle; + } + + + private bool EnableDebugPriv() + { + IntPtr hToken = IntPtr.Zero; + if (!OpenProcessToken(Process.GetCurrentProcess().Handle, TOKEN_ADJUST_PRIVILEGES | TOKEN_QUERY, ref hToken)) + { + return false; + } + LUID luid = new LUID(); + if (!LookupPrivilegeValue(null, "SeDebugPrivilege", ref luid)) + { + CloseHandle(hToken); + return false; + } + TOKEN_PRIVILEGES tp = new TOKEN_PRIVILEGES(); + tp.PrivilegeCount = 1; + tp.Privileges = new LUID_AND_ATTRIBUTES[1]; + tp.Privileges[0].Luid = luid; + tp.Privileges[0].Attributes = SE_PRIVILEGE_ENABLED; + if (!AdjustTokenPrivileges(hToken, false, ref tp, 0, IntPtr.Zero, IntPtr.Zero)) + { + return false; + } + CloseHandle(hToken); + return true; + } + + + + #region WIN32 API + [DllImport("user32.dll", SetLastError = true)] + private static extern IntPtr GetWindow(IntPtr hWnd, uint uCmd); + + [DllImport("user32.dll")] + [ + return: MarshalAs(UnmanagedType.Bool) + ] + private static extern bool GetWindowRect(IntPtr hWnd, out RECT lpRect); + + [DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)] + private static extern IntPtr FindWindow(string lpClassName, string lpWindowName); + + [DllImport("user32.dll", EntryPoint = "FindWindowEx", SetLastError = true)] + + + private static extern IntPtr FindWindowEx(IntPtr hwndParent, uint hwndChildAfter, string lpszClass, string lpszWindow); + + [DllImport("User32.dll")] + public static extern bool GetAsyncKeyState(Keys vKey); + + private const int TOKEN_ADJUST_PRIVILEGES = 0x0020; + private const int TOKEN_QUERY = 0x00000008; + private const int SE_PRIVILEGE_ENABLED = 0x00000002; + + [DllImport("advapi32", SetLastError = true), SuppressUnmanagedCodeSecurityAttribute] + private static extern bool OpenProcessToken(IntPtr ProcessHandle, int DesiredAccess, ref IntPtr TokenHandle); + + [DllImport("kernel32", SetLastError = true), SuppressUnmanagedCodeSecurityAttribute] + private static extern bool CloseHandle(IntPtr handle); + + [StructLayout(LayoutKind.Sequential)] + private struct LUID + { + public UInt32 LowPart; + public Int32 HighPart; + } + + [StructLayout(LayoutKind.Sequential, Pack = 4)] + private struct LUID_AND_ATTRIBUTES + { + public LUID Luid; + public UInt32 Attributes; + } + + [DllImport("advapi32.dll", SetLastError = true)] + private static extern bool LookupPrivilegeValue(string lpSystemName, string lpName, ref LUID lpLuid); + + struct TOKEN_PRIVILEGES + { + public int PrivilegeCount; + [MarshalAs(UnmanagedType.ByValArray)] + public LUID_AND_ATTRIBUTES[] Privileges; + } + // Use this signature if you want the previous state information returned + [DllImport("advapi32.dll", SetLastError = true)] + [return: MarshalAs(UnmanagedType.Bool)] + private static extern bool AdjustTokenPrivileges(IntPtr TokenHandle, + [MarshalAs(UnmanagedType.Bool)]bool DisableAllPrivileges, + ref TOKEN_PRIVILEGES NewState, + UInt32 BufferLengthInBytes, + IntPtr prev, + IntPtr relen); + + [DllImport("KERNEL32.DLL ")] + public static extern IntPtr CreateToolhelp32Snapshot(uint flags, uint processid); + [DllImport("KERNEL32.DLL ")] + public static extern int Process32First(IntPtr handle, ref ProcessEntry32 pe); + [DllImport("KERNEL32.DLL ")] + public static extern int Process32Next(IntPtr handle, ref ProcessEntry32 pe); + + [StructLayout(LayoutKind.Sequential)] + public struct ProcessEntry32 + { + public uint dwSize; + public uint cntUsage; + public uint th32ProcessID; + public IntPtr th32DefaultHeapID; + public uint th32ModuleID; + public uint cntThreads; + public uint th32ParentProcessID; + public int pcPriClassBase; + public uint dwFlags; + + [MarshalAs(UnmanagedType.ByValTStr, SizeConst = 260)] public string szExeFile; + }; + [DllImport("user32.dll", CharSet = CharSet.Auto, CallingConvention = CallingConvention.StdCall)] + public static extern void mouse_event(long dwFlags, long dx, long dy, long cButtons, long dwExtraInfo); + #endregion + + private void Loop_Tick(object sender, EventArgs e) + { + GetWindowRect(hwnd, out rect); + if (espForm != null) + { + espForm._window.FitToWindow(hwnd, true); + } + if (aimbotForm != null) + { + aimbotForm._window.FitToWindow(hwnd, true); + } + } + + private void Update_Tick(object sender, EventArgs e) + { + if (GetAsyncKeyState(Keys.End)) + { + System.Environment.Exit(-1); + } + if (GetAsyncKeyState(Keys.End)) + { + this.Close(); + } + if (GetAsyncKeyState(Keys.Home)) + { + Settings.ShowMenu = !Settings.ShowMenu; + } + if (GetAsyncKeyState(Keys.NumPad1)) + { + Settings.PlayerESP = !Settings.PlayerESP; + } + if (GetAsyncKeyState(Keys.NumPad2)) + { + Settings.PlayerBox = !Settings.PlayerBox; + } + if (GetAsyncKeyState(Keys.NumPad3)) + { + Settings.PlayerBone = !Settings.PlayerBone; + } + if (GetAsyncKeyState(Keys.NumPad4)) + { + Settings.PlayerLines = !Settings.PlayerLines; + } + if (GetAsyncKeyState(Keys.NumPad5)) + { + Settings.PlayerHealth = !Settings.PlayerHealth; + } + if (GetAsyncKeyState(Keys.NumPad6)) + { + Settings.ItemESP = !Settings.ItemESP; + } + if (GetAsyncKeyState(Keys.NumPad7)) + { + Settings.VehicleESP = !Settings.VehicleESP; + } + if (GetAsyncKeyState(Keys.NumPad8)) + { + Settings.Player3dBox = !Settings.Player3dBox; + } + if (GetAsyncKeyState(Keys.F5)) + { + Settings.aimEnabled = !Settings.aimEnabled; + } + if (GetAsyncKeyState(Keys.F6)) + { + Settings.bDrawFow = !Settings.bDrawFow; + } + } + [DllImport("user32.dll")] + public static extern void mouse_event(uint dwFlags, int dx, int dy, uint dwData, UIntPtr dwExtraInfo); + + private void MainForm_FormClosing(object sender, FormClosingEventArgs e) + { + // Stop ESP + System.Environment.Exit(-1); + } + } +} diff --git a/MainForm.resx b/MainForm.resx new file mode 100644 index 0000000..80e2017 --- /dev/null +++ b/MainForm.resx @@ -0,0 +1,126 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + 17, 17 + + + 111, 17 + + \ No newline at end of file diff --git a/PUBESP.csproj b/PUBESP.csproj new file mode 100644 index 0000000..3e48a89 --- /dev/null +++ b/PUBESP.csproj @@ -0,0 +1,145 @@ + + + + + + Debug + AnyCPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB} + WinExe + PUBESP + PUBESP + v4.7.2 + 512 + true + true + + + + + + AnyCPU + true + full + false + bin\Debug\ + DEBUG;TRACE + prompt + 4 + false + true + + + x64 + pdbonly + true + bin\Release\ + TRACE + prompt + 4 + false + true + + + LocalIntranet + + + false + + + + Properties\app.manifest + + + + + + + + packages\Costura.Fody.4.1.0\lib\net40\Costura.dll + + + packages\GameOverlay.Net.4.0.3\lib\GameOverlay.dll + + + packages\SharpDX.4.2.0\lib\net45\SharpDX.dll + + + packages\SharpDX.Direct2D1.4.2.0\lib\net45\SharpDX.Direct2D1.dll + + + packages\SharpDX.DXGI.4.2.0\lib\net45\SharpDX.DXGI.dll + + + packages\SharpDX.Mathematics.4.2.0\lib\net45\SharpDX.Mathematics.dll + + + + + + + + + + + + + + + + + + + + Form + + + MainForm.cs + + + + + + + + + MainForm.cs + + + ResXFileCodeGenerator + Resources.Designer.cs + Designer + + + True + Resources.resx + True + + + + + SettingsSingleFileGenerator + Settings.Designer.cs + + + True + Settings.settings + True + + + + + + + + + + + + + 这台计算机上缺少此项目引用的 NuGet 程序包。使用“NuGet 程序包还原”可下载这些程序包。有关更多信息，请参见 http://go.microsoft.com/fwlink/?LinkID=322105。缺少的文件是 {0}。 + + + + + \ No newline at end of file diff --git a/PUBESP.csproj.user b/PUBESP.csproj.user new file mode 100644 index 0000000..c597a10 --- /dev/null +++ b/PUBESP.csproj.user @@ -0,0 +1,6 @@ + + + + false + + \ No newline at end of file diff --git a/PUBESP.sln b/PUBESP.sln new file mode 100644 index 0000000..ad1039a --- /dev/null +++ b/PUBESP.sln @@ -0,0 +1,49 @@ + +Microsoft Visual Studio Solution File, Format Version 12.00 +# Visual Studio Version 16 +VisualStudioVersion = 16.0.29519.87 +MinimumVisualStudioVersion = 10.0.40219.1 +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "PUBESP", "PUBESP.csproj", "{69B42FC8-AB08-415D-A225-7F0FE305EAEB}" +EndProject +Global + GlobalSection(SolutionConfigurationPlatforms) = preSolution + Debug|Any CPU = Debug|Any CPU + Debug|ARM = Debug|ARM + Debug|ARM64 = Debug|ARM64 + Debug|x64 = Debug|x64 + Debug|x86 = Debug|x86 + Release|Any CPU = Release|Any CPU + Release|ARM = Release|ARM + Release|ARM64 = Release|ARM64 + Release|x64 = Release|x64 + Release|x86 = Release|x86 + EndGlobalSection + GlobalSection(ProjectConfigurationPlatforms) = postSolution + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Debug|Any CPU.Build.0 = Debug|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Debug|ARM.ActiveCfg = Debug|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Debug|ARM.Build.0 = Debug|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Debug|ARM64.ActiveCfg = Debug|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Debug|ARM64.Build.0 = Debug|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Debug|x64.ActiveCfg = Debug|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Debug|x64.Build.0 = Debug|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Debug|x86.ActiveCfg = Debug|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Debug|x86.Build.0 = Debug|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Release|Any CPU.ActiveCfg = Release|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Release|Any CPU.Build.0 = Release|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Release|ARM.ActiveCfg = Release|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Release|ARM.Build.0 = Release|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Release|ARM64.ActiveCfg = Release|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Release|ARM64.Build.0 = Release|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Release|x64.ActiveCfg = Release|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Release|x64.Build.0 = Release|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Release|x86.ActiveCfg = Release|Any CPU + {69B42FC8-AB08-415D-A225-7F0FE305EAEB}.Release|x86.Build.0 = Release|Any CPU + EndGlobalSection + GlobalSection(SolutionProperties) = preSolution + HideSolutionNode = FALSE + EndGlobalSection + GlobalSection(ExtensibilityGlobals) = postSolution + SolutionGuid = {168FB93D-00DD-42F6-93D6-0A7A4F763071} + EndGlobalSection +EndGlobal diff --git a/Patterns.cs b/Patterns.cs new file mode 100644 index 0000000..6f415c1 --- /dev/null +++ b/Patterns.cs @@ -0,0 +1,15 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace PUBGMESP +{ + internal class Patterns + { + #region ESP + public static string viewWorldSearch = "02 00 00 00 80 00 00 00 FF FF FF FF 00 00 00 00 01"; + #endregion + } +} diff --git a/Program.cs b/Program.cs new file mode 100644 index 0000000..50ad8d5 --- /dev/null +++ b/Program.cs @@ -0,0 +1,22 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Threading.Tasks; +using System.Windows.Forms; + +namespace PUBGMESP +{ + static class Program + { + /// + /// 应用程序的主入口点。 + /// + [STAThread] + static void Main() + { + Application.EnableVisualStyles(); + Application.SetCompatibleTextRenderingDefault(false); + Application.Run(new MainForm()); + } + } +} diff --git a/Properties/AssemblyInfo.cs b/Properties/AssemblyInfo.cs new file mode 100644 index 0000000..e875382 --- /dev/null +++ b/Properties/AssemblyInfo.cs @@ -0,0 +1,36 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; + +// 有关程序集的一般信息由以下 +// 控制。更改这些特性值可修改 +// 与程序集关联的信息。 +[assembly: AssemblyTitle("PUBGMESP")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyCompany("")] +[assembly: AssemblyProduct("PUBGMESP")] +[assembly: AssemblyCopyright("Copyright © 2020")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// 将 ComVisible 设置为 false 会使此程序集中的类型 +//对 COM 组件不可见。如果需要从 COM 访问此程序集中的类型 +//请将此类型的 ComVisible 特性设置为 true。 +[assembly: ComVisible(false)] + +// 如果此项目向 COM 公开，则下列 GUID 用于类型库的 ID +[assembly: Guid("69b42fc8-ab08-415d-a225-7f0fe305eaeb")] + +// 程序集的版本信息由下列四个值组成: +// +// 主版本 +// 次版本 +// 生成号 +// 修订号 +// +//可以指定所有这些值，也可以使用“生成号”和“修订号”的默认值 +//通过使用 "*"，如下所示: +// [assembly: AssemblyVersion("1.0.*")] +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] diff --git a/Properties/Resources.Designer.cs b/Properties/Resources.Designer.cs new file mode 100644 index 0000000..9fb9d65 --- /dev/null +++ b/Properties/Resources.Designer.cs @@ -0,0 +1,63 @@ +//------------------------------------------------------------------------------ +// +// Bu kod araç tarafından oluşturuldu. +// Çalışma Zamanı Sürümü:4.0.30319.42000 +// +// Bu dosyada yapılacak değişiklikler yanlış davranışa neden olabilir ve +// kod yeniden oluşturulursa kaybolur. +// +//------------------------------------------------------------------------------ + +namespace PUBESP.Properties { + using System; + + + /// + /// Yerelleştirilmiş dizeleri aramak gibi işlemler için, türü kesin olarak belirtilmiş kaynak sınıfı. + /// + // Bu sınıf ResGen veya Visual Studio gibi bir araç kullanılarak StronglyTypedResourceBuilder + // sınıfı tarafından otomatik olarak oluşturuldu. + // Üye eklemek veya kaldırmak için .ResX dosyanızı düzenleyin ve sonra da ResGen + // komutunu /str seçeneğiyle yeniden çalıştırın veya VS projenizi yeniden oluşturun. + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("System.Resources.Tools.StronglyTypedResourceBuilder", "16.0.0.0")] + [global::System.Diagnostics.DebuggerNonUserCodeAttribute()] + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + internal class Resources { + + private static global::System.Resources.ResourceManager resourceMan; + + private static global::System.Globalization.CultureInfo resourceCulture; + + [global::System.Diagnostics.CodeAnalysis.SuppressMessageAttribute("Microsoft.Performance", "CA1811:AvoidUncalledPrivateCode")] + internal Resources() { + } + + /// + /// Bu sınıf tarafından kullanılan, önbelleğe alınmış ResourceManager örneğini döndürür. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Resources.ResourceManager ResourceManager { + get { + if (object.ReferenceEquals(resourceMan, null)) { + global::System.Resources.ResourceManager temp = new global::System.Resources.ResourceManager("PUBESP.Properties.Resources", typeof(Resources).Assembly); + resourceMan = temp; + } + return resourceMan; + } + } + + /// + /// Tümü için geçerli iş parçacığının CurrentUICulture özelliğini geçersiz kular + /// CurrentUICulture özelliğini tüm kaynak aramaları için geçersiz kılar. + /// + [global::System.ComponentModel.EditorBrowsableAttribute(global::System.ComponentModel.EditorBrowsableState.Advanced)] + internal static global::System.Globalization.CultureInfo Culture { + get { + return resourceCulture; + } + set { + resourceCulture = value; + } + } + } +} diff --git a/Properties/Resources.resx b/Properties/Resources.resx new file mode 100644 index 0000000..1af7de1 --- /dev/null +++ b/Properties/Resources.resx @@ -0,0 +1,120 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + text/microsoft-resx + + + 2.0 + + + System.Resources.ResXResourceReader, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + + System.Resources.ResXResourceWriter, System.Windows.Forms, Version=4.0.0.0, Culture=neutral, PublicKeyToken=b77a5c561934e089 + + \ No newline at end of file diff --git a/Properties/Settings.Designer.cs b/Properties/Settings.Designer.cs new file mode 100644 index 0000000..d14936a --- /dev/null +++ b/Properties/Settings.Designer.cs @@ -0,0 +1,26 @@ +//------------------------------------------------------------------------------ +// +// Bu kod araç tarafından oluşturuldu. +// Çalışma Zamanı Sürümü:4.0.30319.42000 +// +// Bu dosyada yapılacak değişiklikler yanlış davranışa neden olabilir ve +// kod yeniden oluşturulursa kaybolur. +// +//------------------------------------------------------------------------------ + +namespace PUBESP.Properties { + + + [global::System.Runtime.CompilerServices.CompilerGeneratedAttribute()] + [global::System.CodeDom.Compiler.GeneratedCodeAttribute("Microsoft.VisualStudio.Editors.SettingsDesigner.SettingsSingleFileGenerator", "16.4.0.0")] + internal sealed partial class Settings : global::System.Configuration.ApplicationSettingsBase { + + private static Settings defaultInstance = ((Settings)(global::System.Configuration.ApplicationSettingsBase.Synchronized(new Settings()))); + + public static Settings Default { + get { + return defaultInstance; + } + } + } +} diff --git a/Properties/Settings.settings b/Properties/Settings.settings new file mode 100644 index 0000000..3964565 --- /dev/null +++ b/Properties/Settings.settings @@ -0,0 +1,7 @@ + + + + + + + diff --git a/Properties/app.manifest b/Properties/app.manifest new file mode 100644 index 0000000..15b2b8c --- /dev/null +++ b/Properties/app.manifest @@ -0,0 +1,69 @@ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + \ No newline at end of file diff --git a/Settings.cs b/Settings.cs new file mode 100644 index 0000000..262e182 --- /dev/null +++ b/Settings.cs @@ -0,0 +1,41 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using System.Threading.Tasks; + +namespace PUBGMESP +{ + internal class Settings + { + public static bool PlayerESP = true; + public static bool PlayerBone = false; + public static bool PlayerBox = false; + public static bool Player3dBox = true; + public static bool PlayerLines = true; + public static bool PlayerHealth = false; + public static bool ItemESP = false; + public static bool VehicleESP = false; + public static bool ShowMenu = true; + + // aimbot + public static bool aimEnabled = true; + public static bool bDrawFow = true; + public static int bSmooth = 11; + public static int bFovInt = 2; + public static int bPredict = 1; + public static int bYAxis = 2; + public static int bAimKeyINT = 2; + public static string[] aimkeys = { "CAPSLOCK", "LBUTTON", "RBUTTON", "LSHIFT", "V", "E", "Q" }; + public static System.Windows.Forms.Keys[] bAimKeys = new System.Windows.Forms.Keys[] { System.Windows.Forms.Keys.CapsLock, System.Windows.Forms.Keys.LButton, System.Windows.Forms.Keys.RButton, System.Windows.Forms.Keys.LShiftKey, System.Windows.Forms.Keys.V, System.Windows.Forms.Keys.E, System.Windows.Forms.Keys.Q }; + public static float[] bFovArray = new float[] + { + 60f, + 90f, + 120f, + 160f, + 300f, + 300f + }; + } +} diff --git a/Structs.cs b/Structs.cs new file mode 100644 index 0000000..9e519b3 --- /dev/null +++ b/Structs.cs @@ -0,0 +1,83 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using System.Runtime.InteropServices; +using System.Text; +using System.Threading.Tasks; + +namespace PUBGMESP +{ + + [StructLayout(LayoutKind.Sequential)] + public struct RECT + { + public int left; + public int top; + public int right; + public int bottom; + } + + [StructLayout(LayoutKind.Explicit)] + internal struct FTTransform + { + [FieldOffset(0x00)] + public Vector4 Rotation; + [FieldOffset(0x10)] + public Vector3 Translation; + [FieldOffset(0x1C)] + public Vector3 Scale3D; + } + + [StructLayout(LayoutKind.Explicit)] + internal struct FTTransform2 + { + [FieldOffset(0x00)] + public Vector4 Rotation; + [FieldOffset(0x10)] + public Vector3 Translation; + [FieldOffset(0x20)] + public Vector3 Scale3D; + } + + [StructLayout(LayoutKind.Sequential)] + internal struct D3DMatrix + { + public float _11, _12, _13, _14; + public float _21, _22, _23, _24; + public float _31, _32, _33, _34; + public float _41, _42, _43, _44; + } + + [StructLayout(LayoutKind.Sequential)] + public struct Vector2 + { + public float X; + public float Y; + } + + [StructLayout(LayoutKind.Sequential)] + public struct Vector3 + { + public float X; + public float Y; + public float Z; + } + + [StructLayout(LayoutKind.Sequential)] + public struct Vector4 + { + + public float X; + public float Y; + public float Z; + public float W; + + public Vector4(float x, float y, float z, float w) : this() + { + this.W = w; + this.X = x; + this.Y = y; + this.Z = z; + } + } +} diff --git a/Utilities.cs b/Utilities.cs new file mode 100644 index 0000000..1a774a7 --- /dev/null +++ b/Utilities.cs @@ -0,0 +1,759 @@ +using System; +using System.Collections; +using System.Collections.Generic; +using System.ComponentModel; +using System.Diagnostics; +using System.Linq; +using System.Reflection; +using System.Runtime.InteropServices; +using System.Text; +using System.Windows.Forms; +using static PUBGMESP.SigScanSharp; + +namespace PUBGMESP +{ + + + public class SigScanSharp + { + public class BypaPH : IDisposable + { + [DllImport("BypaPH.dll", EntryPoint = "CreateInstance")] + static extern IntPtr BypaPH_ctor(uint pID); + [DllImport("BypaPH.dll", EntryPoint = "DeleteInstance")] + static extern void BypaPH_dtor(IntPtr pInstance); + [DllImport("BypaPH.dll", EntryPoint = "RWVM")] + static extern bool BypaPH_RWVM(IntPtr pInstance, UIntPtr BaseAddress, [Out] byte[] Buffer, UIntPtr BufferSize, out ulong NumberOfBytesReadOrWritten, + bool read = true, bool unsafeRequest = false); + IntPtr pInstance; + public BypaPH(int pID) + { + pInstance = BypaPH_ctor((uint)pID); + } + public bool ReadProcessMem(ulong BaseAddress, out byte[] Buffer, int BufferSize, out ulong NumberOfBytesRead) + { + byte[] buf = new byte[BufferSize]; + bool b = BypaPH_RWVM(pInstance, new UIntPtr(BaseAddress), buf, new UIntPtr((uint)buf.Length), out NumberOfBytesRead); + + Buffer = buf; + return b; + } + public bool WriteProcessMem(ulong BaseAddress, byte[] Buffer, out ulong NumberOfBytesWittin) + { + return BypaPH_RWVM(pInstance, new UIntPtr(BaseAddress), Buffer, new UIntPtr((uint)Buffer.Length), out NumberOfBytesWittin, false); + } + public void Dispose() + { + BypaPH_dtor(pInstance); + } + } + private IntPtr g_hProcess { get; set; } + private byte[] g_arrModuleBuffer { get; set; } + private long g_lpModuleBase { get; set; } + + private Win32.MEMORY_BASIC_INFORMATION MBI; + + private static byte question = (byte)'?'; + + private Dictionary g_dictStringPatterns { get; } + + public SigScanSharp(IntPtr hProc) + { + g_hProcess = hProc; + g_dictStringPatterns = new Dictionary(); + } + + public bool SelectModule(ProcessModule targetModule) + { + g_lpModuleBase = (long)targetModule.BaseAddress; + g_arrModuleBuffer = new byte[targetModule.ModuleMemorySize]; + + g_dictStringPatterns.Clear(); + + return Win32.ReadProcessMemory(g_hProcess, g_lpModuleBase, g_arrModuleBuffer, targetModule.ModuleMemorySize); + } + + public void AddPattern(string szPatternName, string szPattern) + { + g_dictStringPatterns.Add(szPatternName, szPattern); + } + + private bool PatternCheck(int nOffset, byte[] arrPattern) + { + for (int i = 0; i < arrPattern.Length; i++) + { + if (arrPattern[i] == question) + continue; + + if (arrPattern[i] != this.g_arrModuleBuffer[nOffset + i]) + return false; + } + + return true; + } + + private bool PatternCheck(int nOffset, byte[] arrPattern, byte[] source) + { + if (nOffset + arrPattern.Length > source.Length) return false; + for (int i = 0; i < arrPattern.Length; i++) + { + if (arrPattern[i] == question) + continue; + + if (arrPattern[i] != source[nOffset + i]) + return false; + } + + return true; + } + + public long FindPattern(string szPattern, out long lTime) + { + if (g_arrModuleBuffer == null || g_lpModuleBase == 0) + throw new Exception("Selected module is null"); + + Stopwatch stopwatch = Stopwatch.StartNew(); + + byte[] arrPattern = ParsePatternString(szPattern); + + for (int nModuleIndex = 0; nModuleIndex < g_arrModuleBuffer.Length; nModuleIndex++) + { + if (this.g_arrModuleBuffer[nModuleIndex] != arrPattern[0]) + continue; + + if (PatternCheck(nModuleIndex, arrPattern)) + { + lTime = stopwatch.ElapsedMilliseconds; + return g_lpModuleBase + (long)nModuleIndex; + } + } + + lTime = stopwatch.ElapsedMilliseconds; + return 0; + } + + public long[] FindPatternsAllRegion(string szPattern, long iStartAddress = 0, long iEndAddress = 0x7FFFFFFF) + { + byte[] arrPattern = ParsePatternString(szPattern); + long iAddress = iStartAddress; int ptrBytesRead = 0; byte[] bBuffer; + List matchAddvs = new List(); + do + { + int iRead = Win32.VirtualQueryEx(g_hProcess, (IntPtr)iAddress, out MBI, (uint)Marshal.SizeOf(MBI)); + if ((iRead > 0) && ((long)MBI.RegionSize > 0)) + { + //bBuffer = new byte[(long)MBI.RegionSize]; + bBuffer = Mem.ReadMemory((long)MBI.BaseAddress, (int)MBI.RegionSize); + //Win32.ReadProcessMemory(g_hProcess, (long)MBI.BaseAddress, bBuffer, bBuffer.Length, ptrBytesRead); + for (int i = 0; i < bBuffer.Length; i++) + { + if (bBuffer[i] != arrPattern[0]) continue; + if (PatternCheck(i, arrPattern, bBuffer)) + { + matchAddvs.Add((long)(iAddress + i)); + i += arrPattern.Length; + } + } + } + iAddress = (long)(MBI.BaseAddress.ToInt64() + MBI.RegionSize.ToInt64()); + } while (iAddress <= iEndAddress); + return matchAddvs.ToArray(); + } + + public Dictionary FindPatterns(out long lTime) + { + if (g_arrModuleBuffer == null || g_lpModuleBase == 0) + throw new Exception("Selected module is null"); + + Stopwatch stopwatch = Stopwatch.StartNew(); + + byte[][] arrBytePatterns = new byte[g_dictStringPatterns.Count][]; + long[] arrResult = new long[g_dictStringPatterns.Count]; + + // PARSE PATTERNS + for (int nIndex = 0; nIndex < g_dictStringPatterns.Count; nIndex++) + arrBytePatterns[nIndex] = ParsePatternString(g_dictStringPatterns.ElementAt(nIndex).Value); + + // SCAN FOR PATTERNS + for (int nModuleIndex = 0; nModuleIndex < g_arrModuleBuffer.Length; nModuleIndex++) + { + for (int nPatternIndex = 0; nPatternIndex < arrBytePatterns.Length; nPatternIndex++) + { + if (arrResult[nPatternIndex] != 0) + continue; + + if (this.PatternCheck(nModuleIndex, arrBytePatterns[nPatternIndex])) + arrResult[nPatternIndex] = g_lpModuleBase + (long)nModuleIndex; + } + } + + Dictionary dictResultFormatted = new Dictionary(); + + // FORMAT PATTERNS + for (int nPatternIndex = 0; nPatternIndex < arrBytePatterns.Length; nPatternIndex++) + dictResultFormatted[g_dictStringPatterns.ElementAt(nPatternIndex).Key] = arrResult[nPatternIndex]; + + lTime = stopwatch.ElapsedMilliseconds; + return dictResultFormatted; + } + + private byte[] ParsePatternString(string szPattern) + { + List patternbytes = new List(); + + foreach (var szByte in szPattern.Split(' ')) + patternbytes.Add(szByte == "?" ? (byte)'?' : Convert.ToByte(szByte, 16)); + + return patternbytes.ToArray(); + } + + private static class Win32 + { + [DllImport("kernel32.dll")] + public static extern bool ReadProcessMemory(IntPtr hProcess, long lpBaseAddress, byte[] lpBuffer, int dwSize, int lpNumberOfBytesRead = 0); + + [DllImport("kernel32.dll")] + internal static extern Int32 VirtualQueryEx(IntPtr hProcess, IntPtr lpAddress, out Win32.MEMORY_BASIC_INFORMATION lpBuffer, uint dwLength); + + [StructLayout(LayoutKind.Sequential)] + public struct MEMORY_BASIC_INFORMATION + { + public IntPtr BaseAddress; + public IntPtr AllocationBase; + public uint AllocationProtect; + public IntPtr RegionSize; + public uint State; + public uint Protect; + public uint Type; + } + } + } + + public class Mem + { + public static int m_iNumberOfBytesRead = 0; + public static int m_iNumberOfBytesWritten = 0; + public static Process m_Process; + public static IntPtr m_pProcessHandle = IntPtr.Zero; + public static Int64 BaseAddress; + private const int PROCESS_VM_OPERATION = 8; + private const int PROCESS_VM_READ = 16; + private const int PROCESS_VM_WRITE = 32; + + public static void Initialize(string ProcessName) + { + if ((uint)Process.GetProcessesByName(ProcessName).Length > 0U) + { + Mem.m_Process = Process.GetProcessesByName(ProcessName)[0]; + Mem.BaseAddress = Process.GetProcessesByName(ProcessName)[0].MainModule.BaseAddress.ToInt64(); + } + else + { + int num = (int)MessageBox.Show("Emulator should start first!!!"); + Environment.Exit(1); + } + Mem.m_pProcessHandle = Mem.OpenProcess(0x1F0FFF, false, Mem.m_Process.Id); + } + public static BypaPH ByPH; + public static void Initialize(IntPtr ptr) + { + if (ptr != IntPtr.Zero) + { + ByPH = new BypaPH((int)ptr); + Mem.m_pProcessHandle = Mem.OpenProcess(0x1F0FFF, false, (int)ptr); + } + } + + public static Int64 GetModuleAdress(string ModuleName) + { + Int64 num; + try + { + foreach (ProcessModule module in (ReadOnlyCollectionBase)Mem.m_Process.Modules) + { + if (!ModuleName.Contains(".dll")) + ModuleName = ModuleName.Insert(ModuleName.Length, ".dll"); + if (ModuleName == module.ModuleName) + { + num = (Int64)module.BaseAddress; + goto label_13; + } + } + } + catch + { + } + num = -1; + label_13: + return num; + } + + public static string ReadString(Int64 address, int _Size) + { + return Encoding.Default.GetString(ReadMemory(address, _Size)); + } + + + public static T ReadMemory(Int64 Adress) where T : struct + { + ulong num; + byte[] numArray = new byte[Marshal.SizeOf(typeof(T))]; + ByPH.ReadProcessMem((ulong)Adress, out numArray, numArray.Length, out num); + //Mem.ReadProcessMemory((int)Mem.m_pProcessHandle, Adress, numArray, numArray.Length, ref Mem.m_iNumberOfBytesRead); + return Mem.ByteArrayToStructure(numArray); + } + + public static byte[] ReadMemory(Int64 address, int _Size) + { + ulong num; + byte[] numArray = new byte[_Size]; + ByPH.ReadProcessMem((ulong)address, out numArray, numArray.Length, out num); + //Mem.ReadProcessMemory((int)Mem.m_pProcessHandle, address, numArray, _Size, ref Mem.m_iNumberOfBytesRead); + return numArray; + } + + public static float[] ReadMatrix(Int64 Adress, int MatrixSize) where T : struct + { + byte[] numArray = new byte[Marshal.SizeOf(typeof(T)) * MatrixSize]; + ulong num; + ByPH.ReadProcessMem((ulong)Adress, out numArray, numArray.Length, out num); + return Mem.ConvertToFloatArray(numArray); + } + + public static void WriteMemory(Int64 Adress, object Value) where T : struct + { + byte[] byteArray = Mem.StructureToByteArray(Value); + ulong num; + ByPH.WriteProcessMem((ulong)Adress, byteArray, out num); + //Mem.WriteProcessMemory((int)Mem.m_pProcessHandle, Adress, byteArray, byteArray.Length, out Mem.m_iNumberOfBytesWritten); + } + + public static void WriteMemory(Int64 Adress, byte[] byteArray) + { + ulong num; + ByPH.WriteProcessMem((ulong)Adress, byteArray, out num); + } + + public static byte[] PatternToBytes(string pattern, int offset = 0) + { + var patternArr = pattern.Split(' '); + List result = new List(); + for (int i = offset; i < patternArr.Length; i++) + { + if (patternArr[i] == "?") continue; + result.Add(Convert.ToByte(patternArr[i], 16)); + } + return result.ToArray(); + } + + public static float[] ConvertToFloatArray(byte[] bytes) + { + if ((uint)(bytes.Length % 4) > 0U) + throw new ArgumentException(); + float[] numArray = new float[bytes.Length / 4]; + for (int index = 0; index < numArray.Length; ++index) + numArray[index] = BitConverter.ToSingle(bytes, index * 4); + return numArray; + } + + private static T ByteArrayToStructure(byte[] bytes) where T : struct + { + GCHandle gcHandle = GCHandle.Alloc((object)bytes, GCHandleType.Pinned); + try + { + return (T)Marshal.PtrToStructure(gcHandle.AddrOfPinnedObject(), typeof(T)); + } + finally + { + gcHandle.Free(); + } + } + + public static IntPtr AllocateMemory(uint size) + { + return VirtualAllocEx(Mem.m_pProcessHandle, IntPtr.Zero, size, AllocationType.Commit, MemoryProtection.ReadWrite); + } + + private static byte[] StructureToByteArray(object obj) + { + int length = Marshal.SizeOf(obj); + byte[] destination = new byte[length]; + IntPtr num = Marshal.AllocHGlobal(length); + Marshal.StructureToPtr(obj, num, true); + Marshal.Copy(num, destination, 0, length); + Marshal.FreeHGlobal(num); + return destination; + } + + [DllImport("kernel32.dll")] + private static extern IntPtr OpenProcess(int dwDesiredAccess, bool bInheritHandle, int dwProcessId); + + + [DllImport("kernel32.dll", SetLastError = true, ExactSpelling = true)] + static extern IntPtr VirtualAllocEx(IntPtr hProcess, IntPtr lpAddress, uint dwSize, AllocationType flAllocationType, MemoryProtection flProtect); + + [Flags] + public enum AllocationType + { + Commit = 0x1000, + Reserve = 0x2000, + Decommit = 0x4000, + Release = 0x8000, + Reset = 0x80000, + Physical = 0x400000, + TopDown = 0x100000, + WriteWatch = 0x200000, + LargePages = 0x20000000 + } + + [Flags] + public enum MemoryProtection + { + Execute = 0x10, + ExecuteRead = 0x20, + ExecuteReadWrite = 0x40, + ExecuteWriteCopy = 0x80, + NoAccess = 0x01, + ReadOnly = 0x02, + ReadWrite = 0x04, + WriteCopy = 0x08, + GuardModifierflag = 0x100, + NoCacheModifierflag = 0x200, + WriteCombineModifierflag = 0x400 + } + } + + public class GameMemSearch + { + SigScanSharp sgn; + public GameMemSearch(SigScanSharp sgn) + { + this.sgn = sgn; + } + + public long[] ViewWorldSearchCandidates(long startAddv = 0x26000000, long endAddv = 0x30000000) + { + long[] tmpViewWorlds = sgn.FindPatternsAllRegion(Patterns.viewWorldSearch, startAddv, endAddv); + long[] viewWorlds = new long[tmpViewWorlds.Length]; + for (int i = 0; i < viewWorlds.Length; i++) + viewWorlds[i] = tmpViewWorlds[i] - 32; + return viewWorlds; + } + + public long GetViewWorld(long[] cands) + { + long tmp; + float t1, t2, t3, t4; + for (int i = 0; i < cands.Length; i++) + { + tmp = Mem.ReadMemory(Mem.ReadMemory(cands[i]) + 32) + 512; + t1 = Mem.ReadMemory(tmp + 56); + t2 = Mem.ReadMemory(tmp + 40); + t3 = Mem.ReadMemory(tmp + 24); + t4 = Mem.ReadMemory(tmp + 8); + if (t1 >= 3 && t2 == 0 && t3 == 0 && t4 == 0) + { + return cands[i]; + } + } + return -1; + } + } + + public static class GameData + { + /// + /// Tell if a entity is player + /// + /// + /// + public static bool IsPlayer(string str) + { + if (str.Contains("BP_PlayerPawn")) + return true; + return false; + } + + + /// + /// Get Box Item From Item Code + /// + /// + /// + public static Item GetBoxItemType(long code) + { + if (code == 601001) + return Item.EnegyDrink; + if (code == 601002) + return Item.Epinephrine; + if (code == 601003) + return Item.PainKiller; + if (code == 601005) + return Item.AidKit; + if (code == 501006) + return Item.BagLv3; + if (code == 503003) + return Item.ArmorLv3; + if (code == 502003) + return Item.HelmetLv3; + if (code == 103003) + return Item.AWM; + if (code == 101003) + return Item.SCARL; + if (code == 103001) + return Item.Kar98; + if (code == 101008) + return Item.M762; + if (code == 105002) + return Item.DP28; + if (code == 101005) + return Item.Groza; + if (code == 101001) + return Item.AKM; + if (code == 101006) + return Item.AUG; + if (code == 101007) + return Item.QBZ; + if (code == 105001) + return Item.M249; + if (code == 101004) + return Item.M4A1; + if (code == 306001) + return Item.AmmoMagnum; + if (code == 302001) + return Item.Ammo762; + if (code == 303001) + return Item.Ammo556; + if (code == 203004) + return Item.Scope4x; + if (code == 203015) + return Item.Scope6x; + if (code == 203005) + return Item.Scope8x; + if (code == 201011) + return Item.RifleSilenter; + if (code == 204013) + return Item.RifleMagazine; + if (code == 403990 || code == 403187) + return Item.GhillieSuit; + return Item.Useless; + } + + + /// + /// Tell if an item is box + /// + /// + /// + public static bool IsBox(string str) + { + if (str.Contains("PlayerDeadInventoryBox") || str.Contains("PickUpListWrapperActor") || str.Contains("AirDrop")) + return true; + return false; + } + + /// + /// Get Grenade Type + /// + /// + /// + public static Grenade GetGrenadeType(string str) + { + if (str.Contains("BP_Grenade_Smoke_C")) + return Grenade.Smoke; + if (str.Contains("BP_Grenade_Burn_C")) + return Grenade.Burn; + if (str.Contains("BP_Grenade_tun_C")) + return Grenade.Flash; + if (str.Contains("BP_Grenade_Shoulei_C")) + return Grenade.Explode; + return Grenade.Unknown; + } + + /// + /// Get Vehicle Type + /// + /// + /// + public static Vehicle GetVehicleType(string str) + { + if (str.Contains("BRDM")) + return Vehicle.BRDM; + if (str.Contains("Scooter")) + return Vehicle.Scooter; + if (str.Contains("Motorcycle")) + return Vehicle.Motorcycle; + if (str.Contains("MotorcycleCart")) + return Vehicle.MotorcycleCart; + if (str.Contains("Snowmobile")) + return Vehicle.Snowmobile; + if (str.Contains("Tuk")) + return Vehicle.Tuk; + if (str.Contains("Buggy")) + return Vehicle.Buggy; + if (str.Contains("open")) + return Vehicle.Sports; + if (str.Contains("close")) + return Vehicle.Sports; + if (str.Contains("Dacia")) + return Vehicle.Dacia; + if (str.Contains("Rony")) + return Vehicle.Rony; + if (str.Contains("UAZ")) + return Vehicle.UAZ; + if (str.Contains("MiniBus")) + return Vehicle.MiniBus; + if (str.Contains("PG117")) + return Vehicle.PG117; + if (str.Contains("AquaRail")) + return Vehicle.AquaRail; + if (str.Contains("BP_AirDropPlane_C")) + return Vehicle.BP_AirDropPlane_C; + //if (str.Contains("PickUp")) + //{ + // if (str.Contains("PickUp_BP")) + // { + // if (str != "PickUpListWrapperActor") + // return Vehicle.PickUp; + // } + //} + return Vehicle.Unknown; + } + + /// + /// Get Item's Type + /// + /// + /// + public static Item GetItemType(string str) + { + //if (!str.Contains("Pickup") || !str.Contains("PickUp")) + // return Item.Useless; + if (str.Contains("Grenade_Shoulei_Weapon_Wra")) + return Item.Grenade; + if (str.Contains("MZJ_4X")) + return Item.Scope4x; + if (str.Contains("MZJ_6X")) + return Item.Scope6x; + if (str.Contains("MZJ_8X")) + return Item.Scope8x; + if (str.Contains("DJ_Large_EQ")) + return Item.RifleMagazine; + if (str.Contains("QK_Sniper_Suppressor")) + return Item.SniperSilenter; + if (str.Contains("QK_Large_Suppressor")) + return Item.RifleSilenter; + //if (str.Contains("Ammo_556mm")) + // return Item.Ammo556; + //if (str.Contains("Ammo_762mm")) + // return Item.Ammo762; + //if (str.Contains("Ammo_300Magnum")) + // return Item.AmmoMagnum; + if (str.Contains("Helmet_Lv3")) + return Item.HelmetLv3; + if (str.Contains("Armor_Lv3")) + return Item.ArmorLv3; + if (str.Contains("Bag_Lv3")) + return Item.BagLv3; + if (str.Contains("Helmet_Lv2")) + return Item.HelmetLv2; + if (str.Contains("Armor_Lv2")) + return Item.ArmorLv2; + if (str.Contains("Bag_Lv2")) + return Item.BagLv2; + if (str.Contains("Firstaid")) + return Item.AidKit; + if (str.Contains("Injection")) + return Item.Epinephrine; + if (str.Contains("Pills")) + return Item.PainKiller; + if (str.Contains("Drink")) + return Item.EnegyDrink; + if (!str.Contains("Wrapper")) + return Item.Useless; + if (str.Contains("Pistol_Flaregun")) + return Item.FlareGun; + if (str.Contains("AWM")) + return Item.AWM; + if (str.Contains("Kar98k")) + return Item.Kar98; + if (str.Contains("Mk14")) + return Item.MK14; + if (str.Contains("DP28")) + return Item.DP28; + if (str.Contains("SKS")) + return Item.SKS; + if (str.Contains("Groza")) + return Item.Groza; + if (str.Contains("M762")) + return Item.M762; + if (str.Contains("AKM")) + return Item.AKM; + if (str.Contains("M249")) + return Item.M249; + if (str.Contains("M24")) + return Item.M24; + if (str.Contains("AUG")) + return Item.AUG; + if (str.Contains("QBZ")) + return Item.QBZ; + if (str.Contains("M416")) + return Item.M4A1; + if (str.Contains("SCAR")) + return Item.SCARL; + + return Item.Useless; + } + + /// + /// Get Entity's Type + /// + /// + /// + /// + public static string GetEntityType(long gNames, long id) + { + string result = ""; + long gname = Mem.ReadMemory(gNames); + if (id > 0 && id < 2000000) + { + long page = id / 16384; + long index = id % 16384; + long secPartAddv = Mem.ReadMemory(gname + page * 4); + if (secPartAddv > 0) + { + long nameAddv = Mem.ReadMemory(secPartAddv + index * 4); + if (nameAddv > 0) + { + result = Mem.ReadString(nameAddv + 8, 32); + } + } + } + return result; + } + + + } + + internal static class Utility + { + public static string GetDescription(this Enum value) + { + FieldInfo field = value.GetType().GetField(value.ToString()); + + DescriptionAttribute attribute + = Attribute.GetCustomAttribute(field, typeof(DescriptionAttribute)) + as DescriptionAttribute; + + return attribute == null ? value.ToString() : attribute.Description; + } + + public static bool CheckFeasible(this Vector2 vec) + { + if (vec.X > 1 && vec.Y > 1) + return true; + return false; + } + } +} + diff --git a/dependencies/BypaPH.dll b/dependencies/BypaPH.dll new file mode 100644 index 0000000000000000000000000000000000000000..0922e93b9a279df6856c66645e7db60dd4716a3d GIT binary patch literal 66560 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�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 + + + + + + + + + \ No newline at end of file