Начало рефакторинга

Для удобства дальнейшей разработки и понимания кода, дальше пойдёт более сильный рефакторинг, пока что промежуточный
2025-10-27 14:40:26 +03:00
1 parent 487331dc10
commit e6879076a3
@@ -0,0 +1,118 @@
+using Code.Gameplay.Character;
+using Code.Input;
+using Reflex.Attributes;
+using UnityEngine;
+
+/*
+ * Главный скрипт персонажа, объединяющий камеру и контроллер персонажа
+ * Обрабатывает ввод пользователя и распределяет его между компонентами
+ * Синхронизирует состояние камеры и персонажа
+ * Управляет переключением режимов камеры через 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);
+        
+        // Включение 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();
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 9f2cdbe59523ace7ab0d8dfc36b4eb02
@@ -0,0 +1,212 @@
+using System;
+using UnityEngine;
+
+namespace Code.Gameplay.Character
+{
+    /*
+     * Перечисление режимов работы камеры
+     * 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 CharacterCamera : MonoBehaviour
+    {
+        [SerializeField] 
+        private float 
+            // Расстояния от персонажа до камеры
+            defaultDistance = 6f,    // Стандартное расстояние камеры от цели
+            minDistance = 3f,        // Минимальное расстояние при зуме
+            maxDistance = 10f,       // Максимальное расстояние при зуме
+            
+            // Скорость зума камеры
+            distanceMovementSpeed = 5f,  // Множитель скорости изменения дистанции при зуме
+            
+            // Скорость поворота камеры
+            rotationSpeed = 0.3f,     // Множитель скорости вращения камеры
+            
+            // Скорость интерполяции текущее -> целевое вращение
+            rotationSharpness = 100f,  // Коэффициент плавности вращения камеры (чем выше - тем резче)
+            
+            // Резкость следования камеры за целью
+            followSharpness = 100f,  // Коэффициент плавности следования за движущейся целью (чем выше - тем резче)
+            
+            // Углы наклона камеры
+            minVerticalAngle = -70f,    // Минимальный угол наклона камеры (вниз)
+            maxVerticalAngle = 70f,     // Максимальный угол наклона камеры (вверх)
+            defaultVerticalAngle = 10f; // Стандартный угол наклона камеры
+        
+        // Текущий режим работы камеры
+
+        // Трансформ объекта, за которым следует камера (для 1st-person: уровень глаз)
+        private Transform _followTransform;
+        
+        // Позиция следования: текущая сглаженная позиция и горизонтальное направление камеры
+        private Vector3 _currentFollowPosition;
+        
+        // Целевой вертикальный угол камеры (наклон вверх/вниз)
+        private float _targetVerticalAngle;
+        
+        // Текущая и целевая дистанция камеры от цели
+        private float _currentDistance, _targetDistance;
+        
+        // Исходные значения дистанции для восстановления после FirstPerson режима
+        private float _originalDefaultDistance, _originalMinDistance, _originalMaxDistance;
+
+        // Свойства для доступа к важным данным камеры извне
+        public Vector3 PlanarDirection { get; private set; } // Горизонтальное направление камеры
+
+        public CameraMode CurrentMode { get; private set; } = CameraMode.ThirdPerson; // Текущий режим камеры
+
+        // Инициализация камеры при создании
+        private void Awake()
+        {
+            // Сохраняем исходные значения дистанции для восстановления
+            _originalDefaultDistance = defaultDistance;
+            _originalMinDistance = minDistance;
+            _originalMaxDistance = maxDistance;
+            
+            _currentDistance = defaultDistance;
+            _targetDistance = _currentDistance;
+            _targetVerticalAngle = 0f;
+            PlanarDirection = Vector3.forward;  // Начальное направление - вперед по оси Z
+        }
+        
+        // Установка цели для следования камеры
+        public void SetFollowTransform(Transform t)
+        {
+            _followTransform = t;
+            _currentFollowPosition = t.position;
+            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));
+            PlanarDirection = rotationFromInput * PlanarDirection;
+            var planarRotation = Quaternion.LookRotation(PlanarDirection, _followTransform.up);
+            
+            // Вращение вокруг горизонтальной оси (вертикальный наклон)
+            _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);
+            
+            // Применение финального вращения
+            transform.rotation = targetRotation;
+        }
+        
+        // Обработка позиционирования камеры и зума с учетом текущего режима
+        private void HandlePosition(float deltaTime, float zoomInput, Quaternion targetRotation)
+        {
+            // В FirstPerson режиме зум отключается
+            if (CurrentMode != CameraMode.FirstPerson)
+            {
+                // Обновление целевой дистанции на основе ввода зума
+                _targetDistance += zoomInput * distanceMovementSpeed;
+                _targetDistance = Mathf.Clamp(_targetDistance, minDistance, maxDistance);
+            }
+            
+            // Плавное следование за целью с использованием экспоненциального сглаживания
+            _currentFollowPosition = Vector3.Lerp(_currentFollowPosition, _followTransform.position, 1f - Mathf.Exp(-followSharpness * deltaTime));
+            
+            // Вычисление целевой позиции камеры с учетом текущего режима
+            Vector3 targetPosition;
+            if (CurrentMode == CameraMode.FirstPerson)
+            {
+                // В FirstPerson режиме камера находится прямо на позиции цели
+                targetPosition = _currentFollowPosition;
+            }
+            else
+            {
+                // В ThirdPerson режиме камера отодвинута на расстояние от цели
+                targetPosition = _currentFollowPosition - targetRotation * Vector3.forward * _currentDistance;
+            }
+            
+            // Плавное изменение текущей дистанции к целевой (только для ThirdPerson)
+            if (CurrentMode != CameraMode.FirstPerson)
+            {
+                _currentDistance = Mathf.Lerp(_currentDistance, _targetDistance, 1f - Mathf.Exp(-distanceMovementSpeed * deltaTime));
+            }
+            
+            // Установка финальной позиции камеры
+            transform.position = targetPosition;
+        }
+        
+        // Основной метод обновления камеры, вызываемый извне каждый кадр
+        public void UpdateWithInput(float deltaTime, float zoomInput, Vector3 rotationInput)
+        {
+            // Проверка наличия цели для следования
+            if (!_followTransform) return;
+            
+            // Обработка ввода и позиционирования
+            HandleRotationInput(deltaTime, rotationInput, out Quaternion targetRotation);
+            HandlePosition(deltaTime, zoomInput, targetRotation);
+        }
+        
+        // Смена режима камеры
+        public void SetCameraMode(CameraMode newMode)
+        {
+            if (CurrentMode == newMode) return;
+            CurrentMode = newMode;
+                
+            // Применяем настройки специфичные для режима
+            ApplyModeSpecificSettings();
+        }
+        
+        // Применение настроек специфичных для текущего режима
+        private void ApplyModeSpecificSettings()
+        {
+            switch (CurrentMode)
+            {
+                case CameraMode.FirstPerson:
+                    // В FirstPerson режиме дистанция всегда равна 0
+                    minDistance = 0f;
+                    maxDistance = 0f;
+                    defaultDistance = 0f;
+                    _targetDistance = 0f;
+                    _currentDistance = 0f;
+                    break;
+                case CameraMode.ThirdPerson:
+                    // Восстанавливаем исходные значения дистанции
+                    minDistance = _originalMinDistance;
+                    maxDistance = _originalMaxDistance;
+                    defaultDistance = _originalDefaultDistance;
+                    _targetDistance = defaultDistance;
+                    break;
+                // Заготовка на будущее (если понадобится)
+                case CameraMode.Static:
+                case CameraMode.Cinematic:
+                default:
+                    break;
+            }
+        }
+    }
+}
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: f1d98e6c5419411098391c07861e627e
+timeCreated: 1760627986
@@ -0,0 +1,443 @@
+using KinematicCharacterController;
+using UnityEngine;
+
+namespace Code.Gameplay.Character
+{
+    /*
+     * Структура для хранения входных данных от персонажа
+     * Содержит информацию о движении и состоянии камеры
+     */
+    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;              // Флаг указывающий, нажата ли кнопка слайда
+    }
+    
+    /*
+     * Скрипт, отвечающий за передвижение персонажа
+     * Реализует физическое движение персонажа с использованием 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 Vector3 _moveInputVector, _lookInputVector;
+
+        // Текущий режим камеры для адаптации поведения
+        private CameraMode _currentCameraMode = CameraMode.ThirdPerson;
+
+        // Вращение камеры в FirstPerson режиме для синхронизации (только горизонтальная компонента)
+        private Quaternion _firstPersonCameraRotation;
+
+        private bool
+            _shouldApplyCameraRotation,        // Флаг указывающий, что нужно применить вращение камеры к персонажу
+            _jumpRequested,                    // Флаг указывающий, что был запрошен прыжок
+            _isSprinting;                      // Флаг указывающий, что активен режим спринта
+        
+        // Переменные для управления слайдом
+        private bool _isSliding;               // Флаг активного слайда
+        private float _slideTimer;             // Таймер слайда
+        private float _slideCooldownTimer;     // Таймер перезарядки слайда
+        private Vector3 _slideDirection;       // Направление слайда
+        private bool _slideRequested;          // Флаг запроса слайда
+        
+        // Флаг для предотвращения повторного залазания на стену в один и тот же кадр
+        private bool _wallClimbAppliedThisFrame;
+
+        // Инициализация контроллера
+        private void Start()
+        {
+            motor.CharacterController = this; // Регистрация этого контроллера в движке
+            _firstPersonCameraRotation = motor.Transform.rotation; // Начальное вращение совпадает с персонажем
+        }
+
+        // Обработка и преобразование входных данных от персонажа
+        public void SetInputs(ref CharacterInputs inputs)
+        {
+            // Обновляем таймер перезарядки слайда
+            if (_slideCooldownTimer > 0f)
+            {
+                _slideCooldownTimer -= Time.deltaTime;
+            }
+            
+            // Если активен слайд - игнорируем весь остальной ввод
+            if (_isSliding)
+            {
+                // Во время слайда не обрабатываем движение, прыжки и спринт
+                _moveInputVector = Vector3.zero;
+                _lookInputVector = Vector3.one;
+                _isSprinting = false;
+                return;
+            }
+            
+            // Сохраняем текущий режим камеры
+            _currentCameraMode = inputs.CameraMode;
+            
+            // Обработка спринта
+            _isSprinting = inputs is { SprintPressed: true, MoveAxisForward: > 0.1f }; // Спринт только при движении вперёд
+            
+            // Обработка слайда
+            if (inputs.SlidePressed && !_slideRequested && _slideCooldownTimer <= 0f)
+            {
+                _slideRequested = true;
+            }
+
+            // Нормализация вектора движения и ограничение его величины до 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;
+        }
+        
+        // Начало слайда
+        private void StartSlide()
+        {
+            // Проверяем условия для старта слайда
+            if (!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;
+            }
+
+            // Принудительно отключаем спринт и сбрасываем прыжок во время слайда
+            _isSprinting = false;
+            _jumpRequested = false;
+            _slideRequested = false;
+            
+            // Устанавливаем перезарядку
+            _slideCooldownTimer = slideCooldown;
+        }
+
+        // Обработка слайда
+        private void HandleSlide(ref Vector3 currentVelocity, float deltaTime)
+        {
+            // Уменьшаем таймер слайда
+            _slideTimer -= deltaTime;
+            
+            // Если время слайда вышло, персонаж в воздухе - заканчиваем слайд
+            if (_slideTimer <= 0f || !motor.GroundingStatus.IsStableOnGround)
+            {
+                EndSlide();
+                return;
+            }
+            
+            // Устанавливаем скорость слайда вперед
+            // Используем прямую установку скорости вместо сложных вычислений
+            currentVelocity = _slideDirection * slideSpeed;
+            
+            // Добавляем небольшую вертикальную компоненту для лучшего скольжения по неровностям
+            currentVelocity += motor.CharacterUp * 2f;
+        }
+
+        // Завершение слайда
+        private void EndSlide()
+        {
+            _isSliding = false;
+            _slideTimer = 0f;
+        }
+        
+        // Обработка ввода для FirstPerson режима
+        private void HandleFirstPersonInputs(ref CharacterInputs 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 CharacterInputs 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)
+        {
+            // ВО ВРЕМЯ СЛАЙДА НЕ ОБНОВЛЯЕМ ВРАЩЕНИЕ - ПЕРСОНАЖ СМОТРИТ ПРЯМО
+            if (_isSliding) return;
+
+            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)
+        {
+            // Сбрасываем флаг залазания на стену в начале каждого кадра
+            _wallClimbAppliedThisFrame = false;
+            
+            // Проверяем запрос слайда и запускаем его если можно
+            if (_slideRequested && !_isSliding && motor.GroundingStatus.IsStableOnGround && _slideCooldownTimer <= 0f)
+            {
+                StartSlide();
+            }
+            
+            // Если активен слайд - обрабатываем отдельно
+            if (_isSliding)
+            {
+                HandleSlide(ref currentVelocity, deltaTime);
+                return;
+            }
+            
+            // Если персонаж находится на земле
+            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 targetSpeed = _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();
+                }
+            }
+            // Если персонаж не находится на земле
+            else
+            {
+                // Применяем гравитацию
+                currentVelocity += gravity * deltaTime;
+                
+                // Отменяем прыжок (фикс проблемы с двойным прыжком после приземления)
+                _jumpRequested = false;
+            }
+        }
+
+        // Метод вызывается перед обновлением персонажа (можно использовать для подготовки)
+        public void BeforeCharacterUpdate(float deltaTime)
+        {
+        }
+
+        // Метод вызывается после обработки столкновения с землей
+        public void PostGroundingUpdate(float deltaTime)
+        {
+            // Если во время слайда персонаж оторвался от земли - заканчиваем слайд
+            if (_isSliding && !motor.GroundingStatus.IsStableOnGround)
+            {
+                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)
+        {
+            // Игнорируем, если уже залезли на стену в этом кадре или если слайд активен
+            if (_wallClimbAppliedThisFrame || _isSliding) return;
+
+            // Проверяем, что это вертикальная или почти вертикальная поверхность (стена)
+            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();
+                _wallClimbAppliedThisFrame = true;
+            }
+        }
+
+        // Обработка отчета о стабильности столкновения
+        public void ProcessHitStabilityReport(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint, Vector3 atCharacterPosition,
+            Quaternion atCharacterRotation, ref HitStabilityReport hitStabilityReport)
+        {
+        }
+
+        // Обработка дискретных столкновений (для триггеров и специальных коллайдеров)
+        public void OnDiscreteCollisionDetected(Collider hitCollider)
+        {
+        }
+    }
+}
@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: a6f74123648343c498c883d02909b499
+timeCreated: 1760641740