diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XAIComponent.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XAIComponent.cs | 1498 |
1 files changed, 1498 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XAIComponent.cs b/Client/Assets/Scripts/XMainClient/XAIComponent.cs new file mode 100644 index 00000000..a247c12e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XAIComponent.cs @@ -0,0 +1,1498 @@ +using System;
+using System.Collections.Generic;
+using KKSG;
+using UnityEngine;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal class XAIComponent : XComponent
+ {
+ public override uint ID
+ {
+ get
+ {
+ return XAIComponent.uuID;
+ }
+ }
+
+ public bool IsFighting
+ {
+ get
+ {
+ return this._is_fighting;
+ }
+ set
+ {
+ this._is_fighting = value;
+ }
+ }
+
+ public XRole Opponent
+ {
+ get
+ {
+ return this._opponent;
+ }
+ set
+ {
+ this._opponent = value;
+ }
+ }
+
+ public float MoveSpeed
+ {
+ get
+ {
+ return this._entity.Attributes.RunSpeed;
+ }
+ }
+
+ public Vector3 BornPos
+ {
+ get
+ {
+ return this._born_pos;
+ }
+ }
+
+ public float AttackRange
+ {
+ get
+ {
+ return this._attack_range;
+ }
+ }
+
+ public float MinKeepRange
+ {
+ get
+ {
+ return this._min_keep_range;
+ }
+ }
+
+ public int HuanraoIndex
+ {
+ get
+ {
+ return this._huanraoindex;
+ }
+ set
+ {
+ this._huanraoindex = value;
+ }
+ }
+
+ public float AttackProb
+ {
+ get
+ {
+ return this._normal_attack_prob;
+ }
+ }
+
+ public float EnterFightRange
+ {
+ get
+ {
+ return this._enter_fight_range;
+ }
+ }
+
+ public float FightTogetherDis
+ {
+ get
+ {
+ return this._fight_together_dis;
+ }
+ }
+
+ public bool IsCastingSkill
+ {
+ get
+ {
+ return this._is_casting_skill;
+ }
+ }
+
+ public bool IsOppoCastingSkill
+ {
+ get
+ {
+ return this._is_oppo_casting_skill;
+ }
+ }
+
+ public bool IsFixedInCd
+ {
+ get
+ {
+ return this._is_fixed_in_cd;
+ }
+ }
+
+ public bool IsWander
+ {
+ get
+ {
+ return this._is_wander;
+ }
+ }
+
+ public bool IsHurtOppo
+ {
+ get
+ {
+ return this._is_hurt_oppo;
+ }
+ set
+ {
+ this._is_hurt_oppo = value;
+ }
+ }
+
+ public uint CastingSkillId
+ {
+ get
+ {
+ return this._cast_skillid;
+ }
+ set
+ {
+ this._cast_skillid = value;
+ }
+ }
+
+ public XEnmityList EnmityList
+ {
+ get
+ {
+ return this._enmity_list;
+ }
+ }
+
+ public XAIEventArgs AIEvent
+ {
+ get
+ {
+ return this._ai_event;
+ }
+ set
+ {
+ this._ai_event = value;
+ }
+ }
+
+ public XPatrol Patrol
+ {
+ get
+ {
+ return this._Patrol;
+ }
+ }
+
+ private List<XSkillCore> CanCastSkill
+ {
+ get
+ {
+ bool flag = this._can_cast_skill == null;
+ if (flag)
+ {
+ this._can_cast_skill = ListPool<XSkillCore>.Get();
+ }
+ return this._can_cast_skill;
+ }
+ }
+
+ public int CanCastSkillCount
+ {
+ get
+ {
+ return (this._can_cast_skill == null) ? 0 : this._can_cast_skill.Count;
+ }
+ }
+
+ public int RangeSkillCount
+ {
+ get
+ {
+ return (this._range_skill == null) ? 0 : this._range_skill.Count;
+ }
+ }
+
+ private List<XSkillCore> RangeSkill
+ {
+ get
+ {
+ bool flag = this._range_skill == null;
+ if (flag)
+ {
+ this._range_skill = ListPool<XSkillCore>.Get();
+ }
+ return this._range_skill;
+ }
+ }
+
+ private List<XEntity> targets
+ {
+ get
+ {
+ bool flag = this._targets == null;
+ if (flag)
+ {
+ this._targets = ListPool<XEntity>.Get();
+ }
+ return this._targets;
+ }
+ }
+
+ public int TargetsCount
+ {
+ get
+ {
+ return (this._targets == null) ? 0 : this._targets.Count;
+ }
+ }
+
+ public string ComboSkill
+ {
+ get
+ {
+ return this._combo_skill_name;
+ }
+ set
+ {
+ this._combo_skill_name = value;
+ }
+ }
+
+ public SharedData AIData
+ {
+ get
+ {
+ return (this._behavior_tree as AIRunTimeBehaviorTree).Data;
+ }
+ }
+
+ public List<uint> TimerToken
+ {
+ get
+ {
+ bool flag = this._timer_token_list == null;
+ if (flag)
+ {
+ this._timer_token_list = ListPool<uint>.Get();
+ }
+ return this._timer_token_list;
+ }
+ }
+
+ public bool IgnoreSkillCD { get; set; }
+
+ public XEntity Target
+ {
+ get
+ {
+ return this._target;
+ }
+ }
+
+ public float LastCallMonsterTime { get; set; }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.singleton.XHash("XAIComponent");
+
+ public static bool UseRunTime = true;
+
+ private XRole _opponent = null;
+
+ private uint _timer_token = 0u;
+
+ private float _speed = 0f;
+
+ private uint _cast_skillid = 0u;
+
+ private float _action_gap = 1f;
+
+ private float _action_gap_factor = 0.5f;
+
+ private float _ai_start_time = 0.1f;
+
+ private Vector3 _born_pos = Vector3.zero;
+
+ private int _huanraoindex = 0;
+
+ private bool _is_woozy_state = false;
+
+ private XAIEventArgs _ai_event = null;
+
+ private bool _is_inited = false;
+
+ private int _disable_count = 0;
+
+ private List<XSkillCore> _range_skill = null;
+
+ private XEnmityList _enmity_list = new XEnmityList();
+
+ private string _combo_skill_name;
+
+ private List<uint> _timer_token_list = null;
+
+ private float _spawn_time = 0f;
+
+ private List<XSkillCore> _can_cast_skill = null;
+
+ private List<XEntity> _targets = null;
+
+ private Dictionary<uint, IXBehaviorTree> _child_trees = null;
+
+ private XEntity _target = null;
+
+ private Transform _navtarget = null;
+
+ private bool _is_oppo_casting_skill = false;
+
+ private bool _is_hurt_oppo = false;
+
+ private float _target_distance = 0f;
+
+ private float _master_distance = 9999f;
+
+ private bool _is_fixed_in_cd = false;
+
+ private float _normal_attack_prob = 0.5f;
+
+ private float _enter_fight_range = 10f;
+
+ private float _fight_together_dis = 10f;
+
+ private bool _is_wander = false;
+
+ private float _max_hp = 1000f;
+
+ private float _current_hp = 0f;
+
+ private float _max_super_armor = 100f;
+
+ private float _current_super_armor = 50f;
+
+ private int _type = 1;
+
+ private float _target_rotation = 0f;
+
+ private float _attack_range = 1f;
+
+ private float _min_keep_range = 1f;
+
+ private bool _is_casting_skill = false;
+
+ private bool _is_fighting = false;
+
+ private bool _is_qte_state = false;
+
+ private Dictionary<uint, bool> _link_skill_info = null;
+
+ private XPatrol _Patrol = new XPatrol();
+
+ private IXBehaviorTree _behavior_tree = null;
+
+ private bool _enable_runtime_tree = true;
+
+ public void Copy2CanCastSkill(List<XSkillCore> lst)
+ {
+ this.CanCastSkill.Clear();
+ this.CanCastSkill.AddRange(lst);
+ }
+
+ public void ClearCanCastSkill()
+ {
+ bool flag = this._can_cast_skill != null;
+ if (flag)
+ {
+ this._can_cast_skill.Clear();
+ }
+ }
+
+ public void AddCanCastSkill(XSkillCore skill)
+ {
+ this.CanCastSkill.Add(skill);
+ }
+
+ public XSkillCore GetCanCastSkill(int index)
+ {
+ return this.CanCastSkill[index];
+ }
+
+ public void RemoveCanCastSkillAt(int index)
+ {
+ bool flag = this._can_cast_skill != null;
+ if (flag)
+ {
+ this._can_cast_skill.RemoveAt(index);
+ }
+ }
+
+ public void RemoveCanCastSkillRange(int index, int count)
+ {
+ bool flag = this._can_cast_skill != null;
+ if (flag)
+ {
+ this._can_cast_skill.RemoveRange(index, count);
+ }
+ }
+
+ public void AddRangeSkill(XSkillCore skill)
+ {
+ this.RangeSkill.Add(skill);
+ }
+
+ public void CopyRange2CanCast()
+ {
+ this.CanCastSkill.Clear();
+ bool flag = this._range_skill != null;
+ if (flag)
+ {
+ this.CanCastSkill.AddRange(this._range_skill);
+ }
+ }
+
+ public void ClearTargets()
+ {
+ bool flag = this._targets != null;
+ if (flag)
+ {
+ this._targets.Clear();
+ }
+ }
+
+ public void AddTarget(XEntity target)
+ {
+ this.targets.Add(target);
+ }
+
+ public void SortTarget(Comparison<XEntity> comparison)
+ {
+ bool flag = this._targets != null;
+ if (flag)
+ {
+ this._targets.Sort(comparison);
+ }
+ }
+
+ public XEntity GetTarget(int index)
+ {
+ return this.targets[index];
+ }
+
+ public void Copy2Target(List<XEntity> lst)
+ {
+ this.targets.Clear();
+ this.targets.AddRange(lst);
+ }
+
+ protected override void EventSubscribe()
+ {
+ base.RegisterEvent(XEventDefine.XEvent_AIAutoFight, new XComponent.XEventHandler(this.OnTickAI));
+ base.RegisterEvent(XEventDefine.XEvent_AIStartSkill, new XComponent.XEventHandler(this.OnStartSkill));
+ base.RegisterEvent(XEventDefine.XEvent_AIEndSkill, new XComponent.XEventHandler(this.OnEndSkill));
+ base.RegisterEvent(XEventDefine.XEvent_AISkillHurt, new XComponent.XEventHandler(this.OnSkillHurt));
+ base.RegisterEvent(XEventDefine.XEvent_AIEnterFight, new XComponent.XEventHandler(this.OnAIEnterFight));
+ base.RegisterEvent(XEventDefine.XEvent_Enmity, new XComponent.XEventHandler(this.OnEnmity));
+ base.RegisterEvent(XEventDefine.XEvent_OnEntityTransfer, new XComponent.XEventHandler(this.OnEntityTranser));
+ base.RegisterEvent(XEventDefine.XEvent_ArmorBroken, new XComponent.XEventHandler(this.OnArmorBroken));
+ base.RegisterEvent(XEventDefine.XEvent_WoozyOff, new XComponent.XEventHandler(this.OnWoozyArmorRecover));
+ base.RegisterEvent(XEventDefine.XEvent_AIEvent, new XComponent.XEventHandler(this.OnProcessEvent));
+ base.RegisterEvent(XEventDefine.XEvent_RealDead, new XComponent.XEventHandler(this.OnDeathEvent));
+ base.RegisterEvent(XEventDefine.XEvent_EnableAI, new XComponent.XEventHandler(this.OnEnableAI));
+ }
+
+ public override void OnAttachToHost(XObject host)
+ {
+ base.OnAttachToHost(host);
+ bool flag = this._entity.Attributes == null;
+ if (flag)
+ {
+ this._speed = 0f;
+ }
+ else
+ {
+ bool flag2 = this._entity.Attributes is XOthersAttributes;
+ if (flag2)
+ {
+ XOthersAttributes xothersAttributes = this._entity.Attributes as XOthersAttributes;
+ this._speed = xothersAttributes.RunSpeed;
+ }
+ else
+ {
+ XRoleAttributes xroleAttributes = this._entity.Attributes as XRoleAttributes;
+ bool flag3 = xroleAttributes == null;
+ if (flag3)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("_entity.Attributes Error!", null, null, null, null, null);
+ }
+ this._speed = xroleAttributes.RunSpeed;
+ }
+ }
+ this.IgnoreSkillCD = false;
+ this._spawn_time = Time.time;
+ this.LastCallMonsterTime = 0f;
+ this._enable_runtime_tree = XAIComponent.UseRunTime;
+ }
+
+ public override void Attached()
+ {
+ this.InitNavPath();
+ this.InitVariables();
+ this.EnableBehaviorTree(this._enable_runtime_tree);
+ bool is_inited = this._is_inited;
+ if (is_inited)
+ {
+ this.SetFixVariables();
+ this.InitOpponetEnmity();
+ }
+ }
+
+ public bool Active()
+ {
+ bool isPlayer = this._entity.IsPlayer;
+ if (isPlayer)
+ {
+ bool flag = this._timer_token == 0u;
+ if (flag)
+ {
+ bool flag2 = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_ARENA || XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_GODDESS;
+ if (flag2)
+ {
+ (this._entity.Attributes as XPlayerAttributes).AutoPlayOn = true;
+ }
+ bool autoPlayOn = (this._entity.Attributes as XPlayerAttributes).AutoPlayOn;
+ bool flag3 = autoPlayOn;
+ if (flag3)
+ {
+ this.SetEnable(true, true);
+ }
+ }
+ }
+ else
+ {
+ this.SetEnable(true, true);
+ }
+ bool flag4 = XSingleton<XLevelSpawnMgr>.singleton.AIGlobal != null;
+ if (flag4)
+ {
+ XSingleton<XLevelSpawnMgr>.singleton.AIGlobal.SendAIMsg("ReadyFight", 0f, 0, 0);
+ }
+ return true;
+ }
+
+ public void EnableBehaviorTree(bool isRunTime)
+ {
+ if (isRunTime)
+ {
+ this._behavior_tree = new AIRunTimeBehaviorTree();
+ (this._behavior_tree as AIRunTimeBehaviorTree).Host = this._entity;
+ }
+ else
+ {
+ this._behavior_tree = (this._entity.EngineObject.AddComponent(EComponentType.EXBehaviorTree) as IXBehaviorTree);
+ }
+ bool isPlayer = this._entity.IsPlayer;
+ if (isPlayer)
+ {
+ SceneType sceneType = XSingleton<XScene>.singleton.SceneType;
+ if (sceneType != SceneType.SCENE_PK)
+ {
+ if (sceneType != SceneType.SCENE_TOWER)
+ {
+ this.InitSubBehaviorTree(isRunTime, XSingleton<XGlobalConfig>.singleton.GetValue("PlayerAutoFight"));
+ }
+ else
+ {
+ this._behavior_tree.SetBehaviorTree("AutoFight_TeamTower");
+ }
+ }
+ else
+ {
+ this.InitSubBehaviorTree(isRunTime, XSingleton<XGlobalConfig>.singleton.GetValue("ArenaPlayerServerAI"));
+ }
+ this._is_inited = true;
+ }
+ else
+ {
+ bool flag = XSingleton<XScene>.singleton.SceneType == SceneType.SCENE_ARENA;
+ if (flag)
+ {
+ this.InitSubBehaviorTree(isRunTime, XSingleton<XGlobalConfig>.singleton.GetValue("ArenaClientAI"));
+ this._is_inited = true;
+ }
+ else
+ {
+ XEntityStatistics.RowData byID = XSingleton<XEntityMgr>.singleton.EntityStatistics.GetByID(this._entity.TypeID);
+ bool flag2 = byID != null;
+ if (flag2)
+ {
+ bool flag3 = string.IsNullOrEmpty(byID.AiBehavior);
+ if (flag3)
+ {
+ this.InitSubBehaviorTree(isRunTime, "Monster_Empty");
+ this._is_inited = false;
+ }
+ else
+ {
+ this.InitSubBehaviorTree(isRunTime, byID.AiBehavior);
+ this._is_inited = true;
+ }
+ }
+ else
+ {
+ this.InitSubBehaviorTree(isRunTime, "default");
+ }
+ }
+ }
+ bool flag4 = this._behavior_tree == null;
+ if (!flag4)
+ {
+ this._behavior_tree.EnableBehaviorTree(true);
+ this._behavior_tree.SetManual(true);
+ }
+ }
+
+ private void InitSubBehaviorTree(bool isRunTime, string treename)
+ {
+ string[] array = treename.Split(new char[]
+ {
+ ':'
+ });
+ this._behavior_tree.SetBehaviorTree(array[0]);
+ bool flag = this._child_trees == null;
+ if (flag)
+ {
+ this._child_trees = DictionaryPool<uint, IXBehaviorTree>.Get();
+ }
+ for (int i = 1; i < array.Length; i++)
+ {
+ uint key = XSingleton<XCommon>.singleton.XHash(array[i]);
+ IXBehaviorTree ixbehaviorTree;
+ if (isRunTime)
+ {
+ AIRunTimeBehaviorTree airunTimeBehaviorTree = new AIRunTimeBehaviorTree();
+ airunTimeBehaviorTree.Host = this._entity;
+ this._child_trees[key] = airunTimeBehaviorTree;
+ ixbehaviorTree = airunTimeBehaviorTree;
+ }
+ else
+ {
+ ixbehaviorTree = (this._entity.EngineObject.AddComponent(EComponentType.EXBehaviorTree) as IXBehaviorTree);
+ this._child_trees[key] = ixbehaviorTree;
+ }
+ ixbehaviorTree.SetBehaviorTree(array[i]);
+ ixbehaviorTree.EnableBehaviorTree(true);
+ ixbehaviorTree.SetManual(true);
+ }
+ }
+
+ public void SetBehaviorTree(string tree)
+ {
+ bool flag = !string.IsNullOrEmpty(tree);
+ if (flag)
+ {
+ this._is_inited = true;
+ }
+ bool enable_runtime_tree = this._enable_runtime_tree;
+ if (enable_runtime_tree)
+ {
+ this._behavior_tree = new AIRunTimeBehaviorTree();
+ (this._behavior_tree as AIRunTimeBehaviorTree).Host = this._entity;
+ }
+ else
+ {
+ this._behavior_tree = (this._entity.EngineObject.AddComponent(EComponentType.EXBehaviorTree) as IXBehaviorTree);
+ }
+ bool flag2 = this._behavior_tree != null;
+ if (flag2)
+ {
+ this._behavior_tree.SetBehaviorTree(tree);
+ this._behavior_tree.EnableBehaviorTree(true);
+ this._behavior_tree.SetManual(true);
+ this.AIFire(this._action_gap * this._action_gap_factor);
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Add behavior error: ", tree, null, null, null, null);
+ }
+ }
+
+ public override void OnDetachFromHost()
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._timer_token);
+ bool flag = this._can_cast_skill != null;
+ if (flag)
+ {
+ ListPool<XSkillCore>.Release(this._can_cast_skill);
+ this._can_cast_skill = null;
+ }
+ bool flag2 = this._range_skill != null;
+ if (flag2)
+ {
+ ListPool<XSkillCore>.Release(this._range_skill);
+ this._range_skill = null;
+ }
+ bool flag3 = this._timer_token_list != null;
+ if (flag3)
+ {
+ ListPool<uint>.Release(this._timer_token_list);
+ this._timer_token_list = null;
+ }
+ bool flag4 = this._link_skill_info != null;
+ if (flag4)
+ {
+ DictionaryPool<uint, bool>.Release(this._link_skill_info);
+ this._link_skill_info = null;
+ }
+ bool flag5 = this._child_trees != null;
+ if (flag5)
+ {
+ DictionaryPool<uint, IXBehaviorTree>.Release(this._child_trees);
+ this._child_trees = null;
+ }
+ bool flag6 = this._targets != null;
+ if (flag6)
+ {
+ ListPool<XEntity>.Release(this._targets);
+ this._targets = null;
+ }
+ this._Patrol.Destroy();
+ base.OnDetachFromHost();
+ this.ClearAllTimer();
+ }
+
+ public void ClearAllTimer()
+ {
+ bool flag = this._timer_token_list != null;
+ if (flag)
+ {
+ for (int i = 0; i < this._timer_token_list.Count; i++)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._timer_token_list[i]);
+ }
+ this._timer_token_list.Clear();
+ }
+ }
+
+ protected virtual bool OnTickAI(XEventArgs e)
+ {
+ bool flag = !this._is_inited;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag2 = this.CheckManualInput();
+ if (flag2)
+ {
+ this.AIFire(this._action_gap * this._action_gap_factor);
+ result = true;
+ }
+ else
+ {
+ bool flag3 = this._behavior_tree != null && e != null && (XEntity.ValideEntity(this._entity) || this._entity.Attributes == null);
+ if (flag3)
+ {
+ this.UpdateVariable();
+ this.SetTreeVariable(this._behavior_tree);
+ this._behavior_tree.TickBehaviorTree();
+ this._action_gap_factor = this._behavior_tree.OnGetHeartRate();
+ bool flag4 = this._action_gap_factor == 0f;
+ if (flag4)
+ {
+ this._action_gap_factor = 1f;
+ }
+ this.AIFire(this._action_gap * this._action_gap_factor);
+ }
+ else
+ {
+ this._action_gap_factor = 1f;
+ this.AIFire(0.05f);
+ }
+ this._ai_event = null;
+ result = true;
+ }
+ }
+ return result;
+ }
+
+ public void OnTickSubTree(string treeName)
+ {
+ IXBehaviorTree ixbehaviorTree = null;
+ bool flag = this._child_trees != null && this._child_trees.TryGetValue(XSingleton<XCommon>.singleton.XHash(treeName), out ixbehaviorTree);
+ if (flag)
+ {
+ this.SetTreeVariable(ixbehaviorTree);
+ ixbehaviorTree.TickBehaviorTree();
+ }
+ }
+
+ public bool OnAIEnterFight(XEventArgs e)
+ {
+ bool is_fighting = this._is_fighting;
+ bool result;
+ if (is_fighting)
+ {
+ result = true;
+ }
+ else
+ {
+ XAIEnterFightEventArgs xaienterFightEventArgs = e as XAIEnterFightEventArgs;
+ this._target = xaienterFightEventArgs.Target;
+ this._is_fighting = true;
+ this.SendEnterFightEvent();
+ this.InitLinkSkill();
+ this._enmity_list.AddInitHateValue(this._target);
+ this._enmity_list.SetActive(true);
+ this.NotifyAllyIntoFight(xaienterFightEventArgs.Target);
+ XAIEventArgs @event = XEventPool<XAIEventArgs>.GetEvent();
+ @event.DepracatedPass = true;
+ @event.Firer = XSingleton<XEntityMgr>.singleton.Player;
+ @event.EventType = 1;
+ @event.EventArg = "SpawnMonster";
+ XSingleton<XEventMgr>.singleton.FireEvent(@event, 0.05f);
+ bool is_fighting2 = this._is_fighting;
+ if (is_fighting2)
+ {
+ XSingleton<XLevelStatistics>.singleton.OnAIinFight(this._entity);
+ }
+ bool flag = this._behavior_tree != null && XAIComponent.UseRunTime;
+ if (flag)
+ {
+ this._behavior_tree.SetVariable("target", (this._target == null) ? null : this._target.EngineObject.Find(""));
+ this._behavior_tree.SetVariable("target_distance", (this._entity.EngineObject.Position - this._target.EngineObject.Position).magnitude);
+ }
+ result = true;
+ }
+ return result;
+ }
+
+ private bool CheckManualInput()
+ {
+ return XSingleton<XVirtualTab>.singleton.Feeding && this._entity.IsPlayer;
+ }
+
+ private void UpdateVariable()
+ {
+ bool flag = this._target != null && XEntity.ValideEntity(this._target);
+ if (flag)
+ {
+ this._target_distance = ((this._host as XEntity).EngineObject.Position - this._target.EngineObject.Position).magnitude;
+ this._target_distance -= this._target.Radius;
+ bool flag2 = this._target_distance < 0f;
+ if (flag2)
+ {
+ this._target_distance = 0f;
+ }
+ Vector3 from = (this._host as XEntity).EngineObject.Position - this._target.EngineObject.Position;
+ this._target_rotation = Mathf.Abs(XSingleton<XCommon>.singleton.AngleWithSign(from, this._target.EngineObject.Forward));
+ }
+ else
+ {
+ this._target_distance = 9999999f;
+ this._target_rotation = 0f;
+ this.targets.Clear();
+ List<XEntity> opponent = XSingleton<XEntityMgr>.singleton.GetOpponent(this._entity);
+ for (int i = 0; i < opponent.Count; i++)
+ {
+ bool flag3 = XEntity.ValideEntity(opponent[i]);
+ if (flag3)
+ {
+ this.targets.Add(opponent[i]);
+ }
+ }
+ }
+ bool flag4 = XEntity.ValideEntity(XSingleton<XEntityMgr>.singleton.Player);
+ if (flag4)
+ {
+ this._master_distance = ((this._host as XEntity).EngineObject.Position - XSingleton<XEntityMgr>.singleton.Player.EngineObject.Position).magnitude;
+ }
+ bool flag5 = this._entity.Attributes != null;
+ if (flag5)
+ {
+ this._max_hp = (float)this._entity.Attributes.GetAttr(XAttributeDefine.XAttr_MaxHP_Total);
+ this._current_hp = (float)this._entity.Attributes.GetAttr(XAttributeDefine.XAttr_CurrentHP_Total);
+ this._max_super_armor = (float)this._entity.Attributes.GetAttr(XAttributeDefine.XAttr_MaxSuperArmor_Total);
+ this._current_super_armor = (float)this._entity.Attributes.GetAttr(XAttributeDefine.XAttr_CurrentSuperArmor_Total);
+ }
+ }
+
+ private void SetTreeVariable(IXBehaviorTree tree)
+ {
+ tree.SetXGameObjectByName("target", (this._target == null) ? null : this._target.EngineObject);
+ tree.SetXGameObjectByName("master", (XSingleton<XEntityMgr>.singleton.Player == null) ? null : XSingleton<XEntityMgr>.singleton.Player.EngineObject);
+ tree.SetTransformByName("navtarget", this._navtarget);
+ tree.SetBoolByName("is_oppo_casting_skill", this._is_oppo_casting_skill);
+ tree.SetBoolByName("is_hurt_oppo", this._is_hurt_oppo);
+ tree.SetFloatByName("target_distance", this._target_distance);
+ tree.SetFloatByName("master_distance", this._master_distance);
+ tree.SetBoolByName("is_fixed_in_cd", this._is_fixed_in_cd);
+ tree.SetFloatByName("normal_attack_prob", this._normal_attack_prob);
+ tree.SetFloatByName("enter_fight_range", this._enter_fight_range);
+ tree.SetFloatByName("fight_together_dis", this._fight_together_dis);
+ tree.SetBoolByName("is_wander", this._is_wander);
+ tree.SetFloatByName("max_hp", this._max_hp);
+ tree.SetFloatByName("current_hp", this._current_hp);
+ tree.SetFloatByName("max_super_armor", this._max_super_armor);
+ tree.SetFloatByName("current_super_armor", this._current_super_armor);
+ tree.SetIntByName("type", this._type);
+ tree.SetFloatByName("target_rotation", this._target_rotation);
+ tree.SetFloatByName("attack_range", this._attack_range);
+ tree.SetFloatByName("min_keep_range", this._min_keep_range);
+ tree.SetBoolByName("is_casting_skill", this._is_casting_skill);
+ tree.SetBoolByName("is_fighting", this._is_fighting);
+ tree.SetBoolByName("is_qte_state", this._is_qte_state);
+ tree.SetVector3ByName("movedir", Vector3.zero);
+ tree.SetVector3ByName("movedest", Vector3.zero);
+ tree.SetFloatByName("movespeed", 1f);
+ tree.SetVector3ByName("bornpos", this._born_pos);
+ }
+
+ public bool IsAtWoozyState()
+ {
+ return this._entity.Attributes.HasWoozyStatus && this._is_woozy_state;
+ }
+
+ public void SetTarget(XEntity entity)
+ {
+ bool flag = entity == null;
+ if (flag)
+ {
+ this._target = null;
+ }
+ else
+ {
+ this._target = entity;
+ bool flag2 = this._target != null && XEntity.ValideEntity(this._target);
+ if (flag2)
+ {
+ this._target_distance = ((this._host as XEntity).EngineObject.Position - this._target.EngineObject.Position).magnitude;
+ this._behavior_tree.SetFloatByName("target_distance", this._target_distance);
+ this._behavior_tree.SetXGameObjectByName("target", this._target.EngineObject);
+ }
+ }
+ }
+
+ private void InitNavPath()
+ {
+ XEntityStatistics.RowData byID = XSingleton<XEntityMgr>.singleton.EntityStatistics.GetByID(this._entity.TypeID);
+ this._Patrol.InitNavPath(byID);
+ }
+
+ public void SetNavTarget(int index)
+ {
+ this._navtarget = this._Patrol.GetFromNavPath(index);
+ this._behavior_tree.SetTransformByName("navtarget", this._navtarget);
+ }
+
+ public bool RefreshNavTarget()
+ {
+ this.SetNavTarget(this._Patrol.PathIndex);
+ return this._navtarget != null;
+ }
+
+ private void InitLinkSkill()
+ {
+ bool flag = this._link_skill_info == null;
+ if (flag)
+ {
+ this._link_skill_info = DictionaryPool<uint, bool>.Get();
+ }
+ this._link_skill_info.Clear();
+ bool flag2 = this._entity.MobbedBy != null;
+ if (flag2)
+ {
+ for (int i = 0; i < this._entity.SkillMgr.SkillOrder.Count; i++)
+ {
+ XSkillCore xskillCore = this._entity.SkillMgr.SkillOrder[i] as XSkillCore;
+ bool flag3 = XSingleton<XSkillEffectMgr>.singleton.AICantCast(xskillCore.ID, xskillCore.Level, this._entity.SkillCasterTypeID);
+ if (flag3)
+ {
+ this._link_skill_info[xskillCore.ID] = false;
+ }
+ }
+ }
+ }
+
+ public bool IsLinkSkillCannotCast(uint skillid)
+ {
+ return this._link_skill_info != null && this._link_skill_info.ContainsKey(skillid);
+ }
+
+ public void InitVariables()
+ {
+ bool flag = this._entity.Attributes == null;
+ if (!flag)
+ {
+ this._born_pos = this._entity.EngineObject.Position;
+ bool flag2 = this._entity.Attributes is XOthersAttributes;
+ if (flag2)
+ {
+ XOthersAttributes xothersAttributes = this._entity.Attributes as XOthersAttributes;
+ XEntityStatistics.RowData byID = XSingleton<XEntityMgr>.singleton.EntityStatistics.GetByID(this._entity.TypeID);
+ this._speed = xothersAttributes.RunSpeed;
+ this._normal_attack_prob = xothersAttributes.NormalAttackProb;
+ this._enter_fight_range = xothersAttributes.EnterFightRange;
+ this._is_wander = xothersAttributes.IsWander;
+ this._action_gap = xothersAttributes.AIActionGap;
+ this._ai_start_time = xothersAttributes.AIStartTime;
+ this._is_fixed_in_cd = xothersAttributes.IsFixedInCD;
+ bool flag3 = byID != null;
+ if (flag3)
+ {
+ this._fight_together_dis = byID.FightTogetherDis;
+ }
+ this._type = (int)xothersAttributes.Type;
+ }
+ else
+ {
+ XRoleAttributes xroleAttributes = this._entity.Attributes as XRoleAttributes;
+ bool flag4 = xroleAttributes == null;
+ if (flag4)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("_entity.Attributes Error!", null, null, null, null, null);
+ }
+ this._speed = xroleAttributes.RunSpeed;
+ this._normal_attack_prob = 1f;
+ this._enter_fight_range = 20f;
+ this._is_wander = false;
+ this._action_gap = 1.5f;
+ this._ai_start_time = 1.5f;
+ this._is_fixed_in_cd = false;
+ this._type = (int)xroleAttributes.Type;
+ }
+ XSkillCore xskillCore = (this._entity.SkillMgr == null) ? null : this._entity.SkillMgr.GetPhysicalSkill();
+ bool flag5 = xskillCore != null;
+ if (flag5)
+ {
+ this._attack_range = xskillCore.CastRangeUpper;
+ this._min_keep_range = xskillCore.CastRangeLower;
+ }
+ else
+ {
+ this._attack_range = 0f;
+ this._min_keep_range = 0f;
+ }
+ bool isPlayer = this._entity.IsPlayer;
+ if (isPlayer)
+ {
+ List<XEntity> opponent = XSingleton<XEntityMgr>.singleton.GetOpponent(this._entity);
+ for (int i = 0; i < opponent.Count; i++)
+ {
+ bool flag6 = opponent[i].AI != null;
+ if (flag6)
+ {
+ opponent[i].IsServerFighting = true;
+ }
+ }
+ }
+ }
+ }
+
+ public void SetFixVariables()
+ {
+ bool flag = this._behavior_tree == null;
+ if (!flag)
+ {
+ XEntityStatistics.RowData byID = XSingleton<XEntityMgr>.singleton.EntityStatistics.GetByID(this._entity.TypeID);
+ bool flag2 = byID != null;
+ if (flag2)
+ {
+ this._behavior_tree.SetFloatByName("ratioleft", byID.ratioleft);
+ this._behavior_tree.SetFloatByName("ratioright", byID.ratioright);
+ this._behavior_tree.SetFloatByName("ratioidle", byID.ratioidle);
+ this._behavior_tree.SetFloatByName("ratiodistance", byID.ratiodistance);
+ this._behavior_tree.SetFloatByName("ratioskill", byID.ratioskill);
+ this._behavior_tree.SetFloatByName("ratioexp", byID.ratioexp);
+ }
+ }
+ }
+
+ public void NotifyAllyIntoFight(XEntity target)
+ {
+ List<XEntity> ally = XSingleton<XEntityMgr>.singleton.GetAlly(this._entity);
+ for (int i = 0; i < ally.Count; i++)
+ {
+ bool flag = !XEntity.ValideEntity(ally[i]);
+ if (!flag)
+ {
+ bool flag2 = XSingleton<XCommon>.singleton.IsGreater((ally[i].EngineObject.Position - this._entity.EngineObject.Position).magnitude, this.FightTogetherDis);
+ if (!flag2)
+ {
+ XAIEnterFightEventArgs @event = XEventPool<XAIEnterFightEventArgs>.GetEvent();
+ @event.Firer = ally[i];
+ @event.Target = target;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ }
+ }
+ }
+ }
+
+ protected void AIFire(float time)
+ {
+ bool flag = this._timer_token > 0u;
+ if (flag)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._timer_token);
+ this._timer_token = 0u;
+ }
+ XAIAutoFightEventArgs @event = XEventPool<XAIAutoFightEventArgs>.GetEvent();
+ @event.Firer = this._host;
+ this._timer_token = XSingleton<XEventMgr>.singleton.FireEvent(@event, time);
+ }
+
+ public bool OnWoozyArmorRecover(XEventArgs e)
+ {
+ this.AIFire(this._action_gap * this._action_gap_factor);
+ this._is_woozy_state = false;
+ return true;
+ }
+
+ public bool OnArmorBroken(XEventArgs e)
+ {
+ bool hasWoozyStatus = this._entity.Attributes.HasWoozyStatus;
+ if (hasWoozyStatus)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._timer_token);
+ this._timer_token = 0u;
+ this._is_woozy_state = true;
+ XSingleton<XLevelSpawnMgr>.singleton.AIGlobal.SendAIMsg("ArmorBroken", 0f, 0, 0);
+ }
+ return true;
+ }
+
+ private bool OnProcessEvent(XEventArgs e)
+ {
+ XAIEventArgs ai_event = e as XAIEventArgs;
+ this._ai_event = ai_event;
+ bool flag = this._timer_token > 0u;
+ if (flag)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._timer_token);
+ this._timer_token = 0u;
+ XAIAutoFightEventArgs @event = XEventPool<XAIAutoFightEventArgs>.GetEvent();
+ @event.Firer = base.Host;
+ this.OnTickAI(@event);
+ @event.Recycle();
+ }
+ return true;
+ }
+
+ private bool OnEnableAI(XEventArgs e)
+ {
+ XAIEnableAI xaienableAI = e as XAIEnableAI;
+ bool flag = !xaienableAI.Enable;
+ if (flag)
+ {
+ this._disable_count++;
+ this.SetEnable(false, xaienableAI.Puppet);
+ }
+ else
+ {
+ this._disable_count--;
+ bool flag2 = this._disable_count <= 0;
+ if (flag2)
+ {
+ bool flag3 = this._entity.IsPlayer && (this._entity.Attributes as XPlayerAttributes).AutoPlayOn;
+ if (flag3)
+ {
+ this.SetEnable(true, true);
+ }
+ bool flag4 = !this._entity.IsPlayer;
+ if (flag4)
+ {
+ this.SetEnable(true, true);
+ }
+ }
+ bool flag5 = this._disable_count < 0;
+ if (flag5)
+ {
+ this._disable_count = 0;
+ }
+ }
+ return true;
+ }
+
+ private bool OnDeathEvent(XEventArgs e)
+ {
+ XSecurityAIInfo xsecurityAIInfo = XSecurityAIInfo.TryGetStatistics(this._entity);
+ bool flag = xsecurityAIInfo != null;
+ if (flag)
+ {
+ bool flag2 = !this._entity.IsPlayer && !this._entity.IsRole;
+ if (flag2)
+ {
+ xsecurityAIInfo.SetLifeTime(Time.time - this._spawn_time);
+ }
+ }
+ bool flag3 = XSingleton<XLevelSpawnMgr>.singleton.AIGlobal != null;
+ if (flag3)
+ {
+ XSingleton<XLevelSpawnMgr>.singleton.AIGlobal.SendAIMsg("Dead", 0.1f, (int)this._entity.TypeID, 0);
+ }
+ return true;
+ }
+
+ private XSkillCore GetDashSkill()
+ {
+ XEntity xentity = this._host as XEntity;
+ bool flag = xentity == null;
+ XSkillCore result;
+ if (flag)
+ {
+ result = null;
+ }
+ else
+ {
+ uint dashIdentity = xentity.SkillMgr.GetDashIdentity();
+ bool flag2 = dashIdentity == 0u;
+ if (flag2)
+ {
+ result = null;
+ }
+ else
+ {
+ XSkillCore skill = xentity.SkillMgr.GetSkill(dashIdentity);
+ bool flag3 = skill != null;
+ if (flag3)
+ {
+ result = skill;
+ }
+ else
+ {
+ result = null;
+ }
+ }
+ }
+ return result;
+ }
+
+ private bool OnStartSkill(XEventArgs e)
+ {
+ XAIStartSkillEventArgs xaistartSkillEventArgs = e as XAIStartSkillEventArgs;
+ bool isCaster = xaistartSkillEventArgs.IsCaster;
+ if (isCaster)
+ {
+ bool flag = this.GetDashSkill() == null || this.GetDashSkill().ID != xaistartSkillEventArgs.SkillId;
+ if (flag)
+ {
+ this._is_hurt_oppo = false;
+ this._is_casting_skill = true;
+ this._cast_skillid = xaistartSkillEventArgs.SkillId;
+ bool flag2 = this._behavior_tree != null;
+ if (flag2)
+ {
+ this._behavior_tree.SetIntByName("skillid", (int)this._cast_skillid);
+ }
+ }
+ }
+ else
+ {
+ this._is_oppo_casting_skill = true;
+ }
+ return true;
+ }
+
+ private bool OnEndSkill(XEventArgs e)
+ {
+ XAIEndSkillEventArgs xaiendSkillEventArgs = e as XAIEndSkillEventArgs;
+ bool isCaster = xaiendSkillEventArgs.IsCaster;
+ if (isCaster)
+ {
+ bool flag = this.GetDashSkill() == null || this.GetDashSkill().ID != xaiendSkillEventArgs.SkillId;
+ if (flag)
+ {
+ this._is_casting_skill = false;
+ this._cast_skillid = 0u;
+ this._is_hurt_oppo = false;
+ }
+ }
+ else
+ {
+ this._is_oppo_casting_skill = false;
+ }
+ return true;
+ }
+
+ private bool OnSkillHurt(XEventArgs e)
+ {
+ XAISkillHurtEventArgs xaiskillHurtEventArgs = e as XAISkillHurtEventArgs;
+ bool isCaster = xaiskillHurtEventArgs.IsCaster;
+ if (isCaster)
+ {
+ this._is_hurt_oppo = true;
+ }
+ return true;
+ }
+
+ private bool OnEnmity(XEventArgs e)
+ {
+ XEnmityEventArgs xenmityEventArgs = e as XEnmityEventArgs;
+ bool flag = xenmityEventArgs == null;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag2 = !this._enmity_list.IsActive;
+ if (flag2)
+ {
+ this._enmity_list.SetActive(true);
+ }
+ XEntity xentity = xenmityEventArgs.Starter as XEntity;
+ bool flag3 = xentity != null;
+ if (flag3)
+ {
+ uint skillLevel = xentity.Attributes.SkillLevelInfo.GetSkillLevel(xenmityEventArgs.SkillId);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(xenmityEventArgs.SkillId, skillLevel);
+ bool flag4 = skillConfig != null;
+ if (flag4)
+ {
+ this._enmity_list.AddHateValue(xentity, (float)(xenmityEventArgs.DeltaValue * (double)skillConfig.EnmityRatio + (double)skillConfig.EnmityExtValue));
+ }
+ else
+ {
+ this._enmity_list.AddHateValue(xentity, (float)xenmityEventArgs.DeltaValue);
+ }
+ bool flag5 = !this._is_fighting;
+ if (flag5)
+ {
+ this._is_fighting = true;
+ this.SendEnterFightEvent();
+ this.NotifyAllyIntoFight(xentity);
+ }
+ }
+ result = true;
+ }
+ return result;
+ }
+
+ public bool OnEntityTranser(XEventArgs e)
+ {
+ XOnEntityTransferEventArgs xonEntityTransferEventArgs = e as XOnEntityTransferEventArgs;
+ bool flag = !this._entity.IsPlayer;
+ if (flag)
+ {
+ Vector3 vector;
+ vector= new Vector3(0.5f, 0f, 0f);
+ this._entity.EngineObject.Position = XSingleton<XEntityMgr>.singleton.Player.EngineObject.Position + vector;
+ }
+ XPatrol patrol = this._Patrol;
+ int pathIndex = patrol.PathIndex;
+ patrol.PathIndex = pathIndex + 1;
+ return true;
+ }
+
+ private void SetEnable(bool enable, bool puppet = true)
+ {
+ this.SendAutoFightMsg(enable);
+ this.ResetAIData();
+ if (enable)
+ {
+ bool flag = this._timer_token > 0u;
+ if (flag)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._timer_token);
+ this._timer_token = 0u;
+ }
+ this.OnTickAI(null);
+ }
+ else
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._timer_token);
+ this._timer_token = 0u;
+ if (puppet)
+ {
+ XSingleton<XEntityMgr>.singleton.Idled(this._entity);
+ bool flag2 = this._entity.Nav != null;
+ if (flag2)
+ {
+ this._entity.Nav.Interrupt();
+ }
+ }
+ else
+ {
+ bool flag3 = this._entity.Skill != null && this._entity.Skill.IsCasting();
+ if (!flag3)
+ {
+ bool flag4 = this._entity.Machine != null && this._entity.Machine.Current == XStateDefine.XState_Move;
+ if (flag4)
+ {
+ this._entity.Net.ReportMoveAction(Vector3.zero, 0.0);
+ }
+ }
+ }
+ }
+ }
+
+ private void ResetAIData()
+ {
+ this._target = null;
+ bool flag = this._behavior_tree != null && this._is_inited;
+ if (flag)
+ {
+ this._behavior_tree.SetXGameObjectByName("target", null);
+ this._behavior_tree.SetTransformByName("BuffTarget", null);
+ this._behavior_tree.SetTransformByName("ItemTarget", null);
+ this._behavior_tree.SetFloatByName("target_distance", 99999f);
+ }
+ }
+
+ private void SendEnterFightEvent()
+ {
+ XAIEventArgs @event = XEventPool<XAIEventArgs>.GetEvent();
+ @event.DepracatedPass = false;
+ @event.Firer = this._host;
+ @event.EventType = 1;
+ @event.EventArg = "enterfight";
+ float delay = 1f;
+ XEntityStatistics.RowData byID = XSingleton<XEntityMgr>.singleton.EntityStatistics.GetByID(this._entity.TypeID);
+ bool flag = byID != null;
+ if (flag)
+ {
+ delay = byID.AIStartTime;
+ }
+ XSingleton<XEventMgr>.singleton.FireEvent(@event, delay);
+ }
+
+ private void InitOpponetEnmity()
+ {
+ List<XEntity> opponent = XSingleton<XEntityMgr>.singleton.GetOpponent(this._entity);
+ for (int i = 0; i < opponent.Count; i++)
+ {
+ XEntityStatistics.RowData byID = XSingleton<XEntityMgr>.singleton.EntityStatistics.GetByID(opponent[i].Attributes.TypeID);
+ bool flag = byID != null && byID.InitEnmity > 0;
+ if (flag)
+ {
+ this._enmity_list.AddHateValue(opponent[i], (float)byID.InitEnmity);
+ }
+ }
+ }
+
+ private void SendAutoFightMsg(bool enable)
+ {
+ bool flag = !this._entity.IsPlayer;
+ if (!flag)
+ {
+ PtcC2G_AutoFightNTF ptcC2G_AutoFightNTF = new PtcC2G_AutoFightNTF();
+ ptcC2G_AutoFightNTF.Data.autof = enable;
+ XSingleton<XClientNetwork>.singleton.Send(ptcC2G_AutoFightNTF);
+ }
+ }
+
+ public override void OnReconnect(UnitAppearance data)
+ {
+ base.OnReconnect(data);
+ this.SetEnable(XSingleton<XReconnection>.singleton.IsAutoFight, true);
+ }
+ }
+}
|