public static SkillTree ParseSkillTree(string filepath) {
SkillTree tree = new SkillTree();
SkillTreeJob job = null;
SkillTreeJobSkill skill = null;
using (XmlReader xml = XmlReader.Create(filepath)) {
while (xml.Read() == true) {
if (xml.NodeType != XmlNodeType.Element) {
continue;
}
string name = xml.Name;
if (name == "Job") {
if (job != null) {
if (skill != null) {
job.Add(skill.ID, skill);
skill = null;
}
tree.Add(job.ID, job);
job = null;
}
job = new SkillTreeJob {
ID = int.Parse(xml.GetAttribute("ID"))
};
} else if (name == "Skill") {
if (skill != null) {
job.Add(skill.ID, skill);
skill = null;
}
skill = new SkillTreeJobSkill {
ID = int.Parse(xml.GetAttribute("ID")),
MaxLevel = int.Parse(xml.GetAttribute("Max")),
JobLevel = int.Parse(xml.GetAttribute("MinLv"))
};
} else if (name == "Require") {
SkillTreeJobSkillRequirement r = new SkillTreeJobSkillRequirement {
ID = int.Parse(xml.GetAttribute("ID")),
Level = int.Parse(xml.GetAttribute("Level"))
};
skill.Add(r.ID, r);
}
} // while
// Add last skill to last job
if (job != null && skill != null) {
job.Add(skill.ID, skill);
}
// Add last job to tree
if (job != null) {
tree.Add(job.ID, job);
}
} // using
return tree;
}
//AudioSource audio;
void Start()
{
player = GameObject.FindWithTag ("Player");
skill = player.GetComponent<SkillTree >();
Destroy(gameObject, 2f);
}
void Start()
{
player = this.gameObject;
stat = player.GetComponent<StatCollectionClass >();
skill = player.GetComponent<SkillTree >();
quest = player.GetComponent<All_Quests> ();
item = player.GetComponent<ItemGUI>();
}
void Start()
{
player = this.gameObject;
stat = player.GetComponent<StatCollectionClass >();
skill = player.GetComponent<SkillTree >();
quest = player.GetComponent<All_Quests> ();
ps = player.GetComponent<PlayerStateGUI>();
up = player.GetComponent<ItemUpgrade> ();
}
/// <summary>
/// Constructs a new SettingsViewModel that operates on the given skill tree.
/// </summary>
/// <param name="tree">The skill tree to operate on. (not null)</param>
/// <param name="dialogCoordinator"></param>
public SettingsViewModel(SkillTree tree, ISettingsDialogCoordinator dialogCoordinator)
{
Tree = tree;
_dialogCoordinator = dialogCoordinator;
SelectedTabIndex = new LeafSetting <int>(nameof(SelectedTabIndex), 0);
Action <GeneratorTabViewModel> runCallback = async g => await RunAsync(g);
Tabs = new ObservableCollection <GeneratorTabViewModel>
{
new SteinerTabViewModel(Tree, _dialogCoordinator, this, runCallback),
new AdvancedTabViewModel(Tree, _dialogCoordinator, this, runCallback),
new AutomatedTabViewModel(Tree, _dialogCoordinator, this, runCallback)
};
SubSettings = new ISetting[] { SelectedTabIndex }.Union(Tabs).ToArray();
}
public static SkillTree CreateSupportTree()
{
SkillTree tree = new SkillTree();
tree.levelList[0].skillList.Add(SkillData.instance.universalSkillList[Commands.FirstAid]);
tree.levelList[1].skillList.Add(SkillData.instance.universalSkillList[Commands.Medicine]);
tree.levelList[1].skillList.Add(SkillData.instance.universalSkillList[Commands.Revive]);
tree.levelList[2].skillList.Add(SkillData.instance.universalSkillList[Commands.AccuracyBuff]);
tree.levelList[2].skillList.Add(SkillData.instance.universalSkillList[Commands.DefenceBuff]);
tree.levelList[3].skillList.Add(SkillData.instance.universalSkillList[Commands.AllyActionBoost]);
tree.levelList[3].skillList.Add(SkillData.instance.universalSkillList[Commands.Motivate]);
tree.levelList[4].skillList.Add(SkillData.instance.universalSkillList[Commands.HealArea]);
tree.levelList[4].skillList.Add(SkillData.instance.universalSkillList[Commands.AbsorbShield]);
tree.levelList[5].skillList.Add(SkillData.instance.universalSkillList[Commands.Distraction]);
tree.levelList[5].skillList.Add(SkillData.instance.universalSkillList[Commands.GroupBuff]);
return(tree);
}
public static SkillTree CreateDefenseTree()
{
SkillTree tree = new SkillTree();
tree.levelList[0].skillList.Add(SkillData.instance.universalSkillList[Commands.Defend]);
tree.levelList[1].skillList.Add(SkillData.instance.universalSkillList[Commands.Counter]);
tree.levelList[1].skillList.Add(SkillData.instance.universalSkillList[Commands.Recover]);
tree.levelList[2].skillList.Add(SkillData.instance.universalSkillList[Commands.Push]);
tree.levelList[2].skillList.Add(SkillData.instance.universalSkillList[Commands.Taunt]);
tree.levelList[3].skillList.Add(SkillData.instance.universalSkillList[Commands.Stun]);
tree.levelList[3].skillList.Add(SkillData.instance.universalSkillList[Commands.ShieldAlly]);
tree.levelList[4].skillList.Add(SkillData.instance.universalSkillList[Commands.SmokeBomb]);
tree.levelList[4].skillList.Add(SkillData.instance.universalSkillList[Commands.NapalmBarricade]);
tree.levelList[5].skillList.Add(SkillData.instance.universalSkillList[Commands.NuclearBlood]);
tree.levelList[5].skillList.Add(SkillData.instance.universalSkillList[Commands.Angst]);
return(tree);
}
public static SkillTree CreateOffenseTree()
{
SkillTree tree = new SkillTree();
tree.levelList[0].skillList.Add(SkillData.instance.universalSkillList[Commands.AllOrNothing]);
tree.levelList[1].skillList.Add(SkillData.instance.universalSkillList[Commands.SureHit]);
tree.levelList[1].skillList.Add(SkillData.instance.universalSkillList[Commands.AllAroundAttack]);
tree.levelList[2].skillList.Add(SkillData.instance.universalSkillList[Commands.Storm]);
tree.levelList[2].skillList.Add(SkillData.instance.universalSkillList[Commands.Grenade]);
tree.levelList[3].skillList.Add(SkillData.instance.universalSkillList[Commands.FinishingAttack]);
tree.levelList[3].skillList.Add(SkillData.instance.universalSkillList[Commands.AimedAttack]);
tree.levelList[4].skillList.Add(SkillData.instance.universalSkillList[Commands.BattleShout]);
tree.levelList[4].skillList.Add(SkillData.instance.universalSkillList[Commands.TripleAttack]);
tree.levelList[5].skillList.Add(SkillData.instance.universalSkillList[Commands.ActionBoost]);
tree.levelList[5].skillList.Add(SkillData.instance.universalSkillList[Commands.Lifesteal]);
return(tree);
}
public void PersistSkillTree()
{
ResponseCache.Clear();
SkillTree skillTree = EveApi.GetSkillTree();
ResponseCache.Save("ResponseCache.xml");
ResponseCache.Clear();
ResponseCache.Load("ResponseCache.xml");
SkillTree cached = EveApi.GetSkillTree();
Assert.AreEqual(skillTree.CachedUntilLocal, cached.CachedUntilLocal);
// Skill Groups
for (int i = 0; i < skillTree.SkillGroups.Length; i++)
{
Assert.AreEqual(skillTree.SkillGroups[i].GroupName, cached.SkillGroups[i].GroupName);
Assert.AreEqual(skillTree.SkillGroups[i].GroupId, cached.SkillGroups[i].GroupId);
}
// Skills
for (int i = 0; i < skillTree.Skills.Length; i++)
{
SkillTree.Skill skill = skillTree.Skills[i];
SkillTree.Skill cskill = cached.Skills[i];
Assert.AreEqual(skill.TypeName, cskill.TypeName);
Assert.AreEqual(skill.GroupId, cskill.GroupId);
Assert.AreEqual(skill.TypeId, cskill.TypeId);
Assert.AreEqual(skill.Description, cskill.Description);
Assert.AreEqual(skill.Rank, cskill.Rank);
Assert.AreEqual(skill.PrimaryAttribute, cskill.PrimaryAttribute);
Assert.AreEqual(skill.SecondaryAttribute, cskill.SecondaryAttribute);
for (int j = 0; j < skill.RequiredSkills.Length; j++)
{
Assert.AreEqual(skill.RequiredSkills[j].TypeId, cskill.RequiredSkills[j].TypeId);
Assert.AreEqual(skill.RequiredSkills[j].SkillLevel, cskill.RequiredSkills[j].SkillLevel);
}
for (int j = 0; j < skill.SkillBonuses.Length; j++)
{
Assert.AreEqual(skill.SkillBonuses[j].BonusType, cskill.SkillBonuses[j].BonusType);
Assert.AreEqual(skill.SkillBonuses[j].BonusType, cskill.SkillBonuses[j].BonusType);
}
}
}
public OptimizerControllerWindow(SkillTree tree, HashSet <ushort> targetNodes, HashSet <ushort> nodesToOmit = null)
{
InitializeComponent();
this.tree = tree;
steinerSolver = new SteinerSolver(tree);
this.targetNodes = targetNodes;
this.nodesToOmit = nodesToOmit;
initializationWorker.DoWork += initializationWorker_DoWork;
initializationWorker.RunWorkerCompleted += initializationWorker_RunWorkerCompleted;
solutionWorker.DoWork += solutionWorker_DoWork;
solutionWorker.ProgressChanged += solutionWorker_ProgressChanged;
solutionWorker.RunWorkerCompleted += solutionWorker_RunWorkerCompleted;
solutionWorker.WorkerReportsProgress = true;
solutionWorker.WorkerSupportsCancellation = true;
}
// Start is called before the first frame update
void Start()
{
anim.SetBool("isDying", false);
stats = (Stats)GameObject.Find("Stats").GetComponent("Stats");
skillTree = (SkillTree)GameObject.Find("SkillTree").GetComponent("SkillTree");
rb = GetComponent <Rigidbody>();
initialPosition = transform.position;
minPosition = new Vector3(initialPosition.x - maxMovementRange, initialPosition.y, initialPosition.z);
maxPosition = new Vector3(initialPosition.x + maxMovementRange, initialPosition.y, initialPosition.z);
damageController = this.GetComponent <DamageController>();
targetPlayer = GameObject.FindGameObjectWithTag("Player").GetComponent <Transform>();
InvokeRepeating(nameof(EnableAttack), 0f, 3f);
if (summonedUnit && summoner != null)
{
summoner.enemiesAlive += summonValor;
}
}
public SkillTree GetSkillTree(string skillTreeName)
{
SkillTree foundSkillTree = null;
int index = 0;
do
{
SkillTree temp = m_skillTrees[index];
if (temp.GetSkillTreeName() == skillTreeName)
{
foundSkillTree = temp;
}
++index;
} while (foundSkillTree == null && index < m_skillTrees.Count - 1);
return(foundSkillTree);
}
/// <summary>
/// LoadContent will be called once per game and is the place to load
/// all of your content.
/// </summary>
protected override void LoadContent()
{
// Create a new SpriteBatch, which can be used to draw textures.
spriteBatch = new SpriteBatch(GraphicsDevice);
//RenderTarget2D target = new RenderTarget2D(GraphicsDevice, 1024, 576);
//GraphicsDevice.SetRenderTarget(target);
Text.loadContent(Content);
Button.LoadContent(Content);
MainMenu.loadContent(Content);
MenuBoss.LoadContent(Content);
//UpgradeMenu.loadContent(Content);
PartyManager.Init();
Resources.Init();
SkillTree.LoadContent(Content);
//SkillTree.Init();
Character.load_content(Content);
AnimatedEffect.LoadContent(Content);
Status.LoadContent(Content);
BattleManager.LoadContent(Content);
SkillTree.LoadContent(Content);
UpgradeMenu.loadContent(Content);
LairManager.loadContent(Content);
Menu_Song = Content.Load <SoundEffect>("Sounds/Epic_Loop");
Menu_Song_Instance = Menu_Song.CreateInstance();
Menu_Song_Instance.IsLooped = true;
Menu_Song_Instance.Volume = .1f;
Battle_Song = Content.Load <SoundEffect>("Sounds/VGameTune");
Battle_Song_Instance = Battle_Song.CreateInstance();
Battle_Song_Instance.IsLooped = true;
Battle_Song_Instance.Volume = .1f;
Main_Song = Content.Load <SoundEffect>("Sounds/LingeringChip");
Main_Song_Instance = Main_Song.CreateInstance();
Main_Song_Instance.IsLooped = true;
Main_Song_Instance.Volume = .3f;
//both songs have no duration
EndGameText = new Text("And So,\n\nThrough much perserverence\nand a low interest mortgage\nour boss was finally\n\nLeft Alone.",
new Vector2(300, 200), Text.fonts["6809Chargen-24"], Color.Cyan);
}
// Use this for initialization
void Start () {
skillTreeHandler = this;
if(!loadSkillsFromDisk()) {
skilltree = new SkillTree();
} else {
skilltree = GameSave.current.skilltree;
}
/*for(int a=0;a!=transform.childCount;++a) {
SkillButton button = transform.GetChild(a).GetComponent<SkillButton>();
for(int b=0;b!=skilltree.skillLevel;++b) {
if(skilltree.skills[b].skillType == button.skillType) {
button.skillCount = skilltree.skills[b].skillCount;
button.LoadedClick();
break;
}
}
}*/
}
/// <summary>
/// Generates a simple text output containing the total XP and
/// level for each skill in the given skilltree
/// </summary>
/// <param name="skilltree"></param>
/// <returns></returns>
private string GenerateSkillTreeText(SkillTree skilltree)
{
//Init empty string for skill tree
string st = "";
//Iterate each skill
foreach (Skills skill in MiscUtils.GetValues <Skills>())
{
//Get the relevent Skill object from the skill tree
Skill curSkill = skilltree.GetSkill(skill);
//Create skill information
st += "<b>" + curSkill.Name + "</b>\n";
st += " Current XP: " + curSkill.GetXP() + "\n";
st += " Current Level: " + curSkill.GetLevel() + "\n\n";
}
return(st);
}
// Update is called once per frame
void Update()
{
if (ability != null) //TODO probably move for performance
{
tooltipAbility.SetAbility(ability);
}
if (skillTree == null)
{
foreach (SkillTree tree in SkillTree.all)
{
if (tree.ability == ability)
{
skillTree = tree;
}
}
}
}
public async Task GetPointCountTest()
{
var build = _builds.FindByName("PoeplannerWitchOccultistAscendant");
var targetUrl = build.GetAlternativeUrl("pathofexileWindowed");
// Need instance created in current thread for a WPF UI logic
SkillTree.ClearAssets();
SkillTree tree = await SkillTree.CreateAsync(_persistentData);
tree.LoadFromUrl(targetUrl);
var deserializer = _tree.BuildConverter.GetUrlDeserializer(targetUrl);
var points = tree.GetPointCount();
var count = points["NormalUsed"] + points["AscendancyUsed"] + points["ScionAscendancyChoices"];
Assert.AreEqual(count, deserializer.GetPointsCount(true));
}
/// <summary>
/// Constructs a new SettingsViewModel that operates on the given skill tree.
/// </summary>
/// <param name="tree">The skill tree to operate on. (not null)</param>
/// <param name="persistentData"></param>
/// <param name="dialogCoordinator"></param>
/// <param name="dialogContext">The context used for <paramref name="dialogCoordinator"/>.</param>
public SettingsViewModel(SkillTree tree, IPersistentData persistentData, ISettingsDialogCoordinator dialogCoordinator, object dialogContext)
{
Tree = tree;
_dialogCoordinator = dialogCoordinator;
_dialogContext = dialogContext;
SelectedTabIndex = new LeafSetting <int>(nameof(SelectedTabIndex), 0);
async void RunCallback(GeneratorTabViewModel g) => await RunAsync(g);
Tabs = new ObservableCollection <GeneratorTabViewModel>
{
new SteinerTabViewModel(Tree, _dialogCoordinator, _dialogContext, RunCallback),
new AdvancedTabViewModel(Tree, persistentData, _dialogCoordinator, _dialogContext, RunCallback),
new AutomatedTabViewModel(Tree, _dialogCoordinator, _dialogContext, RunCallback)
};
SubSettings = new ISetting[] { SelectedTabIndex }.Union(Tabs).ToArray();
}
public SkillTree GetTree(SkillType sT)
{
SkillTree result = null;
switch (sT)
{
case SkillType.Illusion: result = IllusionTree; break;
case SkillType.Conjuration: result = ConjurationTree; break;
case SkillType.Destruction: result = DestructionTree; break;
case SkillType.Restoration: result = RestorationTree; break;
case SkillType.Alteration: result = AlterationTree; break;
case SkillType.Enchanting: result = EnchantingTree; break;
case SkillType.Smithing: result = SmithingTree; break;
case SkillType.HeavyArmor: result = HeavyArmorTree; break;
case SkillType.Block: result = BlockTree; break;
case SkillType.Twohanded: result = TwohandedTree; break;
case SkillType.Onehanded: result = OnehandedTree; break;
case SkillType.Marksman: result = MarksmanTree; break;
case SkillType.LightArmor: result = LightArmorTree; break;
case SkillType.Sneak: result = SneakTree; break;
case SkillType.Lockpicking: result = LockpickingTree; break;
case SkillType.Pickpocket: result = PickpocketTree; break;
case SkillType.Speechcraft: result = SpeechcraftTree; break;
case SkillType.Alchemy: result = AlchemyTree; break;
}
return(result);
}
private static void InitTrees()
{
//Create all possible skill trees//
trees = new SkillTree[CharacterData.NumClasses * 3];
nodes = new SkillNode[skills.Length];
//Warrior Skill Trees//
//Skill Tree names not final//
trees[0] = new SkillTree(0, CharacterData.warrior, "Knight");
//Add Skills//
//Barbarian is my scapegoat for testing//
trees[1] = new SkillTree(1, CharacterData.warrior, "Barbarian");
nodes[0] = new SkillNode(1, null, 1, skills[0]);
nodes[1] = new SkillNode(2, new int[] { 0 }, 5, skills[1]);
nodes[2] = new SkillNode(3, new int[] { 1 }, 10, skills[2]);
trees[1].AddSkills(new int[] { 0, 1, 2 });
trees[2] = new SkillTree(2, CharacterData.warrior, "Spellsword");
//Add Skills//
//Wizard Skill Trees//
trees[3] = new SkillTree(3, CharacterData.wizard, "Battlemage");
//Add Skills//
trees[4] = new SkillTree(4, CharacterData.wizard, "Archmage");
//Add Skills//
trees[5] = new SkillTree(5, CharacterData.wizard, "Sorcerer");
//Add Skills//
//Thief Skill Trees//
trees[6] = new SkillTree(6, CharacterData.thief, "Assassin");
//Add Skills//
trees[7] = new SkillTree(7, CharacterData.thief, "Bandit");
//Add Skills//
trees[8] = new SkillTree(8, CharacterData.thief, "Ninja");
//Add Skills//
}
public async Task SaveToUrlTest()
{
var build = _builds.FindByName("PoeplannerWitchOccultistAscendant");
var targetUrl = build.GetAlternativeUrl("pathofexileWindowed");
string expectedUrl = targetUrl.Split('/').LastOrDefault();
// Need instance created in current thread for a WPF UI logic
SkillTree.ClearAssets();
SkillTree tree = await SkillTree.CreateAsync(_persistentData);
tree.LoadFromUrl(targetUrl);
var actualUrl = tree.Serializer.ToUrl().Split('/').LastOrDefault();
Assert.AreEqual(expectedUrl, actualUrl);
SkillTree.ClearAssets();
}
public async Task SaveToUrlNoAscendancyPointsTest()
{
var build = _builds.FindByName("PathofexilWitchOccultist");
var targetUrl = build.DefaultUrl;
string expectedSegment = targetUrl.Split('/').LastOrDefault();
// Need new instance created in current thread for a WPF UI logic
SkillTree.ClearAssets();
SkillTree tree = await SkillTree.CreateAsync(_persistentData);
tree.LoadFromUrl(targetUrl);
var actualSegment = tree.Serializer.ToUrl().Split('/').LastOrDefault();
Assert.AreEqual(expectedSegment, actualSegment);
SkillTree.ClearAssets();
}
private void Start()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Debug.LogError("Duplicate " + this.GetType().Name);
Destroy(gameObject);
}
upgrades = content.GetComponentsInChildren <UpgradeInstance>().ToList();
rims = new List <Image>();
InitializeUpgrades();
upgrades[1].SetCanBeApplied(true);
upgrades[3].SetCanBeApplied(true);
upgrades[5].SetCanBeApplied(true);
gameObject.SetActive(false);
}
private void SkillList_Click(object sender, EventArgs e)
{
newToolStripMenuItem4.HideDropDown();
try
{
// Make sure that if the class was changed, the new skill list is loaded
if (lastClass != CurrentWSG.Class)
{
DoSkillList();
}
// Look up the name of the selected skill from its display text
string skillName = SkillsAllXml.XmlReadAssociatedValue("Name", "SkillName", (string)SkillList.SelectedItem);
if (skillName == "")
{
skillName = (string)SkillList.SelectedItem;
}
// If the skill is already in the tree, just select it and do nothing
TreeNodeAdv skillNode = SkillTree.FindFirstNodeByTag(skillName, false);
if (skillNode != null)
{
SkillTree.SelectedNode = skillNode;
return;
}
// Add enough room for the new skill in each of the skill arrays
CurrentWSG.NumberOfSkills = CurrentWSG.NumberOfSkills + 1;
Util.ResizeArrayLarger(ref CurrentWSG.SkillNames, CurrentWSG.NumberOfSkills);
Util.ResizeArrayLarger(ref CurrentWSG.LevelOfSkills, CurrentWSG.NumberOfSkills);
Util.ResizeArrayLarger(ref CurrentWSG.ExpOfSkills, CurrentWSG.NumberOfSkills);
Util.ResizeArrayLarger(ref CurrentWSG.InUse, CurrentWSG.NumberOfSkills);
// Set the data for the new skill.
int index = CurrentWSG.NumberOfSkills - 1;
CurrentWSG.InUse[index] = -1;
CurrentWSG.LevelOfSkills[index] = 0;
CurrentWSG.ExpOfSkills[index] = 01;
CurrentWSG.SkillNames[CurrentWSG.NumberOfSkills - 1] = skillName;
DoSkillTree();
}
catch { MessageBox.Show("Could not add new Skill."); }
}
public void SaveSkillTree()
{
// We fill with as many skills as nodes we have
SkillTree skillTree = new SkillTree();
skillTree.skilltree = new Skill[_skillTree.Length];
for (int i = 0; i < _skillTree.Length; ++i)
{
_skills.TryGetValue(_skillTree[i].id_Skill, out _skillInspected);
if (_skillInspected != null)
{
skillTree.skilltree[i] = _skillInspected;
}
}
string json = JsonUtility.ToJson(skillTree);
PlayerPrefs.SetString("SkillTree", json);
}
public void clicked()
{
UIBase uiBase = UIBase.instance;
if (uiBase && uiBase.openSkillTrees.Count > 0)
{
SkillTree openSKillTree = uiBase.openSkillTrees[0];
GameObject player = PlayerFinder.getPlayer();
if (openSKillTree && player && player.GetComponent <SpecialisedAbilityList>())
{
player.GetComponent <SpecialisedAbilityList>().SpecialiseIfThereIsAFreeSlot(openSKillTree.ability);
// play a sound
UISounds.playSound(UISounds.UISoundLabel.Specialise);
}
uiBase.closeSkillTrees();
openSKillTree.open();
uiBase.closeSpecialisationSelection();
}
}
public static void ClassInitialize(TestContext testContext)
{
if (ItemDB.IsEmpty())
{
ItemDB.Load("Data/ItemDB/GemList.xml", true);
}
_persistentData = new BarePersistentData {
CurrentBuild = new PoEBuild()
};
_persistentData.EquipmentData = EquipmentData.CreateAsync(_persistentData.Options).Result;
_builds = TestBuildUrlLoader.LoadFromXmlFile("../../TestBuilds/BuildUrls.xml");
_builds.AddRange(TestBuildUrlLoader.LoadFromXmlFile("../../TestBuilds/EmptyBuildUrls.xml"));
// This initialization requires a lot of time, so it is reasonable to reuse one instance if possible.
// However, as some tests may change tree state this field should be used only for methods,
// that does not depend on a tree instance.
_tree = SkillTree.CreateAsync(_persistentData).Result;
}
void onLoadCharacter(NetworkMessage msg)
{
PlayerInfo m = msg.ReadMessage <PlayerInfo>();
GameObject playerObj = ClientScene.FindLocalObject(m.id);
Player player = playerObj.GetComponent <Player>();
List <Skill> skillsToVerifyFromServer = new List <Skill>();
for (int i = 2; i < m.skillProperties.Length; i += 3)
{
Skill tempSkill = new Skill();
tempSkill.id = m.skillProperties[i - 2]; //skillId
tempSkill.currentPoints = m.skillProperties[i - 1]; //currentPoints
tempSkill.maxPoints = m.skillProperties[i]; //maxPoints
this.player.skillsToVerifyWithFromServer.Add(tempSkill);
}
skillTree = Instantiate(skillTreePrefab).GetComponent <SkillTree> ();
skillTree.initilize(player);
}
public void AssignCharactersToUnlockToLevels()
{
GameObject skillTreesParent = FindObjectOfType <CanvasSkillTreesContainer>().gameObject;
for (int i = 0; i < skillTreesParent.transform.childCount; i++)
{
SkillTree tempSkillTree = skillTreesParent.transform.GetChild(i).GetComponent <SkillTree>();
if (tempSkillTree.characterId == idCharacter)
{
skillTreePrefab = tempSkillTree.gameObject;
}
}
//Hacer reaparecer el modelo
HideShowMeshCharacterData(true);
InitializeCharacterToUnlocks();
}
// called when a specialised skill is changed
public void checkIfAbilityChanged(int abilitySlotChanged)
{
if (abilitySlotChanged == abilityNumber && list.abilities.Count > abilityNumber)
{
if (list.abilities[abilityNumber] != null)
{
ability = list.abilities[abilityNumber];
icon.sprite = ability.abilitySprite;
findSkillTree();
locked = false;
}
else
{
ability = null;
icon.sprite = openSlotSprite;
skillTree = null;
}
}
}
public void loadTree(string treeID, int unspentPoints, int unspentAxisPoints, List <StringIntPair> nodesTaken)
{
// open the relevant parts of the ui
UIBase uiBase = UIBase.instance;
uiBase.openSkills();
uiBase.openPassiveTree(true);
// get a list of the saved node IDs for iterating through later
List <string> savedNodeIDs = new List <string>();
Dictionary <string, int> nodeIDsToPositionInNodesTaken = new Dictionary <string, int>();
for (int i = 0; i < nodesTaken.Count; i++)
{
savedNodeIDs.Add(nodesTaken[i].key);
nodeIDsToPositionInNodesTaken.Add(nodesTaken[i].key, i);
}
// find the correct tree
foreach (Tree tree in FindObjectsOfType <Tree>())
{
if (tree.treeID == treeID)
{
tree.unspentPoints = unspentPoints;
tree.unspentAxisPoints = unspentAxisPoints;
SkillTree skillTree = tree as SkillTree;
if (skillTree)
{
skillTree.open();
}
foreach (SkillTreeNode node in tree.nodeList)
{
if (savedNodeIDs.Contains(node.nodeID))
{
node.pointsAllocated = nodesTaken[nodeIDsToPositionInNodesTaken[node.nodeID]].value;
node.updateText();
}
}
tree.updateMutator();
}
}
uiBase.closeSkillTrees();
uiBase.closeSkills();
uiBase.closePassiveTree();
}
public SkillTree Returnable()
{
if (TB_Name == null)
{
MessageBox.Show($"Skill tree requires a name", "Error, No name given", MessageBoxButtons.OK, MessageBoxIcon.Error);
return(null);
}
var tmp = TBL_Skilltree.DataSource as DataTable;
Output = new SkillTree()
{
Name = TB_Name.Text, Desc = TB_Desc.Text, Red = TB_Red.Text, Green = TB_Green.Text, Blue = TB_Blue.Text, Alpha = TB_Alhpa.Text
};
Output.Skills = new List <Tuple <int, CustomSkill> >();
foreach (DataRow item in tmp.Rows)
{
Output.Skills.Add(new Tuple <int, CustomSkill>(int.Parse(item.ItemArray[0].ToString()), item.ItemArray[1] as CustomSkill));
}
return(Output);
}
void Awake()
{
if (instance == null)
{
instance = this;
}
else if (instance != this)
{
Destroy(gameObject);
}
if (!MasterPlayerData.instance.checkSeenHint(HintIds.SkillTree))
{
Elementalist.instance.sayEasyHappy(Hints.getHintFrom(HintIds.SkillTree));
Elementalist.instance.sayEasyHappy(Hints.getHintFrom(HintIds.SkillTreeSuggest) + getTopEssenceCountBiome());
MasterPlayerData.instance.seenHint(HintIds.SkillTree);
}
skillExplanationPanel.gameObject.SetActive(false);
}
/// <summary>
/// Instantiates a new ControllerViewModel.
/// </summary>
/// <param name="solver">The (not null) solver this object should run.</param>
/// <param name="generatorName">The name suffix shown as DisplayName as 'Skill tree generator - {generatorName}'</param>
/// <param name="tree">SkillTree to operate on (not null)</param>
public ControllerViewModel(ISolver solver, string generatorName, SkillTree tree)
{
if (solver == null)
{
throw new ArgumentNullException("solver");
}
if (tree == null)
{
throw new ArgumentNullException("tree");
}
_solver = solver;
DisplayName = L10n.Message("Skill tree generator") + " - " + generatorName;
_tree = tree;
_progress = new Progress <Tuple <int, IEnumerable <ushort> > >(tuple => ReportProgress(tuple.Item1, tuple.Item2));
_reportStopwatch.Start();
RequestClose += (sender, args) => CancelClose();
}
public SkillsData(SkillTree s)
{
skill_points = s.total_skill_points;
List <Skill> skills = s.GetSkillList();
int max_id = 0;
foreach (Skill skill in skills)
{
if (skill.id > max_id)
{
max_id = skill.id;
}
}
skill_levels = new int[max_id + 1];
for (int i = 0; i < skills.Count; i++)
{
skill_levels[skills[i].id] = skills[i].level;
}
}
void initSkillTrees()
{
//Order is important
SkillTree assaultSkill = new SkillTree();
SkillTree defenderSkill = new SkillTree();
SkillTree medicSkill = new SkillTree();
skillTrees = new List<SkillTree>();
skillTrees.Add(assaultSkill);
skillTrees.Add(defenderSkill);
skillTrees.Add(medicSkill);
SetPassiveInfo();
}
public Class(string name, string description, SkillTree skillTree)
{
this.name = name;
this.description = description;
this.skillTree = skillTree;
}
/// <summary>
/// A new instance of the SteinerSolver optimizer that still needs to be
/// initialized.
/// </summary>
/// <param name="tree">The skill tree in which to optimize.</param>
public SteinerSolver(SkillTree tree)
{
this.tree = tree;
}
public GameSave() {
characterLevel = 0;
skilltree = new SkillTree();
}
bool loadSkillsFromDisk() {
if(SaveLoad.Load()) {
Debug.Log("loaded");
GameSave save = GameSave.current;
skilltree = save.skilltree;
putSkillsAfterLoad();
return true;
}
return false;
}
// Use this for initialization
void Start()
{
CreateQuests ();
//find out all GUI we need to handle
player = GameObject.FindWithTag ("Player");
psg = player.GetComponent<PlayerStateGUI> ();
skill = player.GetComponent<SkillTree> ();
item = player.GetComponent<ItemGUI> ();
Q1Script = this.gameObject.GetComponent<Quest1>();
Q2Script = this.gameObject.GetComponent<Quest2>();
Q3Script = this.gameObject.GetComponent<Quest3>();
Q4Script = this.gameObject.GetComponent<Quest4>();
R = GameObject.Find ("Arrow").GetComponent<RotateTo>();
}
// Use this for initialization
void Start()
{
CreateQuests ();
//find out all GUI we need to handle
player = GameObject.FindWithTag ("Player");
psg = player.GetComponent<PlayerStateGUI> ();
skill = player.GetComponent<SkillTree> ();
}
public void ActivateSkill(SkillTree skillTree)
{
this.skillTree = skillTree;
gameObject.SetActive(true);
}
