Initial. Added files

Assets/Scripts/Character/CharacterCondition.cs

@@ -0,0 +1,39 @@
+using System;
+using UnityEngine;
+
+public class CharacterCondition : MonoBehaviour
+{
+    public event Action<object> OnKilledEvent;
+    public event Action<int> OnDamageHealthTakenEvent;
+    public event Action<int> OnDamageArmourTakenEvent;
+    public event Action<int> OnAmmunitionTakenEvent;
+
+    [SerializeField] private int HealthPoints;
+    [SerializeField] private int ArmourPoints;
+    [SerializeField] private int Ammunition;
+
+    public void Start()
+    {
+        
+    }
+    
+    public void GetDamage(float damage)
+    {
+        HealthPoints -= Mathf.RoundToInt(damage * (1 - ArmourPoints * 0.5f));
+        ArmourPoints -= Mathf.RoundToInt(Mathf.Sqrt(damage) * 5);
+
+        OnDamageHealthTakenEvent?.Invoke(HealthPoints);
+        OnDamageArmourTakenEvent?.Invoke(ArmourPoints);
+        if (HealthPoints < 0)
+            OnKilledEvent?.Invoke(gameObject);
+    }
+    public void GiveHealth(int health) => HealthPoints = Mathf.Clamp(health + HealthPoints, 0, 100);
+    public void SetHealth(int health) => HealthPoints = Mathf.Clamp(health, 0, 100);
+    public void GiveArmour(int armour) => ArmourPoints = Mathf.Clamp(armour + ArmourPoints, 0, 100);
+    public void SetArmour(int armour) => ArmourPoints = Mathf.Clamp(armour, 0, 100);
+    public void TakeAmmo(int ammo)
+    {
+        Ammunition += ammo;
+        OnAmmunitionTakenEvent?.Invoke(Ammunition);
+    }
+}

Assets/Scripts/Character/CharacterCondition.cs.meta

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

Assets/Scripts/Character/MovementController.cs

@@ -0,0 +1,38 @@
+using System.Linq;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.AI;
+
+[RequireComponent(typeof(NavMeshAgent))]
+public class MovementController : MonoBehaviour
+{
+    public NavPoint currentPosition { get; private set; }
+    [SerializeField] private MapManager mapManager;
+    [SerializeField] private NavMeshAgent navMeshAgent;
+
+    private void Start()
+    {
+        navMeshAgent.speed = SettingsReader.Instance.GetSettings.movementSpeed;
+    }
+
+    public void Move()
+    {
+        var pointCandidate = getPointCandidate();
+        goToNextNavPoint(pointCandidate);
+    }
+
+    
+    // todo внутри сенсора передавать в mlagents как variable length observations: https://github.com/Unity-Technologies/ml-agents/blob/main/docs/Learning-Environment-Design-Agents.md#variable-length-observations
+    private NavPoint getPointCandidate()
+    {
+        var NavPointsPositions = mapManager.navPoints
+            .Select(point => point.transform.position)
+            .Where(point => (currentPosition.transform.position - point).magnitude <= SettingsReader.Instance.GetSettings.movementSpeed)
+            .ToList();
+        //TODO AI
+        return null;
+    }
+
+    private void goToNextNavPoint(NavPoint destination) =>
+        navMeshAgent.SetDestination(destination.transform.position);
+}

Assets/Scripts/Character/MovementController.cs.meta

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

Assets/Scripts/Character/NPC.cs

@@ -0,0 +1,37 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using Unity.MLAgents;
+using Unity.MLAgents.Sensors;
+
+public class NPC : Agent
+{
+    public float LastTimeHit;
+    private BaseBehaviour NPCBehaviour;
+    public List<Action> ActionList;
+    
+    [SerializeField]
+    private List<ISensor> SensorList; // todo тут интерфейс должен быть наш
+
+    public void SetBehaviour(BaseBehaviour behaviour) => NPCBehaviour = behaviour;
+    public Team Team { get; set; }
+    private void Start()
+    {
+       
+    }
+    
+    public override void CollectObservations(VectorSensor sensor)
+    {
+        // Target and Agent positions
+        foreach (var _sensor in SensorList)
+        {
+            sensor.AddObservation(1); // todo
+            // sensor.AddObservation(_sensor.GetValue());
+        }
+    }
+    
+    private void Update()
+    {
+        //NPCBehaviour.DoAction();
+    }
+}

Assets/Scripts/Character/NPC.cs.meta

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

Assets/Scripts/Character/scr_CharacterController.cs

@@ -0,0 +1,259 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using Unity.Barracuda;
+using UnityEngine;
+
+using static scr_Models; 
+
+public class scr_CharacterController : MonoBehaviour
+{
+
+    private CharacterController characterController;
+    private DefaultInput defaultInput;
+    private Vector2 input_Movement;
+    [HideInInspector]
+    public Vector2 input_View;
+   
+    private Vector3 newCameraRotation;
+    private Vector3 newCharacterRotation;
+
+    [Header("References")]
+    public Transform cameraHolder;
+    public Transform feetTransform;
+
+    [Header("Settings")] 
+    public PlayerSettingsModel playerSettings;
+
+    public float ViewClampYMin = -70;
+    public float ViewClampYMax = 80;
+    public LayerMask playerMask;
+    
+    [Header("Gravity")] 
+    public float gravityAmount;
+    public float gravityMin;
+    private float playerGravity;
+
+    public Vector3 jumpingForce;
+    private Vector3 jumpingForceVelocity;
+
+    [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;
+
+    private bool isSprinting;
+
+    private Vector3 newMovementSpeed;
+    private Vector3 newMovementSpeedVelocity;
+
+    [Header("Weapon")] public scr_WeaponController currentWeapon;
+    private void Awake()
+    {
+        defaultInput = new DefaultInput();
+
+        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;
+        newCharacterRotation = transform.localRotation.eulerAngles;
+        characterController = GetComponent<CharacterController>();
+
+        cameraHeight = cameraHolder.localPosition.y;
+
+        if (currentWeapon)
+        {
+            currentWeapon.Initialise(this);
+        }
+        
+    }
+
+    private void Update()
+    {
+        CalculateView();
+        CalculateMovement();
+        CalculateJump();
+        CalculateCameraHeight();
+    }
+
+    private void CalculateView()
+    {
+        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);
+    }
+
+    private void CalculateMovement()
+    {
+        if (input_Movement.y <= 0.2f)
+        {
+            isSprinting = false;
+        }
+        
+        var verticalSpeed = playerSettings.WalkingForwardSpeed;
+        var horizontalSpeed = playerSettings.WalkingStrafeSpeed;
+
+        if (isSprinting)
+        {
+            verticalSpeed = playerSettings.RunningForwardSpeed;
+            horizontalSpeed = playerSettings.RunningStrafeSpeed;
+        }
+        
+        // Effectors
+        if (!characterController.isGrounded)
+        {
+            playerSettings.SpeedEffector = playerSettings.FallingSpeedEffector;
+        }
+        else if(playerStance == PlayerStance.Crouch)
+        {
+            playerSettings.SpeedEffector = playerSettings.CrouchSpeedEffector;
+        } 
+        else if(playerStance == PlayerStance.Prone)
+        {
+            playerSettings.SpeedEffector = playerSettings.ProneSpeedEffector;
+        }
+        else
+        {
+            playerSettings.SpeedEffector = 1;
+        }
+        
+        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)
+        {
+            playerGravity -= gravityAmount * Time.deltaTime;
+        }
+
+        if (playerGravity < -0.1f && characterController.isGrounded)
+        {
+            playerGravity = -0.1f;
+        }
+
+        MovementSpeed.y += playerGravity;
+        MovementSpeed += jumpingForce * Time.deltaTime;
+        
+        characterController.Move(MovementSpeed);
+    }
+
+    private void CalculateJump()
+    {
+        jumpingForce = Vector3.SmoothDamp(jumpingForce, Vector3.zero, ref jumpingForceVelocity, playerSettings.JumpingFalloff);
+    }
+
+    private void CalculateCameraHeight()
+    {
+        var stanceHeight = playerStandStance.CameraHeight;
+
+        if (playerStance == PlayerStance.Crouch)
+        {
+            stanceHeight = playerCrouchStance.CameraHeight;
+        }
+        else if (playerStance == PlayerStance.Prone)
+        {
+            stanceHeight = playerProneStance.CameraHeight;
+        }
+        
+        cameraHeight = Mathf.SmoothDamp(cameraHolder.localPosition.y, stanceHeight, ref cameraHeightVelocity, playerStanceSmoothing);
+
+        cameraHolder.localPosition = new Vector3(cameraHolder.localPosition.x, cameraHeight, cameraHolder.localPosition.z);
+    }
+    private void Jump()
+    {
+        if (!characterController.isGrounded || playerStance == PlayerStance.Prone)
+        {
+            return;
+        }
+        
+        if (playerStance == PlayerStance.Crouch)
+        {
+            if (StanceCheck(playerStandStance.StanceCollider.height))
+            {
+                return;
+            }
+            playerStance = PlayerStance.Stand;
+            return;
+        }
+        
+        // Jump
+        jumpingForce = Vector3.up * playerSettings.JumpingHeight;
+        playerGravity = 0;
+    }
+
+    private void Crouch()
+    {
+        if (playerStance == PlayerStance.Crouch)
+        {
+            if (StanceCheck(playerStandStance.StanceCollider.height))
+            {
+                return;
+            }
+            playerStance = PlayerStance.Stand;
+            return;
+        }
+        if (StanceCheck(playerCrouchStance.StanceCollider.height))
+        {
+            return;
+        }
+        playerStance = PlayerStance.Crouch;
+    }
+
+    private void Prone()
+    {
+        playerStance = PlayerStance.Prone;
+    }
+
+    private bool StanceCheck(float stanceCheckheight)
+    {
+        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);
+    }
+
+    private void ToggleSprint()
+    {
+        if (input_Movement.y <= 0.2f)
+        {
+            isSprinting = false;
+            return;
+        }
+        isSprinting = !isSprinting;
+    }
+    
+    private void StopSprint()
+    {
+        if (playerSettings.SprintingHold)
+        {
+            isSprinting = false;
+        }
+    }
+    
+}

Assets/Scripts/Character/scr_CharacterController.cs.meta

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

Assets/Scripts/Character/scr_Models.cs

@@ -0,0 +1,75 @@
+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;
+
+      public bool ViewXInverted;
+      public bool ViewYInverted;
+
+      [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;
+
+      [Header("Jumping")] 
+      public float JumpingHeight;
+      public float JumpingFalloff;
+      public float FallingSmoothing;
+
+      [Header("Speed Effectors")] 
+      public float SpeedEffector = 1;
+      public float CrouchSpeedEffector;
+      public float ProneSpeedEffector;
+      public float FallingSpeedEffector;
+   }
+
+   [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
+}

Assets/Scripts/Character/scr_Models.cs.meta

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