private void setRecoil(ItemGunAsset asset, float maxX, float maxY, float minX, float minY)
 {
     asset.recoilMax_x = maxX;
     asset.recoilMax_y = maxY;
     asset.recoilMin_x = minX;
     asset.recoilMin_y = minY;
 }
        public ushort GetMagId(UnturnedPlayer player, ItemGunAsset gun, string[] command)
        {
            ushort magId = 0;

            if (command.Length == 2 || command.Length == 1)
            {
                if (command.Length == 1)
                {
                    if (command[0].ToLower() == "c")
                    {
                        magId = player.Player.equipment.state[8];
                    }
                }
                else if (command.Length == 2)
                {
                    if (command[1].ToLower() == "c")
                    {
                        magId = player.Player.equipment.state[8];
                    }
                }
            }

            if (magId == 0 || UnturnedItems.GetItemAssetById(magId).type != EItemType.MAGAZINE)
            {
                magId = gun.getMagazineID();
            }

            return(magId);
        }
Exemple #3
0
        //Todo: Find better method for this, isn't 100%, kinda big
        public void UpdateFirearm(ItemGunAsset ass)
        {
            if (ass.recoilMax_y == 0f && ass.shakeMax_x == 0f)
            {
                return;
            }

            //No Recoil
            ass.recoilMax_x = 0f;
            ass.recoilMax_y = 0f;
            ass.recoilMin_x = 0f;
            ass.recoilMin_y = 0f;

            //No Shake
            ass.shakeMax_x = 0f;
            ass.shakeMax_y = 0f;
            ass.shakeMax_z = 0f;
            ass.shakeMin_x = 0f;
            ass.shakeMin_y = 0f;
            ass.shakeMin_z = 0f;

            //No Spread
            ass.spreadAim = 0f;
            ass.spreadHip = 0f;
            PlayerUI.updateCrosshair(0f);

            //Shake recovery
            ass.recover_x = 0f;
            ass.recover_y = 0f;
        }
    public static List <Vector3> PlotTrajectory(UseableGun gun, out RaycastHit hit, int maxSteps = 255)
    {
        hit = default(RaycastHit);
        Transform      transform        = (OptimizationVariables.MainPlayer.look.perspective == EPlayerPerspective.FIRST) ? OptimizationVariables.MainPlayer.look.aim : OptimizationVariables.MainCam.transform;
        Vector3        vector           = transform.position;
        Vector3        forward          = transform.forward;
        ItemGunAsset   equippedGunAsset = gun.equippedGunAsset;
        float          num         = equippedGunAsset.ballisticDrop;
        Attachments    attachments = (Attachments)TrajectoryComponent.thirdAttachments.GetValue(gun);
        List <Vector3> list        = new List <Vector3>
        {
            vector
        };
        bool flag = ((attachments != null) ? attachments.barrelAsset : null) != null;

        if (flag)
        {
            num *= attachments.barrelAsset.ballisticDrop;
        }
        for (int i = 1; i < maxSteps; i++)
        {
            vector    += forward * equippedGunAsset.ballisticTravel;
            forward.y -= num;
            forward.Normalize();
            bool flag2 = Physics.Linecast(list[i - 1], vector, out hit, RayMasks.DAMAGE_CLIENT);
            if (flag2)
            {
                list.Add(hit.point);
                break;
            }
            list.Add(vector);
        }
        return(list);
    }
Exemple #5
0
        //Todo: Find better method for this, isn't 100%, kinda big
        public void UpdateFirearm(ItemGunAsset ass)
        {
            if (ass.recoilMax_y == 0f && ass.shakeMax_x == 0f)
            {
                return;
            }

            //No Recoil
            ass.recoilMax_x = 0f;
            ass.recoilMax_y = 0f;
            ass.recoilMin_x = 0f;
            ass.recoilMin_y = 0f;

            //No Shake
            ass.shakeMax_x = 0f;
            ass.shakeMax_y = 0f;
            ass.shakeMax_z = 0f;
            ass.shakeMin_x = 0f;
            ass.shakeMin_y = 0f;
            ass.shakeMin_z = 0f;

            //Shake recovery
            ass.recover_x = 0f;
            ass.recover_y = 0f;
        }
 private void setShake(ItemGunAsset asset, float maxX, float maxY, float maxZ, float minX, float minY, float minZ)
 {
     asset.shakeMax_x = maxX;
     asset.shakeMax_y = maxY;
     asset.shakeMax_z = maxZ;
     asset.shakeMin_x = minX;
     asset.shakeMin_y = minY;
     asset.shakeMin_z = minZ;
 }
Exemple #7
0
        public void OnGUI()
        {
            ItemGunAsset gun = (ItemGunAsset)Player.player.equipment.asset;

            if (MenuGUI.instance.showGunRange && gun != null && Provider.isConnected && !Provider.isLoading)
            {
                GunInfoWin = GUILayout.Window(73964, GunInfoWin, GunInfoWindow, "Weapon Info");
            }
        }
        public void Update()
        {
            if (Provider.isConnected && !Provider.isLoading)
            {
                if (Player.player?.equipment?.asset is ItemGunAsset)
                {
                    ItemGunAsset gun = (ItemGunAsset)Player.player?.equipment?.asset;

                    if (!SpreadBackup.ContainsKey(gun.id))
                    {
                        SpreadBackup.Add(gun.id, gun.spreadHip);
                    }

                    if (G.Settings.WeaponOptions.RemoveBurstDelay || G.Settings.WeaponOptions.RemoveHammerDelay || G.Settings.WeaponOptions.InstantReload)
                    {
                        Player.player.equipment.isBusy = false;
                    }
                    if (G.Settings.WeaponOptions.RemoveHammerDelay)
                    {
                        Player.player.equipment.useable.GetType().GetField("isHammering", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(Player.player.equipment.useable, false);
                    }
                    if (G.Settings.WeaponOptions.RemoveHammerDelay)
                    {
                        Player.player.equipment.useable.GetType().GetField("needsRechamber", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(Player.player.equipment.useable, false);
                    }
                    if (G.Settings.WeaponOptions.InstantReload)
                    {
                        Player.player.equipment.useable.GetType().GetField("reloadTime", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(Player.player.equipment.useable, 0f);
                    }

                    if (G.Settings.WeaponOptions.NoSpread)
                    {
                        gun.spreadAim = 0f;
                        gun.spreadHip = 0f;
                    }
                    if (G.BeingSpied || !G.Settings.WeaponOptions.NoSpread) // revert crosshair on spy
                    {
                        SpreadBackup.TryGetValue(gun.id, out var backupspread);
                        gun.spreadHip = backupspread;
                        gun.spreadAim = backupspread;
                    }
                    typeof(UseableGun).GetMethod("updateCrosshair", BindingFlags.NonPublic | BindingFlags.Instance).Invoke(Player.player.equipment.useable, null);
                    if (G.Settings.WeaponOptions.NoRecoil)
                    {
                        gun.recoilMax_x = 0f;
                        gun.recoilMax_y = 0f;
                        gun.recoilMin_x = 0f;
                        gun.recoilMin_y = 0f;
                    }

                    if (G.Settings.WeaponOptions.NoSway)
                    {
                        Player.player.animator.viewSway = Vector3.zero;
                    }
                }
            }
        }
        //Calculate bullet drop to a point
        //BUG: Drop will be more innacurate the higher the slope to target
        //Rotation in the math maybe??
        public float DropCalc(Vector3 point)
        {
            float treturn = 0f;

            if (Vector3.Distance(point, Player.player.look.aim.position) < 5f)
            {
                return(0f);
            }

            ItemGunAsset firearm = (ItemGunAsset)Player.player.equipment.asset;

            Quaternion quaternion    = Quaternion.LookRotation(point - Player.player.look.transform.position, Player.player.look.transform.up);
            Vector3    targetForward = quaternion * Vector3.forward;

            BulletInfo bulletInfo = new BulletInfo();

            bulletInfo.pos = Player.player.look.transform.position;
            bulletInfo.dir = targetForward.normalized;

            float num = firearm.ballisticDrop;

            bulletInfo.barrelAsset = Player.player.equipment.thirdModel.gameObject.GetComponent <Attachments>().barrelAsset;
            if (bulletInfo.barrelAsset != null)
            {
                num *= bulletInfo.barrelAsset.ballisticDrop;
            }

            int ticker = 0;

            while (++ticker < firearm.ballisticSteps)
            {
                bulletInfo.pos   += bulletInfo.dir * firearm.ballisticTravel;
                bulletInfo.dir.y -= num;
                bulletInfo.dir.Normalize();

                if (Vector3.Distance(
                        new Vector3(point.x, 0f, point.z),
                        new Vector3(bulletInfo.pos.x, 0f, bulletInfo.pos.z))
                    < firearm.ballisticTravel
                    )
                {
                    treturn = bulletInfo.pos.y - point.y;
                    break;
                }
            }

            if (treturn < 0)
            {
                treturn -= treturn * 2;
            }
            else
            {
                treturn = 0f;
            }

            return(treturn);
        }
Exemple #10
0
        public void Update()
        {
            if (Provider.isConnected && !Provider.isLoading)
            {
                ItemGunAsset gun = (ItemGunAsset)Player.player.equipment.asset;
                if (gun != null)
                {
                    Player.player.equipment.isBusy = false;
                    Player.player.equipment.useable.GetType().GetField("isFired", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(Player.player.equipment.useable, false);
                    Player.player.equipment.useable.GetType().GetField("isHammering", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(Player.player.equipment.useable, false);
                    Player.player.equipment.useable.GetType().GetField("needsRechamber", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(Player.player.equipment.useable, false);
                    Player.player.equipment.useable.GetType().GetField("reloadTime", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(Player.player.equipment.useable, 0f);
                    gun.hasAuto = true;

                    if (MenuGUI.instance.noSpread && Player.player.equipment.asset is ItemGunAsset)
                    {
                        gun.spreadAim = 0f;
                        gun.spreadHip = 0f;
                        PlayerUI.disableCrosshair();
                        PlayerUI.enableDot();
                    }
                    else
                    {
                        PlayerUI.enableCrosshair();
                    }

                    if (MenuGUI.instance.noRecoil && Player.player.equipment.asset is ItemGunAsset)
                    {
                        gun.recoilMax_x = 0f;
                        gun.recoilMax_y = 0f;
                        gun.recoilMin_x = 0f;
                        gun.recoilMin_y = 0f;
                    }

                    if (MenuGUI.instance.noSway && Player.player.equipment.asset is ItemGunAsset)
                    {
                        gun.shakeMax_x = 0f;
                        gun.shakeMax_y = 0f;
                        gun.shakeMax_z = 0f;
                        gun.shakeMin_x = 0f;
                        gun.shakeMin_y = 0f;
                        gun.shakeMin_z = 0f;
                        MenuGUI.instance.alwaysBreath   = true;
                        Player.player.animator.viewSway = Vector3.zero;
                        //Player.player.equipment.GetType().GetField("prim", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(Player.player.equipment, true);
                    }
                }
                else
                {
                    if (MenuGUI.instance.noSpread)
                    {
                        PlayerUI.enableDot();
                    }
                }
            }
        }
Exemple #11
0
        public void Update()
        {
            if (tool_ToolZ.getLocalPlayer().equipment.asset is ItemGunAsset)
            {
                ItemGunAsset gun = (ItemGunAsset)tool_ToolZ.getLocalPlayer().equipment.asset;
                if (nospread)
                {
                    if (!isBackupAsset(gun))
                    {
                        backups_Asset.Add(new GunAssetInfo(gun));
                    }
                    gun.GetType().GetField("_spreadAim", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(gun, 0f);
                    gun.GetType().GetField("_spreadHip", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(gun, 0f);
                }
                if (norecoil)
                {
                    if (!isBackupAsset(gun))
                    {
                        backups_Asset.Add(new GunAssetInfo(gun));
                    }
                    gun.GetType().GetField("_recoilMax_x", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(gun, 0f);
                    gun.GetType().GetField("_recoilMax_y", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(gun, 0f);
                    gun.GetType().GetField("_recoilMin_x", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(gun, 0f);
                    gun.GetType().GetField("_recoilMin_y", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(gun, 0f);
                }

                if (!nospread)
                {
                    if (isBackupAsset(gun))
                    {
                        GunAssetInfo back = getGunAsset(gun);
                        gun.GetType().GetField("_recoilMax_x", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(gun, back.recoilMax_x);
                        gun.GetType().GetField("_recoilMax_y", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(gun, back.recoilMax_y);
                        gun.GetType().GetField("_recoilMin_x", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(gun, back.recoilMin_x);
                        gun.GetType().GetField("_recoilMin_y", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(gun, back.recoilMin_y);
                    }
                }
                if (!norecoil)
                {
                    if (isBackupAsset(gun))
                    {
                        GunAssetInfo back = getGunAsset(gun);
                        gun.GetType().GetField("_spreadAim", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(gun, back.spreadAim);
                        gun.GetType().GetField("_spreadHip", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(gun, back.spreadHip);
                    }
                }
            }
            if (tool_ToolZ.getLocalPlayer().equipment.useable is UseableGun)
            {
                UseableGun gun = (UseableGun)tool_ToolZ.getLocalPlayer().equipment.useable;
                if (rapidfire)
                {
                    gun.GetType().GetField("firemode", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(gun, EFiremode.AUTO);
                }
            }
        }
Exemple #12
0
        void GunInfoWindow(int winid)
        {
            string       s   = "";
            ItemGunAsset gun = (ItemGunAsset)Player.player.equipment.asset;

            if (gun != null && Provider.isConnected && !Provider.isLoading)
            {
                s += gun.range.ToString();
            }
            GUILayout.Label("Range: " + s);
            GUI.DragWindow();
        }
        // Token: 0x06000095 RID: 149 RVA: 0x00006AF4 File Offset: 0x00004CF4
        public static bool GenerateRaycast(out RaycastInfo info)
        {
            ItemGunAsset itemGunAsset = OptimizationVariables.MainPlayer.equipment.asset as ItemGunAsset;
            float        num          = (itemGunAsset != null) ? itemGunAsset.range : 15.5f;

            info = RaycastUtilities.GenerateOriginalRaycast(new Ray(OptimizationVariables.MainPlayer.look.aim.position, OptimizationVariables.MainPlayer.look.aim.forward), num, RayMasks.DAMAGE_CLIENT);
            bool flag = RaycastOptions.EnablePlayerSelection && RaycastUtilities.TargetedPlayer != null;

            if (flag)
            {
                GameObject gameObject = RaycastUtilities.TargetedPlayer.gameObject;
                bool       flag2      = true;
                Vector3    position   = OptimizationVariables.MainPlayer.look.aim.position;
                bool       flag3      = Vector3.Distance(position, gameObject.transform.position) > num;
                if (flag3)
                {
                    flag2 = false;
                }
                Vector3 point;
                bool    flag4 = !SphereUtilities.GetRaycast(gameObject, position, out point);
                if (flag4)
                {
                    flag2 = false;
                }
                bool flag5 = flag2;
                if (flag5)
                {
                    info = RaycastUtilities.GenerateRaycast(gameObject, point, info.collider);
                    return(true);
                }
                bool onlyShootAtSelectedPlayer = RaycastOptions.OnlyShootAtSelectedPlayer;
                if (onlyShootAtSelectedPlayer)
                {
                    return(false);
                }
            }
            GameObject @object;
            Vector3    point2;
            bool       targetObject = RaycastUtilities.GetTargetObject(RaycastUtilities.Objects, out @object, out point2, (double)num);
            bool       result;

            if (targetObject)
            {
                info   = RaycastUtilities.GenerateRaycast(@object, point2, info.collider);
                result = true;
            }
            else
            {
                result = false;
            }
            return(result);
        }
        public static float GetGunDistance()
        {
            ItemGunAsset gun = (ItemGunAsset)Player.player.equipment.asset;

            if (gun != null)
            {
                return(gun.range);
            }
            else
            {
                return(-1);
            }
        }
        public GunAssetInfo(ItemGunAsset iga)
        {
            recoilMax_x = iga.recoilMax_x;
            recoilMax_y = iga.recoilMax_y;
            recoilMin_x = iga.recoilMin_x;
            recoilMin_y = iga.recoilMin_y;

            spreadAim = iga.spreadAim;
            spreadHip = iga.spreadHip;

            _firerate = iga.firerate;

            hash = iga.hash;
        }
        public void DropMags(ushort ammoAmountToSpawn, IRocketPlayer caller, ItemGunAsset currentWeapon,
                             UnturnedPlayer uPlayer, string[] command)
        {
            UnturnedChat.Say(caller,
                             EasyAmmo.Instance.Translate("dropping_mags", ammoAmountToSpawn.ToString(),
                                                         UnturnedItems.GetItemAssetById(GetMagId(uPlayer, currentWeapon, command)).name,
                                                         GetMagId(uPlayer, currentWeapon, command).ToString()));

            for (int ii = 0; ii < (int)ammoAmountToSpawn; ii++)
            {
                ItemManager.dropItem(new Item(GetMagId(uPlayer, currentWeapon, command), true), uPlayer.Position, true,
                                     true, true);
            }
        }
 // Token: 0x06000292 RID: 658 RVA: 0x00017A44 File Offset: 0x00015C44
 public static void DisableHacks(ItemGunAsset gun)
 {
     gun.recoilMax_x   = WeaponComponent.AssetBackups[gun][0];
     gun.recoilMax_y   = WeaponComponent.AssetBackups[gun][1];
     gun.recoilMin_x   = WeaponComponent.AssetBackups[gun][2];
     gun.recoilMin_y   = WeaponComponent.AssetBackups[gun][3];
     gun.shakeMax_z    = WeaponComponent.AssetBackups[gun][4];
     gun.shakeMin_z    = WeaponComponent.AssetBackups[gun][5];
     gun.shakeMax_x    = WeaponComponent.AssetBackups[gun][6];
     gun.shakeMin_x    = WeaponComponent.AssetBackups[gun][7];
     gun.shakeMax_y    = WeaponComponent.AssetBackups[gun][8];
     gun.shakeMin_y    = WeaponComponent.AssetBackups[gun][9];
     gun.spreadHip     = WeaponComponent.AssetBackups[gun][10];
     gun.ballisticDrop = WeaponComponent.AssetBackups[gun][11];
 }
Exemple #18
0
 public void SpawnMags(ushort ammoAmountToSpawn, IRocketPlayer caller, ItemGunAsset currentWeapon,
                       UnturnedPlayer uPlayer, string[] command)
 {
     if (uPlayer.GiveItem(GetMagId(uPlayer, currentWeapon, command), (byte)ammoAmountToSpawn))
     {
         UnturnedChat.Say(caller,
                          EasyAmmo.Instance.Translate("giving_mags", ammoAmountToSpawn.ToString(),
                                                      UnturnedItems.GetItemAssetById(GetMagId(uPlayer, currentWeapon, command)).name,
                                                      GetMagId(uPlayer, currentWeapon, command).ToString()));
     }
     else
     {
         UnturnedChat.Say(caller, EasyAmmo.Instance.Translate("failed_to_spawn_mags"));
     }
 }
 public static void AddDamage(RaycastInfo ri)
 {
     if (G.Settings.WeaponOptions.DamageIndicators && ri.point != new Vector3(0, 0, 0))
     {
         ItemGunAsset currentGun = Player.player.equipment.asset as ItemGunAsset;
         if (currentGun != null && ri.player != null)
         {
             IndicatorObject dmgi = new IndicatorObject
             {
                 HitPos   = ri.point,
                 Damage   = Mathf.FloorToInt(DamageTool.getPlayerArmor(ri.limb, ri.player) * currentGun.playerDamageMultiplier.multiply(ri.limb)), // big maths
                 ShotTime = DateTime.Now
             };
             DamageIndicators.Add(dmgi);
         }
     }
 }
Exemple #20
0
        public static bool GenerateRaycast(out RaycastInfo info)
        {
            ItemGunAsset currentGun = OptimizationVariables.MainPlayer.equipment.asset as ItemGunAsset;

            float Range = currentGun?.range ?? 15.5f;

            info = GenerateOriginalRaycast(new Ray(OptimizationVariables.MainPlayer.look.aim.position, OptimizationVariables.MainPlayer.look.aim.forward), Range,
                                           RayMasks.DAMAGE_CLIENT);

            if (RaycastOptions.EnablePlayerSelection && TargetedPlayer != null)
            {
                GameObject p          = TargetedPlayer.gameObject;
                bool       shouldFire = true;

                Vector3 aimPos = OptimizationVariables.MainPlayer.look.aim.position;

                if (Vector3.Distance(aimPos, p.transform.position) > Range)
                {
                    shouldFire = false;
                }

                if (!SphereUtilities.GetRaycast(p, aimPos, out Vector3 point))
                {
                    shouldFire = false;
                }

                if (shouldFire)
                {
                    info = GenerateRaycast(p, point, info.collider);
                    return(true);
                }

                if (RaycastOptions.OnlyShootAtSelectedPlayer)
                {
                    return(false);
                }
            }

            if (!GetTargetObject(Objects, out GameObject Object, out Vector3 Point, Range))
            {
                return(false);
            }

            info = GenerateRaycast(Object, Point, info.collider);
            return(true);
        }
Exemple #21
0
 private void attack(ItemAsset asset, float distance)
 {
     if (asset is ItemGunAsset && Provider.mode != EGameMode.EASY && bulletSnap)
     {
         ItemGunAsset iga  = (ItemGunAsset)asset;
         float        drop = distance - iga.ballisticSteps;
         if (drop > 0)
         {
             drop = ((drop / iga.ballisticTravel) * (iga.ballisticDrop + iga.ballisticForce)) + ((distance / iga.ballisticSteps) * (iga.ballisticDrop + iga.ballisticForce));
         }
         else
         {
             drop = 0f;
         }
         Information.player.look.GetType().GetField("_pitch", BindingFlags.Instance | BindingFlags.NonPublic).SetValue(Information.player.look, Information.player.look.pitch - drop);
     }
     Information.player.equipment.GetType().GetField("prim", BindingFlags.NonPublic | BindingFlags.Instance).SetValue(Information.player.equipment, true);
 }
Exemple #22
0
        public WAssetSave(ItemGunAsset asset)
        {
            this.asset = asset;

            recoilMax_x = asset.recoilMax_x;
            recoilMax_y = asset.recoilMax_y;
            recoilMin_x = asset.recoilMin_x;
            recoilMin_y = asset.recoilMin_y;

            spreadAim = asset.spreadAim;
            spreadHip = asset.spreadHip;

            shakeMax_x = asset.shakeMax_x;
            shakeMax_y = asset.shakeMax_y;
            shakeMax_z = asset.shakeMax_z;
            shakeMin_x = asset.shakeMin_x;
            shakeMin_y = asset.shakeMin_y;
            shakeMin_z = asset.shakeMin_z;

            range = asset.range;
        }
Exemple #23
0
        public GunAsset(ItemGunAsset input)
        {
            recoilmaxx = input.recoilMax_x;
            recoilmaxy = input.recoilMax_y;
            recoilminx = input.recoilMin_x;
            recoilminy = input.recoilMin_y;

            spreadaim = input.spreadAim;
            spreadhip = input.spreadHip;

            shakemaxx = input.shakeMax_x;
            shakemaxy = input.shakeMax_y;
            shakemaxz = input.shakeMax_z;
            shakeminx = input.shakeMin_x;
            shakeminy = input.shakeMin_y;
            shakeminz = input.shakeMin_z;

            ballisticforce = input.ballisticForce;
            ballisticdrop  = input.ballisticDrop;

            guid = input.GUID;
        }
Exemple #24
0
        void Update()
        {
            if (Provider.isConnected && !Provider.isLoading)
            {
                if (Input.GetKeyDown(MenuGUI.instance.aimKey))
                {
                    MenuGUI.instance.aimEnabled = true;
                }
                if (MenuGUI.instance.aimOnFire)
                {
                    ItemGunAsset gun = (ItemGunAsset)Player.player.equipment.asset;
                    if (gun != null && !MenuGUI.guiOn)
                    {
                        if (Input.GetKeyDown(KeyCode.Mouse0))
                        {
                            MenuGUI.instance.aimEnabled = true;
                        }
                        if (Input.GetKeyUp(KeyCode.Mouse0))
                        {
                            MenuGUI.instance.aimEnabled = false;
                        }
                    }
                }
                if (Input.GetKeyUp(MenuGUI.instance.aimKey))
                {
                    MenuGUI.instance.aimEnabled = false;
                }

                if (Player.player.life == null || Player.player.life.isDead)
                {
                    MenuGUI.instance.aimEnabled = false;
                }

                if (MenuGUI.instance.aimEnabled)
                {
                    updateAim();
                }
            }
        }
Exemple #25
0
        public decimal GetCost(bool negative, int amount, ItemGunAsset gun, ItemMagazineAsset magazine)
        {
            decimal cost;

            if (EasyAmmo.Instance.Configuration.Instance.ScaleCostByWeaponDamage)
            {
                cost = (decimal)(gun.playerDamageMultiplier.damage * amount) *
                       EasyAmmo.Instance.Configuration.Instance.WeaponDamageCostMultiplier;
            }
            else
            {
                cost = (decimal)(magazine.amount * amount) *
                       EasyAmmo.Instance.Configuration.Instance.PerBulletCostMultiplier;
            }

            if (negative)
            {
                cost = -cost;
            }

            //Logger.Log(cost.ToString());
            return(cost);
        }
    public static bool GenerateRaycast(out RaycastInfo info)
    {
        ItemGunAsset itemGunAsset = OptimizationVariables.MainPlayer.equipment.asset as ItemGunAsset;
        float        num          = (itemGunAsset != null) ? itemGunAsset.range : 15.5f;

        info = RaycastUtilities.GenerateOriginalRaycast(new Ray(OptimizationVariables.MainPlayer.look.aim.position, OptimizationVariables.MainPlayer.look.aim.forward), num, RayMasks.DAMAGE_CLIENT);
        if (RaycastOptions.EnablePlayerSelection && RaycastUtilities.TargetedPlayer != null)
        {
            GameObject gameObject = RaycastUtilities.TargetedPlayer.gameObject;
            bool       flag       = true;
            Vector3    position   = OptimizationVariables.MainPlayer.look.aim.position;
            if (Vector3.Distance(position, gameObject.transform.position) > num)
            {
                flag = false;
            }
            if (!SphereUtilities.GetRaycast(gameObject, position, out Vector3 point))
            {
                flag = false;
            }
            if (flag)
            {
                info = RaycastUtilities.GenerateRaycast(gameObject, point, info.collider);
                return(true);
            }
            if (RaycastOptions.OnlyShootAtSelectedPlayer)
            {
                return(false);
            }
        }

        if (RaycastUtilities.GetTargetObject(RaycastUtilities.Objects, out GameObject @object, out Vector3 point2, num))
        {
            info = RaycastUtilities.GenerateRaycast(@object, point2, info.collider);
            return(true);
        }
        return(false);
    }
Exemple #27
0
 private void setSpread(ItemGunAsset asset, float aim, float hip)
 {
     asset.spreadAim = aim;
     asset.spreadHip = hip;
 }
Exemple #28
0
        internal static void Modify(ItemModification modification)
        {
            ItemAsset asset = (ItemAsset)Assets.find(EAssetType.ITEM, modification.ID);

            if (asset == null)
            {
                LogError("Item ID {0} is invalid.", modification.ID);
                return;
            }

            if (asset.isPro)
            {
                LogError("Item ID {0} is a cosmetic.", modification.ID);
                return;
            }

            if (modification.Height.HasValue || modification.Width.HasValue)
            {
                if (asset is ItemBagAsset)
                {
                    ItemBagAsset bagAsset = asset as ItemBagAsset;
                    if (modification.Width.HasValue)
                    {
                        SetWidth(bagAsset, modification.Width.Value);
                    }
                    if (modification.Height.HasValue)
                    {
                        SetHeight(bagAsset, modification.Height.Value);
                    }
                }
                else
                {
                    LogError("Item ID {0} isn't a clothing item with storage.", modification.ID);
                }
            }

            if (modification.Health.HasValue)
            {
                if (asset is ItemBarricadeAsset)
                {
                    SetHealth(asset as ItemBarricadeAsset, modification.Health.Value);
                }
                else if (asset is ItemStructureAsset)
                {
                    SetHealth(asset as ItemStructureAsset, modification.Health.Value);
                }
                else
                {
                    LogError("Item ID {0} isn't a structure or barricade.", modification.ID);
                }
            }

            if (modification.PlayerDamage.HasValue ||
                modification.PlayerLegMultiplier.HasValue ||
                modification.PlayerArmMultiplier.HasValue ||
                modification.PlayerSpineMultiplier.HasValue ||
                modification.PlayerSkullMultiplier.HasValue ||
                modification.ZombieDamage.HasValue ||
                modification.ZombieLegMultiplier.HasValue ||
                modification.ZombieArmMultiplier.HasValue ||
                modification.ZombieSpineMultiplier.HasValue ||
                modification.ZombieSkullMultiplier.HasValue ||
                modification.AnimalDamage.HasValue ||
                modification.AnimalLegMultiplier.HasValue ||
                modification.AnimalSpineMultiplier.HasValue ||
                modification.AnimalSkullMultiplier.HasValue ||
                modification.BarricadeDamage.HasValue ||
                modification.StructureDamage.HasValue ||
                modification.VehicleDamage.HasValue ||
                modification.ResourceDamage.HasValue ||
                modification.ObjectDamage.HasValue ||
                modification.Invulnerable.HasValue) // Isn't this pretty?
            {
                if (asset is ItemWeaponAsset)
                {
                    ItemWeaponAsset weaponAsset = asset as ItemWeaponAsset;
                    if (modification.PlayerDamage.HasValue)
                    {
                        SetPlayerDamage(weaponAsset, modification.PlayerDamage.Value);
                    }
                    if (modification.PlayerLegMultiplier.HasValue)
                    {
                        SetPlayerLegMultiplier(weaponAsset, modification.PlayerLegMultiplier.Value);
                    }
                    if (modification.PlayerArmMultiplier.HasValue)
                    {
                        SetPlayerArmMultiplier(weaponAsset, modification.PlayerArmMultiplier.Value);
                    }
                    if (modification.PlayerSpineMultiplier.HasValue)
                    {
                        SetPlayerSpineMultiplier(weaponAsset, modification.PlayerSpineMultiplier.Value);
                    }
                    if (modification.PlayerSkullMultiplier.HasValue)
                    {
                        SetPlayerSkullMultiplier(weaponAsset, modification.PlayerSkullMultiplier.Value);
                    }
                    if (modification.ZombieDamage.HasValue)
                    {
                        SetZombieDamage(weaponAsset, modification.ZombieDamage.Value);
                    }
                    if (modification.ZombieLegMultiplier.HasValue)
                    {
                        SetZombieLegMultiplier(weaponAsset, modification.ZombieLegMultiplier.Value);
                    }
                    if (modification.ZombieArmMultiplier.HasValue)
                    {
                        SetZombieArmMultiplier(weaponAsset, modification.ZombieArmMultiplier.Value);
                    }
                    if (modification.ZombieSpineMultiplier.HasValue)
                    {
                        SetZombieSpineMultiplier(weaponAsset, modification.ZombieSpineMultiplier.Value);
                    }
                    if (modification.ZombieSkullMultiplier.HasValue)
                    {
                        SetZombieSkullMultiplier(weaponAsset, modification.ZombieSkullMultiplier.Value);
                    }
                    if (modification.AnimalDamage.HasValue)
                    {
                        SetAnimalDamage(weaponAsset, modification.AnimalDamage.Value);
                    }
                    if (modification.AnimalLegMultiplier.HasValue)
                    {
                        SetAnimalLegMultiplier(weaponAsset, modification.AnimalLegMultiplier.Value);
                    }
                    if (modification.AnimalSpineMultiplier.HasValue)
                    {
                        SetAnimalSpineMultiplier(weaponAsset, modification.AnimalSpineMultiplier.Value);
                    }
                    if (modification.AnimalSkullMultiplier.HasValue)
                    {
                        SetAnimalSkullMultiplier(weaponAsset, modification.AnimalSkullMultiplier.Value);
                    }
                    if (modification.BarricadeDamage.HasValue)
                    {
                        SetBarricadeDamage(weaponAsset, modification.BarricadeDamage.Value);
                    }
                    if (modification.StructureDamage.HasValue)
                    {
                        SetStructureDamage(weaponAsset, modification.StructureDamage.Value);
                    }
                    if (modification.VehicleDamage.HasValue)
                    {
                        SetVehicleDamage(weaponAsset, modification.VehicleDamage.Value);
                    }
                    if (modification.ResourceDamage.HasValue)
                    {
                        SetResourceDamage(weaponAsset, modification.ResourceDamage.Value);
                    }
                    if (modification.ObjectDamage.HasValue)
                    {
                        SetObjectDamage(weaponAsset, modification.ObjectDamage.Value);
                    }
                    if (modification.Invulnerable.HasValue)
                    {
                        SetIsInvulnerable(weaponAsset, modification.Invulnerable.Value);
                    }
                }
                else
                {
                    LogError("Item ID {0} isn't a weapon.", modification.ID);
                }
            }

            if (modification.Caliber.HasValue ||
                modification.Range.HasValue ||
                modification.SpreadAim.HasValue ||
                modification.SpreadHip.HasValue ||
                modification.Muzzle.HasValue)
            {
                if (asset is ItemWeaponAsset)
                {
                    ItemGunAsset gunAsset = asset as ItemGunAsset;
                    if (modification.Caliber.HasValue)
                    {
                        SetCaliber(gunAsset, modification.Caliber.Value);
                    }
                    if (modification.Range.HasValue)
                    {
                        SetRange(gunAsset, modification.Range.Value);
                    }
                    if (modification.SpreadAim.HasValue)
                    {
                        SetSpreadAim(gunAsset, modification.SpreadAim.Value);
                    }
                    if (modification.SpreadHip.HasValue)
                    {
                        SetSpreadHip(gunAsset, modification.SpreadHip.Value);
                    }
                    if (modification.Muzzle.HasValue)
                    {
                        SetMuzzle(gunAsset, modification.Muzzle.Value);
                    }
                }
                else
                {
                    LogError("Item ID {0} isn't a gun.", modification.ID);
                }
            }

            if (modification.Explosion.HasValue)
            {
                if (asset is ItemStructureAsset)
                {
                    SetExplosion(asset as ItemStructureAsset, modification.Explosion.Value);
                }
                else if (asset is ItemBarricadeAsset)
                {
                    SetExplosion(asset as ItemBarricadeAsset, modification.Explosion.Value);
                }
                else if (asset is ItemGunAsset)
                {
                    SetExplosion(asset as ItemGunAsset, modification.Explosion.Value);
                }
                else
                {
                    LogError("Item ID {0} doesn't have an explosion tag.");
                }
            }

            if (modification.BallisticDrop.HasValue ||
                modification.Braked.HasValue ||
                modification.Silenced.HasValue ||
                modification.Volume.HasValue)
            {
                if (asset is ItemBarrelAsset)
                {
                    ItemBarrelAsset barrelAsset = asset as ItemBarrelAsset;
                    if (modification.BallisticDrop.HasValue)
                    {
                        SetBallisticDrop(barrelAsset, modification.BallisticDrop.Value);
                    }
                    if (modification.Braked.HasValue)
                    {
                        SetIsBraked(barrelAsset, modification.Braked.Value);
                    }
                    if (modification.Silenced.HasValue)
                    {
                        SetIsSilenced(barrelAsset, modification.Silenced.Value);
                    }
                    if (modification.Volume.HasValue)
                    {
                        SetVolume(barrelAsset, modification.Volume.Value);
                    }
                }
                else
                {
                    LogError("Item ID {0} isn't a barrel.");
                }
            }
        }
Exemple #29
0
 public static bool SetExplosion(ItemGunAsset asset, ushort explosion)
 {
     asset.explosion = explosion;
     return(true);
 }
Exemple #30
0
 public static bool SetMuzzle(ItemGunAsset asset, ushort muzzle)
 {
     asset.muzzle = muzzle;
     return(true);
 }