// Token: 0x06000BB7 RID: 2999 RVA: 0x00032F0C File Offset: 0x0003110C
        private void FixedUpdate()
        {
            if (!NetworkServer.active)
            {
                return;
            }
            if (!this.owner)
            {
                UnityEngine.Object.Destroy(base.gameObject);
                return;
            }
            InputBankTest component = this.owner.GetComponent <InputBankTest>();
            Vector3       vector    = component ? component.aimDirection : base.transform.forward;

            if (this.target)
            {
                vector = (this.target.transform.position - base.transform.position).normalized;
            }
            base.transform.forward = Vector3.RotateTowards(base.transform.forward, vector, 0.017453292f * this.turnSpeed * Time.fixedDeltaTime, 0f);
            Vector3 vector2 = this.owner.transform.position + base.transform.rotation * this.localOffset;

            base.transform.position = Vector3.SmoothDamp(base.transform.position, vector2, ref this.velocity, this.positionSmoothTime, float.PositiveInfinity, Time.fixedDeltaTime);
            this.fireTimer         -= Time.fixedDeltaTime;
            this.timeoutTimer      -= Time.fixedDeltaTime;
            if (this.fireTimer <= 0f)
            {
                this.target    = this.FindTarget();
                this.fireTimer = this.interval;
            }
            if (this.target && this.WillHit(this.target))
            {
                Vector3 normalized = (this.target.transform.position - base.transform.position).normalized;
                this.Fire(base.transform.position, normalized);
                this.ammo--;
                this.target       = null;
                this.timeoutTimer = this.timeout;
            }
            if (this.ammo <= 0 || this.timeoutTimer <= 0f)
            {
                UnityEngine.Object.Destroy(base.gameObject);
            }
        }
Example #2
0
        // Token: 0x06000EBA RID: 3770 RVA: 0x0004190C File Offset: 0x0003FB0C
        private void ScheduleIntensityCalculation(GameObject targetBodyObject)
        {
            if (!targetBodyObject)
            {
                return;
            }
            ReadOnlyCollection <TeamComponent> teamMembers = TeamComponent.GetTeamMembers(TeamIndex.Monster);
            int count = teamMembers.Count;

            this.EnsureEnemyBufferSize(count);
            int num  = 0;
            int i    = 0;
            int num2 = count;

            while (i < num2)
            {
                TeamComponent teamComponent = teamMembers[i];
                InputBankTest component     = teamComponent.GetComponent <InputBankTest>();
                CharacterBody component2    = teamComponent.GetComponent <CharacterBody>();
                if (component)
                {
                    this.enemyInfoBuffer[num++] = new MusicController.EnemyInfo
                    {
                        aimRay      = new Ray(component.aimOrigin, component.aimDirection),
                        threatScore = (component2.master ? component2.GetNormalizedThreatValue() : 0f)
                    };
                }
                i++;
            }
            this.calculateIntensityJob = new MusicController.CalculateIntensityJob
            {
                enemyInfoBuffer = this.enemyInfoBuffer,
                elementCount    = num,
                targetPosition  = targetBodyObject.transform.position,
                nearDistance    = 20f,
                farDistance     = 75f
            };
            this.calculateIntensityJobHandle = this.calculateIntensityJob.Schedule(num, 32, default(JobHandle));
        }
        // Token: 0x06000BF4 RID: 3060 RVA: 0x0003A450 File Offset: 0x00038650
        private void Update()
        {
            if (Time.deltaTime == 0f)
            {
                return;
            }
            if (this.target != this.previousTarget)
            {
                this.previousTarget = this.target;
                Action <CameraRigController, GameObject> action = CameraRigController.onCameraTargetChanged;
                if (action != null)
                {
                    action(this, this.target);
                }
            }
            this.lerpCameraTime   += Time.deltaTime * this.lerpCameraTimeScale;
            this.firstPersonTarget = null;
            float num = this.baseFov;

            this.sceneCam.rect = this.viewport;
            Player      player      = null;
            UserProfile userProfile = null;
            bool        flag        = false;

            if (this.viewer && this.viewer.localUser != null)
            {
                player      = this.viewer.localUser.inputPlayer;
                userProfile = this.viewer.localUser.userProfile;
                flag        = this.viewer.localUser.isUIFocused;
            }
            if (this.cameraMode == CameraRigController.CameraMode.SpectateUser && player != null)
            {
                if (player.GetButtonDown("PrimarySkill"))
                {
                    this.target = CameraRigController.GetNextSpectateGameObject(this.viewer, this.target);
                }
                if (player.GetButtonDown("SecondarySkill"))
                {
                    this.target = CameraRigController.GetPreviousSpectateGameObject(this.viewer, this.target);
                }
            }
            LocalUser     localUserViewer = this.localUserViewer;
            MPEventSystem mpeventSystem   = (localUserViewer != null) ? localUserViewer.eventSystem : null;
            float         num14;
            float         num15;

            if ((!mpeventSystem || !mpeventSystem.isCursorVisible) && player != null && userProfile != null && !flag && this.overrideCam == null)
            {
                float   mouseLookSensitivity = userProfile.mouseLookSensitivity;
                float   num2 = userProfile.stickLookSensitivity * CameraRigController.aimStickGlobalScale.value * 45f;
                Vector2 vector = new Vector2(player.GetAxisRaw(2), player.GetAxisRaw(3));
                Vector2 vector2 = new Vector2(player.GetAxisRaw(16), player.GetAxisRaw(17));
                CameraRigController.< Update > g__ConditionalNegate | 69_0 (ref vector.x, userProfile.mouseLookInvertX);
                CameraRigController.< Update > g__ConditionalNegate | 69_0 (ref vector.y, userProfile.mouseLookInvertY);
                CameraRigController.< Update > g__ConditionalNegate | 69_0 (ref vector2.x, userProfile.stickLookInvertX);
                CameraRigController.< Update > g__ConditionalNegate | 69_0 (ref vector2.y, userProfile.stickLookInvertY);
                float magnitude = vector2.magnitude;
                float num3      = magnitude;
                this.aimStickPostSmoothing = Vector2.zero;
                this.aimStickPostDualZone  = Vector2.zero;
                this.aimStickPostExponent  = Vector2.zero;
                if (CameraRigController.aimStickDualZoneSmoothing.value != 0f)
                {
                    float maxDelta = Time.deltaTime / CameraRigController.aimStickDualZoneSmoothing.value;
                    num3 = Mathf.Min(Mathf.MoveTowards(this.stickAimPreviousAcceleratedMagnitude, magnitude, maxDelta), magnitude);
                    this.stickAimPreviousAcceleratedMagnitude = num3;
                    this.aimStickPostSmoothing = ((magnitude != 0f) ? (vector2 * (num3 / magnitude)) : Vector2.zero);
                }
                float num4  = num3;
                float value = CameraRigController.aimStickDualZoneSlope.value;
                float num5;
                if (num4 <= CameraRigController.aimStickDualZoneThreshold.value)
                {
                    num5 = 0f;
                }
                else
                {
                    num5 = 1f - value;
                }
                num3 = value * num4 + num5;
                this.aimStickPostDualZone = ((magnitude != 0f) ? (vector2 * (num3 / magnitude)) : Vector2.zero);
                num3 = Mathf.Pow(num3, CameraRigController.aimStickExponent.value);
                this.aimStickPostExponent = ((magnitude != 0f) ? (vector2 * (num3 / magnitude)) : Vector2.zero);
                if (magnitude != 0f)
                {
                    vector2 *= num3 / magnitude;
                }
                if (this.cameraMode == CameraRigController.CameraMode.PlayerBasic && this.targetBody && !this.targetBody.isSprinting)
                {
                    AimAssistTarget exists     = null;
                    AimAssistTarget exists2    = null;
                    float           value2     = CameraRigController.aimStickAssistMinSize.value;
                    float           num6       = value2 * CameraRigController.aimStickAssistMaxSize.value;
                    float           value3     = CameraRigController.aimStickAssistMaxSlowdownScale.value;
                    float           value4     = CameraRigController.aimStickAssistMinSlowdownScale.value;
                    float           num7       = 0f;
                    float           value5     = 0f;
                    float           num8       = 0f;
                    Vector2         v          = Vector2.zero;
                    Vector2         zero       = Vector2.zero;
                    Vector2         normalized = vector2.normalized;
                    Vector2         vector3    = new Vector2(0.5f, 0.5f);
                    for (int i = 0; i < AimAssistTarget.instancesList.Count; i++)
                    {
                        AimAssistTarget aimAssistTarget = AimAssistTarget.instancesList[i];
                        if (aimAssistTarget.teamComponent.teamIndex != this.targetTeamIndex)
                        {
                            Vector3 vector4 = this.sceneCam.WorldToViewportPoint(aimAssistTarget.point0.position);
                            Vector3 vector5 = this.sceneCam.WorldToViewportPoint(aimAssistTarget.point1.position);
                            float   num9    = Mathf.Lerp(vector4.z, vector5.z, 0.5f);
                            if (num9 > 3f)
                            {
                                float   num10   = 1f / num9;
                                Vector2 vector6 = Util.ClosestPointOnLine(vector4, vector5, vector3) - vector3;
                                float   num11   = Mathf.Clamp01(Util.Remap(vector6.magnitude, value2 * aimAssistTarget.assistScale * num10, num6 * aimAssistTarget.assistScale * num10, 1f, 0f));
                                float   num12   = Mathf.Clamp01(Vector3.Dot(vector6, vector2.normalized));
                                float   num13   = num12 * num11;
                                if (num7 < num11)
                                {
                                    num7    = num11;
                                    exists2 = aimAssistTarget;
                                }
                                if (num13 > num8)
                                {
                                    num7   = num11;
                                    value5 = num12;
                                    exists = aimAssistTarget;
                                    v      = vector6;
                                }
                            }
                        }
                    }
                    Vector2 vector7 = vector2;
                    if (exists2)
                    {
                        float magnitude2 = vector2.magnitude;
                        float d          = Mathf.Clamp01(Util.Remap(1f - num7, 0f, 1f, value3, value4));
                        vector7 *= d;
                    }
                    if (exists)
                    {
                        vector7 = Vector3.RotateTowards(vector7, v, Util.Remap(value5, 1f, 0f, CameraRigController.aimStickAssistMaxDelta.value, CameraRigController.aimStickAssistMinDelta.value), 0f);
                    }
                    vector2 = vector7;
                }
                num14 = vector.x * mouseLookSensitivity * userProfile.mouseLookScaleX + vector2.x * num2 * userProfile.stickLookScaleX * Time.deltaTime;
                num15 = vector.y * mouseLookSensitivity * userProfile.mouseLookScaleY + vector2.y * num2 * userProfile.stickLookScaleY * Time.deltaTime;
            }
            else
            {
                num14 = 0f;
                num15 = 0f;
            }
            NetworkUser         networkUser         = Util.LookUpBodyNetworkUser(this.target);
            NetworkedViewAngles networkedViewAngles = null;

            if (networkUser)
            {
                networkedViewAngles = networkUser.GetComponent <NetworkedViewAngles>();
            }
            this.targetTeamIndex = TeamIndex.None;
            bool flag2 = false;

            if (this.target)
            {
                this.targetBody = this.target.GetComponent <CharacterBody>();
                flag2           = this.targetBody.isSprinting;
                TeamComponent component = this.target.GetComponent <TeamComponent>();
                if (component)
                {
                    this.targetTeamIndex = component.teamIndex;
                }
                this.targetParams = this.target.GetComponent <CameraTargetParams>();
            }
            Vector3 vector8 = this.desiredCameraState.position;

            if (this.targetParams)
            {
                Vector3 position            = this.target.transform.position;
                Vector3 cameraPivotPosition = this.targetParams.cameraPivotPosition;
                if (this.targetParams.dontRaycastToPivot)
                {
                    vector8 = cameraPivotPosition;
                }
                else
                {
                    Vector3 direction = cameraPivotPosition - position;
                    Ray     ray       = new Ray(position, direction);
                    float   distance  = this.Raycast(ray, direction.magnitude, this.targetParams.cameraParams.wallCushion);
                    vector8 = ray.GetPoint(distance);
                }
            }
            if (this.cameraMode == CameraRigController.CameraMode.PlayerBasic || this.cameraMode == CameraRigController.CameraMode.SpectateUser)
            {
                float   min = -89.9f;
                float   max = 89.9f;
                Vector3 idealLocalCameraPos = new Vector3(0f, 0f, 0f);
                float   wallCushion         = 0.1f;
                Vector2 vector9             = Vector2.zero;
                if (this.targetParams)
                {
                    min = this.targetParams.cameraParams.minPitch;
                    max = this.targetParams.cameraParams.maxPitch;
                    idealLocalCameraPos = this.targetParams.idealLocalCameraPos;
                    wallCushion         = this.targetParams.cameraParams.wallCushion;
                    vector9             = this.targetParams.recoil;
                    if (this.targetParams.aimMode == CameraTargetParams.AimType.FirstPerson)
                    {
                        this.firstPersonTarget = this.target;
                    }
                    if (this.targetParams.fovOverride >= 0f)
                    {
                        num    = this.targetParams.fovOverride;
                        num14 *= num / this.baseFov;
                        num15 *= num / this.baseFov;
                    }
                    if (this.targetBody && flag2)
                    {
                        num14 *= 0.5f;
                        num15 *= 0.5f;
                    }
                }
                if (this.sprintingParticleSystem)
                {
                    ParticleSystem.MainModule main = this.sprintingParticleSystem.main;
                    if (flag2)
                    {
                        main.loop = true;
                        if (!this.sprintingParticleSystem.isPlaying)
                        {
                            this.sprintingParticleSystem.Play();
                        }
                    }
                    else
                    {
                        main.loop = false;
                    }
                }
                if (this.cameraMode == CameraRigController.CameraMode.PlayerBasic)
                {
                    float num16 = this.pitch - num15;
                    float num17 = this.yaw + num14;
                    num16     += vector9.y;
                    num17     += vector9.x;
                    this.pitch = Mathf.Clamp(num16, min, max);
                    this.yaw   = Mathf.Repeat(num17, 360f);
                }
                else if (this.cameraMode == CameraRigController.CameraMode.SpectateUser && this.target)
                {
                    if (networkedViewAngles)
                    {
                        this.SetPitchYaw(networkedViewAngles.viewAngles);
                    }
                    else
                    {
                        InputBankTest component2 = this.target.GetComponent <InputBankTest>();
                        if (component2)
                        {
                            this.SetPitchYawFromLookVector(component2.aimDirection);
                        }
                    }
                }
                this.desiredCameraState.rotation = Quaternion.Euler(this.pitch, this.yaw, 0f);
                Vector3 direction2 = vector8 + this.desiredCameraState.rotation * idealLocalCameraPos - vector8;
                float   num18      = direction2.magnitude;
                float   num19      = (1f + this.pitch / -90f) * 0.5f;
                num18 *= Mathf.Sqrt(1f - num19);
                if (num18 < 0.25f)
                {
                    num18 = 0.25f;
                }
                float a = this.Raycast(new Ray(vector8, direction2), num18, wallCushion);
                this.currentCameraDistance       = Mathf.Min(a, Mathf.SmoothDamp(this.currentCameraDistance, a, ref this.cameraDistanceVelocity, 0.5f));
                this.desiredCameraState.position = vector8 + direction2.normalized * this.currentCameraDistance;
                this.pitch -= vector9.y;
                this.yaw   -= vector9.x;
                if (networkedViewAngles && networkedViewAngles.hasEffectiveAuthority)
                {
                    networkedViewAngles.viewAngles = new PitchYawPair(this.pitch, this.yaw);
                }
            }
            if (this.targetBody)
            {
                num *= (this.targetBody.isSprinting ? 1.3f : 1f);
            }
            this.desiredCameraState.fov = Mathf.SmoothDamp(this.desiredCameraState.fov, num, ref this.fovVelocity, 0.2f, float.PositiveInfinity, Time.deltaTime);
            if (this.hud)
            {
                CharacterMaster targetMaster = this.targetBody ? this.targetBody.master : null;
                this.hud.targetMaster = targetMaster;
            }
            this.UpdateCrosshair(vector8);
            CameraState cameraState = this.desiredCameraState;

            if (this.overrideCam != null)
            {
                if ((UnityEngine.Object) this.overrideCam)
                {
                    cameraState = this.overrideCam.GetCameraState(this);
                }
                this.overrideCam = null;
            }
            if (this.lerpCameraTime >= 1f)
            {
                this.currentCameraState = cameraState;
            }
            else
            {
                this.currentCameraState = CameraState.Lerp(ref this.lerpCameraState, ref cameraState, CameraRigController.RemapLerpTime(this.lerpCameraTime));
            }
            this.SetCameraState(this.currentCameraState);
        }
Example #4
0
        public void Awake() {
            R2API.Utils.CommandHelper.AddToConsoleWhenReady();
            double RT_timer = 0.0;
            double RT_animationCancelDelay = 0.15;
            bool RT_isSprinting = false;
            bool RT_animationCancel = false;
            bool RT_walkToggle = false;

            SetupConfiguration();

            // MUL-T
            RT_RegisterSprintDisable("EntityStates.Toolbot.ToolbotDualWield");
            RT_RegisterSprintDisable("EntityStates.Toolbot.ToolbotDualWieldBase");
            RT_RegisterSprintDisable("EntityStates.Toolbot.ToolbotDualWieldStart");
            RT_RegisterSprintDisable("EntityStates.Toolbot.FireNailgun");
            RT_RegisterSprintDisable("EntityStates.Toolbot.AimStunDrone");
            RT_RegisterAnimationDelay("EntityStates.Toolbot.FireGrenadeLauncher");

            // Artificer
            RT_RegisterSprintDisable("EntityStates.Mage.Weapon.Flamethrower");
            RT_RegisterSprintDisable("EntityStates.Mage.Weapon.PrepWall");
            RT_RegisterAnimationDelay("EntityStates.Mage.Weapon.FireFireBolt");
            RT_RegisterAnimationDelay("EntityStates.Mage.Weapon.FireLaserbolt");

            // Bandit
            RT_RegisterSprintDisable("EntityStates.Bandit2.Weapon.BasePrepSidearmRevolverState");
            RT_RegisterSprintDisable("EntityStates.Bandit2.Weapon.PrepSidearmResetRevolver");
            RT_RegisterSprintDisable("EntityStates.Bandit2.Weapon.PrepSidearmSkullRevolver");
            RT_RegisterAnimationDelay("EntityStates.Bandit2.Weapon.Bandit2FirePrimaryBase");
            RT_RegisterAnimationDelay("EntityStates.Bandit2.Weapon.FireShotgun2");
            RT_RegisterAnimationDelay("EntityStates.Bandit2.Weapon.Bandit2FireRifle");

            // Engineer
            RT_RegisterSprintDisable("EntityStates.Engi.EngiMissilePainter.Paint");
            RT_RegisterAnimationDelay("EntityStates.Engi.EngiWeapon.FireMines");
            RT_RegisterAnimationDelay("EntityStates.Engi.EngiWeapon.FireSeekerGrenades");

            // Rex
            RT_RegisterSprintDisable("EntityStates.Treebot.Weapon.AimMortar");
            RT_RegisterSprintDisable("EntityStates.Treebot.Weapon.AimMortar2");
            RT_RegisterSprintDisable("EntityStates.Treebot.Weapon.AimMortarRain");
            RT_RegisterAnimationDelay("EntityStates.Treebot.Weapon.FireSyringe");

            // Captain
            RT_RegisterSprintDisable("EntityStates.Captain.Weapon.SetupAirstrike");
            RT_RegisterSprintDisable("EntityStates.Captain.Weapon.SetupAirstrikeAlt");
            RT_RegisterSprintDisable("EntityStates.Captain.Weapon.SetupSupplyDrop");

            // Acrid
            RT_RegisterAnimationDelay("EntityStates.Croco.Slash");

            // Commando
            RT_RegisterAnimationDelay("EntityStates.Commando.CommandoWeapon.FirePistol2");

            // Loader
            RT_RegisterAnimationDelay("EntityStates.Loader.SwingComboFist");

            // On.RoR2.CharacterBody.OnSkillActivated += (orig, self, GenericSkill) => { 
            //     orig(self, GenericSkill); 
            //     Debug.Log( 
            //             GenericSkill.skillDef.skillName  + " | "          // FireFirebolt
            //         + GenericSkill + " | "                                  // MageBody(Clone) (RoR2.GenericSkill)
            //         + GenericSkill.characterBody + " | "                // MageBody(Clone) (RoR2.CharacterBody)
            //         + GenericSkill.characterBody.name + " | "           // MageBody(Clone)
            //         + GenericSkill.characterBody.master + " | "         // CommandoMaster(Clone) (RoR2.CharacterMaster)
            //         + GenericSkill.characterBody.masterObject + " | "   // CommandoMaster(Clone) (UnityEngine.GameObject)           
            //         );
            // }; 

            On.RoR2.PlayerCharacterMasterController.FixedUpdate += delegate (On.RoR2.PlayerCharacterMasterController.orig_FixedUpdate orig, RoR2.PlayerCharacterMasterController self) {
                orig.Invoke(self);
                if (RT_enabled) {
                    RoR2.InputBankTest instanceFieldBodyInputs = self.GetInstanceField<RoR2.InputBankTest>("bodyInputs");
                    if (instanceFieldBodyInputs) {
                        if (self.networkUser && self.networkUser.localUser != null && !self.networkUser.localUser.isUIFocused) {
                            RoR2.CharacterBody instanceFieldBody = self.GetInstanceField<RoR2.CharacterBody>("body");
                            if (instanceFieldBody) {
                                Player inputPlayer = self.networkUser.localUser.inputPlayer;
                                RT_isSprinting = instanceFieldBody.isSprinting;
                                // Periodic sprint checker
                                if (!RT_isSprinting) {
                                    RT_timer += (double)Time.deltaTime;
                                    if (RT_timer >= 0.05) {
                                        if (!RT_animationCancel) {
                                            RT_timer = 0 - SprintDelayTime(instanceFieldBody);
                                        }
                                        if (RT_timer >= 0) {
                                            RT_isSprinting = !ShouldSprintBeDisabledOnThisBody(instanceFieldBody);
                                            RT_animationCancel = false;
                                            RT_timer = 0;
                                        }
                                    }
                                } else { RT_timer = 0; }

                                // Walk Toggle logic
                                if (!HoldSprintToWalk.Value && inputPlayer.GetButtonDown("Sprint") && !ShouldSprintBeDisabledOnThisBody(instanceFieldBody)) {
                                    RT_walkToggle = !RT_walkToggle;
                                } else if (inputPlayer.GetButton("Sprint")) {
                                    if (RT_isSprinting && HoldSprintToWalk.Value) RT_isSprinting = false;
                                    if (!RT_isSprinting && ShouldSprintBeDisabledOnThisBody(instanceFieldBody)) RT_isSprinting = true;
                                    RT_timer = 0;
                                }


                                // Animation cancelling logic.
                                if (!RT_animationCancel && RT_timer < -(RT_animationCancelDelay)
                                    && !inputPlayer.GetButton("PrimarySkill") && !inputPlayer.GetButton("SecondarySkill")
                                    && !inputPlayer.GetButton("SpecialSkill") && !inputPlayer.GetButton("UtilitySkill")) {
                                    RT_timer = -(RT_animationCancelDelay);
                                    RT_animationCancel = true;
                                }

                                // Angle check disables sprinting if the movement angle is too large
                                if (RT_isSprinting && !SprintInAnyDirection.Value) {
                                    Vector3 aimDirection = instanceFieldBodyInputs.aimDirection;
                                    aimDirection.y = 0f;
                                    aimDirection.Normalize();
                                    Vector3 moveVector = instanceFieldBodyInputs.moveVector;
                                    moveVector.y = 0f;
                                    moveVector.Normalize();
                                    if ((instanceFieldBody.bodyFlags & CharacterBody.BodyFlags.SprintAnyDirection) == CharacterBody.BodyFlags.None && (Vector3.Dot(aimDirection, moveVector) < self.GetFieldValue<float>("sprintMinAimMoveDot"))) {
                                        RT_isSprinting = false;
                                    }
                                }

                                if (HoldSprintToWalk.Value && RT_walkToggle) RT_walkToggle = false;
                                if (!RT_walkToggle) instanceFieldBodyInputs.sprint.PushState(RT_isSprinting);
                            } // End of if (instanceFieldBody)
                        } // End of if (networkUser) check
                    } // End of if (instanceFieldBodyInputs)
                } // End of "RT_enabled"
            }; // End of FixedUpdate

            // Custom FOV
            On.RoR2.CameraRigController.Update += (orig, self) => {
                orig(self);
                if (RTAutoSprintEx.RT_visuals) {
                    if (CustomFOV.Value >= 1 && CustomFOV.Value <= 180) self.baseFov = CustomFOV.Value;
                    else Logger.LogWarning("CustomFOV value out of range!");
                }
            };

            // Sprinting Crosshair
            IL.RoR2.UI.CrosshairManager.UpdateCrosshair += (il) => {
                if (RTAutoSprintEx.RT_visuals) {
                    ILCursor c = new ILCursor(il);
                    if (DisableSprintingCrosshair.Value) {
                        Logger.LogInfo("Disabling sprinting crosshair:");
                        try {
                            c.Index = 0;
                            c.GotoNext(
                                MoveType.After,
                                x => x.MatchCallvirt<CharacterBody>("get_isSprinting")
                            );
                            c.Emit(OpCodes.Ldc_I4, 0);
                            c.Emit(OpCodes.And);
                        } catch (Exception ex) { Debug.LogError(ex); }
                    }
                }
            };

            //Sprinting FOV change
            IL.RoR2.CameraRigController.Update += (il) => {
                if (RTAutoSprintEx.RT_visuals) {
                    ILCursor c = new ILCursor(il);
                    if (SprintFOVMultiplier.Value >= 0.1 && SprintFOVMultiplier.Value <= 2.0) {
                        Logger.LogInfo("Modifying Sprint FOV Multiplier:");
                        try {
                            c.Index = 0;
                            c.GotoNext(
                                x => x.MatchLdloc(0),
                                x => x.MatchLdarg(0),
                                x => x.MatchLdfld<RoR2.CameraRigController>("targetBody"),
                                x => x.MatchCallvirt<RoR2.CharacterBody>("get_isSprinting")
                            );
                            c.Index += 7;
                            c.Next.Operand = (float)SprintFOVMultiplier.Value;
                        } catch (Exception ex) { Debug.LogError(ex); }
                    } else Logger.LogWarning("SprintFOVMultiplier value out of range!");
                    // Disable Speedlines
                    if (DisableSpeedlines.Value) {
                        Logger.LogInfo("Disabling Speedlines:");
                        try {
                            c.Index = 0;
                            c.GotoNext(
                                x => x.MatchLdarg(0),
                                x => x.MatchLdfld<RoR2.CameraRigController>("sprintingParticleSystem"),
                                x => x.MatchCallvirt<UnityEngine.ParticleSystem>("get_isPlaying")
                            );
                            c.RemoveRange(3);
                            c.Emit(OpCodes.Ldc_I4, 1);
                        } catch (Exception ex) { Debug.LogError(ex); }
                    }
                }
                Logger.LogInfo("CameraRigController.Update IL edits done.");
            };
        } // End of Awake