Respan Dataset Explorer

Здарова, вот тебе код бега по стенам, нужно подстроить его под characterController, то есть без использования rigidbody
using System;
using System.Collections;
using System.Collections.Generic;
using Unity.VisualScripting;
using UnityEngine;

public class WallRunning : MonoBehaviour
{
    [Header("Wall Running")]
    [SerializeField] private LayerMask whatIsWall;
    [SerializeField] private LayerMask whatIsGround;
    [SerializeField] private float wallRunForce;
    [SerializeField] private float wallJumpUpForce;
    [SerializeField] private float wallJumpSlideForce;
    [SerializeField] private float maxWallRunTime;
    [NonSerialized] private float wallRunTimer;
    [Header("Player Input")]
    [SerializeField] private KeyCode jumpKey = KeyCode.Space;
    [NonSerialized] private float horizontalInput;
    [NonSerialized] private float verticalInput;
    [Header("Wall Checker")]
    [SerializeField] private float wallCheckDistance;
    [SerializeField] private float minJumpHeight;
    [SerializeField] private RaycastHit leftWallHit;
    [SerializeField] private RaycastHit rightWallHit;
    [SerializeField] private bool wallLeft;
    [SerializeField] private bool wallRight;
    [Header("Exiting")]
    private bool exitingWall;
    public float exitWallTime;
    private float exitWallTimer;

    [Header("References")]
    [SerializeField] public Transform orientation;
    private PlayerMovement pm;
    private Rigidbody rb;

    private void Start() {
        rb = GetComponent<Rigidbody>();
        pm = GetComponent<PlayerMovement>();
    }
    private void Update() {
       CheckForWall();
       StateMachine();
    }
    private void FixedUpdate() {
        if(pm.isWallRunning) {
            WallRunningMovement();
        }
    }
    private void CheckForWall() {
        wallRight = Physics.Raycast(transform.position, orientation.right, out rightWallHit, wallCheckDistance, whatIsWall);
        wallLeft = Physics.Raycast(transform.position, -orientation.right, out leftWallHit, wallCheckDistance, whatIsWall);
    }
    private bool AboveGround() {
        return !Physics.Raycast(transform.position, Vector3.down, minJumpHeight, whatIsGround);
    }
    private void StateMachine() {
        horizontalInput = Input.GetAxisRaw("Horizontal");
        verticalInput = Input.GetAxisRaw("Vertical");

        if ((wallRight || wallLeft) && verticalInput > 0 && AboveGround() && !exitingWall) {
            if(!pm.isWallRunning) 
                StartWallRun();
            
            if(Input.GetKeyDown(jumpKey)) WallJump();
                         
        }
        else if (exitingWall) {
            if (pm.isWallRunning) 
                StopWallRun();
            if (exitWallTimer > 0)
                exitWallTimer -= Time.deltaTime;
            if (exitWallTimer <= 0) 
                exitingWall = false;                        
        }
        else {
            if(pm.isWallRunning) {
                StopWallRun();
            }
        } 
    }
    private void StartWallRun() {
        pm.isWallRunning = true;
    }
    private void WallRunningMovement() {
        rb.useGravity = false;
        rb.velocity = new Vector3(rb.velocity.x, 0f, rb.velocity.z);

        Vector3 wallNormal = wallRight ? rightWallHit.normal : leftWallHit.normal;
        Vector3 wallForward = Vector3.Cross(transform.up, wallNormal);

        if ((orientation.forward - wallForward).magnitude > (orientation.forward - -wallForward).magnitude)
            wallForward = -wallForward;        

        rb.AddForce(wallForward * wallRunForce, ForceMode.Force);
    }
    private void StopWallRun() {
        pm.isWallRunning = false;
    }
    private void WallJump() {
        exitingWall = true;
        exitWallTimer = exitWallTime; 

        Vector3 wallNormal = wallRight ? rightWallHit.normal : leftWallHit.normal;

        Vector3 forceToApply = transform.up * wallJumpUpForce + wallNormal * wallJumpUpForce;

        rb.velocity = new Vector3(rb.velocity.x, 0f, rb.velocity.z);
        rb.AddForce(forceToApply, ForceMode.Impulse);
    }
}

Чтобы подстроить ваш код для бега по стенам под `CharacterController` и не использовать `Rigidbody`, надо учитывать, что `CharacterController` работает с методом `Move`, что требует изменения логики движения и взаимодействия с физикой. Ниже приведен обновленный код:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class WallRunning : MonoBehaviour
{
    [Header("Wall Running")]
    [SerializeField] private LayerMask whatIsWall;
    [SerializeField] private LayerMask whatIsGround;
    [SerializeField] private float wallRunForce;
    [SerializeField] private float wallJumpUpForce;
    [SerializeField] private float wallJumpSlideForce;
    [SerializeField] private float maxWallRunTime;
    [NonSerialized] private float wallRunTimer;

    [Header("Player Input")]
    [SerializeField] private KeyCode jumpKey = KeyCode.Space;
    [NonSerialized] private float horizontalInput;
    [NonSerialized] private float verticalInput;

    [Header("Wall Checker")]
    [SerializeField] private float wallCheckDistance;
    [SerializeField] private float minJumpHeight;
    [SerializeField] private RaycastHit leftWallHit;
    [SerializeField] private RaycastHit rightWallHit;
    [SerializeField] private bool wallLeft;
    [SerializeField] private bool wallRight;

    [Header("Exiting")]
    private bool exitingWall;
    public float exitWallTime;
    private float exitWallTimer;

    [Header("References")]
    [SerializeField] public Transform orientation;
    private CharacterController characterController;
    private Vector3 velocity;

    private void Start()
    {
        characterController = GetComponent<CharacterController>();
    }

    private void Update()
    {
        CheckForWall();
        StateMachine();
    }

    private void FixedUpdate()
    {
        if (pm.isWallRunning)
        {
            WallRunningMovement();
        }
    }

    private void CheckForWall()
    {
        wallRight = Physics.Raycast(transform.position, orientation.right, out rightWallHit, wallCheckDistance, whatIsWall);
        wallLeft = Physics.Raycast(transform.position, -orientation.right, out leftWallHit, wallCheckDistance, whatIsWall);
    }

    private bool AboveGround()
    {
        return !Physics.Raycast(transform.position, Vector3.down, minJumpHeight, whatIsGround);
    }

    private void StateMachine()
    {
        horizontalInput = Input.GetAxisRaw("Horizontal");
        verticalInput = Input.GetAxisRaw("Vertical");

        if ((wallRight || wallLeft) && verticalInput > 0 && AboveGround() && !exitingWall)
        {
            if (!pm.isWallRunning)
                StartWallRun();

            if (Input.GetKeyDown(jumpKey)) WallJump();
        }
        else if (exitingWall)
        {
            if (pm.isWallRunning)
                StopWallRun();

            if (exitWallTimer > 0)
                exitWallTimer -= Time.deltaTime;

            if (exitWallTimer <= 0)
                exitingWall = false;
        }
        else
        {
            if (pm.isWallRunning)
            {
                StopWallRun();
            }
        }
    }

    private void StartWallRun()
    {
        pm.isWallRunning = true;
    }

    private void WallRunningMovement()
    {
        characterController.Move(Vector3.zero); // Отменяем движение, чтобы произвести собственное

        Vector3 wallNormal = wallRight ? rightWallHit.normal : leftWallHit.normal;
        Vector3 wallForward = Vector3.Cross(transform.up, wallNormal).normalized;

        // Применение силы бега по стене
        Vector3 moveDirection = wallForward * wallRunForce * Time.deltaTime;
        characterController.Move(moveDirection);

        // Устранение гравитации
        velocity.y = 0f;
    }

    private void StopWallRun()
    {
        pm.isWallRunning = false;
    }

    private void WallJump()
    {
        exitingWall = true;
        exitWallTimer = exitWallTime;

        Vector3 wallNormal = wallRight ? rightWallHit.normal : leftWallHit.normal;
        Vector3 jumpDirection = transform.up * wallJumpUpForce + wallNormal * wallJumpSlideForce;

        characterController.Move(jumpDirection * Time.deltaTime);
    }
}
```

### Примечания к изменениям:

1. **Rigidbody удален**: Все места, где использовался компонент `Rigidbody`, заменены на `CharacterController`.

2. **Переписывание методов движения**: Используйте `CharacterController.Move` для движения, вместо методов, связанных с физикой.

3. **Устранение гравитации**: Поскольку `CharacterController` уже обрабатывает физику, просто установите `velocity.y = 0` во время бега по стене.

4. **Корректировка силы и направления при прыжке**: Чтобы обеспечить правильное движение при прыжке, вам нужно рассчитывать направление силы относительно стены.

Этот код — базовая структура. В зависимости от ваших требований, возможно, понадобятся дополнительные корректировки для улучшения поведения персонажа.

ещё раз и будь внимательнее

Извините за недостаточную точность в предыдущем ответе. Давайте попробуем адаптировать код для бега по стенам с использованием `CharacterController` более аккуратно.

Вот исправленный код для бега по стенам с использованием `CharacterController` без `Rigidbody`:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class WallRunning : MonoBehaviour
{
    [Header("Wall Running")]
    [SerializeField] private LayerMask whatIsWall;
    [SerializeField] private LayerMask whatIsGround;
    [SerializeField] private float wallRunForce;
    [SerializeField] private float wallJumpUpForce;
    [SerializeField] private float wallJumpSlideForce;
    [SerializeField] private float maxWallRunTime;

    [Header("Player Input")]
    [SerializeField] private KeyCode jumpKey = KeyCode.Space;

    [Header("Wall Checker")]
    [SerializeField] private float wallCheckDistance;
    [SerializeField] private float minJumpHeight;
    [SerializeField] private RaycastHit leftWallHit;
    [SerializeField] private RaycastHit rightWallHit;
    private bool wallLeft;
    private bool wallRight;

    [Header("Exiting")]
    private bool exitingWall;
    public float exitWallTime;
    private float exitWallTimer;

    [Header("References")]
    [SerializeField] private Transform orientation;
    private CharacterController characterController;
    private Vector3 velocity;

    private PlayerMovement pm; // Предполагается, что есть класс PlayerMovement для управления состояниями игрока.

    private void Start()
    {
        characterController = GetComponent<CharacterController>();
        pm = GetComponent<PlayerMovement>();
    }

    private void Update()
    {
        CheckForWall();
        StateMachine();
        
        // Применение гравитации
        if (!pm.isWallRunning)
        {
            velocity.y += Physics.gravity.y * Time.deltaTime;
        }

        characterController.Move(velocity * Time.deltaTime);
    }

    private void CheckForWall()
    {
        wallRight = Physics.Raycast(transform.position, orientation.right, out rightWallHit, wallCheckDistance, whatIsWall);
        wallLeft = Physics.Raycast(transform.position, -orientation.right, out leftWallHit, wallCheckDistance, whatIsWall);
    }

    private bool AboveGround()
    {
        return !Physics.Raycast(transform.position, Vector3.down, minJumpHeight, whatIsGround);
    }

    private void StateMachine()
    {
        float horizontalInput = Input.GetAxisRaw("Horizontal");
        float verticalInput = Input.GetAxisRaw("Vertical");

        if ((wallRight || wallLeft) && verticalInput > 0 && AboveGround() && !exitingWall)
        {
            if (!pm.isWallRunning)
                StartWallRun();

            if (Input.GetKeyDown(jumpKey))
                WallJump();
        }
        else if (exitingWall)
        {
            if (pm.isWallRunning)
                StopWallRun();

            if (exitWallTimer > 0)
                exitWallTimer -= Time.deltaTime;

            if (exitWallTimer <= 0)
                exitingWall = false;
        }
        else
        {
            if (pm.isWallRunning)
            {
                StopWallRun();
            }
        }
    }

    private void StartWallRun()
    {
        pm.isWallRunning = true; // Устанавливаем состояние бега по стене
        velocity = Vector3.zero; // Сбрасываем скорость
    }

    private void WallRunningMovement()
    {
        Vector3 wallNormal = wallRight ? rightWallHit.normal : leftWallHit.normal;
        Vector3 wallForward = Vector3.Cross(transform.up, wallNormal).normalized;

        // Применение силы для движения по стене
        velocity = wallForward * wallRunForce;
    }

    private void StopWallRun()
    {
        pm.isWallRunning = false;
        velocity = Vector3.zero; // Сбрасываем скорость при остановке бега по стене
    }

    private void WallJump()
    {
        exitingWall = true;
        exitWallTimer = exitWallTime;

        Vector3 wallNormal = wallRight ? rightWallHit.normal : leftWallHit.normal;
        Vector3 jumpDirection = transform.up * wallJumpUpForce + wallNormal * wallJumpSlideForce;

        velocity = jumpDirection; // Устанавливаем скорость при прыжке
    }
}
```

### Ключевые изменения:

1. **Управление движением**: Убрана переменная `Rigidbody` с использованием компонента `CharacterController` и его метода `Move`.

2. **Логика бега по стене**: Используется `Vector3.Cross` для вычисления направления движения относительно стен, и `velocity` для хранения направления и силы, применяемой к движению.

3. **Гравитация**: Добавлена логика для применения гравитации, когда игрок не находится в состоянии бега по стене.

4. **Управление состоянием**: Реализован простой механизм для управления состоянием бега по стене.

Проверьте этот код и внесите необходимые доработки в зависимости от ваших возможностей. Если есть дополнительные аспекты, которые нужно учесть, дайте знать!

using System;
using System.Collections;
using System.Collections.Generic;
using System.Runtime.CompilerServices;
using Unity.Properties;
using Unity.VisualScripting;
using UnityEngine;

public class FirstPersonController : MonoBehaviour
{
    public CharacterController characterController;
    public Camera mainCamera;
    private Camera playerCamera;

    private Vector3 moveDirection;
    private Vector2 currentInput;

    private float rotationX = 0;

    public bool CanMove { get; private set; } = true;
    private bool isSprinting => canSprint && !isCrouching && Input.GetKey(sprintKey);
    private bool ShouldJump => Input.GetKeyDown(jumpKey) && !isCrouching && characterController.isGrounded;
    private bool ShouldCrouch => Input.GetKeyDown(crouchKey) && !duringCrouchAnimation && characterController.isGrounded;

    [Header("Functional Options")]
    [SerializeField] private bool canSprint = true;
    [SerializeField] private bool canJump = true;
    [SerializeField] private bool canCrouch = true;
    [SerializeField] private bool canUseHeadbob = true;
    [SerializeField] private bool canInteract = true;
    //[SerializeField] private bool useFootsteps = true;

    [Header("Controls")] 
    [SerializeField] private KeyCode sprintKey = KeyCode.LeftShift;
    [SerializeField] private KeyCode jumpKey = KeyCode.Space;
    [SerializeField] private KeyCode crouchKey = KeyCode.LeftControl;
    [SerializeField] private KeyCode interactKey = KeyCode.E;

    [Header("Movement Parameters")]
    [SerializeField] private float walkSpeed = 5.0f;
    [SerializeField] private float sprintSpeed = 9.5f;
    [SerializeField] private float crouchSpeed = 3.0f;
    private float targetSpeed;

    [Header("Look Parameters")]
    [SerializeField, Range(1, 10)] private float lookSpeedX = 2.0f;
    [SerializeField, Range(1, 10)] private float lookSpeedY = 2.0f;
    [SerializeField, Range(1, 180)] private float upperLookLimit = 80.0f;
    [SerializeField, Range(1, 180)] private float lowerLookLimit = 80.0f;

    [Header("Jumping Parameters")]
    [SerializeField] private float jumpForce = 9.0f;
    [SerializeField] private float gravity = 30.0f;

    [Header("Croch Parameters")]
    [SerializeField] private float crouchHeight = 0.5f;
    [SerializeField] private float standHeight = 2f;
    [SerializeField] private float timeToCrouch = 0.25f;
    [SerializeField] private Vector3 crouchingCenter = new Vector3(0, 0.5f, 0);
    [SerializeField] private Vector3 standingCenter = new Vector3(0, 0, 0);
    private bool isCrouching;
    private bool duringCrouchAnimation;

    [Header("Headbob Parameters")]
    [SerializeField] private float walkBobSpeed = 14f;
    [SerializeField] private float walkBobAmount = 0.05f;
    [SerializeField] private float sprintBobSpeed = 18f;
    [SerializeField] private float sprintBobAmount = 0.11f;
    [SerializeField] private float crouchBobSpeed = 8f;
    [SerializeField] private float crouchBobAmount = 0.025f;
    private float defaultYPos = 0;
    private float defaultXPos = 0;
    private float timer;

    /*[Header("Footsteps Parameters")]
    [SerializeField] private float baseStepSpeed = 0.5f;
    [SerializeField] private float crouchStepMultiplier = 1.5f;
    [SerializeField] private float sprintStepMultiplier = 0.6f;
    [SerializeField] private AudioSource footstepAudioSource = default;
    [SerializeField] private AudioClip[] woodClips = default;
    [SerializeField] private AudioClip[] metalClips = default;
    [SerializeField] private AudioClip[] grassClips = default;
    private float footstepTimer = 0;
    private float GetCurrentOffset => isCrouching ? baseStepSpeed * crouchStepMultiplier : IsSprinting ? baseStepSpeed * sprintStepMultiplier : baseStepSpeed;
    */
    [Header("FOV Manager")]
    [SerializeField] private float walkingFOV = 70f;
    [SerializeField] private float sprintingFOV = 90f;
    [SerializeField] private float speedFOVchange = 5f;
    private float targetFOV;

    [Header("Interaction")]
    [SerializeField] private Vector3 interactionRayPoint = default;
    [SerializeField] private float interactionDistance = default;
    [SerializeField] private LayerMask interactionLayer = default;
    private Interactable currentInteractable;

    [Header("Wall Running")]
    [SerializeField] private LayerMask whatIsWall;
    [SerializeField] private float wallRunForce;
    [SerializeField] private float wallRunSpeed;
    [SerializeField] private float wallJumpUpForce;
    [SerializeField] private float wallJumpSlideForce;
    [SerializeField] private float maxWallRunTime;
    [SerializeField] private float WallRunTimer;
    [SerializeField] private bool isWallRunning;
    [Header("Wall Checker")]
    [SerializeField] private float wallCheckDistance;
    [SerializeField] private float minJumpHeight;
    [NonSerialized] private RaycastHit wallLeftHit;
    [NonSerialized] private RaycastHit wallRightHit;
    [SerializeField] private bool wallLeft;
    [SerializeField] private bool wallRight;
    [Header("Exiting Wall Run")]
    [NonSerialized] private bool exitingWall;
    [SerializeField] private float exitWallTime;
    [NonSerialized] private float exitWallTimer;
    public Transform orientation;
    public MovementState state;
    public enum MovementState {
        wallrunning
    }  
    
    void Awake() {
        playerCamera = GetComponentInChildren<Camera>();
        characterController = GetComponent<CharacterController>();
        defaultYPos = playerCamera.transform.localPosition.y;
        defaultXPos = playerCamera.transform.localPosition.x;
        Cursor.lockState = CursorLockMode.Locked;
        Cursor.visible = false;
    }
    void Update() {
        if (CanMove) {
            HandleMovementInput();
            HandleMouseLook();
            ManagerFOV();

            if (canJump) 
                HandleJump();

            if (canCrouch)
                HandleCrouch();
            
            if (canUseHeadbob) 
                HandleHeadbob();
            
            if (canInteract)
                HandleInteractionCheck();
                HandleInteractionInput();

            //if (useFootsteps) 
            //    HandleFootsteps();

            SpeedControl();   
            ApplyFinalMovements();
        }
    }
    private void FixedUpdate() {
        
    }
    private void CheckForWall() {
        wallLeft = Physics.Raycast(transform.position, -orientation.right, out wallLeftHit, wallCheckDistance, whatIsWall);
        wallRight = Physics.Raycast(transform.position, orientation.right, out wallRightHit, wallCheckDistance, whatIsWall);  
    }
    private bool AboveGround() {
        return !characterController.isGrounded;
    }
    private void StateMachine() {
        
    }
    private void StartWallRun() {
        isWallRunning = true;
    }
    private void WallRunMovement() {
        

    }
    private void StopWallRun() {
        isWallRunning = false;
    }
    /*private void HandleFootsteps() {
        if (!characterController.isGrounded) return;
        if (currentInput == Vector2.zero) return;

        footstepTimer -= Time.deltaTime;
        if (footstepTimer <= 0) {
            footstepAudioSource.pitch = UnityEngine.Random.Range(0.9f, 1.1f);
            if (Physics.Raycast(characterController.transform.position, Vector3.down, out RaycastHit hit, 3)) {
                switch(hit.collider.tag) {
                    case "Footsteps/WOOD":
                        footstepAudioSource.PlayOneShot(woodClips[UnityEngine.Random.Range(0, woodClips.Length - 1)]);
                        break;
                    case "Footsteps/METALIC":
                        footstepAudioSource.PlayOneShot(metalClips[UnityEngine.Random.Range(0, metalClips.Length - 1)]);
                        break;
                    case "Footsteps/GRASS":
                        footstepAudioSource.PlayOneShot(grassClips[UnityEngine.Random.Range(0, grassClips.Length - 1)]);
                        break;
                    default:
                        footstepAudioSource.PlayOneShot(metalClips[UnityEngine.Random.Range(0, metalClips.Length - 1)]);
                        break;                       
                }
            }
            footstepTimer = GetCurrentOffset;
        }        
    }*/
    private void HandleInteractionCheck() {
        if (Physics.Raycast(playerCamera.ViewportPointToRay(interactionRayPoint), out RaycastHit hit, interactionDistance)) {
            if (hit.collider.gameObject.layer == 31 && (currentInteractable == null || hit.collider.gameObject.GetInstanceID() != currentInteractable.GetInstanceID())) {
                hit.collider.TryGetComponent(out currentInteractable);

                if(currentInteractable)
                    currentInteractable.OnFocus();
            }
        }
        else if (currentInteractable) {
            currentInteractable.OnLoseFocus();
            currentInteractable = null;
        }
    }
    private void HandleInteractionInput() {
        if (Input.GetKeyDown(interactKey) && currentInteractable != null && Physics.Raycast(playerCamera.ViewportPointToRay(interactionRayPoint), out RaycastHit hit, interactionDistance, interactionLayer)) {
            currentInteractable.OnInteract();            
        }
    }
    private void HandleMovementInput() {
        currentInput = new Vector2((isSprinting && !isWallRunning ? sprintSpeed : isWallRunning ? wallRunSpeed : isCrouching ? crouchSpeed : walkSpeed) * Input.GetAxis("Vertical"),
        (isSprinting && !isWallRunning ? sprintSpeed : isWallRunning ? wallRunSpeed : isCrouching ? crouchSpeed : walkSpeed) * Input.GetAxis("Horizontal"));

        float moveDirectionY = moveDirection.y;
        moveDirection = (transform.TransformDirection(Vector3.forward) * currentInput.x) + (transform.TransformDirection(Vector3.right) * currentInput.y);
        moveDirection.y = moveDirectionY;
    }
    private void HandleMouseLook() {
        rotationX -= Input.GetAxis("Mouse Y") * lookSpeedY;
        rotationX = Mathf.Clamp(rotationX, -upperLookLimit, lowerLookLimit);
        playerCamera.transform.localRotation = Quaternion.Euler(rotationX, 0, 0);
        transform.rotation *= Quaternion.Euler(0, Input.GetAxis("Mouse X") * lookSpeedX, 0);
    }
    private void HandleJump() {
        if (ShouldJump) {
            moveDirection.y = jumpForce;
        }
    }
    private void HandleCrouch() {
        if (ShouldCrouch) {
          StartCoroutine(CrouchStand());
        }
    }
    private void HandleHeadbob() {
        if (!characterController.isGrounded) return;

        if (Mathf.Abs(moveDirection.x) > 0.1f || Mathf.Abs(moveDirection.z) > 0.1f) {
            timer += Time.deltaTime * (isCrouching ? crouchBobSpeed : isSprinting ? sprintBobSpeed : walkBobSpeed);
            playerCamera.transform.localPosition = new Vector3 (
            defaultXPos + Mathf.Sin(timer) * (isCrouching ? crouchBobAmount * 0.25f : isSprinting ? sprintBobAmount * 0.25f : walkBobAmount * 0.25f),
            defaultYPos + Mathf.Sin(timer) * (isCrouching ? crouchBobAmount : isSprinting ? sprintBobAmount : walkBobAmount),
            playerCamera.transform.localPosition.z
            );
        }     
    }
    private void ApplyFinalMovements() {
        if (!characterController.isGrounded) {
            moveDirection.y -= gravity * Time.deltaTime;
        }
        characterController.Move(moveDirection * Time.deltaTime);
    }
    private void ManagerFOV() {
        targetFOV = isSprinting && characterController.velocity.magnitude >= sprintSpeed * 0.5f ? sprintingFOV : walkingFOV;
        mainCamera.fieldOfView = Mathf.Lerp(mainCamera.fieldOfView, targetFOV, speedFOVchange * Time.deltaTime);      
    }
    private IEnumerator CrouchStand() {
        if (isCrouching && Physics.Raycast(playerCamera.transform.position, Vector3.up, 1f)) 
            yield break;      

        duringCrouchAnimation = true;

        float timeElapsed = 0;
        float targetHeight = isCrouching ? standHeight : crouchHeight;
        float currentHeight = characterController.height;
        Vector3 targetCenter = isCrouching ? standingCenter : crouchingCenter;
        Vector3 currentCenter = characterController.center;

        while(timeElapsed < timeToCrouch) {
            characterController.height = Mathf.Lerp(currentHeight, targetHeight, timeElapsed/timeToCrouch);
            characterController.center = Vector3.Lerp(currentCenter, targetCenter, timeElapsed/timeToCrouch);
            timeElapsed += Time.deltaTime;
            yield return null;  
        }

        characterController.height = targetHeight;
        characterController.center = targetCenter;

        isCrouching = !isCrouching;        

        duringCrouchAnimation = false;
    }
    private void SpeedControl() {
        Vector3 flatVel = new Vector3(characterController.velocity.x, 0, characterController.velocity.z);
        targetSpeed = isCrouching ? crouchSpeed : isSprinting ? sprintSpeed : walkSpeed;

        if (flatVel.magnitude > targetSpeed) {
            flatVel = flatVel.normalized * targetSpeed;

            moveDirection.x = flatVel.x;
            moveDirection.z = flatVel.z;
        }
    }
}
Пожалуйста, вставь это в мой код, будь внимателен пожалуйста

Давайте объединим систему управления персонажем в стиле FPS с механизмом бега по стенам, который вы предоставили ранее. Я добавлю необходимые методы и поля для обработки бега по стенам в ваш класс `FirstPersonController`.

Вот адаптированный код:

```csharp
using System.Collections;
using System.Collections.Generic;
using UnityEngine;

public class FirstPersonController : MonoBehaviour
{
    public CharacterController characterController;
    public Camera mainCamera;
    private Camera playerCamera;

    private Vector3 moveDirection;
    private Vector2 currentInput;

    private float rotationX = 0;

    public bool CanMove { get; private set; } = true;

    #region Movement Options
    private bool isSprinting => canSprint && !isCrouching && Input.GetKey(sprintKey);
    private bool ShouldJump => Input.GetKeyDown(jumpKey) && !isCrouching && characterController.isGrounded;
    private bool ShouldCrouch => Input.GetKeyDown(crouchKey) && !duringCrouchAnimation && characterController.isGrounded;
    #endregion

    #region Functional Options
    [Header("Functional Options")]
    [SerializeField] private bool canSprint = true;
    [SerializeField] private bool canJump = true;
    [SerializeField] private bool canCrouch = true;
    [SerializeField] private bool canUseHeadbob = true;
    [SerializeField] private bool canInteract = true;
    #endregion

    #region Controls
    [Header("Controls")]
    [SerializeField] private KeyCode sprintKey = KeyCode.LeftShift;
    [SerializeField] private KeyCode jumpKey = KeyCode.Space;
    [SerializeField] private KeyCode crouchKey = KeyCode.LeftControl;
    [SerializeField] private KeyCode interactKey = KeyCode.E;
    #endregion

    #region Movement Parameters
    [Header("Movement Parameters")]
    [SerializeField] private float walkSpeed = 5.0f;
    [SerializeField] private float sprintSpeed = 9.5f;
    [SerializeField] private float crouchSpeed = 3.0f;
    private float targetSpeed;
    #endregion

    #region Look Parameters
    [Header("Look Parameters")]
    [SerializeField, Range(1, 10)] private float lookSpeedX = 2.0f;
    [SerializeField, Range(1, 10)] private float lookSpeedY = 2.0f;
    [SerializeField, Range(1, 180)] private float upperLookLimit = 80.0f;
    [SerializeField, Range(1, 180)] private float lowerLookLimit = 80.0f;
    #endregion

    #region Jumping Parameters
    [Header("Jumping Parameters")]
    [SerializeField] private float jumpForce = 9.0f;
    [SerializeField] private float gravity = 30.0f;
    #endregion

    #region Crouch Parameters
    [Header("Crouch Parameters")]
    [SerializeField] private float crouchHeight = 0.5f;
    [SerializeField] private float standHeight = 2f;
    [SerializeField] private float timeToCrouch = 0.25f;
    [SerializeField] private Vector3 crouchingCenter = new Vector3(0, 0.5f, 0);
    [SerializeField] private Vector3 standingCenter = new Vector3(0, 0, 0);
    private bool isCrouching;
    private bool duringCrouchAnimation;
    #endregion

    #region Headbob Parameters
    [Header("Headbob Parameters")]
    [SerializeField] private float walkBobSpeed = 14f;
    [SerializeField] private float walkBobAmount = 0.05f;
    [SerializeField] private float sprintBobSpeed = 18f;
    [SerializeField] private float sprintBobAmount = 0.11f;
    [SerializeField] private float crouchBobSpeed = 8f;
    [SerializeField] private float crouchBobAmount = 0.025f;
    private float defaultYPos = 0;
    private float defaultXPos = 0;
    private float timer;
    #endregion

    #region FOV Manager
    [Header("FOV Manager")]
    [SerializeField] private float walkingFOV = 70f;
    [SerializeField] private float sprintingFOV = 90f;
    [SerializeField] private float speedFOVchange = 5f;
    private float targetFOV;
    #endregion

    #region Interaction
    [Header("Interaction")]
    [SerializeField] private Vector3 interactionRayPoint = default;
    [SerializeField] private float interactionDistance = default;
    [SerializeField] private LayerMask interactionLayer = default;
    private Interactable currentInteractable;
    #endregion

    #region Wall Running
    [Header("Wall Running")]
    [SerializeField] private LayerMask whatIsWall;
    [SerializeField] private float wallRunForce;
    [SerializeField] private float wallRunSpeed;
    [SerializeField] private float wallJumpUpForce;
    [SerializeField] private float wallJumpSlideForce;
    [SerializeField] private float maxWallRunTime;
    private float wallRunTimer;
    private bool isWallRunning;

    [Header("Wall Checker")]
    [SerializeField] private float wallCheckDistance;
    [SerializeField] private float minJumpHeight;
    private RaycastHit wallLeftHit;
    private RaycastHit wallRightHit;
    private bool wallLeft;
    private bool wallRight;

    [Header("Exiting Wall Run")]
    private bool exitingWall;
    [SerializeField] private float exitWallTime;
    private float exitWallTimer;
    public Transform orientation;
    #endregion

    void Awake() {
        playerCamera = GetComponentInChildren<Camera>();
        characterController = GetComponent<CharacterController>();
        defaultYPos = playerCamera.transform.localPosition.y;
        defaultXPos = playerCamera.transform.localPosition.x;
        Cursor.lockState = CursorLockMode.Locked;
        Cursor.visible = false;
    }

    void Update() {
        if (CanMove) {
            HandleMovementInput();
            HandleMouseLook();
            ManagerFOV();

            if (canJump) {
                HandleJump();
            }

            if (canCrouch) {
                HandleCrouch();
            }

            if (canUseHeadbob) {
                HandleHeadbob();
            }

            if (canInteract) {
                HandleInteractionCheck();
                HandleInteractionInput();
            }

            CheckForWall();
            StateMachine();
            SpeedControl();   
            ApplyFinalMovements();
        }
    }

    private void FixedUpdate() {
        if (isWallRunning) {
            WallRunMovement();
        }
    }

    private void CheckForWall() {
        wallLeft = Physics.Raycast(transform.position, -orientation.right, out wallLeftHit, wallCheckDistance, whatIsWall);
        wallRight = Physics.Raycast(transform.position, orientation.right, out wallRightHit, wallCheckDistance, whatIsWall);
    }

    private bool AboveGround() {
        return !characterController.isGrounded;
    }

    private void StateMachine() {
        // Проверка состояния игрока
        if ((wallLeft || wallRight) && Input.GetAxis("Vertical") > 0 && AboveGround() && !exitingWall) {
            if (!isWallRunning) {
                StartWallRun();
            }
            if (Input.GetKeyDown(jumpKey)) {
                WallJump();
            }
        } else if (exitingWall) {
            if (isWallRunning) {
                StopWallRun();
            }
            if (exitWallTimer > 0) {
                exitWallTimer -= Time.deltaTime;
            }
            if (exitWallTimer <= 0) {
                exitingWall = false;
            }
        } else {
            if (isWallRunning) {
                StopWallRun();
            }
        }
    }

    private void StartWallRun() {
        isWallRunning = true;
        moveDirection.y = 0; // Сбросить вертикальную скорость
    }

    private void WallRunMovement() {
        // Получение нормали стены
        Vector3 wallNormal = wallRight ? wallRightHit.normal : wallLeftHit.normal;
        Vector3 wallForward = Vector3.Cross(transform.up, wallNormal).normalized;

        // Перемещение по стене
        moveDirection = wallForward * wallRunSpeed;
        moveDirection.y = 0; // Установить вертикальную скорость в 0, чтобы избежать падения
    }

    private void StopWallRun() {
        isWallRunning = false;
    }

    private void WallJump() {
        exitingWall = true;
        exitWallTimer = exitWallTime;

        Vector3 wallNormal = wallRight ? wallRightHit.normal : wallLeftHit.normal;
        Vector3 jumpDirection = transform.up * wallJumpUpForce + wallNormal * wallJumpSlideForce;

        moveDirection.y = jumpDirection.y; // Устанавливаем вертикальную скорость для прыжка
    }

    private void HandleMovementInput() {
        currentInput = new Vector2(
            (isSprinting && !isWallRunning ? sprintSpeed : isWallRunning ? wallRunSpeed : isCrouching ? crouchSpeed : walkSpeed) * Input.GetAxis("Vertical"),
            (isSprinting && !isWallRunning ? sprintSpeed : isWallRunning ? wallRunSpeed : isCrouching ? crouchSpeed : walkSpeed) * Input.GetAxis("Horizontal")
        );

        float moveDirectionY = moveDirection.y;
        moveDirection = (transform.TransformDirection(Vector3.forward) * currentInput.x) + (transform.TransformDirection(Vector3.right) * currentInput.y);
        moveDirection.y = moveDirectionY;
    }

    private void HandleMouseLook() {
        rotationX -= Input.GetAxis("Mouse Y") * lookSpeedY;
        rotationX = Mathf.Clamp(rotationX, -upperLookLimit, lowerLookLimit);
        playerCamera.transform.localRotation = Quaternion.Euler(rotationX, 0, 0);
        transform.rotation *= Quaternion.Euler(0, Input.GetAxis("Mouse X") * lookSpeedX, 0);
    }

    private void HandleJump() {
        if (ShouldJump) {
            moveDirection.y = jumpForce;
        }
    }

    private void HandleCrouch() {
        if (ShouldCrouch) {
            StartCoroutine(CrouchStand());
        }
    }

    private void HandleHeadbob() {
        if (!characterController.isGrounded) return;

        if (Mathf.Abs(moveDirection.x) > 0.1f || Mathf.Abs(moveDirection.z) > 0.1f) {
            timer += Time.deltaTime * (isCrouching ? crouchBobSpeed : isSprinting ? sprintBobSpeed : walkBobSpeed);
            playerCamera.transform.localPosition = new Vector3(
                defaultXPos + Mathf.Sin(timer) * (isCrouching ? crouchBobAmount * 0.25f : isSprinting ? sprintBobAmount * 0.25f : walkBobAmount * 0.25f),
                defaultYPos + Mathf.Sin(timer) * (isCrouching ? crouchBobAmount : isSprinting ? sprintBobAmount : walkBobAmount),
                playerCamera.transform.localPosition.z
            );
        }
    }

    private void ApplyFinalMovements() {
        if (!characterController.isGrounded) {
            moveDirection.y -= gravity * Time.deltaTime;
        }
        characterController.Move(moveDirection * Time.deltaTime);
    }

    private void ManagerFOV() {
        targetFOV = isSprinting && characterController.velocity.magnitude >= sprintSpeed * 0.5f ? sprintingFOV : walkingFOV;
        mainCamera.fieldOfView = Mathf.Lerp(mainCamera.fieldOfView, targetFOV, speedFOVchange * Time.deltaTime);
    }

    private IEnumerator CrouchStand() {
        if (isCrouching && Physics.Raycast(playerCamera.transform.position, Vector3.up, 1f)) 
            yield break;

        duringCrouchAnimation = true;

        float timeElapsed = 0;
        float targetHeight = isCrouching ? standHeight : crouchHeight;
        float currentHeight = characterController.height;
        Vector3 targetCenter = isCrouching ? standingCenter : crouchingCenter;
        Vector3 currentCenter = characterController.center;

        while(timeElapsed < timeToCrouch) {
            characterController.height = Mathf.Lerp(currentHeight, targetHeight, timeElapsed/timeToCrouch);
            characterController.center = Vector3.Lerp(currentCenter, targetCenter, timeElapsed/timeToCrouch);
            timeElapsed += Time.deltaTime;
            yield return null;  
        }

        characterController.height = targetHeight;
        characterController.center = targetCenter;

        isCrouching = !isCrouching;
        duringCrouchAnimation = false;
    }

    private void SpeedControl() {
        Vector3 flatVel = new Vector3(characterController.velocity.x, 0, characterController.velocity.z);
        targetSpeed = isCrouching ? crouchSpeed : isSprinting ? sprintSpeed : walkSpeed;

        if (flatVel.magnitude > targetSpeed) {
            flatVel = flatVel.normalized * targetSpeed;
            moveDirection.x = flatVel.x;
            moveDirection.z = flatVel.z;
        }
    }
}
```

### Изменения и дополнения:

1. **Структура класса**: Я добавил блоки региона для стенового бега, взаимодействия и других аспектов, чтобы сделать код легче для чтения.

2. **Методы бега по стенам**: `CheckForWall`, `StateMachine`, `StartWallRun`, `WallRunMovement`, `StopWallRun` и `WallJump` добавлены, чтобы обеспечить функциональность бега по стенам.

3. **Обработка состояний**: В `StateMachine` добавлена логика для проверки, когда начинать и заканчивать бег по стенам.

4. **Параметры прыжка**: Учитывая состояние бега по стенам, вертикальная скорость корректируется.

Попробуйте интегрировать этот код в вашу игру и дайте знать, если требуется внести дополнительные изменения!

слушай, а вот в коде который я скинул выше был orientation. как ты его заменил, или с characterController он не нужен?

Извините за недостаток ясности. В `CharacterController` не требуется видеть или хранить `Rigidbody`, но `orientation` все равно важен для определения направления движения и проверки стен. Элемент `orientation` служит для управления направлениями по отношению к стенам и другим объектам, что важно для механики бега по стенам.

В коде, который я предоставил, `orientation` остался, и он по-прежнему используется для проверки наличия стен и вычисления направления бега по стенам. Важно, чтобы `orientation` указывал на объект или трансформ, который представляет направление глаз или тела игрока. Обычно это делается с помощью объекта `Transform`, который является дочерним элементом контроллера.

Если `orientation` используется для проверки стен и других направлений, давайте убедимся, что он корректно интегрирован в код. Вот кратко, как вы можете убедиться, что `orientation` правильно работает.

Вы должны убедиться, что:

1. Имеется `public Transform orientation;`, который вы можете установить в инспекторе, или вычислить в коде.
2. `orientation` используется в методах, таких как `CheckForWall()` для проверки наличия стен и в `WallRunMovement()` для результирующего направления движения.

Если вы хотите внести изменения или сделать его более определенным, вы можете сделать так:

### Обновленный код с `orientation`

```csharp
private void StartWallRun() {
    isWallRunning = true;
    moveDirection.y = 0; // Сбросить вертикальную скорость
}

private void WallRunMovement() {
    // Получение нормали стены
    Vector3 wallNormal = wallRight ? wallRightHit.normal : wallLeftHit.normal;
    Vector3 wallForward = Vector3.Cross(orientation.up, wallNormal).normalized; // использование orientation для расчета

    // Перемещение по стене
    moveDirection = wallForward * wallRunSpeed;
    moveDirection.y = 0; // устранение вертикальной скорости
}
```

### Общий Вопрос

- Когда вы прикрепляете `FirstPersonController` к типичному объекту игрока, убедитесь, что `orientation` установлен на соответствующий дочерний объект (например, пустой объект на уровне головы игрока или непосредственно объекта камеры). Это нужно для корректного вызова направлений и проверок.

Если у вас останутся вопросы о том, как лучше интегрировать `orientation` с `CharacterController`, пожалуйста, уточните, и я с радостью помогу!

слушай а wall jump как будто не работает 

Давайте проверим реализацию метода `WallJump`, чтобы выяснить, почему этот функционал может не работать. В методе `WallJump` следует корректно устанавливать вертикальную скорость при прыжке по стене. Мы также должны убедиться, что состояние бега по стенам и направления прыжка правильно обрабатываются.

Вот несколько вещей, которые стоит проверить и учесть при реализации `WallJump`:

### 1. Логика Прыжка

Метод `WallJump` должен применить вертикальное движение в зависимости от текущего состояния игрока и направления стены.

### 2. Пример реализации `WallJump`

```csharp
private void WallJump() {
    exitingWall = true;
    exitWallTimer = exitWallTime;

    Vector3 wallNormal = wallRight ? wallRightHit.normal : wallLeftHit.normal;
    
    // Создаем направление прыжка, используя нормаль стены и вертикальную скорость
    moveDirection = transform.up * wallJumpUpForce + wallNormal * wallJumpSlideForce; 
}
```

### 3. Убедитесь, что `ApplyFinalMovements` корректно работает

В вашем методе `ApplyFinalMovements` необходимо позаботиться о том, чтобы вертикальное движение игрока правильно обрабатывалось:

```csharp
private void ApplyFinalMovements() {
    if (!characterController.isGrounded) {
        moveDirection.y -= gravity * Time.deltaTime; // Применить гравитацию
    }

    characterController.Move(moveDirection * Time.deltaTime); // Применить движения
}
```

### 4. Убедитесь, что вызывается `CheckForWall`

При проверке на стену метод `CheckForWall` должен быть вызван каждый кадр, чтобы убедиться, что `wallLeft` и `wallRight` правильно обновляются. Логика, которая проверяет, можно ли выполнить прыжок, должна быть корректно интегрирована в `StateMachine`.

### Обновленный метод `StateMachine`

Вот обновленный метод `StateMachine`, чтобы учесть все необходимые условия для прыжка по стене:

```csharp
private void StateMachine() {
    float verticalInput = Input.GetAxis("Vertical");

    if ((wallLeft || wallRight) && verticalInput > 0 && AboveGround() && !exitingWall) {
        if (!isWallRunning) {
            StartWallRun();
        }

        if (ShouldJump) {
            WallJump(); // выполняем прыжок по стене
        }
    } else if (exitingWall) {
        if (isWallRunning) {
            StopWallRun();
        }
        if (exitWallTimer > 0) {
            exitWallTimer -= Time.deltaTime;
        }
        if (exitWallTimer <= 0) {
            exitingWall = false;
        }
    } else {
        if (isWallRunning) {
            StopWallRun();
        }
    }
}
```

### Обратите внимание

1. **Проверка условий**: Убедитесь, что все условия для выполнения прыжка удовлетворены (стена, направление, состояние и т.д.).

2. **Настройки скорости прыжка**: Проверьте, что значения `wallJumpUpForce` и `wallJumpSlideForce` заданы правильно в инспекторе.

3. **Гравитация**: Убедитесь, что при выходе из стены и в обычных условиях, а также при прыжке, правильно применяются значения гравитации.

4. **Отладка**: Используйте отладочные сообщения с помощью `Debug.Log`, чтобы понять, когда срабатывают ваши условия (например, выполнен ли прыжок, правильно ли определяется направление стены и т.д.).

Если вы все это проверите и исправите, это должно помочь исправить проблемы с прыжком по стене. Если проблема останется, дайте знать, и я помогу вам с дополнительной отладкой!

private void WallJump() {
    exitingWall = true;
    exitWallTimer = exitWallTime;

    Vector3 wallNormal = wallRight ? wallRightHit.normal : wallLeftHit.normal;
    
    // Создаем направление прыжка, используя нормаль стены и вертикальную скорость
    moveDirection = transform.up * wallJumpUpForce + wallNormal * wallJumpSlideForce; 
}
а тут прыжок прямо, да? то есть персонаж прыгает вперед?

Да, в текущей реализации метода `WallJump` движение направляется в сторону нормали стены и вверх, что может привести к тому, что персонаж будет прыгать в диагональном направлении. Давайте подробнее разберемся, как изменить направление так, чтобы персонаж прыгал точно в сторону от стены, а не просто вверх.

### Изменения для Directional Jump (Прыжок с направлением)

Чтобы ваш персонаж прыгал в сторону от стены, следует немного изменить логику в методе `WallJump`. Мы можем использовать нормаль стены для выведения вектора направления, который будет комбинировать вертикальное направление с направлением, перпендикулярным к стене. Это даст возможность прыгать не только вверх, но и немного в сторону.

Вот обновленный метод `WallJump`:

```csharp
private void WallJump() {
    exitingWall = true;
    exitWallTimer = exitWallTime;

    Vector3 wallNormal = wallRight ? wallRightHit.normal : wallLeftHit.normal;

    // Рассчитываем вектор прыжка
    Vector3 jumpDirection = transform.up * wallJumpUpForce + wallNormal * wallJumpSlideForce;

    // Устанавливаем вертикальную скорость перед прыжком
    moveDirection = new Vector3(jumpDirection.x, jumpDirection.y, jumpDirection.z);
}
```

### Пояснение:
1. **`wallNormal`**: Этот вектор ориентирован в сторону стены. Он будет использоваться для направленного прыжка.

2. **`jumpDirection`**: Это комбинированный вектор, который учитывает вертикальную компоненту и компоненту, перпендикулярную стене. Это улучшает управляемость прыжка, так как ваш персонаж будет иметь возможность отталкиваться и от стены, и вверх.

3. **`moveDirection`**: Мы присваиваем `moveDirection` рассчитанному `jumpDirection`, так чтобы персонаж получил скорость при прыжке.

### Подбор значений

- **`wallJumpUpForce`**: Это значение определяет силу вертикального прыжка. Убедитесь, что оно достаточно большое, чтобы персонаж поднимался в воздух.

- **`wallJumpSlideForce`**: Это значение определяет силу смещения в сторону от стены. Если вам нужно, чтобы персонаж отходил от стены дальше, увеличьте это значение.

### Итог
Таким образом, ваш персонаж будет прыжком отходить от стены, а не только вверх. Если вы заметите, что прыжки не такие, как вы ожидаете, вы также можете поэкспериментировать с векторами или добавить больше контроля над направлением, если это необходимо.

Если у вас есть дополнительные вопросы или нужна помощь с этой реализацией, не стесняйтесь спрашивать!

слушай а мне надо чтобы  персонаж прыгал в сторону, как это сделать

Чтобы персонаж прыгал в сторону, например, от стены, необходимо правильно рассчитать направление прыжка. Основная идея заключается в том, чтобы использовать нормаль стены для определения направления, в котором будет производиться прыжок, и обеспечивать соответствующее влияние на скорость движения.

### Изменение метода WallJump

Вот как вы можете изменить метод `WallJump`, чтобы персонаж прыгал в сторону от стены:

```csharp
private void WallJump() {
    exitingWall = true;
    exitWallTimer = exitWallTime;

    // Определяем нормаль стены
    Vector3 wallNormal = wallRight ? wallRightHit.normal : wallLeftHit.normal;

    // Вычисляем направление прыжка
    Vector3 jumpDirection = wallNormal + Vector3.up * wallJumpUpForce;

    // Нормализуем вектор, чтобы у него была одна единица длина
    jumpDirection.Normalize();

    // Устанавливаем скорость прыжка
    moveDirection = jumpDirection * wallJumpSlideForce;  // Умножаем на силу для движения в сторону
}
```

### Объяснение изменений:
1. **Параметры `wallNormal`**: Это норма стены, к которой вы обращаетесь (либо левая, либо правая). Этот вектор будет использоваться как консоль для определения направления прыжка.

2. **Вектор направления прыжка (`jumpDirection`)**:
   - Мы складываем `wallNormal` с вертикальным вектором `Vector3.up` умноженным на `wallJumpUpForce`. Это предоставляет направление, которое включает оба вектора: от стены и вверх.
   - Используя `Normalize()`, мы гарантируем, что направляющий вектор будет иметь длину один. Это важно для того, чтобы корректно управлять направлением.

3. **Установка `moveDirection`**: Здесь мы устанавливаем скорость движения `moveDirection`, умножая его на `wallJumpSlideForce`, что определяет силу смещения в сторону.

### Итог

С этой реализацией, когда персонаж прыгает, он будет уходить от стены с определенной высотой. Параметр `wallJumpSlideForce` будет определять, насколько далеко персонаж уходит от стены при прыжке.

### Дополнительные Смотр:

- **Тестирование значений**: Убедитесь, что значения `wallJumpUpForce` и `wallJumpSlideForce` правильно установлены в инспекторе, чтобы добиться требуемого результата.
  
- **Обработка прыжков**: Убедитесь, что обработка прыжков в методе `ApplyFinalMovements()` корректно учитывает новую настройку скорости и гравитации.

Если потребуется дальнейшая поддержка или более детальная проработка механики, дайте знать!

Write a detailed and concise text with a simple straightfoward language about Impact and Influence: Explore how the actor or actress influenced the film industry during there era and beyond.Discuss their contribution to Hollywood.of actor Bruce Cabot Please ensure that the response avoids phrases such as 'Ah,' 'Oh,' or any other similar expressions. Please avoid unnecessary repetition of dates and times in your responses unless they are directly relevant to the context. Ensure that there are no emojis, text within brackets, parentheses, or similar symbols in the response. I want one text without paraphrase titles. And please provide concise and straightforward responses without unnecessary adjectives or embellishments to keep the language minimalistic and simple. 

        Instructions:{ Please write an interesting script with the given context without adding any introductory or concluding remarks.
        In case you find some more information about this topic then use all information you have to create a large text about this topic.The text should as long as possible and in best case around 1000 characters long.
        Ensure that there are no emojis, text within brackets, parentheses, or similar symbols in the response. 
        Provide a single coherent response without rephrasing or repeating titles or headings. Avoid enumerations or bullet points. 
        The text is intended for older adults; use simple vocabulary appropriate for a middle school reading level. Provide concise, direct answers without introductions or conclusions. 
        Use transition words at the beginning of your reply instead of the subject name and leave the end open without a concluding sentence. 
        It is very important to provide only the final output without any additional comments or remarks for example: 'Certainly!' Here's the revised text.
         
        Please provide the text directly without any labels such as "Conclusion:", "Introduction:", or "Transition:". Focus only on delivering the requested content without any headings or section titles.
        Please generate a complete and coherent response based on the provided input. Ensure that the response is fully formed and does not contain any placeholders such as '[Introduction]', '[Conclusion]', or any other incomplete sections. 
        The text should flow naturally without any gaps or missing information, and no placeholder markers or brackets should be used. 
        Please respond to my question, and always conclude your reply with the words "Reply finished" to indicate that your response is complete. 
        Make sure the reply is fully contained before these words and is not cut off prematurely. Thank you.}
        

Bruce Cabot significantly influenced the film industry during his career. He gained prominence in the 1930s and became known for his rugged good looks and strong screen presence. His breakout role in "King Kong" marked a turning point for both his career and the monster movie genre. This classic film showcased groundbreaking special effects and set the standard for adventure films that followed. Cabot's performance helped establish a new kind of leading man, one who embodied bravery and resilience.

Throughout his career, he worked alongside notable directors and actors, broadening his impact on Hollywood. His roles often involved characters that faced dramatic challenges, which resonated with audiences during tough times. This connection allowed Cabot to remain relevant even as genres evolved.

Cabot's influence extended beyond his on-screen roles. He contributed to the development of character-driven storytelling in films. His ability to portray complex emotions paved the way for future actors to explore deeper character arcs. As Hollywood transitioned through various eras, Cabot's presence reminded filmmakers of the importance of relatable heroes. His legacy endures in the way action and adventure films are crafted today. 

Reply finished.

Перевір, якщо новина є закликом щось виграти, зааробити і тд реклама напиши "Y". Якщо ні, то перевір чи ці дві новини описують одну й ту саму подію чи ні? Максимально детально проаналызуй. Якщо різні, то напиши тільки "N", а якщо однакові за змістом, та описують одну й ту саму подію, то напиши тільки "Y". Увага! твоя відповідь має містити лише одну з зазначених букв!!:  НОВИНА 1: Якщо Україна програє війну — вона зникне як держава, — іспанський міністр закордонних справ Хосе Мануель Альбарес.

«Нічого не можна вирішувати щодо України без України, тому що це суверенна держава із законним урядом...
Якщо росія програє цю війну, то рф просто програла війну. Якщо Україна програє цю війну, Україна зникає. У цьому велика різниця! Україна зникне», — заявив Альбарес.

🚀 Приєднатися до ZN.UA

🚀 Підтримати 🤝 ✅✅🤝 НОВИНА 2: **⚡️Трамп призначив Стіва Уіткоффа спецпредставником у Росію та Україну, обіцяючи припинити війну, — ЗМІ 🌎**

[**НейроХрюк**](https://t.me/neirohruk)

N

Перевір, якщо новина є закликом щось виграти, зааробити і тд реклама напиши "Y". Якщо ні, то перевір чи ці дві новини описують одну й ту саму подію чи ні? Максимально детально проаналызуй. Якщо різні, то напиши тільки "N", а якщо однакові за змістом, та описують одну й ту саму подію, то напиши тільки "Y". Увага! твоя відповідь має містити лише одну з зазначених букв!!:  НОВИНА 1: Якщо Україна програє війну — вона зникне як держава, — іспанський міністр закордонних справ Хосе Мануель Альбарес.

«Нічого не можна вирішувати щодо України без України, тому що це суверенна держава із законним урядом...
Якщо росія програє цю війну, то рф просто програла війну. Якщо Україна програє цю війну, Україна зникає. У цьому велика різниця! Україна зникне», — заявив Альбарес.

🚀 Приєднатися до ZN.UA

🚀 Підтримати 🤝 ✅✅🤝 НОВИНА 2: **⚔️ Російські війська продовжують наступальні операції на сході України і, за оцінками аналітиків ISW, не планують зупинятися щонайменше до осені. **

🔥 Зокрема, особливо інтенсивні бої тривають на лінії «Куп’янськ — Борова — Лиман». 

🗣️ «Путін будує свою стратегію війни на безперервному виснажливому тиску, розраховуючи на довготривалу кампанію. Кремль не зацікавлений у мирних переговорах, бо ставка зроблена на затяжний конфлікт», — йдеться у повідомленні.

[**НейроХрюк**](https://t.me/neirohruk)

N