Studio/Assets/Scripts/XED/Machine/AGV/AGV_Manager.cs

using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Linq;
using UnityEngine;
using XRLib;

namespace XED.Machine
{
    public class AGV_Manager : MonoBehaviour,ISingle
    {
        [SerializeField]
        GameObject agvPrefab;

        public List<AGV> agvs = new List<AGV>();
        Dictionary<AGV, List<AGVNode>> orderDict = new Dictionary<AGV, List<AGVNode>>();
        public event Action<List<AGVNode>> onOrderStarted;

        public string fileName = "Assets/AGVsLog.csv";

        private void Start()
        {

            agvs = FindObjectsByType<AGV>(FindObjectsSortMode.None).ToList();
            foreach(var a in agvs)
            {
                a.onTaskComplete += WriteLog;
            }

            CreateLogFile();
        }

        void CreateLogFile()
        {
            if (!File.Exists(fileName))
            {
                using (StreamWriter sw = File.CreateText(fileName))
                {
                    sw.WriteLine("Time,AGV_ID,Task,Target,Success");
                }
            }
        }

        public AGV SpawnAGV(Vector3 position,Quaternion rotation)
        {
            GameObject newAGV = Instantiate(agvPrefab,position, rotation);
            AGV agv = newAGV.GetComponent<AGV>();
            agv.onTaskComplete += WriteLog;
            agvs.Add(agv);
            return agv;
        }
        public void OrderToAGV(AGV AGV, AGVTaskType order, GameObject Target,Component comp)
        {
            AGV.QueueOrderOnAGV(new AGVOrderClass(order, Target,comp));
        }

        public void OrderToAGV(int AGVindex,AGVTaskType order, GameObject Target)
        {
            agvs[AGVindex].QueueOrderOnAGV(new AGVOrderClass(order, Target));
        }

        public void OrderToAGV(AGV AGV, AGVTaskType order, GameObject Target)
        {
            AGV.QueueOrderOnAGV(new AGVOrderClass(order, Target));
        }

        public void OrderToAGV(AGV AGV, AGVTaskType order, Vector3 Target)
        {
            AGV.QueueOrderOnAGV(new AGVOrderClass(order, Target));
        }

        public void OrderToAGV(int AGVindex, AGVTaskType order, GameObject Target1, GameObject Target2)
        {
            agvs[AGVindex].QueueOrderOnAGV(new AGVOrderClass(order, Target1,Target2));
        }

        public void OrderToAGV(AGV AGV, AGVTaskType order)
        {
            AGV.QueueOrderOnAGV(new AGVOrderClass(order));
        }

        void WriteLog(AGV agv, AGVTaskType task, string target,bool success)
        {
            using (StreamWriter sw = File.AppendText(fileName))
            {
                string logLine = $"{DateTime.Now},{agv.id},{task},{target},{success}";
                sw.WriteLine();
                sw.WriteLine(logLine);
                sw.Dispose();
            }
        }

        public void ordertoAGV(List<AGVNode> OrderList)
        {
            Vector3 direction = (OrderList[1].transform.position - OrderList[0].transform.position);
            direction = new Vector3(direction.x, 0, direction.z);
            Quaternion lookRotation = Quaternion.LookRotation(direction);
            var agv=SpawnAGV(OrderList[0].transform.position, lookRotation);
            for (int i = 0; i < OrderList.Count; i++)
            {
                if (i != 0)
                {
                    OrderToAGV(agv, AGVTaskType.SpinToTarget, OrderList[i].gameObject);
                    OrderToAGV(agv, AGVTaskType.MoveToTarget, OrderList[i].gameObject);
                }
                if (OrderList[i].nodeClass.type == AGVNodeType.charge)
                {
                    OrderToAGV(agv, AGVTaskType.Charging);
                }
                if (OrderList[i].nodeClass.type == AGVNodeType.load)
                {
                    OrderToAGV(agv, AGVTaskType.LoadCargo, OrderList[i].loadSocket, OrderList[i]);
                    //OrderToAGV(agv, AGVTaskType.LiftUpDown, OrderList[i].loadSocket.transform.position + new Vector3(0, 0.2f, 0));
                }
                if (OrderList[i].nodeClass.type == AGVNodeType.unLoad)
                {
                    OrderToAGV(agv, AGVTaskType.UnLoadCargo, OrderList[i].unLoadSocket, OrderList[i]);
                    OrderToAGV(agv, AGVTaskType.LiftReset);
                }
            }
            orderDict.Add(agv, OrderList);
            onOrderStarted?.Invoke(OrderList);
            agv.onOrderCompleted += OrderReplay;
            agv.onOrderStoped += StopOrder;
        }

        public void ordertoAGV(List<AGVNode> OrderList,AGV agv)
        {
            for (int i = 0; i < OrderList.Count; i++)
            {
                OrderToAGV(agv, AGVTaskType.SpinToTarget, OrderList[i].gameObject);
                OrderToAGV(agv, AGVTaskType.MoveToTarget, OrderList[i].gameObject);
                if (OrderList[i].nodeClass.type == AGVNodeType.charge)
                {
                    OrderToAGV(agv, AGVTaskType.Charging);
                }
                if (OrderList[i].nodeClass.type == AGVNodeType.load)
                {
                    OrderToAGV(agv, AGVTaskType.LoadCargo, OrderList[i].loadSocket, OrderList[i]);
                    //OrderToAGV(agv, AGVTaskType.LiftUpDown, OrderList[i].loadSocket.transform.position+new Vector3(0,0.2f,0));
                }
                if (OrderList[i].nodeClass.type == AGVNodeType.unLoad)
                {
                    OrderToAGV(agv, AGVTaskType.UnLoadCargo, OrderList[i].unLoadSocket, OrderList[i]);
                    OrderToAGV(agv, AGVTaskType.LiftReset);
                }
            }
        }

        public void OrderReplay(AGV agv)
        {
            ordertoAGV(orderDict[agv], agv);
        }

        public void StopOrder(AGV agv)
        {
            agv.onOrderCompleted -= OrderReplay;
            orderDict.Remove(agv);
        }
    }
}