Restructure solution

Client/Scripts/Util/AddOnDataProvider.cs

@@ -0,0 +1,59 @@
+using GTA;
+
+namespace RageCoop.Client
+{
+    /// <summary>
+    /// Class providing support for addon mods
+    /// </summary>
+    internal class AddOnDataProvider
+    {
+        public static int GetMuzzleIndex(Model model)
+        {
+            switch (model.Hash)
+            {
+                // f14a2
+                case -848721350:
+                    return 48;
+
+                // f15e
+                case 881261972:
+                    return 32;
+
+                // f16c
+                case -2051171080:
+                    return 25;
+
+                // F22A
+                case 2061630439:
+                    return 14;
+
+                // f35c
+                case -343547392:
+                    return 44;
+
+                // mig29a
+                case 513887552:
+                    return 18;
+
+                // su30sm
+                case -733985185:
+                    return 34;
+
+                // su33
+                case -722216722:
+                    return 34;
+
+                // su35s
+                case -268602544:
+                    return 28;
+
+                // su57
+                case 1490050781:
+                    return 21;
+
+                default:
+                    return -1;
+            }
+        }
+    }
+}

Client/Scripts/Util/Memory.cs

@@ -0,0 +1,103 @@
+
+using GTA;
+using GTA.Math;
+using RageCoop.Core;
+using SHVDN;
+using System;
+using System.Collections.Generic;
+using System.Runtime.InteropServices;
+
+namespace RageCoop.Client
+{
+    internal unsafe class MemPatch
+    {
+        private readonly byte[] _data;
+        private readonly byte[] _orginal;
+        private readonly IntPtr _address;
+        public MemPatch(byte* address, byte[] data)
+        {
+            _data = data;
+            _orginal = new byte[data.Length];
+            _address = (IntPtr)address;
+            Marshal.Copy((IntPtr)address, _orginal, 0, data.Length);
+        }
+        public void Install()
+        {
+            Marshal.Copy(_data, 0, _address, _data.Length);
+        }
+        public void Uninstall()
+        {
+            Marshal.Copy(_orginal, 0, _address, _orginal.Length);
+        }
+    }
+
+    internal static unsafe class Memory
+    {
+        public static MemPatch VignettingPatch;
+        public static MemPatch VignettingCallPatch;
+        public static MemPatch TimeScalePatch;
+        static Memory()
+        {
+            // Weapon/radio wheel slow-mo patch
+            // Thanks @CamxxCore, https://github.com/CamxxCore/GTAVWeaponWheelMod
+            var result = NativeMemory.FindPattern("\x38\x51\x64\x74\x19", "xxxxx");
+            if (result == null) { throw new NotSupportedException("Can't find memory pattern to patch weapon/radio slow-mo"); }
+            var address = result + 26;
+            address = address + *(int*)address + 4u;
+            VignettingPatch = new MemPatch(address, new byte[] { RET, 0x90, 0x90, 0x90, 0x90 });
+            VignettingCallPatch = new MemPatch(result + 8, new byte[] { 0x90, 0x90, 0x90, 0x90, 0x90 });
+            TimeScalePatch = new MemPatch(result + 34, new byte[] { XOR_32_64, 0xD2 });
+
+        }
+        public static void ApplyPatches()
+        {
+            VignettingPatch.Install();
+            VignettingCallPatch.Install();
+            TimeScalePatch.Install();
+        }
+        public static void RestorePatches()
+        {
+            VignettingPatch.Uninstall();
+            VignettingCallPatch.Uninstall();
+            TimeScalePatch.Uninstall();
+        }
+        #region PATCHES
+        #endregion
+        #region OFFSET-CONST
+        public const int PositionOffset = 144;
+        public const int VelocityOffset = 800;
+        public const int MatrixOffset = 96;
+        #endregion
+        #region OPCODE
+        private const byte XOR_32_64 = 0x31;
+        private const byte RET = 0xC3;
+        #endregion
+        public static Vector3 ReadPosition(this Entity e) => ReadVector3(e.MemoryAddress + PositionOffset);
+        public static Quaternion ReadQuaternion(this Entity e) => Quaternion.RotationMatrix(e.Matrix);
+        public static Vector3 ReadRotation(this Entity e) => e.ReadQuaternion().ToEulerDegrees();
+        public static Vector3 ReadVelocity(this Ped e) => ReadVector3(e.MemoryAddress + VelocityOffset);
+        public static Vector3 ReadVector3(IntPtr address)
+        {
+            float* ptr = (float*)address.ToPointer();
+            return new Vector3()
+            {
+                X = *ptr,
+                Y = ptr[1],
+                Z = ptr[2]
+            };
+        }
+        public static List<int> FindOffset(float toSearch, IntPtr start, int range = 1000, float tolerance = 0.01f)
+        {
+            var foundOffsets = new List<int>(100);
+            for (int i = 0; i <= range; i++)
+            {
+                var val = NativeMemory.ReadFloat(start + i);
+                if (Math.Abs(val - toSearch) < tolerance)
+                {
+                    foundOffsets.Add(i);
+                }
+            }
+            return foundOffsets;
+        }
+    }
+}

Client/Scripts/Util/NativeCaller.cs

@@ -0,0 +1,145 @@
+using GTA.Math;
+using GTA.Native;
+using System;
+using System.Runtime.InteropServices;
+
+namespace RageCoop.Client
+{
+    [StructLayout(LayoutKind.Explicit, Size = 80)]
+    public struct HeadBlendData
+    {
+        [FieldOffset(0)]
+        public int ShapeFirst;
+
+        [FieldOffset(8)]
+        public int ShapeSecond;
+
+        [FieldOffset(16)]
+        public int ShapeThird;
+
+        [FieldOffset(24)]
+        public int SkinFirst;
+
+        [FieldOffset(32)]
+        public int SkinSecond;
+
+        [FieldOffset(40)]
+        public int SkinThird;
+
+        [FieldOffset(48)]
+        public float ShapeMix;
+
+        [FieldOffset(56)]
+        public float SkinMix;
+
+        [FieldOffset(64)]
+        public float ThirdMix;
+    }
+
+    [StructLayout(LayoutKind.Explicit, Size = 24)]
+    public struct NativeVector3
+    {
+        [FieldOffset(0)]
+        public float X;
+
+        [FieldOffset(8)]
+        public float Y;
+
+        [FieldOffset(16)]
+        public float Z;
+
+        public static implicit operator Vector3(NativeVector3 vec)
+        {
+            return new Vector3() { X = vec.X, Y = vec.Y, Z = vec.Z };
+        }
+        public static implicit operator NativeVector3(Vector3 vec)
+        {
+            return new NativeVector3() { X = vec.X, Y = vec.Y, Z = vec.Z };
+        }
+    }
+    public static class NativeCaller
+    {
+        // These are borrowed from ScriptHookVDotNet's 
+        [DllImport("ScriptHookV.dll", ExactSpelling = true, EntryPoint = "?nativeInit@@YAX_K@Z")]
+        private static extern void NativeInit(ulong hash);
+
+        [DllImport("ScriptHookV.dll", ExactSpelling = true, EntryPoint = "?nativePush64@@YAX_K@Z")]
+        private static extern void NativePush64(ulong val);
+
+        [DllImport("ScriptHookV.dll", ExactSpelling = true, EntryPoint = "?nativeCall@@YAPEA_KXZ")]
+        private static extern unsafe ulong* NativeCall();
+
+        // These are from ScriptHookV's nativeCaller.h
+        private static unsafe void NativePush<T>(T val) where T : unmanaged
+        {
+            ulong val64 = 0;
+            *(T*)(&val64) = val;
+            NativePush64(val64);
+        }
+
+        public static unsafe R Invoke<R>(ulong hash) where R : unmanaged
+        {
+            NativeInit(hash);
+            return *(R*)(NativeCall());
+        }
+        public static unsafe R Invoke<R>(Hash hash, params object[] args)
+            where R : unmanaged
+        {
+            NativeInit((ulong)hash);
+            var arguments = ConvertPrimitiveArguments(args);
+            foreach (var arg in arguments)
+                NativePush(arg);
+
+            return *(R*)(NativeCall());
+        }
+
+
+        /// <summary>
+        /// Helper function that converts an array of primitive values to a native stack.
+        /// </summary>
+        /// <param name="args"></param>
+        /// <returns></returns>
+        private static unsafe ulong[] ConvertPrimitiveArguments(object[] args)
+        {
+            var result = new ulong[args.Length];
+            for (int i = 0; i < args.Length; ++i)
+            {
+                if (args[i] is bool valueBool)
+                {
+                    result[i] = valueBool ? 1ul : 0ul;
+                    continue;
+                }
+                if (args[i] is byte valueByte)
+                {
+                    result[i] = valueByte;
+                    continue;
+                }
+                if (args[i] is int valueInt32)
+                {
+                    result[i] = (ulong)valueInt32;
+                    continue;
+                }
+                if (args[i] is ulong valueUInt64)
+                {
+                    result[i] = valueUInt64;
+                    continue;
+                }
+                if (args[i] is float valueFloat)
+                {
+                    result[i] = *(ulong*)&valueFloat;
+                    continue;
+                }
+                if (args[i] is IntPtr valueIntPtr)
+                {
+                    result[i] = (ulong)valueIntPtr.ToInt64();
+                    continue;
+                }
+
+                throw new ArgumentException("Unknown primitive type in native argument list", nameof(args));
+            }
+
+            return result;
+        }
+    }
+
+}

Client/Scripts/Util/PedConfigFlags.cs

@@ -0,0 +1,465 @@
+namespace RageCoop.Client
+{
+    // Potential names and hash collisions included as comments
+    internal enum PedConfigFlags
+    {
+        _0x67D1A445 = 0,
+        _0xC63DE95E = 1,
+        CPED_CONFIG_FLAG_NoCriticalHits = 2,
+        CPED_CONFIG_FLAG_DrownsInWater = 3,
+        CPED_CONFIG_FLAG_DisableReticuleFixedLockon = 4,
+        _0x37D196F4 = 5,
+        _0xE2462399 = 6,
+        CPED_CONFIG_FLAG_UpperBodyDamageAnimsOnly = 7,
+        _0xEDDEB838 = 8,
+        _0xB398B6FD = 9,
+        _0xF6664E68 = 10,
+        _0xA05E7CA3 = 11,
+        _0xCE394045 = 12,
+        CPED_CONFIG_FLAG_NeverLeavesGroup = 13,
+        _0xCD8D1411 = 14,
+        _0xB031F1A9 = 15,
+        _0xFE65BEE3 = 16,
+        CPED_CONFIG_FLAG_BlockNonTemporaryEvents = 17,
+        _0x380165BD = 18,
+        _0x07C045C7 = 19,
+        _0x583B5E2D = 20,
+        _0x475EDA58 = 21,
+        _0x8629D05B = 22,
+        _0x1522968B = 23,
+        CPED_CONFIG_FLAG_IgnoreSeenMelee = 24,
+        _0x4CC09C4B = 25,
+        _0x034F3053 = 26,
+        _0xD91BA7CC = 27,
+        _0x5C8DC66E = 28,
+        _0x8902EAA0 = 29,
+        _0x6580B9D2 = 30,
+        _0x0EF7A297 = 31,
+        _0x6BF86E5B = 32,
+        CPED_CONFIG_FLAG_DieWhenRagdoll = 33,
+        CPED_CONFIG_FLAG_HasHelmet = 34,
+        CPED_CONFIG_FLAG_UseHelmet = 35,
+        _0xEEB3D630 = 36,
+        _0xB130D17B = 37,
+        _0x5F071200 = 38,
+        CPED_CONFIG_FLAG_DisableEvasiveDives = 39,
+        _0xC287AAFF = 40,
+        _0x203328CC = 41,
+        CPED_CONFIG_FLAG_DontInfluenceWantedLevel = 42,
+        CPED_CONFIG_FLAG_DisablePlayerLockon = 43,
+        CPED_CONFIG_FLAG_DisableLockonToRandomPeds = 44,
+        _0xEC4A8ACF = 45,
+        _0xDB115BFA = 46,
+        CPED_CONFIG_FLAG_PedBeingDeleted = 47,
+        CPED_CONFIG_FLAG_BlockWeaponSwitching = 48,
+        _0xF8E99565 = 49,
+        _0xDD17FEE6 = 50,
+        _0x7ED9B2C9 = 51,
+        _0x655E8618 = 52,
+        _0x5A6C1F6E = 53,
+        _0xD749FC41 = 54,
+        _0x357F63F3 = 55,
+        _0xC5E60961 = 56,
+        _0x29275C3E = 57,
+        CPED_CONFIG_FLAG_IsFiring = 58,
+        CPED_CONFIG_FLAG_WasFiring = 59,
+        CPED_CONFIG_FLAG_IsStanding = 60,
+        CPED_CONFIG_FLAG_WasStanding = 61,
+        CPED_CONFIG_FLAG_InVehicle = 62,
+        CPED_CONFIG_FLAG_OnMount = 63,
+        CPED_CONFIG_FLAG_AttachedToVehicle = 64,
+        CPED_CONFIG_FLAG_IsSwimming = 65,
+        CPED_CONFIG_FLAG_WasSwimming = 66,
+        CPED_CONFIG_FLAG_IsSkiing = 67,
+        CPED_CONFIG_FLAG_IsSitting = 68,
+        CPED_CONFIG_FLAG_KilledByStealth = 69,
+        CPED_CONFIG_FLAG_KilledByTakedown = 70,
+        CPED_CONFIG_FLAG_Knockedout = 71,
+        _0x3E3C4560 = 72,
+        _0x2994C7B7 = 73,
+        _0x6D59D275 = 74,
+        CPED_CONFIG_FLAG_UsingCoverPoint = 75,
+        CPED_CONFIG_FLAG_IsInTheAir = 76,
+        _0x2D493FB7 = 77,
+        CPED_CONFIG_FLAG_IsAimingGun = 78,
+        _0x14D69875 = 79,
+        _0x40B05311 = 80,
+        _0x8B230BC5 = 81,
+        _0xC74E5842 = 82,
+        _0x9EA86147 = 83,
+        _0x674C746C = 84,
+        _0x3E56A8C2 = 85,
+        _0xC144A1EF = 86,
+        _0x0548512D = 87,
+        _0x31C93909 = 88,
+        _0xA0269315 = 89,
+        _0xD4D59D4D = 90,
+        _0x411D4420 = 91,
+        _0xDF4AEF0D = 92,
+        CPED_CONFIG_FLAG_ForcePedLoadCover = 93,
+        _0x300E4CD3 = 94,
+        _0xF1C5BF04 = 95,
+        _0x89C2EF13 = 96,
+        CPED_CONFIG_FLAG_VaultFromCover = 97,
+        _0x02A852C8 = 98,
+        _0x3D9407F1 = 99,
+        _0x319B4558 = 100,
+        CPED_CONFIG_FLAG_ForcedAim = 101,
+        _0xB942D71A = 102,
+        _0xD26C55A8 = 103,
+        _0xB89E703B = 104,
+        CPED_CONFIG_FLAG_ForceReload = 105,
+        _0xD9E73DA2 = 106,
+        _0xFF71DC2C = 107,
+        _0x1E27E8D8 = 108,
+        _0xF2C53966 = 109,
+        _0xC4DBE247 = 110,
+        _0x83C0A4BF = 111,
+        _0x0E0FAF8C = 112,
+        _0x26616660 = 113,
+        _0x43B80B79 = 114,
+        _0x0D2A9309 = 115,
+        _0x12C1C983 = 116,
+        CPED_CONFIG_FLAG_BumpedByPlayer = 117,
+        _0xE586D504 = 118,
+        _0x52374204 = 119,
+        CPED_CONFIG_FLAG_IsHandCuffed = 120,
+        CPED_CONFIG_FLAG_IsAnkleCuffed = 121,
+        CPED_CONFIG_FLAG_DisableMelee = 122,
+        _0xFE714397 = 123,
+        _0xB3E660BD = 124,
+        _0x5FED6BFD = 125,
+        _0xC9D6F66F = 126,
+        _0x519BC986 = 127,
+        CPED_CONFIG_FLAG_CanBeAgitated = 128,
+        _0x9A4B617C = 129, // CPED_CONFIG_FLAG_FaceDirInsult
+        _0xDAB70E9F = 130,
+        _0xE569438A = 131,
+        _0xBBC77D6D = 132,
+        _0xCB59EF0F = 133,
+        _0x8C5EA971 = 134,
+        CPED_CONFIG_FLAG_IsScuba = 135,
+        CPED_CONFIG_FLAG_WillArrestRatherThanJack = 136,
+        _0xDCE59B58 = 137,
+        CPED_CONFIG_FLAG_RidingTrain = 138,
+        CPED_CONFIG_FLAG_ArrestResult = 139,
+        CPED_CONFIG_FLAG_CanAttackFriendly = 140,
+        _0x98A4BE43 = 141,
+        _0x6901E731 = 142,
+        _0x9EC9BF6C = 143,
+        _0x42841A8F = 144,
+        CPED_CONFIG_FLAG_ShootingAnimFlag = 145,
+        CPED_CONFIG_FLAG_DisableLadderClimbing = 146,
+        CPED_CONFIG_FLAG_StairsDetected = 147,
+        CPED_CONFIG_FLAG_SlopeDetected = 148,
+        _0x1A15670B = 149,
+        _0x61786EE5 = 150,
+        _0xCB9186BD = 151,
+        _0xF0710152 = 152,
+        _0x43DFE310 = 153,
+        _0xC43C624E = 154,
+        CPED_CONFIG_FLAG_CanPerformArrest = 155,
+        CPED_CONFIG_FLAG_CanPerformUncuff = 156,
+        CPED_CONFIG_FLAG_CanBeArrested = 157,
+        _0xF7960FF5 = 158,
+        _0x59564113 = 159,
+        _0x0C6C3099 = 160,
+        _0x645F927A = 161,
+        _0xA86549B9 = 162,
+        _0x8AAF337A = 163,
+        _0x13BAA6E7 = 164,
+        _0x5FB9D1F5 = 165,
+        CPED_CONFIG_FLAG_IsInjured = 166,
+        _0x6398A20B = 167,
+        _0xD8072639 = 168,
+        _0xA05B1845 = 169,
+        _0x83F6D220 = 170,
+        _0xD8430331 = 171,
+        _0x4B547520 = 172,
+        _0xE66E1406 = 173,
+        _0x1C4BFE0C = 174,
+        _0x90008BFA = 175,
+        _0x07C7A910 = 176,
+        _0xF15F8191 = 177,
+        _0xCE4E8BE2 = 178,
+        _0x1D46E4F2 = 179,
+        CPED_CONFIG_FLAG_IsInCustody = 180,
+        _0xE4FD9B3A = 181,
+        _0x67AE0812 = 182,
+        CPED_CONFIG_FLAG_IsAgitated = 183,
+        CPED_CONFIG_FLAG_PreventAutoShuffleToDriversSeat = 184,
+        _0x7B2D325E = 185,
+        CPED_CONFIG_FLAG_EnableWeaponBlocking = 186,
+        CPED_CONFIG_FLAG_HasHurtStarted = 187,
+        CPED_CONFIG_FLAG_DisableHurt = 188,
+        CPED_CONFIG_FLAG_PlayerIsWeird = 189,
+        _0x32FC208B = 190,
+        _0x0C296E5A = 191,
+        _0xE63B73EC = 192,
+        _0x04E9CC80 = 193,
+        CPED_CONFIG_FLAG_UsingScenario = 194,
+        CPED_CONFIG_FLAG_VisibleOnScreen = 195,
+        _0xD88C58A1 = 196,
+        _0x5A3DCF43 = 197, // CPED_CONFIG_FLAG_AvoidUnderSide
+        _0xEA02B420 = 198,
+        _0x3F559CFF = 199,
+        _0x8C55D029 = 200,
+        _0x5E6466F6 = 201,
+        _0xEB5AD706 = 202,
+        _0x0EDDDDE7 = 203,
+        _0xA64F7B1D = 204,
+        _0x48532CBA = 205,
+        _0xAA25A9E7 = 206,
+        _0x415B26B9 = 207,
+        CPED_CONFIG_FLAG_DisableExplosionReactions = 208,
+        CPED_CONFIG_FLAG_DodgedPlayer = 209,
+        _0x67405504 = 210,
+        _0x75DDD68C = 211,
+        _0x2AD879B4 = 212,
+        _0x51486F91 = 213,
+        _0x32F79E21 = 214,
+        _0xBF099213 = 215,
+        _0x054AC8E2 = 216,
+        _0x14E495CC = 217,
+        _0x3C7DF9DF = 218,
+        _0x848FFEF2 = 219,
+        CPED_CONFIG_FLAG_DontEnterLeadersVehicle = 220,
+        _0x2618E1CF = 221,
+        _0x84F722FA = 222,
+        _0xD1B87B1F = 223,
+        _0x728AA918 = 224,
+        CPED_CONFIG_FLAG_DisablePotentialToBeWalkedIntoResponse = 225,
+        CPED_CONFIG_FLAG_DisablePedAvoidance = 226,
+        _0x59E91185 = 227,
+        _0x1EA7225F = 228,
+        CPED_CONFIG_FLAG_DisablePanicInVehicle = 229,
+        _0x6DCA7D88 = 230,
+        _0xFC3E572D = 231,
+        _0x08E9F9CF = 232,
+        _0x2D3BA52D = 233,
+        _0xFD2F53EA = 234,
+        _0x31A1B03B = 235,
+        CPED_CONFIG_FLAG_IsHoldingProp = 236,
+        _0x82ED0A66 = 237, // CPED_CONFIG_FLAG_BlocksPathingWhenDead
+        _0xCE57C9A3 = 238,
+        _0x26149198 = 239,
+        _0x1B33B598 = 240,
+        _0x719B6E87 = 241,
+        _0x13E8E8E8 = 242,
+        _0xF29739AE = 243,
+        _0xABEA8A74 = 244,
+        _0xB60EA2BA = 245,
+        _0x536B0950 = 246,
+        _0x0C754ACA = 247,
+        CPED_CONFIG_FLAG_DisableVehicleSeatRandomAnimations = 248,
+        _0x12659168 = 249,
+        _0x1BDF2F04 = 250,
+        _0x7728FAA3 = 251,
+        _0x6A807ED8 = 252,
+        CPED_CONFIG_FLAG_OnStairs = 253,
+        _0xE1A2F73F = 254,
+        _0x5B3697C8 = 255,
+        _0xF1EB20A9 = 256,
+        _0x8B7DF407 = 257,
+        _0x329DCF1A = 258,
+        _0x8D90DD1B = 259,
+        _0xB8A292B7 = 260,
+        _0x8374B087 = 261,
+        _0x2AF558F0 = 262,
+        _0x82251455 = 263,
+        _0x30CF498B = 264,
+        _0xE1CD50AF = 265,
+        _0x72E4AE48 = 266,
+        _0xC2657EA1 = 267,
+        _0x29FF6030 = 268,
+        _0x8248A5EC = 269,
+        CPED_CONFIG_FLAG_OnStairSlope = 270,
+        _0xA0897933 = 271,
+        CPED_CONFIG_FLAG_DontBlipCop = 272,
+        CPED_CONFIG_FLAG_ClimbedShiftedFence = 273,
+        _0xF7823618 = 274,
+        _0xDC305CCE = 275, // CPED_CONFIG_FLAG_KillWhenTrapped
+        CPED_CONFIG_FLAG_EdgeDetected = 276,
+        _0x92B67896 = 277,
+        _0xCAD677C9 = 278,
+        CPED_CONFIG_FLAG_AvoidTearGas = 279,
+        _0x5276AC7B = 280,
+        _0x1032692A = 281,
+        _0xDA23E7F1 = 282,
+        _0x9139724D = 283,
+        _0xA1457461 = 284,
+        _0x4186E095 = 285,
+        _0xAC68E2EB = 286,
+        CPED_CONFIG_FLAG_RagdollingOnBoat = 287,
+        CPED_CONFIG_FLAG_HasBrandishedWeapon = 288,
+        _0x1B9EE8A1 = 289,
+        _0xF3F5758C = 290,
+        _0x2A9307F1 = 291,
+        _0x7403D216 = 292,
+        _0xA06A3C6C = 293,
+        CPED_CONFIG_FLAG_DisableShockingEvents = 294,
+        _0xF8DA25A5 = 295,
+        _0x7EF55802 = 296,
+        _0xB31F1187 = 297,
+        _0x84315402 = 298,
+        _0x0FD69867 = 299,
+        _0xC7829B67 = 300,
+        CPED_CONFIG_FLAG_DisablePedConstraints = 301,
+        _0x6D23CF25 = 302,
+        _0x2ADA871B = 303,
+        _0x47BC8A58 = 304,
+        _0xEB692FA5 = 305,
+        _0x4A133C50 = 306,
+        _0xC58099C3 = 307,
+        _0xF3D76D41 = 308,
+        _0xB0EEE9F2 = 309,
+        CPED_CONFIG_FLAG_IsInCluster = 310,
+        _0x0FA153EF = 311,
+        _0xD73F5CD3 = 312,
+        _0xD4136C22 = 313,
+        _0xE404CA6B = 314,
+        _0xB9597446 = 315,
+        _0xD5C98277 = 316,
+        _0xD5060A9C = 317,
+        _0x3E5F1CBB = 318,
+        _0xD8BE1D54 = 319,
+        _0x0B1F191F = 320,
+        _0xC995167A = 321,
+        CPED_CONFIG_FLAG_HasHighHeels = 322,
+        _0x86B01E54 = 323,
+        _0x3A56FE15 = 324,
+        _0xC03B736C = 325, // CPED_CONFIG_FLAG_SpawnedAtScenario
+        _0xBBF47729 = 326,
+        _0x22B668A8 = 327,
+        _0x2624D4D4 = 328,
+        CPED_CONFIG_FLAG_DisableTalkTo = 329,
+        CPED_CONFIG_FLAG_DontBlip = 330,
+        CPED_CONFIG_FLAG_IsSwitchingWeapon = 331,
+        _0x630F55F3 = 332,
+        _0x150468FD = 333,
+        _0x914EBD6B = 334,
+        _0x79AF3B6D = 335,
+        _0x75C7A632 = 336,
+        _0x52D530E2 = 337,
+        _0xDB2A90E0 = 338,
+        _0x5922763D = 339,
+        _0x12ADB567 = 340,
+        _0x105C8518 = 341,
+        _0x106F703D = 342,
+        _0xED152C3E = 343,
+        _0xA0EFE6A8 = 344,
+        _0xBF348C82 = 345,
+        _0xCDDFE830 = 346,
+        _0x7B59BD9B = 347,
+        _0x0124C788 = 348,
+        CPED_CONFIG_FLAG_EquipJetpack = 349,
+        _0x08D361A5 = 350,
+        _0xE13D1F7C = 351,
+        _0x40E25FB9 = 352,
+        _0x930629D9 = 353,
+        _0xECCF0C7F = 354,
+        _0xB6E9613B = 355,
+        _0x490C0478 = 356,
+        _0xE8865BEA = 357,
+        _0xF3C34A29 = 358,
+        CPED_CONFIG_FLAG_IsDuckingInVehicle = 359,
+        _0xF660E115 = 360,
+        _0xAB0E6DED = 361,
+        CPED_CONFIG_FLAG_HasReserveParachute = 362,
+        CPED_CONFIG_FLAG_UseReserveParachute = 363,
+        _0x5C5D9CD3 = 364,
+        _0x8F7701F3 = 365,
+        _0xBC4436AD = 366,
+        _0xD7E07D37 = 367,
+        _0x03C4FD24 = 368,
+        _0x7675789A = 369,
+        _0xB7288A88 = 370,
+        _0xC06B6291 = 371,
+        _0x95A4A805 = 372,
+        _0xA8E9A042 = 373,
+        CPED_CONFIG_FLAG_NeverLeaveTrain = 374,
+        _0xBAC674B3 = 375,
+        _0x147F1FFB = 376,
+        _0x4376DD79 = 377,
+        _0xCD3DB518 = 378,
+        _0xFE4BA4B6 = 379,
+        _0x5DF03A55 = 380,
+        _0xBCD816CD = 381,
+        _0xCF02DD69 = 382,
+        _0xF73AFA2E = 383,
+        _0x80B9A9D0 = 384,
+        _0xF601F7EE = 385,
+        _0xA91350FC = 386,
+        _0x3AB23B96 = 387,
+        CPED_CONFIG_FLAG_IsClimbingLadder = 388,
+        CPED_CONFIG_FLAG_HasBareFeet = 389,
+        _0xB4B1CD4C = 390,
+        _0x5459AFB8 = 391,
+        _0x54F27667 = 392,
+        _0xC11D3E8F = 393,
+        _0x5419EB3E = 394,
+        _0x82D8DBB4 = 395,
+        _0x33B02D2F = 396,
+        _0xAE66176D = 397,
+        _0xA2692593 = 398,
+        _0x714C7E31 = 399,
+        _0xEC488AC7 = 400,
+        _0xAE398504 = 401,
+        _0xABC58D72 = 402,
+        _0x5E5B9591 = 403,
+        _0x6BA1091E = 404,
+        _0x77840177 = 405,
+        _0x1C7ACAC4 = 406,
+        _0x124420E9 = 407,
+        _0x75A65587 = 408,
+        _0xDFD2D55B = 409,
+        _0xBDD39919 = 410,
+        _0x43DEC267 = 411,
+        _0xE42B7797 = 412,
+        CPED_CONFIG_FLAG_IsHolsteringWeapon = 413,
+        _0x4F8149F5 = 414,
+        _0xDD9ECA7A = 415,
+        _0x9E7EF9D2 = 416,
+        _0x2C6ED942 = 417,
+        CPED_CONFIG_FLAG_IsSwitchingHelmetVisor = 418,
+        _0xA488727D = 419,
+        _0xCFF5F6DE = 420,
+        _0x6D614599 = 421,
+        CPED_CONFIG_FLAG_DisableVehicleCombat = 422,
+        _0xFE401D26 = 423,
+        CPED_CONFIG_FLAG_FallsLikeAircraft = 424,
+        _0x2B42AE82 = 425,
+        _0x7A95734F = 426,
+        _0xDF4D8617 = 427,
+        _0x578F1F14 = 428,
+        CPED_CONFIG_FLAG_DisableStartEngine = 429,
+        CPED_CONFIG_FLAG_IgnoreBeingOnFire = 430,
+        _0x153C9500 = 431,
+        _0xCB7A632E = 432,
+        _0xDE727981 = 433,
+        CPED_CONFIG_FLAG_DisableHomingMissileLockon = 434,
+        _0x12BBB935 = 435,
+        _0xAD0A1277 = 436,
+        _0xEA6AA46A = 437,
+        CPED_CONFIG_FLAG_DisableHelmetArmor = 438,
+        _0xCB7F3A1E = 439,
+        _0x50178878 = 440,
+        _0x051B4F0D = 441,
+        _0x2FC3DECC = 442,
+        _0xC0030B0B = 443,
+        _0xBBDAF1E9 = 444,
+        _0x944FE59C = 445,
+        _0x506FBA39 = 446,
+        _0xDD45FE84 = 447,
+        _0xE698AE75 = 448,
+        _0x199633F8 = 449,
+        CPED_CONFIG_FLAG_PedIsArresting = 450,
+        CPED_CONFIG_FLAG_IsDecoyPed = 451,
+        _0x3A251D83 = 452,
+        _0xA56F6986 = 453,
+        _0x1D19C622 = 454,
+        _0xB68D3EAB = 455,
+        CPED_CONFIG_FLAG_CanBeIncapacitated = 456,
+        _0x4BD5EBAD = 457,
+    }
+}

Client/Scripts/Util/PedExtensions.cs

@@ -0,0 +1,511 @@
+using GTA;
+using GTA.Math;
+using GTA.Native;
+using RageCoop.Core;
+using System;
+using System.Collections.Generic;
+
+namespace RageCoop.Client
+{
+    internal static partial class PedExtensions
+    {
+
+        public static bool IsBetween<T>(this T item, T start, T end)
+        {
+            return Comparer<T>.Default.Compare(item, start) >= 0 && Comparer<T>.Default.Compare(item, end) <= 0;
+        }
+
+        public static bool Compare<T, Y>(this Dictionary<T, Y> item, Dictionary<T, Y> item2)
+        {
+            if (item == null || item2 == null || item.Count != item2.Count)
+            {
+                return false;
+            }
+
+            foreach (KeyValuePair<T, Y> pair in item)
+            {
+                if (item2.TryGetValue(pair.Key, out Y value) && Equals(value, pair.Value))
+                {
+                    continue;
+                }
+
+                // TryGetValue() or Equals failed
+                return false;
+            }
+
+            // No difference between item and item2
+            return true;
+        }
+
+
+
+
+        #region PED
+
+        public static byte GetPedSpeed(this Ped ped)
+        {
+
+            if (ped.IsSittingInVehicle())
+            {
+                return 4;
+            }
+            if (ped.IsTaskActive(TaskType.CTaskEnterVehicle))
+            {
+                return 5;
+            }
+            if (ped.IsTaskActive(TaskType.CTaskExitVehicle))
+            {
+                return 6;
+            }
+            if (ped.IsWalking)
+            {
+                return 1;
+            }
+            if (ped.IsRunning)
+            {
+                return 2;
+            }
+            if (ped.IsSprinting)
+            {
+                return 3;
+            }
+
+
+            return 0;
+        }
+
+        // Not sure whether component will always be lesser than 255, whatever...
+        public static byte[] GetPedClothes(this Ped ped)
+        {
+            var result = new byte[36];
+            for (byte i = 0; i < 12; i++)
+            {
+                result[i] = (byte)Function.Call<short>(Hash.GET_PED_DRAWABLE_VARIATION, ped.Handle, i);
+                result[i + 12] = (byte)Function.Call<short>(Hash.GET_PED_TEXTURE_VARIATION, ped.Handle, i);
+                result[i + 24] = (byte)Function.Call<short>(Hash.GET_PED_PALETTE_VARIATION, ped.Handle, i);
+            }
+            return result;
+        }
+
+        public static PedDataFlags GetPedFlags(this Ped ped)
+        {
+            PedDataFlags flags = PedDataFlags.None;
+
+            if (ped.IsAiming || ped.IsOnTurretSeat())
+            {
+                flags |= PedDataFlags.IsAiming;
+            }
+
+
+            if (ped.IsReloading)
+            {
+                flags |= PedDataFlags.IsReloading;
+            }
+
+            if (ped.IsJumping)
+            {
+                flags |= PedDataFlags.IsJumping;
+            }
+
+            // Fake death
+            if (ped.IsRagdoll || (ped.Health == 1 && ped.IsPlayer))
+            {
+                flags |= PedDataFlags.IsRagdoll;
+            }
+
+            if (ped.IsOnFire)
+            {
+                flags |= PedDataFlags.IsOnFire;
+            }
+
+            if (ped.IsInParachuteFreeFall)
+            {
+                flags |= PedDataFlags.IsInParachuteFreeFall;
+            }
+
+            if (ped.ParachuteState == ParachuteState.Gliding)
+            {
+                flags |= PedDataFlags.IsParachuteOpen;
+            }
+
+            bool climbingLadder = ped.IsTaskActive(TaskType.CTaskGoToAndClimbLadder);
+            if (climbingLadder)
+            {
+                flags |= PedDataFlags.IsOnLadder;
+            }
+
+            if (ped.IsVaulting && !climbingLadder)
+            {
+                flags |= PedDataFlags.IsVaulting;
+            }
+
+            if (ped.IsInCover || ped.IsGoingIntoCover)
+            {
+                flags |= PedDataFlags.IsInCover;
+                if (ped.IsInCoverFacingLeft)
+                {
+                    flags |= PedDataFlags.IsInCover;
+                }
+                if (!Function.Call<bool>(Hash.IS_PED_IN_HIGH_COVER, ped))
+                {
+                    flags |= PedDataFlags.IsInLowCover;
+                }
+                if (ped.IsTaskActive(TaskType.CTaskAimGunBlindFire))
+                {
+                    flags |= PedDataFlags.IsBlindFiring;
+                }
+            }
+
+            if (ped.IsInvincible)
+            {
+                flags |= PedDataFlags.IsInvincible;
+            }
+
+            if (Function.Call<bool>(Hash.GET_PED_STEALTH_MOVEMENT, ped))
+            {
+                flags |= PedDataFlags.IsInStealthMode;
+            }
+
+
+            return flags;
+        }
+
+        public static string[] GetReloadingAnimation(this Ped ped)
+        {
+            switch (ped.Weapons.Current.Hash)
+            {
+                case WeaponHash.Revolver:
+                case WeaponHash.RevolverMk2:
+                case WeaponHash.DoubleActionRevolver:
+                case WeaponHash.NavyRevolver:
+                    return new string[2] { "anim@weapons@pistol@revolver_str", "reload_aim" };
+                case WeaponHash.APPistol:
+                    return new string[2] { "weapons@pistol@ap_pistol_str", "reload_aim" };
+                case WeaponHash.Pistol50:
+                    return new string[2] { "weapons@pistol@pistol_50_str", "reload_aim" };
+                case WeaponHash.Pistol:
+                case WeaponHash.PistolMk2:
+                case WeaponHash.PericoPistol:
+                case WeaponHash.SNSPistol:
+                case WeaponHash.SNSPistolMk2:
+                case WeaponHash.HeavyPistol:
+                case WeaponHash.VintagePistol:
+                case WeaponHash.CeramicPistol:
+                case WeaponHash.MachinePistol:
+                    return new string[2] { "weapons@pistol@pistol_str", "reload_aim" };
+                case WeaponHash.AssaultRifle:
+                case WeaponHash.AssaultrifleMk2:
+                    return new string[2] { "weapons@rifle@hi@assault_rifle_str", "reload_aim" };
+                case WeaponHash.SniperRifle:
+                    return new string[2] { "weapons@rifle@hi@sniper_rifle_str", "reload_aim" };
+                case WeaponHash.HeavySniper:
+                case WeaponHash.HeavySniperMk2:
+                    return new string[2] { "weapons@rifle@lo@sniper_heavy_str", "reload_aim" };
+                case WeaponHash.PumpShotgun:
+                case WeaponHash.PumpShotgunMk2:
+                    return new string[2] { "weapons@rifle@pump_str", "reload_aim" };
+                case WeaponHash.Railgun:
+                    return new string[2] { "weapons@rifle@lo@rail_gun_str", "reload_aim" };
+                case WeaponHash.SawnOffShotgun:
+                    return new string[2] { "weapons@rifle@lo@sawnoff_str", "reload_aim" };
+                case WeaponHash.AssaultShotgun:
+                    return new string[2] { "weapons@rifle@lo@shotgun_assault_str", "reload_aim" };
+                case WeaponHash.BullpupShotgun:
+                    return new string[2] { "weapons@rifle@lo@shotgun_bullpup_str", "reload_aim" };
+                case WeaponHash.AdvancedRifle:
+                    return new string[2] { "weapons@submg@advanced_rifle_str", "reload_aim" };
+                case WeaponHash.CarbineRifle:
+                case WeaponHash.CarbineRifleMk2:
+                case WeaponHash.CompactRifle:
+                    return new string[2] { "weapons@rifle@lo@carbine_str", "reload_aim" };
+                case WeaponHash.Gusenberg:
+                    return new string[2] { "anim@weapons@machinegun@gusenberg_str", "reload_aim" };
+                case WeaponHash.Musket:
+                    return new string[2] { "anim@weapons@musket@musket_str", "reload_aim" };
+                case WeaponHash.FlareGun:
+                    return new string[2] { "anim@weapons@pistol@flare_str", "reload_aim" };
+                case WeaponHash.SpecialCarbine:
+                case WeaponHash.SpecialCarbineMk2:
+                    return new string[2] { "anim@weapons@rifle@lo@spcarbine_str", "reload_aim" };
+                case WeaponHash.CombatPDW:
+                    return new string[2] { "anim@weapons@rifle@lo@pdw_str", "reload_aim" };
+                case WeaponHash.BullpupRifle:
+                case WeaponHash.BullpupRifleMk2:
+                    return new string[2] { "anim@weapons@submg@bullpup_rifle_str", "reload_aim" };
+                case WeaponHash.AssaultSMG:
+                    return new string[2] { "weapons@submg@assault_smg_str", "reload_aim" };
+                case WeaponHash.MicroSMG:
+                case WeaponHash.MiniSMG:
+                    return new string[2] { "weapons@submg@lo@micro_smg_str", "reload_aim" };
+                case WeaponHash.SMG:
+                case WeaponHash.SMGMk2:
+                    return new string[2] { "weapons@rifle@smg_str", "reload_aim" };
+                case WeaponHash.GrenadeLauncher:
+                case WeaponHash.GrenadeLauncherSmoke:
+                case WeaponHash.CompactGrenadeLauncher:
+                    return new string[2] { "weapons@heavy@grenade_launcher_str", "reload_aim" };
+                case WeaponHash.RPG:
+                case WeaponHash.Firework:
+                    return new string[2] { "weapons@heavy@rpg_str", "reload_aim" };
+                case WeaponHash.CombatMG:
+                case WeaponHash.CombatMGMk2:
+                    return new string[2] { "weapons@machinegun@combat_mg_str", "reload_aim" };
+                case WeaponHash.MG:
+                    return new string[2] { "weapons@machinegun@mg_str", "reload_aim" };
+                default:
+                    Main.Logger.Warning($"~r~Reloading failed! Weapon ~g~[{ped.Weapons.Current.Hash}]~r~ could not be found!");
+                    return null;
+            }
+        }
+
+        public static VehicleSeat GetNearestSeat(this Ped ped, Vehicle veh, float distanceToignoreDoors = 50f)
+        {
+            float num = 99f;
+            int result = -2;
+            Dictionary<string, int> dictionary = new Dictionary<string, int>();
+            dictionary.Add("door_dside_f", -1);
+            dictionary.Add("door_pside_f", 0);
+            dictionary.Add("door_dside_r", 1);
+            dictionary.Add("door_pside_r", 2);
+            foreach (string text in dictionary.Keys)
+            {
+                bool flag = veh.Bones[text].Position != Vector3.Zero;
+                if (flag)
+                {
+                    float num2 = ped.Position.DistanceTo(Function.Call<Vector3>(Hash.GET_WORLD_POSITION_OF_ENTITY_BONE, new InputArgument[]
+                    {
+                        veh,
+                        veh.Bones[text].Index
+                    }));
+                    bool flag2 = (num2 < distanceToignoreDoors) && (num2 < num) && IsSeatUsableByPed(ped, veh, dictionary[text]);
+                    if (flag2)
+                    {
+                        num = num2;
+                        result = dictionary[text];
+                    }
+                }
+            }
+            return (VehicleSeat)result;
+        }
+        public static bool IsSeatUsableByPed(Ped ped, Vehicle veh, int _seat)
+        {
+            VehicleSeat seat = (VehicleSeat)_seat;
+            bool result = false;
+            bool flag = veh.IsSeatFree(seat);
+            if (flag)
+            {
+                result = true;
+            }
+            else
+            {
+
+                bool isDead = veh.GetPedOnSeat(seat).IsDead;
+                if (isDead)
+                {
+                    result = true;
+                }
+                else
+                {
+                    int num = Function.Call<int>(Hash.GET_RELATIONSHIP_BETWEEN_PEDS, new InputArgument[]
+                    {
+                        ped,
+                        veh.GetPedOnSeat(seat)
+                    });
+                    bool flag2 = num > 2;
+                    if (flag2)
+                    {
+                        result = true;
+                    }
+                }
+
+            }
+            return result;
+        }
+        public static bool IsTaskActive(this Ped p, TaskType task)
+        {
+            return Function.Call<bool>(Hash.GET_IS_TASK_ACTIVE, p.Handle, task);
+        }
+        public static Vector3 GetAimCoord(this Ped p)
+        {
+            var weapon = p.Weapons.CurrentWeaponObject;
+
+            var v = p.CurrentVehicle;
+            // Rhino
+            if (v != null && v.Model.Hash == 782665360)
+            {
+                return v.Bones[35].Position + v.Bones[35].ForwardVector * 100;
+            }
+            if (p.IsOnTurretSeat()) { return p.GetLookingCoord(); }
+            if (weapon != null)
+            {
+                // Not very accurate, but doesn't matter
+                Vector3 dir = weapon.RightVector;
+                return weapon.Position + dir * 20;
+
+            }
+            return GetLookingCoord(p);
+        }
+        public static Vector3 GetLookingCoord(this Ped p)
+        {
+            if (p == Main.P && Function.Call<int>(Hash.GET_FOLLOW_PED_CAM_VIEW_MODE) == 4)
+            {
+                return RaycastEverything(default);
+            }
+            EntityBone b = p.Bones[Bone.FacialForehead];
+            Vector3 v = b.UpVector.Normalized;
+            return b.Position + 200 * v;
+        }
+        public static VehicleSeat GetSeatTryingToEnter(this Ped p)
+        {
+            return (VehicleSeat)Function.Call<int>(Hash.GET_SEAT_PED_IS_TRYING_TO_ENTER, p);
+        }
+
+
+        #endregion
+
+
+
+
+
+
+
+        public static Vector3 RaycastEverything(Vector2 screenCoord)
+        {
+            Vector3 camPos = GameplayCamera.Position;
+            Vector3 camRot = GameplayCamera.Rotation;
+            const float raycastToDist = 100.0f;
+            const float raycastFromDist = 1f;
+
+            Vector3 target3D = ScreenRelToWorld(camPos, camRot, screenCoord);
+            Vector3 source3D = camPos;
+
+            Entity ignoreEntity = Game.Player.Character;
+            if (Game.Player.Character.IsInVehicle())
+            {
+                ignoreEntity = Game.Player.Character.CurrentVehicle;
+            }
+
+            Vector3 dir = target3D - source3D;
+            dir.Normalize();
+            RaycastResult raycastResults = World.Raycast(source3D + dir * raycastFromDist,
+                source3D + dir * raycastToDist,
+                IntersectFlags.Everything,
+                ignoreEntity);
+
+            if (raycastResults.DidHit)
+            {
+                return raycastResults.HitPosition;
+            }
+
+            return camPos + dir * raycastToDist;
+        }
+        public static Vector3 ScreenRelToWorld(Vector3 camPos, Vector3 camRot, Vector2 coord)
+        {
+            Vector3 camForward = camRot.ToDirection();
+            Vector3 rotUp = camRot + new Vector3(10, 0, 0);
+            Vector3 rotDown = camRot + new Vector3(-10, 0, 0);
+            Vector3 rotLeft = camRot + new Vector3(0, 0, -10);
+            Vector3 rotRight = camRot + new Vector3(0, 0, 10);
+
+            Vector3 camRight = rotRight.ToDirection() - rotLeft.ToDirection();
+            Vector3 camUp = rotUp.ToDirection() - rotDown.ToDirection();
+
+            double rollRad = -camRot.Y.ToRadians();
+
+            Vector3 camRightRoll = camRight * (float)Math.Cos(rollRad) - camUp * (float)Math.Sin(rollRad);
+            Vector3 camUpRoll = camRight * (float)Math.Sin(rollRad) + camUp * (float)Math.Cos(rollRad);
+
+            Vector3 point3D = camPos + camForward * 10.0f + camRightRoll + camUpRoll;
+            if (!WorldToScreenRel(point3D, out Vector2 point2D))
+            {
+                return camPos + camForward * 10.0f;
+            }
+
+            Vector3 point3DZero = camPos + camForward * 10.0f;
+            if (!WorldToScreenRel(point3DZero, out Vector2 point2DZero))
+            {
+                return camPos + camForward * 10.0f;
+            }
+
+            const double eps = 0.001;
+            if (Math.Abs(point2D.X - point2DZero.X) < eps || Math.Abs(point2D.Y - point2DZero.Y) < eps)
+            {
+                return camPos + camForward * 10.0f;
+            }
+
+            float scaleX = (coord.X - point2DZero.X) / (point2D.X - point2DZero.X);
+            float scaleY = (coord.Y - point2DZero.Y) / (point2D.Y - point2DZero.Y);
+
+            return camPos + camForward * 10.0f + camRightRoll * scaleX + camUpRoll * scaleY;
+        }
+        public static bool WorldToScreenRel(Vector3 worldCoords, out Vector2 screenCoords)
+        {
+            OutputArgument num1 = new OutputArgument();
+            OutputArgument num2 = new OutputArgument();
+
+            if (!Function.Call<bool>(Hash.GET_SCREEN_COORD_FROM_WORLD_COORD, worldCoords.X, worldCoords.Y, worldCoords.Z, num1, num2))
+            {
+                screenCoords = new Vector2();
+                return false;
+            }
+
+            screenCoords = new Vector2((num1.GetResult<float>() - 0.5f) * 2, (num2.GetResult<float>() - 0.5f) * 2);
+            return true;
+        }
+        public static void StayInCover(this Ped p)
+        {
+            Function.Call(Hash.TASK_STAY_IN_COVER, p);
+        }
+
+        public static bool IsTurretSeat(this Vehicle veh, int seat)
+        {
+            if (!Function.Call<bool>(Hash.DOES_VEHICLE_HAVE_WEAPONS, veh.Handle))
+            {
+                return false;
+            }
+
+            switch (seat)
+            {
+                case -1:
+                    return (VehicleHash)veh.Model.Hash == VehicleHash.Rhino
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Khanjari
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.FireTruck
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Riot2
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Cerberus
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Cerberus2
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Cerberus3;
+                case 0:
+                    return (VehicleHash)veh.Model.Hash == VehicleHash.Apc
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Dune3;
+                case 1:
+                    return (VehicleHash)veh.Model.Hash == VehicleHash.Valkyrie
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Valkyrie2
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Technical
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Technical2
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Technical3
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.HalfTrack
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Barrage;
+                case 2:
+                    return (VehicleHash)veh.Model.Hash == VehicleHash.Valkyrie
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Valkyrie2
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Barrage;
+                case 3:
+                    return (VehicleHash)veh.Model.Hash == VehicleHash.Limo2
+                        || (VehicleHash)veh.Model.Hash == VehicleHash.Dinghy5;
+                case 7:
+                    return (VehicleHash)veh.Model.Hash == VehicleHash.Insurgent;
+            }
+
+            return false;
+        }
+        public static bool IsOnTurretSeat(this Ped P)
+        {
+            if (P.CurrentVehicle == null) { return false; }
+            return IsTurretSeat(P.CurrentVehicle, (int)P.SeatIndex);
+        }
+
+
+
+
+    }
+}

Client/Scripts/Util/TaskType.cs

@@ -0,0 +1,438 @@
+// WARNING: values can change after a game update
+// if R* adds in the middle!
+// This is up-to-date for b2372
+internal enum TaskType
+{
+    CTaskHandsUp = 0,
+    CTaskClimbLadder = 1,
+    CTaskExitVehicle = 2,
+    CTaskCombatRoll = 3,
+    CTaskAimGunOnFoot = 4,
+    CTaskMovePlayer = 5,
+    CTaskPlayerOnFoot = 6,
+    CTaskWeapon = 8,
+    CTaskPlayerWeapon = 9,
+    CTaskPlayerIdles = 10,
+    CTaskAimGun = 12,
+    CTaskComplex = 12,
+    CTaskFSMClone = 12,
+    CTaskMotionBase = 12,
+    CTaskMove = 12,
+    CTaskMoveBase = 12,
+    CTaskNMBehaviour = 12,
+    CTaskNavBase = 12,
+    CTaskScenario = 12,
+    CTaskSearchBase = 12,
+    CTaskSearchInVehicleBase = 12,
+    CTaskShockingEvent = 12,
+    CTaskTrainBase = 12,
+    CTaskVehicleFSM = 12,
+    CTaskVehicleGoTo = 12,
+    CTaskVehicleMissionBase = 12,
+    CTaskVehicleTempAction = 12,
+    CTaskPause = 14,
+    CTaskDoNothing = 15,
+    CTaskGetUp = 16,
+    CTaskGetUpAndStandStill = 17,
+    CTaskFallOver = 18,
+    CTaskFallAndGetUp = 19,
+    CTaskCrawl = 20,
+    CTaskComplexOnFire = 25,
+    CTaskDamageElectric = 26,
+    CTaskTriggerLookAt = 28,
+    CTaskClearLookAt = 29,
+    CTaskSetCharDecisionMaker = 30,
+    CTaskSetPedDefensiveArea = 31,
+    CTaskUseSequence = 32,
+    CTaskMoveStandStill = 34,
+    CTaskComplexControlMovement = 35,
+    CTaskMoveSequence = 36,
+    CTaskAmbientClips = 38,
+    CTaskMoveInAir = 39,
+    CTaskNetworkClone = 40,
+    CTaskUseClimbOnRoute = 41,
+    CTaskUseDropDownOnRoute = 42,
+    CTaskUseLadderOnRoute = 43,
+    CTaskSetBlockingOfNonTemporaryEvents = 44,
+    CTaskForceMotionState = 45,
+    CTaskSlopeScramble = 46,
+    CTaskGoToAndClimbLadder = 47,
+    CTaskClimbLadderFully = 48,
+    CTaskRappel = 49,
+    CTaskVault = 50,
+    CTaskDropDown = 51,
+    CTaskAffectSecondaryBehaviour = 52,
+    CTaskAmbientLookAtEvent = 53,
+    CTaskOpenDoor = 54,
+    CTaskShovePed = 55,
+    CTaskSwapWeapon = 56,
+    CTaskGeneralSweep = 57,
+    CTaskPolice = 58,
+    CTaskPoliceOrderResponse = 59,
+    CTaskPursueCriminal = 60,
+    CTaskArrestPed = 62,
+    CTaskArrestPed2 = 63,
+    CTaskBusted = 64,
+    CTaskFirePatrol = 65,
+    CTaskHeliOrderResponse = 66,
+    CTaskHeliPassengerRappel = 67,
+    CTaskAmbulancePatrol = 68,
+    CTaskPoliceWantedResponse = 69,
+    CTaskSwat = 70,
+    CTaskSwatWantedResponse = 72,
+    CTaskSwatOrderResponse = 73,
+    CTaskSwatGoToStagingArea = 74,
+    CTaskSwatFollowInLine = 75,
+    CTaskWitness = 76,
+    CTaskGangPatrol = 77,
+    CTaskArmy = 78,
+    CTaskShockingEventWatch = 80,
+    CTaskShockingEventGoto = 82,
+    CTaskShockingEventHurryAway = 83,
+    CTaskShockingEventReactToAircraft = 84,
+    CTaskShockingEventReact = 85,
+    CTaskShockingEventBackAway = 86,
+    CTaskShockingPoliceInvestigate = 87,
+    CTaskShockingEventStopAndStare = 88,
+    CTaskShockingNiceCarPicture = 89,
+    CTaskShockingEventThreatResponse = 90,
+    CTaskTakeOffHelmet = 92,
+    CTaskCarReactToVehicleCollision = 93,
+    CTaskCarReactToVehicleCollisionGetOut = 95,
+    CTaskDyingDead = 97,
+    CTaskWanderingScenario = 100,
+    CTaskWanderingInRadiusScenario = 101,
+    CTaskMoveBetweenPointsScenario = 103,
+    CTaskChatScenario = 104,
+    CTaskCowerScenario = 106,
+    CTaskDeadBodyScenario = 107,
+    CTaskSayAudio = 114,
+    CTaskWaitForSteppingOut = 116,
+    CTaskCoupleScenario = 117,
+    CTaskUseScenario = 118,
+    CTaskUseVehicleScenario = 119,
+    CTaskUnalerted = 120,
+    CTaskStealVehicle = 121,
+    CTaskReactToPursuit = 122,
+    CTaskHitWall = 125,
+    CTaskCower = 126,
+    CTaskCrouch = 127,
+    CTaskMelee = 128,
+    CTaskMoveMeleeMovement = 129,
+    CTaskMeleeActionResult = 130,
+    CTaskMeleeUpperbodyAnims = 131,
+    CTaskMoVEScripted = 133,
+    CTaskScriptedAnimation = 134,
+    CTaskSynchronizedScene = 135,
+    CTaskComplexEvasiveStep = 137,
+    CTaskWalkRoundCarWhileWandering = 138,
+    CTaskComplexStuckInAir = 140,
+    CTaskWalkRoundEntity = 141,
+    CTaskMoveWalkRoundVehicle = 142,
+    CTaskReactToGunAimedAt = 144,
+    CTaskDuckAndCover = 146,
+    CTaskAggressiveRubberneck = 147,
+    CTaskInVehicleBasic = 150,
+    CTaskCarDriveWander = 151,
+    CTaskLeaveAnyCar = 152,
+    CTaskComplexGetOffBoat = 153,
+    CTaskCarSetTempAction = 155,
+    CTaskBringVehicleToHalt = 156,
+    CTaskCarDrive = 157,
+    CTaskPlayerDrive = 159,
+    CTaskEnterVehicle = 160,
+    CTaskEnterVehicleAlign = 161,
+    CTaskOpenVehicleDoorFromOutside = 162,
+    CTaskEnterVehicleSeat = 163,
+    CTaskCloseVehicleDoorFromInside = 164,
+    CTaskInVehicleSeatShuffle = 165,
+    CTaskExitVehicleSeat = 167,
+    CTaskCloseVehicleDoorFromOutside = 168,
+    CTaskControlVehicle = 169,
+    CTaskMotionInAutomobile = 170,
+    CTaskMotionOnBicycle = 171,
+    CTaskMotionOnBicycleController = 172,
+    CTaskMotionInVehicle = 173,
+    CTaskMotionInTurret = 174,
+    CTaskReactToBeingJacked = 175,
+    CTaskReactToBeingAskedToLeaveVehicle = 176,
+    CTaskTryToGrabVehicleDoor = 177,
+    CTaskGetOnTrain = 178,
+    CTaskGetOffTrain = 179,
+    CTaskRideTrain = 180,
+    CTaskMountThrowProjectile = 190,
+    CTaskGoToCarDoorAndStandStill = 195,
+    CTaskMoveGoToVehicleDoor = 196,
+    CTaskSetPedInVehicle = 197,
+    CTaskSetPedOutOfVehicle = 198,
+    CTaskVehicleMountedWeapon = 199,
+    CTaskVehicleGun = 200,
+    CTaskVehicleProjectile = 201,
+    CTaskSmashCarWindow = 204,
+    CTaskMoveGoToPoint = 205,
+    CTaskMoveAchieveHeading = 206,
+    CTaskMoveFaceTarget = 207,
+    CTaskComplexGoToPointAndStandStillTimed = 208,
+    CTaskMoveGoToPointAndStandStill = 208,
+    CTaskMoveFollowPointRoute = 209,
+    CTaskMoveSeekEntity_CEntitySeekPosCalculatorStandard = 210,
+    CTaskMoveSeekEntity_CEntitySeekPosCalculatorLastNavMeshIntersection = 211,
+    CTaskMoveSeekEntity_CEntitySeekPosCalculatorLastNavMeshIntersection2 = 212,
+    CTaskMoveSeekEntity_CEntitySeekPosCalculatorXYOffsetFixed = 213,
+    CTaskMoveSeekEntity_CEntitySeekPosCalculatorXYOffsetFixed2 = 214,
+    CTaskExhaustedFlee = 215,
+    CTaskGrowlAndFlee = 216,
+    CTaskScenarioFlee = 217,
+    CTaskSmartFlee = 218,
+    CTaskFlyAway = 219,
+    CTaskWalkAway = 220,
+    CTaskWander = 221,
+    CTaskWanderInArea = 222,
+    CTaskFollowLeaderInFormation = 223,
+    CTaskGoToPointAnyMeans = 224,
+    CTaskTurnToFaceEntityOrCoord = 225,
+    CTaskFollowLeaderAnyMeans = 226,
+    CTaskFlyToPoint = 228,
+    CTaskFlyingWander = 229,
+    CTaskGoToPointAiming = 230,
+    CTaskGoToScenario = 231,
+    CTaskSeekEntityAiming = 233,
+    CTaskSlideToCoord = 234,
+    CTaskSwimmingWander = 235,
+    CTaskMoveTrackingEntity = 237,
+    CTaskMoveFollowNavMesh = 238,
+    CTaskMoveGoToPointOnRoute = 239,
+    CTaskEscapeBlast = 240,
+    CTaskMoveWander = 241,
+    CTaskMoveBeInFormation = 242,
+    CTaskMoveCrowdAroundLocation = 243,
+    CTaskMoveCrossRoadAtTrafficLights = 244,
+    CTaskMoveWaitForTraffic = 245,
+    CTaskMoveGoToPointStandStillAchieveHeading = 246,
+    CTaskMoveGetOntoMainNavMesh = 251,
+    CTaskMoveSlideToCoord = 252,
+    CTaskMoveGoToPointRelativeToEntityAndStandStill = 253,
+    CTaskHelicopterStrafe = 254,
+    CTaskGetOutOfWater = 256,
+    CTaskMoveFollowEntityOffset = 259,
+    CTaskFollowWaypointRecording = 261,
+    CTaskMotionPed = 264,
+    CTaskMotionPedLowLod = 265,
+    CTaskHumanLocomotion = 268,
+    CTaskMotionBasicLocomotionLowLod = 269,
+    CTaskMotionStrafing = 270,
+    CTaskMotionTennis = 271,
+    CTaskMotionAiming = 272,
+    CTaskBirdLocomotion = 273,
+    CTaskFlightlessBirdLocomotion = 274,
+    CTaskFishLocomotion = 278,
+    CTaskQuadLocomotion = 279,
+    CTaskMotionDiving = 280,
+    CTaskMotionSwimming = 281,
+    CTaskMotionParachuting = 282,
+    CTaskMotionDrunk = 283,
+    CTaskRepositionMove = 284,
+    CTaskMotionAimingTransition = 285,
+    CTaskThrowProjectile = 286,
+    CTaskCover = 287,
+    CTaskMotionInCover = 288,
+    CTaskAimAndThrowProjectile = 289,
+    CTaskGun = 290,
+    CTaskAimFromGround = 291,
+    CTaskAimGunVehicleDriveBy = 295,
+    CTaskAimGunScripted = 296,
+    CTaskReloadGun = 298,
+    CTaskWeaponBlocked = 299,
+    CTaskEnterCover = 300,
+    CTaskExitCover = 301,
+    CTaskAimGunFromCoverIntro = 302,
+    CTaskAimGunFromCoverOutro = 303,
+    CTaskAimGunBlindFire = 304,
+    CTaskCombatClosestTargetInArea = 307,
+    CTaskCombatAdditionalTask = 308,
+    CTaskInCover = 309,
+    CTaskAimSweep = 313,
+    CTaskSharkCircle = 319,
+    CTaskSharkAttack = 320,
+    CTaskAgitated = 321,
+    CTaskAgitatedAction = 322,
+    CTaskConfront = 323,
+    CTaskIntimidate = 324,
+    CTaskShove = 325,
+    CTaskShoved = 326,
+    CTaskCrouchToggle = 328,
+    CTaskRevive = 329,
+    CTaskParachute = 335,
+    CTaskParachuteObject = 336,
+    CTaskTakeOffPedVariation = 337,
+    CTaskCombatSeekCover = 340,
+    CTaskCombatFlank = 342,
+    CTaskCombat = 343,
+    CTaskCombatMounted = 344,
+    CTaskMoveCircle = 345,
+    CTaskMoveCombatMounted = 346,
+    CTaskSearch = 347,
+    CTaskSearchOnFoot = 348,
+    CTaskSearchInAutomobile = 349,
+    CTaskSearchInBoat = 350,
+    CTaskSearchInHeli = 351,
+    CTaskThreatResponse = 352,
+    CTaskInvestigate = 353,
+    CTaskStandGuardFSM = 354,
+    CTaskPatrol = 355,
+    CTaskShootAtTarget = 356,
+    CTaskSetAndGuardArea = 357,
+    CTaskStandGuard = 358,
+    CTaskSeparate = 359,
+    CTaskStayInCover = 360,
+    CTaskVehicleCombat = 361,
+    CTaskVehiclePersuit = 362,
+    CTaskVehicleChase = 363,
+    CTaskDraggingToSafety = 364,
+    CTaskDraggedToSafety = 365,
+    CTaskVariedAimPose = 366,
+    CTaskMoveWithinAttackWindow = 367,
+    CTaskMoveWithinDefensiveArea = 368,
+    CTaskShootOutTire = 369,
+    CTaskShellShocked = 370,
+    CTaskBoatChase = 371,
+    CTaskBoatCombat = 372,
+    CTaskBoatStrafe = 373,
+    CTaskHeliChase = 374,
+    CTaskHeliCombat = 375,
+    CTaskSubmarineCombat = 376,
+    CTaskSubmarineChase = 377,
+    CTaskPlaneChase = 378,
+    CTaskTargetUnreachable = 379,
+    CTaskTargetUnreachableInInterior = 380,
+    CTaskTargetUnreachableInExterior = 381,
+    CTaskStealthKill = 382,
+    CTaskWrithe = 383,
+    CTaskAdvance = 384,
+    CTaskCharge = 385,
+    CTaskMoveToTacticalPoint = 386,
+    CTaskToHurtTransit = 387,
+    CTaskAnimatedHitByExplosion = 388,
+    CTaskNMRelax = 389,
+    CTaskNMPose = 391,
+    CTaskNMBrace = 392,
+    CTaskNMBuoyancy = 393,
+    CTaskNMInjuredOnGround = 394,
+    CTaskNMShot = 395,
+    CTaskNMHighFall = 396,
+    CTaskNMBalance = 397,
+    CTaskNMElectrocute = 398,
+    CTaskNMPrototype = 399,
+    CTaskNMExplosion = 400,
+    CTaskNMOnFire = 401,
+    CTaskNMScriptControl = 402,
+    CTaskNMJumpRollFromRoadVehicle = 403,
+    CTaskNMFlinch = 404,
+    CTaskNMSit = 405,
+    CTaskNMFallDown = 406,
+    CTaskBlendFromNM = 407,
+    CTaskNMControl = 408,
+    CTaskNMDangle = 409,
+    CTaskNMGenericAttach = 412,
+    CTaskNMDraggingToSafety = 414,
+    CTaskNMThroughWindscreen = 415,
+    CTaskNMRiverRapids = 416,
+    CTaskNMSimple = 417,
+    CTaskRageRagdoll = 418,
+    CTaskJumpVault = 421,
+    CTaskJump = 422,
+    CTaskFall = 423,
+    CTaskReactAimWeapon = 425,
+    CTaskChat = 426,
+    CTaskMobilePhone = 427,
+    CTaskReactToDeadPed = 428,
+    CTaskSearchForUnknownThreat = 430,
+    CTaskBomb = 432,
+    CTaskDetonator = 433,
+    CTaskAnimatedAttach = 435,
+    CTaskCutScene = 441,
+    CTaskReactToExplosion = 442,
+    CTaskReactToImminentExplosion = 443,
+    CTaskDiveToGround = 444,
+    CTaskReactAndFlee = 445,
+    CTaskSidestep = 446,
+    CTaskCallPolice = 447,
+    CTaskReactInDirection = 448,
+    CTaskReactToBuddyShot = 449,
+    CTaskVehicleGoToAutomobileNew = 454,
+    CTaskVehicleGoToPlane = 455,
+    CTaskVehicleGoToHelicopter = 456,
+    CTaskVehicleGoToSubmarine = 457,
+    CTaskVehicleGoToBoat = 458,
+    CTaskVehicleGoToPointAutomobile = 459,
+    CTaskVehicleGoToPointWithAvoidanceAutomobile = 460,
+    CTaskVehiclePursue = 461,
+    CTaskVehicleRam = 462,
+    CTaskVehicleSpinOut = 463,
+    CTaskVehicleApproach = 464,
+    CTaskVehicleThreePointTurn = 465,
+    CTaskVehicleDeadDriver = 466,
+    CTaskVehicleCruiseNew = 467,
+    CTaskVehicleCruiseBoat = 468,
+    CTaskVehicleStop = 469,
+    CTaskVehiclePullOver = 470,
+    CTaskVehiclePassengerExit = 471,
+    CTaskVehicleFlee = 472,
+    CTaskVehicleFleeAirborne = 473,
+    CTaskVehicleFleeBoat = 474,
+    CTaskVehicleFollowRecording = 475,
+    CTaskVehicleFollow = 476,
+    CTaskVehicleBlock = 477,
+    CTaskVehicleBlockCruiseInFront = 478,
+    CTaskVehicleBlockBrakeInFront = 479,
+    CTaskVehicleBlockBackAndForth = 478,
+    CTaskVehicleCrash = 481,
+    CTaskVehicleLand = 482,
+    CTaskVehicleLandPlane = 483,
+    CTaskVehicleHover = 484,
+    CTaskVehicleAttack = 485,
+    CTaskVehicleAttackTank = 486,
+    CTaskVehicleCircle = 487,
+    CTaskVehiclePoliceBehaviour = 488,
+    CTaskVehiclePoliceBehaviourHelicopter = 489,
+    CTaskVehiclePoliceBehaviourBoat = 490,
+    CTaskVehicleEscort = 491,
+    CTaskVehicleHeliProtect = 492,
+    CTaskVehiclePlayerDriveAutomobile = 494,
+    CTaskVehiclePlayerDriveBike = 495,
+    CTaskVehiclePlayerDriveBoat = 496,
+    CTaskVehiclePlayerDriveSubmarine = 497,
+    CTaskVehiclePlayerDriveSubmarineCar = 498,
+    CTaskVehiclePlayerDriveAmphibiousAutomobile = 499,
+    CTaskVehiclePlayerDrivePlane = 500,
+    CTaskVehiclePlayerDriveHeli = 501,
+    CTaskVehiclePlayerDriveAutogyro = 502,
+    CTaskVehiclePlayerDriveDiggerArm = 503,
+    CTaskVehiclePlayerDriveTrain = 504,
+    CTaskVehiclePlaneChase = 505,
+    CTaskVehicleNoDriver = 506,
+    CTaskVehicleAnimation = 507,
+    CTaskVehicleConvertibleRoof = 508,
+    CTaskVehicleParkNew = 509,
+    CTaskVehicleFollowWaypointRecording = 510,
+    CTaskVehicleGoToNavmesh = 511,
+    CTaskVehicleReactToCopSiren = 512,
+    CTaskVehicleGotoLongRange = 513,
+    CTaskVehicleWait = 514,
+    CTaskVehicleReverse = 515,
+    CTaskVehicleBrake = 516,
+    CTaskVehicleHandBrake = 517,
+    CTaskVehicleTurn = 518,
+    CTaskVehicleGoForward = 519,
+    CTaskVehicleSwerve = 520,
+    CTaskVehicleFlyDirection = 521,
+    CTaskVehicleHeadonCollision = 522,
+    CTaskVehicleBoostUseSteeringAngle = 523,
+    CTaskVehicleShotTire = 524,
+    CTaskVehicleBurnout = 525,
+    CTaskVehicleRevEngine = 526,
+    CTaskVehicleSurfaceInSubmarine = 527,
+    CTaskVehiclePullAlongside = 528,
+    CTaskVehicleTransformToSubmarine = 529,
+    CTaskAnimatedFallback = 530
+};

Client/Scripts/Util/Util.cs

@@ -0,0 +1,268 @@
+using GTA;
+using Console = GTA.Console;
+using GTA.Math;
+using GTA.Native;
+using RageCoop.Core;
+using System;
+using System.Collections.Generic;
+using System.Drawing;
+using System.IO;
+using System.Linq;
+using System.Runtime.CompilerServices;
+using System.Runtime.InteropServices;
+using System.Windows.Forms;
+using System.Xml.Serialization;
+using Newtonsoft.Json;
+using SHVDN;
+
+[assembly: InternalsVisibleTo("RageCoop.Client.Installer")]
+namespace RageCoop.Client
+{
+    internal static class Util
+    {
+        public static SizeF ResolutionMaintainRatio
+        {
+            get
+            {
+                // Get the game width and height
+                int screenw = GTA.UI.Screen.Resolution.Width;
+                int screenh = GTA.UI.Screen.Resolution.Height;
+                // Calculate the ratio
+                float ratio = (float)screenw / screenh;
+                // And the width with that ratio
+                float width = 1080f * ratio;
+                // Finally, return a SizeF
+                return new SizeF(width, 1080f);
+            }
+        }
+        public static bool WorldToScreen(Vector3 pos, ref Point screenPos)
+        {
+            float x, y;
+            unsafe
+            {
+                var res = ResolutionMaintainRatio;
+                if (Function.Call<bool>(Hash.GET_SCREEN_COORD_FROM_WORLD_COORD, pos.X, pos.Y, pos.Z, &x, &y))
+                {
+                    screenPos = new Point((int)(res.Width * x), (int)(y * 1080));
+                    return true;
+                }
+            }
+            return false;
+        }
+
+
+        #region -- POINTER --
+        private static int _steeringAngleOffset { get; set; }
+
+        public static unsafe void NativeMemory()
+        {
+            IntPtr address;
+
+            address = Game.FindPattern("\x74\x0A\xF3\x0F\x11\xB3\x1C\x09\x00\x00\xEB\x25", "xxxxxx????xx");
+            if (address != IntPtr.Zero)
+            {
+                _steeringAngleOffset = *(int*)(address + 6) + 8;
+            }
+
+        }
+
+        public static unsafe void CustomSteeringAngle(this Vehicle veh, float value)
+        {
+            IntPtr address = new IntPtr((long)veh.MemoryAddress);
+            if (address == IntPtr.Zero || _steeringAngleOffset == 0)
+            {
+                return;
+            }
+
+            *(float*)(address + _steeringAngleOffset).ToPointer() = value;
+        }
+        #endregion
+        #region MATH
+        public static Vector3 LinearVectorLerp(Vector3 start, Vector3 end, ulong currentTime, int duration)
+        {
+            return new Vector3()
+            {
+                X = LinearFloatLerp(start.X, end.X, currentTime, duration),
+                Y = LinearFloatLerp(start.Y, end.Y, currentTime, duration),
+                Z = LinearFloatLerp(start.Z, end.Z, currentTime, duration),
+            };
+        }
+
+        public static float LinearFloatLerp(float start, float end, ulong currentTime, int duration)
+        {
+            return (end - start) * currentTime / duration + start;
+        }
+
+        public static float Lerp(float from, float to, float fAlpha)
+        {
+            return (from * (1.0f - fAlpha)) + (to * fAlpha); //from + (to - from) * fAlpha
+        }
+
+        public static Vector3 RotationToDirection(Vector3 rotation)
+        {
+            double z = MathExtensions.DegToRad(rotation.Z);
+            double x = MathExtensions.DegToRad(rotation.X);
+            double num = Math.Abs(Math.Cos(x));
+
+            return new Vector3
+            {
+                X = (float)(-Math.Sin(z) * num),
+                Y = (float)(Math.Cos(z) * num),
+                Z = (float)Math.Sin(x)
+            };
+        }
+
+
+        #endregion
+        public static string SettingsPath = "RageCoop\\Settings.json";
+        public static Settings ReadSettings(string path = null)
+        {
+            path = path ?? SettingsPath;
+
+            Directory.CreateDirectory(Directory.GetParent(path).FullName);
+            Settings settings;
+            try
+            {
+                settings = JsonConvert.DeserializeObject<Settings>(File.ReadAllText(path));
+            }
+            catch (Exception ex)
+            {
+                Main.Logger?.Error(ex);
+                File.WriteAllText(path, JsonConvert.SerializeObject(settings = new Settings(), Formatting.Indented));
+            }
+
+            return settings;
+        }
+        public static bool SaveSettings(string path = null, Settings settings = null)
+        {
+            try
+            {
+                path = path ?? SettingsPath;
+                settings = settings ?? Main.Settings;
+                Directory.CreateDirectory(Directory.GetParent(path).FullName);
+
+                File.WriteAllText(path, JsonConvert.SerializeObject(settings, Formatting.Indented));
+                return true;
+            }
+            catch (Exception ex)
+            {
+                Main.Logger?.Error(ex);
+                return false;
+            }
+        }
+
+
+        public static Vehicle CreateVehicle(Model model, Vector3 position, float heading = 0f)
+        {
+            if (!model.IsLoaded) { return null; }
+            return (Vehicle)Entity.FromHandle(Function.Call<int>(Hash.CREATE_VEHICLE, model.Hash, position.X, position.Y, position.Z, heading, false, false));
+        }
+        public static Ped CreatePed(Model model, Vector3 position, float heading = 0f)
+        {
+            if (!model.IsLoaded) { return null; }
+            return (Ped)Entity.FromHandle(Function.Call<int>(Hash.CREATE_PED, 26, model.Hash, position.X, position.Y, position.Z, heading, false, false));
+        }
+        public static void SetOnFire(this Entity e, bool toggle)
+        {
+            if (toggle)
+            {
+                Function.Call(Hash.START_ENTITY_FIRE, e.Handle);
+            }
+            else
+            {
+                Function.Call(Hash.STOP_ENTITY_FIRE, e.Handle);
+            }
+        }
+        public static void SetFrozen(this Entity e, bool toggle)
+        {
+            Function.Call(Hash.FREEZE_ENTITY_POSITION, e, toggle);
+        }
+
+        public static SyncedPed GetSyncEntity(this Ped p)
+        {
+            if (p == null) { return null; }
+            var c = EntityPool.GetPedByHandle(p.Handle);
+            if (c == null) { EntityPool.Add(c = new SyncedPed(p)); }
+            return c;
+        }
+
+        public static SyncedVehicle GetSyncEntity(this Vehicle veh)
+        {
+            if (veh == null) { return null; }
+            var v = EntityPool.GetVehicleByHandle(veh.Handle);
+            if (v == null) { EntityPool.Add(v = new SyncedVehicle(veh)); }
+            return v;
+        }
+
+        public static void ApplyForce(this Entity e, int boneIndex, Vector3 direction, Vector3 rotation = default(Vector3), ForceType forceType = ForceType.MaxForceRot2)
+        {
+            Function.Call(Hash.APPLY_FORCE_TO_ENTITY, e.Handle, forceType, direction.X, direction.Y, direction.Z, rotation.X, rotation.Y, rotation.Z, boneIndex, false, true, true, false, true);
+        }
+        public static byte GetPlayerRadioIndex()
+        {
+            return (byte)Function.Call<int>(Hash.GET_PLAYER_RADIO_STATION_INDEX);
+        }
+        public static void SetPlayerRadioIndex(int index)
+        {
+            Function.Call(Hash.SET_RADIO_TO_STATION_INDEX, index);
+        }
+
+        #region WIN32
+
+        private const UInt32 WM_KEYDOWN = 0x0100;
+        public static void Reload()
+        {
+            string reloadKey = "None";
+            var lines = File.ReadAllLines("ScriptHookVDotNet.ini");
+            foreach (var l in lines)
+            {
+                var ss = l.Split('=');
+                if (ss.Length > 0 && ss[0] == "ReloadKey")
+                {
+                    reloadKey = ss[1];
+                }
+            }
+            var lineList = lines.ToList();
+            if (reloadKey == "None")
+            {
+                foreach (var l in lines)
+                {
+                    var ss = l.Split('=');
+                    if (ss.Length > 0 && ss[0] == "ReloadKey")
+                    {
+                        reloadKey = ss[1];
+                        lineList.Remove(l);
+                    }
+                }
+                lineList.Add("ReloadKey=Insert");
+                File.WriteAllLines("ScriptHookVDotNet.ini", lineList.ToArray());
+                GTA.UI.Notification.Show("Reload cannot be performed automatically, please type \"Reload()\" manually in the SHVDN console.");
+            }
+            Keys key = (Keys)Enum.Parse(typeof(Keys), reloadKey, true);
+
+            // Move log file so it doesn't get deleted 
+            Main.Logger.Dispose();
+
+            var path = Main.LogPath + ".last.log";
+            try
+            {
+                if (File.Exists(path)) { File.Delete(path); }
+                if (File.Exists(Main.LogPath)) { File.Move(Main.LogPath, path); }
+            }
+            catch (Exception ex)
+            {
+                GTA.UI.Notification.Show(ex.Message);
+            }
+
+            PostMessage(System.Diagnostics.Process.GetCurrentProcess().MainWindowHandle, WM_KEYDOWN, (int)key, 0);
+        }
+
+        [DllImport("user32.dll")]
+        private static extern bool PostMessage(IntPtr hWnd, UInt32 Msg, int wParam, int lParam);
+
+
+        [DllImport("kernel32.dll")]
+        public static extern ulong GetTickCount64();
+        #endregion
+    }
+}

Client/Scripts/Util/VehicleExtensions.cs

@@ -0,0 +1,293 @@
+using GTA;
+using GTA.Native;
+using RageCoop.Core;
+using System;
+using System.Collections.Generic;
+
+namespace RageCoop.Client
+{
+    internal static class VehicleExtensions
+    {
+        #region VEHICLE
+
+        public static VehicleDataFlags GetVehicleFlags(this SyncedVehicle v)
+        {
+            var veh = v.MainVehicle;
+            VehicleDataFlags flags = 0;
+
+            if (veh.IsEngineRunning)
+            {
+                flags |= VehicleDataFlags.IsEngineRunning;
+            }
+
+            if (veh.AreLightsOn)
+            {
+                flags |= VehicleDataFlags.AreLightsOn;
+            }
+
+            if (veh.BrakePower >= 0.01f)
+            {
+                flags |= VehicleDataFlags.AreBrakeLightsOn;
+            }
+
+            if (veh.AreHighBeamsOn)
+            {
+                flags |= VehicleDataFlags.AreHighBeamsOn;
+            }
+
+            if (veh.IsSirenActive)
+            {
+                flags |= VehicleDataFlags.IsSirenActive;
+            }
+
+            if (veh.IsDead)
+            {
+                flags |= VehicleDataFlags.IsDead;
+            }
+
+            if (Function.Call<bool>(Hash.IS_HORN_ACTIVE, veh.Handle))
+            {
+                flags |= VehicleDataFlags.IsHornActive;
+            }
+
+            if (v.IsSubmarineCar && Function.Call<bool>(Hash._GET_IS_SUBMARINE_VEHICLE_TRANSFORMED, veh.Handle))
+            {
+                flags |= VehicleDataFlags.IsTransformed;
+            }
+
+            if (v.IsAircraft)
+            {
+                flags |= VehicleDataFlags.IsAircraft;
+            }
+
+            if (v.IsDeluxo && veh.IsDeluxoHovering())
+            {
+                flags |= VehicleDataFlags.IsDeluxoHovering;
+            }
+
+            if (v.HasRoof)
+            {
+                flags |= VehicleDataFlags.HasRoof;
+            }
+
+            if (v.HasRocketBoost && veh.IsRocketBoostActive())
+            {
+                flags |= VehicleDataFlags.IsRocketBoostActive;
+            }
+
+            if (v.HasParachute && veh.IsParachuteActive())
+            {
+                flags |= VehicleDataFlags.IsParachuteActive;
+            }
+
+            if (veh.IsOnFire)
+            {
+                flags |= VehicleDataFlags.IsOnFire;
+            }
+
+            return flags;
+        }
+        public static bool IsRocketBoostActive(this Vehicle veh)
+        {
+            return Function.Call<bool>(Hash._IS_VEHICLE_ROCKET_BOOST_ACTIVE, veh);
+        }
+        public static bool IsParachuteActive(this Vehicle veh)
+        {
+            return Function.Call<bool>((Hash)0x3DE51E9C80B116CF, veh);
+        }
+        public static void SetRocketBoostActive(this Vehicle veh, bool toggle)
+        {
+            Function.Call(Hash._SET_VEHICLE_ROCKET_BOOST_ACTIVE, veh, toggle);
+        }
+        public static void SetParachuteActive(this Vehicle veh, bool toggle)
+        {
+            Function.Call((Hash)0x0BFFB028B3DD0A97, veh, toggle);
+        }
+        public static Dictionary<int, int> GetVehicleMods(this VehicleModCollection mods)
+        {
+            Dictionary<int, int> result = new Dictionary<int, int>();
+            foreach (VehicleMod mod in mods.ToArray())
+            {
+                result.Add((int)mod.Type, mod.Index);
+            }
+            return result;
+        }
+
+        public static VehicleDamageModel GetVehicleDamageModel(this Vehicle veh)
+        {
+            // Broken windows
+            byte brokenWindows = 0;
+            for (int i = 0; i < 8; i++)
+            {
+                if (!veh.Windows[(VehicleWindowIndex)i].IsIntact)
+                {
+                    brokenWindows |= (byte)(1 << i);
+                }
+            }
+
+            // Broken doors
+            byte brokenDoors = 0;
+            byte openedDoors = 0;
+            foreach (VehicleDoor door in veh.Doors)
+            {
+                if (door.IsBroken)
+                {
+                    brokenDoors |= (byte)(1 << (byte)door.Index);
+                }
+                else if (door.IsOpen)
+                {
+                    openedDoors |= (byte)(1 << (byte)door.Index);
+                }
+            }
+
+            // Bursted tires
+            short burstedTires = 0;
+            foreach (VehicleWheel wheel in veh.Wheels.GetAllWheels())
+            {
+                if (wheel.IsBursted)
+                {
+                    burstedTires |= (short)(1 << (int)wheel.BoneId);
+                }
+            }
+
+            return new VehicleDamageModel()
+            {
+                BrokenDoors = brokenDoors,
+                OpenedDoors = openedDoors,
+                BrokenWindows = brokenWindows,
+                BurstedTires = burstedTires,
+                LeftHeadLightBroken = (byte)(veh.IsLeftHeadLightBroken ? 1 : 0),
+                RightHeadLightBroken = (byte)(veh.IsRightHeadLightBroken ? 1 : 0)
+            };
+        }
+
+        public static void SetDamageModel(this Vehicle veh, VehicleDamageModel model, bool leavedoors = true)
+        {
+            for (int i = 0; i < 8; i++)
+            {
+                var door = veh.Doors[(VehicleDoorIndex)i];
+                if ((model.BrokenDoors & (byte)(1 << i)) != 0)
+                {
+                    if (!door.IsBroken)
+                    {
+                        door.Break(leavedoors);
+                    }
+                    continue;
+                }
+                else if (door.IsBroken)
+                {
+                    // The vehicle can only fix a door if the vehicle was completely fixed
+                    veh.Repair();
+                    return;
+                }
+                if ((model.OpenedDoors & (byte)(1 << i)) != 0)
+                {
+                    if ((!door.IsOpen) && (!door.IsBroken))
+                    {
+                        door.Open();
+                    }
+                }
+                else if (door.IsOpen)
+                {
+                    if (!door.IsBroken) { door.Close(); }
+                }
+
+                if ((model.BrokenWindows & (byte)(1 << i)) != 0)
+                {
+                    veh.Windows[(VehicleWindowIndex)i].Smash();
+                }
+                else if (!veh.Windows[(VehicleWindowIndex)i].IsIntact)
+                {
+                    veh.Windows[(VehicleWindowIndex)i].Repair();
+                }
+            }
+
+            foreach (VehicleWheel wheel in veh.Wheels)
+            {
+                if ((model.BurstedTires & (short)(1 << (int)wheel.BoneId)) != 0)
+                {
+                    if (!wheel.IsBursted)
+                    {
+                        wheel.Puncture();
+                        wheel.Burst();
+                    }
+                }
+                else if (wheel.IsBursted)
+                {
+                    wheel.Fix();
+                }
+            }
+
+            veh.IsLeftHeadLightBroken = model.LeftHeadLightBroken > 0;
+            veh.IsRightHeadLightBroken = model.RightHeadLightBroken > 0;
+        }
+
+        public static Dictionary<int, int> GetPassengers(this Vehicle veh)
+        {
+            Dictionary<int, int> ps = new Dictionary<int, int>();
+            var d = veh.Driver;
+            if (d != null && d.IsSittingInVehicle())
+            {
+                ps.Add(-1, d.GetSyncEntity().ID);
+            }
+            foreach (Ped p in veh.Passengers)
+            {
+                if (p.IsSittingInVehicle())
+                {
+                    ps.Add((int)p.SeatIndex, p.GetSyncEntity().ID);
+                }
+            }
+            return ps;
+        }
+
+        public static void SetDeluxoHoverState(this Vehicle deluxo, bool hover)
+        {
+            Function.Call(Hash._SET_VEHICLE_HOVER_TRANSFORM_PERCENTAGE, deluxo, hover ? 1f : 0f);
+        }
+        public static bool IsDeluxoHovering(this Vehicle deluxo)
+        {
+            return Math.Abs(deluxo.Bones[27].ForwardVector.GetCosTheta(deluxo.ForwardVector) - 1) > 0.05;
+        }
+        public static void SetDeluxoWingRatio(this Vehicle v, float ratio)
+        {
+            Function.Call(Hash._SET_SPECIALFLIGHT_WING_RATIO, v, ratio);
+        }
+        public static float GetDeluxoWingRatio(this Vehicle v)
+        {
+            return v.Bones[99].Position.DistanceTo(v.Bones[92].Position) - 1.43f;
+        }
+        public static float GetNozzleAngel(this Vehicle plane)
+        {
+            return Function.Call<float>(Hash._GET_VEHICLE_FLIGHT_NOZZLE_POSITION, plane);
+        }
+        public static bool HasNozzle(this Vehicle v)
+        {
+
+            switch (v.Model.Hash)
+            {
+                // Hydra
+                case 970385471:
+                    return true;
+
+                // Avenger
+                case -2118308144:
+                    return true;
+
+                // Tula
+                case 1043222410:
+                    return true;
+
+                // Avenger
+                case 408970549:
+                    return true;
+
+            }
+            return false;
+        }
+        public static void SetNozzleAngel(this Vehicle plane, float ratio)
+        {
+            Function.Call(Hash.SET_VEHICLE_FLIGHT_NOZZLE_POSITION, plane, ratio);
+        }
+        #endregion
+    }
+}

Client/Scripts/Util/WeaponUtil.cs

@@ -0,0 +1,543 @@
+using GTA;
+using GTA.Math;
+using GTA.Native;
+using System.Collections.Generic;
+
+namespace RageCoop.Client
+{
+    internal class MuzzleInfo
+    {
+        public MuzzleInfo(Vector3 pos, Vector3 forward)
+        {
+            Position = pos;
+            ForawardVector = forward;
+        }
+        public Vector3 Position;
+        public Vector3 ForawardVector;
+    }
+    internal static class WeaponUtil
+    {
+        public static Dictionary<uint, bool> GetWeaponComponents(this Weapon weapon)
+        {
+            Dictionary<uint, bool> result = null;
+
+            if (weapon.Components.Count > 0)
+            {
+                result = new Dictionary<uint, bool>();
+
+                foreach (var comp in weapon.Components)
+                {
+                    result.Add((uint)comp.ComponentHash, comp.Active);
+                }
+            }
+
+            return result;
+        }
+
+        public static Vector3 GetMuzzlePosition(this Ped p)
+        {
+            var w = p.Weapons.CurrentWeaponObject;
+            if (w != null)
+            {
+                var hash = p.Weapons.Current.Hash;
+                if (MuzzleBoneIndexes.ContainsKey(hash)) { return w.Bones[MuzzleBoneIndexes[hash]].Position; }
+                return w.Position;
+            }
+            return p.Bones[Bone.SkelRightHand].Position;
+        }
+
+        private static long BulletsShot = 0;
+
+        public static float GetWeaponDamage(this Ped P, uint hash)
+        {
+            var comp = P.Weapons.Current.Components.GetSuppressorComponent();
+            return Function.Call<float>(Hash.GET_WEAPON_DAMAGE, hash, comp.Active ? comp.ComponentHash : WeaponComponentHash.Invalid);
+
+            /*
+            if (P.IsInVehicle() && (hash!=(uint)P.Weapons.Current.Hash))
+            {
+                // This is a vehicle weapon
+                P.VehicleWeapon=(VehicleWeaponHash)hash;
+                return 100;
+            }
+            switch (P.Weapons.Current.Group)
+            {
+                case WeaponGroup.Pistol: return 30;
+                case WeaponGroup.AssaultRifle: return 30;
+                case WeaponGroup.SMG: return 20;
+                case WeaponGroup.MG: return 40;
+                case WeaponGroup.Shotgun: return 30;
+                case WeaponGroup.Sniper: return 200;
+                case WeaponGroup.Heavy: return 30;
+            }
+            return 0;
+            */
+        }
+
+        public static int GetMuzzleIndex(this Vehicle v)
+        {
+            BulletsShot++;
+            switch (v.Model.Hash)
+            {
+                // cerberus3
+                case 1909700336:
+                    return 53;
+
+                // cerberus2
+                case 679453769:
+                    return 54;
+
+                // cerberus
+                case -801550069:
+                    return 90;
+                /*
+                // cerberus (flame)
+                case -801550069:
+                    i=BulletsShot%2==0 ? 89 : 88;
+                    return new MuzzleInfo(v.Bones[i].Position, v.Bones[i].ForwardVector);
+                // cerberus (passenger flame)
+                case -801550069:
+                    i=BulletsShot%2==0 ? 76 : 75;
+                    return new MuzzleInfo(v.Bones[i].Position, v.Bones[i].ForwardVector);
+                 */
+
+                // ISSI6
+                case 1239571361:
+                    return BulletsShot % 2 == 0 ? 12 : 14;
+
+
+                // ISSI5
+                case 1537277726:
+                    return BulletsShot % 2 == 0 ? 30 : 32;
+
+
+                // ISSI4
+                case 628003514:
+                    return BulletsShot % 2 == 0 ? 14 : 12;
+
+
+                // DOMINATOR6
+                case -1293924613:
+                    return BulletsShot % 2 == 0 ? 51 : 55;
+
+
+                // IMPALER4
+                case -1744505657:
+                    return BulletsShot % 2 == 0 ? 64 : 63;
+
+
+
+                // IMPERATOR3
+                case -755532233:
+                    return BulletsShot % 2 == 0 ? 86 : 88;
+
+
+
+                // SLAMVAN6
+                case 1742022738:
+                    return BulletsShot % 2 == 0 ? 78 : 76;
+
+
+                // CHAMPION
+                case -915234475:
+                    return BulletsShot % 2 == 0 ? 60 : 61;
+
+
+                // MONSTER4
+                case 840387324:
+                    return BulletsShot % 2 == 0 ? 63 : 65;
+
+
+                // BRUTUS2
+                case -1890996696:
+                    return 67;
+
+                // BRUISER2
+                case -1694081890:
+                    return BulletsShot % 2 == 0 ? 45 : 51;
+
+
+                // TECHNICAL3
+                case 1356124575:
+                    return 67;
+
+                // TECHNICAL2
+                case 1180875963:
+                    return 54;
+
+                // TECHNICAL
+                case -2096818938:
+                    return 63;
+
+                // PATRIOT3
+                case -670086588:
+                    return BulletsShot % 2 == 0 ? 87 : 89;
+
+                // NIGHTSHARK
+                case 433954513:
+                    return BulletsShot % 2 == 0 ? 1 : 2;
+
+                /*
+                // NIGHTSHARK (second)
+                case 433954513:
+                    return BulletsShot%2==0 ? 3 : 4;
+                */
+
+                // MENACER
+                case 2044532910:
+                    return BulletsShot % 2 == 0 ? 91 : 90;
+                /*
+                // MENACER
+                case 2044532910:
+                    return new MuzzleInfo(v.Bones[75].Position, v.Bones[75].ForwardVector);
+                // MENACER
+                case 2044532910:
+                    return new MuzzleInfo(v.Bones[78].Position, v.Bones[78].ForwardVector);
+                 
+                 */
+
+                // CARACARA
+                case 1254014755:
+                    return 83;
+
+                /*
+                // CARACARA
+                case 1254014755:
+                    return BulletsShot%2==0 ? 93 : 94;
+                */
+
+                // INSURGENT
+                case -1860900134:
+                    return 49;
+
+                // INSURGENT3
+                case -1924433270:
+                    return 81;
+
+                /*
+                // INSURGENT3
+                case -1924433270:
+                    return BulletsShot%2==0 ? 86 : 91;
+                */
+
+                // BLAZER5
+                case -1590337689:
+                    return BulletsShot % 2 == 0 ? 17 : 18;
+
+                // BRUISER
+                case 668439077:
+                    return BulletsShot % 2 == 0 ? 66 : 68;
+
+
+                // BRUTUS
+                case 2139203625:
+                    return 84;
+
+
+                // MONSTER3
+                case 1721676810:
+                    return BulletsShot % 2 == 0 ? 53 : 55;
+
+
+                // BRUISER3
+                case -2042350822:
+                    return BulletsShot % 2 == 0 ? 52 : 50;
+
+                // BRUTUS3
+                case 2038858402:
+                    return 84;
+
+                // MONSTER5
+                case -715746948:
+                    return BulletsShot % 2 == 0 ? 63 : 65;
+
+                // JB7002
+                case 394110044:
+                    return BulletsShot % 2 == 0 ? 54 : 53;
+
+                // DOMINATOR5
+                case -1375060657:
+                    return BulletsShot % 2 == 0 ? 35 : 36;
+
+                // IMPALER3
+                case -1924800695:
+                    return BulletsShot % 2 == 0 ? 75 : 76;
+
+
+                // IMPERATOR2
+                case 1637620610:
+                    return BulletsShot % 2 == 0 ? 97 : 99;
+
+
+                // SLAMVAN5
+                case 373261600:
+                    return BulletsShot % 2 == 0 ? 51 : 53;
+
+
+                // RUINER2
+                case 941494461:
+                    return BulletsShot % 2 == 0 ? 65 : 66;
+
+
+                // TAMPA3
+                case -1210451983:
+                    return 87;
+
+                // SCRAMJET
+                case -638562243:
+                    return BulletsShot % 2 == 0 ? 44 : 45;
+
+
+                // VIGILANTE
+                case -1242608589:
+                    return BulletsShot % 2 == 0 ? 42 : 43;
+
+
+                // ZR380
+                case 540101442:
+                    return BulletsShot % 2 == 0 ? 57 : 63;
+
+
+                // ZR3802
+                case -1106120762:
+                    return BulletsShot % 2 == 0 ? 57 : 63;
+
+
+                // ZR3803
+                case -1478704292:
+                    return BulletsShot % 2 == 0 ? 53 : 59;
+
+
+                // STROMBERG
+                case 886810209:
+                    return BulletsShot % 2 == 0 ? 85 : 84;
+
+
+                // SLAMVAN4
+                case -2061049099:
+                    return BulletsShot % 2 == 0 ? 76 : 78;
+
+
+                // IMPERATOR
+                case 444994115:
+                    return BulletsShot % 2 == 0 ? 88 : 86;
+
+
+                // IMPALER2
+                case 1009171724:
+                    return BulletsShot % 2 == 0 ? 63 : 64;
+
+
+                // DOMINATOR4
+                case -688189648:
+                    return BulletsShot % 2 == 0 ? 59 : 60;
+
+
+                // SAVAGE
+                case -82626025:
+                    return 30;
+
+                // BUZZARD
+                case 788747387:
+                    return BulletsShot % 2 == 0 ? 28 : 23;
+
+
+                // ANNIHL
+                case 837858166:
+                    return (int)BulletsShot % 4 + 35;
+
+
+                // HYDRA
+                case 970385471:
+                    return BulletsShot % 2 == 0 ? 29 : 28;
+
+
+                // STARLING
+                case -1700874274:
+                    return BulletsShot % 2 == 0 ? 24 : 12;
+
+
+                // RHINO
+                case 782665360:
+                    return 30;
+
+                default:
+                    return AddOnDataProvider.GetMuzzleIndex(v.Model.Hash);
+            }
+        }
+        public static bool IsUsingProjectileWeapon(this Ped p)
+        {
+            var vp = p.VehicleWeapon;
+            var type = Function.Call<int>(Hash.GET_WEAPON_DAMAGE_TYPE, vp);
+            if (vp != VehicleWeaponHash.Invalid)
+            {
+                return type == 3 ? false : VehicleProjectileWeapons.Contains(vp) || (type == 5 && !ExplosiveBullets.Contains((uint)vp));
+            }
+
+            var w = p.Weapons.Current;
+            return w.Group == WeaponGroup.Thrown || ProjectileWeapons.Contains(w.Hash);
+        }
+
+        public static readonly HashSet<uint> ExplosiveBullets = new HashSet<uint>
+        {
+            (uint)VehicleWeaponHash.PlayerLazer,
+            (uint)WeaponHash.Railgun,
+            1638077257
+        };
+
+        public static readonly Dictionary<WeaponHash, int> MuzzleBoneIndexes = new Dictionary<WeaponHash, int>
+        {
+            {WeaponHash.HeavySniper,6},
+            {WeaponHash.MarksmanRifle,9},
+            {WeaponHash.SniperRifle,9},
+            {WeaponHash.AdvancedRifle,5},
+            {WeaponHash.SpecialCarbine,9},
+            {WeaponHash.BullpupRifle,7},
+            {WeaponHash.AssaultRifle,9},
+            {WeaponHash.CarbineRifle,6},
+            {WeaponHash.MachinePistol,5},
+            {WeaponHash.SMG,5},
+            {WeaponHash.AssaultSMG,6},
+            {WeaponHash.CombatPDW,5},
+            {WeaponHash.MG,6},
+            {WeaponHash.CombatMG,7},
+            {WeaponHash.Gusenberg,7},
+            {WeaponHash.MicroSMG,10},
+            {WeaponHash.APPistol,8},
+            {WeaponHash.StunGun,4},
+            {WeaponHash.Pistol,8},
+            {WeaponHash.CombatPistol,8},
+            {WeaponHash.Pistol50,7},
+            {WeaponHash.SNSPistol,8},
+            {WeaponHash.HeavyPistol,8},
+            {WeaponHash.VintagePistol,8},
+            {WeaponHash.Railgun,9},
+            {WeaponHash.Minigun,5},
+            {WeaponHash.Musket,3},
+            {WeaponHash.HeavyShotgun,10},
+            {WeaponHash.PumpShotgun,11},
+            {WeaponHash.SawnOffShotgun,8},
+            {WeaponHash.BullpupShotgun,8},
+            {WeaponHash.AssaultShotgun,9},
+            {WeaponHash.HeavySniperMk2,11},
+            {WeaponHash.MarksmanRifleMk2,9},
+            {WeaponHash.CarbineRifleMk2,13},
+            {WeaponHash.SpecialCarbineMk2,16},
+            {WeaponHash.BullpupRifleMk2,8},
+            {WeaponHash.CompactRifle,7},
+            {WeaponHash.MilitaryRifle,11},
+            {WeaponHash.AssaultrifleMk2,17},
+            {WeaponHash.MiniSMG,5},
+            {WeaponHash.SMGMk2,6},
+            {WeaponHash.CombatMGMk2,16},
+            {WeaponHash.UnholyHellbringer,4},
+            {WeaponHash.PistolMk2,12},
+            {WeaponHash.SNSPistolMk2,15},
+            {WeaponHash.CeramicPistol,10},
+            {WeaponHash.MarksmanPistol,4},
+            {WeaponHash.Revolver,7},
+            {WeaponHash.RevolverMk2,7},
+            {WeaponHash.DoubleActionRevolver,7},
+            {WeaponHash.NavyRevolver,7},
+            {WeaponHash.PericoPistol,4},
+            {WeaponHash.FlareGun,4},
+            {WeaponHash.UpNAtomizer,4},
+            {WeaponHash.HomingLauncher,5},
+            {WeaponHash.CompactGrenadeLauncher,8},
+            {WeaponHash.Widowmaker,6},
+            {WeaponHash.GrenadeLauncher,3},
+            {WeaponHash.RPG,9},
+            {WeaponHash.DoubleBarrelShotgun,8},
+            {WeaponHash.SweeperShotgun,7},
+            {WeaponHash.CombatShotgun,7},
+            {WeaponHash.PumpShotgunMk2,7},
+
+        };
+
+        public static readonly HashSet<WeaponHash> ProjectileWeapons = new HashSet<WeaponHash> {
+            WeaponHash.HomingLauncher,
+            WeaponHash.RPG,
+            WeaponHash.Firework,
+            WeaponHash.UpNAtomizer,
+            WeaponHash.GrenadeLauncher,
+            WeaponHash.GrenadeLauncherSmoke,
+            WeaponHash.CompactGrenadeLauncher,
+            WeaponHash.FlareGun,
+        };
+        public static readonly HashSet<VehicleWeaponHash> VehicleProjectileWeapons = new HashSet<VehicleWeaponHash> {
+            VehicleWeaponHash.PlaneRocket,
+            VehicleWeaponHash.SpaceRocket,
+            VehicleWeaponHash.Tank,
+            (VehicleWeaponHash)3565779982, // STROMBERG missiles
+            (VehicleWeaponHash)3169388763, // SCRAMJET missiles
+        };
+        public static string GetFlashFX(this WeaponHash w)
+        {
+            switch (w.GetWeaponGroup())
+            {
+                case WeaponGroup.SMG:
+                    return "muz_smg";
+
+                case WeaponGroup.Shotgun:
+                    return "muz_smg";
+
+                case WeaponGroup.AssaultRifle:
+                    return "muz_assault_rifle";
+
+                case WeaponGroup.Pistol:
+                    return "muz_pistol";
+
+                case WeaponGroup.Stungun:
+                    return "muz_stungun";
+
+                case WeaponGroup.Heavy:
+                    switch (w)
+                    {
+                        case WeaponHash.Minigun:
+                            return "muz_minigun";
+
+                        case WeaponHash.RPG:
+                            return "muz_rpg";
+
+                        default:
+                            return "muz_minigun";
+                    }
+                case WeaponGroup.Sniper:
+                    return "muz_alternate_star";
+
+                case WeaponGroup.PetrolCan:
+                    return "weap_petrol_can";
+
+                case WeaponGroup.FireExtinguisher:
+                    return "weap_extinguisher";
+            }
+            switch ((VehicleWeaponHash)w)
+            {
+                case VehicleWeaponHash.Tank:
+                    return "muz_tank";
+
+                case VehicleWeaponHash.PlayerBuzzard:
+                    return "muz_buzzard";
+            }
+            return "muz_assault_rifle";
+        }
+        public static WeaponGroup GetWeaponGroup(this WeaponHash hash)
+        {
+            return Function.Call<WeaponGroup>(Hash.GET_WEAPONTYPE_GROUP, hash);
+        }
+    }
+    /*
+    class WeaponInfo
+    {
+        public string Name;
+        public string MuzzleFx;
+    }
+    public class AimingInfo
+    {
+        public string Name;
+        public float HeadingLimit;
+        public float SweepPitchMin;
+        public float SweepPitchMax;
+    }
+    */
+}