protected SkillNode AddAttackNode() { SkillNode node = null; if (CanInput()) { node = AddCategorySkillNode(SkillCategory.kAttack); } return(node); }
// child should override this function public override bool StopSkill(SkillNode node) { SkillScript ss = m_SkillManager.GetCurPlaySkill(); if (ss != null && ss.IsActive()) { ss.StopSkill(); } return(true); }
public static PassiveNodeDefinition Convert(SkillNode skillNode) => new PassiveNodeDefinition( skillNode.Id, skillNode.Type, skillNode.Name, skillNode.IsAscendancyNode, !skillNode.IsRootNode && !skillNode.IsAscendancyStart && !skillNode.IsMultipleChoiceOption, skillNode.PassivePointsGranted, new NodePosition(skillNode.Position.X, skillNode.Position.Y), skillNode.StatDefinitions);
/// <summary> /// 攻击结束触发,(攻击物体,伤害值) /// </summary> static BattleEffect[] GetSkillEffects(SkillNode Node) { BattleEffect[] effs = new BattleEffect[Node.battleEffects.Length]; SkillEffectNode[] effNodes = SkillNode.GetSkillEffectNodes(Node.battleEffects); for (int i = 0; i < effs.Length; i++) { effs[i] = new ChangeValueEffect(effNodes[i]); } return(effs); }
public override void Init(SkillNode skillNode, GameObject targetTrans, Transform thisTrans, VoidResult action) { base.Init(skillNode, targetTrans, thisTrans, action); intervals = mCurSkillNode.interval_time; distance = 0; sphere = gameObject.AddMissingComponent <SphereCollider>(); sphere.isTrigger = true; sphere.radius = 0f; mRadiusMax = mCurSkillNode.max_fly + GameLibrary.Instance().GetExtendDis(mHitTargetCs); }
// child should override this function public override bool StopSkill(SkillNode node) { IShooterSkill ss = m_SkillManager.GetCurPlaySkill(); if (ss != null) { ss.StopSkill(); } return(true); }
public override void parseJson(object jd) { base.parseJson(jd); id = long.Parse(item["monster_id"].ToString()); types = int.Parse(item["types"].ToString()); describe = item["describe"].ToString(); info = item["info"].ToString(); icon_name = item["icon_name"].ToString(); model = int.Parse(item["model"].ToString()); modelNode = FSDataNodeTable <ModelNode> .GetSingleton().FindDataByType(model); released = int.Parse(item["released"].ToString()); is_icon = int.Parse(item["is_icon"].ToString()); if (null != item["skill_id"] && item["skill_id"] is int[]) { int[] node = item["skill_id"] as int[]; if (node != null) { skill_id = new long[node.Length]; skills = new SkillNode[node.Length]; for (int i = 0; i < node.Length; i++) { skill_id[i] = long.Parse(node[i].ToString()); skills[i] = FSDataNodeTable <SkillNode> .GetSingleton().DataNodeList[skill_id[i]]; if (skills[i].site != 0) { skillNodeDict.Add(skills[i].site, skills[i]); } } } } lv_hp = float.Parse(item["lv_hp"].ToString()); lv_attack = float.Parse(item["lv_attack"].ToString()); lv_armor = float.Parse(item["lv_armor"].ToString()); lv_resist = float.Parse(item["lv_resist"].ToString()); lv_critical = float.Parse(item["lv_critical"].ToString()); lv_dodge = float.Parse(item["lv_dodge"].ToString()); lv_ratio = float.Parse(item["lv_ratio"].ToString()); lv_armorpenetration = float.Parse(item["lv_armorpenetration"].ToString()); lv_magicpenetration = float.Parse(item["lv_magicpenetration"].ToString()); lv_suckblood = float.Parse(item["lv_suckblood"].ToString()); lv_tenacity = float.Parse(item["lv_tenacity"].ToString()); attrLvRates = new float[Formula.ATTR_COUNT] { 0f, 0f, 0f, lv_hp, lv_attack, lv_armor, lv_resist, lv_critical, lv_dodge, lv_ratio, lv_armorpenetration, lv_magicpenetration, lv_suckblood, lv_tenacity }; model_size = float.Parse(item["model_size"].ToString()); effect_sign = item["effect_sign"].ToString(); }
public void Decode(string jsonTree) { Nodes = new List <SkillNode>(); var jss = new JsonSerializerSettings { Error = (sender, args) => { // This one is known: "509":{"x":_,"y":_,"oo":[],"n":[]}} has an Array in "oo". // if (args.ErrorContext.Path != "groups.509.oo") // PoeHUD.Plugins.BasePlugin.LogError("Exception while deserializing Json tree" + args.ErrorContext.Error, 5); if (args.ErrorContext.Path == null || !args.ErrorContext.Path.EndsWith(".oo")) { Logger.Log.Error("Exception while deserializing Json tree" + args.ErrorContext.Error); } args.ErrorContext.Handled = true; } }; SkillTree = JsonConvert.DeserializeObject <PoESkillTree>(jsonTree, jss); Skillnodes = new Dictionary <ushort, SkillNode>(); NodeGroups = new List <SkillNodeGroup>(); foreach (var nd in SkillTree.nodes) { var skillNode = new SkillNode { Id = nd.Value.id, Name = nd.Value.dn, Orbit = nd.Value.o, OrbitIndex = nd.Value.oidx, bJevel = nd.Value.isJewelSocket, bKeyStone = nd.Value.ks, bMastery = nd.Value.m, bMult = nd.Value.isMultipleChoice, bNotable = nd.Value.not, linkedNodes = nd.Value._out }; Nodes.Add(skillNode); Skillnodes.Add(nd.Value.id, skillNode); } NodeGroups = new List <SkillNodeGroup>(); foreach (var gp in SkillTree.groups) { var ng = new SkillNodeGroup(); ng.OcpOrb = gp.Value.oo; ng.Position = new Vector2((float)gp.Value.x, (float)gp.Value.y); foreach (var node in gp.Value.n) { var nodeToAdd = Skillnodes[node]; ng.Nodes.Add(nodeToAdd); nodeToAdd.SkillNodeGroup = ng; } NodeGroups.Add(ng); } }
private Dictionary <GameObject, GameObject> AddMultiAttackEffect(SkillNode skillNode, string id, GameObject target, Transform emissionPoint) { Dictionary <GameObject, GameObject> result = new Dictionary <GameObject, GameObject>(); List <GameObject> mViewTarget = GetMultiTargetByCondition(skillNode); for (int i = 0; i < mViewTarget.Count; i++) { result.Add(AddAttackEffect(id, target, skillNode, emissionPoint), mViewTarget [i]); } return(result); }
public override void Init(SkillNode skillNode, GameObject targetTrans, Transform thisTrans, VoidResult action) { base.Init(skillNode, targetTrans, thisTrans, action); Destroy(gameObject, destoryTime); if (attackerCs != null && !attackerCs.isDie) { prefab = Resources.Load(attackerCs.emission.GetEffectResourceRoot() + "skill" + mCurSkillNode.site + "_Bounce") as GameObject; isHitAction = false; attackerCs.HitActionDelegate += HitDelegate; } }
public virtual void StartAttack() { CancelBreakSkillTask(); SkillNode node = AddAttackNode(); if (node != null) { node.TargetPos = Vector3.zero; } m_IsAttacking = true; }
public SkillNode AddChild(SkillNode n) { int count = checkChild(n.theDir); if (count == -1) { child.Add(n); return(n); } return(child[count]); }
//The game isn't equipped to handle health and mana potion nodes being upgraded past 1 //We need to increment the stats for them manually to make it do anything private void FixHealthManaPots(PlayerStats stats) { for (int i = 0; i < SkillTree.nodes.Length; i++) { SkillNode node = SkillTree.nodes[i]; if ((node.type == SkillNode.TYPE_HEALTH_POT || node.type == SkillNode.TYPE_MANA_POT) && stats.treeUnlocks[i] > 1) { stats.itemClass[node.type] += stats.treeUnlocks[i] - 1; } } }
private void Draw(DrawingContext context, SkillNode node) { var size = _getSize(node); var brush = _getBrush(node); context.DrawRectangle(brush, null, new Rect(node.Position.X - size.Width * _sizeFactor, node.Position.Y - size.Height * _sizeFactor, size.Width * 2 * _sizeFactor, size.Height * 2 * _sizeFactor)); }
public override void Init(SkillNode skillNode, GameObject targetTrans, Transform thisTrans, VoidResult action) { base.Init(skillNode, targetTrans, thisTrans, action); Destroy(gameObject, destoryTime); if (attackerCs != null) { attackerCs.JumpStartDelegate += JumpStart; attackerCs.JumpOverDelegate += JumpOver; attackerCs.HitActionDelegate += HitAction; } }
private void addSkill(SkillNode skill, int level) { while (skillsByLevel.Count <= level) { skillsByLevel.Add(new List <SkillNode>()); } if (!skillsByLevel[level].Contains(skill)) { skillsByLevel[level].Add(skill); } }
void UseNormalSkill(SkillNode node) { int indx = (int)node.site; thisCs.pm.Stop(); if (thisCs.state == Modestatus.Boss && thisCs.attackTarget != null) { thisCs.SetForward(); } thisCs.pm.Skill(indx); }
protected void ShootBullet(Fixed2 position, Fixed rotation, SkillNode skillnode, ISkillNodeRun run) { Bullet bullet = new Bullet(); bullet.skillNode = skillnode; bullet.skill = run.skill; bullet.user = netData; bullet.Init(netData.client); bullet.Reset(position, rotation); netData.client.objectManager.Instantiate(bullet); }
float UseSerialSkill(SkillNode node) { float totalCd = 0f; for (int i = 0; i < node.skill_parts.Length; i++) { SkillNode partNode = GetNode(node.skill_parts[i]); totalCd += i > 0 ? partNode.cooling : 0f; CDTimer.GetInstance().AddCD(totalCd, (int c, long id) => UseNormalSkill(partNode)); } return(totalCd); }
private void OnSkillStart(SkillNode node) { HideSkillTip(SkillCategory.kNone); m_LastSkillNode = m_CurSkillNode; m_CurSkillNode = node; m_CurSkillNode.StartTime = Time.time; m_CurSkillNode.IsCDChecked = false; m_WaiteSkillBuffer.RemoveAt(m_WaiteSkillBuffer.Count - 1); List <SkillNode> new_buffer_element = new List <SkillNode>(); new_buffer_element.AddRange(m_WaiteSkillBuffer); m_WaiteSkillBuffer.Clear(); if (m_CurSkillNode.NextSkillNode != null) { while (new_buffer_element.Count >= 1) { SkillNode last = new_buffer_element[new_buffer_element.Count - 1]; if (m_CurSkillNode != null && last != null && last.Category == m_CurSkillNode.Category && last.Category != SkillCategory.kAttack) { PushSkill(last.Category, Vector3.zero); new_buffer_element.RemoveAt(new_buffer_element.Count - 1); } else { break; } } } string categoryname = GetCategoryName(m_CurSkillNode.Category); if (m_CurSkillNode.NextSkillNode != null && !string.IsNullOrEmpty(categoryname)) { DashFire.LogicSystem.EventChannelForGfx.Publish("ge_cast_skill", "ui", categoryname); } if (m_LastSkillNode != null && m_LastSkillNode.Category != SkillCategory.kAttack && m_LastSkillNode.Category != m_CurSkillNode.Category) { if (!m_LastSkillNode.IsCDChecked) { BeginSkillCategoryCD(m_LastSkillNode.Category); m_LastSkillNode.IsCDChecked = true; } } if (null != m_SkillStartHandler) { m_SkillStartHandler(); } }
public Supernode SetStartNodes(HashSet <ushort> startNodes) { Supernode supernode = new Supernode(startNodes); foreach (ushort nodeId in startNodes) { SkillNode node = SkillTree.Skillnodes[nodeId]; NodeDict.Add(node, supernode); CheckLinks(node); } return(supernode); }
protected void BeginSkillCategoryCD(SkillCategory category) { SkillNode head = null; if (m_SkillCategoryDict.TryGetValue(category, out head)) { DashFire.LogicSystem.EventChannelForGfx.Publish("ge_cast_skill_cd", "ui", GetCategoryName(head.Category), GetSkillCD(head)); BeginSkillCD(head); } }
public void Init(List <IShooterSkill> skills) { m_Skills = skills; foreach (IShooterSkill ss in skills) { if (IsCategoryContain(ss.GetSkillId()) || !ss.IsDefaultCategory()) { continue; } SkillNode first_node = InitNodeByScript(skills, ss); m_SkillCategoryDict[ss.GetCategory()] = first_node; } }
public override void Init(SkillNode skillNode, GameObject targetTrans, Transform thisTrans, VoidResult action) { base.Init(skillNode, targetTrans, thisTrans, action); if (targetTrans == null) { Destroy(gameObject, destoryTime); } mOriginPos = transform.position; if (attackerCs != null) { mAttackerCs = attackerCs.state == Modestatus.SummonHero ? attackerCs.Master : attackerCs; } }
public SkillTree() { m_SkillTree = new SkillNode[Enum.GetNames(typeof(EAbility)).Length]; for (int i = 0; i < m_SkillTree.Length; i++) { m_SkillTree[i] = new SkillNode((EAbility)i); } AddPrereq(EAbility.Fireball, EAbility.Read); AddPrereq(EAbility.Icestorm, EAbility.Read); AddAntireq(EAbility.Icestorm, EAbility.Fireball); AddPrereq(EAbility.Mount, EAbility.Push); }
private static SkillNode blankNode; //To avoid null reference exceptions, create an empty "default" node// ////////////////////////////////////////////////////////////////////////// //void InitSkills() // //Retrieves skills from the Resources folder and stores them in an array// ////////////////////////////////////////////////////////////////////////// public static void InitSkills() { //Initialize Skills array// skills = (Skill[])Resources.LoadAll <Skill>("Skills"); //Sort by ID for easy access in the future// Array.Sort(skills, delegate(Skill x, Skill y){ return((x.id < y.id)?1:0); }); //Initialize Skill Trees// InitTrees(); blankNode = new SkillNode(-1, null, 0, null); }
private void AddPassiveBuff(int index) { if (cs.mCurMobalId == MobaObjectID.HeroJiansheng && index == 3 && !isTriggerPassive) { SkillNode mCurSkillNode = GameLibrary.Instance().GetCurrentSkillNodeByCs(cs, index); if (mCurSkillNode != null) { CharacterData characterData = null; GameLibrary.Instance().SetSkillDamageCharaData(ref characterData, mCurSkillNode, cs); cs.AddBuffManager(mCurSkillNode, cs, characterData); } } }
public void SetCsAttackTargetByChoseTarget(SkillNode skill, CharacterState cs) { if (SceneBaseManager.instance == null) { return; } CharacterState target = null; List <CharacterState> mCurCalTarget = GetCsAttackTargetBySkillNode(skill, cs); if (mCurCalTarget.Count > 0) { mCurCalTarget.Sort((a, b) => { float aDis = Vector3.Distance(cs.transform.position, a.transform.position); float bDis = Vector3.Distance(cs.transform.position, b.transform.position); return(Mathf.FloorToInt(aDis - bDis)); }); switch (skill.choseTarget) { case ChoseTarget.none: CharacterState mCurTarget = null; if (cs.mCurMobalId == MobaObjectID.HeroShengqi && skill.site == 2) { mCurCalTarget.Sort((a, b) => a.currentHp - b.currentHp); mCurTarget = mCurCalTarget [0]; } else { mCurTarget = mCurCalTarget.Find(chs => BattleUtil.IsHeroTarget(chs)); } target = mCurTarget == null ? mCurCalTarget[0] : mCurTarget; break; case ChoseTarget.random: target = mCurCalTarget[Random.Range(0, mCurCalTarget.Count)]; break; case ChoseTarget.farthest: target = mCurCalTarget[mCurCalTarget.Count - 1]; break; default: break; } } cs.SetAttackTargetTo(target); if (cs.state == Modestatus.Player) { CharacterManager.instance.ChangePlayerAttackTargetTo(target); } }
public void CheckLockTargetCastSkillValid(CharacterState cs, SkillNode mCurSkillNode) { if (cs.attackTarget != null) { if (!CheckHitCondition(mCurSkillNode, cs, cs.attackTarget)) { SetCsAttackTargetBySkillNode(mCurSkillNode, cs); } } else { SetCsAttackTargetBySkillNode(mCurSkillNode, cs); } }
public GameObject BuildNode(SkillNode node) { var sn = Instantiate(GSkillNode); SetHoverInfo(sn, node); sn.transform.SetParent(this.transform); sn.GetComponent <RectTransform>().localPosition = new Vector3(node.X, node.Y); sn.GetComponent <Button>().onClick.AddListener(() => NodeSelected(this, new NodeSelectEventArgs(node, sn))); return(sn); }
//for testing only /*private void initFakeSkills(){ setActiveSkill1(player.unlockedSkills[0]); setActiveSkill2(player.unlockedSkills[1]); setActiveSkill3(player.unlockedSkills[2]); activeSkill1.icon = FireballModel.getImage(); activeSkill1.position.x = Screen.width * 0.5f - position.width * 0.5f + 60; activeSkill1.position.y = Screen.height - 53; activeSkill2.icon = FireballModel.getImage(); activeSkill2.position.x = Screen.width * 0.5f - position.width * 0.5f + 104; activeSkill2.position.y = Screen.height - 53; activeSkill3.icon = FireballModel.getImage(); activeSkill3.position.x = Screen.width * 0.5f - position.width * 0.5f + 148; activeSkill3.position.y = Screen.height - 53; }*/ public void initializeBasicAttack(){ SkillNode basicAttack; if(player.GetType().IsSubclassOf(typeof(Fighter))){ basicAttack = new SkillNode(typeof(BasicMelee), "Basic Melee", "...", new Rect(0,0,0,0), BasicMeleeModel.getImage()); } else{ basicAttack = new SkillNode(typeof(BasicRanged), "Basic Ranged", "...", new Rect(0,0,0,0), BasicRangeModel.getImage()); } addSkillComponent(basicAttack.skillType); setActiveSkill5(basicAttack); }
// Use this for initialization void Start () { player = null; position.x = Screen.width * 0.5f - position.width * 0.5f; position.y = Screen.height - position.height; activeSkill1 = null; activeSkill2 = null; activeSkill3 = null; activeSkill4 = null; activeSkill5 = null; activeSkill6 = null; // legacy code //player = (Fighter) GameObject.FindObjectOfType (typeof (Fighter)); //player.actionBar = this; //initializeBasicAttack(); //for testing only //initFakeSkills(); }
/// <summary> /// Adds a skill node to the graph. New nodes are automatically /// connected to existing adjacent nodes. /// </summary> /// <param name="node">The skill node to be added.</param> /// <param name="isTarget">Whether or not this node is a target /// node.</param> /// <returns>The graph node that is added to the graph.</returns> public GraphNode AddNode(SkillNode node) { SingleNode graphNode = new SingleNode(node); nodeDict.Add(node, graphNode); CheckLinks(node); return graphNode; }
public void setActiveSkill5(SkillNode skillNode){ // decide if skill 5 (left mouse click) is always basic attack activeSkill5 = skillNode; activeSkill5.position = new Rect(position.x + 236, position.y + 12, 38, 38); player.activeSkill5 = player.gameObject.GetComponent(skillNode.skillType) as ISkill; player.activeSkill5.setCaster(player); }
private void DrawConnection(DrawingContext dc, Pen pen2, SkillNode n1, SkillNode n2) { if (n1.NodeGroup == n2.NodeGroup && n1.orbit == n2.orbit) { if (n1.Arc - n2.Arc > 0 && n1.Arc - n2.Arc <= Math.PI || n1.Arc - n2.Arc < -Math.PI) { dc.DrawArc(null, pen2, n1.Position, n2.Position, new Size(SkillTree.SkillNode.orbitRadii[n1.orbit], SkillTree.SkillNode.orbitRadii[n1.orbit])); } else { dc.DrawArc(null, pen2, n2.Position, n1.Position, new Size(SkillTree.SkillNode.orbitRadii[n1.orbit], SkillTree.SkillNode.orbitRadii[n1.orbit])); } } else { dc.DrawLine(pen2, n1.Position, n2.Position); } }
public void setActiveSkill6(SkillNode skillNode){ activeSkill6 = skillNode; activeSkill6.position = new Rect(position.x + 278, position.y + 12, 38, 38); player.activeSkill6 = player.gameObject.GetComponent(skillNode.skillType) as ISkill; player.activeSkill6.setCaster(player); }
protected void equipSkill(){ //make sure target is set, and mouse is still in target position (since target doesn't go back null) if(target != null && target.position.Contains(mousePositionInSkillTree())){ //on mouse click, if target skill is avalable and unlocked if(Input.GetMouseButton(1) && target.isAvailable() && target.isUnlocked()){ SkillNode newSkill = new SkillNode(target.skillType, target.skillName, target.skillDesc, target.position, target.icon); if(Input.GetKeyDown(KeyCode.Alpha1)){ actionBar.setActiveSkill1(newSkill); } if(Input.GetKeyDown(KeyCode.Alpha2)){ actionBar.setActiveSkill2(newSkill); } if(Input.GetKeyDown(KeyCode.Alpha3)){ actionBar.setActiveSkill3(newSkill); } if(Input.GetKeyDown(KeyCode.Alpha4)){ actionBar.setActiveSkill4(newSkill); } if(Input.GetKeyDown(KeyCode.Alpha5)){ actionBar.setActiveSkill5(newSkill); } if(Input.GetKeyDown(KeyCode.Alpha6)){ actionBar.setActiveSkill6(newSkill); } } } }
private void CheckLinks(SkillNode node) { if (!nodeDict.ContainsKey(node)) return; GraphNode currentNode = nodeDict[node]; foreach (SkillNode neighbor in node.Neighbor) { if (nodeDict.ContainsKey(neighbor)) { GraphNode adjacentNode = nodeDict[neighbor]; if (adjacentNode == currentNode) continue; adjacentNode.Adjacent.Add(currentNode); currentNode.Adjacent.Add(adjacentNode); } } }
public SingleNode(SkillNode baseNode) { this.baseNode = baseNode; this.id = baseNode.Id; }
public void setActiveSkill1(SkillNode skillNode){ activeSkill1 = skillNode; activeSkill1.position = new Rect(position.x + 60, position.y + 12, 38, 38); player.activeSkill1 = player.gameObject.GetComponent(skillNode.skillType) as ISkill; Debug.Log(player.activeSkill1 + " : " + skillNode.skillType); player.activeSkill1.setCaster(player); }