Пример #1
0
 public void removeBlip(LocalHandle blip)
 {
     if (new Blip(blip.Value).Exists())
     {
         new Blip(blip.Value).Remove();
     }
 }
Пример #2
0
 public void setBlipScale(LocalHandle blip, float scale)
 {
     if (new Blip(blip.Value).Exists())
     {
         new Blip(blip.Value).Scale = scale;
     }
 }
Пример #3
0
        public static void ResetEntityProperty(LocalHandle entity, string key)
        {
            var handle = NetEntityHandler.EntityToNet(entity.Value);
            var item   = NetEntityHandler.NetToStreamedItem(handle);
            var prop   = item as EntityProperties;

            if (prop == null || string.IsNullOrEmpty(key))
            {
                return;
            }

            if (prop.SyncedProperties == null || !prop.SyncedProperties.ContainsKey(key))
            {
                return;
            }

            prop.SyncedProperties.Remove(key);

            if (!item.LocalOnly)
            {
                var delta = new Delta_EntityProperties();
                delta.SyncedProperties = new Dictionary <string, NativeArgument>();
                delta.SyncedProperties.Add(key, new LocalGamePlayerArgument());
                UpdateEntityInfo(handle, EntityType.Prop, delta);
            }
        }
Пример #4
0
        public static bool SetEntityProperty(LocalHandle entity, string key, object value)
        {
            var handle = NetEntityHandler.EntityToNet(entity.Value);
            var item   = NetEntityHandler.NetToStreamedItem(handle);
            var prop   = item as EntityProperties;

            if (prop == null || string.IsNullOrEmpty(key))
            {
                return(false);
            }

            if (prop.SyncedProperties == null)
            {
                prop.SyncedProperties = new Dictionary <string, NativeArgument>();
            }

            var nativeArg = ParseNativeArguments(value).Single();

            NativeArgument oldValue = prop.SyncedProperties.Get(key);

            prop.SyncedProperties.Set(key, nativeArg);


            if (!item.LocalOnly)
            {
                var delta = new Delta_EntityProperties();
                delta.SyncedProperties = new Dictionary <string, NativeArgument>();
                delta.SyncedProperties.Add(key, nativeArg);
                UpdateEntityInfo(handle, EntityType.Prop, delta);
            }

            JavascriptHook.InvokeDataChangeEvent(entity, key, DecodeArgumentListPure(oldValue).FirstOrDefault());
            return(true);
        }
Пример #5
0
 public void setBlipPosition(LocalHandle blip, Vector3 pos)
 {
     if (new Blip(blip.Value).Exists())
     {
         new Blip(blip.Value).Position = pos.ToVector();
     }
 }
Пример #6
0
        public string getPlayerName(LocalHandle player)
        {
            var opp = Main.Opponents.FirstOrDefault(op => op.Value.Character != null && op.Value.Character.Handle == player.Value);

            if (opp.Value != null)
            {
                return(opp.Value.Name);
            }
            return(null);
        }
Пример #7
0
        public static bool HasEntityProperty(LocalHandle entity, string key)
        {
            var handle = NetEntityHandler.EntityToNet(entity.Value);
            var prop   = NetEntityHandler.NetToStreamedItem(handle) as EntityProperties;

            if (prop == null || string.IsNullOrEmpty(key) || prop.SyncedProperties == null)
            {
                return(false);
            }

            return(prop.SyncedProperties.ContainsKey(key));
        }
Пример #8
0
        public static string[] GetEntityAllProperties(LocalHandle entity)
        {
            var handle = NetEntityHandler.EntityToNet(entity.Value);
            var prop   = NetEntityHandler.NetToStreamedItem(handle) as EntityProperties;

            if (prop == null)
            {
                return(new string[0]);
            }

            if (prop.SyncedProperties == null || prop.SyncedProperties.Any(pair => string.IsNullOrEmpty(pair.Key)))
            {
                return(new string[0]);
            }

            //return prop.SyncedProperties.Select(pair => DecodeArgumentListPure(pair.Value).Single().ToString()).ToArray(); //Returns all the values
            return(prop.SyncedProperties.Select(pair => pair.Key).ToArray());
        }
Пример #9
0
        public static object GetEntityProperty(LocalHandle entity, string key)
        {
            var handle = NetEntityHandler.EntityToNet(entity.Value);
            var prop   = NetEntityHandler.NetToStreamedItem(handle) as EntityProperties;

            if (prop == null || string.IsNullOrEmpty(key))
            {
                return(null);
            }

            if (prop.SyncedProperties == null || !prop.SyncedProperties.ContainsKey(key))
            {
                return(null);
            }

            var natArg = prop.SyncedProperties[key];

            return(DecodeArgumentListPure(natArg).Single());
        }
Пример #10
0
 public int getPlayerArmor(LocalHandle ped)
 {
     return(new Ped(ped.Value).Armor);
 }
Пример #11
0
 public void setPlayerArmor(LocalHandle ped, int armor)
 {
     new Ped(ped.Value).Armor = armor;
 }
Пример #12
0
 public int getPlayerHealth(LocalHandle ped)
 {
     return(new Ped(ped.Value).Health);
 }
Пример #13
0
 public void TestHasRights()
 {
     Assert.IsTrue(LocalHandle.HasRights(ProcessRights.None));
     Assert.IsTrue(LocalHandle.HasRights(ProcessRights.QueryInformation));
     Assert.IsFalse(LocalHandle.HasRights(ProcessRights.CreateThread));
 }
Пример #14
0
 public bool isVehicle(LocalHandle ent)
 {
     return(Function.Call <bool>(Hash.IS_ENTITY_A_VEHICLE, ent.Value));
 }
Пример #15
0
 public void setBlipScale(LocalHandle blip, double scale)
 {
     setBlipScale(blip, (float)scale);
 }
Пример #16
0
        private void UpdateVehicleMountedWeapon()
        {
            if (WeaponDataProvider.DoesVehicleSeatHaveGunPosition((VehicleHash)VehicleHash, VehicleSeat))
            {
                var delay = 30;
                //if ((VehicleHash) VehicleHash == GTA.Native.VehicleHash.Rhino) delay = 300;

                if (Game.GameTime - _lastVehicleAimUpdate > delay)
                {
                    Function.Call(Hash.TASK_VEHICLE_AIM_AT_COORD, Character, AimCoords.X, AimCoords.Y,
                                  AimCoords.Z);
                    _lastVehicleAimUpdate = Game.GameTime;
                }

                if (IsShooting)
                {
                    if (((VehicleHash)VehicleHash == GTA.VehicleHash.Rhino &&
                         DateTime.Now.Subtract(_lastRocketshot).TotalMilliseconds > 1000) ||
                        ((VehicleHash)VehicleHash != GTA.VehicleHash.Rhino))
                    {
                        _lastRocketshot = DateTime.Now;

                        var baseTurretPos =
                            MainVehicle.GetOffsetInWorldCoords(
                                WeaponDataProvider.GetVehicleWeaponMuzzle((VehicleHash)VehicleHash, false));
                        var doesBaseTurretDiffer =
                            WeaponDataProvider.DoesVehiclesMuzzleDifferFromVehicleGunPos(
                                (VehicleHash)VehicleHash);
                        var barrellLength = WeaponDataProvider.GetVehicleTurretLength((VehicleHash)VehicleHash);

                        var speed = 0xbf800000;
                        var hash  = WeaponHash.CombatPDW;
                        if ((VehicleHash)VehicleHash == GTA.VehicleHash.Rhino)
                        {
                            hash = (WeaponHash)1945616459;
                        }

                        Vector3 tPos = baseTurretPos;
                        if (
                            WeaponDataProvider.DoesVehicleHaveParallelWeapon((VehicleHash)VehicleHash, false) &&
                            VehicleSeat == 1)
                        {
                            var muzzle = WeaponDataProvider.GetVehicleWeaponMuzzle((VehicleHash)VehicleHash,
                                                                                   false);
                            tPos =
                                MainVehicle.GetOffsetInWorldCoords(new Vector3(muzzle.X * -1f, muzzle.Y, muzzle.Z));
                        }

                        if (doesBaseTurretDiffer)
                        {
                            var kekDir = (AimCoords - tPos);
                            kekDir.Normalize();
                            var rot    = Main.DirectionToRotation(kekDir);
                            var newDir = Main.RotationToDirection(new Vector3(0, 0, rot.Z));
                            newDir.Normalize();
                            tPos = tPos +
                                   newDir *
                                   WeaponDataProvider.GetVehicleWeaponMuzzle((VehicleHash)VehicleHash, true)
                                   .Length();
                        }


                        var turretDir = (AimCoords - tPos);
                        turretDir.Normalize();
                        var start = tPos + turretDir * barrellLength;
                        var end   = start + turretDir * 100f;

                        _lastStart = start;
                        _lastEnd   = end;

                        var damage = WeaponDataProvider.GetWeaponDamage(WeaponHash.Minigun);
                        if ((VehicleHash)VehicleHash == GTA.VehicleHash.Rhino)
                        {
                            damage = 210;
                        }

                        if (IsFriend())
                        {
                            damage = 0;
                        }

                        Function.Call(Hash.SHOOT_SINGLE_BULLET_BETWEEN_COORDS, start.X, start.Y, start.Z, end.X,
                                      end.Y, end.Z, damage, true, (int)hash, Character, true, false, speed);
                    }
                }
            }
            else if (!WeaponDataProvider.DoesVehicleSeatHaveMountedGuns((VehicleHash)VehicleHash) || VehicleSeat != -1)
            {
                if (Character.Weapons.Current.Hash != (WeaponHash)CurrentWeapon)
                {
                    //Function.Call(Hash.GIVE_WEAPON_TO_PED, Character, CurrentWeapon, 999, true, true);
                    //Function.Call(Hash.SET_CURRENT_PED_WEAPON, Character, CurrentWeapon, true);
                    //Character.Weapons.Give((WeaponHash)CurrentWeapon, -1, true, true);
                    //Character.Weapons.Select((WeaponHash) CurrentWeapon);
                    Character.Weapons.RemoveAll();
                    Character.Weapons.Give((WeaponHash)CurrentWeapon, -1, true, true);
                }

                if (IsShooting || IsAiming)
                {
                    if (!_lastDrivebyShooting)
                    {
                        Function.Call(Hash.SET_PED_CURRENT_WEAPON_VISIBLE, Character, false, false, false, false);

                        Function.Call(Hash.TASK_DRIVE_BY, Character, 0, 0, AimCoords.X, AimCoords.Y, AimCoords.Z,
                                      0, 0, 0, unchecked ((int)FiringPattern.SingleShot));
                    }
                    else
                    {
                        Function.Call(Hash.SET_PED_CURRENT_WEAPON_VISIBLE, Character, true, false, false, false);

                        Function.Call(Hash.SET_DRIVEBY_TASK_TARGET, Character, 0, 0, AimCoords.X, AimCoords.Y, AimCoords.Z);
                    }

                    var rightSide = (VehicleSeat + 2) % 2 == 0;

                    if (WeaponDataProvider.NeedsFakeBullets(CurrentWeapon))
                    {
                        const string rightDict = "veh@driveby@first_person@passenger_right_handed@throw";
                        const string leftDict  = "veh@driveby@first_person@driver@throw";

                        string drivebyDict = rightSide ? rightDict : leftDict;

                        Function.Call(Hash.TASK_PLAY_ANIM_ADVANCED, Character, Util.Util.LoadDict(drivebyDict),
                                      "sweep_low", Character.Position.X, Character.Position.Y, Character.Position.Z, Character.Rotation.X,
                                      Character.Rotation.Y, Character.Rotation.Z, -8f, -8f, -1, 0, rightSide ? 0.6f : 0.3f, 0, 0);
                    }

                    if (IsShooting)
                    {
                        Function.Call(Hash.SET_PED_INFINITE_AMMO_CLIP, Character, true);
                        Function.Call(Hash.SET_PED_AMMO, Character, CurrentWeapon, 10);


                        if (AimPlayer != null && AimPlayer.Position != null)
                        {
                            AimCoords = AimPlayer.Position;
                            AimPlayer = null;
                        }

                        if (!WeaponDataProvider.NeedsFakeBullets(CurrentWeapon))
                        {
                            Function.Call(Hash.SET_PED_SHOOTS_AT_COORD, Character, AimCoords.X, AimCoords.Y, AimCoords.Z,
                                          true);
                        }
                        else if (DateTime.Now.Subtract(_lastRocketshot).TotalMilliseconds > 500)
                        {
                            _lastRocketshot = DateTime.Now;

                            var damage  = WeaponDataProvider.GetWeaponDamage((WeaponHash)CurrentWeapon);
                            var speed   = 0xbf800000;
                            var weaponH = (WeaponHash)CurrentWeapon;

                            if (IsFriend())
                            {
                                damage = 0;
                            }

                            var start = Character.GetBoneCoord(rightSide ? Bone.SKEL_R_Hand : Bone.SKEL_L_Hand);
                            var end   = AimCoords;

                            Function.Call(Hash.SHOOT_SINGLE_BULLET_BETWEEN_COORDS, start.X, start.Y, start.Z,
                                          end.X,
                                          end.Y, end.Z, damage, true, (int)weaponH, Character, false, true, speed);
                        }
                    }

                    _lastVehicleAimUpdate = Game.GameTime;
                    _lastDrivebyShooting  = IsShooting || IsAiming;
                    Ped PlayerChar = Game.Player.Character;
                    if (Function.Call <bool>(Hash.HAS_ENTITY_BEEN_DAMAGED_BY_ENTITY, PlayerChar, Character, true))
                    {
                        int boneHit    = -1;
                        var boneHitArg = new OutputArgument();

                        if (Function.Call <bool>(Hash.GET_PED_LAST_DAMAGE_BONE, PlayerChar, boneHitArg))
                        {
                            boneHit = boneHitArg.GetResult <int>();
                        }

                        LocalHandle them = new LocalHandle(Character.Handle, HandleType.GameHandle);
                        JavascriptHook.InvokeCustomEvent(api =>
                                                         api.invokeonLocalPlayerDamaged(them, CurrentWeapon, boneHit /*, playerHealth, playerArmor*/));
                    }

                    Function.Call(Hash.CLEAR_ENTITY_LAST_DAMAGE_ENTITY, Character);
                    Function.Call(Hash.CLEAR_ENTITY_LAST_DAMAGE_ENTITY, PlayerChar);
                }

                if (!IsShooting && !IsAiming && _lastDrivebyShooting && Game.GameTime - _lastVehicleAimUpdate > 200)
                {
                    Tasks task = Character.Task;
                    task.ClearAll();
                    task.ClearSecondary();
                    Function.Call(Hash.CLEAR_DRIVEBY_TASK_UNDERNEATH_DRIVING_TASK, Character);
                    //Function.Call(Hash.TASK_DRIVE_BY, Character, 0, 0, 0, 0, 0, 0, 0, 0, 0);
                    //Function.Call(Hash.SET_DRIVEBY_TASK_TARGET, Character, 0, 0, 0, 0, 0);
                    task.ClearLookAt();
                    //GTA.UI.Screen.ShowNotification("Done shooting");
                    //GTA.UI.Screen.ShowSubtitle("Done Shooting1", 300);
                    _lastDrivebyShooting = false;
                }
            }
        }
Пример #17
0
 public void deleteMarker(LocalHandle handle)
 {
     Main.NetEntityHandler.DeleteLocalMarker(handle.Value);
 }
 public static extern BOOL ConvertSidToStringSidW(
     ref SID Sid,
     out LocalHandle StringSid);
Пример #19
0
        public void OnTick(object sender, EventArgs e)
        {
            Main.TickCount++;
            try
            {
                Ped player = Game.Player.Character;
                var res    = UIMenu.GetScreenResolutionMantainRatio();

                if (Environment.TickCount - _lastCheck > 1000)
                {
                    _bytesSentPerSecond     = _bytesSent - _lastBytesSent;
                    _bytesReceivedPerSecond = _bytesReceived - _lastBytesReceived;

                    _lastBytesReceived = _bytesReceived;
                    _lastBytesSent     = _bytesSent;


                    _lastCheck = Environment.TickCount;
                }

                if (!string.IsNullOrWhiteSpace(_threadsafeSubtitle))
                {
                    GTA.UI.Screen.ShowSubtitle(_threadsafeSubtitle, 500);
                }

                DEBUG_STEP = 1;

                if (!_hasInitialized)
                {
                    RebuildServerBrowser();
#if INTEGRITYCHECK
                    if (!VerifyGameIntegrity())
                    {
                        _mainWarning          = new Warning("alert", "Could not verify game integrity.\nPlease restart your game, or update Grand Theft Auto V.");
                        _mainWarning.OnAccept = () =>
                        {
                            if (Client != null && IsOnServer())
                            {
                                Client.Disconnect("Quit");
                            }
                            CEFManager.Dispose();
                            CEFManager.DisposeCef();
                            Script.Wait(500);
                            //Environment.Exit(0);
                            Process.GetProcessesByName("GTA5")[0].Kill();
                            Process.GetCurrentProcess().Kill();
                        };
                    }
#endif
                    _hasInitialized = true;
                }
                DEBUG_STEP = 2;

                if (!_hasPlayerSpawned && player != null && player.Handle != 0 && !Game.IsLoading)
                {
                    GTA.UI.Screen.FadeOut(1);
                    ResetPlayer();
                    MainMenu.RefreshIndex();
                    _hasPlayerSpawned     = true;
                    MainMenu.Visible      = true;
                    World.RenderingCamera = MainMenuCamera;

                    var address = Util.Util.FindPattern("\x32\xc0\xf3\x0f\x11\x09", "xxxxxx"); // Weapon/radio slowdown

                    DEBUG_STEP = 3;

                    if (address != IntPtr.Zero)
                    {
                        Util.Util.WriteMemory(address, 0x90, 6);
                    }

                    address = Util.Util.FindPattern("\x48\x85\xC0\x0F\x84\x00\x00\x00\x00\x8B\x48\x50", "xxxxx????xxx");
                    // unlock objects; credit goes to the GTA-MP team

                    DEBUG_STEP = 4;

                    if (address != IntPtr.Zero)
                    {
                        Util.Util.WriteMemory(address, 0x90, 24);
                    }

                    //TerminateGameScripts();

                    GTA.UI.Screen.FadeIn(1000);
                }

                DEBUG_STEP = 5;

                Game.DisableControlThisFrame(0, Control.EnterCheatCode);
                Game.DisableControlThisFrame(0, Control.FrontendPause);
                Game.DisableControlThisFrame(0, Control.FrontendPauseAlternate);
                Game.DisableControlThisFrame(0, Control.FrontendSocialClub);
                Game.DisableControlThisFrame(0, Control.FrontendSocialClubSecondary);

                if (!player.IsJumping)
                {
                    //Game.DisableControlThisFrame(0, Control.MeleeAttack1);
                    Game.DisableControlThisFrame(0, Control.MeleeAttackLight);
                }

                Function.Call(Hash.HIDE_HELP_TEXT_THIS_FRAME);

                if (Game.Player.Character.IsRagdoll)
                {
                    Game.DisableControlThisFrame(0, Control.Attack);
                    Game.DisableControlThisFrame(0, Control.Attack2);
                }

                if (_mainWarning != null)
                {
                    _mainWarning.Draw();
                    return;
                }

                if ((Game.IsControlJustPressed(0, Control.FrontendPauseAlternate) || Game.IsControlJustPressed(0, Control.FrontendPause)) &&
                    !MainMenu.Visible && !_wasTyping)
                {
                    MainMenu.Visible = true;

                    if (!IsOnServer())
                    {
                        if (MainMenu.Visible)
                        {
                            World.RenderingCamera = MainMenuCamera;
                        }
                        else
                        {
                            World.RenderingCamera = null;
                        }
                    }
                    else if (MainMenu.Visible)
                    {
                        RebuildPlayersList();
                    }

                    MainMenu.RefreshIndex();
                }
                else
                {
                    if (!BlockControls)
                    {
                        MainMenu.ProcessControls();
                    }
                    MainMenu.Update();
                    MainMenu.CanLeave = IsOnServer();
                    if (MainMenu.Visible && !MainMenu.TemporarilyHidden && !_mainMapItem.Focused && _hasScAvatar && File.Exists(GTANInstallDir + "\\images\\scavatar.png"))
                    {
                        var safe = new Point(300, 180);
                        Util.Util.DxDrawTexture(0, GTANInstallDir + "images\\scavatar.png", res.Width - safe.X - 64, safe.Y - 80, 64, 64, 0, 255, 255, 255, 255, false);
                    }

                    if (!IsOnServer())
                    {
                        Game.EnableControlThisFrame(0, Control.FrontendPause);
                    }
                }
                DEBUG_STEP = 6;

                if (_isGoingToCar && Game.IsControlJustPressed(0, Control.PhoneCancel))
                {
                    Game.Player.Character.Task.ClearAll();
                    _isGoingToCar = false;
                }

                if (Client == null || Client.ConnectionStatus == NetConnectionStatus.Disconnected || Client.ConnectionStatus == NetConnectionStatus.None)
                {
                    return;
                }
                // BELOW ONLY ON SERVER

                _versionLabel.Position      = new Point((int)(res.Width / 2), 0);
                _versionLabel.TextAlignment = UIResText.Alignment.Centered;
                _versionLabel.Draw();

                DEBUG_STEP = 7;

                if (_wasTyping)
                {
                    Game.DisableControlThisFrame(0, Control.FrontendPauseAlternate);
                }

                var playerCar = Game.Player.Character.CurrentVehicle;

                DEBUG_STEP = 8;

                Watcher.Tick();

                DEBUG_STEP = 9;

                _playerGodMode = Game.Player.IsInvincible;

                //invokeonLocalPlayerShoot
                if (player != null && player.IsShooting)
                {
                    JavascriptHook.InvokeCustomEvent(
                        api =>
                        api?.invokeonLocalPlayerShoot((int)(player.Weapons.Current?.Hash ?? 0),
                                                      RaycastEverything(new Vector2(0, 0)).ToLVector()));
                }


                DEBUG_STEP = 10;

                int           netPlayerCar = 0;
                RemoteVehicle cc           = null;
                if (playerCar != null && (netPlayerCar = NetEntityHandler.EntityToNet(playerCar.Handle)) != 0)
                {
                    var item = NetEntityHandler.NetToStreamedItem(netPlayerCar) as RemoteVehicle;

                    if (item != null)
                    {
                        var lastHealth      = item.Health;
                        var lastDamageModel = item.DamageModel;

                        item.Position    = playerCar.Position.ToLVector();
                        item.Rotation    = playerCar.Rotation.ToLVector();
                        item.Health      = playerCar.EngineHealth;
                        item.IsDead      = playerCar.IsDead;
                        item.DamageModel = playerCar.GetVehicleDamageModel();

                        if (lastHealth != playerCar.EngineHealth)
                        {
                            JavascriptHook.InvokeCustomEvent(api => api?.invokeonVehicleHealthChange((int)lastHealth));
                        }

                        if (playerCar.IsEngineRunning ^ !PacketOptimization.CheckBit(item.Flag, EntityFlag.EngineOff))
                        {
                            playerCar.IsEngineRunning = !PacketOptimization.CheckBit(item.Flag, EntityFlag.EngineOff);
                        }

                        if (lastDamageModel != null)
                        {
                            if (lastDamageModel.BrokenWindows != item.DamageModel.BrokenWindows)
                            {
                                for (int i = 0; i < 8; i++)
                                {
                                    if (((lastDamageModel.BrokenWindows ^ item.DamageModel.BrokenWindows) & 1 << i) != 0)
                                    {
                                        var i1 = i;
                                        JavascriptHook.InvokeCustomEvent(api => api?.invokeonVehicleWindowSmash(i1));
                                    }
                                }
                            }

                            if (lastDamageModel.BrokenDoors != item.DamageModel.BrokenDoors)
                            {
                                for (int i = 0; i < 8; i++)
                                {
                                    if (((lastDamageModel.BrokenDoors ^ item.DamageModel.BrokenDoors) & 1 << i) != 0)
                                    {
                                        var i1 = i;
                                        JavascriptHook.InvokeCustomEvent(api => api?.invokeonVehicleDoorBreak(i1));
                                    }
                                }
                            }
                        }
                    }

                    cc = item;
                }

                DEBUG_STEP = 11;

                if (playerCar != _lastPlayerCar)
                {
                    if (_lastPlayerCar != null)
                    {
                        var c = NetEntityHandler.EntityToStreamedItem(_lastPlayerCar.Handle) as
                                RemoteVehicle;

                        if (VehicleSyncManager.IsSyncing(c))
                        {
                            _lastPlayerCar.IsInvincible = c?.IsInvincible ?? false;
                        }
                        else
                        {
                            _lastPlayerCar.IsInvincible = true;
                        }

                        if (c != null)
                        {
                            Function.Call(Hash.SET_VEHICLE_ENGINE_ON, _lastPlayerCar,
                                          !PacketOptimization.CheckBit(c.Flag, EntityFlag.EngineOff), true, true);
                        }

                        int h  = _lastPlayerCar.Handle;
                        var lh = new LocalHandle(h);
                        JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerExitVehicle(lh));
                        _lastVehicleSiren = false;
                    }

                    if (playerCar != null)
                    {
                        if (!NetEntityHandler.ContainsLocalHandle(playerCar.Handle))
                        {
                            playerCar.Delete();
                            playerCar = null;
                        }
                        else
                        {
                            playerCar.IsInvincible = cc?.IsInvincible ?? false;

                            LocalHandle handle = new LocalHandle(playerCar.Handle);
                            JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerEnterVehicle(handle));
                        }
                    }

                    LastCarEnter = DateTime.Now;
                }

                DEBUG_STEP = 12;

                if (playerCar != null)
                {
                    if (playerCar.GetResponsiblePed().Handle == player.Handle)
                    {
                        playerCar.IsInvincible = cc?.IsInvincible ?? false;
                    }
                    else
                    {
                        playerCar.IsInvincible = true;
                    }

                    var siren = playerCar.SirenActive;

                    if (siren != _lastVehicleSiren)
                    {
                        JavascriptHook.InvokeCustomEvent(api => api?.invokeonVehicleSirenToggle());
                    }

                    _lastVehicleSiren = siren;
                }

                Game.Player.Character.MaxHealth = 200;

                var playerObj = NetEntityHandler.EntityToStreamedItem(Game.Player.Character.Handle) as RemotePlayer;

                if (playerObj != null)
                {
                    Game.Player.IsInvincible = playerObj.IsInvincible;
                }

                if (!string.IsNullOrWhiteSpace(CustomAnimation))
                {
                    var sp = CustomAnimation.Split();

                    if (
                        !Function.Call <bool>(Hash.IS_ENTITY_PLAYING_ANIM, Game.Player.Character,
                                              sp[0], sp[1],
                                              3))
                    {
                        Game.Player.Character.Task.ClearSecondary();

                        Function.Call(Hash.TASK_PLAY_ANIM, Game.Player.Character,
                                      Util.Util.LoadDict(sp[0]), sp[1],
                                      8f, 10f, -1, AnimationFlag, -8f, 1, 1, 1);
                    }
                }

                DEBUG_STEP     = 13;
                _lastPlayerCar = playerCar;


                if (Game.IsControlJustPressed(0, Control.ThrowGrenade) && !Game.Player.Character.IsInVehicle() && IsOnServer() && !Chat.IsFocused)
                {
                    var vehs = World.GetAllVehicles().OrderBy(v => v.Position.DistanceToSquared(Game.Player.Character.Position)).Take(1).ToList();
                    if (vehs.Any() && Game.Player.Character.IsInRangeOfEx(vehs[0].Position, 6f))
                    {
                        var         relPos = vehs[0].GetOffsetFromWorldCoords(Game.Player.Character.Position);
                        VehicleSeat seat   = VehicleSeat.Any;

                        if (relPos.X < 0 && relPos.Y > 0)
                        {
                            seat = VehicleSeat.LeftRear;
                        }
                        else if (relPos.X >= 0 && relPos.Y > 0)
                        {
                            seat = VehicleSeat.RightFront;
                        }
                        else if (relPos.X < 0 && relPos.Y <= 0)
                        {
                            seat = VehicleSeat.LeftRear;
                        }
                        else if (relPos.X >= 0 && relPos.Y <= 0)
                        {
                            seat = VehicleSeat.RightRear;
                        }

                        if (vehs[0].PassengerCapacity == 1)
                        {
                            seat = VehicleSeat.Passenger;
                        }

                        if (vehs[0].PassengerCapacity > 3 && vehs[0].GetPedOnSeat(seat).Handle != 0)
                        {
                            if (seat == VehicleSeat.LeftRear)
                            {
                                for (int i = 3; i < vehs[0].PassengerCapacity; i += 2)
                                {
                                    if (vehs[0].GetPedOnSeat((VehicleSeat)i).Handle == 0)
                                    {
                                        seat = (VehicleSeat)i;
                                        break;
                                    }
                                }
                            }
                            else if (seat == VehicleSeat.RightRear)
                            {
                                for (int i = 4; i < vehs[0].PassengerCapacity; i += 2)
                                {
                                    if (vehs[0].GetPedOnSeat((VehicleSeat)i).Handle == 0)
                                    {
                                        seat = (VehicleSeat)i;
                                        break;
                                    }
                                }
                            }
                        }

                        if (WeaponDataProvider.DoesVehicleSeatHaveGunPosition((VehicleHash)vehs[0].Model.Hash, 0, true) && Game.Player.Character.IsIdle && !Game.Player.IsAiming)
                        {
                            Game.Player.Character.SetIntoVehicle(vehs[0], seat);
                        }
                        else
                        {
                            Game.Player.Character.Task.EnterVehicle(vehs[0], seat, -1, 2f);
                        }
                        _isGoingToCar = true;
                    }
                }

                DEBUG_STEP = 14;

                Game.DisableControlThisFrame(0, Control.SpecialAbility);
                Game.DisableControlThisFrame(0, Control.SpecialAbilityPC);
                Game.DisableControlThisFrame(0, Control.SpecialAbilitySecondary);
                Game.DisableControlThisFrame(0, Control.CharacterWheel);
                Game.DisableControlThisFrame(0, Control.Phone);
                Game.DisableControlThisFrame(0, Control.Duck);

                DEBUG_STEP = 15;

                VehicleSyncManager?.Pulse();

                DEBUG_STEP = 16;

                if (StringCache != null)
                {
                    StringCache?.Pulse();
                }

                DEBUG_STEP = 17;

                double aver = 0;
                lock (_averagePacketSize)
                    aver = _averagePacketSize.Count > 0 ? _averagePacketSize.Average() : 0;

                _statsItem.Text =
                    string.Format(
                        "~h~Bytes Sent~h~: {0}~n~~h~Bytes Received~h~: {1}~n~~h~Bytes Sent / Second~h~: {5}~n~~h~Bytes Received / Second~h~: {6}~n~~h~Average Packet Size~h~: {4}~n~~n~~h~Messages Sent~h~: {2}~n~~h~Messages Received~h~: {3}",
                        _bytesSent, _bytesReceived, _messagesSent, _messagesReceived,
                        aver, _bytesSentPerSecond,
                        _bytesReceivedPerSecond);



                DEBUG_STEP = 18;
                if (Game.IsControlPressed(0, Control.Aim) && !Game.Player.Character.IsInVehicle() && Game.Player.Character.Weapons.Current.Hash != WeaponHash.Unarmed)
                {
                    Game.DisableControlThisFrame(0, Control.Jump);
                }

                //CRASH WORKAROUND: DISABLE PARACHUTE RUINER2
                if (Game.Player.Character.IsInVehicle())
                {
                    if (Game.Player.Character.CurrentVehicle.IsInAir && Game.Player.Character.CurrentVehicle.Model.Hash == 941494461)
                    {
                        Game.DisableAllControlsThisFrame(0);
                    }
                }


                DEBUG_STEP = 19;
                Function.Call((Hash)0x5DB660B38DD98A31, Game.Player, 0f);
                DEBUG_STEP              = 20;
                Game.MaxWantedLevel     = 0;
                Game.Player.WantedLevel = 0;
                DEBUG_STEP              = 21;
                lock (_localMarkers)
                {
                    foreach (var marker in _localMarkers)
                    {
                        World.DrawMarker((MarkerType)marker.Value.MarkerType, marker.Value.Position.ToVector(),
                                         marker.Value.Direction.ToVector(), marker.Value.Rotation.ToVector(),
                                         marker.Value.Scale.ToVector(),
                                         Color.FromArgb(marker.Value.Alpha, marker.Value.Red, marker.Value.Green, marker.Value.Blue));
                    }
                }

                DEBUG_STEP = 22;
                var hasRespawned = (Function.Call <int>(Hash.GET_TIME_SINCE_LAST_DEATH) < 8000 &&
                                    Function.Call <int>(Hash.GET_TIME_SINCE_LAST_DEATH) != -1 &&
                                    Game.Player.CanControlCharacter);

                if (hasRespawned && !_lastDead)
                {
                    _lastDead = true;
                    var msg = Client.CreateMessage();
                    msg.Write((byte)PacketType.PlayerRespawned);
                    Client.SendMessage(msg, NetDeliveryMethod.ReliableOrdered, (int)ConnectionChannel.SyncEvent);

                    JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerRespawn());

                    if (Weather != null)
                    {
                        Function.Call(Hash.SET_WEATHER_TYPE_NOW_PERSIST, Weather);
                    }
                    if (Time.HasValue)
                    {
                        World.CurrentDayTime = new TimeSpan(Time.Value.Hours, Time.Value.Minutes, 00);
                    }

                    Function.Call(Hash.PAUSE_CLOCK, true);

                    var us = NetEntityHandler.EntityToStreamedItem(Game.Player.Character.Handle);

                    NetEntityHandler.ReattachAllEntities(us, true);
                    foreach (
                        var source in
                        Main.NetEntityHandler.ClientMap.Values.Where(
                            item => item is RemoteParticle && ((RemoteParticle)item).EntityAttached == us.RemoteHandle)
                        .Cast <RemoteParticle>())
                    {
                        Main.NetEntityHandler.StreamOut(source);
                        Main.NetEntityHandler.StreamIn(source);
                    }
                }

                var pHealth = player.Health;
                var pArmor  = player.Armor;
                var pGun    = player.Weapons.Current?.Hash ?? WeaponHash.Unarmed;
                var pModel  = player.Model.Hash;

                if (pHealth != _lastPlayerHealth)
                {
                    int test = _lastPlayerHealth;
                    JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerHealthChange(test));
                }

                if (pArmor != _lastPlayerArmor)
                {
                    int test = _lastPlayerArmor;
                    JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerArmorChange(test));
                }

                if (pGun != _lastPlayerWeapon)
                {
                    WeaponHash test = _lastPlayerWeapon;
                    JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerWeaponSwitch((int)test));
                }

                if (pModel != (int)_lastPlayerModel)
                {
                    PedHash test = _lastPlayerModel;
                    JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerModelChange((int)test));
                }

                _lastPlayerHealth = pHealth;
                _lastPlayerArmor  = pArmor;
                _lastPlayerWeapon = pGun;
                _lastPlayerModel  = (PedHash)pModel;

                DEBUG_STEP = 23;
                _lastDead  = hasRespawned;
                DEBUG_STEP = 24;
                var killed = Game.Player.Character.IsDead;
                DEBUG_STEP = 25;
                if (killed && !_lastKilled)
                {
                    var msg = Client.CreateMessage();
                    msg.Write((byte)PacketType.PlayerKilled);
                    var killer = Function.Call <int>(Hash.GET_PED_SOURCE_OF_DEATH, Game.Player.Character);
                    var weapon = Function.Call <int>(Hash.GET_PED_CAUSE_OF_DEATH, Game.Player.Character);


                    var killerEnt = NetEntityHandler.EntityToNet(killer);
                    msg.Write(killerEnt);
                    msg.Write(weapon);

                    /*
                     * var playerMod = (PedHash)Game.Player.Character.Model.Hash;
                     * if (playerMod != PedHash.Michael && playerMod != PedHash.Franklin && playerMod != PedHash.Trevor)
                     * {
                     *  _lastModel = Game.Player.Character.Model.Hash;
                     *  var lastMod = new Model(PedHash.Michael);
                     *  lastMod.Request(10000);
                     *  Function.Call(Hash.SET_PLAYER_MODEL, Game.Player, lastMod);
                     *  Game.Player.Character.Kill();
                     * }
                     * else
                     * {
                     *  _lastModel = 0;
                     * }
                     */
                    Client.SendMessage(msg, NetDeliveryMethod.ReliableOrdered, (int)ConnectionChannel.SyncEvent);

                    JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerDeath(new LocalHandle(killer), weapon));

                    NativeUI.BigMessageThread.MessageInstance.ShowColoredShard("WASTED", "", HudColor.HUD_COLOUR_BLACK, HudColor.HUD_COLOUR_RED, 7000);
                    Function.Call(Hash.REQUEST_SCRIPT_AUDIO_BANK, "HUD_MINI_GAME_SOUNDSET", true);
                    Function.Call(Hash.PLAY_SOUND_FRONTEND, -1, "CHECKPOINT_NORMAL", "HUD_MINI_GAME_SOUNDSET");
                }

                /*
                 * if (Function.Call<int>(Hash.GET_TIME_SINCE_LAST_DEATH) < 8000 &&
                 *  Function.Call<int>(Hash.GET_TIME_SINCE_LAST_DEATH) != -1)
                 * {
                 *  if (_lastModel != 0 && Game.Player.Character.Model.Hash != _lastModel)
                 *  {
                 *      var lastMod = new Model(_lastModel);
                 *      lastMod.Request(10000);
                 *      Function.Call(Hash.SET_PLAYER_MODEL, new InputArgument(Game.Player), lastMod.Hash);
                 *  }
                 * }
                 */


                DEBUG_STEP = 28;


                if (!IsSpectating && _lastSpectating)
                {
                    Game.Player.Character.Opacity          = 255;
                    Game.Player.Character.IsPositionFrozen = false;
                    Game.Player.IsInvincible = false;
                    Game.Player.Character.IsCollisionEnabled = true;
                    SpectatingEntity                       = 0;
                    CurrentSpectatingPlayer                = null;
                    _currentSpectatingPlayerIndex          = 100000;
                    Game.Player.Character.PositionNoOffset = _preSpectatorPos;
                }
                if (IsSpectating)
                {
                    if (SpectatingEntity != 0)
                    {
                        Game.Player.Character.Opacity          = 0;
                        Game.Player.Character.IsPositionFrozen = true;
                        Game.Player.IsInvincible = true;
                        Game.Player.Character.IsCollisionEnabled = false;

                        Control[] exceptions = new[]
                        {
                            Control.LookLeftRight,
                            Control.LookUpDown,
                            Control.LookLeft,
                            Control.LookRight,
                            Control.LookUp,
                            Control.LookDown,
                        };

                        Game.DisableAllControlsThisFrame(0);
                        foreach (var c in exceptions)
                        {
                            Game.EnableControlThisFrame(0, c);
                        }

                        var ent = NetEntityHandler.NetToEntity(SpectatingEntity);

                        if (ent != null)
                        {
                            if (Function.Call <bool>(Hash.IS_ENTITY_A_PED, ent) && new Ped(ent.Handle).IsInVehicle())
                            {
                                Game.Player.Character.PositionNoOffset = ent.Position + new GTA.Math.Vector3(0, 0, 1.3f);
                            }
                            else
                            {
                                Game.Player.Character.PositionNoOffset = ent.Position;
                            }
                        }
                    }
                    else if (SpectatingEntity == 0 && CurrentSpectatingPlayer == null &&
                             NetEntityHandler.ClientMap.Values.Count(op => op is SyncPed && !((SyncPed)op).IsSpectating &&
                                                                     (((SyncPed)op).Team == 0 || ((SyncPed)op).Team == Main.LocalTeam) &&
                                                                     (((SyncPed)op).Dimension == 0 || ((SyncPed)op).Dimension == Main.LocalDimension)) > 0)
                    {
                        CurrentSpectatingPlayer =
                            NetEntityHandler.ClientMap.Values.Where(
                                op =>
                                op is SyncPed && !((SyncPed)op).IsSpectating &&
                                (((SyncPed)op).Team == 0 || ((SyncPed)op).Team == Main.LocalTeam) &&
                                (((SyncPed)op).Dimension == 0 || ((SyncPed)op).Dimension == Main.LocalDimension))
                            .ElementAt(_currentSpectatingPlayerIndex %
                                       NetEntityHandler.ClientMap.Values.Count(
                                           op =>
                                           op is SyncPed && !((SyncPed)op).IsSpectating &&
                                           (((SyncPed)op).Team == 0 || ((SyncPed)op).Team == Main.LocalTeam) &&
                                           (((SyncPed)op).Dimension == 0 ||
                                            ((SyncPed)op).Dimension == Main.LocalDimension))) as SyncPed;
                    }
                    else if (SpectatingEntity == 0 && CurrentSpectatingPlayer != null)
                    {
                        Game.Player.Character.Opacity          = 0;
                        Game.Player.Character.IsPositionFrozen = true;
                        Game.Player.IsInvincible = true;
                        Game.Player.Character.IsCollisionEnabled = false;
                        Game.DisableAllControlsThisFrame(0);

                        if (CurrentSpectatingPlayer.Character == null)
                        {
                            Game.Player.Character.PositionNoOffset = CurrentSpectatingPlayer.Position;
                        }
                        else if (CurrentSpectatingPlayer.IsInVehicle)
                        {
                            Game.Player.Character.PositionNoOffset = CurrentSpectatingPlayer.Character.Position + new GTA.Math.Vector3(0, 0, 1.3f);
                        }
                        else
                        {
                            Game.Player.Character.PositionNoOffset = CurrentSpectatingPlayer.Character.Position;
                        }

                        if (Game.IsControlJustPressed(0, Control.PhoneLeft))
                        {
                            _currentSpectatingPlayerIndex--;
                            CurrentSpectatingPlayer = null;
                        }
                        else if (Game.IsControlJustPressed(0, Control.PhoneRight))
                        {
                            _currentSpectatingPlayerIndex++;
                            CurrentSpectatingPlayer = null;
                        }

                        if (CurrentSpectatingPlayer != null)
                        {
                            var center = new Point((int)(res.Width / 2), (int)(res.Height / 2));

                            new UIResText("Now spectating:~n~" + CurrentSpectatingPlayer.Name,
                                          new Point(center.X, (int)(res.Height - 200)), 0.4f, Color.White, GTA.UI.Font.ChaletLondon,
                                          UIResText.Alignment.Centered)
                            {
                                Outline = true,
                            }.Draw();

                            new Sprite("mparrow", "mp_arrowxlarge", new Point(center.X - 264, (int)(res.Height - 232)), new Size(64, 128), 180f, Color.White).Draw();
                            new Sprite("mparrow", "mp_arrowxlarge", new Point(center.X + 200, (int)(res.Height - 232)), new Size(64, 128)).Draw();
                        }
                    }
                }

                _lastSpectating = IsSpectating;

                _lastKilled = killed;

                var collection = new CallCollection();

                collection.Call(Hash.SET_RANDOM_TRAINS, 0);
                collection.Call(Hash.CAN_CREATE_RANDOM_COPS, false);
                DEBUG_STEP = 29;
                collection.Call(Hash.SET_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME, 0f);
                collection.Call(Hash.SET_VEHICLE_POPULATION_BUDGET, 0);
                collection.Call(Hash.SET_PED_POPULATION_BUDGET, 0);
                collection.Call(Hash.SUPPRESS_SHOCKING_EVENTS_NEXT_FRAME);
                collection.Call(Hash.SUPPRESS_AGITATION_EVENTS_NEXT_FRAME);
                collection.Call(Hash.SET_RANDOM_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME, 0f);
                collection.Call(Hash.SET_PARKED_VEHICLE_DENSITY_MULTIPLIER_THIS_FRAME, 0f);
                collection.Call(Hash.SET_NUMBER_OF_PARKED_VEHICLES, -1);
                collection.Call(Hash.SET_ALL_LOW_PRIORITY_VEHICLE_GENERATORS_ACTIVE, false);
                collection.Call(Hash.SET_FAR_DRAW_VEHICLES, false);
                collection.Call(Hash.DESTROY_MOBILE_PHONE);
                collection.Call((Hash)0x015C49A93E3E086E, true);
                collection.Call(Hash.SET_PED_DENSITY_MULTIPLIER_THIS_FRAME, 0f);
                collection.Call(Hash.SET_SCENARIO_PED_DENSITY_MULTIPLIER_THIS_FRAME, 0f, 0f);
                collection.Call(Hash.SET_CAN_ATTACK_FRIENDLY, Game.Player.Character, true, true);
                collection.Call(Hash.SET_PED_CAN_BE_TARGETTED, Game.Player.Character, true);
                collection.Call((Hash)0xF796359A959DF65D, false); // Display distant vehicles
                collection.Call(Hash.SET_AUTO_GIVE_PARACHUTE_WHEN_ENTER_PLANE, Game.Player, false);
                collection.Call((Hash)0xD2B315B6689D537D, Game.Player, false);
                collection.Call(Hash.DISPLAY_CASH, false);
                collection.Execute();
                DEBUG_STEP = 30;


                GameScript.Pulse();

                if ((Game.Player.Character.Position - _lastWaveReset).LengthSquared() > 10000f) // 100f * 100f
                {
                    Function.Call((Hash)0x5E5E99285AE812DB);
                    Function.Call((Hash)0xB96B00E976BE977F, 0f);

                    _lastWaveReset = Game.Player.Character.Position;
                }

                Function.Call((Hash)0x2F9A292AD0A3BD89);
                Function.Call((Hash)0x5F3B7749C112D552);

                if (Function.Call <bool>(Hash.IS_STUNT_JUMP_IN_PROGRESS))
                {
                    Function.Call(Hash.CANCEL_STUNT_JUMP);
                }

                DEBUG_STEP = 31;
                if (Function.Call <int>(Hash.GET_PED_PARACHUTE_STATE, Game.Player.Character) == 2)
                {
                    Game.DisableControlThisFrame(0, Control.Aim);
                    Game.DisableControlThisFrame(0, Control.Attack);
                }
                DEBUG_STEP = 32;


                if (RemoveGameEntities && Util.Util.TickCount - _lastEntityRemoval > 500) // Save ressource
                {
                    _lastEntityRemoval = Util.Util.TickCount;
                    foreach (var entity in World.GetAllPeds())
                    {
                        if (!NetEntityHandler.ContainsLocalHandle(entity.Handle) && entity != Game.Player.Character)
                        {
                            entity.Kill(); //"Some special peds like Epsilon guys or seashark minigame will refuse to despawn if you don't kill them first." - Guad
                            entity.Delete();
                        }
                    }

                    foreach (var entity in World.GetAllVehicles())
                    {
                        if (entity == null)
                        {
                            continue;
                        }
                        var veh = NetEntityHandler.NetToStreamedItem(entity.Handle, useGameHandle: true) as RemoteVehicle;
                        if (veh == null)
                        {
                            entity.Delete();
                            continue;
                        }
                        //TO CHECK
                        if (entity.IsVehicleEmpty() && !VehicleSyncManager.IsInterpolating(entity.Handle) && veh.TraileredBy == 0 && !VehicleSyncManager.IsSyncing(veh) && ((entity.Handle == Game.Player.LastVehicle?.Handle && DateTime.Now.Subtract(LastCarEnter).TotalMilliseconds > 3000) || entity.Handle != Game.Player.LastVehicle?.Handle))
                        {
                            if (entity.Position.DistanceToSquared(veh.Position.ToVector()) > 2f)
                            {
                                entity.PositionNoOffset = veh.Position.ToVector();
                                entity.Quaternion       = veh.Rotation.ToVector().ToQuaternion();
                            }
                        }

                        //veh.Position = entity.Position.ToLVector();
                        //veh.Rotation = entity.Rotation.ToLVector();
                    }
                }
                _whoseturnisitanyways = !_whoseturnisitanyways;

                DEBUG_STEP = 34;
                NetEntityHandler.UpdateAttachments();
                DEBUG_STEP = 35;
                NetEntityHandler.DrawMarkers();
                DEBUG_STEP = 36;
                NetEntityHandler.DrawLabels();
                DEBUG_STEP = 37;
                NetEntityHandler.UpdateMisc();
                DEBUG_STEP = 38;
                NetEntityHandler.UpdateInterpolations();
                DEBUG_STEP = 39;
                WeaponInventoryManager.Update();
                DEBUG_STEP = 40;

                /*string stats = string.Format("{0}Kb (D)/{1}Kb (U), {2}Msg (D)/{3}Msg (U)", _bytesReceived / 1000,
                 *  _bytesSent / 1000, _messagesReceived, _messagesSent);
                 */
                //GTA.UI.Screen.ShowSubtitle(stats);


                PedThread.OnTick("thisaintnullnigga", e);

                DebugInfo.Draw();

                //Thread calcucationThread = new Thread(Work);
                //calcucationThread.IsBackground = true;
                //calcucationThread.Start();

                lock (_threadJumping)
                {
                    if (_threadJumping.Any())
                    {
                        Action action = _threadJumping.Dequeue();
                        if (action != null)
                        {
                            action.Invoke();
                        }
                    }
                }
                DEBUG_STEP = 41;
            }
            catch (Exception ex) // Catch any other exception. (can prevent crash)
            {
                LogManager.LogException(ex, "MAIN OnTick: STEP : " + DEBUG_STEP);
            }
        }
Пример #20
0
        private void DisplayMeleeAnimation()
        {
            var currentTime = Function.Call <float>(Hash.GET_ENTITY_ANIM_CURRENT_TIME, Character,
                                                    lastMeleeAnim.Split()[0], lastMeleeAnim.Split()[1]);

            //UpdatePlayerPedPos();
            Ped PlayerChar = Game.Player.Character;

            if (!meleeSwingDone && CurrentWeapon != unchecked ((int)WeaponHash.Unarmed))
            {
                var gunEntity = Function.Call <Prop>((Hash)0x3B390A939AF0B5FC, Character);
                if (gunEntity != null)
                {
                    gunEntity.Model.GetDimensions(out Vector3 min, out Vector3 max);
                    var start = gunEntity.GetOffsetInWorldCoords(min);
                    var end   = gunEntity.GetOffsetInWorldCoords(max);
                    var ray   = World.RaycastCapsule(start, end, (int)Math.Abs(end.X - start.X), IntersectOptions.Peds1, Character);
                    //Function.Call(Hash.DRAW_LINE, start.X, start.Y, start.Z, end.X, end.Y, end.Z, 255, 255, 255, 255);
                    if (ray.DidHit && ray.DidHitEntity && ray.HitEntity.Handle == PlayerChar.Handle)
                    {
                        LocalHandle them = new LocalHandle(Character.Handle, HandleType.GameHandle);
                        JavascriptHook.InvokeCustomEvent(api => api.invokeonLocalPlayerMeleeHit(them, CurrentWeapon));

                        if (!Main.NetEntityHandler.LocalCharacter.IsInvincible)
                        {
                            PlayerChar.ApplyDamage(25);
                        }

                        meleeSwingDone = true;
                        meleeSwingEnd  = false;
                    }
                }
            }
            else if (!meleeSwingDone && CurrentWeapon == unchecked ((int)WeaponHash.Unarmed))
            {
                var rightfist = Character.GetBonePosition((int)Bone.IK_R_Hand);
                var start     = rightfist - new Vector3(0, 0, 0.5f);
                var end       = rightfist + new Vector3(0, 0, 0.5f);
                var ray       = World.RaycastCapsule(start, end, (int)Math.Abs(end.X - start.X), IntersectOptions.Peds1, Character);
                if (ray.DidHit && ray.DidHitEntity && ray.HitEntity.Handle == PlayerChar.Handle)
                {
                    LocalHandle them = new LocalHandle(Character.Handle, HandleType.GameHandle);
                    JavascriptHook.InvokeCustomEvent(api =>
                                                     api.invokeonLocalPlayerMeleeHit(them, CurrentWeapon));
                    if (!Main.NetEntityHandler.LocalCharacter.IsInvincible)
                    {
                        PlayerChar.ApplyDamage(25);
                    }
                    meleeSwingDone = true;
                    meleeSwingEnd  = false;
                }
            }

            if (currentTime >= 0.95f)
            {
                lastMeleeAnim  = null;
                meleeSwingDone = false;
                meleeSwingEnd  = false;
            }

            if (currentTime >= meleeanimationend)
            {
                if (lastMeleeAnim != null)
                {
                    Character.Task.ClearAnimation(lastMeleeAnim.Split()[0], lastMeleeAnim.Split()[1]);
                }
                lastMeleeAnim  = null;
                meleeSwingDone = false;
                meleeSwingEnd  = true;
            }
        }
Пример #21
0
        public static void InvokeEvents(object sender, EventArgs e)
        {
            var player = Game.Player.Character;

            #region invokeonLocalPlayerShoot
            if (player != null && player.IsShooting)
            {
                JavascriptHook.InvokeCustomEvent(api => api?.invokeonLocalPlayerShoot((int)(player.Weapons.Current?.Hash ?? 0), Main.RaycastEverything(new Vector2(0, 0)).ToLVector()));
            }
            #endregion

            //#region invokeonPlayerRespawn
            var hasRespawned = (Function.Call <int>(Hash.GET_TIME_SINCE_LAST_DEATH) < 8000 &&
                                Function.Call <int>(Hash.GET_TIME_SINCE_LAST_DEATH) != -1 &&
                                Game.Player.CanControlCharacter);

            if (hasRespawned && !_lastDead)
            {
                _lastDead = true;
                var msg = Main.Client.CreateMessage();
                msg.Write((byte)PacketType.PlayerRespawned);
                Main.Client.SendMessage(msg, NetDeliveryMethod.ReliableOrdered, (int)ConnectionChannel.SyncEvent);

                JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerRespawn());

                if (Main.Weather != null)
                {
                    Function.Call(Hash.SET_WEATHER_TYPE_NOW_PERSIST, Main.Weather);
                }
                if (Main.Time.HasValue)
                {
                    World.CurrentDayTime = new TimeSpan(Main.Time.Value.Hours, Main.Time.Value.Minutes, 00);
                }

                Function.Call(Hash.PAUSE_CLOCK, true);

                var us = Main.NetEntityHandler.EntityToStreamedItem(Game.Player.Character.Handle);

                Main.NetEntityHandler.ReattachAllEntities(us, true);
                foreach (
                    var source in
                    Main.NetEntityHandler.ClientMap.Values.Where(
                        item => item is RemoteParticle && ((RemoteParticle)item).EntityAttached == us.RemoteHandle)
                    .Cast <RemoteParticle>())
                {
                    Main.NetEntityHandler.StreamOut(source);
                    Main.NetEntityHandler.StreamIn(source);
                }
            }

            var pHealth = player.Health;
            var pArmor  = player.Armor;
            var pGun    = player.Weapons.Current?.Hash ?? WeaponHash.Unarmed;
            var pModel  = player.Model.Hash;

            if (pHealth != _lastPlayerHealth)
            {
                int test = _lastPlayerHealth;
                JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerHealthChange(test));
            }

            if (pArmor != _lastPlayerArmor)
            {
                int test = _lastPlayerArmor;
                JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerArmorChange(test));
            }

            if (pGun != _lastPlayerWeapon)
            {
                WeaponHash test = _lastPlayerWeapon;
                JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerWeaponSwitch((int)test));
            }

            if (pModel != (int)_lastPlayerModel)
            {
                PedHash test = _lastPlayerModel;
                JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerModelChange((int)test));
            }

            _lastPlayerHealth = pHealth;
            _lastPlayerArmor  = pArmor;
            _lastPlayerWeapon = pGun;
            _lastPlayerModel  = (PedHash)pModel;

            _lastDead = hasRespawned;

            var killed = Game.Player.Character.IsDead;
            if (killed && !_lastKilled)
            {
                var msg = Main.Client.CreateMessage();
                msg.Write((byte)PacketType.PlayerKilled);
                var killer = Function.Call <int>(Hash.GET_PED_SOURCE_OF_DEATH, Game.Player.Character);
                var weapon = Function.Call <int>(Hash.GET_PED_CAUSE_OF_DEATH, Game.Player.Character);

                var killerEnt = Main.NetEntityHandler.EntityToNet(killer);
                msg.Write(killerEnt);
                msg.Write(weapon);

                Main.Client.SendMessage(msg, NetDeliveryMethod.ReliableOrdered, (int)ConnectionChannel.SyncEvent);

                JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerDeath(new LocalHandle(killer), weapon));

                //TODO: ADD OPTION TO ENABLE IT
                NativeUI.BigMessageThread.MessageInstance.ShowColoredShard("WASTED", "", HudColor.HUD_COLOUR_BLACK, HudColor.HUD_COLOUR_RED, 7000);
                Function.Call(Hash.REQUEST_SCRIPT_AUDIO_BANK, "HUD_MINI_GAME_SOUNDSET", true);
                Function.Call(Hash.PLAY_SOUND_FRONTEND, -1, "CHECKPOINT_NORMAL", "HUD_MINI_GAME_SOUNDSET");
            }

            _lastKilled = killed;

            if (player.CurrentVehicle != null)
            {
                var playerCar    = player.CurrentVehicle;
                var netPlayerCar = 0;


                RemoteVehicle cc = null;

                //invokeonVehicleHealthChange
                //invokeonVehicleWindowSmash
                #region invokeonVehicleDoorBreak
                if ((netPlayerCar = Main.NetEntityHandler.EntityToNet(playerCar.Handle)) != 0)
                {
                    var item = Main.NetEntityHandler.NetToStreamedItem(netPlayerCar) as RemoteVehicle;

                    if (item != null)
                    {
                        var lastHealth      = item.Health;
                        var lastDamageModel = item.DamageModel;

                        item.Position    = playerCar.Position.ToLVector();
                        item.Rotation    = playerCar.Rotation.ToLVector();
                        item.Health      = playerCar.EngineHealth;
                        item.IsDead      = playerCar.IsDead;
                        item.DamageModel = playerCar.GetVehicleDamageModel();

                        if (lastHealth != playerCar.EngineHealth)
                        {
                            JavascriptHook.InvokeCustomEvent(api => api?.invokeonVehicleHealthChange((int)lastHealth));
                        }

                        if (playerCar.IsEngineRunning ^ !PacketOptimization.CheckBit(item.Flag, EntityFlag.EngineOff))
                        {
                            playerCar.IsEngineRunning = !PacketOptimization.CheckBit(item.Flag, EntityFlag.EngineOff);
                        }

                        if (lastDamageModel != null)
                        {
                            if (lastDamageModel.BrokenWindows != item.DamageModel.BrokenWindows)
                            {
                                for (var i = 0; i < 8; i++)
                                {
                                    if (((lastDamageModel.BrokenWindows ^ item.DamageModel.BrokenWindows) & 1 << i) == 0)
                                    {
                                        continue;
                                    }
                                    var i1 = i;
                                    JavascriptHook.InvokeCustomEvent(api => api?.invokeonVehicleWindowSmash(i1));
                                }
                            }

                            if (lastDamageModel.BrokenDoors != item.DamageModel.BrokenDoors)
                            {
                                for (var i = 0; i < 8; i++)
                                {
                                    if (((lastDamageModel.BrokenDoors ^ item.DamageModel.BrokenDoors) & 1 << i) == 0)
                                    {
                                        continue;
                                    }
                                    var i1 = i;
                                    JavascriptHook.InvokeCustomEvent(api => api?.invokeonVehicleDoorBreak(i1));
                                }
                            }
                        }
                    }

                    cc = item;
                }
                #endregion

                #region invokeonPlayerExitVehicle
                if (playerCar != _lastPlayerCar)
                {
                    if (_lastPlayerCar != null)
                    {
                        var c = Main.NetEntityHandler.EntityToStreamedItem(_lastPlayerCar.Handle) as RemoteVehicle;

                        if (Main.VehicleSyncManager.IsSyncing(c))
                        {
                            _lastPlayerCar.IsInvincible = c?.IsInvincible ?? false;
                        }
                        else
                        {
                            _lastPlayerCar.IsInvincible = true;
                        }

                        if (c != null)
                        {
                            Function.Call(Hash.SET_VEHICLE_ENGINE_ON, _lastPlayerCar, !PacketOptimization.CheckBit(c.Flag, EntityFlag.EngineOff), true, true);
                        }

                        var h  = _lastPlayerCar.Handle;
                        var lh = new LocalHandle(h);
                        JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerExitVehicle(lh));
                        _lastVehicleSiren = false;
                        _lastPlayerCar    = null;
                    }

                    //invokeonPlayerEnterVehicle
                    if (!Main.NetEntityHandler.ContainsLocalHandle(playerCar.Handle))
                    {
                        playerCar.Delete();
                        playerCar = null;
                    }
                    else
                    {
                        playerCar.IsInvincible = cc?.IsInvincible ?? false;

                        var handle = new LocalHandle(playerCar.Handle);
                        JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerEnterVehicle(handle));
                        LastCarEnter   = DateTime.Now;
                        _lastPlayerCar = playerCar;
                    }
                }
                #endregion

                #region invokeonVehicleSirenToggle
                if (Util.Util.GetResponsiblePed(playerCar, player).Handle != 0)
                {
                    playerCar.IsInvincible = cc?.IsInvincible ?? false;
                }
                else
                {
                    playerCar.IsInvincible = true;
                }

                var siren = playerCar.IsSirenActive;

                if (siren != _lastVehicleSiren)
                {
                    JavascriptHook.InvokeCustomEvent(api => api?.invokeonVehicleSirenToggle());
                }

                _lastVehicleSiren = siren;
                #endregion
            }
            else
            {
                if (_lastPlayerCar != null)
                {
                    var c = Main.NetEntityHandler.EntityToStreamedItem(_lastPlayerCar.Handle) as RemoteVehicle;

                    if (Main.VehicleSyncManager.IsSyncing(c))
                    {
                        _lastPlayerCar.IsInvincible = c?.IsInvincible ?? false;
                    }
                    else
                    {
                        _lastPlayerCar.IsInvincible = true;
                    }

                    if (c != null)
                    {
                        Function.Call(Hash.SET_VEHICLE_ENGINE_ON, _lastPlayerCar, !PacketOptimization.CheckBit(c.Flag, EntityFlag.EngineOff), true, true);
                    }

                    var h  = _lastPlayerCar.Handle;
                    var lh = new LocalHandle(h);
                    JavascriptHook.InvokeCustomEvent(api => api?.invokeonPlayerExitVehicle(lh));
                    _lastVehicleSiren = false;
                    _lastPlayerCar    = null;
                }
            }
        }
Пример #22
0
 public bool isPed(LocalHandle ent)
 {
     return(Function.Call <bool>(Hash.IS_ENTITY_A_PED, ent.Value));
 }
Пример #23
0
 public void setPlayerHealth(LocalHandle ped, int health)
 {
     new Ped(ped.Value).Health = health;
 }
Пример #24
0
 public bool isProp(LocalHandle ent)
 {
     return(Function.Call <bool>(Hash.IS_ENTITY_AN_OBJECT, ent.Value));
 }
Пример #25
0
 public void TestTargetsProcess()
 {
     Assert.IsTrue(LocalHandle.TargetsProcess(Current.Id));
 }