//called by any external component to build tower, uses buildInfo
        public static string BuildTower(UnitTower tower)
        {
            if(buildInfo==null) return "Select a Build Point First";

            UnitTower sampleTower=GetSampleTower(tower);

            //check if there are sufficient resource
            List<int> cost=sampleTower.GetCost();
            int suffCost=ResourceManager.HasSufficientResource(cost);
            if(suffCost==-1){
                ResourceManager.SpendResource(cost);

                GameObject towerObj=(GameObject)Instantiate(tower.gameObject, buildInfo.position, buildInfo.platform.thisT.rotation);
                UnitTower towerInstance=towerObj.GetComponent<UnitTower>();
                towerInstance.InitTower(instance.towerCount+=1);
                towerInstance.Build();

                //clear the build info and indicator for build manager
                ClearBuildPoint();

                return "";
            }

            return "Insufficient Resource";
        }

        //called by any external component to build tower, uses buildInfo
        public static string BuildTower(UnitTower tower)
        {
            if(buildInfo==null) return "Select a Build Point First";

            //dont allow building of resource tower before game started
            if(tower.type==_TowerType.Resource && !GameControl.IsGameStarted()){
                return "Cant Build Tower before spawn start";
            }

            UnitTower sampleTower=GetSampleTower(tower);

            //check if there are sufficient resource
            List<int> cost=sampleTower.GetCost();
            int suffCost=ResourceManager.HasSufficientResource(cost);
            if(suffCost==-1){
                ResourceManager.SpendResource(cost);

                GameObject towerObj=(GameObject)Instantiate(tower.gameObject, buildInfo.position, buildInfo.platform.thisT.rotation);
                UnitTower towerInstance=towerObj.GetComponent<UnitTower>();
                towerInstance.InitTower(instance.towerCount+=1);
                towerInstance.Build();

                //register the tower to the platform
                if(buildInfo.platform!=null) buildInfo.platform.BuildTower(buildInfo.position, towerInstance);

                //clear the build info and indicator for build manager
                ClearBuildPoint();

                return "";
            }

            return "Insufficient Resource";
        }

 public static void AddNewTower(UnitTower newTower)
 {
     if (instance.towerList.Contains(newTower)) return;
       instance.towerList.Add(newTower);
       instance.AddNewSampleTower(newTower);
       if (onAddNewTowerE != null) onAddNewTowerE(newTower);
 }

		public void _AddNewTower(UnitTower newTower){
			int count=buttonList.Count;
			buttonList.Add(buttonList[count-1].Clone("button"+(count), new Vector3(55, 0, 0)));
			buttonList[count].imageIcon.sprite=newTower.iconSprite;
			
			EventTrigger trigger = buttonList[count].rootObj.GetComponent<EventTrigger>();
			EventTrigger.Entry entry=SetupTriggerEntry();
			trigger.triggers.Add(entry);
		}

    // Use this for initialization
    void Start()
    {
        myRenderers = GetComponentsInChildren<MeshRenderer>();
        myRenderersColors = new List<Color>(myRenderers.Length);
        for (int i = 0; i < myRenderers.Length; i++)
        {
            myRenderersColors.Add(myRenderers[i].material.color);
        }

        unitTowerT = GetComponent<TDTK.UnitTower>();
    }

        public void BuildTower(Vector3 pos, UnitTower tower)
        {
            //pathfinding related code, only call if this platform is walkable;
            if(!walkable) return;

            NodeTD node=PathFinder.GetNearestNode(pos, nodeGraph);
            node.walkable=false;
            tower.SetPlatform(this, node);

            //if the node has been check before during CheckForBlock(), just use the altPath
            if(node==nextBuildNode){
                for(int i=0; i<subPathList.Count; i++){
                    if(subPathList[i].IsNodeInPath(node)) subPathList[i].SwitchToSubPath();
                }
                return;
            }

            for(int i=0; i<subPathList.Count; i++){
                if(subPathList[i].IsNodeInPath(node)) subPathList[i].SearchNewPath(nodeGraph);
            }
        }

 public static void OnTowerUpgraded(UnitTower tower)
 {
     if (onTowerUpgradedE != null) onTowerUpgradedE(tower);
 }

 public static void OnTowerSold(UnitTower tower)
 {
     if (onTowerSoldE != null) onTowerSoldE(tower);
 }

		public UnitTower CreateSampleTower(UnitTower towerPrefab){
			GameObject towerObj=(GameObject)Instantiate(towerPrefab.gameObject);
			
			towerObj.transform.parent=transform;
			if(towerObj.GetComponent<Collider>()!=null) Destroy(towerObj.GetComponent<Collider>());
			Utility.DestroyColliderRecursively(towerObj.transform);
			towerObj.SetActive(false);
			
			UnitTower towerInstance=towerObj.GetComponent<UnitTower>();
			towerInstance.SetAsSampleTower(towerPrefab);
			
			return towerInstance;
		}

		public static void PreBuildTower(UnitTower tower){
			PlatformTD platform=null;
			LayerMask mask=1<<LayerManager.LayerPlatform();
			Collider[] cols=Physics.OverlapSphere(tower.thisT.position, _gridSize, mask);
			if(cols.Length>0) platform=cols[0].gameObject.GetComponent<PlatformTD>();
			
			if(platform!=null){
				Vector3 buildPos=GetTilePos(platform.thisT, tower.thisT.position);
				tower.thisT.position=buildPos;
				tower.thisT.rotation=platform.thisT.rotation;
			}
			else Debug.Log("no platform found for pre-placed tower");
			
			tower.InitTower(instance.towerCount+=1);
		}

		//called when a tower building is initated in DragNDrop, use the sample tower as the model and set it in DragNDrop mode
		public static string BuildTowerDragNDrop(UnitTower tower){ return instance._BuildTowerDragNDrop(tower); }

        public void _SelectTower(UnitTower tower)
        {
            _ClearSelectedTower();

            selectedTower=tower;

            float range=tower.GetRange();

            Transform indicatorT=rangeIndicator;

            if(indicatorT!=null){
                indicatorT.parent=tower.thisT;
                indicatorT.position=tower.thisT.position;
                indicatorT.localScale=new Vector3(2*range, 1, 2*range);

                indicatorT.gameObject.SetActive(true);
            }
        }

 public static void SelectTower(UnitTower tower)
 {
     instance._SelectTower(tower);
 }

		public static void Building(UnitTower tower){ instance.StartCoroutine(instance._Building(tower)); }

        public bool UpdatePathMaps(UnitTower tow, bool destroy = false)
        {
            int index_z = (int)Mathf.Round(tow.Platform.transform.position.z - platform_min_z) / 2;
              int index_x = (int)Mathf.Round(tow.Platform.transform.position.x - platform_min_x) / 2;

              if (index_z < 0)
            return true;

              beerMap[index_x, index_z + 1] = destroy;  // false -> new tower build there

              // Check if the last paths are still walkable
              // exit if true
              if (lastPathOne.Count >= 0 && lastPathTwo.Count >= 0)
              {
            bool lastPathOK = true;

            for (int i = 0; i < lastPathOne.Count; i++)
            {
              if (beerMap[lastPathOne[i].X, lastPathOne[i].Y] == false)
            lastPathOK = false;
            }

            for (int i = 0; i < lastPathTwo.Count; i++)
            {
              if (beerMap[lastPathTwo[i].X, lastPathTwo[i].Y] == false)
            lastPathOK = false;
            }

            if (lastPathOK)
              return true;
              }

              if (!GenerateGlobalPaths())
              {
            beerMap[index_x, index_z + 1] = !destroy;
            GenerateGlobalPaths();
            return false;
              }

              // TODO position of this SpawnManager functions ?
              // Here becazse GenerateGlobalPaths is called at startup
              // Waves not generated at that time
              for (int i = 0; i < SpawnManager.instance.waveList.Count; i++)
              {
            SpawnManager.instance.waveGenerator.UpdateWavePath(SpawnManager.instance.waveList[i]);
              }

              UnitCreep[] creeps = ObjectPoolManager.FindObjectsOfType<UnitCreep>();
              foreach (UnitCreep creep in creeps)
              {
            // Problem with creeps not in the maze -> between start and normal platforms
            // or between normal platforms and goal
            // No new Path, if creep is already past the last tower row
            if (creep.transform.position.z > platform_min_z)
            {
              int c_z;
              if (creep.transform.position.z > platform_max_z)
            c_z = 34;
              else
            c_z = Mathf.CeilToInt(creep.transform.position.z - platform_min_z) / 2; // Changed to CeilToInt and not round

              int c_x = (int)Mathf.Round(creep.transform.position.x - platform_min_x) / 2;
              parameters = new PathFindingParameters(new Point(c_x, c_z), pt_goal, beerMap, nodeMap);
              pf = new PathFinder(parameters);

              PathTD pt = pf.FindPathTD(creep.transform, "CreepCustomPath");

              creep.SetNewPath(pt);
            }
              }

              //Object[] towers = GameObject.FindObjectsOfType(typeof(UnitTower));

              //Object[] platforms = GameObject.FindObjectsOfType(typeof(PlatformTD));

              //Object[] paths = GameObject.FindObjectsOfType(typeof(PathTD));

              //SpawnManager.ChangeDefaultPath(paths[0] as PathTD);
              return true;
        }

		public static bool TowerUseShootObjectT(UnitTower tower){
			_TowerType type=tower.type;
			if(type==_TowerType.AOE || type==_TowerType.Mine) return true;
			return false;
		}

		public static bool TowerUseShootObject(UnitTower tower){
			_TowerType type=tower.type;
			if(type==_TowerType.Turret) return true;
			return false;
		}

		public static bool TowerTargetHostile(UnitTower tower){
			_TowerType type=tower.type;
			if(type==_TowerType.Turret || type==_TowerType.AOE || type==_TowerType.Mine) return true;
			return false;
		}

		IEnumerator _Building(UnitTower tower){
			Slider bar=GetUnusedBuildingBar();
			Transform barT=bar.transform;
			while(tower!=null && tower.IsInConstruction()){
				bar.value=tower.GetBuildProgress();
				
				if(mainCam==null){
					mainCam=Camera.main;
					continue;
				}
				
				Vector3 screenPos = mainCam.WorldToScreenPoint(tower.thisT.position+new Vector3(0, 0, 0));
				barT.localPosition=(screenPos+new Vector3(0, -20, 0))/UI.GetScaleFactor();
				bar.gameObject.SetActive(true);
				
				yield return null;
			}
			bar.gameObject.SetActive(false);
		}

        //called by any external component to build tower, uses buildInfo
        public static string BuildTower(UnitTower tower)
        {
            if (buildInfo == null) return "Select a Build Point First";

              UnitTower sampleTower = GetSampleTower(tower);

              /***/
              // check if there's energy reciving tower
              if (tower.electricityNeeded && !tower.electricityReciever && !tower.electricityFacility)
              {
            LayerMask maskTarget = 1 << LayerManager.LayerTower();

            Collider[] cols = Physics.OverlapSphere(buildInfo.position, 1000 /*GetRange()*/, maskTarget);

            if (cols.Length > 0)
            {
              tower.electicitySources.Clear();
              // find all electric facility
              for (int i = 0; i < cols.Length; i++)
              {
            // if it's not electric reciever skip
            if (!cols[i].gameObject.GetComponent<UnitTower>().electricityReciever)
              continue;

            //float test = cols[i].gameObject.GetComponent<UnitTower>().GetRange();
            //float test2 = Vector3.Distance(cols[i].gameObject.GetComponent<UnitTower>().transform.position, buildInfo.position);

            // if this tower is in range of electricityReciever
            if (Vector3.Distance(cols[i].gameObject.GetComponent<UnitTower>().transform.position, buildInfo.position) <= cols[i].gameObject.GetComponent<UnitTower>().GetRange())
            {
              tower.electicitySources.Add(cols[i].gameObject.GetComponent<UnitTower>());
            }
              }

              if (tower.electicitySources.Count == 0)
              {
            // set electricity source for tower weapon
            return "There is not enough electricity";
              }
            }
            else
              return "There is not enough electricity";
              }
              /***/

              //check if there are sufficient resource
              List<int> cost = sampleTower.GetCost();
              int suffCost = ResourceManager.HasSufficientResource(cost);
              if (suffCost == -1)
              {
            ResourceManager.SpendResource(cost);

            GameObject towerObj = (GameObject)Instantiate(tower.gameObject, buildInfo.position, buildInfo.platform.thisT.rotation);
            UnitTower towerInstance = towerObj.GetComponent<UnitTower>();
            towerInstance.InitTower(instance.towerCount += 1, buildInfo.platform);
            towerInstance.Build();

            // if new electricity reciver is placed search for all towers in it's range and add itself as electricity source
            if (tower.electricityReciever)
            {
              LayerMask maskTarget = 1 << LayerManager.LayerTower();

              Collider[] cols = Physics.OverlapSphere(buildInfo.position, tower.GetRange(), maskTarget);

              if (cols.Length > 0)
              {
            UnitTower tmp_tow;
            for (int i = 0; i < cols.Length; i++)
            {
              tmp_tow = cols[i].gameObject.GetComponent<UnitTower>();

              if (tmp_tow.electricityReciever || tmp_tow.electricityFacility)
                continue;

              tmp_tow.electicitySources.Add(towerInstance);
            }
              }
            }

            //clear the build info and indicator for build manager
            ClearBuildPoint();

            return "";
              }

              return "Insufficient Resource";
        }