Merge branch 'movement-dev' of https://github.com/ThomasCharester/CourierOld into movement-dev

Чисто для удобства, чтобы не было много грязюки

Game/CourierOld/Assets/Code/Configs/CharacterCameraConfig.cs

@@ -0,0 +1,38 @@
+using Code.Gameplay.Character.Core;
+using UnityEngine;
+
+namespace Code.Configs
+{
+    [CreateAssetMenu(fileName = "CharacterCameraConfig", menuName = "Config/CharacterCameraConfig")]
+    public class CharacterCameraConfig : ScriptableObject
+    {
+        public float 
+            // Расстояния от персонажа до камеры
+            defaultDistance = 6f,    // Стандартное расстояние камеры от цели
+            minDistance = 3f,        // Минимальное расстояние при зуме
+            maxDistance = 10f,       // Максимальное расстояние при зуме
+            
+            // Скорость зума камеры
+            distanceMovementSpeed = 5f,  // Множитель скорости изменения дистанции при зуме
+            
+            // Скорость поворота камеры
+            rotationSpeed = 0.3f,     // Множитель скорости вращения камеры
+            
+            // Скорость интерполяции текущее -> целевое вращение
+            rotationSharpness = 100f,  // Коэффициент плавности вращения камеры (чем выше - тем резче)
+            
+            // Резкость следования камеры за целью
+            followSharpness = 100f,  // Коэффициент плавности следования за движущейся целью (чем выше - тем резче)
+            
+            // Углы наклона камеры
+            minVerticalAngle = -70f,    // Минимальный угол наклона камеры (вниз)
+            maxVerticalAngle = 70f,     // Максимальный угол наклона камеры (вверх)
+            defaultVerticalAngle = 10f; // Стандартный угол наклона камеры
+        
+        // Текущий режим камеры
+        public CameraMode defaultCameraMode = CameraMode.MainMenu; 
+        
+        // Позиция следования по умолчанию (для меню)
+        public Vector3 defaultFollowPosition = Vector3.zero;
+    }
+}

Game/CourierOld/Assets/Code/Configs/CharacterCameraConfig.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 72fbf590e5fd4747acfdd32eb26bba3a
+timeCreated: 1761637489

Game/CourierOld/Assets/Code/Gameplay/Character/Camera.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b36ec6a31fb74d608232394fd5df657c
+timeCreated: 1761570832

Game/CourierOld/Assets/Code/Gameplay/Character/Camera/CharacterCamera.cs

@@ -1,64 +1,42 @@
 using System;
+using Code.Gameplay.Character.Core;
+using Code.StaticData;
+using Reflex.Attributes;
 using UnityEngine;
 
-namespace Code.Gameplay.Player
+namespace Code.Gameplay.Character.Camera
 {
-    /*
-     * Перечисление режимов работы камеры
-     * Static - статичная камера без следования за целью
-     * FirstPerson - камера от первого лица (встроена в модель персонажа)
-     * ThirdPerson - камера от третьего лица (следует за персонажем на расстоянии)
-     * Cinematic - кинематографическая камера для скриптовых сцен
-     */
-    public enum CameraMode
-    {
-        Static,
-        FirstPerson,
-        ThirdPerson,
-        Cinematic
-    }
-    
     /*
      * Скрипт, отвечающий за поведение камеры при передвижении
      * Поддерживает как 3rd-person, так и 1st-person режимы камеры
-     * Реализует плавное следование за игроком, вращение и зум камеры
+     * Реализует плавное следование за персонажем, вращение и зум камеры
      * 
      * Источник: Tvtig, https://www.youtube.com/watch?v=9ibpY64wBYM
      */ 
-    public class PlayerCamera : MonoBehaviour
+    public class CharacterCamera : MonoBehaviour
     {
-        [SerializeField] 
+        // Параметры загружаются из CharacterCameraConfig
         private float 
-            // Расстояния от игрока до камеры
-            defaultDistance = 6f,    // Стандартное расстояние камеры от цели
-            minDistance = 3f,        // Минимальное расстояние при зуме
-            maxDistance = 10f,       // Максимальное расстояние при зуме
-            
-            // Скорость зума камеры
-            distanceMovementSpeed = 5f,  // Множитель скорости изменения дистанции при зуме
-            
-            // Скорость поворота камеры
-            rotationSpeed = 0.3f,     // Множитель скорости вращения камеры
-            
-            // Скорость интерполяции текущее -> целевое вращение
-            rotationSharpness = 100f,  // Коэффициент плавности вращения камеры (чем выше - тем резче)
-            
-            // Резкость следования камеры за целью
-            followSharpness = 100f,  // Коэффициент плавности следования за движущейся целью (чем выше - тем резче)
-            
-            // Углы наклона камеры
-            minVerticalAngle = -70f,    // Минимальный угол наклона камеры (вниз)
-            maxVerticalAngle = 70f,     // Максимальный угол наклона камеры (вверх)
-            defaultVerticalAngle = 10f; // Стандартный угол наклона камеры
+            _defaultDistance,
+            _minDistance,
+            _maxDistance,
+            _distanceMovementSpeed,
+            _rotationSpeed,
+            _rotationSharpness,
+            _followSharpness,
+            _minVerticalAngle,
+            _maxVerticalAngle,
+            _defaultVerticalAngle;
         
-        // Текущий режим работы камеры
-
         // Трансформ объекта, за которым следует камера (для 1st-person: уровень глаз)
         private Transform _followTransform;
         
         // Позиция следования: текущая сглаженная позиция и горизонтальное направление камеры
         private Vector3 _currentFollowPosition;
         
+        // Fallback-позиция для режимов без цели (например, MainMenu)
+        private Vector3 _defaultFollowPosition;
+        
         // Целевой вертикальный угол камеры (наклон вверх/вниз)
         private float _targetVerticalAngle;
         
@@ -67,24 +45,56 @@ namespace Code.Gameplay.Player
         
         // Исходные значения дистанции для восстановления после FirstPerson режима
         private float _originalDefaultDistance, _originalMinDistance, _originalMaxDistance;
+        
+        // Горизонтальное направление камеры (проекция forward на плоскость)
+        public Vector3 PlanarDirection { get; private set; } 
+        
+        // Текущий режим работы камеры
+        public CameraMode CurrentMode { get; private set; }
+        
+        // DI для загрузки конфига
+        [Inject] private IStaticDataService _staticDataService;
+        
+        // Загрузка конфига для камеры
+        private void LoadConfig()
+        {
+            // Загрузка значений из конфигов
+            var config = _staticDataService.CharacterCameraConfig;
+            
+            _defaultDistance = config.defaultDistance;
+            _minDistance = config.minDistance;
+            _maxDistance = config.maxDistance;
+            _distanceMovementSpeed = config.distanceMovementSpeed;
+            _rotationSpeed = config.rotationSpeed;
+            _rotationSharpness = config.rotationSharpness;
+            _followSharpness = config.followSharpness;
+            _minVerticalAngle = config.minVerticalAngle;
+            _maxVerticalAngle = config.maxVerticalAngle;
+            _defaultVerticalAngle = config.defaultVerticalAngle;
+            CurrentMode = config.defaultCameraMode;
+            _defaultFollowPosition = config.defaultFollowPosition;
+            
+            // Валидация значений (на случай ручного редактирования конфига)
+            _defaultDistance = Mathf.Clamp(_defaultDistance, _minDistance, _maxDistance);
+            _defaultVerticalAngle = Mathf.Clamp(_defaultVerticalAngle, _minVerticalAngle, _maxVerticalAngle);
 
-        // Свойства для доступа к важным данным камеры извне
-        public Vector3 PlanarDirection { get; private set; } // Горизонтальное направление камеры
-
-        public CameraMode CurrentMode { get; private set; } = CameraMode.ThirdPerson; // Текущий режим камеры
-
+            // Сохраняем оригинальные значения для восстановления
+            _originalDefaultDistance = _defaultDistance;
+            _originalMinDistance = _minDistance;
+            _originalMaxDistance = _maxDistance;
+            
+            // Инициализация состояния камеры
+            _currentDistance = _defaultDistance;
+            _targetDistance = _currentDistance;
+            _targetVerticalAngle = _defaultVerticalAngle;
+            PlanarDirection = Vector3.forward; // Начальное направление - вперед по оси Z
+            _currentFollowPosition = _defaultFollowPosition;
+        }
+        
         // Инициализация камеры при создании
         private void Awake()
         {
-            // Сохраняем исходные значения дистанции для восстановления
-            _originalDefaultDistance = defaultDistance;
-            _originalMinDistance = minDistance;
-            _originalMaxDistance = maxDistance;
-            
-            _currentDistance = defaultDistance;
-            _targetDistance = _currentDistance;
-            _targetVerticalAngle = 0f;
-            PlanarDirection = Vector3.forward;  // Начальное направление - вперед по оси Z
+            LoadConfig();
         }
         
         // Установка цели для следования камеры
@@ -95,29 +105,21 @@ namespace Code.Gameplay.Player
             PlanarDirection = t.forward;  // Начальное направление совпадает с направлением цели
         }
         
-        // Валидация параметров в редакторе Unity
-        private void OnValidate()
-        {
-            // Обеспечиваем корректные значения дистанции и угла
-            defaultDistance = Mathf.Clamp(defaultDistance, minDistance, maxDistance);
-            defaultVerticalAngle = Mathf.Clamp(defaultVerticalAngle, minVerticalAngle, maxVerticalAngle);
-        }
-        
         // Обработка вращения камеры на основе пользовательского ввода
         private void HandleRotationInput(float deltaTime, Vector3 rotationInput, out Quaternion targetRotation)
         {
             // Вращение вокруг вертикальной оси (горизонтальный поворот)
-            var rotationFromInput = Quaternion.Euler(_followTransform.up * (rotationInput.x * rotationSpeed));
+            var rotationFromInput = Quaternion.Euler(_followTransform.up * (rotationInput.x * _rotationSpeed));
             PlanarDirection = rotationFromInput * PlanarDirection;
             var planarRotation = Quaternion.LookRotation(PlanarDirection, _followTransform.up);
             
             // Вращение вокруг горизонтальной оси (вертикальный наклон)
-            _targetVerticalAngle -= rotationInput.y * rotationSpeed;
-            _targetVerticalAngle = Math.Clamp(_targetVerticalAngle, minVerticalAngle, maxVerticalAngle);
+            _targetVerticalAngle -= rotationInput.y * _rotationSpeed;
+            _targetVerticalAngle = Math.Clamp(_targetVerticalAngle, _minVerticalAngle, _maxVerticalAngle);
             var verticalRotation = Quaternion.Euler(_targetVerticalAngle, 0, 0);
             
             // Интерполяция к целевому вращению для плавности
-            targetRotation = Quaternion.Slerp(transform.rotation, planarRotation * verticalRotation, deltaTime * rotationSharpness);
+            targetRotation = Quaternion.Slerp(transform.rotation, planarRotation * verticalRotation, deltaTime * _rotationSharpness);
             
             // Применение финального вращения
             transform.rotation = targetRotation;
@@ -130,12 +132,12 @@ namespace Code.Gameplay.Player
             if (CurrentMode != CameraMode.FirstPerson)
             {
                 // Обновление целевой дистанции на основе ввода зума
-                _targetDistance += zoomInput * distanceMovementSpeed;
-                _targetDistance = Mathf.Clamp(_targetDistance, minDistance, maxDistance);
+                _targetDistance += zoomInput * _distanceMovementSpeed;
+                _targetDistance = Mathf.Clamp(_targetDistance, _minDistance, _maxDistance);
             }
             
             // Плавное следование за целью с использованием экспоненциального сглаживания
-            _currentFollowPosition = Vector3.Lerp(_currentFollowPosition, _followTransform.position, 1f - Mathf.Exp(-followSharpness * deltaTime));
+            _currentFollowPosition = Vector3.Lerp(_currentFollowPosition, _followTransform.position, 1f - Mathf.Exp(-_followSharpness * deltaTime));
             
             // Вычисление целевой позиции камеры с учетом текущего режима
             Vector3 targetPosition;
@@ -153,7 +155,7 @@ namespace Code.Gameplay.Player
             // Плавное изменение текущей дистанции к целевой (только для ThirdPerson)
             if (CurrentMode != CameraMode.FirstPerson)
             {
-                _currentDistance = Mathf.Lerp(_currentDistance, _targetDistance, 1f - Mathf.Exp(-distanceMovementSpeed * deltaTime));
+                _currentDistance = Mathf.Lerp(_currentDistance, _targetDistance, 1f - Mathf.Exp(-_distanceMovementSpeed * deltaTime));
             }
             
             // Установка финальной позиции камеры
@@ -163,11 +165,11 @@ namespace Code.Gameplay.Player
         // Основной метод обновления камеры, вызываемый извне каждый кадр
         public void UpdateWithInput(float deltaTime, float zoomInput, Vector3 rotationInput)
         {
-            // Проверка наличия цели для следования
-            if (!_followTransform) return;
+            // Проверка наличия цели для следования и проверка на режим главного меню
+            if (!_followTransform || CurrentMode == CameraMode.MainMenu) return;
             
             // Обработка ввода и позиционирования
-            HandleRotationInput(deltaTime, rotationInput, out Quaternion targetRotation);
+            HandleRotationInput(deltaTime, rotationInput, out var targetRotation);
             HandlePosition(deltaTime, zoomInput, targetRotation);
         }
         
@@ -188,20 +190,21 @@ namespace Code.Gameplay.Player
             {
                 case CameraMode.FirstPerson:
                     // В FirstPerson режиме дистанция всегда равна 0
-                    minDistance = 0f;
-                    maxDistance = 0f;
-                    defaultDistance = 0f;
+                    _minDistance = 0f;
+                    _maxDistance = 0f;
+                    _defaultDistance = 0f;
                     _targetDistance = 0f;
                     _currentDistance = 0f;
                     break;
                 case CameraMode.ThirdPerson:
                     // Восстанавливаем исходные значения дистанции
-                    minDistance = _originalMinDistance;
-                    maxDistance = _originalMaxDistance;
-                    defaultDistance = _originalDefaultDistance;
-                    _targetDistance = defaultDistance;
+                    _minDistance = _originalMinDistance;
+                    _maxDistance = _originalMaxDistance;
+                    _defaultDistance = _originalDefaultDistance;
+                    _targetDistance = _defaultDistance;
                     break;
                 // Заготовка на будущее (если понадобится)
+                case CameraMode.MainMenu:
                 case CameraMode.Static:
                 case CameraMode.Cinematic:
                 default:

Game/CourierOld/Assets/Code/Gameplay/Character/Controller.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: fb497e2e267044a7a35f80b47c88c2c9
+timeCreated: 1761570825

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Abilities.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: d3be946108b44b33b99d2e3e4a75d47f
+timeCreated: 1761571338

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Abilities/SlideMechanic.cs

@@ -0,0 +1,122 @@
+using KinematicCharacterController;
+using UnityEngine;
+using Code.Gameplay.Character.Core;
+
+namespace Code.Gameplay.Character.Controller.Abilities
+{
+    /*
+     * Механика слайда для персонажа
+     * Отвечает за управление состоянием, таймерами и скоростью слайда
+     */
+    public class SlideMechanic
+    {
+        // Скорость слайда
+        private readonly float _slideSpeed;
+        // Длительность слайда в секундах
+        private readonly float _slideDuration;
+        // Время перезарядки слайда
+        private readonly float _slideCooldown;
+
+        // Таймер слайда
+        private float _slideTimer;
+        // Таймер перезарядки слайда
+        private float _slideCooldownTimer;
+        // Направление слайда
+        private Vector3 _slideDirection;
+        // Флаг запроса слайда
+        private bool _slideRequested;
+        
+        // Свойство-флаг, активен ли слайд
+        public bool IsSliding { get; private set; }
+        
+        // Конструктор механики слайда
+        public SlideMechanic(float slideSpeed, float slideDuration, float slideCooldown)
+        {
+            _slideSpeed = slideSpeed;
+            _slideDuration = slideDuration;
+            _slideCooldown = slideCooldown;
+        }
+
+        // Обновляем таймер перезарядки слайда
+        public void TickCooldown(float deltaTime)
+        {
+            if (_slideCooldownTimer > 0f)
+            {
+                _slideCooldownTimer -= deltaTime;
+            }
+        }
+
+        // Обработка слайда
+        public void RequestSlide(bool slidePressed)
+        {
+            if (slidePressed && !_slideRequested && _slideCooldownTimer <= 0f)
+            {
+                _slideRequested = true;
+            }
+        }
+
+        // Начало слайда
+        public void TryStartSlide(KinematicCharacterMotor motor,
+            CameraMode currentCameraMode,
+            Quaternion firstPersonCameraRotation,
+            Vector3 lookInputVector)
+        {
+            // Проверяем условия для старта слайда
+            if (!_slideRequested || !motor.GroundingStatus.IsStableOnGround || _slideCooldownTimer > 0f)
+            {
+                _slideRequested = false;
+                return;
+            }
+
+            IsSliding = true;
+            _slideTimer = _slideDuration;
+            
+            // НАПРАВЛЕНИЕ СЛАЙДА - ВСЕГДА ВПЕРЕД ПО КАМЕРЕ
+            // Используем направление камеры, но проецируем на горизонтальную плоскость
+            var slideDir = currentCameraMode == CameraMode.FirstPerson ? 
+                firstPersonCameraRotation * Vector3.forward : 
+                lookInputVector;
+            
+            // Проецируем на горизонтальную плоскость и нормализуем
+            _slideDirection = Vector3.ProjectOnPlane(slideDir, motor.CharacterUp).normalized;
+            
+            // Если направление нулевое (персонаж стоит на месте), используем направление вперед
+            if (_slideDirection.sqrMagnitude < 0.01f)
+            {
+                _slideDirection = motor.CharacterForward;
+            }
+
+            // Устанавливаем перезарядку
+            _slideCooldownTimer = _slideCooldown;
+            _slideRequested = false;
+        }
+
+        // Обработка слайда
+        public void HandleSlide(ref Vector3 currentVelocity, float deltaTime, KinematicCharacterMotor motor)
+        {
+            // Уменьшаем таймер слайда
+            _slideTimer -= deltaTime;
+            
+            // Если время слайда вышло, персонаж в воздухе - заканчиваем слайд
+            if (_slideTimer <= 0f || !motor.GroundingStatus.IsStableOnGround)
+            {
+                EndSlide();
+                return;
+            }
+            
+            // Устанавливаем скорость слайда вперед
+            // Используем прямую установку скорости вместо сложных вычислений
+            currentVelocity = _slideDirection * _slideSpeed;
+            
+            // Добавляем небольшую вертикальную компоненту для лучшего скольжения по неровностям
+            currentVelocity += motor.CharacterUp * 2f;
+        }
+
+        // Завершение слайда
+        public void EndSlide()
+        {
+            IsSliding = false;
+            _slideTimer = 0f;
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Abilities/SlideMechanic.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5904fa03346e4751967d57500ab3d1cf
+timeCreated: 1761571347

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Abilities/WallClimbMechanic.cs

@@ -0,0 +1,51 @@
+using KinematicCharacterController;
+using UnityEngine;
+
+namespace Code.Gameplay.Character.Controller.Abilities
+{
+    /*
+     * Механика залазания на стены
+     * Обрабатывает столкновения и применяет вертикальный импульс при ударе о стену с достаточной скоростью
+     */
+    public class WallClimbMechanic
+    {
+        // Коэффициент преобразования горизонтальной скорости в вертикальную при залазании на стену
+        private readonly float _wallClimbSpeedFactor;
+        // Минимальная горизонтальная скорость для начала залазания на стену
+        private readonly float _minWallClimbSpeed;
+        
+        // Конструктор механики залазания на стену
+        public WallClimbMechanic(float wallClimbSpeedFactor, float minWallClimbSpeed)
+        {
+            _wallClimbSpeedFactor = wallClimbSpeedFactor;
+            _minWallClimbSpeed = minWallClimbSpeed;
+        }
+
+        // Обработка столкновения при движении (вызывается при ударе о препятствие)
+        public void OnMovementHit(KinematicCharacterMotor motor, Vector3 hitNormal)
+        {
+            // Проверяем, что это вертикальная или почти вертикальная поверхность (стена)
+            var dotWithUp = Vector3.Dot(hitNormal, motor.CharacterUp);
+            if (Mathf.Abs(dotWithUp) > 0.1f) return; // Не стена — это пол или потолок
+
+            // Получаем текущую скорость персонажа
+            var currentVelocity = motor.Velocity;
+
+            // Проекция скорости на направление к стене (отрицательная, если летим в стену)
+            var velocityIntoWall = Vector3.Dot(currentVelocity, -hitNormal);
+
+            // Если движемся в стену с достаточной скоростью
+            if (velocityIntoWall > _minWallClimbSpeed)
+            {
+                // Преобразуем часть горизонтальной скорости в вертикальную
+                var verticalBoost = velocityIntoWall * _wallClimbSpeedFactor;
+
+                // Добавляем вертикальный импульс через BaseVelocity
+                motor.BaseVelocity += motor.CharacterUp * verticalBoost;
+
+                // Предотвращаем заземление и повторное применение в этом кадре
+                motor.ForceUnground();
+            }
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Abilities/WallClimbMechanic.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: cfce19738ff34be286c953e33e515c46
+timeCreated: 1761571364

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/CustomCharacterController.cs

@@ -0,0 +1,220 @@
+using Code.Gameplay.Character.Controller.Abilities;
+using Code.Gameplay.Character.Controller.Input;
+using Code.Gameplay.Character.Controller.Movement;
+using Code.Gameplay.Character.Core;
+using KinematicCharacterController;
+using UnityEngine;
+
+namespace Code.Gameplay.Character.Controller
+{
+    /*
+     * Скрипт, отвечающий за передвижение персонажа
+     * Реализует физическое движение персонажа с использованием Kinematic Character Controller
+     * Обрабатывает ввод пользователя, применяет движение и вращение с учетом поверхности
+     *
+     * Источник: Tvtig, https://www.youtube.com/watch?v=9ibpY64wBYM
+     */
+    public class CustomCharacterController : MonoBehaviour, ICharacterController
+    {
+        [SerializeField]
+        private KinematicCharacterMotor motor; // Движок физического перемещения персонажа
+
+        [SerializeField]
+        private float 
+            maxStableMoveSpeed = 8f,           // Максимальная скорость движения по устойчивой поверхности
+            sprintMoveSpeed = 12f,             // Максимальная скорость спринта
+            slideSpeed = 20f,                  // Скорость слайда
+            slideDuration = 0.8f,              // Длительность слайда в секундах
+            slideCooldown = 1.5f,              // Время перезарядки слайда
+            stableMovementSharpness = 15f,     // Резкость изменения скорости движения (чем выше - тем резче)
+            orientationSharpness = 10f,        // Резкость изменения вращения персонажа (чем выше - тем резче)
+            jumpSpeed = 10f,                   // Скорость прыжка
+            wallClimbSpeedFactor = 0.8f,       // Коэффициент преобразования горизонтальной скорости в вертикальную при залазании на стену
+            minWallClimbSpeed = 9f;            // Минимальная горизонтальная скорость для начала залазания на стену
+
+        [SerializeField]
+        private Vector3 gravity = new(0, -30f, 0); // Вектор, отвечающий за применение гравитации
+        
+        // Подсистемы
+        private readonly CharacterInputHandler _inputHandler;
+        private readonly SlideMechanic _slideMechanic;
+        private readonly WallClimbMechanic _wallClimbMechanic;
+        private readonly GroundMovementSystem _groundMovement;
+        private readonly AirMovementSystem _airMovement;
+        
+        // Конструктор без параметров, инициализирующий контроллер
+        public CustomCharacterController()
+        {
+            _inputHandler = new CharacterInputHandler();
+            _slideMechanic = new SlideMechanic(slideSpeed, slideDuration, slideCooldown);
+            _wallClimbMechanic = new WallClimbMechanic(wallClimbSpeedFactor, minWallClimbSpeed);
+            _groundMovement = new GroundMovementSystem(maxStableMoveSpeed, sprintMoveSpeed, stableMovementSharpness, jumpSpeed);
+            _airMovement = new AirMovementSystem(gravity);
+        }
+        
+        // Текущий режим камеры для адаптации поведения
+        private CameraMode _currentCameraMode = CameraMode.ThirdPerson;
+
+        // Инициализация контроллера
+        private void Start()
+        {
+            motor.CharacterController = this; // Регистрация этого контроллера в движке
+            _inputHandler.FirstPersonCameraRotation = motor.Transform.rotation; // Начальное вращение совпадает с персонажем
+        }
+
+        // Обработка и преобразование входных данных от персонажа
+        public void SetInputs(ref CharacterInputs inputs)
+        {
+            // Обновляем таймер перезарядки слайда
+            _slideMechanic.TickCooldown(Time.deltaTime);
+    
+            // Если активен слайд - игнорируем весь остальной ввод
+            if (_slideMechanic.IsSliding)
+            {
+                // Во время слайда не обрабатываем движение, прыжки и спринт
+                _inputHandler.MoveInputVector = Vector3.zero;
+                _inputHandler.LookInputVector = Vector3.one;
+                _inputHandler.IsSprinting = false;
+                _groundMovement.RequestJump(inputs.JumpPressed);
+                return;
+            }
+    
+            // Сохраняем текущий режим камеры
+            _currentCameraMode = inputs.CameraMode;
+    
+            // Обработка слайда
+            _slideMechanic.RequestSlide(inputs.SlidePressed);
+
+            // Обработка остального ввода
+            _inputHandler.ProcessInputs(ref inputs, motor);
+    
+            // Передаём запрос прыжка напрямую в систему движения по земле
+            _groundMovement.RequestJump(inputs.JumpPressed);
+        }
+
+        // Обновление вращения персонажа на основе входных данных
+        public void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
+        {
+            // ВО ВРЕМЯ СЛАЙДА НЕ ОБНОВЛЯЕМ ВРАЩЕНИЕ - ПЕРСОНАЖ СМОТРИТ ПРЯМО
+            if (_slideMechanic.IsSliding) return;
+
+            switch (_currentCameraMode)
+            {
+                // В FirstPerson режиме применяем вращение камеры напрямую к персонажу (только горизонталь)
+                case CameraMode.FirstPerson when _inputHandler.ShouldApplyCameraRotation:
+                    // Немедленно применяем горизонтальное вращение камеры к персонажу
+                    currentRotation = _inputHandler.FirstPersonCameraRotation;
+                    break;
+                // В ThirdPerson режиме плавно поворачиваем персонаж в направлении движения
+                case CameraMode.ThirdPerson:
+                {
+                    // Вращение применяется только если есть направление движения и разрешена резкость вращения
+                    if (_inputHandler.LookInputVector.sqrMagnitude > 0 && orientationSharpness > 0)
+                    {
+                        // Плавная интерполяция текущего направления к целевому с экспоненциальным сглаживанием
+                        var smoothedLookInputDirection = Vector3.Slerp(
+                            motor.CharacterForward, 
+                            _inputHandler.LookInputVector, 
+                            1f - Mathf.Exp(-orientationSharpness * deltaTime)
+                        ).normalized;
+
+                        // Установка нового вращения смотря в сглаженном направлении
+                        currentRotation = Quaternion.LookRotation(smoothedLookInputDirection, motor.CharacterUp);
+                    }
+
+                    break;
+                }
+                // Заготовка на будущее (если понадобится)
+                case CameraMode.Static:
+                case CameraMode.Cinematic:
+                case CameraMode.MainMenu: // Скорее всего юзлес, но пускай будет
+                default:
+                    break;
+            }
+        }
+
+        // Обновление скорости движения персонажа
+        public void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
+        {
+            // Если во время слайда запрошен прыжок — прерываем слайд
+            if (_slideMechanic.IsSliding && _groundMovement.JumpRequested)
+            {
+                _slideMechanic.EndSlide();
+            }
+            
+            // Проверяем запрос слайда и запускаем его если можно
+            if (!_slideMechanic.IsSliding)
+            {
+                _slideMechanic.TryStartSlide(motor, _currentCameraMode, _inputHandler.FirstPersonCameraRotation, _inputHandler.LookInputVector);
+            }
+            // Если активен слайд - обрабатываем отдельно
+            else
+            {
+                _slideMechanic.HandleSlide(ref currentVelocity, deltaTime, motor);
+                return;
+            }
+            
+            // Если персонаж находится на земле
+            if (motor.GroundingStatus.IsStableOnGround)
+            {
+                _groundMovement.UpdateVelocity(ref currentVelocity, _inputHandler, motor, deltaTime);
+            }
+            // Если персонаж не находится на земле
+            else
+            {
+                _airMovement.UpdateVelocity(ref currentVelocity, deltaTime);
+                // Отменяем прыжок (фикс проблемы с двойным прыжком после приземления)
+                _groundMovement.CancelJumpRequest();
+            }
+        }
+
+        // Метод вызывается перед обновлением персонажа (можно использовать для подготовки)
+        public void BeforeCharacterUpdate(float deltaTime)
+        {
+        }
+
+        // Метод вызывается после обработки столкновения с землей
+        public void PostGroundingUpdate(float deltaTime)
+        {
+            // Если во время слайда персонаж оторвался от земли - заканчиваем слайд
+            if (_slideMechanic.IsSliding && !motor.GroundingStatus.IsStableOnGround)
+            {
+                _slideMechanic.EndSlide();
+            }
+        }
+
+        // Метод вызывается после обновления персонажа (можно использовать для пост-обработки)
+        public void AfterCharacterUpdate(float deltaTime)
+        {
+        }
+
+        // Проверка валидности коллайдера для обработки столкновений
+        public bool IsColliderValidForCollisions(Collider coll)
+        {
+            return true; // Все коллайдеры считаются валидными для столкновений
+        }
+
+        // Обработка столкновения с землей (вызывается при приземлении)
+        public void OnGroundHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, ref HitStabilityReport hitStabilityReport)
+        {
+        }
+
+        // Обработка столкновения при движении (вызывается при ударе о препятствие)
+        public void OnMovementHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint,
+            ref HitStabilityReport hitStabilityReport)
+        {
+            _wallClimbMechanic.OnMovementHit(motor, hitNormal);
+        }
+
+        // Обработка отчета о стабильности столкновения
+        public void ProcessHitStabilityReport(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, Vector3 atCharacterPosition,
+            Quaternion atCharacterRotation, ref HitStabilityReport hitStabilityReport)
+        {
+        }
+
+        // Обработка дискретных столкновений (для триггеров и специальных коллайдеров)
+        public void OnDiscreteCollisionDetected(Collider hitCollider)
+        {
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Input.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e50ac1a55a4f4706b6385746eb9c6d1f
+timeCreated: 1761571269

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Input/CharacterInputHandler.cs

@@ -0,0 +1,115 @@
+using UnityEngine;
+using Code.Gameplay.Character.Core;
+using KinematicCharacterController;
+
+namespace Code.Gameplay.Character.Controller.Input
+{
+    /*
+     * Обработчик входных данных для персонажа
+     * Преобразует сырые данные ввода в векторы движения и направления взгляда
+     */
+    public class CharacterInputHandler
+    {
+        // Векторы движения и направления взгляда
+        public Vector3 MoveInputVector { get; set; }
+        public Vector3 LookInputVector { get; set; }
+
+        // Флаг-свойство указывающий, что активен режим спринта
+        public bool IsSprinting { get; set; }
+
+        // Вращение камеры в FirstPerson режиме для синхронизации (только горизонтальная компонента)
+        public Quaternion FirstPersonCameraRotation { get; set; }
+        
+        // Флаг-свойство указывающий, что нужно применить вращение камеры к персонажу
+        public bool ShouldApplyCameraRotation { get; private set; }
+
+        // Обработка и преобразование входных данных от персонажа
+        public void ProcessInputs(ref CharacterInputs inputs, KinematicCharacterMotor motor)
+        {
+            // Сохраняем текущий режим камеры
+            var currentCameraMode = inputs.CameraMode;
+            
+            // Обработка спринта
+            IsSprinting = inputs is { SprintPressed: true, MoveAxisForward: > 0.1f }; // Спринт только при движении вперёд
+
+            // Нормализация вектора движения и ограничение его величины до 1
+            var moveInputVector = 
+                Vector3.ClampMagnitude(new Vector3(inputs.MoveAxisRight, 0, inputs.MoveAxisForward), 1f);
+
+            // Раздельная обработка в зависимости от режима камеры
+            if (currentCameraMode == CameraMode.FirstPerson)
+            {
+                HandleFirstPersonInputs(ref inputs, moveInputVector, motor);
+            }
+            else
+            {
+                HandleThirdPersonInputs(ref inputs, moveInputVector, motor);
+            }
+        }
+
+        // Обработка ввода для FirstPerson режима
+        private void HandleFirstPersonInputs(ref CharacterInputs inputs, Vector3 moveInputVector, KinematicCharacterMotor motor)
+        {
+            // Сохраняем вращение камеры для применения в UpdateRotation (только горизонтальная компонента)
+            FirstPersonCameraRotation = ExtractHorizontalRotation(inputs.CameraRotation, motor);
+            ShouldApplyCameraRotation = true;
+
+            // В FirstPerson режиме движение всегда относительно направления камеры
+            // Получаем направление камеры в горизонтальной плоскости
+            var cameraPlanarDirection = inputs.CameraPlanarDirection;
+
+            // Создание вращения на основе направления камеры
+            var cameraPlanarRotation = Quaternion.LookRotation(cameraPlanarDirection, motor.CharacterUp);
+
+            // Преобразование локального ввода в мировые координаты относительно камеры
+            MoveInputVector = cameraPlanarRotation * moveInputVector;
+
+            // В FirstPerson режиме направление взгляда всегда совпадает с направлением камеры (горизонтально)
+            LookInputVector = cameraPlanarDirection;
+        }
+
+        // Обработка ввода для ThirdPerson режима
+        private void HandleThirdPersonInputs(ref CharacterInputs inputs, Vector3 moveInputVector, KinematicCharacterMotor motor)
+        {
+            // Сбрасываем флаг применения вращения камеры
+            ShouldApplyCameraRotation = false;
+
+            // Получение направления камеры в горизонтальной плоскости (игнорируя наклон)
+            var cameraPlanarDirection = inputs.CameraPlanarDirection;
+
+            // Резервный расчет направления, если основное направление параллельно вертикали
+            if (cameraPlanarDirection.sqrMagnitude == 0f)
+            {
+                cameraPlanarDirection = Vector3.ProjectOnPlane(inputs.CameraRotation * Vector3.up, motor.CharacterUp);
+            }
+
+            // Создание вращения на основе направления камеры
+            var cameraPlanarRotation = Quaternion.LookRotation(cameraPlanarDirection, motor.CharacterUp);
+
+            // Преобразование локального ввода в мировые координаты относительно камеры
+            MoveInputVector = cameraPlanarRotation * moveInputVector;
+
+            // Направление взгляда совпадает с направлением движения (нормализованное)
+            LookInputVector = MoveInputVector.normalized;
+        }
+
+        // Извлечение только горизонтальной компоненты вращения (игнорируя наклон камеры)
+        private static Quaternion ExtractHorizontalRotation(Quaternion cameraRotation, KinematicCharacterMotor motor)
+        {
+            // Получаем вектор направления камеры
+            var cameraForward = cameraRotation * Vector3.forward;
+            
+            // Проецируем на горизонтальную плоскость
+            var horizontalForward = Vector3.ProjectOnPlane(cameraForward, motor.CharacterUp).normalized;
+            
+            // Если проекция вырождена, используем текущее направление персонажа
+            if (horizontalForward.sqrMagnitude < 0.01f)
+            {
+                horizontalForward = motor.CharacterForward;
+            }
+            
+            // Создаем вращение только по горизонтали
+            return Quaternion.LookRotation(horizontalForward, motor.CharacterUp);
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Input/CharacterInputHandler.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 513b50847de24c619c380c15e084e932
+timeCreated: 1761571281

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Movement.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b3dfd8f0dbeb4e8690e11049cb7e2f55
+timeCreated: 1761571298

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Movement/AirMovementSystem.cs

@@ -0,0 +1,26 @@
+using UnityEngine;
+
+namespace Code.Gameplay.Character.Controller.Movement
+{
+    /*
+     * Система движения персонажа в воздухе
+     */
+    public class AirMovementSystem
+    {
+        // Вектор, отвечающий за применение гравитации
+        private readonly Vector3 _gravity;
+        
+        // Конструктор системы движения в воздухе
+        public AirMovementSystem(Vector3 gravity)
+        {
+            _gravity = gravity;
+        }
+        
+        // Обновление скорости движения персонажа в воздухе
+        public void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
+        {
+            // Применяем гравитацию
+            currentVelocity += _gravity * deltaTime;
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Movement/AirMovementSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5ea8841f02ff4e17ab8ebd8c7a949f6f
+timeCreated: 1761571326

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Movement/GroundMovementSystem.cs

@@ -0,0 +1,88 @@
+using UnityEngine;
+using Code.Gameplay.Character.Controller.Input;
+using KinematicCharacterController;
+
+namespace Code.Gameplay.Character.Controller.Movement
+{
+    /*
+     * Система движения персонажа по устойчивой поверхности
+     */
+    public class GroundMovementSystem
+    {
+        // Максимальная скорость движения по устойчивой поверхности
+        private readonly float _maxStableMoveSpeed;
+        // Максимальная скорость спринта
+        private readonly float _sprintMoveSpeed;
+        // Резкость изменения скорости движения (чем выше - тем резче)
+        private readonly float _stableMovementSharpness;
+        // Скорость прыжка
+        private readonly float _jumpSpeed;
+        
+        // Свойство-флаг указывающий, что был запрошен прыжок
+        public bool JumpRequested { get; private set; }
+
+        // Конструктор системы движения на земле
+        public GroundMovementSystem(float maxStableMoveSpeed, float sprintMoveSpeed, float stableMovementSharpness, float jumpSpeed)
+        {
+            _maxStableMoveSpeed = maxStableMoveSpeed;
+            _sprintMoveSpeed = sprintMoveSpeed;
+            _stableMovementSharpness = stableMovementSharpness;
+            _jumpSpeed = jumpSpeed;
+        }
+        
+        // Метод для установки запроса на прыжок извне
+        public void RequestJump(bool jumpPressed)
+        {
+            if (jumpPressed)
+                JumpRequested = true;
+        }
+        
+        // Метод для отмены запроса на прыжок извне
+        public void CancelJumpRequest()
+        {
+            JumpRequested = false;
+        }
+        
+        // Обновление скорости движения персонажа на земле
+        public void UpdateVelocity(
+            ref Vector3 currentVelocity,
+            CharacterInputHandler inputHandler,
+            KinematicCharacterMotor motor,
+            float deltaTime)
+        {
+            // Сохранение текущей величины скорости
+            var currentVelocityMagnitude = currentVelocity.magnitude;
+
+            // Получение нормали поверхности для корректного движения по наклонным плоскостям
+            var effectiveGroundNormal = motor.GroundingStatus.GroundNormal;
+
+            // Переориентация текущей скорости вдоль поверхности
+            currentVelocity = motor.GetDirectionTangentToSurface(currentVelocity, effectiveGroundNormal) *
+                              currentVelocityMagnitude;
+
+            // Переориентация входного вектора движения вдоль поверхности
+            var inputRight = Vector3.Cross(inputHandler.MoveInputVector, motor.CharacterUp);
+            var reorientedInput = Vector3.Cross(effectiveGroundNormal, inputRight).normalized *
+                                  inputHandler.MoveInputVector.magnitude;
+
+            // Расчет целевой скорости движения с учетом ограничения максимальной скорости и спринта
+            var targetSpeed = inputHandler.IsSprinting ? _sprintMoveSpeed : _maxStableMoveSpeed;
+            var targetMovementVelocity = reorientedInput * targetSpeed;
+
+            // Плавная интерполяция текущей скорости к целевой с экспоненциальным сглаживанием
+            currentVelocity = Vector3.Lerp(
+                currentVelocity,
+                targetMovementVelocity,
+                1f - Mathf.Exp(-_stableMovementSharpness * deltaTime)
+            );
+            
+            // Если запрошен прыжок
+            if (JumpRequested)
+            {
+                currentVelocity += motor.CharacterUp * _jumpSpeed - Vector3.Project(currentVelocity, motor.CharacterUp);
+                JumpRequested = false; // Сброс сразу после применения
+                motor.ForceUnground();
+            }
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Character/Controller/Movement/GroundMovementSystem.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 21cd95513cd44d52b6ae014403f9e3d1
+timeCreated: 1761571312

Game/CourierOld/Assets/Code/Gameplay/Character/Core.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4028bee0a1774348bb81e0c56e400ddc
+timeCreated: 1761570805

Game/CourierOld/Assets/Code/Gameplay/Character/Core/CameraMode.cs

@@ -0,0 +1,19 @@
+namespace Code.Gameplay.Character.Core
+{
+    /*
+     * Перечисление режимов работы камеры
+     * MainMenu - статичная камера, смотрит на заданную позицию (то что надо в главном меню)
+     * Static - статичная камера без следования за целью
+     * FirstPerson - камера от первого лица (встроена в модель персонажа)
+     * ThirdPerson - камера от третьего лица (следует за персонажем на расстоянии)
+     * Cinematic - кинематографическая камера для скриптовых сцен
+     */
+    public enum CameraMode
+    {
+        MainMenu,
+        Static,
+        FirstPerson,
+        ThirdPerson,
+        Cinematic
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Character/Core/CameraMode.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 5a49105845a7435b9179e402fa7b8e30
+timeCreated: 1761570884

Game/CourierOld/Assets/Code/Gameplay/Character/Core/Character.cs

@@ -0,0 +1,118 @@
+using Code.Gameplay.Character.Camera;
+using Code.Gameplay.Character.Controller;
+using Code.Input;
+using Reflex.Attributes;
+using UnityEngine;
+
+namespace Code.Gameplay.Character.Core
+{
+/*
+ * Главный скрипт персонажа, объединяющий камеру и контроллер персонажа
+ * Обрабатывает ввод пользователя и распределяет его между компонентами
+ * Синхронизирует состояние камеры и персонажа
+ * Управляет переключением режимов камеры через Input System
+ */
+    public class Character : MonoBehaviour
+    {
+        [SerializeField] private CharacterCamera characterCamera; // Компонент камеры персонажа
+        [SerializeField] private CustomCharacterController customCharacterController; // Компонент управления персонажем
+        [SerializeField] private Transform cameraFollowPoint; // Точка следования камеры (уровень глаз для FirstPerson)
+
+        [Inject] private IInputService _inputService; // Сервис ввода через DI
+
+        // Флаг для отслеживания переключения режима камеры (чтобы избежать многократных срабатываний)
+        private bool _cameraModeToggleHandled;
+
+        // Инициализация персонажа
+        private void Start()
+        {
+            // Настройка камеры для следования за точкой камеры
+            characterCamera.SetFollowTransform(cameraFollowPoint);
+            characterCamera.SetCameraMode(CameraMode.FirstPerson);
+
+            // Включение Gameplay мапа ввода
+            _inputService.EnableMap(ActionMappings.Gameplay);
+        }
+
+        // Обработка ввода для камеры (вращение и зум)
+        private void HandleCameraInput()
+        {
+            // Получаем данные ввода из Input System
+            var lookInput = _inputService.LookInput;
+            var scrollInput = _inputService.ZoomInput;
+
+            // Передаем данные в камеру
+            characterCamera.UpdateWithInput(Time.deltaTime, scrollInput,
+                new Vector3(lookInput.x, lookInput.y, 0));
+        }
+
+        // Обработка ввода для движения персонажа
+        private void HandleCharacterInput()
+        {
+            // Создаем структуру ввода с полной информацией о камере
+            var inputs = new CharacterInputs();
+
+            // Получаем данные движения из Input System
+            var moveInput = _inputService.MoveInput;
+            inputs.MoveAxisForward = moveInput.y; // Vertical ось (W/S или Up/Down)
+            inputs.MoveAxisRight = moveInput.x; // Horizontal ось (A/D или Left/Right)
+            inputs.JumpPressed = _inputService.JumpPressed; // Прыжки (Space)
+            inputs.SprintPressed = _inputService.SprintPressed; // Спринт (Shift)
+            inputs.SlidePressed = _inputService.SlidePressed; // Слайд (Ctrl)
+
+            // Передаем информацию о камере для адаптивного поведения
+            inputs.CameraRotation = characterCamera.transform.rotation;
+            inputs.CameraMode = characterCamera.CurrentMode;
+            inputs.CameraPlanarDirection = characterCamera.PlanarDirection;
+
+            // Передаем ввод в контроллер персонажа
+            customCharacterController.SetInputs(ref inputs);
+        }
+
+        // Обработка переключения режима камеры через Input System
+        private void HandleCameraModeInput()
+        {
+            // Получаем состояние переключения режима камеры из Input System
+            var togglePressed = _inputService.ToggleCameraModePressed;
+
+            switch (togglePressed)
+            {
+                // Обрабатываем нажатие только один раз при первом обнаружении
+                case true when !_cameraModeToggleHandled:
+                    ToggleCameraMode();
+                    _cameraModeToggleHandled = true;
+                    break;
+                // Сбрасываем флаг когда кнопка отпущена
+                case false:
+                    _cameraModeToggleHandled = false;
+                    break;
+            }
+        }
+
+        // Метод для переключения режимов камеры
+        private void ToggleCameraMode()
+        {
+            var currentMode = characterCamera.CurrentMode;
+            var newMode = currentMode == CameraMode.FirstPerson ? CameraMode.ThirdPerson : CameraMode.FirstPerson;
+
+            characterCamera.SetCameraMode(newMode);
+        }
+
+        // Обновление логики каждый кадр
+        private void Update()
+        {
+            // Обработка ввода для движения в Update (физика)
+            HandleCharacterInput();
+
+            // Обработка переключения режима камеры
+            HandleCameraModeInput();
+        }
+
+        // Обновление после всех вычислений (идеально для камеры)
+        private void LateUpdate()
+        {
+            // Обработка ввода для камеры в LateUpdate (после движения персонажа)
+            HandleCameraInput();
+        }
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Character/Core/CharacterInputs.cs

@@ -0,0 +1,20 @@
+using UnityEngine;
+
+namespace Code.Gameplay.Character.Core
+{
+    /*
+     * Структура для хранения входных данных от персонажа
+     * Содержит информацию о движении и состоянии камеры
+     */
+    public struct CharacterInputs
+    {
+        public float MoveAxisForward;          // Ввод движения вперед/назад (W/S или Up/Down)
+        public float MoveAxisRight;            // Ввод движения влево/вправо (A/D или Left/Right)
+        public Quaternion CameraRotation;      // Текущее вращение камеры для определения направления движения
+        public CameraMode CameraMode;          // Текущий режим камеры для адаптации поведения
+        public Vector3 CameraPlanarDirection;  // Направление камеры в горизонтальной плоскости
+        public bool JumpPressed;               // Флаг указывающий, нажата ли кнопка прыжка
+        public bool SprintPressed;             // Флаг указывающий, нажата ли кнопка спринта
+        public bool SlidePressed;              // Флаг указывающий, нажата ли кнопка слайда
+    }
+}

Game/CourierOld/Assets/Code/Gameplay/Character/Core/CharacterInputs.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: c3edde7108664ecc9b84a8096a3dec93
+timeCreated: 1761570939

Game/CourierOld/Assets/Code/Gameplay/Player/CharacterController.cs

@@ -1,284 +0,0 @@
-using KinematicCharacterController;
-using UnityEngine;
-
-namespace Code.Gameplay.Player
-{
-    /*
-     * Структура для хранения входных данных от игрока
-     * Содержит информацию о движении и состоянии камеры
-     */
-    public struct PlayerInputs
-    {
-        public float MoveAxisForward;          // Ввод движения вперед/назад (W/S или Up/Down)
-        public float MoveAxisRight;            // Ввод движения влево/вправо (A/D или Left/Right)
-        public Quaternion CameraRotation;      // Текущее вращение камеры для определения направления движения
-        public CameraMode CameraMode;          // Текущий режим камеры для адаптации поведения
-        public Vector3 CameraPlanarDirection;  // Направление камеры в горизонтальной плоскости
-        public bool JumpPressed;               // Флаг указывающий, нажата ли кнопка прыжка
-    }
-    
-    /*
-     * Скрипт, отвечающий за передвижения игрока
-     * Реализует физическое движение персонажа с использованием Kinematic Character Controller
-     * Обрабатывает ввод пользователя, применяет движение и вращение с учетом поверхности
-     *
-     * Источник: Tvtig, https://www.youtube.com/watch?v=9ibpY64wBYM
-     */
-    public class CharacterController : MonoBehaviour, ICharacterController
-    {
-        [SerializeField]
-        private KinematicCharacterMotor motor; // Движок физического перемещения персонажа
-
-        [SerializeField]
-        private float 
-            maxStableMoveSpeed = 10f,          // Максимальная скорость движения по устойчивой поверхности
-            stableMovementSharpness = 15f,     // Резкость изменения скорости движения (чем выше - тем резче)
-            orientationSharpness = 10f,        // Резкость изменения вращения персонажа (чем выше - тем резче)
-            jumpSpeed = 10f;                   // Скорость прыжка
-
-        [SerializeField]
-        private Vector3 gravity = new(0, -30f, 0); // Вектор, отвечающий за применение гравитации
-        
-        // Векторы движения и направления взгляда
-        private Vector3 _moveInputVector, _lookInputVector;
-
-        // Текущий режим камеры для адаптации поведения
-        private CameraMode _currentCameraMode = CameraMode.ThirdPerson;
-
-        // Вращение камеры в FirstPerson режиме для синхронизации (только горизонтальная компонента)
-        private Quaternion _firstPersonCameraRotation;
-
-
-        private bool
-            _shouldApplyCameraRotation, // Флаг указывающий, что нужно применить вращение камеры к персонажу
-            _jumpRequested; // Флаг указывающий, что был запрошен прыжок
-
-        // Инициализация контроллера
-        private void Start()
-        {
-            motor.CharacterController = this; // Регистрация этого контроллера в движке
-            _firstPersonCameraRotation = motor.Transform.rotation; // Начальное вращение совпадает с персонажем
-        }
-
-        // Обработка и преобразование входных данных от игрока
-        public void SetInputs(ref PlayerInputs inputs)
-        {
-            // Сохраняем текущий режим камеры
-            _currentCameraMode = inputs.CameraMode;
-
-            // Нормализация вектора движения и ограничение его величины до 1
-            var moveInputVector = 
-                Vector3.ClampMagnitude(new Vector3(inputs.MoveAxisRight, 0, inputs.MoveAxisForward), 1f);
-
-            // Раздельная обработка в зависимости от режима камеры
-            if (_currentCameraMode == CameraMode.FirstPerson)
-            {
-                HandleFirstPersonInputs(ref inputs, moveInputVector);
-            }
-            else
-            {
-                HandleThirdPersonInputs(ref inputs, moveInputVector);
-            }
-            
-            // При запрашивании прыжка
-            if (inputs.JumpPressed)
-                _jumpRequested = true;
-        }
-        
-        // Обработка ввода для FirstPerson режима
-        private void HandleFirstPersonInputs(ref PlayerInputs inputs, Vector3 moveInputVector)
-        {
-            // Сохраняем вращение камеры для применения в UpdateRotation (только горизонтальная компонента)
-            _firstPersonCameraRotation = ExtractHorizontalRotation(inputs.CameraRotation);
-            _shouldApplyCameraRotation = true;
-
-            // В FirstPerson режиме движение всегда относительно направления камеры
-            // Получаем направление камеры в горизонтальной плоскости
-            var cameraPlanarDirection = inputs.CameraPlanarDirection;
-
-            // Создание вращения на основе направления камеры
-            var cameraPlanarRotation = Quaternion.LookRotation(cameraPlanarDirection, motor.CharacterUp);
-
-            // Преобразование локального ввода в мировые координаты относительно камеры
-            _moveInputVector = cameraPlanarRotation * moveInputVector;
-
-            // В FirstPerson режиме направление взгляда всегда совпадает с направлением камеры (горизонтально)
-            _lookInputVector = cameraPlanarDirection;
-        }
-
-        // Обработка ввода для ThirdPerson режима
-        private void HandleThirdPersonInputs(ref PlayerInputs inputs, Vector3 moveInputVector)
-        {
-            // Сбрасываем флаг применения вращения камеры
-            _shouldApplyCameraRotation = false;
-
-            // Получение направления камеры в горизонтальной плоскости (игнорируя наклон)
-            var cameraPlanarDirection = inputs.CameraPlanarDirection;
-
-            // Резервный расчет направления, если основное направление параллельно вертикали
-            if (cameraPlanarDirection.sqrMagnitude == 0f)
-            {
-                cameraPlanarDirection = Vector3.ProjectOnPlane(inputs.CameraRotation * Vector3.up, motor.CharacterUp);
-            }
-
-            // Создание вращения на основе направления камеры
-            var cameraPlanarRotation = Quaternion.LookRotation(cameraPlanarDirection, motor.CharacterUp);
-
-            // Преобразование локального ввода в мировые координаты относительно камеры
-            _moveInputVector = cameraPlanarRotation * moveInputVector;
-
-            // Направление взгляда совпадает с направлением движения (нормализованное)
-            _lookInputVector = _moveInputVector.normalized;
-        }
-
-        // Извлечение только горизонтальной компоненты вращения (игнорируя наклон камеры)
-        private Quaternion ExtractHorizontalRotation(Quaternion cameraRotation)
-        {
-            // Получаем вектор направления камеры
-            var cameraForward = cameraRotation * Vector3.forward;
-            
-            // Проецируем на горизонтальную плоскость
-            var horizontalForward = Vector3.ProjectOnPlane(cameraForward, motor.CharacterUp).normalized;
-            
-            // Если проекция вырождена, используем текущее направление персонажа
-            if (horizontalForward.sqrMagnitude < 0.01f)
-            {
-                horizontalForward = motor.CharacterForward;
-            }
-            
-            // Создаем вращение только по горизонтали
-            return Quaternion.LookRotation(horizontalForward, motor.CharacterUp);
-        }
-
-        // Обновление вращения персонажа на основе входных данных
-        public void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
-        {
-            switch (_currentCameraMode)
-            {
-                // В FirstPerson режиме применяем вращение камеры напрямую к персонажу (только горизонталь)
-                case CameraMode.FirstPerson when _shouldApplyCameraRotation:
-                    // Немедленно применяем горизонтальное вращение камеры к персонажу
-                    currentRotation = _firstPersonCameraRotation;
-                    _shouldApplyCameraRotation = false;
-                    break;
-                // В ThirdPerson режиме плавно поворачиваем персонаж в направлении движения
-                case CameraMode.ThirdPerson:
-                {
-                    // Вращение применяется только если есть направление движения и разрешена резкость вращения
-                    if (_lookInputVector.sqrMagnitude > 0 && orientationSharpness > 0)
-                    {
-                        // Плавная интерполяция текущего направления к целевому с экспоненциальным сглаживанием
-                        var smoothedLookInputDirection = Vector3.Slerp(
-                            motor.CharacterForward, 
-                            _lookInputVector, 
-                            1f - Mathf.Exp(-orientationSharpness * deltaTime)
-                        ).normalized;
-
-                        // Установка нового вращения смотря в сглаженном направлении
-                        currentRotation = Quaternion.LookRotation(smoothedLookInputDirection, motor.CharacterUp);
-                    }
-
-                    break;
-                }
-                // Заготовка на будущее (если понадобится)
-                case CameraMode.Static:
-                case CameraMode.Cinematic:
-                default:
-                    break;
-            }
-        }
-
-        // Обновление скорости движения персонажа
-        public void UpdateVelocity(ref Vector3 currentVelocity, float deltaTime)
-        {
-            // Если персонаж находится на земле
-            if (motor.GroundingStatus.IsStableOnGround)
-            {
-                // Сохранение текущей величины скорости
-                var currentVelocityMagnitude = currentVelocity.magnitude;
-
-                // Получение нормали поверхности для корректного движения по наклонным плоскостям
-                var effectiveGroundNormal = motor.GroundingStatus.GroundNormal;
-
-                // Переориентация текущей скорости вдоль поверхности
-                currentVelocity = motor.GetDirectionTangentToSurface(currentVelocity, effectiveGroundNormal) *
-                                  currentVelocityMagnitude;
-
-                // Переориентация входного вектора движения вдоль поверхности
-                var inputRight = Vector3.Cross(_moveInputVector, motor.CharacterUp);
-                var reorientedInput = Vector3.Cross(effectiveGroundNormal, inputRight).normalized *
-                                      _moveInputVector.magnitude;
-
-                // Расчет целевой скорости движения с учетом ограничения максимальной скорости
-                var targetMovementVelocity = reorientedInput * maxStableMoveSpeed;
-
-                // Плавная интерполяция текущей скорости к целевой с экспоненциальным сглаживанием
-                currentVelocity = Vector3.Lerp(
-                    currentVelocity,
-                    targetMovementVelocity,
-                    1f - Mathf.Exp(-stableMovementSharpness * deltaTime)
-                );
-                
-                // Если запрошен прыжок
-                if (_jumpRequested)
-                {
-                    currentVelocity += motor.CharacterUp * jumpSpeed - Vector3.Project(currentVelocity, motor.CharacterUp);
-                    _jumpRequested = false;
-                    motor.ForceUnground();
-                }
-            }
-
-            // Если персонаж не находится на земле
-            else
-            {
-                // Применяем гравитацию
-                currentVelocity += gravity * deltaTime;
-                // Отменяем прыжок (фикс проблемы с двойным прыжком после приземления)
-                _jumpRequested = false;
-            }
-        }
-
-        // Метод вызывается перед обновлением персонажа (можно использовать для подготовки)
-        public void BeforeCharacterUpdate(float deltaTime)
-        {
-        }
-
-        // Метод вызывается после обработки столкновения с землей
-        public void PostGroundingUpdate(float deltaTime)
-        {
-        }
-
-        // Метод вызывается после обновления персонажа (можно использовать для пост-обработки)
-        public void AfterCharacterUpdate(float deltaTime)
-        {
-        }
-
-        // Проверка валидности коллайдера для обработки столкновений
-        public bool IsColliderValidForCollisions(Collider coll)
-        {
-            return true; // Все коллайдеры считаются валидными для столкновений
-        }
-
-        // Обработка столкновения с землей (вызывается при приземлении)
-        public void OnGroundHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, ref HitStabilityReport hitStabilityReport)
-        {
-        }
-
-        // Обработка столкновения при движении (вызывается при ударе о препятствие)
-        public void OnMovementHit(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint,
-            ref HitStabilityReport hitStabilityReport)
-        {
-        }
-
-        // Обработка отчета о стабильности столкновения
-        public void ProcessHitStabilityReport(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, Vector3 atCharacterPosition,
-            Quaternion atCharacterRotation, ref HitStabilityReport hitStabilityReport)
-        {
-        }
-
-        // Обработка дискретных столкновений (для триггеров и специальных коллайдеров)
-        public void OnDiscreteCollisionDetected(Collider hitCollider)
-        {
-        }
-    }
-}

Game/CourierOld/Assets/Code/Gameplay/Player/Player.cs

@@ -1,117 +0,0 @@
-using Code.Gameplay.Player;
-using Code.Input;
-using Reflex.Attributes;
-using UnityEngine;
-using CharacterController = Code.Gameplay.Player.CharacterController;
-
-/*
- * Главный скрипт игрока, объединяющий камеру и контроллер персонажа
- * Обрабатывает ввод пользователя и распределяет его между компонентами
- * Синхронизирует состояние камеры и персонажа
- * Управляет переключением режимов камеры через Input System
- */
-public class Player : MonoBehaviour
-{
-    [SerializeField]
-    private PlayerCamera playerCamera;          // Компонент камеры игрока
-    [SerializeField]
-    private CharacterController characterController; // Компонент управления персонажем
-    [SerializeField]
-    private Transform cameraFollowPoint;        // Точка следования камеры (уровень глаз для FirstPerson)
-
-    [Inject] 
-    private IInputService _inputService; // Сервис ввода через DI
-
-    // Флаг для отслеживания переключения режима камеры (чтобы избежать многократных срабатываний)
-    private bool _cameraModeToggleHandled;
-
-    // Инициализация игрока
-    private void Start()
-    {
-        // Настройка камеры для следования за точкой камеры
-        playerCamera.SetFollowTransform(cameraFollowPoint);
-        
-        // Включение Gameplay мапа ввода
-        _inputService.EnableMap(ActionMappings.Gameplay);
-    }
-
-    // Обработка ввода для камеры (вращение и зум)
-    private void HandleCameraInput()
-    {
-        // Получаем данные ввода из Input System
-        var lookInput = _inputService.LookInput;
-        var scrollInput = _inputService.ZoomInput;
-
-        // Передаем данные в камеру
-        playerCamera.UpdateWithInput(Time.deltaTime, scrollInput, 
-            new Vector3(lookInput.x, lookInput.y, 0));
-    }
-
-    // Обработка ввода для движения персонажа
-    private void HandleCharacterInput()
-    {
-        // Создаем структуру ввода с полной информацией о камере
-        var inputs = new PlayerInputs();
-        
-        // Получаем данные движения из Input System
-        var moveInput = _inputService.MoveInput;
-        inputs.MoveAxisForward = moveInput.y;  // Vertical ось (W/S или Up/Down)
-        inputs.MoveAxisRight = moveInput.x;    // Horizontal ось (A/D или Left/Right)
-        inputs.JumpPressed = _inputService.JumpPressed; // Прыжки (Space)
-        
-        // Передаем информацию о камере для адаптивного поведения
-        inputs.CameraRotation = playerCamera.transform.rotation;
-        inputs.CameraMode = playerCamera.CurrentMode;
-        inputs.CameraPlanarDirection = playerCamera.PlanarDirection;
-        
-        // Передаем ввод в контроллер персонажа
-        characterController.SetInputs(ref inputs);
-    }
-
-    // Обработка переключения режима камеры через Input System
-    private void HandleCameraModeInput()
-    {
-        // Получаем состояние переключения режима камеры из Input System
-        var togglePressed = _inputService.ToggleCameraModePressed;
-
-        switch (togglePressed)
-        {
-            // Обрабатываем нажатие только один раз при первом обнаружении
-            case true when !_cameraModeToggleHandled:
-                ToggleCameraMode();
-                _cameraModeToggleHandled = true;
-                break;
-            // Сбрасываем флаг когда кнопка отпущена
-            case false:
-                _cameraModeToggleHandled = false;
-                break;
-        }
-    }
-
-    // Метод для переключения режимов камеры
-    private void ToggleCameraMode()
-    {
-        var currentMode = playerCamera.CurrentMode;
-        var newMode = currentMode == CameraMode.FirstPerson ? 
-            CameraMode.ThirdPerson : CameraMode.FirstPerson;
-        
-        playerCamera.SetCameraMode(newMode);
-    }
-
-    // Обновление логики каждый кадр
-    private void Update()
-    {
-        // Обработка ввода для движения в Update (физика)
-        HandleCharacterInput();
-
-        // Обработка переключения режима камеры
-        HandleCameraModeInput();
-    }
-
-    // Обновление после всех вычислений (идеально для камеры)
-    private void LateUpdate()
-    {
-        // Обработка ввода для камеры в LateUpdate (после движения персонажа)
-        HandleCameraInput();
-    }
-}

Game/CourierOld/Assets/Code/Input/IInputService.cs

@@ -14,6 +14,8 @@ namespace Code.Input
         // Для управления движением персонажа
         Vector2 MoveInput { get; }
         bool JumpPressed { get; }
+        bool SprintPressed { get; }
+        bool SlidePressed { get; }
         
         // Для переключения режима камеры
         bool ToggleCameraModePressed { get; }

Game/CourierOld/Assets/Code/Input/InputService.cs

@@ -13,6 +13,8 @@ namespace Code.Input
         public float ZoomInput { get; private set; }
         public Vector2 MoveInput { get; private set; }
         public bool JumpPressed { get; private set; }
+        public bool SprintPressed { get; private set; }
+        public bool SlidePressed { get; private set; }
         public bool ToggleCameraModePressed { get; private set; }
         
         public InputService(InputActionAsset inputActionAsset)
@@ -65,6 +67,22 @@ namespace Code.Input
                 jumpAction.canceled += OnJumpCanceled;
             }
             
+            // Обработка спринта (персонаж)
+            var sprintAction = gameplayMap.FindAction("Sprint");
+            if (sprintAction != null)
+            {
+                sprintAction.performed += OnSprintPerformed;
+                sprintAction.canceled += OnSprintCanceled;
+            }
+            
+            // Обработка слайда (персонаж)
+            var slideAction = gameplayMap.FindAction("Slide");
+            if (slideAction != null)
+            {
+                slideAction.performed += OnSlidePerformed;
+                slideAction.canceled += OnSlideCanceled;
+            }
+            
             // Обработка переключения режима камеры
             var toggleCameraModeAction = gameplayMap.FindAction("ToggleCameraMode");
             if (toggleCameraModeAction != null)
@@ -113,6 +131,26 @@ namespace Code.Input
         {
             JumpPressed = false;
         }
+
+        private void OnSprintPerformed(InputAction.CallbackContext context)
+        {
+            SprintPressed = true;
+        }
+
+        private void OnSprintCanceled(InputAction.CallbackContext context)
+        {
+            SprintPressed = false;
+        }
+
+        private void OnSlidePerformed(InputAction.CallbackContext context)
+        {
+            SlidePressed = true;
+        }
+
+        private void OnSlideCanceled(InputAction.CallbackContext context)
+        {
+            SlidePressed = false;
+        }
         
         private void OnToggleCameraModePerformed(InputAction.CallbackContext context)
         {
@@ -149,6 +187,12 @@ namespace Code.Input
             gameplayMap.FindAction("Jump").performed -= OnJumpPerformed;
             gameplayMap.FindAction("Jump").canceled -= OnJumpCanceled;
             
+            gameplayMap.FindAction("Sprint").performed -= OnSprintPerformed;
+            gameplayMap.FindAction("Sprint").canceled -= OnSprintCanceled;
+            
+            gameplayMap.FindAction("Slide").performed -= OnSlidePerformed;
+            gameplayMap.FindAction("Slide").canceled -= OnSlideCanceled;
+            
             gameplayMap.FindAction("ToggleCameraMode").performed -= OnToggleCameraModePerformed;
             gameplayMap.FindAction("ToggleCameraMode").canceled -= OnToggleCameraModeCanceled;
         }

Game/CourierOld/Assets/Code/StaticData/IStaticDataService.cs

@@ -8,5 +8,6 @@ namespace Code.StaticData
         void Load();
         InputConfig InputConfig { get; }
         AppConfig AppConfig { get; }
+        CharacterCameraConfig CharacterCameraConfig { get; }
     }
 }

Game/CourierOld/Assets/Code/StaticData/StaticDataService.cs

@@ -8,11 +8,13 @@ namespace Code.StaticData
     {
         public AppConfig AppConfig { get; private set; }
         public InputConfig InputConfig { get; private set; }
+        public CharacterCameraConfig CharacterCameraConfig { get; private set; }
 
         public void Load()
         {
             InputConfig = Resources.Load<InputConfig>(string.Format(StringPaths.ConfigSingle, "App", "InputConfig"));
             AppConfig = Resources.Load<AppConfig>(string.Format(StringPaths.ConfigSingle, "App", "AppConfig"));
+            CharacterCameraConfig = Resources.Load<CharacterCameraConfig>(string.Format(StringPaths.ConfigSingle, "App", "CharacterCameraConfig"));
         }
     }
 }

Game/CourierOld/Assets/Resources/Configs/App/CharacterCameraConfig.asset

@@ -0,0 +1,25 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 72fbf590e5fd4747acfdd32eb26bba3a, type: 3}
+  m_Name: CharacterCameraConfig
+  m_EditorClassIdentifier: Assembly-CSharp::Code.Configs.CharacterCameraConfig
+  defaultDistance: 6
+  minDistance: 3
+  maxDistance: 10
+  distanceMovementSpeed: 5
+  rotationSpeed: 0.3
+  rotationSharpness: 100
+  followSharpness: 100
+  minVerticalAngle: -70
+  maxVerticalAngle: 70
+  defaultVerticalAngle: 10
+  defaultCameraMode: 0

Game/CourierOld/Assets/Resources/Configs/App/CharacterCameraConfig.asset.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6938984fc7d25285abb4922dd46d9272
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Game/CourierOld/Assets/Resources/Scenes/MovementDev.unity

@@ -222,7 +222,7 @@ GameObject:
   - component: {fileID: 338454663}
   - component: {fileID: 338454664}
   m_Layer: 0
-  m_Name: PlayerCamera
+  m_Name: CharacterCamera
   m_TagString: MainCamera
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
@@ -362,7 +362,6 @@ MonoBehaviour:
   minDistance: 3
   maxDistance: 10
   distanceMovementSpeed: 5
-  distanceMovementSharpness: 100
   rotationSpeed: 0.3
   rotationSharpness: 100
   followSharpness: 100
@@ -870,7 +869,7 @@ GameObject:
   - component: {fileID: 1696686256}
   - component: {fileID: 1696686258}
   m_Layer: 0
-  m_Name: Player
+  m_Name: Character
   m_TagString: Untagged
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
@@ -905,8 +904,8 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: 9f2cdbe59523ace7ab0d8dfc36b4eb02, type: 3}
   m_Name: 
   m_EditorClassIdentifier: Assembly-CSharp::Player
-  playerCamera: {fileID: 338454664}
-  characterController: {fileID: 1696686258}
+  characterCamera: {fileID: 338454664}
+  customCharacterController: {fileID: 1696686258}
   cameraFollowPoint: {fileID: 453575298}
 --- !u!114 &1696686256
 MonoBehaviour:
@@ -986,10 +985,16 @@ MonoBehaviour:
   m_Name: 
   m_EditorClassIdentifier: Assembly-CSharp::Code.Gameplay.Player.CharacterController
   motor: {fileID: 1696686256}
-  maxStableMoveSpeed: 10
+  maxStableMoveSpeed: 8
+  sprintMoveSpeed: 12
+  slideSpeed: 20
+  slideDuration: 0.8
+  slideCooldown: 1.5
   stableMovementSharpness: 15
   orientationSharpness: 10
   jumpSpeed: 10
+  wallClimbSpeedFactor: 0.8
+  minWallClimbSpeed: 9
   gravity: {x: 0, y: -30, z: 0}
 --- !u!1 &1959874989
 GameObject:

Game/CourierOld/Packages/manifest.json

@@ -5,15 +5,15 @@
     "com.unity.ai.navigation": "2.0.9",
     "com.unity.collab-proxy": "2.10.0",
     "com.unity.ide.rider": "3.0.38",
-    "com.unity.ide.visualstudio": "2.0.23",
+    "com.unity.ide.visualstudio": "2.0.25",
     "com.unity.inputsystem": "1.14.2",
     "com.unity.multiplayer.center": "1.0.0",
     "com.unity.render-pipelines.universal": "17.2.0",
     "com.unity.test-framework": "1.6.0",
     "com.unity.timeline": "1.8.9",
-    "com.unity.toolchain.linux-x86_64": "2.0.10",
+    "com.unity.toolchain.linux-x86_64": "2.0.11",
     "com.unity.ugui": "2.0.0",
-    "com.unity.visualscripting": "1.9.7",
+    "com.unity.visualscripting": "1.9.9",
     "com.unity.modules.accessibility": "1.0.0",
     "com.unity.modules.ai": "1.0.0",
     "com.unity.modules.androidjni": "1.0.0",

Game/CourierOld/Packages/packages-lock.json

@@ -7,7 +7,7 @@
       "dependencies": {
         "com.unity.localization": "1.0.0"
       },
-      "hash": "bd1d662b53cff58b86c2cef02b284a52ce964cae"
+      "hash": "dfa901c9eeef09febe0dfb2f2a52319ea532747f"
     },
     "com.gustavopsantos.reflex": {
       "version": "https://github.com/gustavopsantos/reflex.git?path=/Assets/Reflex/#13.0.2",
@@ -87,11 +87,11 @@
       "url": "https://packages.unity.com"
     },
     "com.unity.ide.visualstudio": {
-      "version": "2.0.23",
+      "version": "2.0.25",
       "depth": 0,
       "source": "registry",
       "dependencies": {
-        "com.unity.test-framework": "1.1.9"
+        "com.unity.test-framework": "1.1.31"
       },
       "url": "https://packages.unity.com"
     },
@@ -268,7 +268,7 @@
       "url": "https://packages.unity.com"
     },
     "com.unity.toolchain.linux-x86_64": {
-      "version": "2.0.10",
+      "version": "2.0.11",
       "depth": 0,
       "source": "registry",
       "dependencies": {
@@ -287,7 +287,7 @@
       }
     },
     "com.unity.visualscripting": {
-      "version": "1.9.7",
+      "version": "1.9.9",
       "depth": 0,
       "source": "registry",
       "dependencies": {