Bachelor-Thesis_Furkan_Karakocaoglu/testumgebung/CrowdModelling/Assets/Depictions_Years/Scripts/WanderingAI/WanderingAI.cs

using System.Collections.Generic;
using UnityEngine;
using UnityEngine.AI;

[DefaultExecutionOrder(10)]
[RequireComponent(typeof(InstantiatePrefab))]
public class WanderingAI : MonoBehaviour
{
    [Header("Only for Debugging (do not set from here)")]
    public Transform[] waypoints;
    public List<Transform> waypointsList;
    public float[] wanderTimer;
    [Header("Scattering around the target")]
    public float targetScattering = 5.0f; //Streuung
    [Header("Leave Settings")]
    public float leaveTimer = 120f;
    public Vector3 leavePosition;

    // Settings Leave Market
    private float offsetx = 0;
    private float offsetz = 0;
    private int inRow = 4; // incl 0 - 4
    private bool leaveMarket = false;

    // Settings Humans
    private Vector3[][] target;
    private int[][] humansPrio;

    // Settings Waypoints and Waiting Time
    private int maxWPCount;
    private List<List<int>> waitingTimer;
    private List<int> waitingList;
    private float[] currentWait;
    private int countFilling = 0;

    // Time
    private float[] timer;
    private float globalTimer;

    private GameObject[][] humansGO;
    private NavMeshAgent[][] humansNMA;
    private Animator[][] humansA;

    private const string isWalking = "isWalking";

    void Start()
    {
        // Get initialized Variables from InstantiatePrefab
        humansGO = gameObject.GetComponent<InstantiatePrefab>().humanGameObject;
        humansNMA = gameObject.GetComponent<InstantiatePrefab>().humanNavMeshAgent;
        humansA = gameObject.GetComponent<InstantiatePrefab>().humanAnimator;
        wanderTimer = gameObject.GetComponent<InstantiatePrefab>().wanderTimer;
        waypoints = gameObject.GetComponent<InstantiatePrefab>().waypointsArray;
        humansPrio = gameObject.GetComponent<InstantiatePrefab>().humanPriorities;
        // Set length of variables to humanGo.Length
        target = new Vector3[humansGO.Length][];
        timer = new float[humansGO.Length];

        // Create copies
        waypointsList = new List<Transform>(waypoints);
        waitingTimer = new List<List<int>>(gameObject.GetComponent<InstantiatePrefab>().waitingTimer);
        waitingList = new List<int>(waitingTimer[0]);
        currentWait = new float[humansGO.Length];

        maxWPCount = waypointsList.Count;

        // Initialize size and content
        for (int i = 0; i < humansGO.Length; i++)
        {
            target[i] = new Vector3[humansGO[i].Length];
            timer[i] = 0;
        }

        globalTimer = 0;
    }

    private void FixedUpdate()
    {
        // Leave Market if time is up
        if(globalTimer >= leaveTimer)
            leaveMarket = true;

        for (int i = 0; i < humansGO.Length; ++i)
        {
            if (waypoints.Length == 0) return;
            // Set a new destination if the waiting time is over
            if (timer[i] >= currentWait[i])
            {
                for (int j = 0; j < humansGO[i].Length; ++j)
                {
                    // Set new destination iff the human reached his destination or (only in first iteration) target vector is zero
                    if (target[i][j] == Vector3.zero ||
                        humansNMA[i][j].velocity.magnitude <= 0.01f ||
                        humansNMA[i][j].remainingDistance <= humansNMA[i][j].stoppingDistance ||
                        humansNMA[i][j].pathStatus == NavMeshPathStatus.PathComplete ||
                        !humansNMA[i][j].hasPath)
                    {
                        // Random index for waypointsList
                        if (maxWPCount <= 0) maxWPCount = waypointsList.Count;
                        int currentWPIndex = Random.Range(0, maxWPCount);
                        target[i][j] = CheckTarget(waypointsList[currentWPIndex].transform.position, targetScattering);
                        // Random index for waitingTimer
                        int currentWaitingIndex = Random.Range(0, waitingTimer[currentWPIndex].Count);
                        currentWait[i] = waitingTimer[currentWPIndex][currentWaitingIndex];
                        RemoveIndexFromWaitingTimer(currentWPIndex, currentWaitingIndex);
                        // Fill waiting timer with default, if it is empty, to get a new waiting time for the next iteration
                        if (waitingTimer[currentWPIndex].Count <= 0)
                        {
                            waitingTimer[currentWPIndex] = new List<int>(waitingList);
                            countFilling++; // to check if all waitingTimer entries are processed
                        }

                        // Set destination and animation
                        if (target[i][0].x != float.PositiveInfinity)
                        {
                            if (humansNMA[i][j].isActiveAndEnabled)
                                humansNMA[i][j].SetDestination(target[i][j]);

                            humansA[i][j].SetBool(isWalking, humansNMA[i][j].velocity.magnitude > 0.01f);
                        }
                        // Append the current WP and the waiting time from both lists to the end to ensure that all WPs and waiting timers are visited at the frequency indicated,
                        // afterwords decrement the imaginated max length by 1
                        AppendIndexToEndWP(currentWPIndex);
                        AppendIndexToEndWT(currentWPIndex);
                        maxWPCount--;
                        timer[i] = 0;
                    }
                }
            }
            // Wait until the waiting time is over
            else
            {
                for (int j = 0; j < humansGO[i].Length; ++j)
                {
                    // Set walking state and priority; increment timer
                    humansA[i][j].SetBool(isWalking, humansNMA[i][j].velocity.magnitude > 0.01f);
                    if (humansNMA[i][j].remainingDistance <= humansNMA[i][j].stoppingDistance)
                        timer[i] += Time.deltaTime;
                    // if humans are not walking, then set priority to 0 so that the other humans dont disturb them
                    if (humansNMA[i][j].velocity.magnitude <= 0.01f)
                        humansNMA[i][j].avoidancePriority = 0;
                    else
                        humansNMA[i][j].avoidancePriority = humansPrio[i][j];
                }
            }
        }
        globalTimer += Time.deltaTime;
    }

    public static Vector3 CheckTarget(Vector3 target, float dist)
    {
        Vector3 modifiedTarget = Random.insideUnitSphere * dist + target;
        // SamplePosition also checks the y axis. However, this is not relevant for me, so valid positions (x & z) are also discarded.
        // 0.0f is the only valid entry for y
        modifiedTarget = new Vector3(modifiedTarget.x, 0f, modifiedTarget.z);
        
        NavMeshHit navHit;
        NavMesh.SamplePosition(modifiedTarget, out navHit, 1.0f, -1);

        return navHit.position;
    }

    public void AppendIndexToEndWP(int index)
    {
        waypointsList.Add(waypointsList[index]);
        waypointsList.RemoveAt(index);
    }

    public void AppendIndexToEndWT(int index)
    {
        waitingTimer.Add(waitingTimer[index]);
        waitingTimer.RemoveAt(index);
    }

    public void RemoveIndexFromWaitingTimer(int i, int removeIndex)
    {
        waitingTimer[i].RemoveAt(removeIndex);
    }

    public void LeaveMarket(int i)
    {
        for (int j = 0; j < humansGO[i].Length; ++j)
        {
            target[i][j] = new Vector3(leavePosition.x + offsetx, 0, leavePosition.z + offsetz);

            // Calculate offset
            if (offsetz < inRow * 2)
                offsetz += 2;
            else
            {
                offsetz = 0;
                offsetx += 2;
            }
        }
    }

    private void LateUpdate()
    {
        for (int i = 0; i < humansGO.Length; ++i)
        {
            for (int j = 0; j < humansGO[i].Length; ++j)
            {
                humansA[i][j].speed = 0.5f + (humansNMA[i][j].velocity.magnitude / gameObject.GetComponent<InstantiatePrefab>().speedMinMax.y);
            }
        }
    }
}