private void ActiveSubElements(ChargeItem element)
        {
            var actived = completeAbleFeature.elementPool.Find(x => x as ChargeItem != element && x.Name == element.Name);

            if (actived == null)
            {
                var tools = ElementController.Instence.GetElements <ChargeTool>();
                if (tools != null)
                {
                    for (int i = 0; i < tools.Count; i++)
                    {
                        if (element.completeDatas.FindAll(y => tools[i].CanLoad(y.type)).Count == 0)
                        {
                            return;
                        }

                        if (log)
                        {
                            Debug.Log("ActiveElements:" + element.Name + (!tools[i].Actived));
                        }

                        if (!tools[i].Actived)
                        {
                            tools[i].SetActive(this);
                        }
                    }
                }

                var resources = ElementController.Instence.GetElements <ChargeResource>();
                if (resources != null)
                {
                    for (int i = 0; i < resources.Count; i++)
                    {
                        if (element.completeDatas.FindAll(y => y.type == resources[i].type).Count == 0)
                        {
                            continue;
                        }

                        if (log)
                        {
                            Debug.Log("ActiveElements:" + element.Name + (!resources[i].Actived));
                        }

                        if (!resources[i].Actived)
                        {
                            resources[i].SetActive(this);
                        }
                    }
                }
            }

            if (!completeAbleFeature.elementPool.Contains(element))
            {
                completeAbleFeature.elementPool.Add(element);
            }
        }
 public void Update()
 {
     if (chargeTool != null)
     {
         if (chargeTool.charged)
         {
             if (ChargeUtil.FindChargeObj(chargeTool, out chargeObj))
             {
                 if (chargeObj != lastMatchChargeObj)
                 {
                     if (lastMatchChargeObj != null)
                     {
                         highter.UnHighLightTarget(lastMatchChargeObj.gameObject);
                     }
                     highter.HighLightTarget(chargeObj.gameObject, Color.green);
                     lastMatchChargeObj = chargeObj;
                 }
             }
             else
             {
                 if (lastMatchChargeObj != null)
                 {
                     highter.UnHighLightTarget(lastMatchChargeObj.gameObject);
                     lastMatchChargeObj = null;
                 }
             }
         }
         else
         {
             if (ChargeUtil.FindResource(chargeTool, out chargeResource))
             {
                 if (chargeResource != lastMatchChargeResource)
                 {
                     if (lastMatchChargeResource != null)
                     {
                         highter.UnHighLightTarget(lastMatchChargeResource.gameObject);
                     }
                     highter.HighLightTarget(chargeResource.gameObject, Color.green);
                     lastMatchChargeResource = chargeResource;
                 }
             }
             else
             {
                 if (lastMatchChargeResource != null)
                 {
                     highter.UnHighLightTarget(lastMatchChargeResource.gameObject);
                     lastMatchChargeResource = null;
                 }
             }
         }
     }
 }
        public static bool FindChargeObj(ChargeTool item, out ChargeItem container)
        {
            var containerItems = SelectItems <ChargeItem>(ChargeItem.layer, CameraController.Instence.currentCamera.transform.position, item.transform.position, item.Range);

            if (containerItems == null || containerItems.Length == 0)
            {
                container = null;
                return(false);
            }
            else
            {
                for (int i = 0; i < containerItems.Length; i++)
                {
                    ChargeItem tempItem = containerItems[i];
                    if (tempItem != null && tempItem.Actived && tempItem.completeDatas.FindAll(x => x.type == item.data.type).Count > 0)
                    {
                        container = tempItem;
                        return(true);
                    }
                }
                container = null;
                return(false);
            }
        }
        private void OnPickStay(PickUpAbleComponent item)
        {
            var chargeTool = item.GetComponentInParent <ChargeTool>();

            if (chargeTool)
            {
                var currTool = chargeTool;
                if (chargeResource != null)
                {
                    var value = Mathf.Min(currTool.capacity, chargeResource.current);
                    var type  = chargeResource.type;
                    currTool.RetriveFeature <PickUpAbleFeature>().PickUpAble = false;
                    currTool.LoadData(chargeResource.transform.position, new ChargeData(type, value), () =>
                    {
                        currTool.RetriveFeature <PickUpAbleFeature>().PickUpAble = true;
                    });
                    chargeResource.Subtruct(value, () => { });

                    highter.UnHighLightTarget(chargeResource.gameObject);
                    lastMatchChargeResource = chargeResource = null;
                }
                else if (chargeObj != null)
                {
                    var        data     = currTool.data;
                    ChargeData worpData = chargeObj.JudgeLeft(data);
                    if (!string.IsNullOrEmpty(worpData.type))
                    {
                        currTool.RetriveFeature <PickUpAbleFeature>().PickUpAble = false;
                        currTool.OnCharge(chargeObj.transform.position, worpData.value, () => { currTool.RetriveFeature <PickUpAbleFeature>().PickUpAble = true; });
                        chargeObj.Charge(worpData, () => { chargeObj.JudgeComplete(); });
                    }
                    highter.UnHighLightTarget(chargeObj.gameObject);
                    lastMatchChargeObj = null;
                }
            }
        }
 protected virtual void Awake()
 {
     target          = GetComponent <ChargeItem>();
     target.onCharge = OnCharge;
 }
        private void CompleteSubElements(ChargeItem element, bool undo)
        {
            completeAbleFeature.elementPool.Remove(element);
            var active = completeAbleFeature.elementPool.Find(x => x.Name == element.Name);

            if (active == null)
            {
                var tools = ElementController.Instence.GetElements <ChargeTool>();
                if (tools != null)
                {
                    for (int i = 0; i < tools.Count; i++)
                    {
                        if (log)
                        {
                            Debug.Log("CompleteElements:" + element.Name + tools[i].Actived);
                        }

                        if (element.completeDatas.FindAll(y => tools[i].CanLoad(y.type)).Count == 0)
                        {
                            return;
                        }

                        if (tools[i].Actived)
                        {
                            if (undo)
                            {
                                tools[i].UnDoChanges(this);
                            }
                            else
                            {
                                tools[i].SetInActive(this);
                            }
                        }
                    }
                }

                var resources = ElementController.Instence.GetElements <ChargeResource>();
                if (resources != null)
                {
                    for (int i = 0; i < resources.Count; i++)
                    {
                        if (log)
                        {
                            Debug.Log("CompleteElements:" + element.Name + resources[i].Actived);
                        }

                        if (element.completeDatas.FindAll(y => y.type == resources[i].type).Count == 0)
                        {
                            continue;
                        }

                        if (resources[i].Actived)
                        {
                            if (undo)
                            {
                                resources[i].UnDoChanges(this);
                            }
                            else
                            {
                                resources[i].SetInActive(this);
                            }
                        }
                    }
                }
            }
        }