优化RadarChart雷达图，增加多雷达图支持

Scripts/UI/RadarChart.cs

@@ -13,16 +13,13 @@ namespace XCharts
     {
         private const string INDICATOR_TEXT = "indicator";
 
-        [SerializeField]
-        private Radar m_Radar = Radar.defaultRadar;
-        private Radar m_CheckRadar = Radar.defaultRadar;
-        private float m_RadarCenterX = 0f;
-        private float m_RadarCenterY = 0f;
-        private float m_RadarRadius = 0;
-        private List<Text> indicatorTextList = new List<Text>();
-        private List<List<Vector3>> dataPosList = new List<List<Vector3>>();
+        //[SerializeField] private Radar radar = Radar.defaultRadar;
+        [SerializeField] private List<Radar> m_Radars = new List<Radar>();
+        private List<Radar> m_CheckRadars = new List<Radar>();
+        private bool m_IsEnterLegendButtom;
 
-        public Radar radar { get { return m_Radar; } }
+        //public Radar radar { get { return radar; } }
+        public List<Radar> radars { get { return m_Radars; } }
 
         /// <summary>
         /// 移除所有数据，包含指示器数据。
@@ -30,12 +27,38 @@ namespace XCharts
         public override void RemoveData()
         {
             base.RemoveData();
-            m_Radar.indicatorList.Clear();
+            foreach (var radar in m_Radars)
+            {
+                radar.indicatorList.Clear();
+            }
+            m_CheckRadars.Clear();
         }
+
+        protected override void OnLegendButtonClick(int index, string legendName, bool show)
+        {
+            bool active = CheckDataShow(legendName, show);
+            var bgColor1 = active ? m_ThemeInfo.GetColor(index) : m_ThemeInfo.legendUnableColor;
+            m_Legend.UpdateButtonColor(legendName, bgColor1);
+            RefreshChart();
+        }
+
+        protected override void OnLegendButtonEnter(int index, string legendName)
+        {
+            m_IsEnterLegendButtom = true;
+            CheckDataHighlighted(legendName, true);
+            RefreshChart();
+        }
+
+        protected override void OnLegendButtonExit(int index, string legendName)
+        {
+            m_IsEnterLegendButtom = false;
+            CheckDataHighlighted(legendName, false);
+            RefreshChart();
+        }
+
         protected override void Awake()
         {
             base.Awake();
-            UpdateRadarCenter();
             InitIndicator();
         }
 
@@ -50,198 +73,255 @@ namespace XCharts
         {
             base.Reset();
             RemoveData();
-            m_Radar = Radar.defaultRadar;
+            m_Radars.Add(Radar.defaultRadar);
             m_Title.text = "RadarChart";
-            AddSerie("serie1", SerieType.Radar);
+            var serie = AddSerie("serie1", SerieType.Radar);
+            serie.symbol.type = SerieSymbolType.EmptyCircle;
+            serie.symbol.size = 4;
+            serie.symbol.selectedSize = 6;
+            List<float> data = new List<float>();
             for (int i = 0; i < 5; i++)
             {
-                AddData(0, Random.Range(20, 90));
+                data.Add(Random.Range(20, 90));
             }
+            AddData(0, data);
         }
 #endif
 
-
         private void InitIndicator()
         {
-            indicatorTextList.Clear();
             ChartHelper.HideAllObject(transform, INDICATOR_TEXT);
-            int indicatorNum = m_Radar.indicatorList.Count;
-            float txtWid = 100;
-            float txtHig = 20;
-            for (int i = 0; i < indicatorNum; i++)
+            for (int n = 0; n < m_Radars.Count; n++)
             {
-                var pos = GetIndicatorPosition(i);
-                TextAnchor anchor = TextAnchor.MiddleCenter;
-                var diff = pos.x - m_RadarCenterX;
-                if (diff < -1f)
+                Radar radar = m_Radars[n];
+                radar.UpdateRadarCenter(chartWidth, chartHeight);
+                int indicatorNum = radar.indicatorList.Count;
+                float txtWid = 100;
+                float txtHig = 20;
+                for (int i = 0; i < indicatorNum; i++)
                 {
-                    pos = new Vector3(pos.x - 5, pos.y);
-                    anchor = TextAnchor.MiddleRight;
+                    var indicator = radar.indicatorList[i];
+                    var pos = radar.GetIndicatorPosition(i);
+                    TextAnchor anchor = TextAnchor.MiddleCenter;
+                    var diff = pos.x - radar.centerPos.x;
+                    if (diff < -1f)
+                    {
+                        pos = new Vector3(pos.x - 5, pos.y);
+                        anchor = TextAnchor.MiddleRight;
+                    }
+                    else if (diff > 1f)
+                    {
+                        anchor = TextAnchor.MiddleLeft;
+                        pos = new Vector3(pos.x + txtWid + 5, pos.y);
+                    }
+                    else
+                    {
+                        anchor = TextAnchor.MiddleCenter;
+                        float y = pos.y > radar.centerPos.y ? pos.y + txtHig / 2 : pos.y - txtHig / 2;
+                        pos = new Vector3(pos.x + txtWid / 2, y);
+                    }
+                    var textColor = indicator.color == Color.clear ? (Color)m_ThemeInfo.axisTextColor : indicator.color;
+                    Text txt = ChartHelper.AddTextObject(INDICATOR_TEXT + "_" + n + "_" + i, transform, m_ThemeInfo.font,
+                        textColor, anchor, Vector2.zero, Vector2.zero, new Vector2(1, 0.5f),
+                        new Vector2(txtWid, txtHig));
+                    txt.transform.localPosition = pos;
+                    txt.text = radar.indicatorList[i].name;
+                    txt.gameObject.SetActive(radar.indicator);
                 }
-                else if (diff > 1f)
-                {
-                    anchor = TextAnchor.MiddleLeft;
-                    pos = new Vector3(pos.x + txtWid + 5, pos.y);
-                }
-                else
-                {
-                    anchor = TextAnchor.MiddleCenter;
-                    float y = pos.y > m_RadarCenterY ? pos.y + txtHig / 2 : pos.y - txtHig / 2;
-                    pos = new Vector3(pos.x + txtWid / 2, y);
-                }
-                Text txt = ChartHelper.AddTextObject(INDICATOR_TEXT + i, transform, m_ThemeInfo.font,
-                    m_ThemeInfo.titleTextColor, anchor, Vector2.zero, Vector2.zero, new Vector2(1, 0.5f),
-                    new Vector2(txtWid, txtHig));
-                txt.transform.localPosition = pos;
-                txt.text = m_Radar.indicatorList[i].name;
-                txt.gameObject.SetActive(m_Radar.indicator);
-                indicatorTextList.Add(txt);
             }
         }
 
         private void CheckRadarInfoChanged()
         {
-            if (m_CheckRadar != m_Radar)
+            if (!ChartHelper.IsValueEqualsList(m_CheckRadars, m_Radars))
             {
-                m_CheckRadar.Copy(m_Radar);
+                m_CheckRadars.Clear();
+                foreach (var radar in m_Radars) m_CheckRadars.Add(radar.Clone());
                 OnRadarChanged();
             }
         }
 
         private void OnRadarChanged()
         {
-            UpdateRadarCenter();
             InitIndicator();
             m_Tooltip.UpdateToTop();
         }
 
-        private Vector3 GetIndicatorPosition(int i)
-        {
-            int indicatorNum = m_Radar.indicatorList.Count;
-            var angle = 2 * Mathf.PI / indicatorNum * i;
-            var x = m_RadarCenterX + m_Radar.radius * Mathf.Sin(angle);
-            var y = m_RadarCenterY + m_Radar.radius * Mathf.Cos(angle);
-
-            return new Vector3(x, y);
-        }
-
         protected override void DrawChart(VertexHelper vh)
         {
             base.DrawChart(vh);
-            UpdateRadarCenter();
-            if (m_Radar.cricle)
-                DrawCricleRadar(vh);
-            else
-                DrawRadar(vh);
+            foreach (var radar in m_Radars)
+            {
+                radar.UpdateRadarCenter(chartWidth, chartHeight);
+                if (radar.shape == Radar.Shape.Circle)
+                {
+                    DrawCricleRadar(vh, radar);
+                }
+                else
+                {
+                    DrawRadar(vh, radar);
+                }
+            }
             DrawData(vh);
         }
 
         protected override void OnThemeChanged()
         {
             base.OnThemeChanged();
-            m_Radar.backgroundColorList.Clear();
-            switch (m_ThemeInfo.theme)
+            foreach (var radar in m_Radars)
             {
-                case Theme.Dark:
-                    m_Radar.backgroundColorList.Add(ThemeInfo.GetColor("#6f6f6f"));
-                    m_Radar.backgroundColorList.Add(ThemeInfo.GetColor("#606060"));
-                    break;
-                case Theme.Default:
-                    m_Radar.backgroundColorList.Add(ThemeInfo.GetColor("#f6f6f6"));
-                    m_Radar.backgroundColorList.Add(ThemeInfo.GetColor("#e7e7e7"));
-                    break;
-                case Theme.Light:
-                    m_Radar.backgroundColorList.Add(ThemeInfo.GetColor("#f6f6f6"));
-                    m_Radar.backgroundColorList.Add(ThemeInfo.GetColor("#e7e7e7"));
-                    break;
+                radar.splitArea.color.Clear();
+                switch (m_ThemeInfo.theme)
+                {
+                    case Theme.Dark:
+                        radar.splitArea.color.Add(ThemeInfo.GetColor("#6f6f6f"));
+                        radar.splitArea.color.Add(ThemeInfo.GetColor("#606060"));
+                        break;
+                    case Theme.Default:
+                        radar.splitArea.color.Add(ThemeInfo.GetColor("#f6f6f6"));
+                        radar.splitArea.color.Add(ThemeInfo.GetColor("#e7e7e7"));
+                        break;
+                    case Theme.Light:
+                        radar.splitArea.color.Add(ThemeInfo.GetColor("#f6f6f6"));
+                        radar.splitArea.color.Add(ThemeInfo.GetColor("#e7e7e7"));
+                        break;
+                }
             }
             InitIndicator();
         }
 
-        HashSet<string> serieNameSet = new HashSet<string>();
+        Dictionary<string, int> serieNameSet = new Dictionary<string, int>();
         private void DrawData(VertexHelper vh)
         {
-            int indicatorNum = m_Radar.indicatorList.Count;
-            var angle = 2 * Mathf.PI / indicatorNum;
-            var p = new Vector3(m_RadarCenterX, m_RadarCenterY);
             Vector3 startPoint = Vector3.zero;
             Vector3 toPoint = Vector3.zero;
             Vector3 firstPoint = Vector3.zero;
-            dataPosList.Clear();
-            dataPosList.Capacity = m_Series.Count;
+
             serieNameSet.Clear();
             int serieNameCount = -1;
             for (int i = 0; i < m_Series.Count; i++)
             {
                 var serie = m_Series.series[i];
-                if (string.IsNullOrEmpty(serie.name)) serieNameCount++;
-                else if (!serieNameSet.Contains(serie.name))
-                {
-                    serieNameSet.Add(serie.name);
-                    serieNameCount++;
-                }
+                var radar = m_Radars[serie.radarIndex];
+                int indicatorNum = radar.indicatorList.Count;
+                var angle = 2 * Mathf.PI / indicatorNum;
+                Vector3 p = radar.centerPos;
                 if (!IsActive(i))
                 {
-                    dataPosList.Add(new List<Vector3>());
                     continue;
                 }
-                var dataList = m_Series.series[i].yData;
-                var color = m_ThemeInfo.GetColor(i);
-                var areaColor = color;
-                areaColor.a = (byte)m_Radar.areaAlpha;
-
-                List<Vector3> pointList = new List<Vector3>(dataList.Count);
-                dataPosList.Add(pointList);
-                for (int j = 0; j < dataList.Count; j++)
+                for (int j = 0; j < serie.data.Count; j++)
                 {
-                    var max = m_Radar.GetIndicatorMax(j) > 0 ?
-                        m_Radar.GetIndicatorMax(j) :
-                        GetMaxValue(j);
-                    var radius = max < 0 ? m_Radar.radius - m_Radar.radius * dataList[j] / max
-                        : m_Radar.radius * dataList[j] / max;
-                    var currAngle = j * angle;
-                    if (j == 0)
+                    var serieData = serie.data[j];
+                    int key = i * 100 + j;
+                    if (!radar.dataPosList.ContainsKey(key))
                     {
-                        startPoint = new Vector3(p.x + radius * Mathf.Sin(currAngle),
-                            p.y + radius * Mathf.Cos(currAngle));
-                        firstPoint = startPoint;
+                        radar.dataPosList.Add(i * 100 + j, new List<Vector3>(serieData.data.Count));
                     }
                     else
                     {
-                        toPoint = new Vector3(p.x + radius * Mathf.Sin(currAngle),
-                            p.y + radius * Mathf.Cos(currAngle));
-                        if (m_Radar.area)
-                        {
-                            ChartHelper.DrawTriangle(vh, p, startPoint, toPoint, areaColor);
-                        }
-                        ChartHelper.DrawLine(vh, startPoint, toPoint, m_Radar.lineTickness, color);
-                        startPoint = toPoint;
+                        radar.dataPosList[key].Clear();
+                    }
+                    string dataName = serieData.name;
+                    int serieIndex = 0;
+                    if (string.IsNullOrEmpty(dataName))
+                    {
+                        serieNameCount++;
+                        serieIndex = serieNameCount;
+                    }
+                    else if (!serieNameSet.ContainsKey(dataName))
+                    {
+                        serieNameSet.Add(dataName, serieNameCount);
+                        serieNameCount++;
+                        serieIndex = serieNameCount;
+                    }
+                    else
+                    {
+                        serieIndex = serieNameSet[dataName];
+                    }
+                    if (!serieData.show)
+                    {
+                        continue;
+                    }
+                    var isHighlight = serie.highlighted || serieData.highlighted ||
+                        (m_Tooltip.show && m_Tooltip.dataIndex[0] == i && m_Tooltip.dataIndex[1] == j);
+                    var areaColor = serie.GetAreaColor(m_ThemeInfo, serieIndex, isHighlight);
+                    var lineColor = serie.GetLineColor(m_ThemeInfo, serieIndex, isHighlight);
+                    int dataCount = radar.indicatorList.Count;
+                    List<Vector3> pointList = radar.dataPosList[key];
+                    for (int n = 0; n < dataCount; n++)
+                    {
+                        if (n >= serieData.data.Count) break;
+                        float min = radar.GetIndicatorMin(n);
+                        float max = radar.GetIndicatorMax(n);
+                        float value = serieData.data[n];
+                        if (max == 0)
+                        {
+                            serie.GetMinMaxData(n, out min, out max);
+                            min = radar.GetIndicatorMin(n);
+                        }
+                        var radius = max < 0 ? radar.actualRadius - radar.actualRadius * value / max
+                        : radar.actualRadius * value / max;
+                        var currAngle = n * angle;
+                        if (n == 0)
+                        {
+                            startPoint = new Vector3(p.x + radius * Mathf.Sin(currAngle),
+                                p.y + radius * Mathf.Cos(currAngle));
+                            firstPoint = startPoint;
+                        }
+                        else
+                        {
+                            toPoint = new Vector3(p.x + radius * Mathf.Sin(currAngle),
+                                p.y + radius * Mathf.Cos(currAngle));
+                            if (serie.areaStyle.show)
+                            {
+                                ChartHelper.DrawTriangle(vh, p, startPoint, toPoint, areaColor);
+                            }
+                            if (serie.lineStyle.show)
+                            {
+                                ChartHelper.DrawLine(vh, startPoint, toPoint, serie.lineStyle.width, lineColor);
+                            }
+                            startPoint = toPoint;
+                        }
+                        pointList.Add(startPoint);
+                    }
+                    if (serie.areaStyle.show)
+                    {
+                        ChartHelper.DrawTriangle(vh, p, startPoint, firstPoint, areaColor);
+                    }
+                    if (serie.lineStyle.show)
+                    {
+                        ChartHelper.DrawLine(vh, startPoint, firstPoint, serie.lineStyle.width, lineColor);
+                    }
+                    if (serie.symbol.type != SerieSymbolType.None)
+                    {
+                        var symbolSize = (isHighlight ? serie.symbol.selectedSize : serie.symbol.size);
+                        float symbolRadius = symbolSize - serie.lineStyle.width * 2;
+                        foreach (var point in pointList)
+                        {
+                            DrawSymbol(vh, serie.symbol.type, symbolSize, serie.lineStyle.width, point, lineColor);
+                        }
                     }
-                    pointList.Add(startPoint);
-                }
-                if (m_Radar.area) ChartHelper.DrawTriangle(vh, p, startPoint, firstPoint, areaColor);
-                ChartHelper.DrawLine(vh, startPoint, firstPoint, m_Radar.lineTickness, color);
-                foreach (var point in pointList)
-                {
-                    float radius = m_Radar.linePointSize - m_Radar.lineTickness * 2;
-
-                    ChartHelper.DrawCricle(vh, point, radius, Color.white);
-                    ChartHelper.DrawDoughnut(vh, point, radius, m_Radar.linePointSize, 0, 360, color);
                 }
             }
         }
 
-        private void DrawRadar(VertexHelper vh)
+        private void DrawRadar(VertexHelper vh, Radar radar)
         {
-            float insideRadius = 0, outsideRadius = 0;
-            float block = m_Radar.radius / m_Radar.splitNumber;
-            int indicatorNum = m_Radar.indicatorList.Count;
-            Vector3 p1, p2, p3, p4;
-            Vector3 p = new Vector3(m_RadarCenterX, m_RadarCenterY);
-            float angle = 2 * Mathf.PI / indicatorNum;
-            for (int i = 0; i < m_Radar.splitNumber; i++)
+            if (!radar.lineStyle.show && !radar.splitArea.show)
             {
-                Color color = m_Radar.backgroundColorList[i % m_Radar.backgroundColorList.Count];
+                return;
+            }
+            float insideRadius = 0, outsideRadius = 0;
+            float block = radar.actualRadius / radar.splitNumber;
+            int indicatorNum = radar.indicatorList.Count;
+            Vector3 p1, p2, p3, p4;
+            Vector3 p = radar.centerPos;
+            float angle = 2 * Mathf.PI / indicatorNum;
+            var lineColor = GetLineColor(radar);
+            for (int i = 0; i < radar.splitNumber; i++)
+            {
+                Color color = radar.splitArea.color[i % radar.splitArea.color.Count];
                 outsideRadius = insideRadius + block;
                 p1 = new Vector3(p.x + insideRadius * Mathf.Sin(0), p.y + insideRadius * Mathf.Cos(0));
                 p2 = new Vector3(p.x + outsideRadius * Mathf.Sin(0), p.y + outsideRadius * Mathf.Cos(0));
@@ -252,9 +332,14 @@ namespace XCharts
                         p.y + outsideRadius * Mathf.Cos(currAngle));
                     p4 = new Vector3(p.x + insideRadius * Mathf.Sin(currAngle),
                         p.y + insideRadius * Mathf.Cos(currAngle));
-
-                    ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, color);
-                    ChartHelper.DrawLine(vh, p2, p3, m_Radar.lineTickness, m_Radar.lineColor);
+                    if (radar.splitArea.show)
+                    {
+                        ChartHelper.DrawPolygon(vh, p1, p2, p3, p4, color);
+                    }
+                    if (radar.lineStyle.show)
+                    {
+                        ChartHelper.DrawLine(vh, p2, p3, radar.lineStyle.width, lineColor);
+                    }
                     p1 = p4;
                     p2 = p3;
                 }
@@ -265,24 +350,38 @@ namespace XCharts
                 float currAngle = j * angle;
                 p3 = new Vector3(p.x + outsideRadius * Mathf.Sin(currAngle),
                     p.y + outsideRadius * Mathf.Cos(currAngle));
-                ChartHelper.DrawLine(vh, p, p3, m_Radar.lineTickness / 2, m_Radar.lineColor);
+                if (radar.lineStyle.show)
+                {
+                    ChartHelper.DrawLine(vh, p, p3, radar.lineStyle.width / 2, lineColor);
+                }
             }
         }
 
-        private void DrawCricleRadar(VertexHelper vh)
+        private void DrawCricleRadar(VertexHelper vh, Radar radar)
         {
+            if (!radar.lineStyle.show && !radar.splitArea.show)
+            {
+                return;
+            }
             float insideRadius = 0, outsideRadius = 0;
-            float block = m_Radar.radius / m_Radar.splitNumber;
-            int indicatorNum = m_Radar.indicatorList.Count;
-            Vector3 p = new Vector3(m_RadarCenterX, m_RadarCenterY);
+            float block = radar.actualRadius / radar.splitNumber;
+            int indicatorNum = radar.indicatorList.Count;
+            Vector3 p = radar.centerPos;
             Vector3 p1;
             float angle = 2 * Mathf.PI / indicatorNum;
-            for (int i = 0; i < m_Radar.splitNumber; i++)
+            var lineColor = GetLineColor(radar);
+            for (int i = 0; i < radar.splitNumber; i++)
             {
-                Color color = m_Radar.backgroundColorList[i % m_Radar.backgroundColorList.Count];
+                Color color = radar.splitArea.color[i % radar.splitArea.color.Count];
                 outsideRadius = insideRadius + block;
-                ChartHelper.DrawDoughnut(vh, p, insideRadius, outsideRadius, 0, 360, color);
-                ChartHelper.DrawCicleNotFill(vh, p, outsideRadius, m_Radar.lineTickness, m_Radar.lineColor);
+                if (radar.splitArea.show)
+                {
+                    ChartHelper.DrawDoughnut(vh, p, insideRadius, outsideRadius, 0, 360, color);
+                }
+                if (radar.lineStyle.show)
+                {
+                    ChartHelper.DrawCicleNotFill(vh, p, outsideRadius, radar.lineStyle.width, lineColor);
+                }
                 insideRadius = outsideRadius;
             }
             for (int j = 0; j <= indicatorNum; j++)
@@ -290,76 +389,99 @@ namespace XCharts
                 float currAngle = j * angle;
                 p1 = new Vector3(p.x + outsideRadius * Mathf.Sin(currAngle),
                     p.y + outsideRadius * Mathf.Cos(currAngle));
-                ChartHelper.DrawLine(vh, p, p1, m_Radar.lineTickness / 2, m_Radar.lineColor);
+                if (radar.lineStyle.show)
+                {
+                    ChartHelper.DrawLine(vh, p, p1, radar.lineStyle.width / 2, lineColor);
+                }
             }
         }
 
-        private void UpdateRadarCenter()
+        private Color GetLineColor(Radar radar)
         {
-            float diffX = chartWidth - m_Radar.left - m_Radar.right;
-            float diffY = chartHeight - m_Radar.top - m_Radar.bottom;
-            float diff = Mathf.Min(diffX, diffY);
-            if (m_Radar.radius <= 0)
+            if (radar.lineStyle.color != Color.clear)
             {
-                m_RadarRadius = diff / 3 * 2;
-                m_RadarCenterX = m_Radar.left + m_RadarRadius;
-                m_RadarCenterY = m_Radar.bottom + m_RadarRadius;
+                var color = radar.lineStyle.color;
+                color.a *= radar.lineStyle.opactiy;
+                return color;
             }
             else
             {
-                m_RadarRadius = m_Radar.radius;
-                m_RadarCenterX = chartWidth / 2;
-                m_RadarCenterY = chartHeight / 2;
-                if (m_Radar.left > 0) m_RadarCenterX = m_Radar.left + m_RadarRadius;
-                if (m_Radar.right > 0) m_RadarCenterX = chartWidth - m_Radar.right - m_RadarRadius;
-                if (m_Radar.top > 0) m_RadarCenterY = chartHeight - m_Radar.top - m_RadarRadius;
-                if (m_Radar.bottom > 0) m_RadarCenterY = m_Radar.bottom + m_RadarRadius;
+                var color = (Color)m_ThemeInfo.axisLineColor;
+                color.a *= radar.lineStyle.opactiy;
+                return color;
             }
         }
 
+
         protected override void CheckTootipArea(Vector2 local)
         {
-            if (dataPosList.Count <= 0) return;
-            m_Tooltip.dataIndex[0] = -1;
+            if (m_IsEnterLegendButtom) return;
+
+            bool highlight = false;
             for (int i = 0; i < m_Series.Count; i++)
             {
                 if (!IsActive(i)) continue;
-                for (int j = 0; j < dataPosList[i].Count; j++)
+                var serie = m_Series.GetSerie(i);
+                var radar = m_Radars[serie.radarIndex];
+                var dist = Vector2.Distance(radar.centerPos, local);
+                if (dist > radar.actualRadius + serie.symbol.size)
                 {
-                    if (Vector3.Distance(local, dataPosList[i][j]) <= m_Radar.linePointSize * 1.2f)
+                    continue;
+                }
+                for (int n = 0; n < serie.data.Count; n++)
+                {
+                    var posKey = i * 100 + n;
+                    if (radar.dataPosList.ContainsKey(posKey))
                     {
-                        m_Tooltip.dataIndex[0] = i;
-                        break;
+                        var posList = radar.dataPosList[posKey];
+                        foreach (var pos in posList)
+                        {
+                            if (Vector2.Distance(pos, local) <= serie.symbol.size * 1.2f)
+                            {
+                                m_Tooltip.dataIndex[0] = i;
+                                m_Tooltip.dataIndex[1] = n;
+                                highlight = true;
+                                break;
+                            }
+                        }
                     }
                 }
             }
-            if (m_Tooltip.dataIndex[0] >= 0)
+            
+            if (!highlight)
+            {
+                if (m_Tooltip.IsActive())
+                {
+                    m_Tooltip.SetActive(false);
+                    RefreshChart();
+                }
+            }
+            else
             {
                 m_Tooltip.UpdateContentPos(new Vector2(local.x + 18, local.y - 25));
                 RefreshTooltip();
                 RefreshChart();
             }
-            else
-            {
-                m_Tooltip.SetActive(false);
-            }
         }
 
         protected override void RefreshTooltip()
         {
             base.RefreshTooltip();
-            int index = m_Tooltip.dataIndex[0];
-            if (index < 0)
+            int serieIndex = m_Tooltip.dataIndex[0];
+            if (serieIndex < 0)
             {
                 m_Tooltip.SetActive(false);
                 return;
             }
             m_Tooltip.SetActive(true);
-            StringBuilder sb = new StringBuilder(m_Legend.data[index]);
-            for (int i = 0; i < m_Radar.indicatorList.Count; i++)
+            var serie = m_Series.GetSerie(serieIndex);
+            var radar = m_Radars[serie.radarIndex];
+            var serieData = serie.GetSerieData(m_Tooltip.dataIndex[1]);
+            StringBuilder sb = new StringBuilder(serieData.name);
+            for (int i = 0; i < radar.indicatorList.Count; i++)
             {
-                string key = m_Radar.indicatorList[i].name;
-                float value = m_Series.series[index].yData[i];
+                string key = radar.indicatorList[i].name;
+                float value = serieData.GetData(i);
                 sb.Append("\n");
                 sb.AppendFormat("{0}: {1}", key, value);
             }