Driftology/Assets/Scripts/VehicleTracker.cs


using Fusion;
using UnityEngine;

public class VehicleTracker : NetworkBehaviour
{
    [SerializeField] private float _leadOffset = 5f;
    [SerializeField] private float _leadMultiplier = 0.1f;
    [SerializeField] private float _sideOffset = 0f;

    private bool _isOffTrack = false;
    private float _offTrackTimer = 0f;

    private float _trackerSpeed = 0f;
    private float _distanceTraveled = 0f;
    private float _speedLeadOffset = 50f;
    private float _speedLeadMultiplier = 0.2f;
    private float _offsetTimerRandom = 0f;

    private RaycastHit _surfaceHit;
    private Vector3 _deltaToWaypoint = Vector3.zero;
    private Vector3 _previousPos = Vector3.zero;
    private Vector3 _offsetToTarget = Vector3.zero;
    private RoutePoint _currentWaypoint = new RoutePoint();
    private Transform _targetTracker = null;
    private VehicleController _linkedController = null;

    public Vector3 TargetPos => _targetTracker != null ? _targetTracker.position : Vector3.zero;
    private float VehicleSpeed => _linkedController != null ? _linkedController.LocalVelocity.z : 0f;
    public WaypointCircuit waypointsCircuit;
    public WaypointCircuit[] allwaypointCircuits;

    private float _offsetSwitchTimer;
    //private void Start()
    //{
    //    _linkedController = GetComponent<VehicleController>();
    //    _targetTracker = new GameObject(name + " Tracker Target").transform;
    //    _targetTracker.SetParent(transform);
    //    _targetTracker.localPosition = Vector3.zero;
    //    _targetTracker.localRotation = Quaternion.identity;
    //    _distanceTraveled = 0f;
    //    _offsetTimerRandom = Random.Range(2.5f, 15f);
    //    _offsetSwitchTimer = _offsetTimerRandom;
    //    waypointsCircuit=FindFirstObjectByType<WaypointCircuit>();
    //}
    public override void Spawned()
    {
        base.Spawned();

        // exactly your old Start() body:
        _linkedController = GetComponent<VehicleController>();
        _targetTracker = new GameObject(name + " Tracker Target").transform;
        _targetTracker.SetParent(transform);
        _targetTracker.localPosition = Vector3.zero;
        _targetTracker.localRotation = Quaternion.identity;
        _distanceTraveled = 0f;
        _offsetTimerRandom = Random.Range(2.5f, 15f);
        _offsetSwitchTimer = _offsetTimerRandom;
        allwaypointCircuits=FindObjectsOfType<WaypointCircuit>();
        for (int i = 0; i < allwaypointCircuits.Length; i++)
        {
            if (allwaypointCircuits[i].accepted==false)
            {
                allwaypointCircuits[i].accepted = true;
                waypointsCircuit = allwaypointCircuits[i];
                break;
            }
        }
        //waypointsCircuit = FindObjectOfType<WaypointCircuit>();
    }
    public override void FixedUpdateNetwork()
    {
        // only the host/state‐authority should drive the AI & resets
        if (!Object.HasStateAuthority)
            return;

        // copy your old FixedUpdate() ground check + waypoint update:
        if (_linkedController == null || !_linkedController.Running)
        {
            _isOffTrack = false;
        }
        else
        {
            // ground‐detection
            if (Physics.Raycast(transform.position - Vector3.down, -transform.up, out _surfaceHit, 10f))
                _isOffTrack = _surfaceHit.collider.CompareTag("Ground");
            else
                _isOffTrack = false;

            UpdateWaypointTracking();
        }

        // copy your old Update() off‐track logic & side‐offset timer:
        if (_linkedController.Running && _linkedController.AIControlled)
        {
            _offsetSwitchTimer += Runner.DeltaTime;                   // use network delta
            if (_offsetSwitchTimer >= _offsetTimerRandom)
            {
                _offsetSwitchTimer = 0;
                _sideOffset = 6f * Mathf.Sin(Time.time * _offsetTimerRandom);
            }
        }

        if (_isOffTrack)
        {
            _offTrackTimer += Runner.DeltaTime;
            if (_offTrackTimer > 3f)
            {
                _isOffTrack = false;
                _offTrackTimer = 0f;
                ResetToTrack();
            }
        }
        else
        {
            _offTrackTimer = 0f;
        }
    }

    #region Commented
    //private void Update()
    //{
    //    if (_linkedController.Running && _linkedController.AIControlled)
    //    {
    //        _offsetSwitchTimer += Time.deltaTime;
    //        if (_offsetSwitchTimer >= _offsetTimerRandom)
    //        {
    //            _offsetSwitchTimer = 0;
    //            _sideOffset = 6f * Mathf.Sin(Time.time * Time.deltaTime * _offsetTimerRandom);
    //        }
    //    }

    //    if (_isOffTrack)
    //    {
    //        _offTrackTimer += Time.deltaTime;
    //        if (_offTrackTimer > 3f)
    //        {
    //            _isOffTrack = false;
    //            _offTrackTimer = 0f;
    //            ResetToTrack();
    //        }
    //    }
    //    else
    //    {
    //        _offTrackTimer = 0f;
    //    }
    //}

    //private void FixedUpdate()
    //{
    //    if (_linkedController == null || !_linkedController.Running)
    //    {
    //        _isOffTrack = false;
    //        return;
    //    }

    //    // 👇 Restrict to local player or server
    //    if (Physics.Raycast(transform.position - Vector3.down, -transform.up, out _surfaceHit, 10f))
    //    {
    //        _isOffTrack = _surfaceHit.collider.CompareTag("Ground");
    //    }
    //    else
    //    {
    //        _isOffTrack = false;
    //    }

    //    UpdateWaypointTracking();
    //}
    #endregion
    private void UpdateWaypointTracking()
    {
        if (Time.deltaTime > 0f)
            _trackerSpeed = VehicleSpeed;

        _targetTracker.position = waypointsCircuit.GetRoutePoint(_distanceTraveled + _leadOffset + _leadMultiplier * _trackerSpeed).position + Vector3.right * _sideOffset;
        _targetTracker.rotation = Quaternion.LookRotation(waypointsCircuit.GetRoutePoint(_distanceTraveled + _speedLeadOffset + _speedLeadMultiplier * _trackerSpeed).direction);

        _currentWaypoint = waypointsCircuit.GetRoutePoint(_distanceTraveled);
        _deltaToWaypoint = _currentWaypoint.position - transform.position;

        if (Vector3.Dot(_deltaToWaypoint, _currentWaypoint.direction) < 0f)
            _distanceTraveled += _deltaToWaypoint.magnitude * 0.5f;

        _previousPos = transform.position;
    }

    private void ResetToTrack()
    {
        _linkedController.DisableVehicle();
        transform.position = _targetTracker.position + new Vector3(0, 0.5f, 0);
        transform.rotation = _targetTracker.rotation;
        _linkedController.EnableVehicle();
    }
}