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

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

[DefaultExecutionOrder(10)]
[RequireComponent(typeof(InstantiatePrefab))]
public class WanderingAI_Thief : 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 = 2.0f; //Streuung
    [Header("Leave Settings")]
    public float leaveTimer = 120f;
    public Vector3 leavePosition;

    // Settings Leave Market
    private bool leaveMarket = false;
    private Vector3 endTarget;

    // Settings Thief
    [HideInInspector]
    public bool ignoreThief;
    private int thief_i;
    private int thief_j;

    // 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;

    // Time
    private float[] timer;
    [HideInInspector]
    public 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;
        
        thief_i = gameObject.GetComponent<ControllingThief>().thief_i;
        thief_j = gameObject.GetComponent<ControllingThief>().thief_j;

        endTarget = CheckTarget(leavePosition, 0);
    }

    // To ensure that all market stalls (WPs) are visited, all entries in the WP-list are first edited in a random order
    // and each edited one is appended to the end of the list so that all unedited ones can be selected by decreasing the range.
    // Since the order of the WP-list is the same as the first dimension of the waitingTimer (WT) matrix,
    // the WT matrix can be edited with the same index as for the selection of the WP. So the arrangement is always the same.
    // The second dimension (the times of the individual market stalls) of the WT matrix is first completely emptied each time and then refilled.
    // After the leaving time is reached, all humans walk straight outside the market, without waiting the waiting times.
    private void FixedUpdate()
    {
        if (waypoints.Length == 0) return;
        // Leave Market if time is up
        if(globalTimer >= leaveTimer)
            leaveMarket = true;

        for (int i = 0; i < humansGO.Length; ++i)
        {
            // Set a new destination if the waiting time is over
            if (timer[i] >= currentWait[i] && !leaveMarket)
            {
                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);

                        // Set destination and animation
                        if (target[i][0].x != float.PositiveInfinity)
                        {
                            // 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);
                                
                            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 max length by 1
                            AppendIndexToEndWP(currentWPIndex);
                            AppendIndexToEndWT(currentWPIndex);
                            maxWPCount--;
                            timer[i] = 0;
                        }
                    }
                }
            }
            // if leaving time has arrived, then leave market
            else if (leaveMarket)
            {
                for (int j = 0; j < humansGO[i].Length; ++j)
                {
                    if (ignoreThief && thief_i == i && thief_j == j)
                    {
                        continue;
                    }

                    if (humansNMA[i][j].isActiveAndEnabled && Vector3.Distance(humansNMA[i][j].destination, endTarget) > 0.01f)
                        humansNMA[i][j].SetDestination(endTarget);

                    humansA[i][j].SetBool(isWalking, humansNMA[i][j].velocity.magnitude > 0.01f);

                    if ((Vector3.Distance(humansNMA[i][j].transform.position, endTarget) <= 4))
                    {
                        humansGO[i][j].SetActive(false);
                    }
                }
            }
            // 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];
                }
            }
        }
        if(globalTimer >= 10.0f)
            gameObject.GetComponent<WriteInCSV>().startWriting = true;
        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);
    }

    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);
            }
        }
    }
}