Algorithms.cs

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
    {
        /// <summary>
        /// Check if enemy is inside fov circle
        /// </summary>
        /// <param name="xc"></param>
        /// <param name="yc"></param>
        /// <param name="r"></param>
        /// <param name="x"></param>
        /// <param name="y"></param>
        /// <returns></returns>
        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;
        }

        /// <summary>
        /// Get Distance Between Enemy And Player
        /// </summary>
        /// <param name="x1"></param>
        /// <param name="y1"></param>
        /// <param name="x2"></param>
        /// <param name="y2"></param>
        /// <returns></returns>
        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));
        }

        /// <summary>
        /// Read View Matrix
        /// </summary>
        /// <param name="vAddv"></param>
        /// <returns></returns>
        public static D3DMatrix ReadViewMatrix(long vAddv) => Mem.ReadMemory<D3DMatrix>(vAddv);

        /// <summary>
        /// Read FTTransform
        /// </summary>
        /// <param name="vAddv"></param>
        /// <returns></returns>
        public static FTTransform ReadFTTransform(long vAddv) => Mem.ReadMemory<FTTransform>(vAddv);

        public static FTTransform2 ReadFTransform2(long vAddv) => Mem.ReadMemory<FTTransform2>(vAddv);

        /// <summary>
        /// Get Bone's world position
        /// </summary>
        /// <param name="actorAddv"></param>
        /// <param name="boneAddv"></param>
        /// <returns></returns>
        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;
        }

        /// <summary>
        /// To Matrix With Scale
        /// </summary>
        /// <param name="translation"></param>
        /// <param name="scale"></param>
        /// <param name="rot"></param>
        /// <returns></returns>
        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;
        }

        /// <summary>
        /// D3DMatrix Mutiplication
        /// </summary>
        /// <param name="pM1"></param>
        /// <param name="pM2"></param>
        /// <returns></returns>
        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;
        }

        /// <summary>
        /// Player's World To Screen Function
        /// </summary>
        /// <param name="vAddr"></param>
        /// <param name="pos"></param>
        /// <param name="screen"></param>
        /// <param name="windowWidth"></param>
        /// <param name="windowHeight"></param>
        /// <returns></returns>
        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;
        }

        /// <summary>
        /// Bone's World to Screen Function
        /// </summary>
        /// <param name="viewMatrix"></param>
        /// <param name="pos"></param>
        /// <param name="screen"></param>
        /// <param name="windowWidth"></param>
        /// <param name="windowHeight"></param>
        /// <returns></returns>
        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
        /// </summary>
        /// <param name="viewMatrix"></param>
        /// <param name="pos"></param>
        /// <param name="screen"></param>
        /// <param name="distance"></param>
        /// <param name="windowWidth"></param>
        /// <param name="windowHeight"></param>
        /// <returns></returns>
        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);
        }


    }
}