public Tower PrepareNewTower(Tower.Type type)
{
Tower tower = null;
List <Object> towerTemplates;
bool found = m_TowerTemplates.TryGetValue(type, out towerTemplates);
Assert.IsTrue(found);
if (found)
{
tower = new Tower();
tower.Init();
foreach (GameObject towerObject in towerTemplates)
{
TowerLevel newLevel = towerObject.GetComponent <TowerLevel>();
tower.AddLevel(newLevel);
}
tower.PrepareToPlace();
}
return(tower);
}
/// <summary>
/// Define the button information for the tower
/// </summary>
/// <param name="towerData">
/// The tower to initialize the button with
/// </param>
public void InitializeButton(Tower towerData)
{
m_Tower = towerData;
if (towerData.levels.Length > 0)
{
TowerLevel firstTower = towerData.levels[0];
buttonText.text = firstTower.cost.ToString();
towerIcon.sprite = firstTower.levelData.icon;
}
else
{
Debug.LogWarning("[Tower Spawn Button] No level data for tower");
}
if (LevelManager.instanceExists)
{
m_Currency = LevelManager.instance.currency;
m_Currency.currencyChanged += UpdateButton;
}
else
{
Debug.LogWarning("[Tower Spawn Button] No level manager to get currency object");
}
UpdateButton();
}
/// <summary>
/// Define the button information for the tower
/// </summary>
/// <param name="towerData">
/// The tower to initialize the button with
/// </param>
public void InitializeButton(Tower towerData)
{
m_Tower = towerData;
if (towerData.levels.Length > 0)
{
TowerLevel firstTower = towerData.levels[0];
buttonText.text = firstTower.cost.ToString();
towerIcon.sprite = firstTower.levelData.icon;
}
else
{
Debug.LogWarning("[Tower Spawn Button] No level data for tower");
}
if (PlayerStats.instanceExists)
{
playerStats = PlayerStats.Instance;
playerStats.goldChanged += UpdateButton;
}
else
{
Debug.LogWarning("[Tower Spawn Button] No game manager to get gold change event ");
}
UpdateButton();
}
void MovingTurret()
{
TowerLevel selectedTurret = currentTurret.GetComponent <TowerLevel>();
Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
if (Input.GetMouseButtonDown(1))
{
RaycastHit hit;
if (Physics.Raycast(ray, out hit))
{
//Assign destination
//Vector3 targetedPosition = new Vector3(hit.transform.position.x, hit.transform.position.y + 1, hit.transform.position.z);
Vector3 targetedPosition = hit.point;
selectedTurret.agent.SetDestination(targetedPosition);
//goto fix;
currentTurret.GetComponent <TowerUI>().isSelected = false; //This 2 lines
currentTurret.GetComponent <TowerUI>().DeductMoney();
if (currentTurret != null)
{
currentTurret.transform.GetComponent <BoxCollider>().enabled = true;
currentTurret.GetComponent <TowerUI>().isSelected = false;
currentTurret.GetComponent <TowerLevel>().isClickedOn = false;
currentTurret = null;
isClick = false;
isTeleporting = false;
}
}
}
/*
* fix:
* //Fix shit up
* if (Time.timeScale >= 1.0f && selectedTurret.agent.hasPath)
* {
* NavMeshHit navhit;
* float maxAgentTravelDistance = Time.deltaTime * selectedTurret.agent.speed;
*
* //If at the end of path, stop agent.
* if (
* selectedTurret.agent.SamplePathPosition(NavMesh.AllAreas, maxAgentTravelDistance, out navhit) ||
* selectedTurret.agent.remainingDistance <= selectedTurret.agent.stoppingDistance
* )
* {
* //Stop agent
* selectedTurret.agent.updatePosition = true;
* selectedTurret.transform.position = selectedTurret.agent.nextPosition;
* }
* //Else, move the actor and manually update the agent pos
* else
* {
* selectedTurret.agent.updatePosition = false;
* selectedTurret.transform.position = new Vector3(navhit.position.x, navhit.position.y, navhit.position.z);
* selectedTurret.agent.nextPosition = selectedTurret.transform.position; //Set simulated agent to the gameObject's position
* Debug.Log("Agent is moving");
* }
* }
*/
}
void OnEnable()
{
for (int i = 0; i < levels.Count; i++)
{
levels[i].visualization.SetActive(false);
}
CurrentLevel = levels[0];
}
public void PrepareToPlace()
{
m_CurrentLevel = CreateTowerLevel();
if (m_CurrentLevel)
{
m_CurrentLevel.GetComponent <CapsuleCollider>().enabled = false;
}
}
public void Destroy()
{
if (m_CurrentLevel)
{
GameObject.Destroy(m_CurrentLevel.gameObject);
m_CurrentLevel = null;
}
}
public void increaseLevel()
{
int currentLevelIndex = levels.IndexOf(currentLevel);
if (currentLevelIndex < levels.Count - 1)
{
CurrentLevel = levels[currentLevelIndex + 1];
}
}
public void increaseLevel()
{
int currentLevelIndex = levels.IndexOf(currentLevel);
if (currentLevelIndex < levels.Count - 1)
{
CurrentLevel = levels[currentLevelIndex + 1];
}
}
public void IncreaseLevel()
{
int currentIndex = TowerLevel.IndexOf(CurrentLevel);
if (currentIndex < TowerLevel.Count - 1)
{
CurrentLevel = TowerLevel[currentIndex + 1];
SetTowerLevel(CurrentLevel);
}
}
public bool canUpgradeMonster()
{
TowerLevel nextLevel = getNextLevel();
if (nextLevel != null && nextLevel.cost <= gameManager.Gold)
{
return(true);
}
return(false);
}
private bool canUpgradeTower() //procedimento que vai informar se pode evoluir um monstro;
{
if (tower != null) //se o local tiver algum monstro
{
TowerData td = tower.GetComponent <TowerData> (); //cria uma variavel do tipo dados de monstro, que vai receber o monstro que estiver no slot
TowerLevel nextLevel = td.getNextLevel(); //cria uma variavel do tipo de level do monstro, que vai execultar o procedimento de pegar o level atual
if (nextLevel != null) //se existir um proximo level
{
return(gameManager.Tropas >= nextLevel.tropas); //vai retornar verdadeiro se o dinheiro atual for maior que o custo de evoluir para o proximo level.
}
}
return(false); //retorna falso, informando que não pode evoluir.
}
private int WeightRecurse(TowerLevel level, HashSet <TowerLevel> allChildren = null)
{
allChildren = allChildren ?? new HashSet <TowerLevel>();
allChildren.Add(level);
foreach (var levelChild in level.Children)
{
WeightRecurse(levelChild, allChildren);
}
return(allChildren.Sum(c => c.Weight));
}
public void increaseLevel() //procedimento que vai aumentar o level do monstro
{
int currentLevelIndex = levels.IndexOf(currentLevel); //variavel do tipo inteiro que vai receber o indice do level atual do monstro
if (currentLevelIndex < levels.Count - 1) //se o indice do level atual for menor que a quantidade de levels - 1
{
CurrentLevel = levels[currentLevelIndex + 1]; //o level atual do monstro é aumentado de acordo com o valor que estiver na lista com indice + 1
if (raio != null) //se o raio não for nulo
{
raio.radius = CurrentLevel.campoVisao; //aumenta o valor do raio do CircleCollider2D de acordo com o valor do campo de visão da torre
}
}
}
private bool canUpgradeTower()
{
if (tower != null)
{
TowerData towerData = tower.GetComponent <TowerData>();
TowerLevel nextLevel = towerData.getNextLevel();
if (nextLevel != null)
{
return(true);
}
}
return(false);
}
public int getSellPrice()
{
int index = 0;
TowerLevel tl = levels[index];
int cost = tl.cost;
while (CurrentLevel != tl)
{
tl = levels[index];
cost += tl.cost;
}
return(cost / 2);
}
public bool CanUpgradeTower()
{
if (_tower != null)
{
TowerData towerData = _tower.GetComponent <TowerData>();
TowerLevel nextLevel = towerData.getNextLevel();
if (nextLevel != null)
{
int cost = nextLevel.cost;
return(_gameManager.Gold >= cost);
}
}
return(false);
}
private bool canUpgradeTower()
{
if (selectedGO != null)
{
TowerData towerData = selectedGO.GetComponent <TowerData> ();
TowerLevel nextLevel = towerData.GetNextLevel();
if (nextLevel != null)
{
return(gameManager.Gold >= nextLevel.cost);
}
}
return(false);
}
public void Upgrade()
{
if ((level + 1 <= maxLevel))
{
TowerLevel data = levelData[level - 1];
level++;
Range.AddModifer(data.RangeIncrease);
Damage.AddModifer(data.DamageIncrease);
FireRate.AddModifer(data.FireRateIncrease);
hasPickedPerk = false;
OnTowerChanged();
UpdateSelectionCircleRadius();
}
}
public int getSellPrice()
{
int index = 0;
int currentLevelIndex = levels.IndexOf(currentLevel);
TowerLevel tl = levels[index];
int cost = tl.cost;
while (index != currentLevelIndex)
{
tl = levels[index];
cost += tl.cost;
index++;
}
return(cost / 2);
}
public void UpgradeOneLevel()
{
if (currentLevel < levels.Length - 1 && currentLevel >= 0)
{
currentLevel++;
if (currentTowerLevel)
{
Destroy(currentTowerLevel.gameObject);
}
currentTowerLevel = Instantiate(levels[currentLevel], transform);
currentTowerLevel.SetValues();
}
}
public void Upgrade()
{
if (CanUpgrade())
{
if (m_CurrentLevel != null)
{
GameObject.Destroy(m_CurrentLevel.gameObject);
}
++m_CurrentLevelIndex;
m_CurrentLevel = CreateTowerLevel();
m_CurrentLevel.SetPosition(m_Position);
Construct();
}
}
private bool CanUpgrade()
{
if (tower == null)
{
return(false);
}
TowerData data = tower.GetComponent <TowerData>();
TowerLevel next = data.GetNextLevel();
if (next == null)
{
return(false);
}
return(true);
}
public void BuildTower()
{
BuildPlace buildPlace = GetComponentInParent <BuildPlace>();
Transform towerInst = Instantiate(tower.transform, buildPlace.ownTransform.position, tower.transform.rotation);
towerInst.parent = buildPlace.ownTransform.parent;
Tower newTower = towerInst.GetComponent <Tower>();
newTower.buildPlace = buildPlace;
buildPlace.gameObject.SetActive(false);
TowerLevel towerData = newTower.towerData;
int price = towerData.price;
newTower.priceToReturn = price;
levelManager.AddGold(price * (-1));
levelManager.SelectedObject = null;
}
private bool canUpgradeWizardTower()
{
if (wizard_tower != null)
{
TowerData towerData = wizard_tower.GetComponent <TowerData>();
TowerLevel nextLevel = towerData.getNextLevel();
if (nextLevel != null)
{
if (wizard_tower.GetComponent <TowerData>().levels.IndexOf(nextLevel) == 1 && gm.cash >= 90)
{
return(true);
}
else if (wizard_tower.GetComponent <TowerData>().levels.IndexOf(nextLevel) == 2 && gm.cash >= 150)
{
return(true);
}
}
}
return(false);
}
private bool canUpgradeSplashTower()
{
if (splash_tower != null)
{
TowerData towerData = splash_tower.GetComponent <TowerData>();
TowerLevel nextLevel = towerData.getNextLevel();
if (nextLevel != null)
{
if (splash_tower.GetComponent <TowerData>().levels.IndexOf(nextLevel) == 1 && gm.cash >= 100)
{
return(true);
}
else if (splash_tower.GetComponent <TowerData>().levels.IndexOf(nextLevel) == 2 && gm.cash >= 170)
{
return(true);
}
}
}
return(false);
}
void TowerInfoList()
{
string towerName = selectedGO.gameObject.name;
TowerData towerData = selectedGO.GetComponent <TowerData> ();
TowerLevel nextLevel = towerData.GetNextLevel();
switch (towerName)
{
case "ArtemisTower(Clone)":
textInfo.GetComponent <Text>().text = selectedGO.gameObject.GetComponent <TowerData>().CurrentLevel.visualization.gameObject.name
+ "\nDamage: " + selectedGO.GetComponent <TowerData>().damageDeal + "\nAttack Speed: " + selectedGO.GetComponent <TowerData>().attackSpeed *100
+ "\nUpgrade Cost: " + nextLevel.cost;
break;
case "ZuesTower(Clone)":
textInfo.GetComponent <Text>().text = selectedGO.gameObject.GetComponent <TowerData>().CurrentLevel.visualization.gameObject.name
+ "\nDamage: " + selectedGO.GetComponent <TowerData>().damageDeal + "\nAttack Speed: " + selectedGO.GetComponent <TowerData>().attackSpeed *100
+ "\nUpgrade Cost: " + nextLevel.cost;
break;
case "ChioneTower(Clone)":
textInfo.GetComponent <Text>().text = selectedGO.gameObject.GetComponent <TowerData>().CurrentLevel.visualization.gameObject.name
+ "\nDamage: " + selectedGO.GetComponent <TowerData>().damageDeal + "\nAttack Speed: " + selectedGO.GetComponent <TowerData>().attackSpeed *100
+ "\nSPD Reduce: " + selectedGO.GetComponent <TowerData>().slowSpeed *100 + "%\nBurn: " + selectedGO.GetComponent <TowerData>().burnDamage
+ "\nUpgrade Cost: " + nextLevel.cost;
break;
case "HeliosTower(Clone)":
textInfo.GetComponent <Text>().text = selectedGO.gameObject.GetComponent <TowerData>().CurrentLevel.visualization.gameObject.name
+ "\nDamage: " + selectedGO.GetComponent <TowerData>().damageDeal + "\nAttack Speed: " + selectedGO.GetComponent <TowerData>().attackSpeed *100
+ "\nBurn: " + selectedGO.GetComponent <TowerData>().burnDamage + "/Second"
+ "\nUpgrade Cost: " + nextLevel.cost;
break;
case "PlutusTower(Clone)":
textInfo.GetComponent <Text>().text = selectedGO.gameObject.GetComponent <TowerData>().CurrentLevel.visualization.gameObject.name
+ "\nCoin Rate: " + selectedGO.gameObject.GetComponent <TowerData>().coinRate;
break;
}
}
public void SetTowerLevel(TowerLevel towerLevel)
{
CurrentLevel = towerLevel;
int currentIndex = TowerLevel.IndexOf(CurrentLevel);
GameObject tower = TowerLevel[currentIndex].Tower;
for (int i = 0; i < TowerLevel.Count; i++)
{
if (tower != null)
{
if (i == currentIndex)
{
TowerLevel[i].Tower.SetActive(true);
}
else
{
TowerLevel[i].Tower.SetActive(false);
}
}
}
}
/// <summary>
/// Draws the tower data on to the canvas,
/// if the relevant text components are populated
/// </summary>
/// <param name="tower">The tower to gain info from</param>
/// <param name="levelOfTower">The level of the tower</param>
public void Show(Tower tower, int levelOfTower)
{
if (levelOfTower >= tower.levels.Length)
{
return;
}
TowerLevel towerLevel = tower.levels[levelOfTower];
DisplayText(towerName, tower.towerName);
DisplayText(description, towerLevel.description);
//DisplayText(dps, towerLevel.GetTowerDps().ToString("f2"));
//DisplayText(health, string.Format("{0}/{1}", tower.configuration.currentHealth, towerLevel.maxHealth));
//DisplayText(level, (levelOfTower + 1).ToString());
//DisplayText(dimensions, string.Format("{0}, {1}", tower.dimensions.x, tower.dimensions.y));
//if (levelOfTower + 1 < tower.levels.Length)
//{
// DisplayText(upgradeCost, tower.levels[levelOfTower + 1].cost.ToString());
//}
//int sellValue = tower.GetSellLevel(levelOfTower);
//DisplayText(sellPrice, sellValue.ToString());
}
void CheckGoldChange()
{
if (tower == null)
{
return;
}
TowerLevel towerData = tower.towerData;
int price = towerData.price;
string decodingGold = B64X.Decode(levelManager.currentGold);
int existsGold = int.Parse(decodingGold);
if (price > existsGold && button.interactable)
{
button.interactable = false;
}
else if (price <= existsGold && !button.interactable)
{
button.interactable = true;
}
currentGold = levelManager.currentGold;
}
private static List <TowerLevel> CompileTowerLevels(string input)
{
var levelDatas = input.SplitOnNewLine();
var towerLevels = new List <TowerLevel>();
foreach (var levelData in levelDatas)
{
var dataParts = levelData.SplitOn("->").ToList();
var pieceData = dataParts[0].SplitOnWhitespace().ToList();
var name = pieceData[0];
var weight = int.Parse(pieceData[1].RemoveInstancesOf("(", ")"));
var towerLevel = new TowerLevel()
{
Name = name,
Weight = weight,
};
if (dataParts.Count == 2)
{
towerLevel.ChildrenNames = dataParts[1].SplitOn(",").ToList().TrimAll();
}
towerLevels.Add(towerLevel);
}
foreach (var towerLevel in towerLevels)
{
towerLevel.Children = towerLevels.Where(l => towerLevel.ChildrenNames.Contains(l.Name)).ToList();
foreach (var towerLevelChild in towerLevel.Children)
{
towerLevelChild.Parent = towerLevel;
}
}
return(towerLevels);
}
public void UpdateTower()
{
if(Settings.Instance.sound){
AudioSource.PlayClipAtPoint(upgradeSound,Camera.main.transform.position,1.0f);
}
if(m_towerType==TowerType.ElecTower){
UpdateElecTower();
}else{
switch (m_level) {
case TowerLevel.Low:
m_levelArray=level2;
m_level=TowerLevel.Mid;
m_power=powerMid;
m_attackArea=attackAreaMid;
m_attackTime=attackTimeMid;
m_cost+=costMid;
GameManager.Instance.SetPoint (-costMid);
break;
case TowerLevel.Mid:
m_levelArray=level3;
m_level=TowerLevel.High;
m_power=powerHigh;
m_attackArea=attackAreaHigh;
m_attackTime=attackTimeHigh;
m_cost+=costHigh;
GameManager.Instance.SetPoint (-costHigh);
break;
case TowerLevel.High:
m_levelArray=level4;
m_level=TowerLevel.Super;
m_power=powerSuper;
m_attackArea=attackAreaSuper;
m_attackTime=attackTimeSuper;
m_cost+=costSuper;
GameManager.Instance.SetPoint (-costSuper);
break;
case TowerLevel.Super:
break;
}
if (index == spriteNum) {
index=0;
}
//Debug.Log (index);
spriteRenderer.sprite=m_levelArray[index];
attackArea.localScale = new Vector3 (m_attackArea,m_attackArea,0);
}
}
// Use this for initialization
void Start()
{
anim = gameObject.GetComponent<Animator> ();
trans=this.transform.FindChild("attack");
spriteRenderer = this.gameObject.GetComponent<SpriteRenderer> ();
towerbutton=this.transform.FindChild("towerbutton");
upgrade=towerbutton.FindChild("upgrade");
attackArea = this.transform.FindChild ("attackArea");
//get the lable text
lable=upgrade.FindChild("lable");
lableController=lable.gameObject.GetComponent<UpgradeLableController>();
//set the gridnode as CanNotStand
float newX=(this.transform.position.x+(bgController.Instance.rate-1.0f)*6.66f) / bgController.Instance.rate;
int inewX=(int)(newX*10.0f+0.5f)/10;
GridMap.Instance.m_map [inewX, (int)this.transform.position.y].fieldtype = MapData.FieldTypeID.CanNotStand;
//set init values
m_levelArray = level1;
m_level = TowerLevel.Low;
m_power = powerLow;
m_attackArea = attackAreaLow;
attackArea.localScale = new Vector3 (m_attackArea,m_attackArea,0);
m_attackTime = attackTimeLow;
m_cost = costLow;
//set the timer as 0
m_timer = 0f;
}
//Called in UpdateTower()
void UpdateElecTower()
{
switch (m_level) {
case TowerLevel.Low:
m_level=TowerLevel.Mid;
m_power=powerMid;
m_attackArea=attackAreaMid;
m_attackTime=attackTimeMid;
m_cost+=costMid;
GameManager.Instance.SetPoint (-costMid);
break;
case TowerLevel.Mid:
m_level=TowerLevel.High;
m_power=powerHigh;
m_attackArea=attackAreaHigh;
m_attackTime=attackTimeHigh;
m_cost+=costMid;
GameManager.Instance.SetPoint (-costHigh);
break;
case TowerLevel.High:
m_level=TowerLevel.Super;
m_power=powerSuper;
m_attackArea=attackAreaSuper;
m_attackTime=attackTimeSuper;
m_cost+=costSuper;
GameManager.Instance.SetPoint (-costSuper);
break;
case TowerLevel.Super:
break;
}
anim.SetTrigger("upgrade");
attackArea.localScale = new Vector3 (m_attackArea,m_attackArea,0);
}
void OnEnable()
{
CurrentLevel = levels[0];
}
