Untitled

using System.Collections;
using System.Collections.Generic;
using UnityEngine;
using Cinemachine;
using Unity.Netcode;
using Unity.Netcode.Transports.UTP;

public class CarController : NetworkBehaviour
{



    private float currentSteerAngle;
    private float currentbreakForce;

    [SerializeField] private float motorForce;
    [SerializeField] private float breakForce;
    [SerializeField] private float maxSteerAngle;

    [SerializeField] private WheelCollider frontLeftWheelCollider;
    [SerializeField] private WheelCollider frontRightWheelCollider;
    [SerializeField] private WheelCollider rearLeftWheelCollider;
    [SerializeField] private WheelCollider rearRightWheelCollider;
    [SerializeField] private CinemachineVirtualCamera virtualCamera;

    [SerializeField] private Transform frontLeftWheelTransform;
    [SerializeField] private Transform frontRightWheeTransform;
    [SerializeField] private Transform rearLeftWheelTransform;
    [SerializeField] private Transform rearRightWheelTransform;
    private Rigidbody rb;

    public override void OnNetworkSpawn()
    {
        base.OnNetworkSpawn();

        virtualCamera.enabled = IsOwner;

        GetComponent<Rigidbody>().centerOfMass = new Vector3(0f, -0.9f, 0f);
        rb = GetComponent<Rigidbody>();


    }
    PlayerControls playerControls;

    private void Start()
    {
        Application.targetFrameRate = 90;


        playerControls = new PlayerControls();

        playerControls.Enable();

        if (IsOwner)
        {
            GetComponent<Rigidbody>().isKinematic = false;
        }
    }
    GameplayMode mode;

    private void Update()
    {
        if (!IsOwner) return;

        float steeringInput = 0;

        if (Input.GetKeyDown(KeyCode.K))
        {
            transform.position = new Vector3(-148.526733f, 7.41411114f, 310.927612f);
            transform.rotation = Quaternion.identity;
            rb.velocity = Vector3.zero;
        }

        /*if (data.Accelerometer.x != 0)
        {
            steeringInput = data.Accelerometer.x;
        }
        else
        {
            steeringInput = data.MoveDirection.x;
        }*/

        steeringInput = playerControls.Athelete.Move.ReadValue<Vector2>().x;


        isBreaking = playerControls.Athelete.G.IsPressed();

        HandleMotor(playerControls.Athelete.Move.ReadValue<Vector2>().y);
        HandleSteering(steeringInput);
        UpdateWheels();

        if (rb.velocity.magnitude > 30)
        {
            rb.velocity = Vector3.ClampMagnitude(rb.velocity, 30);
        }

    }

    public bool isBreaking;

    private void HandleMotor(float verticalInput)
    {
        if(mode == null)
        {
            mode = FindObjectOfType<GameplayMode>();
        }

        if(mode != null)
        {
            verticalInput = mode.autoDrive.Value == true ? 1 : verticalInput;
        }

        frontLeftWheelCollider.motorTorque = verticalInput * motorForce;
        frontRightWheelCollider.motorTorque = verticalInput * motorForce;
        currentbreakForce = isBreaking ? breakForce : 0f;
        ApplyBreaking();
    }

    private void ApplyBreaking()
    {
        frontRightWheelCollider.brakeTorque = currentbreakForce;
        frontLeftWheelCollider.brakeTorque = currentbreakForce;
        rearLeftWheelCollider.brakeTorque = currentbreakForce;
        rearRightWheelCollider.brakeTorque = currentbreakForce;
    }

    private void HandleSteering(float horizontal)
    {
        currentSteerAngle = maxSteerAngle * horizontal;
        frontLeftWheelCollider.steerAngle = currentSteerAngle;
        frontRightWheelCollider.steerAngle = currentSteerAngle;
    }

    private void UpdateWheels()
    {
        UpdateSingleWheel(frontLeftWheelCollider, frontLeftWheelTransform);
        UpdateSingleWheel(frontRightWheelCollider, frontRightWheeTransform);
        UpdateSingleWheel(rearRightWheelCollider, rearRightWheelTransform);
        UpdateSingleWheel(rearLeftWheelCollider, rearLeftWheelTransform);
    }

    private void UpdateSingleWheel(WheelCollider wheelCollider, Transform wheelTransform)
    {
        Vector3 pos;
        Quaternion rot
; wheelCollider.GetWorldPose(out pos, out rot);
        wheelTransform.rotation = rot;
        wheelTransform.position = pos;
    }
}