コード例 #1
0
 // Token: 0x060009E4 RID: 2532 RVA: 0x00050760 File Offset: 0x0004EB60
 public void OnTriggerEnter(Collider other)
 {
     if (other.isTrigger)
     {
         return;
     }
     if (!Provider.isServer)
     {
         return;
     }
     if (other.CompareTag("Player"))
     {
         if (this.killPlayers)
         {
             Player player = DamageTool.getPlayer(other.transform);
             if (player != null)
             {
                 EPlayerKill eplayerKill;
                 DamageTool.damage(player, this.deathCause, ELimb.SPINE, CSteamID.Nil, Vector3.up, 101f, 1f, out eplayerKill);
             }
         }
     }
     else if (other.CompareTag("Agent"))
     {
         if (this.killZombies || this.killAnimals)
         {
             Zombie zombie = DamageTool.getZombie(other.transform);
             if (zombie != null)
             {
                 if (this.killZombies)
                 {
                     EPlayerKill eplayerKill2;
                     uint        num;
                     DamageTool.damage(zombie, Vector3.up, 65000f, 1f, out eplayerKill2, out num);
                 }
             }
             else if (this.killAnimals)
             {
                 Animal animal = DamageTool.getAnimal(other.transform);
                 if (animal != null)
                 {
                     EPlayerKill eplayerKill3;
                     uint        num2;
                     DamageTool.damage(animal, Vector3.up, 65000f, 1f, out eplayerKill3, out num2);
                 }
             }
         }
     }
     else if (other.CompareTag("Vehicle") && this.killVehicles)
     {
         InteractableVehicle vehicle = DamageTool.getVehicle(other.transform);
         if (vehicle != null && !vehicle.isDead)
         {
             EPlayerKill eplayerKill4;
             DamageTool.damage(vehicle, false, Vector3.zero, false, 65000f, 1f, false, out eplayerKill4);
         }
     }
 }
コード例 #2
0
        public static RaycastInfo OriginalRaycast(Ray ray, float range, int mask)
        {
            RaycastHit hit;

            PhysicsUtility.raycast(ray, out hit, range, mask, QueryTriggerInteraction.UseGlobal);
            RaycastInfo raycastInfo = new RaycastInfo(hit);

            raycastInfo.direction = ray.direction;
            if (raycastInfo.transform != null)
            {
                if (raycastInfo.transform.CompareTag("Barricade"))
                {
                    raycastInfo.transform = DamageTool.getBarricadeRootTransform(raycastInfo.transform);
                }

                else if (raycastInfo.transform.CompareTag("Structure"))
                {
                    raycastInfo.transform = DamageTool.getStructureRootTransform(raycastInfo.transform);
                }

                if (raycastInfo.transform.CompareTag("Enemy"))
                {
                    raycastInfo.player = DamageTool.getPlayer(raycastInfo.transform);
                }

                if (raycastInfo.transform.CompareTag("Zombie"))
                {
                    raycastInfo.zombie = DamageTool.getZombie(raycastInfo.transform);
                }

                if (raycastInfo.transform.CompareTag("Animal"))
                {
                    raycastInfo.animal = DamageTool.getAnimal(raycastInfo.transform);
                }

                raycastInfo.limb = DamageTool.getLimb(raycastInfo.transform);

                if (raycastInfo.transform.CompareTag("Vehicle"))
                {
                    raycastInfo.vehicle = DamageTool.getVehicle(raycastInfo.transform);
                }

                if (raycastInfo.zombie != null && raycastInfo.zombie.isRadioactive)
                {
                    raycastInfo.material = EPhysicsMaterial.ALIEN_DYNAMIC;
                }
                else
                {
                    raycastInfo.material = DamageTool.getMaterial(hit.point, raycastInfo.transform, raycastInfo.collider);
                }
            }
            return(raycastInfo);
        }
コード例 #3
0
ファイル: DT.cs プロジェクト: qq1091192337/MSZ-Aftermath
        public static RaycastInfo raycast(Ray ray, float range, int mask)
        {
            RaycastHit hit;
            int        msk = RayMasks.ENEMY | RayMasks.ENTITY | RayMasks.VEHICLE;

            if (ComponentManager.hack_Weapons.meleeThroughWalls)
            {
                Physics.Raycast(ray, out hit, range, msk);
            }
            else
            {
                Physics.Raycast(ray, out hit, range, mask);
            }
            RaycastInfo raycastInfo = new RaycastInfo(hit);

            raycastInfo.direction = ray.direction;
            if (hit.transform != null)
            {
                if (hit.transform.CompareTag("Enemy"))
                {
                    raycastInfo.player = DamageTool.getPlayer(raycastInfo.transform);
                }
                if (hit.transform.CompareTag("Zombie"))
                {
                    raycastInfo.zombie = DamageTool.getZombie(raycastInfo.transform);
                }
                if (hit.transform.CompareTag("Animal"))
                {
                    raycastInfo.animal = DamageTool.getAnimal(raycastInfo.transform);
                }
                raycastInfo.limb = DamageTool.getLimb(raycastInfo.transform);
                if (hit.transform.CompareTag("Vehicle"))
                {
                    raycastInfo.vehicle = DamageTool.getVehicle(raycastInfo.transform);
                }
                if (raycastInfo.zombie != null && raycastInfo.zombie.isRadioactive)
                {
                    raycastInfo.material = EPhysicsMaterial.ALIEN_DYNAMIC;
                }
                else
                {
                    raycastInfo.material = DamageTool.getMaterial(hit.point, hit.transform, hit.collider);
                }
            }
            return(raycastInfo);
        }
コード例 #4
0
        static bool useHook_patch(InteractableVehicle __instance)
        {
            List <HookInfo> hooked = get_priv_hooked(__instance);

            if (hooked.Count > 0)
            {
                __instance.clearHooked();
                return(false);
            }

            float radius;

            if (!Plugin.TryGetCustomDataFor <float>(__instance.asset.GUID, FieldName, out radius))
            {
                radius = 3f;
            }

            var hook = get_priv_hook(__instance);
            var grab = get_priv_grab();

            int num = Physics.OverlapSphereNonAlloc(hook.position, radius, grab, 67108864);

            for (int i = 0; i < num; i++)
            {
                InteractableVehicle vehicle = DamageTool.getVehicle(grab[i].transform);
                if (!(vehicle == null) && !(vehicle == __instance) && vehicle.isEmpty && !vehicle.isHooked && vehicle.asset.engine != EEngine.TRAIN)
                {
                    HookInfo hookInfo = new HookInfo
                    {
                        target        = vehicle.transform,
                        vehicle       = vehicle,
                        deltaPosition = hook.InverseTransformPoint(vehicle.transform.position),
                        deltaRotation = Quaternion.FromToRotation(hook.forward, vehicle.transform.forward)
                    };
                    hooked.Add(hookInfo);
                    vehicle.isHooked = true;
                    __instance.ignoreCollisionWith(vehicle.vehicleColliders, true);
                }
            }

            set_priv_hooked(hooked, __instance);

            return(false);
        }
コード例 #5
0
        public static RaycastInfo GenerateOriginalRaycast(Ray ray, float range, int mask)
        {
            PhysicsUtility.raycast(ray, out RaycastHit hit, range, mask, QueryTriggerInteraction.UseGlobal);
            RaycastInfo raycastInfo = new RaycastInfo(hit)
            {
                direction = ray.direction
            };

            if (hit.transform == null)
            {
                return(raycastInfo);
            }

            if (raycastInfo.transform.CompareTag("Barricade"))
            {
                raycastInfo.transform = DamageTool.getBarricadeRootTransform(raycastInfo.transform);
            }

            else if (raycastInfo.transform.CompareTag("Structure"))
            {
                raycastInfo.transform = DamageTool.getStructureRootTransform(raycastInfo.transform);
            }

            if (raycastInfo.transform.CompareTag("Enemy"))
            {
                raycastInfo.player = DamageTool.getPlayer(raycastInfo.transform);
            }

            if (raycastInfo.transform.CompareTag("Zombie"))
            {
                raycastInfo.zombie = DamageTool.getZombie(raycastInfo.transform);
            }

            if (raycastInfo.transform.CompareTag("Animal"))
            {
                raycastInfo.animal = DamageTool.getAnimal(raycastInfo.transform);
            }

            raycastInfo.limb = DamageTool.getLimb(raycastInfo.transform);

            if (RaycastOptions.UseCustomLimb)
            {
                raycastInfo.limb = RaycastOptions.TargetLimb;
            }

            else if (RaycastOptions.UseRandomLimb)
            {
                ELimb[] Limbs = (ELimb[])Enum.GetValues(typeof(ELimb));
                raycastInfo.limb = Limbs[MathUtilities.Random.Next(0, Limbs.Length)];
            }

            if (raycastInfo.transform.CompareTag("Vehicle"))
            {
                raycastInfo.vehicle = DamageTool.getVehicle(raycastInfo.transform);
            }

            if (raycastInfo.zombie != null && raycastInfo.zombie.isRadioactive)
            {
                raycastInfo.material = EPhysicsMaterial.ALIEN_DYNAMIC;
            }
            else
            {
                raycastInfo.material = DamageTool.getMaterial(hit.point, raycastInfo.transform, raycastInfo.collider);
            }

            return(raycastInfo);
        }
コード例 #6
0
        // Token: 0x06000094 RID: 148 RVA: 0x000068DC File Offset: 0x00004ADC
        public static RaycastInfo GenerateOriginalRaycast(Ray ray, float range, int mask)
        {
            RaycastHit hit;

            PhysicsUtility.raycast(ray, out hit, range, mask, QueryTriggerInteraction.UseGlobal);
            RaycastInfo raycastInfo = new RaycastInfo(hit);

            raycastInfo.direction = ray.direction;
            bool        flag = !(raycastInfo.transform == null);
            RaycastInfo result;

            if (flag)
            {
                bool flag2 = raycastInfo.transform.CompareTag("Barricade");
                if (flag2)
                {
                    raycastInfo.transform = DamageTool.getBarricadeRootTransform(raycastInfo.transform);
                }
                else
                {
                    bool flag3 = raycastInfo.transform.CompareTag("Structure");
                    if (flag3)
                    {
                        raycastInfo.transform = DamageTool.getStructureRootTransform(raycastInfo.transform);
                    }
                }
                bool flag4 = raycastInfo.transform.CompareTag("Enemy");
                if (flag4)
                {
                    raycastInfo.player = DamageTool.getPlayer(raycastInfo.transform);
                }
                bool flag5 = raycastInfo.transform.CompareTag("Zombie");
                if (flag5)
                {
                    raycastInfo.zombie = DamageTool.getZombie(raycastInfo.transform);
                }
                bool flag6 = raycastInfo.transform.CompareTag("Animal");
                if (flag6)
                {
                    raycastInfo.animal = DamageTool.getAnimal(raycastInfo.transform);
                }
                raycastInfo.limb = DamageTool.getLimb(raycastInfo.transform);
                bool flag7 = !RaycastOptions.UseRandomLimb;
                if (flag7)
                {
                    bool useCustomLimb = RaycastOptions.UseCustomLimb;
                    if (useCustomLimb)
                    {
                        raycastInfo.limb = RaycastOptions.TargetLimb;
                    }
                }
                else
                {
                    ELimb[] array = (ELimb[])Enum.GetValues(typeof(ELimb));
                    raycastInfo.limb = array[MathUtilities.Random.Next(0, array.Length)];
                }
                bool flag8 = raycastInfo.transform.CompareTag("Vehicle");
                if (flag8)
                {
                    raycastInfo.vehicle = DamageTool.getVehicle(raycastInfo.transform);
                }
                else
                {
                    bool flag9 = raycastInfo.zombie != null && raycastInfo.zombie.isRadioactive;
                    if (flag9)
                    {
                        raycastInfo.material = EPhysicsMaterial.ALIEN_DYNAMIC;
                    }
                    else
                    {
                        raycastInfo.material = DamageTool.getMaterial(hit.point, raycastInfo.transform, raycastInfo.collider);
                    }
                }
                bool alwaysHitHead = RaycastOptions.AlwaysHitHead;
                if (alwaysHitHead)
                {
                    raycastInfo.limb = ELimb.SKULL;
                }
                result = raycastInfo;
            }
            else
            {
                result = raycastInfo;
            }
            return(result);
        }
コード例 #7
0
        public static RaycastInfo OV_raycast(Ray ray, float range, int mask)
        {
            ItemWeaponAsset weapon = (ItemWeaponAsset)Player.player.equipment.asset;

            /*if (MenuGUI.instance.LongRangeMelee && weapon == null)
             * {
             *  range = MenuGUI.instance.MeleeRange;
             * }*/
            range = Mathf.Infinity;
            RaycastHit hit;

            PhysicsUtility.raycast(ray, out hit, range, mask, 0);
            RaycastInfo raycastInfo = new RaycastInfo(hit);

            if (MenuGUI.instance.silentAim)
            {
                if (hit.transform == null && Functions.GetDistance(Functions.GetNearestPlayer().transform.position) >= Functions.GetGunDistance())
                {
                    return(raycastInfo);
                }
            }

            if (hit.transform.CompareTag("Zombie"))
            {
                raycastInfo.zombie = DamageTool.getZombie(raycastInfo.transform);
            }
            if (hit.transform.CompareTag("Animal"))
            {
                raycastInfo.animal = DamageTool.getAnimal(raycastInfo.transform);
            }
            raycastInfo.direction = new Vector3(0, MenuGUI.instance.launchAmount, 0);

            if (MenuGUI.instance.silentAim && !hit.transform.CompareTag("Zombie"))
            {
                if (Functions.GetDistFrom(Functions.GetNearestPlayer().transform.position, Player.player.look.aim.position) <= 15.5)
                {
                    raycastInfo.point = Player.player.transform.position;
                }
                else
                {
                    raycastInfo.point = Functions.GetLimbPosition(Functions.GetNearestPlayer().transform, "Skull");
                }
                if (MenuGUI.instance.randomLimb)
                {
                    ELimb[] array = (ELimb[])Enum.GetValues(typeof(ELimb));
                    raycastInfo.limb = array[Random.Next(0, array.Length)];
                }
                else
                {
                    raycastInfo.limb = ELimb.SKULL;
                }
                raycastInfo.player = Functions.GetNearestPlayer();
            }
            else
            {
                raycastInfo.limb = DamageTool.getLimb(hit.transform);
                if (hit.transform.CompareTag("Enemy"))
                {
                    raycastInfo.player = DamageTool.getPlayer(raycastInfo.transform);
                }
            }

            if (hit.transform.CompareTag("Vehicle"))
            {
                raycastInfo.vehicle = DamageTool.getVehicle(raycastInfo.transform);
            }
            if (raycastInfo.zombie != null && raycastInfo.zombie.isRadioactive)
            {
                raycastInfo.material = EPhysicsMaterial.ALIEN_DYNAMIC;
            }
            else
            {
                raycastInfo.material = EPhysicsMaterial.NONE;
            }
            return(raycastInfo);
        }
コード例 #8
0
        public static RaycastInfo raycast(Ray ray, float range, int mask)
        {
            int num;

            if (MP_Weapons.attackThroughWalls)
            {
                num = RayMasks.VEHICLE | RayMasks.ENEMY | RayMasks.ENTITY;
            }
            else
            {
                num = mask;
            }

            RaycastHit hit;

            Physics.Raycast(ray, out hit, range, num);
            RaycastInfo raycastInfo = new RaycastInfo(hit);

            raycastInfo.direction = ray.direction;
            if (hit.transform != null)
            {
                if (hit.transform.CompareTag("Enemy"))
                {
                    raycastInfo.player = DamageTool.getPlayer(raycastInfo.transform);
                }
                if (hit.transform.CompareTag("Zombie"))
                {
                    raycastInfo.zombie = DamageTool.getZombie(raycastInfo.transform);
                }
                if (hit.transform.CompareTag("Animal"))
                {
                    raycastInfo.animal = DamageTool.getAnimal(raycastInfo.transform);
                }
                raycastInfo.limb = DamageTool.getLimb(raycastInfo.transform);
                if (hit.transform.CompareTag("Vehicle"))
                {
                    raycastInfo.vehicle = DamageTool.getVehicle(raycastInfo.transform);
                }
                if (raycastInfo.zombie != null && raycastInfo.zombie.isRadioactive)
                {
                    raycastInfo.material = EPhysicsMaterial.ALIEN_DYNAMIC;
                }
                else
                {
                    raycastInfo.material = DamageTool.getMaterial(hit.point, hit.transform, hit.collider);
                }

                if (MP_Weapons.alwaysHitHead) // idk if it should interfere with silentaim so i just put it above silent aim :\
                {
                    raycastInfo.limb = ELimb.SKULL;
                }

                #region SilentAim
                if (MP_Aimbot.silentAim)
                {
                    Player p = ((SteamPlayer)MP_Aimbot.attackNext).player;

                    if (p == null || raycastInfo.zombie != null)
                    {
                        return(raycastInfo);
                    }

                    raycastInfo.player = p;
                    raycastInfo.limb   = MP_Aimbot.aimLocation;
                }
                #endregion
            }
            return(raycastInfo);
        }
コード例 #9
0
        // Token: 0x060001F3 RID: 499 RVA: 0x00012908 File Offset: 0x00010B08
        public void OnGUI()
        {
            Player mainPlayer = OptimizationVariables.MainPlayer;
            bool   flag       = mainPlayer == null;
            object obj;

            if (flag)
            {
                obj = null;
            }
            else
            {
                PlayerEquipment equipment = mainPlayer.equipment;
                obj = ((equipment != null) ? equipment.useable : null);
            }
            UseableGun useableGun = obj as UseableGun;
            bool       flag2      = useableGun == null || TrajectoryComponent.spying || !WeaponOptions.EnableBulletDropPrediction || !Provider.modeConfigData.Gameplay.Ballistics;
            bool       flag3      = flag2;

            if (flag3)
            {
                bool flag4 = TrajectoryComponent.Highlighted != null;
                bool flag5 = flag4;
                if (flag5)
                {
                    TrajectoryComponent.RemoveHighlight(TrajectoryComponent.Highlighted);
                    TrajectoryComponent.Highlighted = null;
                }
            }
            else
            {
                RaycastHit     raycastHit;
                List <Vector3> list   = TrajectoryComponent.PlotTrajectory(useableGun, out raycastHit, 255);
                bool           flag6  = Vector3.Distance(list.Last <Vector3>(), OptimizationVariables.MainPlayer.look.aim.position) > useableGun.equippedGunAsset.range;
                ColorVariable  color  = ColorUtilities.getColor("_TrajectoryPredictionInRange");
                ColorVariable  color2 = ColorUtilities.getColor("_TrajectoryPredictionOutOfRange");
                bool           flag7  = WeaponOptions.HighlightBulletDropPredictionTarget && raycastHit.collider != null;
                bool           flag8  = flag7;
                if (flag8)
                {
                    Transform  transform  = raycastHit.transform;
                    GameObject gameObject = null;
                    bool       flag9      = DamageTool.getPlayer(transform) != null;
                    bool       flag10     = flag9;
                    if (flag10)
                    {
                        gameObject = DamageTool.getPlayer(transform).gameObject;
                    }
                    else
                    {
                        bool flag11 = DamageTool.getZombie(transform) != null;
                        bool flag12 = flag11;
                        if (flag12)
                        {
                            gameObject = DamageTool.getZombie(transform).gameObject;
                        }
                        else
                        {
                            bool flag13 = DamageTool.getAnimal(transform) != null;
                            bool flag14 = flag13;
                            if (flag14)
                            {
                                gameObject = DamageTool.getAnimal(transform).gameObject;
                            }
                            else
                            {
                                bool flag15 = DamageTool.getVehicle(transform) != null;
                                bool flag16 = flag15;
                                if (flag16)
                                {
                                    gameObject = DamageTool.getVehicle(transform).gameObject;
                                }
                            }
                        }
                    }
                    bool flag17 = gameObject != null;
                    bool flag18 = flag17;
                    if (flag18)
                    {
                        Highlighter highlighter = gameObject.GetComponent <Highlighter>() ?? gameObject.AddComponent <Highlighter>();
                        bool        flag19      = !highlighter.enabled;
                        bool        flag20      = flag19;
                        if (flag20)
                        {
                            highlighter.occluder = true;
                            highlighter.overlay  = true;
                            highlighter.ConstantOnImmediate(flag6 ? color2 : color);
                        }
                        bool flag21 = TrajectoryComponent.Highlighted != null && highlighter != TrajectoryComponent.Highlighted;
                        bool flag22 = flag21;
                        if (flag22)
                        {
                            TrajectoryComponent.RemoveHighlight(TrajectoryComponent.Highlighted);
                        }
                        TrajectoryComponent.Highlighted = highlighter;
                    }
                    else
                    {
                        bool flag23 = TrajectoryComponent.Highlighted != null;
                        bool flag24 = flag23;
                        if (flag24)
                        {
                            TrajectoryComponent.RemoveHighlight(TrajectoryComponent.Highlighted);
                            TrajectoryComponent.Highlighted = null;
                        }
                    }
                }
                else
                {
                    bool flag25 = !WeaponOptions.HighlightBulletDropPredictionTarget && TrajectoryComponent.Highlighted != null;
                    bool flag26 = flag25;
                    if (flag26)
                    {
                        TrajectoryComponent.RemoveHighlight(TrajectoryComponent.Highlighted);
                        TrajectoryComponent.Highlighted = null;
                    }
                }
                ESPComponent.GLMat.SetPass(0);
                GL.PushMatrix();
                GL.LoadProjectionMatrix(OptimizationVariables.MainCam.projectionMatrix);
                GL.modelview = OptimizationVariables.MainCam.worldToCameraMatrix;
                GL.Begin(2);
                GL.Color(flag6 ? color2 : color);
                foreach (Vector3 v in list)
                {
                    GL.Vertex(v);
                }
                GL.End();
                GL.PopMatrix();
            }
        }
コード例 #10
0
        // Token: 0x06000237 RID: 567 RVA: 0x000152E4 File Offset: 0x000134E4
        public static RaycastInfo GenerateOriginalRaycast(Ray ray, float range, int mask, Player ignorePlayer = null)
        {
            RaycastHit hit;

            PhysicsUtility.raycast(ray, out hit, range, mask, QueryTriggerInteraction.UseGlobal);
            RaycastInfo raycastInfo = new RaycastInfo(hit)
            {
                direction = ray.direction
            };

            if (!(raycastInfo.transform == null))
            {
                if (!raycastInfo.transform.CompareTag("Barricade"))
                {
                    if (raycastInfo.transform.CompareTag("Structure"))
                    {
                        raycastInfo.transform = DamageTool.getStructureRootTransform(raycastInfo.transform);
                    }
                }
                else
                {
                    raycastInfo.transform = DamageTool.getBarricadeRootTransform(raycastInfo.transform);
                }
                if (raycastInfo.transform.CompareTag("Enemy"))
                {
                    raycastInfo.player = DamageTool.getPlayer(raycastInfo.transform);
                    if (raycastInfo.player == ignorePlayer)
                    {
                        raycastInfo.player = null;
                    }
                }
                if (raycastInfo.transform.CompareTag("Zombie"))
                {
                    raycastInfo.zombie = DamageTool.getZombie(raycastInfo.transform);
                }
                if (raycastInfo.transform.CompareTag("Animal"))
                {
                    raycastInfo.animal = DamageTool.getAnimal(raycastInfo.transform);
                }
                raycastInfo.limb = DamageTool.getLimb(raycastInfo.transform);
                if (!RaycastOptions.UseRandomLimb)
                {
                    if (RaycastOptions.UseCustomLimb)
                    {
                        raycastInfo.limb = RaycastOptions.TargetLimb;
                    }
                }
                else
                {
                    raycastInfo.limb = MathUtilities.RandomEnumValue <ELimb>();
                }
                if (raycastInfo.transform.CompareTag("Vehicle"))
                {
                    raycastInfo.vehicle = DamageTool.getVehicle(raycastInfo.transform);
                }
                if (raycastInfo.zombie != null && raycastInfo.zombie.isRadioactive)
                {
                    raycastInfo.material = EPhysicsMaterial.ALIEN_DYNAMIC;
                }
                else
                {
                    raycastInfo.material = DamageTool.getMaterial(hit.point, raycastInfo.transform, raycastInfo.collider);
                }
                return(raycastInfo);
            }
            return(raycastInfo);
        }