//CHANGE SKILL LEVEL
public void skillLevelUp(GameObject _skill)
{
if (HeroController.mainHero.freeSkillPoints > 0)
{
string _sName = _skill.name;
A_Skill _s = skillTree.Find(x => x.skillName == _sName);
// skills are default level 1
if ((_s.skillLevel + 1 <= _s.skillMaxLevel) || (!_s.isLearned && _s.skillMaxLevel == 1))
{
string _availability = HeroSkillsController.getSkillAvailability(_s);
if (_availability.Equals("Available"))
{
HeroSkillsController.setSkillAsLearned(_s);
HeroSkillsController.getNewAvailableSKills(skillTree, _sName);
--HeroController.mainHero.freeSkillPoints;
visualValuesUpdated = false;
}
else if (_availability.Equals("Learned"))
{
++_s.skillLevel;
refreshSkill(_skill, _sName, _s);
--HeroController.mainHero.freeSkillPoints;
visualValuesUpdated = false;
}
}
}
}
private void loadPreviousLevel(A_Skill skill, SkillsLocalisationData skillLocalisation, SkillsData skillData)
{
//NOT TESTED
if (skill.skillLevel - 1 > 0)
{
Dictionary <string, string> systemMessages = LocalisationManager.systemMessagesLocalisationData.localisationValues["CharacterMenu"];
skillName.text = skillLocalisation.skillLocalisedName;
skillLevel.text = systemMessages["SkillLevel"] + Convert.ToString(skill.skillLevel - 1);
skillAvailability.text = SkillTreeController.getSkillAvailability(skill, LocalisationManager.systemMessagesLocalisationData.localisationValues["CharacterMenu"]);
skillAPcost.text = systemMessages["APCost"] + skillData.skillAPCost[skill.skillLevel] + " -> "
+ "<color=#FF0004>" + skillData.skillAPCost[skill.skillLevel - 1] + "</color>";
skillEneCost.text = systemMessages["EneCost"] + skillData.skillEneCost[skill.skillLevel] + " -> "
+ "<color=#FF0004>" + skillData.skillEneCost[skill.skillLevel - 1] + "</color>";
skillTargets.text = systemMessages["Targets"] +
skillLocalisation.skillTargetsDescription[skill.skillLevel - 1] + "->" + "<color=#FF0004>"
+ skillLocalisation.skillTargetsDescription[skill.skillLevel - 2] + "</color>";
skillDuration.text = systemMessages["Duration"]
+ SkillTreeController.getSkillDuration(skillData, skill.skillLevel, systemMessages)
+ " -> " + "<color=#FF0004>"
+ SkillTreeController.getSkillDuration(skillData, (short)(skill.skillLevel - 1), systemMessages)
+ "</color>";
skillGeneralDescription.text = systemMessages["SkillGeneralDescription"] + skillLocalisation.skillMainDescription;
skillLevelDescription.text = getLocalisedTextForNextLevel(skillLocalisation, skillData,
(short)(skill.skillLevel - 1), (short)(skill.skillLevel - 2), "<color=#FF0004>");
}
}
private void refreshSkill(GameObject _skill, string _sName, A_Skill _s)
{
Text t = _skill.GetComponentInChildren <Text>();
t.text = _s.skillLevel + "/" + _s.skillMaxLevel;
loadSkillData(_skill);
}
public void skillLevelDown(GameObject skillObject)
{
string skillName = skillObject.name;
A_Skill skill = skillTree.Find(x => x.skillName == skillName);
if (skill.skillLevel - 1 >= 0 && skill.isLearned == true)
{
if (skill.skillLevel - 1 >= 1)
{
--skill.skillLevel;
// skill init as level X
++HeroController.mainHero.freeSkillPoints;
skillToolTip.setToolTipGeneratedValue(false);
skillToolTip.generateToolTip(skill, "LoadPreviousLevel");
refreshSkillLevelText(skillObject, skillName, skill);
}
else if (skill.skillLevel - 1 == 0 && !skill.skillName.Equals("Rearm")) // Rearm is starting point for skills learning
{
HeroSkillsController.setSkillAsNotLearned(skill);
HeroSkillsController.cascadeSkillRemoval(skillTree, skill);
initializeSkills(skillTrees); // Need to refresh all skills
}
//cmController.getSkillPoints(); //display skillpoints
}
}
public void skillLevelUp(GameObject skillObject)
{
if (HeroController.mainHero.freeSkillPoints > 0)
{
string skillName = skillObject.name;
A_Skill skill = skillTree.Find(x => x.skillName == skillName);
// skills are default level 1
if ((skill.skillLevel + 1 <= skill.skillMaxLevel) || (!skill.isLearned && skill.skillMaxLevel == 1))
{
if (skill.isAvailableForLearning && !skill.isLearned)
{
// skill init as level 1
HeroSkillsController.setSkillAsLearned(skill);
HeroSkillsController.getNewAvailableSKills(skillTree, skillName);
--HeroController.mainHero.freeSkillPoints;
refreshSkillLevelText(skillObject, skillName, skill);
}
else if (skill.isLearned)
{
++skill.skillLevel;
// skill init as level X
refreshSkillLevelText(skillObject, skillName, skill);
--HeroController.mainHero.freeSkillPoints;
}
refreshSkillLevelText(skillObject, skillName, skill);
skillToolTip.setToolTipGeneratedValue(false);
skillToolTip.generateToolTip(skill, "LoadNextLevel");
// cmController.getSkillPoints(); //display skillpoints
}
}
}
//Update skillPoints UI value and skillAvailability UI value
private void updateTextValues(GameObject _skill)
{
heroSkillPoints.text = HeroController.mainHero.freeSkillPoints.ToString();
A_Skill skill = skillTree.Find(x => x.skillName.Equals(_skill.name));
skillAvailability.text = HeroSkillsController.getSkillAvailability(skill);
}
private void getLevelCount(Transform _skill)
{
string _sName = _skill.name;
A_Skill skill = skillTree.Find(x => x.skillName.Equals(_sName));
Text t = _skill.GetComponentInChildren <Text>();
if (t != null)
{
t.text = skill.skillLevel + "/" + skill.skillMaxLevel;
data.Find(x => x.skillName == _sName).skillCurentLevel = skill.skillLevel; // 0 is first level
}
}
private void refreshSkillLevelText(GameObject _skill, string _sName, A_Skill _s)
{
Text t = _skill.GetComponentInChildren <Text>();
if (_s.isLearned)
{
t.text = _s.skillLevel + "/" + _s.skillMaxLevel;
}
else
{
t.text = "0/" + _s.skillMaxLevel;
}
}
private void setSkillsLevels(Transform childSkill)
{
A_Skill skill = skillTree.Find(x => x.skillName.Equals(childSkill.name));
Text levelText = childSkill.GetComponentInChildren <Text>();
if (skill.isLearned)
{
levelText.text = skill.skillLevel + "/" + skill.skillMaxLevel;
}
else
{
levelText.text = "0/" + skill.skillMaxLevel;
}
}
private void loadCurrentLevel(A_Skill skill, SkillsLocalisationData skillLocalisation, SkillsData skillData)
{
Dictionary <string, string> systemMessages = LocalisationManager.systemMessagesLocalisationData.localisationValues["CharacterMenu"];
skillName.text = skillLocalisation.skillLocalisedName;
skillLevel.text = systemMessages["SkillLevel"] + skill.skillLevel.ToString(); // get actual level from game object
skillAvailability.text = SkillTreeController.getSkillAvailability(skill, LocalisationManager.systemMessagesLocalisationData.localisationValues["CharacterMenu"]);
skillAPcost.text = systemMessages["APCost"] + skillData.skillAPCost[skill.skillLevel];
skillEneCost.text = systemMessages["EneCost"] + skillData.skillEneCost[skill.skillLevel];
skillTargets.text = systemMessages["Targets"] + skillLocalisation.skillTargetsDescription[skill.skillLevel - 1];
skillDuration.text = systemMessages["Duration"] + SkillTreeController.getSkillDuration(skillData, skill.skillLevel, systemMessages);
skillGeneralDescription.text = systemMessages["SkillGeneralDescription"] + skillLocalisation.skillMainDescription;
skillLevelDescription.text = getLocalisedText(skillLocalisation, skillData, skill.skillLevel);
}
public void generateToolTip(A_Skill skill, string flag)
{
if (!toolTipGenerated)
{
SkillsLocalisationData skillLocalisation = skillsLocalisationData.Find(x => x.skillName.Equals(skill.skillName));
SkillsData skillData = skillsData.Find(x => x.skillName.Equals(skill.skillName));
bool isAllowedToGenerateToolTip = true;
switch (flag)
{
case "LoadCurrentLevel":
{
loadCurrentLevel(skill, skillLocalisation, skillData);
break;
}
case "LoadNextLevel":
{
if (skill.skillLevel < skill.skillMaxLevel)
{
loadNextLevel(skill, skillLocalisation, skillData);
}
else
{
isAllowedToGenerateToolTip = false;
}
break;
}
case "LoadPreviousLevel":
{
if (skill.skillLevel > 1)
{
loadPreviousLevel(skill, skillLocalisation, skillData);
}
else
{
isAllowedToGenerateToolTip = false;
}
break;
}
}
if (isAllowedToGenerateToolTip)
{
gameObject.SetActive(true);
toolTipGenerated = true;
}
}
}
public static string getSkillAvailability(A_Skill skill)
{
if (skill.isAvailableForLearning)
{
if (skill.isLearned)
{
return("Learned");
}
else
{
return("Available");
}
}
else
{
return("NotAvailable");
}
}
private void setUISkills(Transform childSkill)
{
A_Skill skill = skillTree.Find(x => x.skillName.Equals(childSkill.name));
Transform skillIcon = childSkill.transform.Find("Icon");
UISkill UIskill = skillIcon.GetComponent <UISkill>();
UIskill.skill = skill;
Transform skillNextLevel = childSkill.transform.Find("Plus");
UISkillNextLevel skillNext = skillNextLevel.GetComponent <UISkillNextLevel>();
skillNext.skill = skill;
Transform skillPreviousLevel = childSkill.transform.Find("Minus");
UISkillPreviousLevel skillPrevious = skillPreviousLevel.GetComponent <UISkillPreviousLevel>();
skillPrevious.skill = skill;
}
public static void cascadeSkillRemoval(List <A_Skill> skillTree, A_Skill skill)
{
skill.isLearned = false;
refundSkillPoints(HeroController.mainHero, skill);
skill.skillLevel = 1;
foreach (string _sToUnlock in skill.skillsToUnlock)
{
if (!_sToUnlock.Equals(""))
{
A_Skill nextSkill = skillTree.Find(x => x.skillName.Equals(_sToUnlock));
if (nextSkill.isLearned)
{
cascadeSkillRemoval(skillTree, nextSkill);
}
if (nextSkill.isAvailableForLearning)
{
nextSkill.isAvailableForLearning = false;
}
}
}
}
public static string getSkillAvailability(A_Skill skill, Dictionary <string, string> systemMessages)
{
if (skill.isAvailableForLearning)
{
if (skill.isLearned)
{
return("<color=#20B51B>" + systemMessages["SkillLearned"] + "</color>");
}
else if (HeroController.mainHero.freeSkillPoints > 0)
{
return("<color=#FFFF00>" + systemMessages["SkillAvailable"] + "</color>");
}
else
{
return("<color=#FFB600>" + systemMessages["SkillAvailableButNoSkillPoints"] + "</color>");
}
}
else
{
return("<color=#FF0004>" + systemMessages["SkillIsNotAvailable"] + "</color>");
}
}
public void skillLevelDown(GameObject _skill)
{
string _sName = _skill.name;
A_Skill _s = skillTree.Find(x => x.skillName == _sName);
if (_s.skillLevel - 1 >= 0 && _s.isLearned == true)
{
if (_s.skillLevel - 1 >= 1)
{
--_s.skillLevel;
refreshSkill(_skill, _sName, _s);
++HeroController.mainHero.freeSkillPoints;
visualValuesUpdated = false;
}
else if (_s.skillLevel - 1 == 0 && !_s.skillName.Equals("Rearm")) // Rearm is starting point for skills learning
{
HeroSkillsController.setSkillAsNotLearned(_s);
HeroSkillsController.cascadeSkillRemoval(skillTree, _s);
loadSkillLevels(skillTreeParent); // Need to refresh all skills
visualValuesUpdated = false;
}
}
}
private static void refundSkillPoints(C_Hero hero, A_Skill skill)
{
hero.freeSkillPoints += skill.skillLevel;
}
public static void setSkillAsLearned(A_Skill skill)
{
skill.isLearned = true;
}
public static void setSkillAsNotLearned(A_Skill skill)
{
skill.isLearned = false;
}
