UniformAim/notGregs.UniformAim/Plugin.cs

using BepInEx;
using BepInEx.Configuration;
using Comfort.Common;
using EFT;
using System;
using System.Collections;
using UnityEngine;


namespace notGreg.UniformAim
{
    [BepInPlugin("com.notGreg.UniformAim", "notGreg's Uniform Aim for Tarkov", "3.3.0")]
    public class Plugin : BaseUnityPlugin
    {
        ConfigEntry<int> configExponent;
        ConfigEntry<float> configSens;

        void Awake()
        {
            configExponent = Config.Bind("General", "Coefficient", 133, new ConfigDescription("", new AcceptableValueRange<int>(10, 200)));
            configSens = Config.Bind("General", "Sensitivity", 1.0f, new ConfigDescription("", new AcceptableValueRange<float>(0.01f, 2.0f)));

            new get_AimingSensitivityPatch().Enable();
        }

        Player mainPlayer;
        int inGameFOV;
        float inGameAimedSens;
        public static float aimingSens;

        //this function can be replaced by FixedUpdate() at 50Hz (adjustable via Time.fixedDeltaTime)
        //FixedUpdate() proved to be slightly more reliable in the past, however it had other unintended effects on the game.
        void Update()
        {
            //check if the world instance exists
            //Logger.LogInfo("Checking world instance");
            if (Singleton<AbstractGame>.Instance == null)
            {
                return;
            }

            //grab the game status of the existing instance
            //Logger.LogInfo("Checking game status");
            GameStatus currentGameStatus = Singleton<AbstractGame>.Instance.Status;

            //check if the game has started and if the player exists. If the player is aiming, update the scoped sensitivity (executed every frame while aiming)
            //Logger.LogInfo("Checking GameStatus and isAiming");
            if (currentGameStatus == GameStatus.Started && mainPlayer != null)
            {
                //Logger.LogInfo($"isAiming? {mainPlayer.HandsController.IsAiming}");
                if (mainPlayer.HandsController.IsAiming)
                {
                    aimingSens = calculateSensitivity();
                }
                return;
            }

            //Logger.LogInfo("Switch on GameStatus");
            switch (currentGameStatus)
            {
                case GameStatus.Started:
                    {
                        mainPlayer = getLocalPlayer();
                        //Logger.LogInfo($"Subscribing to onAimingChanged event");
                        subscribeOnAimingChanged();

                        //Logger.LogInfo("TryGetCameras coroutines");
                        StartCoroutine(tryGetMainCamera());
                        StartCoroutine(tryGetScopeCamera());

                        break;
                    }
                case GameStatus.SoftStopping:
                case GameStatus.Stopped:
                    {
                        mainPlayer = null;
                        break;
                    }
                default:
                    {
                        break;
                    }
            }
        }

        //this function grabs the Field of View from the settings. This is the function that most often needs patching after update.
        //Appropriate class can usually be found by searching for the ClearSettings function.
        int getInGameFOV()
        {
            //int fov = Singleton<GClass1642>.Instance.Game.Settings.FieldOfView; //SPT-AKI 3.2.3
            int fov = Singleton<GClass1653>.Instance.Game.Settings.FieldOfView; //SPT-AKI 3.3.0
           //Logger.LogInfo($"In-game FOV: {fov}");
            return fov;
        }

        //this function grabs the Aiming Sensitivity from the settings. This is the function that most often needs patching after update.
        //Appropriate class can usually be found by searching for the ClearSettings function.
        float getInGameAimSens()
        {
            //float sens = Singleton<GClass1642>.Instance.Control.Settings.MouseAimingSensitivity; //SPT-AKI 3.2.*
            float sens = Singleton<GClass1653>.Instance.Control.Settings.MouseAimingSensitivity; //SPT-AKI 3.3.0
           //Logger.LogInfo($"In-game AimSens: {sens}");
            return sens;
        }

        Player getLocalPlayer()
        {
            return Singleton<GameWorld>.Instance.RegisteredPlayers.Find(p => p.IsYourPlayer);
        }

        WaitForSecondsRealtime myDelay = new WaitForSecondsRealtime(1f);
        Camera mainCamera;
        Camera scopeCamera;

        //this coroutine attempts to find the FPS Camera in the scene.
        IEnumerator tryGetMainCamera()
        {
            string cameraName = "FPS Camera";
            if (GameObject.Find(cameraName) != null)
            {
                mainCamera = GameObject.Find(cameraName).GetComponent<Camera>();
                //Logger.LogInfo($"{mainCamera.name} found!");
            }
            else
            {
                //Logger.LogMessage($"Camera \"{cameraName}\" not found, rescheduling...");
                yield return myDelay;
                StartCoroutine(tryGetMainCamera());
                yield break;
            }
            yield return null;
        }

        //this coroutine attempts to find existing baseOpticCamera in the scene. The state of this camera is used to determine whether the player is using a magnified optic or not.
        IEnumerator tryGetScopeCamera()
        {
            string cameraName = "BaseOpticCamera(Clone)";
            if (GameObject.Find(cameraName) != null)
            {
                scopeCamera = GameObject.Find(cameraName).GetComponent<Camera>();
                //Logger.LogInfo($"{scopeCamera.name} found!");
            }
            yield break;
        }

        //convert vertical FOV (degrees) to horizontal FOV (degrees)
        float calculateHFOV(Camera camera)
        {
            return Camera.VerticalToHorizontalFieldOfView(camera.fieldOfView, camera.aspect);
        }

        //figure out whether the player is using a magnified optic or not. Return the FOV of the sight.
        Camera determineCurrentAimedFOV()
        {
            var currentAimingMode = mainPlayer.ProceduralWeaponAnimation.CurrentAimingMod;

            //get the name of the currently active scope
            string scopeName = currentAimingMode.Item.Template.Name;

            //Logger.LogInfo($"Scope name: {scopeName}");

            //scopeMode determines the scope being used (e.g. main magnified optic at index 0, backup RDS at index 1)
            //scopeIndex determines the mode of the scope being used (e.g. x1 magnification at index 0, x4 magnification at index 1)
            //there are exceptions to this rule thanks to BSG's inconsistency, some of them are patched below
            var scopeIndex = currentAimingMode.SelectedScopeIndex;
            var scopeMode = currentAimingMode.SelectedScopeMode;

            //patches for specific scopes, matches item name
            switch (scopeName)
            {
                case "tactical_mp155_kalashnikov_ultima_camera":
                    {
                        //Logger.LogInfo("MP-155 Thermal");
                        return mainCamera;
                    }
                //SAM-SWAT's Leupold D-Evo optic patch. The modes on this scope are reversed. Causes detection based on baseOpticCamera to fail as the magnified optic camera is always active
                case "scope_leupold_d_evo":
                    {
                        if (scopeMode == 0)
                        {
                            //Logger.LogInfo($"Leupold D-EVO BUIS FOV: {mainCamera.fieldOfView}");
                            return mainCamera;
                        }
                        else
                        {
                            //Logger.LogInfo($"Leupold D-EVO Scope FOV: {scopeCamera.fieldOfView}");
                            return scopeCamera;
                        }
                    }
                default:
                    {
                        if (scopeCamera == null || scopeCamera.isActiveAndEnabled == false)
                        {
                            //Logger.LogInfo($"Non-magnified: {scopeName} FOV: {mainCamera.fieldOfView}");
                            return mainCamera;
                        }
                        else
                        {
                            //Logger.LogInfo($"Magnified: {scopeName} FOV: {scopeCamera.fieldOfView}");
                            return scopeCamera;
                        }
                    }
            }
        }

        float calculateSensitivity()
        {
            //grab vertical hipfire field of view (FOV set by the user in the setting), then convert it to horizontal FOV
            //convert degrees to radians
            float hipFOV = Mathf.Deg2Rad * Camera.VerticalToHorizontalFieldOfView(inGameFOV, mainCamera.aspect);

            //grab current field of view while aiming, then convert it to horizontal FOV
            //convert degrees to radians
            float aimedFOV = Mathf.Deg2Rad * calculateHFOV(determineCurrentAimedFOV());

            //exponent applied to the ratio of aimedFOV to hipFOV, causes sights to become relatively faster or slower as zoom increases
            float exponent = 100f / configExponent.Value;

            float tanRatio = (float)(Mathf.Tan(aimedFOV / 2) / Mathf.Tan(hipFOV / 2));

            float sensitivity = (float)Math.Pow(tanRatio, exponent) * inGameAimedSens;

            //Logger.LogInfo($"Sensitivity: {sensitivity}");
            return sensitivity * configSens.Value;
        }


        void subscribeOnAimingChanged()
        {
            //HandsChangedEvent triggers whenever player changes weapons
            //without it the patch would cease to work as expected when weapons were changed
            mainPlayer.HandsChangedEvent += (handsArgs) =>
            {
                //onAimingChanged triggers whenever the player starts or stops aiming.
                mainPlayer.HandsController.OnAimingChanged += (aimArgs) =>
                {
                    inGameFOV = getInGameFOV();
                    inGameAimedSens = getInGameAimSens();
                    StartCoroutine(tryGetScopeCamera());
                };
            };
        }
    }
}