ChunilENG/Assets/WorkSpace/Personal/JYM/MachineKPIManager.cs

using System.Collections;
using System.Collections.Generic;
using System.Linq;
using UnityEngine;
using UnityEngine.UI;
using WI;

namespace CHN
{
    public class MachineKPIManager : MonoBehaviour, ISingle
    {
        public UI_MachineKPI prefab_MachineKPI;

        private OrbitalController cam;
        private Machine[] machines;
        private List<Machine> matchingMachines = new();
        private SDictionary<string, UI_MachineKPI> machineKPIs = new();

        private UI_MachineKPI current_MachineKPI;

        public float defaultNameHeight;
        public float radius;
        public Vector3 originScale;

        [Range(0.1f, 0.5f)]
        public float minScale;
        [Range(0.5f, 1f)]
        public float maxScale;
        [Range(0.1f, 2f)]
        public float scaleClamp;
        public void SetMachineKPI(MachineKPIData machineKPIData)
        {
            foreach (var item in machineKPIs)
            {
                Destroy(item.Value.gameObject);
            }
            machineKPIs.Clear();
            matchingMachines.Clear();

            cam = FindSingle<OrbitalController>();
            prefab_MachineKPI = Resources.Load<UI_MachineKPI>("Prefabs/UI/PRF_UI_MachineKPI");

            foreach (var data in machineKPIData.data.rows)
            {
                if (machineKPIs.ContainsKey(data.workcd))
                    continue;

                var machineKPI = Instantiate(prefab_MachineKPI, transform);
                machineKPI.SetData(data);
                machineKPI.onClickKPI += OnClickMachineKPI;
                machineKPI.name = data.workcd;

                machineKPIs.Add(data.workcd, machineKPI);
            }

            var building = FindSingle<Building>();
            machines = building.floors.SelectMany(f => f.machines).ToArray();

            foreach (var machine in machines)
            {
                if (machineKPIs.ContainsKey(machine.code))
                {
                    machine.machineKPI = machineKPIs[machine.code];

                    var machinePos = machine.centerPos;
                    machine.machineKPI.transform.position = new Vector3(machinePos.x, machinePos.y + defaultNameHeight, machinePos.z);
                    matchingMachines.Add(machine);
                }
            }
        }
        private void OnClickMachineKPI(UI_MachineKPI machineKPI)
        {
            if (current_MachineKPI != null)
            {
                current_MachineKPI.Shrink();
            }
            current_MachineKPI = machineKPI;
            current_MachineKPI.Expand();
            current_MachineKPI.transform.SetAsLastSibling();
        }
        private void Update()
        {
            SettingPos();
            RangeDetection();
            RectangleContainsPoint();
        }
        private void RectangleContainsPoint()
        {
            if (Input.GetMouseButton(0))
            {
                if (current_MachineKPI == null)
                    return;

                if(!RectTransformUtility.RectangleContainsScreenPoint(current_MachineKPI.DetailsKPI, Input.mousePosition))
                {
                    current_MachineKPI.Shrink();
                    current_MachineKPI = null;
                }
            }
        }
        void SettingPos()
        {
            foreach (var machine in matchingMachines)
            {
                var machinePos = machine.centerPos;

                Vector3 screenPos = cam.camera.WorldToScreenPoint(new Vector3(machinePos.x, machinePos.y + defaultNameHeight, machinePos.z));
                if (screenPos.z > 0)
                {
                    machine.machineKPI.transform.position = screenPos;
                }
            }
        }
        void RangeDetection()
        {
            var layerMask = LayerMask.GetMask("Camera", "Floor Wall", "Floor Ground");
            var currentFloor = FindSingle<Building>().currentFloor;

            var max = cam.option.maxDistance - cam.option.minDistance;
            var distance = cam.option.currentDistance;
            var distanceScale = (max - distance) / max;
            distanceScale *= scaleClamp;
            distanceScale = Mathf.Clamp(distanceScale, minScale, maxScale);

            foreach (var machine in matchingMachines)
            {
                if (machine.GetComponentInParent<Floor>() != currentFloor)
                    continue;

                MachineKPIsActive(machine, layerMask);

                var machineKPI = machine.machineKPI;
                machineKPI.transform.localScale = originScale * distanceScale;
            }
        }
        void MachineKPIsActive(Machine machine, LayerMask layerMask)
        {
            var dir = cam.camera.transform.localPosition - machine.centerPos;
            var hit = new RaycastHit();

            if (Physics.Raycast(machine.centerPos, dir, out hit, Mathf.Infinity, layerMask))
            {
                var hitCameraLayer = hit.collider.gameObject.layer.Equals(LayerMask.NameToLayer("Camera"));

                if (hitCameraLayer)
                {
                    machine.machineKPI.Active();
                }
                else
                {
                    machine.machineKPI.Deactive();
                }
            }
        }
    }
}