public override ActorRoot SelectTarget(SkillSlot UseSlot)
{
return(Singleton <TargetSearcher> .GetInstance().GetLowestHpTarget(UseSlot.Actor.handle, UseSlot.SkillObj.GetMaxSearchDistance(UseSlot.GetSkillLevel()), TargetPriority.TargetPriority_Hero, UseSlot.SkillObj.cfgData.dwSkillTargetFilter, false, true));
}
public override VInt3 SelectTargetDir(SkillSlot UseSlot)
{
ActorRoot lowestHpTarget = Singleton <TargetSearcher> .GetInstance().GetLowestHpTarget(UseSlot.Actor.handle, UseSlot.SkillObj.GetMaxSearchDistance(UseSlot.GetSkillLevel()), TargetPriority.TargetPriority_Hero, UseSlot.SkillObj.cfgData.dwSkillTargetFilter, false, true);
if (lowestHpTarget != null)
{
VInt3 vInt = lowestHpTarget.location - UseSlot.Actor.handle.location;
vInt.y = 0;
return(vInt.NormalizeTo(1000));
}
return(UseSlot.Actor.handle.forward);
}
public void ChangeSkillSlot(SkillSlotType _slotType, int _skillID, int _orgSkillID = 0)
{
int num = 0;
int num2 = 0;
SkillSlot skillSlot = null;
if (this.sourceActor.handle.SkillControl.TryGetSkillSlot(_slotType, out skillSlot))
{
int num3 = 0;
if (_slotType == SkillSlotType.SLOT_SKILL_7)
{
SLevelContext curLvelContext = Singleton <BattleLogic> .instance.GetCurLvelContext();
if (curLvelContext != null)
{
if ((long)this.sourceActor.handle.SkillControl.ornamentFirstSwitchCdEftTime >= (long)Singleton <FrameSynchr> .instance.LogicFrameTick)
{
num3 = curLvelContext.m_ornamentFirstSwitchCd;
}
else
{
num3 = curLvelContext.m_ornamentSwitchCD;
}
this.sourceActor.handle.SkillControl.ornamentFirstSwitchCdEftTime = 0;
}
}
else
{
num3 = skillSlot.CurSkillCD;
}
int skillLevel = skillSlot.GetSkillLevel();
if (skillSlot.SkillObj != null)
{
num = skillSlot.SkillObj.SkillID;
}
if (skillSlot.PassiveSkillObj != null)
{
num2 = skillSlot.PassiveSkillObj.SkillID;
}
if (_orgSkillID != 0 && num != _orgSkillID)
{
return;
}
skillSlot.DestoryIndicatePrefab();
this.sourceActor.handle.SkillControl.InitSkillSlot((int)_slotType, _skillID, num2);
if (this.sourceActor.handle.SkillControl.TryGetSkillSlot(_slotType, out skillSlot))
{
skillSlot.CurSkillCD = num3;
skillSlot.IsCDReady = (num3 == 0);
skillSlot.SetSkillLevel(skillLevel);
DefaultSkillEventParam defaultSkillEventParam = new DefaultSkillEventParam(_slotType, 0, this.sourceActor);
Singleton <GameSkillEventSys> .GetInstance().SendEvent <DefaultSkillEventParam>(GameSkillEventDef.Event_UpdateSkillUI, this.sourceActor, ref defaultSkillEventParam, GameSkillEventChannel.Channel_HostCtrlActor);
if (this.changeSkillSlot[(int)_slotType].changeCount == 0)
{
this.changeSkillSlot[(int)_slotType].initSkillID = num;
this.changeSkillSlot[(int)_slotType].initPassiveSkillID = num2;
}
this.changeSkillSlot[(int)_slotType].changeSkillID = _skillID;
ChangeSkillSlot[] array = this.changeSkillSlot;
array[(int)_slotType].changeCount = array[(int)_slotType].changeCount + 1;
}
}
}
public override uint SelectSkillTarget(SkillSlot _slot)
{
uint num = this.lockTargetID;
SelectEnemyType selectEnemyType = SelectEnemyType.SelectLowHp;
Player ownerPlayer = ActorHelper.GetOwnerPlayer(ref this.actorPtr);
SkillSelectControl instance = Singleton <SkillSelectControl> .GetInstance();
Skill skill = (_slot.NextSkillObj != null) ? _slot.NextSkillObj : _slot.SkillObj;
uint dwSkillTargetFilter = skill.cfgData.dwSkillTargetFilter;
if (skill.cfgData.bSkillTargetRule == 2)
{
num = this.actor.ObjID;
}
else if (skill.cfgData.bSkillTargetRule == 5)
{
ActorRoot actorRoot = instance.SelectTarget(SkillTargetRule.NextSkillTarget, _slot);
if (actorRoot != null)
{
num = actorRoot.ObjID;
if (this.IsValidLockTargetID(num))
{
Singleton <NetLockAttackTarget> .GetInstance().SendLockAttackTarget(num);
}
}
}
else
{
ActorRoot useSkillTargetLockAttackMode = _slot.skillIndicator.GetUseSkillTargetLockAttackMode();
if (useSkillTargetLockAttackMode != null)
{
if (this.IsValidLockTargetID(useSkillTargetLockAttackMode.ObjID))
{
num = useSkillTargetLockAttackMode.ObjID;
Singleton <NetLockAttackTarget> .GetInstance().SendLockAttackTarget(num);
}
}
else if (!this.IsValidLockTargetID(this.lockTargetID))
{
if (ownerPlayer != null)
{
selectEnemyType = ownerPlayer.AttackTargetMode;
}
int srchR;
if (skill.AppointType == SkillRangeAppointType.Target)
{
srchR = skill.GetMaxSearchDistance(_slot.GetSkillLevel());
}
else
{
srchR = skill.cfgData.iMaxAttackDistance;
}
if (selectEnemyType == SelectEnemyType.SelectLowHp)
{
num = Singleton <AttackModeTargetSearcher> .GetInstance().SearchLowestHpTarget(ref this.actorPtr, srchR, dwSkillTargetFilter, true, SearchTargetPriority.CommonAttack);
}
else
{
num = Singleton <AttackModeTargetSearcher> .GetInstance().SearchNearestTarget(ref this.actorPtr, srchR, dwSkillTargetFilter, true, SearchTargetPriority.CommonAttack);
}
if (this.IsValidLockTargetID(num))
{
Singleton <NetLockAttackTarget> .GetInstance().SendLockAttackTarget(num);
}
}
else if (!this.IsValidSkillTargetID(num, dwSkillTargetFilter))
{
num = 0u;
}
}
return(num);
}
private bool UseImpl(PoolObjHandle <ActorRoot> user)
{
if (this.skillContext == null || !this.skillContext.TargetActor || this.cfgData == null)
{
return(false);
}
BuffHolderComponent buffHolderComp = this.skillContext.TargetActor.handle.BuffHolderComp;
if (buffHolderComp == null)
{
return(false);
}
if (!this.CheckUseRule(this.skillContext))
{
return(false);
}
if (!buffHolderComp.overlayRule.CheckOverlay(this))
{
return(false);
}
bool flag = false;
bool flag2 = false;
VInt3 value = VInt3.forward;
switch (this.skillContext.AppointType)
{
case SkillRangeAppointType.Pos:
flag = true;
break;
case SkillRangeAppointType.Directional:
flag2 = true;
value = this.skillContext.UseVector;
if (this.skillContext.TargetID != 0u)
{
PoolObjHandle <ActorRoot> actor = Singleton <GameObjMgr> .GetInstance().GetActor(this.skillContext.TargetID);
if (actor)
{
VInt3 vInt = actor.handle.location - user.handle.location;
vInt.y = 0;
vInt.Normalize();
value = vInt;
}
}
break;
case SkillRangeAppointType.Track:
flag = true;
flag2 = true;
value = this.skillContext.EndVector - this.skillContext.UseVector;
if (value.sqrMagnitudeLong < 1L)
{
value = VInt3.forward;
}
break;
}
GameObject gameObject = this.skillContext.Originator ? this.skillContext.Originator.handle.gameObject : null;
GameObject gameObject2 = this.skillContext.TargetActor ? this.skillContext.TargetActor.handle.gameObject : null;
this.curAction = new PoolObjHandle <Action>(ActionManager.Instance.PlayAction(this.ActionName, true, false, new GameObject[]
{
gameObject,
gameObject2
}));
if (!this.curAction)
{
return(false);
}
this.curAction.handle.onActionStop += new ActionStopDelegate(this.OnActionStoped);
this.curAction.handle.refParams.AddRefParam("SkillObj", this);
this.curAction.handle.refParams.AddRefParam("SkillContext", this.skillContext);
this.curAction.handle.refParams.AddRefParam("TargetActor", this.skillContext.TargetActor);
this.curAction.handle.refParams.SetRefParam("_BulletPos", this.skillContext.EffectPos);
this.curAction.handle.refParams.SetRefParam("_BulletDir", this.skillContext.EffectDir);
if (flag)
{
this.curAction.handle.refParams.SetRefParam("_TargetPos", this.skillContext.UseVector);
}
if (flag2)
{
this.curAction.handle.refParams.SetRefParam("_TargetDir", value);
}
if (this.cfgData != null)
{
int num = this.cfgData.iDuration;
if (this.cfgData.iDurationGrow > 0)
{
SkillSlotType skillSlotType = this.skillContext.SlotType;
int num2 = (int)(this.cfgData.bGrowthType % 10);
int num3 = (int)(this.cfgData.bGrowthType / 10);
if ((skillSlotType >= SkillSlotType.SLOT_SKILL_1 && skillSlotType <= SkillSlotType.SLOT_SKILL_3) || (skillSlotType == SkillSlotType.SLOT_SKILL_0 && num2 > 0))
{
int num4 = 1;
if (this.skillContext.Originator && this.skillContext.Originator.handle.SkillControl != null && this.skillContext.Originator.handle.ValueComponent != null)
{
SkillSlot skillSlot = null;
if (num2 == 1)
{
num4 = this.skillContext.Originator.handle.ValueComponent.actorSoulLevel;
}
else
{
if (num2 - 1 >= 1 && num2 - 1 <= 3)
{
skillSlotType = (SkillSlotType)(num2 - 1);
}
this.skillContext.Originator.handle.SkillControl.TryGetSkillSlot(skillSlotType, out skillSlot);
if (skillSlot != null)
{
num4 = skillSlot.GetSkillLevel();
}
}
}
num4 = ((num4 < 1) ? 1 : num4);
num3 = ((num3 < 1) ? 1 : num3);
num += (num4 - 1) / num3 * this.cfgData.iDurationGrow;
}
}
if (this.skillContext.Originator && this.skillContext.Originator.handle != null && this.skillContext.Originator.handle.TheActorMeta.ActorType == ActorTypeDef.Actor_Type_Hero && this.skillContext.Originator.handle.TheStaticData.TheHeroOnlyInfo.AttackDistanceType == 2 && this.cfgData.iLongRangeReduction > 0)
{
num = num * this.cfgData.iLongRangeReduction / 10000;
}
this.curAction.handle.ResetLength(num, false);
if (this.cfgData.bEffectType == 2)
{
this.DealTenacity(this.skillContext.TargetActor);
}
}
bool flag3 = true;
if (this.cfgData.bShowType != 0 || this.cfgData.bFloatTextID > 0)
{
if (!this.skillContext.TargetActor || this.skillContext.TargetActor.handle == null || this.skillContext.TargetActor.handle.BuffHolderComp == null || this.skillContext.TargetActor.handle.BuffHolderComp.SpawnedBuffList == null)
{
return(false);
}
for (int i = 0; i < this.skillContext.TargetActor.handle.BuffHolderComp.SpawnedBuffList.get_Count(); i++)
{
BuffSkill buffSkill = this.skillContext.TargetActor.handle.BuffHolderComp.SpawnedBuffList.get_Item(i);
if (buffSkill != null && buffSkill.cfgData != null && buffSkill.cfgData.iCfgID == this.cfgData.iCfgID)
{
flag3 = false;
break;
}
}
if (flag3)
{
SpawnBuffEventParam spawnBuffEventParam = new SpawnBuffEventParam((uint)this.cfgData.bShowType, (uint)this.cfgData.bFloatTextID, this.skillContext.TargetActor);
Singleton <GameSkillEventSys> .GetInstance().SendEvent <SpawnBuffEventParam>(GameSkillEventDef.Event_SpawnBuff, this.skillContext.TargetActor, ref spawnBuffEventParam, GameSkillEventChannel.Channel_HostCtrlActor);
}
}
this.skillContext.TargetActor.handle.BuffHolderComp.AddBuff(this);
if (this.cfgData.bEffectType == 2 && this.cfgData.bShowType != 2)
{
LimitMoveEventParam limitMoveEventParam = new LimitMoveEventParam(base.CurAction.handle.length, this.SkillID, this.skillContext.TargetActor);
Singleton <GameSkillEventSys> .GetInstance().SendEvent <LimitMoveEventParam>(GameSkillEventDef.AllEvent_LimitMove, this.skillContext.TargetActor, ref limitMoveEventParam, GameSkillEventChannel.Channel_AllActor);
}
if (this.bAgeImmeExcute)
{
this.curAction.handle.UpdateLogic((int)Singleton <FrameSynchr> .GetInstance().FrameDelta);
}
return(true);
}
