Radar.cs

/************************************************/
/*                                              */
/*     Copyright (c) 2018 - 2021 monitor1394    */
/*     https://github.com/monitor1394           */
/*                                              */
/************************************************/
 
using UnityEngine;
using System.Collections.Generic;
using System;
using System.Text.RegularExpressions;
using UnityEngine.UI;
 
namespace XCharts
{
    [System.Serializable]
    public class Radar : MainComponent
    {
        public enum Shape
        {
            Polygon,
            Circle
        }
        public enum PositionType
        {
            Vertice,
            Between,
        }
        [System.Serializable]
        public class Indicator
        {
            [SerializeField] private string m_Name;
            [SerializeField] private double m_Max;
            [SerializeField] private double m_Min;
            [SerializeField] private double[] m_Range = new double[2] { 0, 0 };
            [SerializeField] private TextStyle m_TextStyle = new TextStyle();
 
            public string name { get { return FormatterHelper.TrimAndReplaceLine(m_Name); } set { m_Name = value; } }
            public double max { get { return m_Max; } set { m_Max = value; } }
            public double min { get { return m_Min; } set { m_Min = value; } }
            public TextStyle textStyle { get { return m_TextStyle; } set { m_TextStyle = value; } }
            public Text text { get; set; }
            public double[] range
            {
                get { return m_Range; }
                set { if (value != null && value.Length == 2) { m_Range = value; } }
            }
 
            public bool IsInRange(double value)
            {
                if (m_Range == null || m_Range.Length < 2) return true;
                if (m_Range[0] != 0 || m_Range[1] != 0)
                    return value >= m_Range[0] && value <= m_Range[1];
                else
                    return true;
            }
        }
        [SerializeField] private bool m_Show;
        [SerializeField] private Shape m_Shape;
        [SerializeField] private float m_Radius = 100;
        [SerializeField] private int m_SplitNumber = 5;
        [SerializeField] private float[] m_Center = new float[2] { 0.5f, 0.5f };
        [SerializeField] private AxisLine m_AxisLine = AxisLine.defaultAxisLine;
        [SerializeField] private AxisSplitLine m_SplitLine = AxisSplitLine.defaultSplitLine;
        [SerializeField] private AxisSplitArea m_SplitArea = AxisSplitArea.defaultSplitArea;
        [SerializeField] private bool m_Indicator = true;
        [SerializeField] private PositionType m_PositionType = PositionType.Vertice;
        [SerializeField] private float m_IndicatorGap = 10;
        [SerializeField] private int m_CeilRate = 0;
        [SerializeField] private bool m_IsAxisTooltip;
        [SerializeField] private Color32 m_OutRangeColor = Color.red;
        [SerializeField] private bool m_ConnectCenter = false;
        [SerializeField] private bool m_LineGradient = true;
        [SerializeField] private List<Indicator> m_IndicatorList = new List<Indicator>();
        public bool show { get { return m_Show; } set { if (PropertyUtil.SetStruct(ref m_Show, value)) SetComponentDirty(); } }
        public Shape shape
        {
            get { return m_Shape; }
            set { if (PropertyUtil.SetStruct(ref m_Shape, value)) SetAllDirty(); }
        }
        public float radius
        {
            get { return m_Radius; }
            set { if (PropertyUtil.SetStruct(ref m_Radius, value)) SetAllDirty(); }
        }
        public int splitNumber
        {
            get { return m_SplitNumber; }
            set { if (PropertyUtil.SetStruct(ref m_SplitNumber, value)) SetAllDirty(); }
        }
        public float[] center
        {
            get { return m_Center; }
            set { if (value != null) { m_Center = value; SetAllDirty(); } }
        }
        public AxisLine axisLine
        {
            get { return m_AxisLine; }
            set { if (PropertyUtil.SetClass(ref m_AxisLine, value, true)) SetAllDirty(); }
        }
        public AxisSplitLine splitLine
        {
            get { return m_SplitLine; }
            set { if (PropertyUtil.SetClass(ref m_SplitLine, value, true)) SetAllDirty(); }
        }
        public AxisSplitArea splitArea
        {
            get { return m_SplitArea; }
            set { if (PropertyUtil.SetClass(ref m_SplitArea, value, true)) SetAllDirty(); }
        }
        public bool indicator
        {
            get { return m_Indicator; }
            set { if (PropertyUtil.SetStruct(ref m_Indicator, value)) SetComponentDirty(); }
        }
        public float indicatorGap
        {
            get { return m_IndicatorGap; }
            set { if (PropertyUtil.SetStruct(ref m_IndicatorGap, value)) SetComponentDirty(); }
        }
        public int ceilRate
        {
            get { return m_CeilRate; }
            set { if (PropertyUtil.SetStruct(ref m_CeilRate, value < 0 ? 0 : value)) SetAllDirty(); }
        }
        public bool isAxisTooltip
        {
            get { return m_IsAxisTooltip; }
            set { if (PropertyUtil.SetStruct(ref m_IsAxisTooltip, value)) SetAllDirty(); }
        }
        public PositionType positionType
        {
            get { return m_PositionType; }
            set { if (PropertyUtil.SetStruct(ref m_PositionType, value)) SetAllDirty(); }
        }
        public Color32 outRangeColor
        {
            get { return m_OutRangeColor; }
            set { if (PropertyUtil.SetStruct(ref m_OutRangeColor, value)) SetAllDirty(); }
        }
        public bool connectCenter
        {
            get { return m_ConnectCenter; }
            set { if (PropertyUtil.SetStruct(ref m_ConnectCenter, value)) SetAllDirty(); }
        }
        public bool lineGradient
        {
            get { return m_LineGradient; }
            set { if (PropertyUtil.SetStruct(ref m_LineGradient, value)) SetAllDirty(); }
        }
        public List<Indicator> indicatorList { get { return m_IndicatorList; } }
 
        public int index { get; internal set; }
        public Vector3 runtimeCenterPos { get; internal set; }
        public float runtimeRadius { get; internal set; }
        public float runtimeDataRadius { get; internal set; }
        public Dictionary<int, List<Vector3>> runtimeDataPosList = new Dictionary<int, List<Vector3>>();
 
        public static Radar defaultRadar
        {
            get
            {
                var radar = new Radar
                {
                    m_Show = true,
                    m_Shape = Shape.Polygon,
                    m_Radius = 0.35f,
                    m_SplitNumber = 5,
                    m_Indicator = true,
                    m_IndicatorList = new List<Indicator>(5){
                        new Indicator(){name="indicator1",max = 0},
                        new Indicator(){name="indicator2",max = 0},
                        new Indicator(){name="indicator3",max = 0},
                        new Indicator(){name="indicator4",max = 0},
                        new Indicator(){name="indicator5",max = 0},
                    }
                };
                radar.center[0] = 0.5f;
                radar.center[1] = 0.4f;
                radar.splitLine.show = true;
                radar.splitArea.show = true;
                return radar;
            }
        }
 
        private bool IsEqualsIndicatorList(List<Indicator> indicators1, List<Indicator> indicators2)
        {
            if (indicators1.Count != indicators2.Count) return false;
            for (int i = 0; i < indicators1.Count; i++)
            {
                var indicator1 = indicators1[i];
                var indicator2 = indicators2[i];
                if (!indicator1.Equals(indicator2)) return false;
            }
            return true;
        }
 
        public bool IsInIndicatorRange(int index, double value)
        {
            var indicator = GetIndicator(index);
            return indicator == null ? true : indicator.IsInRange(value);
        }
 
        public double GetIndicatorMin(int index)
        {
            if (index >= 0 && index < m_IndicatorList.Count)
            {
                return m_IndicatorList[index].min;
            }
            return 0;
        }
        public double GetIndicatorMax(int index)
        {
            if (index >= 0 && index < m_IndicatorList.Count)
            {
                return m_IndicatorList[index].max;
            }
            return 0;
        }
 
        internal void UpdateRadarCenter(Vector3 chartPosition, float chartWidth, float chartHeight)
        {
            if (center.Length < 2) return;
            var centerX = center[0] <= 1 ? chartWidth * center[0] : center[0];
            var centerY = center[1] <= 1 ? chartHeight * center[1] : center[1];
            runtimeCenterPos = chartPosition + new Vector3(centerX, centerY);
            if (radius <= 0)
            {
                runtimeRadius = 0;
            }
            else if (radius <= 1)
            {
                runtimeRadius = Mathf.Min(chartWidth, chartHeight) * radius;
            }
            else
            {
                runtimeRadius = radius;
            }
            if (shape == Radar.Shape.Polygon && positionType == PositionType.Between)
            {
                var angle = Mathf.PI / indicatorList.Count;
                runtimeDataRadius = runtimeRadius * Mathf.Cos(angle);
            }
            else
            {
                runtimeDataRadius = runtimeRadius;
            }
        }
 
        public Vector3 GetIndicatorPosition(int index)
        {
            int indicatorNum = indicatorList.Count;
            var angle = 0f;
            switch (positionType)
            {
                case PositionType.Vertice:
                    angle = 2 * Mathf.PI / indicatorNum * index;
                    break;
                case PositionType.Between:
                    angle = 2 * Mathf.PI / indicatorNum * (index + 0.5f);
                    break;
            }
            var x = runtimeCenterPos.x + (runtimeRadius + indicatorGap) * Mathf.Sin(angle);
            var y = runtimeCenterPos.y + (runtimeRadius + indicatorGap) * Mathf.Cos(angle);
            return new Vector3(x, y);
        }
 
        public void AddIndicator(Radar.Indicator indicator)
        {
            indicatorList.Add(indicator);
            SetAllDirty();
        }
 
        public Radar.Indicator AddIndicator(string name, float min, float max)
        {
            var indicator = new Radar.Indicator();
            indicator.name = name;
            indicator.min = min;
            indicator.max = max;
            indicatorList.Add(indicator);
            SetAllDirty();
            return indicator;
        }
 
        public bool UpdateIndicator(int indicatorIndex, string name, float min, float max)
        {
            var indicator = GetIndicator(indicatorIndex);
            if (indicator == null) return false;
            indicator.name = name;
            indicator.min = min;
            indicator.max = max;
            SetAllDirty();
            return true;
        }
 
        public Radar.Indicator GetIndicator(int indicatorIndex)
        {
            if (indicatorIndex < 0 || indicatorIndex > indicatorList.Count - 1) return null;
            return indicatorList[indicatorIndex];
        }
    }
}