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);
}
