Merge branch 'krazerleo/core/1' of https://gitea.gavt45.ru/gav/real-shooter into enikeev/dev/2

Assets/Scripts/Character/Character.cs

@@ -0,0 +1,12 @@
+using UnityEngine;
+public class Character
+{
+    public Team Team { get; set; }
+    public float LastTimeHit = 0;
+    public CharacterCondition Condition;
+
+    public Character()
+    {
+        Condition = new CharacterCondition();
+    }
+}

Assets/Scripts/Character/Character.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 44d6a17ad31b31241928e1a17e9aba37
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Character/CharacterCondition.cs

@@ -1,12 +1,6 @@
 using System;
 using UnityEngine;
 
-public enum NPCState
-{
-    InCover,
-    InBlancPoint,
-    InRunning,
-}
 
 public class CharacterCondition
 {
@@ -25,7 +19,18 @@ public class CharacterCondition
         {
             health = value;
             OnChangeHealthEvent?.Invoke(value);
-        } 
+        }
+    }
+
+    public int GetHealthPointsInQuantile()
+    {
+        if (health < 25)
+            return 0;
+        else if (health < 50)
+            return 1;
+        else if (health < 75)
+            return 2;
+        else return 3;
     }
     private int armour;
     public int ArmourPoints
@@ -40,6 +45,17 @@ public class CharacterCondition
             OnChangeArmourEvent?.Invoke(value);
         }
     }
+    public int GetArmourPointsInQuantile()
+    {
+        if (armour < 25)
+            return 0;
+        else if (armour < 50)
+            return 1;
+        else if (armour < 75)
+            return 2;
+        else return 3;
+    }
+
     private int ammo;
     public int Ammunition
     {
@@ -54,15 +70,17 @@ public class CharacterCondition
         }
     }
 
-    [HideInInspector]
-    public NPCState npcState { get; private set; }
-
     public CharacterCondition()
+    {
+        this.Reset();
+    }
+
+    public void Reset()
     {
         var settings = SettingsReader.Instance.GetSettings;
-        ammo = settings.maxAmmo;
-        health = settings.maxHealth;
-        armour = settings.maxArmour;
+        ammo = settings.MaxAmmo;
+        health = settings.MaxHealth;
+        armour = settings.MaxArmour;
     }
 
     public void GiveHealth(int health) => HealthPoints = Mathf.Clamp(health + HealthPoints, 0, 100);

Assets/Scripts/Character/Interfaces.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: f23b6db3be1e4cd469fd18dfe3e39764
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Character/Interfaces/ICharacter.cs

@@ -0,0 +1,5 @@
+public interface ICharacter
+{
+    Character GetCharacter { get; }
+    void ResetCharacter();
+}

Assets/Scripts/Character/Interfaces/ICharacter.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: b6dfb78244ae35c4db1326d5f5b73375
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Character/Interfaces/INpcBaseState.cs

@@ -0,0 +1,17 @@
+using UnityEngine;
+
+public interface INpcBaseState
+{
+    NpcEnumState State { get; }
+    bool InCover { get; }
+    bool IsRunning { get; }
+    bool InDirectPoint { get; }
+    float HitChance { get; }
+    float DoDamageChance { get; }
+}
+
+public interface INpcBaseBodyState
+{
+    NpcBodyState State { get; }
+    Vector3 GetPointToHit(GameObject go);
+}

Assets/Scripts/Character/Interfaces/INpcBaseState.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 58b7e1962495ada4c8e6ee6219c99a20
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Character/MovementController.cs

@@ -1,40 +1,83 @@
-using System.Linq;
-using System.Collections.Generic;
+using System.Collections.Generic;
+using System.Linq;
 using UnityEngine;
 using UnityEngine.AI;
 
 [RequireComponent(typeof(NavMeshAgent))]
 public class MovementController : MonoBehaviour
 {
-    public NavPoint currentPosition { get; private set; }
+    public int PointStartID { get; set; }
+    public int PointEndID { get; private set; }
+    public float FlagDistance { get; private set; }
+    private const float UpdateFlagPositionDelay = 5;
+    private const float UpdateReachedDestinationDelay = 5;
+
     [SerializeField] private NavMeshAgent navMeshAgent;
+    [SerializeField] private GameObject flag;
+    public float DistanceToGo { get; private set; }
+    public float RemainingDistance => navMeshAgent.remainingDistance;
+    private Dictionary<int, NavPoint> _idNavPointDict;
 
-    private void Start()
+
+    private void Awake()
     {
-        navMeshAgent.speed = SettingsReader.Instance.GetSettings.movementSpeed;
+        navMeshAgent.speed = SettingsReader.Instance.GetSettings.MovementSpeed;
+        _idNavPointDict = MapManager.Instance.IDToNavPoint;
+        InvokeRepeating(nameof(UpdateFlagPosition), 0, UpdateFlagPositionDelay);
+        InvokeRepeating(nameof(ReachedDestination), 0, UpdateReachedDestinationDelay);
+    }
+   
+    private void OnDestroy()
+    {
+        CancelInvoke(nameof(UpdateFlagPosition));
+        CancelInvoke(nameof(ReachedDestination));
     }
 
-    public void Move()
+    private void UpdateFlagPosition()
     {
-        var pointCandidate = getPointCandidate();
-        goToNextNavPoint(pointCandidate);
+        FlagDistance = (flag.transform.position - gameObject.transform.position).magnitude;
     }
-
+    
     public void MoveToRandomPoint()
-    {   
-        Debug.Log(MapManager.navPoints == null);
-        goToNextNavPoint(MapManager.navPoints[Random.Range(0, MapManager.navPoints.Count)]);
-    }
-
-    private NavPoint getPointCandidate()
     {
-        var NavPointsPositions = MapManager.navPoints
-            .Select(point => point.transform.position)
-            .Where(point => (currentPosition.transform.position - point).magnitude <= SettingsReader.Instance.GetSettings.movementSpeed)
-            .ToList();
-        return null;
+        GoToNextNavPoint(MapManager.Instance.NavPoints[Random.Range(0, MapManager.Instance.NavPoints.Count)]);
     }
 
-    public void goToNextNavPoint(NavPoint destination) =>
-        navMeshAgent.SetDestination(destination.transform.position);
+    public List<NavPoint> GetPointsCandidate()
+    {
+        return MapManager.Instance.NavPoints
+            .Where(point => 
+            (_idNavPointDict[PointStartID].Position - point.Position).magnitude < SettingsReader.Instance.GetSettings.MovementDistance)
+            .ToList();
+    }
+
+    public void GoToNextNavPoint(NavPoint destination)
+    {
+        if (navMeshAgent.isStopped == true) navMeshAgent.isStopped = false;
+        PointStartID = PointEndID;
+        PointEndID = destination.PointId;
+        navMeshAgent.SetDestination(destination.Position);
+        DistanceToGo = navMeshAgent.remainingDistance;      
+    }
+
+    public void ReturnToStartPoint()
+    {
+        if (navMeshAgent.isStopped == true) navMeshAgent.isStopped = false;
+        navMeshAgent.SetDestination(_idNavPointDict[PointStartID].Position);
+        PointEndID = PointStartID;
+        PointStartID = -1;
+    }
+
+    public void StopOnPath()
+    {
+        navMeshAgent.isStopped = true;
+        PointStartID = -1;
+        PointEndID = -1;
+    }
+
+    public void ReachedDestination()
+    {
+        if ((navMeshAgent.isStopped == false) && (navMeshAgent.velocity.magnitude < 0.1))
+            PointStartID = PointEndID;
+    }
 }

Assets/Scripts/Character/NPC.cs

@@ -1,61 +1,212 @@
 using System;
-using UnityEngine;
+using System.Collections.Generic;
 using Unity.MLAgents;
-using Unity.MLAgents.Sensors;
 using Unity.MLAgents.Actuators;
+using Unity.MLAgents.Sensors;
+using UnityEngine;
 
-[RequireComponent(typeof(MovementController))]
-public class NPC : Agent
+[RequireComponent(typeof(MovementController),typeof(BufferSensorComponent))]
+public class NPC : Agent, ICharacter
 {
-    public Team Team { get; set; }
-
     [HideInInspector]
-    private float LastTimeHit;
+    private Character AgentCharacter;
     public CharacterCondition Condition;
+    private FlagZone flagZone = null;
 
-    public MovementController moveController;
-     
-    private void Start()
+    public INpcBaseState NpcState { get; private set; }
+    public INpcBaseBodyState NpcBodyState { get; private set; }
+
+    public Character GetCharacter => AgentCharacter;
+
+    private NpcDirectPointState DirectState;
+    private NpcInCoverState CoverState;
+    private NpcRunningState RunningState;
+
+    private NpcStandingState StandingState;
+    private NpcCrouchingState CrouchingState;
+
+    private MovementController moveController;
+    private BufferSensorComponent bufferSensor;
+
+    private Dictionary<int, NavPoint> navPointIdDict;
+
+    #region UnityEvents and ML
+    private void Awake()
     {
-        Condition = new CharacterCondition();
+        DirectState = new NpcDirectPointState();
+        CoverState = new NpcInCoverState();
+        RunningState = new NpcRunningState();
+        NpcState = DirectState;
+
+        CrouchingState = new NpcCrouchingState();
+        StandingState = new NpcStandingState();
+        NpcBodyState = StandingState;
+
+        AgentCharacter = new Character();
+        Condition = AgentCharacter.Condition;
+
         moveController = gameObject.GetComponent<MovementController>();
+        bufferSensor = gameObject.GetComponent<BufferSensorComponent>();
+        
+        flagZone = GameObject.FindObjectOfType<FlagZone>();
+        if (flagZone is null)
+            Debug.LogError("Flag Is Not Set");
+        
+        navPointIdDict = MapManager.Instance.IDToNavPoint;
+        if (navPointIdDict is null)
+            Debug.LogError("Cant Find Nav Point Dictionary");
+    }
+
+    private void OnDestroy()
+    {
+        Debug.LogWarning("Pooled object was destroyed");
     }
 
     public override void OnEpisodeBegin()
     {
-
+        if (navPointIdDict is null)
+            Debug.LogError("Cant Find Nav Point Dictionary");
+        
+        NpcState = DirectState;
+        flagZone = GameObject.FindObjectOfType<FlagZone>();
     }
 
     public override void CollectObservations(VectorSensor sensor)
     {
-        sensor.AddObservation(Condition.HealthPoints);
-        sensor.AddObservation(Condition.ArmourPoints);
-        sensor.AddObservation(Condition.Ammunition);
-        sensor.AddObservation((int)Condition.npcState);
-    }
+        // Debug.Log("Collect observations called!");
+        navPointIdDict = MapManager.Instance.IDToNavPoint;
+        if (navPointIdDict is null)
+            Debug.LogError("Cant Find Nav Point Dictionary");
+        var candidates = moveController.GetPointsCandidate();
 
-    public override void Heuristic(in ActionBuffers actionsOut)
-    {
-        var discreteActionsOut = actionsOut.DiscreteActions;
-        if (Input.GetKeyDown(KeyCode.W))
+        //common sensors
+        sensor.AddObservation(GameManager.IsHaveSeenByEnemy(AgentCharacter.Team.GetOppositeTeam(),
+                              NpcBodyState.GetPointToHit(gameObject)).ToInt());
+        sensor.AddObservation(AgentCharacter.LastTimeHit);
+        sensor.AddObservation((!flagZone.IsNotOccup).ToInt());
+        sensor.AddObservation(Condition.GetHealthPointsInQuantile());
+        sensor.AddObservation(Condition.GetArmourPointsInQuantile());
+        sensor.AddObservation(candidates.Count);
+        sensor.AddObservation(moveController.PointStartID);
+        sensor.AddObservation(moveController.PointEndID);
+        // Debug.Log("Done common!");
+        //state sensors
+        sensor.AddObservation((int)NpcState.State);
+        sensor.AddObservation((int)NpcBodyState.State);
+        sensor.AddObservation(GameManager.IsEnemyNearby(gameObject.transform.position, AgentCharacter.Team));     
+        sensor.AddObservation(navPointIdDict[moveController.PointStartID].DeathAttr);
+        sensor.AddObservation(navPointIdDict[moveController.PointEndID].DeathAttr);
+        sensor.AddObservation(moveController.FlagDistance);
+        // Debug.Log("Done state sensors!");
+
+        //point sensors
+        foreach (var point in candidates)
         {
-            discreteActionsOut[0] = 1;
+            var position = transform.position;
+            bufferSensor.AppendObservation(new float[] {
+                point.DeathAttr,
+                (int)point.navType,
+                //4 flagEnemyDistance
+                GameManager.IsCloserToFlagFromNextNavPoint(point, position).ToInt(),
+                //5 EnemyVsNavPointDistance
+                GameManager.IsCloserToEnemyThanToNextNavPoint(point, position, AgentCharacter.Team.GetOppositeTeam()).ToInt(),
+                //6 Have been seen by enemy in this point               
+                GameManager.IsHaveSeenByEnemy(AgentCharacter.Team.GetOppositeTeam(),
+                              point.Position).ToInt()
+        });
         }
+        // Debug.Log("Done collect observations!");
     }
 
     public override void OnActionReceived(ActionBuffers actions)
     {
-        if (actions.DiscreteActions[0] == 1)
-            moveController.MoveToRandomPoint();
+        // Debug.Log("Actions recieved!");
+        var result = actions.DiscreteActions;
+        // Debug.Log(result[0] + " " + result[1]);
+        if (result[0] == 0)
+        {
+            if (navPointIdDict[moveController.PointStartID].navType != NavPointType.Cover)
+                return;
+            NpcState = CoverState;
+
+            switch (result[1])
+            {
+                case 0: Peek(); break;
+                case 1: Cover(); break;
+                case 3: Peek(); moveController.GoToNextNavPoint(navPointIdDict[result[2]]); break;
+                case 4: NpcState = DirectState; break;
+                default: throw new ArgumentException("Undefined Action recieved");
+            }
+        }
+        // Debug.Log(result[0] == 1);
+        if (result[0] == 1)
+        {
+            // Debug.Log("BEFORE SOme shitty if >:(");
+            if (navPointIdDict[moveController.PointStartID].navType != NavPointType.Direction)
+            {
+                // Debug.Log("SOme shitty if >:(");
+                return;
+            }
+            // Debug.Log("FUCK");
+
+            switch (result[1])
+            {
+                case 0: moveController.GoToNextNavPoint(navPointIdDict[result[2]]);
+                    NpcState = RunningState; Debug.Log("Go to point " + result[2]);break;
+                case 1: NpcState = DirectState; break;
+                default: throw new ArgumentException("Undefined Action recieved");
+            }
+        }
+        
+        if (result[0] == 2)
+        {
+            if (moveController.PointStartID == moveController.PointEndID && moveController.PointEndID != -1)
+                return;            
+            switch (result[1])
+            {
+                case 0: moveController.StopOnPath(); NpcState = DirectState; break;
+                case 1: moveController.ReturnToStartPoint(); NpcState = RunningState; break;
+                default: throw new ArgumentException("Undefined Action recieved");
+            }
+        }
+        // Debug.Log("Actions processed!");
+    }
+    #endregion
+
+    public event Action<NpcBodyState> OnChangePosition;
+    private void Peek()
+    {
+        OnChangePosition?.Invoke(global::NpcBodyState.Standing);
+        NpcBodyState = StandingState;
     }
 
-    public event Action<object> OnKilledEvent;
-    public void GetDamage(float damage)
+    private void Cover()
     {
+        OnChangePosition?.Invoke(global::NpcBodyState.Crouching);
+        NpcBodyState = CrouchingState;
+    }
+
+    public event Action<int, Team> OnDamageRecieved;
+    public void GetDamage(int damage)
+    {
+        AgentCharacter.LastTimeHit = TimeManager.Instance.CurrentTime;
         Condition.GiveHealth(-Mathf.RoundToInt(damage * (1 - Condition.ArmourPoints * 0.5f)));
         Condition.GiveArmour(-Mathf.RoundToInt(Mathf.Sqrt(damage) * 5));
+        OnDamageRecieved?.Invoke(damage, AgentCharacter.Team);
 
         if (Condition.HealthPoints < 0)
-            OnKilledEvent?.Invoke(this);
+        {
+            MapManager.AddDeathAttributeToPoints(moveController.PointStartID, moveController.PointEndID,
+                                                 moveController.DistanceToGo, moveController.RemainingDistance);
+            var pos = gameObject.transform.position;
+            var id = moveController.PointStartID;
+            CharacterFactory.Instance.ReSpawn(this, ref pos, ref id);
+        }
+    }
+
+    public void ResetCharacter()
+    {
+        Condition.Reset();
+        EndEpisode();
     }
 }

Assets/Scripts/Character/NPC.cs.meta

@@ -4,7 +4,7 @@ MonoImporter:
   externalObjects: {}
   serializedVersion: 2
   defaultReferences: []
-  executionOrder: 0
+  executionOrder: 200
   icon: {instanceID: 0}
   userData: 
   assetBundleName: 

Assets/Scripts/Character/NpcState.cs

@@ -0,0 +1,68 @@
+using UnityEngine;
+
+public enum NpcEnumState
+{
+    InCover,
+    InDirectPoint,
+    InRunning,
+}
+
+public enum NpcBodyState
+{
+    Crouching,
+    Standing,
+}
+
+public class NpcCrouchingState : INpcBaseBodyState
+{
+    public NpcBodyState State => NpcBodyState.Crouching;
+
+    public Vector3 GetPointToHit(GameObject go)
+    {
+        MeshRenderer meshRenderer;
+        go.TryGetComponent<MeshRenderer>(out meshRenderer);
+        return meshRenderer.bounds.center;
+    }
+}
+
+public class NpcStandingState : INpcBaseBodyState
+{
+    public NpcBodyState State => NpcBodyState.Standing;
+
+    public Vector3 GetPointToHit(GameObject go)
+    {
+        MeshRenderer meshRenderer;
+        go.TryGetComponent<MeshRenderer>(out meshRenderer);
+        return meshRenderer.bounds.center;
+    }
+}
+
+public class NpcDirectPointState : INpcBaseState
+{
+    public bool InCover => false;
+    public bool IsRunning => false;
+    public bool InDirectPoint => false;
+    public float HitChance => SettingsReader.Instance.GetSettings.GetHitChanceInDirectPoint;
+    public float DoDamageChance => SettingsReader.Instance.GetSettings.DoDamageChanceInDirectPoint;
+    public NpcEnumState State => NpcEnumState.InDirectPoint;
+}
+
+public class NpcRunningState : INpcBaseState
+{
+    public bool InCover => false;
+    public bool IsRunning => true;
+    public bool InDirectPoint => false;
+    public float HitChance => SettingsReader.Instance.GetSettings.GetHitChanceInRunning;
+    public float DoDamageChance => SettingsReader.Instance.GetSettings.DoDamageChanceInRunning;
+    public NpcEnumState State => NpcEnumState.InRunning;
+}
+
+public class NpcInCoverState : INpcBaseState
+{
+    public bool InCover => true;
+    public bool IsRunning => false;
+    public bool InDirectPoint => false;
+    public float HitChance => SettingsReader.Instance.GetSettings.GetHitChanceInCover;
+    public float DoDamageChance => SettingsReader.Instance.GetSettings.DoDamageChanceInCover;
+    public NpcEnumState State => NpcEnumState.InCover;
+}

Assets/Scripts/Character/NpcState.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a192e433e26797745ad0b46de2586de3
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Character/Player.cs

@@ -0,0 +1,38 @@
+using System;
+using UnityEngine;
+
+public class Player : MonoBehaviour, ICharacter
+{
+    [HideInInspector]
+    public Character PlayerCharacter;
+    public CharacterCondition Condition;
+
+    public Character GetCharacter => PlayerCharacter;
+
+    private void Awake()
+    {
+        PlayerCharacter = new Character();
+        Condition = PlayerCharacter.Condition;
+    }
+
+    private void OnDestroy()
+    {
+        Debug.LogWarning("Pooled object was destroyed");
+    }
+
+    public event Action<object> OnKilledEvent;
+    public void GetDamage(float damage)
+    {
+        PlayerCharacter.LastTimeHit = TimeManager.Instance.CurrentTime;
+        Condition.GiveHealth(-Mathf.RoundToInt(damage * (1 - Condition.ArmourPoints * 0.5f)));
+        Condition.GiveArmour(-Mathf.RoundToInt(Mathf.Sqrt(damage) * 5));
+
+        if (Condition.HealthPoints < 0)
+            OnKilledEvent?.Invoke(this);
+    }
+
+    public void ResetCharacter()
+    {
+        Condition = new CharacterCondition();
+    }
+}

Assets/Scripts/Character/Player.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: a8c9a8e604d395c4ab9d03d28adc4982
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Assets/Scripts/Character/scr_CharacterController.cs

@@ -5,7 +5,7 @@ using Unity.Barracuda;
 using UnityEngine;
 using UnityEngine.InputSystem;
 
-using static scr_Models; 
+using static scr_Models;
 
 public class scr_CharacterController : MonoBehaviour
 {
@@ -17,7 +17,7 @@ public class scr_CharacterController : MonoBehaviour
     public Vector2 input_Movement;
     [HideInInspector]
     public Vector2 input_View;
-   
+
     private Vector3 newCameraRotation;
     private Vector3 newCharacterRotation;
 
@@ -25,14 +25,14 @@ public class scr_CharacterController : MonoBehaviour
     public Transform cameraHolder;
     public Transform feetTransform;
 
-    [Header("Settings")] 
+    [Header("Settings")]
     public PlayerSettingsModel playerSettings;
 
     public float ViewClampYMin = -70;
     public float ViewClampYMax = 80;
     public LayerMask playerMask;
-    
-    [Header("Gravity")] 
+
+    [Header("Gravity")]
     public float gravityAmount;
     public float gravityMin;
     private float playerGravity;
@@ -40,14 +40,14 @@ public class scr_CharacterController : MonoBehaviour
     public Vector3 jumpingForce;
     private Vector3 jumpingForceVelocity;
 
-    [Header("Stance")] 
+    [Header("Stance")]
     public PlayerStance playerStance;
     public float playerStanceSmoothing;
     public CharacterStance playerStandStance;
     public CharacterStance playerCrouchStance;
     public CharacterStance playerProneStance;
     private float stanceCheckErrorMargin = 0.05f;
-    
+
     private float cameraHeight;
     private float cameraHeightVelocity;
 
@@ -77,13 +77,13 @@ public class scr_CharacterController : MonoBehaviour
         defaultInput.Character.Movement.performed += e => input_Movement = e.ReadValue<Vector2>();
         defaultInput.Character.View.performed += e => input_View = e.ReadValue<Vector2>();
         defaultInput.Character.Jump.performed += e => Jump();
-        
+
         defaultInput.Character.Crouch.performed += e => Crouch();
         defaultInput.Character.Prone.performed += e => Prone();
-        
+
         defaultInput.Character.Sprint.performed += e => ToggleSprint();
         defaultInput.Character.SprintReleased.performed += e => StopSprint();
-      
+
         defaultInput.Enable();
 
         newCameraRotation = cameraHolder.localRotation.eulerAngles;
@@ -134,10 +134,10 @@ public class scr_CharacterController : MonoBehaviour
     {
         newCharacterRotation.y += playerSettings.ViewXSensetivity * (playerSettings.ViewXInverted ? -input_View.x : input_View.x) * Time.deltaTime;
         transform.localRotation = Quaternion.Euler(newCharacterRotation);
-        
+
         newCameraRotation.x += playerSettings.ViewYSensetivity * (playerSettings.ViewYInverted ? input_View.y : -input_View.y) * Time.deltaTime;
         newCameraRotation.x = Mathf.Clamp(newCameraRotation.x, ViewClampYMin, ViewClampYMax);
-        
+
         cameraHolder.localRotation = Quaternion.Euler(newCameraRotation);
     }
 
@@ -159,18 +159,18 @@ public class scr_CharacterController : MonoBehaviour
             verticalSpeed = playerSettings.RunningForwardSpeed;
             horizontalSpeed = playerSettings.RunningStrafeSpeed;
         }
-        
+
         // Effectors
         
         if (!characterController.isGrounded)
         {
             playerSettings.SpeedEffector = playerSettings.FallingSpeedEffector;
         }
-        else if(playerStance == PlayerStance.Crouch)
+        else if (playerStance == PlayerStance.Crouch)
         {
             playerSettings.SpeedEffector = playerSettings.CrouchSpeedEffector;
-        } 
-        else if(playerStance == PlayerStance.Prone)
+        }
+        else if (playerStance == PlayerStance.Prone)
         {
             playerSettings.SpeedEffector = playerSettings.ProneSpeedEffector;
         }
@@ -188,12 +188,12 @@ public class scr_CharacterController : MonoBehaviour
 
         verticalSpeed *= playerSettings.SpeedEffector;
         horizontalSpeed *= playerSettings.SpeedEffector;
-        
+
         newMovementSpeed = Vector3.SmoothDamp(newMovementSpeed,
        new Vector3(horizontalSpeed * input_Movement.x * Time.deltaTime,
           0, verticalSpeed * input_Movement.y * Time.deltaTime),
             ref newMovementSpeedVelocity, characterController.isGrounded ? playerSettings.MovementSmoothing : playerSettings.FallingSmoothing);
-        
+
         var MovementSpeed = transform.TransformDirection(newMovementSpeed);
 
         if (playerGravity > gravityMin)
@@ -208,7 +208,7 @@ public class scr_CharacterController : MonoBehaviour
 
         MovementSpeed.y += playerGravity;
         MovementSpeed += jumpingForce * Time.deltaTime;
-        
+
         characterController.Move(MovementSpeed);
     }
 
@@ -229,7 +229,7 @@ public class scr_CharacterController : MonoBehaviour
         {
             stanceHeight = playerProneStance.CameraHeight;
         }
-        
+
         cameraHeight = Mathf.SmoothDamp(cameraHolder.localPosition.y, stanceHeight, ref cameraHeightVelocity, playerStanceSmoothing);
 
         cameraHolder.localPosition = new Vector3(cameraHolder.localPosition.x, cameraHeight, cameraHolder.localPosition.z);
@@ -240,7 +240,7 @@ public class scr_CharacterController : MonoBehaviour
         {
             return;
         }
-        
+
         if (playerStance == PlayerStance.Crouch)
         {
             if (StanceCheck(playerStandStance.StanceCollider.height))
@@ -250,7 +250,7 @@ public class scr_CharacterController : MonoBehaviour
             playerStance = PlayerStance.Stand;
             return;
         }
-        
+
         // Jump
         jumpingForce = Vector3.up * playerSettings.JumpingHeight;
         playerGravity = 0;
@@ -283,8 +283,8 @@ public class scr_CharacterController : MonoBehaviour
     {
         var start = new Vector3(feetTransform.position.x, feetTransform.position.y + characterController.radius + stanceCheckErrorMargin, feetTransform.position.z);
         var end = new Vector3(feetTransform.position.x, feetTransform.position.y - characterController.radius - stanceCheckErrorMargin + stanceCheckheight, feetTransform.position.z);
-        
-        
+
+
         return Physics.CheckCapsule(start, end, characterController.radius, playerMask);
     }
 
@@ -297,7 +297,7 @@ public class scr_CharacterController : MonoBehaviour
         }
         isSprinting = !isSprinting;
     }
-    
+
     private void StopSprint()
     {
         if (playerSettings.SprintingHold)
@@ -305,5 +305,5 @@ public class scr_CharacterController : MonoBehaviour
             isSprinting = false;
         }
     }
-    
+
 }

Assets/Scripts/Character/scr_Models.cs

@@ -1,62 +1,45 @@
-using System;
+using System;
 using UnityEngine;
 
 public static class scr_Models
 {
-   #region Player
-   
-   public enum PlayerStance
-   {
-      Stand,
-      Crouch,
-      Prone
-   }
-   
-   [Serializable]
-   public class PlayerSettingsModel
-   {
-      [Header("View Settings")]
-      public float ViewXSensetivity;
-      public float ViewYSensetivity;
+    #region Player
 
-      public bool ViewXInverted;
-      public bool ViewYInverted;
+    public enum PlayerStance
+    {
+        Stand,
+        Crouch,
+        Prone
+    }
 
-      [Header("Movement Settings")] 
-      public bool SprintingHold;
-      public float MovementSmoothing;
-      
-      [Header("Movement - Running")] 
-      public float RunningForwardSpeed;
-      public float RunningStrafeSpeed;
-      
-      [Header("Movement - Walking")] 
-      public float WalkingForwardSpeed;
-      public float WalkingBackwardSpeed;
-      public float WalkingStrafeSpeed;
+    [Serializable]
+    public class PlayerSettingsModel
+    {
+        [Header("View Settings")]
+        public float ViewXSensetivity;
+        public float ViewYSensetivity;
 
-      [Header("Jumping")] 
-      public float JumpingHeight;
-      public float JumpingFalloff;
-      public float FallingSmoothing;
+        public bool ViewXInverted;
+        public bool ViewYInverted;
 
-      [Header("Speed Effectors")] 
-      public float SpeedEffector = 1;
-      public float CrouchSpeedEffector;
-      public float ProneSpeedEffector;
-      public float FallingSpeedEffector;
-   }
+        [Header("Movement Settings")]
+        public bool SprintingHold;
+        public float MovementSmoothing;
 
-   [Serializable]
-   public class CharacterStance
-   {
-      public float CameraHeight;
-      public CapsuleCollider StanceCollider;
-   }
+        [Header("Movement - Running")]
+        public float RunningForwardSpeed;
+        public float RunningStrafeSpeed;
 
-   #endregion
+        [Header("Movement - Walking")]
+        public float WalkingForwardSpeed;
+        public float WalkingBackwardSpeed;
+        public float WalkingStrafeSpeed;
 
-   #region - Weapons -
+        [Header("Jumping")]
+        public float JumpingHeight;
+        public float JumpingFalloff;
+        public float FallingSmoothing;
+    }
 
    [Serializable]
    public class WeaponSettingsModel
@@ -78,5 +61,29 @@ public static class scr_Models
       public float MovementSwaySmoothing;
    }
 
-   #endregion
+    [Serializable]
+    public class CharacterStance
+    {
+        public float CameraHeight;
+        public CapsuleCollider StanceCollider;
+    }
+
+    #endregion
+
+    #region - Weapons -
+
+    [Serializable]
+    public class WeaponSettingsModel
+    {
+        [Header("Sway")]
+        public float SwayAmount;
+        public bool SwayYInverted;
+        public bool SwayXInverted;
+        public float SwaySmoothing;
+        public float SwayResetSmoothing;
+        public float SwayClampX;
+        public float SwayClampY;
+    }
+
+    #endregion
 }