мержим

Хуже, чем были раньше, но лучше, чем ничего. Плавность переходов имеется, и на том спасибо

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

@@ -22,18 +22,12 @@ namespace Code.Configs
             slideSpeed = 20f,               // Скорость слайда
             slideDuration = 0.8f,           // Длительность слайда в секундах
             slideCooldown = 1.5f;           // Время перезарядки слайда в секундах
-
-        // Залазание на стены
-        public float 
-            wallClimbSpeedFactor = 0.8f,       // Коэффициент преобразования горизонтальной скорости в вертикальную при залазании на стену
-            minWallClimbSpeed = 9f,            // Минимальная горизонтальная скорость для начала залазания на стену
-            wallDetectionAngleThreshold = 80f; // Максимальный угол (в градусах) от вертикали, при котором поверхность считается "стеной"
         
         // Наклон при залазании на стены
-        public float 
-            maxWallLeanAngle = 45f,        // Максимальный угол наклона от стены (в градусах)
-            wallLeanSharpness = 50f,       // Скорость наклона/выпрямления (чем выше — тем резче)
-            wallLeanHeightScale = 0.1f;    // Множитель: на сколько метров подъёма = 1 единица "наклона"
+        public float
+            leanAngle = 25f,
+            leanThreshold = 0.3f,
+            leanSmoothSpeed = 10f;
 
         // Гравитация
         public Vector3 gravity = new(0f, -30f, 0f); // Вектор, отвечающий за применение гравитации

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

@@ -1,147 +1,78 @@
 using UnityEngine;
-using KinematicCharacterController;
 
 namespace Code.Gameplay.Character.Controller.Abilities
 {
-    /*
-     * Механика наклона персонажа при контакте со стеной
-     * Управляет визуальным наклоном модели в зависимости от высоты подъёма по стене
-     */
     public class WallLeanMechanic
     {
-        private readonly float _maxLeanAngle;
-        private readonly float _leanSharpness;
-        private readonly float _heightScale;
-        
-        private Transform _characterTransform;
-        private Vector3 _lastWallNormal;
-        private float _lastWallContactHeight;
-        private float _leanFactor;
-        private float _leanSign;
-        private Vector3 _leanDirection;
-        
-        private Vector3 _lastWallContactPoint;
-        private bool _isLeaningOnWall;
-        private const float WallProximityThreshold = 0.6f;
+        private readonly float _leanAngle;
+        private readonly float _threshold;
+        private readonly float _smoothSpeed;
 
-        public WallLeanMechanic(float maxLeanAngle, float leanSharpness, float heightScale)
+        private Transform _model;
+
+        public WallLeanMechanic(
+            float leanAngle,
+            float threshold,
+            float smoothSpeed)
         {
-            _maxLeanAngle = maxLeanAngle;
-            _leanSharpness = leanSharpness;
-            _heightScale = heightScale;
+            _leanAngle = leanAngle;
+            _threshold = threshold;
+            _smoothSpeed = smoothSpeed;
         }
 
-        // Назначаем трансформ визуальной модели один раз
-        public void SetCharacterTransform(Transform transform)
+        public void SetModel(Transform model) => _model = model;
+
+        public void Update(bool isWallRunning, Vector3 wallNormal, Vector3 characterForward)
         {
-            _characterTransform = transform;
-        }
-
-        // Вызывается из OnMovementHit
-        public void OnWallContact(KinematicCharacterMotor motor, Vector3 wallNormal, float contactHeight)
-        {
-            // Только если это действительно стена (не пол/потолок)
-            var dotWithUp = Vector3.Dot(wallNormal, motor.CharacterUp);
-            if (Mathf.Abs(dotWithUp) > 0.7f) // ~45°, можно настроить
-                return;
-
-            _lastWallNormal = wallNormal;
-            _lastWallContactHeight = contactHeight;
-            _lastWallContactPoint = motor.TransientPosition;
-
-            // Пересчитываем направление наклона
-            _leanDirection = -_lastWallNormal;
-            _leanDirection = Vector3.ProjectOnPlane(_leanDirection, motor.CharacterUp).normalized;
-
-            _leanSign = 1;
-            
-            // what the fuck
-            if (_leanDirection.x != 0)
+            if (!_model)
             {
-                switch (_leanDirection.x)
-                {
-                    case -1 or 1 when motor.CharacterRight.x > 0.1f:
-                        _leanSign = -1;
-                        break;
-                    case -1 or 1 when Mathf.Abs(motor.CharacterRight.x) < 0.1f:
-                        _leanDirection = new Vector3(0, 0, -1);
-                        break;
-                }
-            }
-            else
-            {
-                switch (_leanDirection.z)
-                {
-                    case 1 when Mathf.Abs(motor.CharacterRight.z) < 0.1f:
-                        _leanSign = -1;
-                        break;
-                    case -1 when motor.CharacterRight.z < -0.1f:
-                    case 1 when motor.CharacterRight.z > 0.1f:
-                        _leanDirection = new Vector3(-1, 0, 0);
-                        break;
-                    case -1 when motor.CharacterRight.z > 0.1f:
-                    case 1 when motor.CharacterRight.z < -0.1f:
-                        _leanDirection = new Vector3(1, 0, 0);
-                        break;
-                }
-            }
-            
-            _isLeaningOnWall = true;
-        }
-
-        // Обновление каждый кадр
-        public void UpdateLean(KinematicCharacterMotor motor, float deltaTime)
-        {
-            if (!_characterTransform) return;
-
-            var currentPosition = motor.TransientPosition;
-
-            var isStillNearWall = false;
-            if (_isLeaningOnWall && _lastWallNormal != Vector3.zero)
-            {
-                var toWall = currentPosition - _lastWallContactPoint;
-                var distanceToWallPlane = Mathf.Abs(Vector3.Dot(toWall, _lastWallNormal));
-                isStillNearWall = distanceToWallPlane <= WallProximityThreshold;
-            }
-
-            if (_isLeaningOnWall)
-            {
-                var isBelowContactHeight = currentPosition.y < _lastWallContactHeight;
-
-                if (!isStillNearWall || isBelowContactHeight)
-                {
-                    _isLeaningOnWall = false;
-                }
-                else
-                {
-                    var heightDelta = currentPosition.y - _lastWallContactHeight;
-                    var targetLeanFactor = Mathf.Clamp01(heightDelta * _heightScale);
-                    _leanFactor = Mathf.Lerp(_leanFactor, targetLeanFactor, 1f - Mathf.Exp(-_leanSharpness * deltaTime));
-                }
-            }
-
-            if (!_isLeaningOnWall)
-            {
-                _leanFactor = Mathf.Lerp(_leanFactor, 0f, 1f - Mathf.Exp(-_leanSharpness * deltaTime));
-            }
-            
-            ApplyLeanRotation(motor);
-        }
-
-        private void ApplyLeanRotation(KinematicCharacterMotor motor)
-        {
-            if (_leanFactor <= 0.01f)
-            {
-                _characterTransform.localRotation = Quaternion.identity;
+                _model.localRotation = Quaternion.identity;
                 return;
             }
 
-            if (_leanDirection.sqrMagnitude < 0.01f) return;
+            var targetRotation = Quaternion.identity;
 
-            var leanAngle = _leanSign * _leanFactor * _maxLeanAngle;
-            var leanAxis = Vector3.Cross(motor.CharacterUp, _leanDirection);
-            var leanRotation = Quaternion.AngleAxis(leanAngle, leanAxis);
-            _characterTransform.localRotation = leanRotation;
+            if (isWallRunning)
+            {
+                var n = new Vector3(wallNormal.x, 0f, wallNormal.z).normalized;
+                if (n.sqrMagnitude < 0.001f) n = Vector3.forward;
+
+                var bodyRight = Vector3.Cross(Vector3.up, characterForward).normalized;
+                var side = Vector3.Dot(n, bodyRight);
+                var front = Vector3.Dot(n, characterForward);
+
+                var axis = Vector3.right;
+                var angle = 0f;
+
+                if (side > _threshold)
+                {
+                    axis = Vector3.forward;
+                    angle = -_leanAngle;
+                }
+                else if (side < -_threshold)
+                {
+                    axis = Vector3.forward;
+                    angle = _leanAngle;
+                }
+                else if (front > _threshold)
+                {
+                    axis = Vector3.right;
+                    angle = -_leanAngle;
+                }
+                else if (front < -_threshold)
+                {
+                    axis = Vector3.right;
+                    angle = _leanAngle;
+                }
+
+                targetRotation = Quaternion.AngleAxis(angle, axis);
+            }
+
+            _model.localRotation = Quaternion.Slerp(
+                _model.localRotation,
+                targetRotation,
+                1f - Mathf.Exp(-_smoothSpeed * Time.deltaTime)
+            );
         }
     }
 }

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

@@ -0,0 +1,256 @@
+using Code.Gameplay.Character.Controller.Input;
+using Code.Gameplay.Character.Core;
+using KinematicCharacterController;
+using UnityEngine;
+
+namespace Code.Gameplay.Character.Controller.Abilities
+{
+    public class WallRunningMechanic
+    {
+        public float MaxWallRunTime = 1.75f;
+        public float WallRunSpeed = 8.0f;
+        public float WallRunAcceleration = 25.0f;
+        public float WallRunGravityScale = 0.25f;
+        public float WallDetachImpulse = 7.0f;
+        public float WallContactAngleThreshold = 45.0f;
+
+        private bool _isWallRunning;
+        private float _wallRunTimer;
+        private Vector3 _wallNormal;
+        private Vector3 _wallTangentRight;
+        private Vector3 _wallTangentUp;
+        private Vector3 _wallContactPoint;
+        private Vector3 _lastMoveInputInWallSpace;
+
+        private float _surfaceAngleCos;
+        private bool _canWallRun;
+        public float WallContactHeight { get; private set; }
+        
+        public Vector3 WallRunStartForward { get; private set; }
+
+        private KinematicCharacterMotor _motor;
+        private CharacterInputHandler _inputHandler;
+
+        public bool IsWallRunning => _isWallRunning;
+
+        public void Initialize(KinematicCharacterMotor motor, CharacterInputHandler inputHandler)
+        {
+            _motor = motor;
+            _inputHandler = inputHandler;
+            _surfaceAngleCos = Mathf.Cos(Mathf.Deg2Rad * WallContactAngleThreshold);
+        }
+
+        public void Reset()
+        {
+            _isWallRunning = false;
+            _wallRunTimer = 0f;
+            _wallNormal = Vector3.zero;
+        }
+
+        public void Tick(float deltaTime)
+        {
+            if (_isWallRunning)
+            {
+                _wallRunTimer += deltaTime;
+                if (_wallRunTimer > MaxWallRunTime)
+                {
+                    DetachFromWall(false);
+                }
+            }
+        }
+
+        public bool TryStartWallRun(Vector3 hitNormal, Vector3 hitPoint)
+        {
+            if (_isWallRunning) return false;
+
+            float dotWithUp = Vector3.Dot(hitNormal, _motor.CharacterUp);
+            bool isWall = Mathf.Abs(dotWithUp) < _surfaceAngleCos;
+
+            if (!isWall) return false;
+
+            if (_motor.GroundingStatus.IsStableOnGround) return false;
+
+            float velocityIntoWall = Vector3.Dot(_motor.Velocity, -hitNormal);
+            if (velocityIntoWall < 1f) return false;
+
+            StartWallRun(hitNormal, hitPoint);
+            return true;
+        }
+
+        private void StartWallRun(Vector3 wallNormal, Vector3 contactPoint)
+        {
+            _isWallRunning = true;
+            _wallRunTimer = 0f;
+            _wallNormal = wallNormal.normalized;
+            _wallContactPoint = contactPoint;
+            WallContactHeight = contactPoint.y;
+
+            //_wallTangentUp = Vector3.ProjectOnPlane(_motor.CharacterUp, _wallNormal).normalized;
+            if (_wallTangentUp.sqrMagnitude < 0.01f) _wallTangentUp = Vector3.up;
+
+            _wallTangentRight = Vector3.Cross(_wallNormal, _wallTangentUp).normalized;
+
+            _wallTangentUp = Vector3.Cross(_wallTangentRight, _wallNormal).normalized;
+            if (Vector3.Dot(_wallTangentUp, Vector3.up) < 0)
+                _wallTangentUp = -_wallTangentUp;
+            
+            WallRunStartForward = _motor.CharacterForward;
+            _motor.ForceUnground();
+        }
+
+        public void HandleWallRun(ref Vector3 currentVelocity, CharacterInputs inputs, float deltaTime)
+        {
+            if (!_isWallRunning) return;
+            if (!IsWallStillPresent()) { DetachFromWall(false); return; }
+
+            Vector3 moveInputWorld = _inputHandler.MoveInputVector;
+            Vector3 moveInWallPlane = Vector3.ProjectOnPlane(moveInputWorld, _wallNormal);
+    
+            Vector3 wsMove = Vector3.Project(moveInWallPlane, _wallTangentRight);
+
+            float ad = inputs.MoveAxisRight;
+
+            float sideDot = Vector3.Dot(_wallNormal, _motor.CharacterRight);
+            if (sideDot < 0)
+                ad = -ad;
+
+            Vector3 adMove = _wallTangentUp * (-ad);
+
+            Vector3 finalMove = wsMove + adMove;
+            finalMove = finalMove.normalized * moveInputWorld.magnitude;
+
+            Vector3 targetVelocity = finalMove * WallRunSpeed;
+
+            currentVelocity = Vector3.Lerp(
+                currentVelocity,
+                targetVelocity,
+                1f - Mathf.Exp(-WallRunAcceleration * deltaTime)
+            );
+
+            currentVelocity += Physics.gravity * (WallRunGravityScale * deltaTime);
+
+            float distanceToWall = Vector3.Dot(_motor.TransientPosition - _wallContactPoint, _wallNormal);
+            if (Mathf.Abs(distanceToWall) > 0.8f)
+            {
+                DetachFromWall(false);
+                return;
+            }
+
+            if (inputs.JumpPressed)
+            {
+                DetachFromWall(true);
+            }
+        }
+        
+        private bool IsWallStillPresent()
+        {
+            if (_motor == null) return false;
+
+            Vector3 characterCenter = _motor.TransientPosition;
+            Vector3 characterForward = _motor.CharacterForward;
+            Vector3 characterRight = _motor.CharacterRight;
+            Vector3 characterUp = _motor.CharacterUp;
+
+            float checkDistance = 0.45f;
+            Vector3 rayOrigin = characterCenter + characterUp * 0.2f;
+            Vector3 rayDir = -_wallNormal;
+
+            Vector3[] offsets = {
+                Vector3.zero,
+                characterUp * 0.3f,
+                -characterUp * 0.3f,
+                characterRight * 0.2f,
+                -characterRight * 0.2f
+            };
+
+            foreach (var offset in offsets)
+            {
+                if (Physics.Raycast(rayOrigin + offset, rayDir, out RaycastHit hit, checkDistance, 
+                        _motor.CollidableLayers, QueryTriggerInteraction.Ignore))
+                {
+                    float dotWithUp = Mathf.Abs(Vector3.Dot(hit.normal, characterUp));
+                    if (dotWithUp < _surfaceAngleCos)
+                    {
+                        _wallNormal = hit.normal.normalized;
+                        _wallContactPoint = hit.point;
+
+                        /*_wallTangentUp = Vector3.ProjectOnPlane(_motor.CharacterUp, _wallNormal).normalized;
+                        if (_wallTangentUp.sqrMagnitude < 0.01f) _wallTangentUp = Vector3.up;
+                        _wallTangentRight = Vector3.Cross(_wallNormal, _wallTangentUp).normalized;
+                        */
+
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        public void DetachFromWall(bool withImpulse)
+        {
+            if (!_isWallRunning) return;
+
+            _isWallRunning = false;
+
+            if (withImpulse && _motor != null)
+            {
+                Vector3 detachImpulse = -_wallNormal * WallDetachImpulse;
+                _motor.BaseVelocity += detachImpulse;
+            }
+        }
+
+        public Vector3 GetWallNormal() => _wallNormal;
+        public bool TryGetWallTangents(out Vector3 up, out Vector3 right)
+        {
+            if (!_isWallRunning)
+            {
+                up = right = Vector3.zero;
+                return false;
+            }
+            up = _wallTangentUp;
+            right = _wallTangentRight;
+            return true;
+        }
+
+        public bool CanWallRun()
+        {
+            return !_isWallRunning && !_motor.GroundingStatus.IsStableOnGround;
+        }
+        
+        public void PerformWallJump(CharacterInputs inputs, Quaternion cameraRotation)
+        {
+            if (!_isWallRunning || _motor == null) return;
+
+            _isWallRunning = false;
+
+            Vector3 wallAway = _wallNormal;
+            Vector3 wallUp = _wallTangentUp;
+
+            Vector3 playerForward = cameraRotation * Vector3.forward;
+
+            Vector3 forwardInWallPlane = Vector3.ProjectOnPlane(playerForward, _wallNormal).normalized;
+            if (forwardInWallPlane.sqrMagnitude < 0.01f) forwardInWallPlane = _wallTangentRight;
+
+            Vector3 jumpDirection = 
+                forwardInWallPlane * 0.2f +
+                wallAway * 0.4f +
+                wallUp * 0.4f;
+
+            jumpDirection = jumpDirection.normalized;
+
+            float wallJumpForce = WallDetachImpulse * 2f;
+
+            Vector3 jumpImpulse = jumpDirection * wallJumpForce;
+
+            _motor.BaseVelocity += jumpImpulse;
+
+            _motor.SetPosition(_motor.TransientPosition + wallAway * 0.07f);
+            
+            if (_motor.CharacterController is CustomCharacterController controller)
+            {
+                controller.BlockAbilities(0.12f);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 4bef67aa9cf14753a63ea07eecc5ff67
+timeCreated: 1764263348

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

@@ -15,7 +15,7 @@ namespace Code.Gameplay.Character.Controller
      * Реализует физическое движение персонажа с использованием Kinematic Character Controller
      * Обрабатывает ввод пользователя, применяет движение и вращение с учетом поверхности
      *
-     * Источник: Tvtig, https://www.youtube.com/watch?v=9ibpY64wBYM
+     * Источник: Tvtig, https://www.youtube.com/watch?v=9ibpY64wBYM  
      */
     public class CustomCharacterController : MonoBehaviour, ICharacterController
     {
@@ -28,49 +28,23 @@ namespace Code.Gameplay.Character.Controller
         // Подсистемы
         private CharacterInputHandler _inputHandler;
         private SlideMechanic _slideMechanic;
-        private WallClimbMechanic _wallClimbMechanic;
+        // private WallClimbMechanic _wallClimbMechanic;
+        private WallRunningMechanic _wallRunningMechanic;
         private WallLeanMechanic _wallLeanMechanic;
         private GroundMovementSystem _groundMovement;
         private AirMovementSystem _airMovement;
         
         public bool IsSliding => _slideMechanic.IsSliding; 
+        public bool IsWallRunning => _wallRunningMechanic.IsWallRunning;
         
         private float abilityBlockTimer;
         private bool isAbilitiesBlocked;
         
+        private CharacterInputs _lastInputs;
+        
         public void SetPosition(Vector3 position) => motor.SetPosition(position);
         public void SetRotation(Quaternion rotation) => motor.SetRotation(rotation);
         
-        // Инициализация контроллера
-        // private void Awake()
-        // {
-        //     // Инициализация подсистем с параметрами из конфига
-        //     _inputHandler = new CharacterInputHandler(
-        //         _characterConfig.sprintAngleThreshold
-        //     );
-        //     _slideMechanic = new SlideMechanic(
-        //         _characterConfig.slideSpeed,
-        //         _characterConfig.slideDuration,
-        //         _characterConfig.slideCooldown
-        //     );
-        //     _wallClimbMechanic = new WallClimbMechanic(
-        //         _characterConfig.wallClimbSpeedFactor,
-        //         _characterConfig.minWallClimbSpeed,
-        //         _characterConfig.wallDetectionAngleThreshold
-        //     );
-        //     _wallLeanMechanic = new WallLeanMechanic(
-        //         _characterConfig.maxWallLeanAngle,
-        //         _characterConfig.wallLeanSharpness,
-        //         _characterConfig.wallLeanHeightScale
-        //     );
-        //     _groundMovement = new GroundMovementSystem(
-        //         _characterConfig.maxStableMoveSpeed,
-        //         _characterConfig.sprintMoveSpeed,
-        //         _characterConfig.stableMovementSharpness,
-        //         _characterConfig.jumpSpeed
-        //     );
-        //     _airMovement = new AirMovementSystem(_characterConfig.gravity);
-        // }
         [Inject]
         private void Construct(CharacterConfig characterConfig)
         {
@@ -84,16 +58,25 @@ namespace Code.Gameplay.Character.Controller
                 _characterConfig.slideDuration,
                 _characterConfig.slideCooldown
             );
-            _wallClimbMechanic = new WallClimbMechanic(
-                _characterConfig.wallClimbSpeedFactor,
-                _characterConfig.minWallClimbSpeed,
-                _characterConfig.wallDetectionAngleThreshold
-            );
+            // _wallClimbMechanic = new WallClimbMechanic(
+            //     _characterConfig.wallClimbSpeedFactor,
+            //     _characterConfig.minWallClimbSpeed,
+            //     _characterConfig.wallDetectionAngleThreshold
+            // );
+            _wallRunningMechanic = new WallRunningMechanic();
+            // Настройка параметров WallRunningMechanic (можно вынести в конфиг позже)
+            _wallRunningMechanic.MaxWallRunTime = 1.75f;
+            _wallRunningMechanic.WallRunSpeed = 15.0f;
+            _wallRunningMechanic.WallRunAcceleration = 25.0f;
+            _wallRunningMechanic.WallRunGravityScale = 0.25f;
+            _wallRunningMechanic.WallDetachImpulse = 7.0f;
+            _wallRunningMechanic.WallContactAngleThreshold = 45.0f;
+            
             _wallLeanMechanic = new WallLeanMechanic(
-                _characterConfig.maxWallLeanAngle,
-                _characterConfig.wallLeanSharpness,
-                _characterConfig.wallLeanHeightScale
-            );
+                _characterConfig.leanAngle,
+                _characterConfig.leanThreshold,
+                _characterConfig.leanSmoothSpeed
+                );
             _groundMovement = new GroundMovementSystem(
                 _characterConfig.maxStableMoveSpeed,
                 _characterConfig.sprintMoveSpeed,
@@ -106,31 +89,24 @@ namespace Code.Gameplay.Character.Controller
             motor.CharacterController = this; // Регистрация этого контроллера в движке
             _inputHandler.FirstPersonCameraRotation =
                 motor.Transform.rotation; // Начальное вращение совпадает с персонажемс
-            _wallLeanMechanic.SetCharacterTransform(characterTransform);
+            _wallLeanMechanic.SetModel(characterTransform);
+            _wallRunningMechanic.Initialize(motor, _inputHandler);
         }
+
         // Текущий режим камеры для адаптации поведения
         private CameraMode _currentCameraMode = CameraMode.FirstPerson;
 
-        // Инициализация контроллера
-        // private void Start()
-        // {
-        //     motor.CharacterController = this; // Регистрация этого контроллера в движке
-        //     _inputHandler.FirstPersonCameraRotation =
-        //         motor.Transform.rotation; // Начальное вращение совпадает с персонажемс
-        //     _wallLeanMechanic.SetCharacterTransform(characterTransform);
-        // }
-
-        // Обработка и преобразование входных данных от персонажа
         public void SetInputs(ref CharacterInputs inputs)
         {
-            // Обновляем таймер перезарядки слайда
+            _lastInputs = inputs;
+            // Обновляем таймеры механик
             _slideMechanic.TickCooldown(Time.deltaTime);
-            _wallClimbMechanic.TickCooldown(Time.deltaTime);
+            // _wallClimbMechanic.TickCooldown(Time.deltaTime);
+            _wallRunningMechanic.Tick(Time.deltaTime);
 
             // Если активен слайд - игнорируем весь остальной ввод
             if (_slideMechanic.IsSliding)
             {
-                // Во время слайда не обрабатываем движение, прыжки и спринт
                 _inputHandler.MoveInputVector = Vector3.zero;
                 _inputHandler.LookInputVector = Vector3.one;
                 _inputHandler.IsSprinting = false;
@@ -138,7 +114,6 @@ namespace Code.Gameplay.Character.Controller
                 return;
             }
 
-            // Сохраняем текущий режим камеры
             _currentCameraMode = inputs.CameraMode;
             
             if (isAbilitiesBlocked)
@@ -161,42 +136,33 @@ namespace Code.Gameplay.Character.Controller
             // Обработка остального ввода
             _inputHandler.ProcessInputs(ref inputs, motor);
 
-            // Передаём запрос прыжка напрямую в систему движения по земле
+            // Передаём запрос прыжка
             _groundMovement.RequestJump(inputs.JumpPressed);
         }
 
-        // Обновление вращения персонажа на основе входных данных
         public void UpdateRotation(ref Quaternion currentRotation, float deltaTime)
         {
-            if (_slideMechanic.IsSliding || _wallClimbMechanic.IsClimbingActive)  return;
+            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 && _characterConfig.orientationSharpness > 0)
                     {
-                        // Плавная интерполяция текущего направления к целевому с экспоненциальным сглаживанием
                         var smoothedLookInputDirection = Vector3.Slerp(
                             motor.CharacterForward,
                             _inputHandler.LookInputVector,
                             1f - Mathf.Exp(-_characterConfig.orientationSharpness * deltaTime)
                         ).normalized;
 
-                        // Установка нового вращения смотря в сглаженном направлении
                         currentRotation = Quaternion.LookRotation(smoothedLookInputDirection, motor.CharacterUp);
                     }
-
                     break;
                 }
-                // Заготовка на будущее (если понадобится)
                 case CameraMode.Static:
                 case CameraMode.Cinematic:
                 default:
@@ -204,38 +170,49 @@ namespace Code.Gameplay.Character.Controller
             }
         }
 
-        // Обновление скорости движения персонажа
         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;
             }
 
+            // === WALL RUNNING: обработка состояния ===
+            if (_wallRunningMechanic.IsWallRunning)
+            {
+                // 🔄 Передаём актуальные данные для walljump
+                if (_groundMovement.JumpRequested) // или _lastInputs.JumpPressed — зависит от логики
+                {
+                    _wallRunningMechanic.PerformWallJump(_lastInputs, _inputHandler.FirstPersonCameraRotation);
+                    _groundMovement.CancelJumpRequest(); // сброс, чтобы не сработало дважды
+                }
+                else
+                {
+                    _wallRunningMechanic.HandleWallRun(ref currentVelocity, _lastInputs, deltaTime);
+                }
+                return;
+            }
+
             // Если персонаж находится на земле
             if (motor.GroundingStatus.IsStableOnGround)
             {
                 _groundMovement.UpdateVelocity(ref currentVelocity, _inputHandler, motor, deltaTime);
             }
-            // Если персонаж не находится на земле
+            // Если персонаж не на земле — стандартное воздушное движение
             else
             {
                 _airMovement.UpdateVelocity(ref currentVelocity, deltaTime);
-                // Отменяем прыжок (фикс проблемы с двойным прыжком после приземления)
                 _groundMovement.CancelJumpRequest();
             }
         }
@@ -246,60 +223,51 @@ namespace Code.Gameplay.Character.Controller
             abilityBlockTimer = duration;
         }
 
-        // Метод вызывается перед обновлением персонажа (можно использовать для подготовки)
         public void BeforeCharacterUpdate(float deltaTime)
         {
         }
 
-        // Метод вызывается после обработки столкновения с землей
         public void PostGroundingUpdate(float deltaTime)
         {
-            // Если во время слайда персонаж оторвался от земли - заканчиваем слайд
             if (_slideMechanic.IsSliding && !motor.GroundingStatus.IsStableOnGround)
             {
                 _slideMechanic.EndSlide();
             }
-            
-            if (motor.GroundingStatus.IsStableOnGround)
-            {
-                _wallClimbMechanic.ResetWallClimbSession();
-            }
         }
 
-        // Метод вызывается после обновления персонажа
         public void AfterCharacterUpdate(float deltaTime)
         {
-            _wallLeanMechanic.UpdateLean(motor, deltaTime);
+            _wallLeanMechanic.Update(
+                _wallRunningMechanic.IsWallRunning,
+                _wallRunningMechanic.GetWallNormal(),
+                motor.CharacterForward
+            );
         }
 
-        // Проверка валидности коллайдера для обработки столкновений
         public bool IsColliderValidForCollisions(Collider coll)
         {
-            return true; // Все коллайдеры считаются валидными для столкновений
+            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 (_wallClimbMechanic.TryClimbWall(motor, hitNormal))
-                _wallLeanMechanic.OnWallContact(motor, hitNormal, motor.TransientPosition.y);
+            if (_wallRunningMechanic.TryStartWallRun(hitNormal, hitPoint))
+            {
+            }
         }
 
-        // Обработка отчета о стабильности столкновения
         public void ProcessHitStabilityReport(Collider hitCollider, Vector3 hitNormal, Vector3 hitPoint,
             Vector3 atCharacterPosition,
             Quaternion atCharacterRotation, ref HitStabilityReport hitStabilityReport)
         {
         }
 
-        // Обработка дискретных столкновений (для триггеров и специальных коллайдеров)
         public void OnDiscreteCollisionDetected(Collider hitCollider)
         {
         }

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

@@ -119,63 +119,6 @@ NavMeshSettings:
     debug:
       m_Flags: 0
   m_NavMeshData: {fileID: 0}
---- !u!1001 &256029686
-PrefabInstance:
-  m_ObjectHideFlags: 0
-  serializedVersion: 2
-  m_Modification:
-    serializedVersion: 3
-    m_TransformParent: {fileID: 0}
-    m_Modifications:
-    - target: {fileID: 466513502335772074, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_Name
-      value: Level1 (1)
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalPosition.x
-      value: -27.306025
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalPosition.y
-      value: 0.17
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalPosition.z
-      value: -19.77802
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalRotation.w
-      value: 1
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalRotation.x
-      value: -0.000000037748947
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalRotation.y
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalRotation.z
-      value: -0
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalEulerAnglesHint.x
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalEulerAnglesHint.y
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalEulerAnglesHint.z
-      value: 0
-      objectReference: {fileID: 0}
-    m_RemovedComponents: []
-    m_RemovedGameObjects: []
-    m_AddedGameObjects: []
-    m_AddedComponents: []
-  m_SourcePrefab: {fileID: 100100000, guid: c938de3174f184741925c407a43a47f2, type: 3}
 --- !u!1 &545729161
 GameObject:
   m_ObjectHideFlags: 0
@@ -377,6 +320,117 @@ Transform:
   m_Children: []
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1 &1571744439
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1571744443}
+  - component: {fileID: 1571744442}
+  - component: {fileID: 1571744441}
+  - component: {fileID: 1571744440}
+  m_Layer: 11
+  m_Name: Wall
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 2147483647
+  m_IsActive: 1
+--- !u!65 &1571744440
+BoxCollider:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1571744439}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 0
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Size: {x: 1, y: 1, z: 1}
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &1571744441
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1571744439}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_ForceMeshLod: -1
+  m_MeshLodSelectionBias: 0
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 46c32c803fa6b354e927b3c37077003f, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_GlobalIlluminationMeshLod: 0
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!33 &1571744442
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1571744439}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &1571744443
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1571744439}
+  serializedVersion: 2
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -5, y: 4, z: 0}
+  m_LocalScale: {x: 10, y: 8, z: 10}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1645301969
 GameObject:
   m_ObjectHideFlags: 0
@@ -408,120 +462,117 @@ Transform:
   m_Children: []
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!1001 &196322208361010669
-PrefabInstance:
+--- !u!1 &1855107591
+GameObject:
   m_ObjectHideFlags: 0
-  serializedVersion: 2
-  m_Modification:
-    serializedVersion: 3
-    m_TransformParent: {fileID: 0}
-    m_Modifications:
-    - target: {fileID: 8468544887234864695, guid: 9d78f017876abed4c9cd8957f1e140cb, type: 3}
-      propertyPath: m_Name
-      value: Level1_2
-      objectReference: {fileID: 0}
-    - target: {fileID: 9137100061495655565, guid: 9d78f017876abed4c9cd8957f1e140cb, type: 3}
-      propertyPath: m_LocalPosition.x
-      value: -32.07327
-      objectReference: {fileID: 0}
-    - target: {fileID: 9137100061495655565, guid: 9d78f017876abed4c9cd8957f1e140cb, type: 3}
-      propertyPath: m_LocalPosition.y
-      value: 3.73
-      objectReference: {fileID: 0}
-    - target: {fileID: 9137100061495655565, guid: 9d78f017876abed4c9cd8957f1e140cb, type: 3}
-      propertyPath: m_LocalPosition.z
-      value: 33.26
-      objectReference: {fileID: 0}
-    - target: {fileID: 9137100061495655565, guid: 9d78f017876abed4c9cd8957f1e140cb, type: 3}
-      propertyPath: m_LocalRotation.w
-      value: 1
-      objectReference: {fileID: 0}
-    - target: {fileID: 9137100061495655565, guid: 9d78f017876abed4c9cd8957f1e140cb, type: 3}
-      propertyPath: m_LocalRotation.x
-      value: -0.000000037748947
-      objectReference: {fileID: 0}
-    - target: {fileID: 9137100061495655565, guid: 9d78f017876abed4c9cd8957f1e140cb, type: 3}
-      propertyPath: m_LocalRotation.y
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 9137100061495655565, guid: 9d78f017876abed4c9cd8957f1e140cb, type: 3}
-      propertyPath: m_LocalRotation.z
-      value: -0
-      objectReference: {fileID: 0}
-    - target: {fileID: 9137100061495655565, guid: 9d78f017876abed4c9cd8957f1e140cb, type: 3}
-      propertyPath: m_LocalEulerAnglesHint.x
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 9137100061495655565, guid: 9d78f017876abed4c9cd8957f1e140cb, type: 3}
-      propertyPath: m_LocalEulerAnglesHint.y
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 9137100061495655565, guid: 9d78f017876abed4c9cd8957f1e140cb, type: 3}
-      propertyPath: m_LocalEulerAnglesHint.z
-      value: 0
-      objectReference: {fileID: 0}
-    m_RemovedComponents: []
-    m_RemovedGameObjects: []
-    m_AddedGameObjects: []
-    m_AddedComponents: []
-  m_SourcePrefab: {fileID: 100100000, guid: 9d78f017876abed4c9cd8957f1e140cb, type: 3}
---- !u!1001 &6917886881980893984
-PrefabInstance:
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 1855107595}
+  - component: {fileID: 1855107594}
+  - component: {fileID: 1855107593}
+  - component: {fileID: 1855107592}
+  m_Layer: 11
+  m_Name: Wall (1)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 2147483647
+  m_IsActive: 1
+--- !u!65 &1855107592
+BoxCollider:
   m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1855107591}
+  m_Material: {fileID: 0}
+  m_IncludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_ExcludeLayers:
+    serializedVersion: 2
+    m_Bits: 0
+  m_LayerOverridePriority: 0
+  m_IsTrigger: 0
+  m_ProvidesContacts: 0
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Size: {x: 1, y: 1, z: 1}
+  m_Center: {x: 0, y: 0, z: 0}
+--- !u!23 &1855107593
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1855107591}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_StaticShadowCaster: 0
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RayTracingMode: 2
+  m_RayTraceProcedural: 0
+  m_RayTracingAccelStructBuildFlagsOverride: 0
+  m_RayTracingAccelStructBuildFlags: 1
+  m_SmallMeshCulling: 1
+  m_ForceMeshLod: -1
+  m_MeshLodSelectionBias: 0
+  m_RenderingLayerMask: 1
+  m_RendererPriority: 0
+  m_Materials:
+  - {fileID: 2100000, guid: 46c32c803fa6b354e927b3c37077003f, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_ReceiveGI: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 1
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_GlobalIlluminationMeshLod: 0
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+  m_AdditionalVertexStreams: {fileID: 0}
+--- !u!33 &1855107594
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1855107591}
+  m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &1855107595
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 1855107591}
   serializedVersion: 2
-  m_Modification:
-    serializedVersion: 3
-    m_TransformParent: {fileID: 0}
-    m_Modifications:
-    - target: {fileID: 466513502335772074, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_Name
-      value: Level1
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalPosition.x
-      value: -24.396324
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalPosition.y
-      value: 2.9
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalPosition.z
-      value: 7.062622
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalRotation.w
-      value: 1
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalRotation.x
-      value: -0.000000037748947
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalRotation.y
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalRotation.z
-      value: -0
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalEulerAnglesHint.x
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalEulerAnglesHint.y
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 951019436902842128, guid: c938de3174f184741925c407a43a47f2, type: 3}
-      propertyPath: m_LocalEulerAnglesHint.z
-      value: 0
-      objectReference: {fileID: 0}
-    m_RemovedComponents: []
-    m_RemovedGameObjects: []
-    m_AddedGameObjects: []
-    m_AddedComponents: []
-  m_SourcePrefab: {fileID: 100100000, guid: c938de3174f184741925c407a43a47f2, type: 3}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -18.99, y: 4, z: 0}
+  m_LocalScale: {x: 10, y: 8, z: 10}
+  m_ConstrainProportionsScale: 0
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1660057539 &9223372036854775807
 SceneRoots:
   m_ObjectHideFlags: 0
@@ -530,6 +581,5 @@ SceneRoots:
   - {fileID: 545729165}
   - {fileID: 1420420439}
   - {fileID: 1645301970}
-  - {fileID: 6917886881980893984}
-  - {fileID: 256029686}
-  - {fileID: 196322208361010669}
+  - {fileID: 1571744443}
+  - {fileID: 1855107595}

Game/CourierOld/Assets/Resources_moved/Prefabs/Player/CharacterController.prefab

@@ -29,7 +29,7 @@ Transform:
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_ConstrainProportionsScale: 0
   m_Children: []
-  m_Father: {fileID: 2527703521557431680}
+  m_Father: {fileID: 4122797476271397740}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1477319963861932501
 GameObject:
@@ -156,7 +156,6 @@ Transform:
   m_ConstrainProportionsScale: 0
   m_Children:
   - {fileID: 4122797476271397740}
-  - {fileID: 1047840484662430186}
   - {fileID: 1463034091404591669}
   m_Father: {fileID: 0}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
@@ -417,6 +416,7 @@ Transform:
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_ConstrainProportionsScale: 0
   m_Children:
+  - {fileID: 1047840484662430186}
   - {fileID: 5944670082409334569}
   m_Father: {fileID: 2527703521557431680}
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}

Game/CourierOld/ProjectSettings/EditorBuildSettings.asset

@@ -11,15 +11,18 @@ EditorBuildSettings:
   - enabled: 1
     path: Assets/Resources/Scenes/MainMenu.unity
     guid: fb047145aa42fa81f940ba98cbe0a32f
-  - enabled: 1
-    path: Assets/Resources/Scenes/GameplayMobsDev.unity
-    guid: 59150559bf28464b5a553799889b9b80
   - enabled: 1
     path: Assets/Resources/Scenes/MovementDev.unity
     guid: de5b9a1ae6b033560b88d00b149b86bd
+  - enabled: 1
+    path: Assets/Resources/Scenes/Gameplay.unity
+    guid: 2188911eb1ce2aab6851107101e1c3a9
   - enabled: 1
     path: Assets/Resources/Scenes/DevSceneGenerator.unity
     guid: d9388377850f132deba2cb3b3c603fdc
+  - enabled: 1
+    path: Assets/Resources/Scenes/GameplayMobsDev.unity
+    guid: 59150559bf28464b5a553799889b9b80
   m_configObjects:
     com.unity.addressableassets: {fileID: 11400000, guid: 9338e51d1f2239ddbb8f2c6232a2b678, type: 2}
     com.unity.input.settings.actions: {fileID: -944628639613478452, guid: 052faaac586de48259a63d0c4782560b, type: 3}