Worlds | Easy to use but feature rich World Guard Plugin | Game Engine library

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using Cinemachine;

public class Waypoints : MonoBehaviour
{
    [Header("Objects To Move")]
    public Transform objectToMovePrefab;
    public int numberOfObjectsToMove = 1;

    [Header("Speed")]
    public float speed;
    public bool randomSpeed = false;
    public float minRandomSpeed = 1;
    public float maxRandomSpeed = 100;
    private bool changeSpeedOnce = false;
    private bool currentSpeedState;

    [Header("Waypoints")]
    [SerializeField] private List waypoints;

    [Header("Delay")]
    public bool useDelay = false;
    public float delay = 3;
    public bool randomDelay = false;
    public float minRandomDelay = 0.3f;
    public float maxRandomDelay = 5;

    [Header("LineRenderer")]
    public LineRenderer lineRenderer;
    public bool moveOnLineRenderer = false;
    public List lineRendererPositions = new List();

    [Header("Cinemachine Cameras")]
    public CinemachineVirtualCamera virtualCamera;

    private List waypointsFollowers = new List();

    private void Start()
    {
        currentSpeedState = changeSpeedOnce;

        for (int i = 0; i < numberOfObjectsToMove; i++)
        {
            var parent = GameObject.Find("Moving Object Parent");
            var objectToMove = Instantiate(objectToMovePrefab, parent.transform);
            objectToMove.name = "Platfrom";

            waypointsFollowers.Add(objectToMove.GetComponent());
        }

        virtualCamera.Follow = waypointsFollowers[0].gameObject.transform;
        virtualCamera.LookAt = waypointsFollowers[0].gameObject.transform;

        foreach (Transform wp in waypoints)
        {
            lineRendererPositions.Add(wp.position);
        }

        if (moveOnLineRenderer)
        {
            foreach (WaypointsFollower wpf in waypointsFollowers)
            {
                wpf.go = true;
            }
        }

        SpeedUpdater();

        if (useDelay)
            StartCoroutine(SendObjectstomoveWithDelay());
    }

    private void Update()
    {
        lineRendererPositions.Clear();
        lineRendererPositions.AddRange(GetLinePointsInWorldSpace());

        SpeedUpdater();
    }

    public int Count => waypoints.Count;
    public Vector3 GetWaypoint(int index)
    {
        return waypoints[index].position;
    }

    public int CountLR => lineRendererPositions.Count;
    public Vector3 GetLRWaypoint(int index)
    {
        return lineRendererPositions[index];
    }

    IEnumerator SendObjectstomoveWithDelay()
    {
        {
            foreach (WaypointsFollower follower in waypointsFollowers)
            {
                if (randomDelay)
                {
                    delay = Random.Range(minRandomDelay, maxRandomDelay);
                }

                yield return new WaitForSeconds(delay);

                follower.go = true;
            }
        }
    }

    private void SpeedUpdater()
    {
        foreach (WaypointsFollower follower in waypointsFollowers)
        {
            if (randomSpeed)
            {
                follower.speed = Random.Range(minRandomSpeed, maxRandomSpeed);
            }
            else
            {
                follower.speed = speed;
            }
        }
    }

    Vector3[] GetLinePointsInWorldSpace()
    {
        var positions = new Vector3[lineRenderer.positionCount];
        //Get the positions which are shown in the inspector 
        lineRenderer.GetPositions(positions);


        //the points returned are in world space
        return positions;
    }
}