public void OnHandleClickSelectTargetBtn(AttackTargetType _targetType)
{
OperateMode operateMode = OperateMode.DefaultMode;
Player hostPlayer = Singleton <GamePlayerCenter> .instance.GetHostPlayer();
if (hostPlayer != null)
{
operateMode = hostPlayer.GetOperateMode();
}
if (operateMode == OperateMode.DefaultMode)
{
return;
}
if (_targetType != this.m_TargetType)
{
this.m_CurSelectedActor.Release();
}
SelectEnemyType selectType = SelectEnemyType.SelectLowHp;
if (hostPlayer != null)
{
selectType = hostPlayer.AttackTargetMode;
}
uint selectTargetByTag = this.GetSelectTargetByTag(_targetType, selectType);
Singleton <NetLockAttackTarget> .GetInstance().SendLockAttackTarget(selectTargetByTag);
this.m_TargetType = _targetType;
}
protected override uint AdvancedModeCommonAttackSearchTarget(int srchR, SelectEnemyType type, ref bool bSearched)
{
uint num = this.commonAttackTargetID;
if (base.IsValidTargetID(num) && base.TargetType(num, ActorTypeDef.Actor_Type_Hero))
{
this.SetCommonAttackTarget(num, false);
bSearched = false;
return(num);
}
bSearched = true;
int srchR2;
if (type != SelectEnemyType.SelectLowHp)
{
srchR2 = this.actor.ActorControl.SearchRange;
return(Singleton <AttackModeTargetSearcher> .GetInstance().SearchNearestTarget(ref this.actorPtr, srchR2, 0u, true, SearchTargetPriority.CommonAttack));
}
srchR2 = this.actor.ActorControl.AttackRange;
num = Singleton <AttackModeTargetSearcher> .GetInstance().SearchLowestHpTarget(ref this.actorPtr, srchR2, 0u, false, SearchTargetPriority.CommonAttack);
if (num > 0u && base.TargetType(num, ActorTypeDef.Actor_Type_Hero))
{
return(num);
}
srchR2 = this.actor.ActorControl.SearchRange;
num = Singleton <AttackModeTargetSearcher> .GetInstance().SearchLowestHpTarget(ref this.actorPtr, srchR2, 0u, false, SearchTargetPriority.CommonAttack);
if (num > 0u && base.TargetType(num, ActorTypeDef.Actor_Type_Hero))
{
return(num);
}
srchR2 = this.actor.ActorControl.SearchRange;
return(Singleton <AttackModeTargetSearcher> .GetInstance().SearchNearestTarget(ref this.actorPtr, srchR2, 0u, true, SearchTargetPriority.CommonAttack));
}
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.SkillObj : _slot.NextSkillObj;
uint dwSkillTargetFilter = skill.cfgData.dwSkillTargetFilter;
if (skill.cfgData.bSkillTargetRule == 2)
{
num = this.actor.ObjID;
}
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 == 1)
{
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);
}
protected uint ExecuteSearchTraget(int srchR, ref bool bSearched)
{
Player ownerPlayer = ActorHelper.GetOwnerPlayer(ref this.actorPtr);
SelectEnemyType type = SelectEnemyType.SelectLowHp;
LastHitMode lastHitMode = LastHitMode.None;
if (ownerPlayer != null)
{
type = ownerPlayer.AttackTargetMode;
lastHitMode = ownerPlayer.useLastHitMode;
}
uint result;
if (lastHitMode == LastHitMode.None)
{
result = this.NormalModeCommonAttackSearchTarget(srchR, type, ref bSearched);
}
else if (this.commonAttackButtonType == CommonAttackButtonType.CommonAttackButton)
{
result = this.LastHitModeCommonAttackSearchTarget(srchR, type, ref bSearched);
}
else
{
result = this.LastHitAttackSearchTarget(srchR, type, ref bSearched);
}
return(result);
}
private void ReadyUseSkillLockAttackMode(Skill readySkillObj)
{
this.skillTargetId = 0u;
SelectEnemyType selectEnemyType = SelectEnemyType.SelectLowHp;
uint num = this.Actor.get_handle().LockTargetAttackModeControl.GetLockTargetID();
if (!this.Actor.get_handle().LockTargetAttackModeControl.IsValidLockTargetID(num))
{
Player ownerPlayer = ActorHelper.GetOwnerPlayer(ref this.Actor);
if (ownerPlayer != null)
{
selectEnemyType = ownerPlayer.AttackTargetMode;
}
if (readySkillObj.AppointType == 1)
{
num = 0u;
}
else
{
int srchR = readySkillObj.cfgData.iMaxAttackDistance;
uint dwSkillTargetFilter = readySkillObj.cfgData.dwSkillTargetFilter;
if (selectEnemyType == SelectEnemyType.SelectLowHp)
{
num = Singleton <AttackModeTargetSearcher> .GetInstance().SearchLowestHpTarget(ref this.Actor, srchR, dwSkillTargetFilter, true, SearchTargetPriority.CommonAttack);
}
else
{
num = Singleton <AttackModeTargetSearcher> .GetInstance().SearchNearestTarget(ref this.Actor, srchR, dwSkillTargetFilter, true, SearchTargetPriority.CommonAttack);
}
}
}
PoolObjHandle <ActorRoot> actor = Singleton <GameObjMgr> .GetInstance().GetActor(num);
if (actor)
{
this.skillTargetId = actor.get_handle().ObjID;
this.skillIndicator.SetSkillUsePosition(actor.get_handle());
}
else
{
this.skillIndicator.SetSkillUseDefaultPosition();
}
if (readySkillObj.AppointType == 1 && readySkillObj.cfgData.bSkillTargetRule != 2)
{
this.skillIndicator.SetGuildPrefabShow(false);
this.skillIndicator.SetGuildWarnPrefabShow(false);
this.skillIndicator.SetUseAdvanceMode(false);
this.skillIndicator.SetSkillUseDefaultPosition();
this.skillIndicator.SetEffectPrefabShow(false);
this.skillIndicator.SetFixedPrefabShow(true);
}
else
{
this.skillIndicator.SetGuildPrefabShow(true);
this.skillIndicator.SetGuildWarnPrefabShow(false);
this.skillIndicator.SetUseAdvanceMode(true);
}
}
private void ReadyUseSkillLockAttackMode(Skill readySkillObj)
{
uint dwSkillTargetFilter = 0;
SelectEnemyType selectLowHp = SelectEnemyType.SelectLowHp;
uint lockTargetID = this.Actor.handle.LockTargetAttackModeControl.GetLockTargetID();
if (!this.Actor.handle.LockTargetAttackModeControl.IsValidLockTargetID(lockTargetID))
{
Player ownerPlayer = ActorHelper.GetOwnerPlayer(ref this.Actor);
if (ownerPlayer != null)
{
selectLowHp = ownerPlayer.AttackTargetMode;
}
if (readySkillObj.AppointType == SkillRangeAppointType.Target)
{
lockTargetID = 0;
}
else
{
int iMaxAttackDistance = (int)readySkillObj.cfgData.iMaxAttackDistance;
dwSkillTargetFilter = readySkillObj.cfgData.dwSkillTargetFilter;
if (selectLowHp == SelectEnemyType.SelectLowHp)
{
lockTargetID = Singleton <AttackModeTargetSearcher> .GetInstance().SearchLowestHpTarget(ref this.Actor, iMaxAttackDistance, dwSkillTargetFilter);
}
else
{
lockTargetID = Singleton <AttackModeTargetSearcher> .GetInstance().SearchNearestTarget(ref this.Actor, iMaxAttackDistance, dwSkillTargetFilter);
}
}
}
PoolObjHandle <ActorRoot> actor = Singleton <GameObjMgr> .GetInstance().GetActor(lockTargetID);
if (actor != 0)
{
this.skillIndicator.SetSkillUsePosition(actor.handle);
}
else
{
this.skillIndicator.SetSkillUseDefaultPosition();
}
if ((readySkillObj.AppointType == SkillRangeAppointType.Target) && (readySkillObj.cfgData.dwSkillTargetRule != 2))
{
this.skillIndicator.SetGuildPrefabShow(false);
this.skillIndicator.SetGuildWarnPrefabShow(false);
this.skillIndicator.SetUseAdvanceMode(false);
this.skillIndicator.SetSkillUseDefaultPosition();
this.skillIndicator.SetEffectPrefabShow(false);
this.skillIndicator.SetFixedPrefabShow(true);
}
else
{
this.skillIndicator.SetGuildPrefabShow(true);
this.skillIndicator.SetGuildWarnPrefabShow(false);
this.skillIndicator.SetUseAdvanceMode(true);
}
}
public override uint SelectSkillTarget(SkillSlot _slot)
{
int iMaxSearchDistance = 0;
int dwSkillTargetFilter = 0;
ActorRoot useSkillTargetLockAttackMode = null;
uint lockTargetID = this.lockTargetID;
SelectEnemyType selectLowHp = SelectEnemyType.SelectLowHp;
Player ownerPlayer = ActorHelper.GetOwnerPlayer(ref this.actorPtr);
SkillSelectControl instance = Singleton <SkillSelectControl> .GetInstance();
Skill skill = (_slot.NextSkillObj == null) ? _slot.SkillObj : _slot.NextSkillObj;
if (skill.cfgData.dwSkillTargetRule == 2)
{
return(base.actor.ObjID);
}
useSkillTargetLockAttackMode = _slot.skillIndicator.GetUseSkillTargetLockAttackMode();
if (useSkillTargetLockAttackMode != null)
{
if (this.IsValidLockTargetID(useSkillTargetLockAttackMode.ObjID))
{
lockTargetID = useSkillTargetLockAttackMode.ObjID;
Singleton <NetLockAttackTarget> .GetInstance().SendLockAttackTarget(lockTargetID);
}
return(lockTargetID);
}
if (!this.IsValidLockTargetID(this.lockTargetID))
{
if (ownerPlayer != null)
{
selectLowHp = ownerPlayer.AttackTargetMode;
}
dwSkillTargetFilter = (int)skill.cfgData.dwSkillTargetFilter;
if (skill.AppointType == SkillRangeAppointType.Target)
{
iMaxSearchDistance = skill.cfgData.iMaxSearchDistance;
}
else
{
iMaxSearchDistance = (int)skill.cfgData.iMaxAttackDistance;
}
if (selectLowHp == SelectEnemyType.SelectLowHp)
{
lockTargetID = Singleton <AttackModeTargetSearcher> .GetInstance().SearchLowestHpTarget(ref this.actorPtr, iMaxSearchDistance, dwSkillTargetFilter);
}
else
{
lockTargetID = Singleton <AttackModeTargetSearcher> .GetInstance().SearchNearestTarget(ref this.actorPtr, iMaxSearchDistance, dwSkillTargetFilter);
}
if (this.IsValidLockTargetID(lockTargetID))
{
Singleton <NetLockAttackTarget> .GetInstance().SendLockAttackTarget(lockTargetID);
}
}
return(lockTargetID);
}
protected uint ExecuteSearchTarget(int srchR, ref bool bSearched)
{
PoolObjHandle <ActorRoot> poolObjHandle = this.actorPtr;
MonsterWrapper monsterWrapper = poolObjHandle.handle.ActorControl as MonsterWrapper;
if (monsterWrapper != null && monsterWrapper.isCalledMonster)
{
poolObjHandle = monsterWrapper.hostActor;
}
Player ownerPlayer = ActorHelper.GetOwnerPlayer(ref poolObjHandle);
if (ownerPlayer == null)
{
return(0u);
}
SelectEnemyType attackTargetMode = ownerPlayer.AttackTargetMode;
LastHitMode useLastHitMode = ownerPlayer.useLastHitMode;
AttackOrganMode curAttackOrganMode = ownerPlayer.curAttackOrganMode;
OperateMode operateMode = ownerPlayer.GetOperateMode();
uint result;
if (operateMode == OperateMode.LockMode)
{
result = this.NormalModeCommonAttackSearchTarget(srchR, attackTargetMode, ref bSearched);
}
else if (this.commonAttackButtonType == CommonAttackButtonType.CommonAttackButton)
{
if (useLastHitMode == LastHitMode.None && curAttackOrganMode == AttackOrganMode.None)
{
result = this.NormalModeCommonAttackSearchTarget(srchR, attackTargetMode, ref bSearched);
}
else
{
result = this.AdvancedModeCommonAttackSearchTarget(srchR, attackTargetMode, ref bSearched);
}
}
else if (this.commonAttackButtonType == CommonAttackButtonType.LastHitButton)
{
result = this.LastHitModeSearchTarget(srchR, attackTargetMode, ref bSearched);
}
else
{
result = this.AttackOrganModeSearchTarget(srchR, attackTargetMode, ref bSearched);
}
return(result);
}
static GameSettings()
{
GameSettings._EnableSound = true;
GameSettings._EnableMusic = true;
GameSettings.m_EnableVibrate = true;
GameSettings.DeviceLevel = SGameRenderQuality.Low;
GameSettings.m_dynamicParticleLOD = true;
GameSettings.cameraHeight = CameraHeightType.Medium;
GameSettings._castType = CastType.LunPanCast;
GameSettings._selectType = SelectEnemyType.SelectLowHp;
GameSettings.m_heroSelectHeroViewSortType = CMallSortHelper.HeroViewSortType.Name;
GameSettings.m_clickEnableInBattleInputChat = 1;
GameSettings.m_heroInfoEnable = true;
GameSettings.s_lunpanSensitivity = 1f;
GameSettings.m_MusicEffectLevel = 100f;
GameSettings.m_SoundEffectLevel = 100f;
GameSettings.m_VoiceEffectLevel = 100f;
}
protected override uint NormalModeCommonAttackSearchTarget(int srchR, SelectEnemyType type, ref bool bSearched)
{
uint num = this.lockTargetID;
if (base.IsValidTargetID(num))
{
bSearched = false;
return(num);
}
if (type == SelectEnemyType.SelectLowHp)
{
num = Singleton <AttackModeTargetSearcher> .GetInstance().SearchLowestHpTarget(ref this.actorPtr, srchR, 0u, true, SearchTargetPriority.CommonAttack);
}
else
{
num = Singleton <AttackModeTargetSearcher> .GetInstance().SearchNearestTarget(ref this.actorPtr, srchR, 0u, true, SearchTargetPriority.CommonAttack);
}
bSearched = true;
return(num);
}
public void OnHandleClickSelectTargetBtn(AttackTargetType _targetType)
{
if (_targetType != this.m_TargetType)
{
this.m_CurSelectedActor.Release();
}
SelectEnemyType selectLowHp = SelectEnemyType.SelectLowHp;
Player hostPlayer = Singleton <GamePlayerCenter> .instance.GetHostPlayer();
if (hostPlayer != null)
{
selectLowHp = hostPlayer.AttackTargetMode;
}
uint selectTargetByTag = 0;
selectTargetByTag = this.GetSelectTargetByTag(_targetType, selectLowHp);
Singleton <NetLockAttackTarget> .GetInstance().SendLockAttackTarget(selectTargetByTag);
this.m_TargetType = _targetType;
}
public override uint CommonAttackSearchEnemy(int srchR)
{
SkillCache skillUseCache = null;
SelectEnemyType selectLowHp = SelectEnemyType.SelectLowHp;
uint commonAttackTargetID = this.commonAttackTargetID;
Player ownerPlayer = ActorHelper.GetOwnerPlayer(ref this.actorPtr);
if (ownerPlayer != null)
{
if (base.IsValidTargetID(commonAttackTargetID))
{
this.SetCommonAttackTarget(commonAttackTargetID);
return(commonAttackTargetID);
}
selectLowHp = ownerPlayer.AttackTargetMode;
}
if (selectLowHp == SelectEnemyType.SelectLowHp)
{
commonAttackTargetID = Singleton <CommonAttackSearcher> .GetInstance().CommonAttackSearchLowestHpTarget(base.actor.ActorControl, srchR);
}
else
{
commonAttackTargetID = Singleton <CommonAttackSearcher> .GetInstance().CommonAttackSearchNearestTarget(base.actor.ActorControl, srchR);
}
if (!base.IsValidTargetID(commonAttackTargetID))
{
skillUseCache = base.actor.ActorControl.actor.SkillControl.SkillUseCache;
if ((skillUseCache != null) && !skillUseCache.GetSpecialCommonAttack())
{
this.CancelCommonAttackMode();
commonAttackTargetID = 0;
}
}
if (commonAttackTargetID == 0)
{
this.ClearCommonAttackTarget();
return(commonAttackTargetID);
}
this.SetCommonAttackTarget(commonAttackTargetID);
return(commonAttackTargetID);
}
protected override uint NormalModeCommonAttackSearchTarget(int srchR, SelectEnemyType type, ref bool bSearched)
{
uint num = this.commonAttackTargetID;
if (base.IsValidTargetID(num))
{
this.SetCommonAttackTarget(num, false);
bSearched = false;
return(num);
}
if (type == SelectEnemyType.SelectLowHp)
{
num = Singleton <CommonAttackSearcher> .GetInstance().CommonAttackSearchLowestHpTarget(this.actor.ActorControl, srchR);
}
else
{
num = Singleton <CommonAttackSearcher> .GetInstance().CommonAttackSearchNearestTarget(this.actor.ActorControl, srchR);
}
bSearched = true;
return(num);
}
private void SortActorListByTag(PoolObjHandle <ActorRoot> InActor, ref List <ActorRoot> actorList, SelectEnemyType type)
{
if (actorList.get_Count() <= 1)
{
return;
}
int count = actorList.get_Count();
ulong[] array = new ulong[count];
if (type == SelectEnemyType.SelectLowHp)
{
array[0] = TargetProperty.GetPropertyHpRate(actorList.get_Item(0), RES_FUNCEFT_TYPE.RES_FUNCEFT_MAXHP);
}
else
{
array[0] = (ulong)(InActor.handle.location - actorList.get_Item(0).location).sqrMagnitudeLong2D;
}
for (int i = 1; i < count; i++)
{
ActorRoot actorRoot = actorList.get_Item(i);
ulong num;
if (type == SelectEnemyType.SelectLowHp)
{
num = TargetProperty.GetPropertyHpRate(actorRoot, RES_FUNCEFT_TYPE.RES_FUNCEFT_MAXHP);
}
else
{
num = (ulong)(InActor.handle.location - actorList.get_Item(0).location).sqrMagnitudeLong2D;
}
array[i] = num;
int j;
for (j = i; j >= 1; j--)
{
if (num >= array[j - 1])
{
break;
}
array[j] = array[j - 1];
actorList.set_Item(j, actorList.get_Item(j - 1));
}
array[j] = num;
actorList.set_Item(j, actorRoot);
}
}
private ActorRoot GetLowerValueTargetByTag(PoolObjHandle <ActorRoot> InActor, List <ActorRoot> actorList, SelectEnemyType type)
{
int count = actorList.Count;
if (count <= 0)
{
return(null);
}
if (count > 1)
{
int num2 = 0;
while (num2 < count)
{
if (actorList[num2].SelfPtr == InActor)
{
break;
}
num2++;
}
if (num2 < (count - 1))
{
return(actorList[num2 + 1]);
}
}
return(actorList[0]);
}
private void SortActorListByTag(PoolObjHandle <ActorRoot> InActor, ref List <ActorRoot> actorList, SelectEnemyType type)
{
if (actorList.Count > 1)
{
int count = actorList.Count;
ulong[] numArray = new ulong[count];
if (type == SelectEnemyType.SelectLowHp)
{
numArray[0] = TargetProperty.GetPropertyHpRate(actorList[0], RES_FUNCEFT_TYPE.RES_FUNCEFT_MAXHP);
}
else
{
VInt3 num5 = InActor.handle.location - actorList[0].location;
numArray[0] = (ulong)num5.sqrMagnitudeLong2D;
}
ulong propertyHpRate = 0L;
for (int i = 1; i < count; i++)
{
ActorRoot root = actorList[i];
if (type == SelectEnemyType.SelectLowHp)
{
propertyHpRate = TargetProperty.GetPropertyHpRate(root, RES_FUNCEFT_TYPE.RES_FUNCEFT_MAXHP);
}
else
{
VInt3 num6 = InActor.handle.location - actorList[0].location;
propertyHpRate = (ulong)num6.sqrMagnitudeLong2D;
}
numArray[i] = propertyHpRate;
int index = i;
while (index >= 1)
{
if (propertyHpRate >= numArray[index - 1])
{
break;
}
numArray[index] = numArray[index - 1];
actorList[index] = actorList[index - 1];
index--;
}
numArray[index] = propertyHpRate;
actorList[index] = root;
}
}
}
private uint GetLowerValueTargetIdByTag(PoolObjHandle <ActorRoot> InActor, List <ActorRoot> actorList, SelectEnemyType type)
{
ActorRoot root = null;
int count = actorList.Count;
if (count > 0)
{
if (count == 1)
{
root = actorList[0];
}
else if (this.m_CurSelectedActor != 0)
{
root = this.GetLowerValueTargetByTag(this.m_CurSelectedActor, actorList, type);
}
else
{
root = actorList[0];
}
}
if (root != null)
{
this.m_CurSelectedActor = root.SelfPtr;
return(root.ObjID);
}
return(0);
}
protected virtual uint AttackOrganModeSearchTarget(int srchR, SelectEnemyType type, ref bool bSearched)
{
return(0u);
}
protected virtual uint LastHitModeSearchTarget(int srchR, SelectEnemyType type, ref bool bSearched)
{
return(0u);
}
protected virtual uint AdvancedModeCommonAttackSearchTarget(int srchR, SelectEnemyType type, ref bool bSearched)
{
return(0u);
}
private ActorRoot GetLowerValueTargetByTag(PoolObjHandle <ActorRoot> InActor, List <ActorRoot> actorList, SelectEnemyType type)
{
int count = actorList.get_Count();
if (count <= 0)
{
return(null);
}
if (count <= 1)
{
return(actorList.get_Item(0));
}
int i;
for (i = 0; i < count; i++)
{
if (actorList.get_Item(i).SelfPtr == InActor)
{
break;
}
}
ActorRoot result;
if (i < count - 1)
{
result = actorList.get_Item(i + 1);
}
else
{
result = actorList.get_Item(0);
}
return(result);
}
private uint GetSelectTargetByTag(AttackTargetType targetType, SelectEnemyType selectType)
{
List <ActorRoot> actorList = new List <ActorRoot>();
List <ActorRoot> list2 = new List <ActorRoot>();
List <ActorRoot> list3 = new List <ActorRoot>();
List <ActorRoot> list4 = new List <ActorRoot>();
Player hostPlayer = Singleton <GamePlayerCenter> .instance.GetHostPlayer();
if ((hostPlayer == null) || (hostPlayer.Captain == 0))
{
return(0);
}
PoolObjHandle <ActorRoot> captain = hostPlayer.Captain;
List <PoolObjHandle <ActorRoot> > gameActors = Singleton <GameObjMgr> .GetInstance().GameActors;
int count = gameActors.Count;
for (int i = 0; i < count; i++)
{
PoolObjHandle <ActorRoot> handle2 = gameActors[i];
ActorRoot handle = handle2.handle;
if (handle.HorizonMarker.IsVisibleFor(captain.handle.TheActorMeta.ActorCamp) && captain.handle.CanAttack(handle))
{
if (targetType == AttackTargetType.ATTACK_TARGET_HERO)
{
if (TypeSearchCondition.Fit(handle, ActorTypeDef.Actor_Type_Hero) && DistanceSearchCondition.Fit(handle, (ActorRoot)captain, captain.handle.ActorControl.SearchRange))
{
actorList.Add(handle);
}
}
else if (TypeSearchCondition.Fit(handle, ActorTypeDef.Actor_Type_Organ))
{
if (DistanceSearchCondition.Fit(handle, (ActorRoot)captain, captain.handle.ActorControl.SearchRange))
{
list4.Add(handle);
}
}
else if (TypeSearchCondition.Fit(handle, ActorTypeDef.Actor_Type_Monster) && DistanceSearchCondition.Fit(handle, (ActorRoot)captain, captain.handle.ActorControl.SearchRange))
{
MonsterWrapper wrapper = handle.AsMonster();
if (((wrapper.cfgInfo.bSoldierType == 7) || (wrapper.cfgInfo.bSoldierType == 8)) || (wrapper.cfgInfo.bSoldierType == 9))
{
list3.Add(handle);
}
else
{
list2.Add(handle);
}
}
}
}
if (targetType == AttackTargetType.ATTACK_TARGET_HERO)
{
this.SortActorListByTag(captain, ref actorList, selectType);
return(this.GetLowerValueTargetIdByTag(captain, actorList, selectType));
}
this.SortActorListByTag(captain, ref list3, selectType);
this.SortActorListByTag(captain, ref list2, selectType);
this.SortActorListByTag(captain, ref list4, selectType);
List <ActorRoot> list6 = new List <ActorRoot>();
int num4 = 0;
for (num4 = 0; num4 < list3.Count; num4++)
{
list6.Add(list3[num4]);
}
for (num4 = 0; num4 < list2.Count; num4++)
{
list6.Add(list2[num4]);
}
for (num4 = 0; num4 < list4.Count; num4++)
{
list6.Add(list4[num4]);
}
return(this.GetLowerValueTargetIdByTag(captain, list6, selectType));
}
private uint GetLowerValueTargetIdByTag(PoolObjHandle <ActorRoot> InActor, List <ActorRoot> actorList, SelectEnemyType type)
{
ActorRoot actorRoot = null;
int count = actorList.get_Count();
if (count > 0)
{
if (count == 1)
{
actorRoot = actorList.get_Item(0);
}
else if (this.m_CurSelectedActor)
{
actorRoot = this.GetLowerValueTargetByTag(this.m_CurSelectedActor, actorList, type);
}
else
{
actorRoot = actorList.get_Item(0);
}
}
if (actorRoot != null)
{
this.m_CurSelectedActor = actorRoot.SelfPtr;
return(actorRoot.ObjID);
}
return(0u);
}
private uint GetSelectTargetByTag(AttackTargetType targetType, SelectEnemyType selectType)
{
List <ActorRoot> list = new List <ActorRoot>();
List <ActorRoot> list2 = new List <ActorRoot>();
List <ActorRoot> list3 = new List <ActorRoot>();
List <ActorRoot> list4 = new List <ActorRoot>();
Player hostPlayer = Singleton <GamePlayerCenter> .instance.GetHostPlayer();
if (hostPlayer == null || !hostPlayer.Captain)
{
return(0u);
}
PoolObjHandle <ActorRoot> captain = hostPlayer.Captain;
List <PoolObjHandle <ActorRoot> > gameActors = Singleton <GameObjMgr> .GetInstance().GameActors;
int count = gameActors.get_Count();
for (int i = 0; i < count; i++)
{
ActorRoot handle = gameActors.get_Item(i).handle;
if (handle.HorizonMarker.IsVisibleFor(captain.handle.TheActorMeta.ActorCamp) && captain.handle.CanAttack(handle))
{
if (targetType == AttackTargetType.ATTACK_TARGET_HERO)
{
if (TypeSearchCondition.Fit(handle, ActorTypeDef.Actor_Type_Hero) && DistanceSearchCondition.Fit(handle, captain, captain.handle.ActorControl.SearchRange))
{
list.Add(handle);
}
}
else if (TypeSearchCondition.Fit(handle, ActorTypeDef.Actor_Type_Organ))
{
if (DistanceSearchCondition.Fit(handle, captain, captain.handle.ActorControl.SearchRange))
{
list4.Add(handle);
}
}
else if (TypeSearchCondition.Fit(handle, ActorTypeDef.Actor_Type_Monster) && DistanceSearchCondition.Fit(handle, captain, captain.handle.ActorControl.SearchRange))
{
MonsterWrapper monsterWrapper = handle.AsMonster();
if (monsterWrapper.cfgInfo.bSoldierType == 7 || monsterWrapper.cfgInfo.bSoldierType == 8 || monsterWrapper.cfgInfo.bSoldierType == 9)
{
list3.Add(handle);
}
else
{
list2.Add(handle);
}
}
}
}
uint lowerValueTargetIdByTag;
if (targetType == AttackTargetType.ATTACK_TARGET_HERO)
{
this.SortActorListByTag(captain, ref list, selectType);
lowerValueTargetIdByTag = this.GetLowerValueTargetIdByTag(captain, list, selectType);
}
else
{
this.SortActorListByTag(captain, ref list3, selectType);
this.SortActorListByTag(captain, ref list2, selectType);
this.SortActorListByTag(captain, ref list4, selectType);
List <ActorRoot> list5 = new List <ActorRoot>();
for (int j = 0; j < list3.get_Count(); j++)
{
list5.Add(list3.get_Item(j));
}
for (int k = 0; k < list2.get_Count(); k++)
{
list5.Add(list2.get_Item(k));
}
for (int l = 0; l < list4.get_Count(); l++)
{
list5.Add(list4.get_Item(l));
}
lowerValueTargetIdByTag = this.GetLowerValueTargetIdByTag(captain, list5, selectType);
}
return(lowerValueTargetIdByTag);
}
