private IEnumerator PlaySkill(AffectEffectProperty affectEffectProperty, List <CharacterStateControl> targetList)
{
SubStatePlayHitAnimationAction.Data data = new SubStatePlayHitAnimationAction.Data();
foreach (CharacterStateControl characterStateControl in targetList)
{
if (!characterStateControl.isDied)
{
SkillResults skillResults;
if (AffectEffectProperty.IsDamage(affectEffectProperty.type))
{
skillResults = SkillStatus.GetStageDamageSkillResult(affectEffectProperty, null, characterStateControl);
if (!skillResults.onMissHit)
{
if (characterStateControl.currentSufferState.FindSufferState(SufferStateProperty.SufferType.CountBarrier))
{
this.sufferStatePropertyCounter.AddCountDictionary(SufferStateProperty.SufferType.CountBarrier, characterStateControl, null);
}
else if (characterStateControl.currentSufferState.FindSufferState(SufferStateProperty.SufferType.CountEvasion))
{
this.sufferStatePropertyCounter.AddCountDictionary(SufferStateProperty.SufferType.CountEvasion, characterStateControl, null);
}
else if (skillResults.isGuard)
{
this.sufferStatePropertyCounter.AddCountDictionary(SufferStateProperty.SufferType.CountGuard, characterStateControl, skillResults.damageRateResult.dataList.Select((SufferStateProperty.Data item) => item.id).ToArray <string>());
}
}
}
else if (Tolerance.OnInfluenceToleranceAffectEffect(affectEffectProperty.type))
{
skillResults = base.stateManager.skillDetails.GetToleranceSkillResult(affectEffectProperty, null, characterStateControl);
if (!skillResults.onMissHit)
{
if (characterStateControl.currentSufferState.FindSufferState(SufferStateProperty.SufferType.CountBarrier))
{
this.sufferStatePropertyCounter.AddCountDictionary(SufferStateProperty.SufferType.CountBarrier, characterStateControl, null);
}
else if (characterStateControl.currentSufferState.FindSufferState(SufferStateProperty.SufferType.CountEvasion))
{
this.sufferStatePropertyCounter.AddCountDictionary(SufferStateProperty.SufferType.CountEvasion, characterStateControl, null);
}
}
}
else
{
skillResults = base.stateManager.skillDetails.GetOtherSkillResult(affectEffectProperty, null, characterStateControl);
}
data.AddHitIcon(characterStateControl, skillResults.hitIconAffectEffect, skillResults.attackPower, skillResults.onWeakHit, skillResults.onMissHit, skillResults.onCriticalHit, false, false, false, skillResults.extraEffectType);
}
}
data.time = base.stateManager.stateProperty.multiHitIntervalWaitSecond;
data.affectEffectProperty = affectEffectProperty;
data.cameraKey = this.cameraKey;
this.subStatePlayHitAnimationAction.Init(data);
base.SetState(this.subStatePlayHitAnimationAction.GetType());
while (base.isWaitState)
{
yield return(null);
}
yield break;
}
private static bool CheckSkillAttribute(AffectEffectProperty skillEffect, bool isPublicAttack, string targetSubType, string targetValue, string targetValue2, string effectTriggerValue)
{
if (effectTriggerValue.ToInt32() == 0)
{
return(true);
}
if (targetSubType.ToInt32() != 9)
{
global::Attribute attribute = ServerToBattleUtility.IntToAttribute(effectTriggerValue.ToInt32());
return(skillEffect.attribute == attribute);
}
global::Attribute attribute2 = ServerToBattleUtility.IntToAttribute(targetValue.ToInt32());
bool flag = skillEffect.attribute == attribute2;
if (targetValue2 == "0")
{
return(flag);
}
if (targetValue2 == "1")
{
return(flag && isPublicAttack);
}
if (targetValue2 == "2")
{
return(flag && !isPublicAttack);
}
return(flag);
}
public void AddAffectEffect(AffectEffectProperty addAffectEffect)
{
this._addAffectEffect.Add(addAffectEffect);
this._returnAffectEffect.Clear();
this._returnAffectEffect.AddRange(this._affectEffect);
this._returnAffectEffect.AddRange(this._addAffectEffect);
}
private static CharacterStateControl[] GetTargets(CharacterStateControl actor, AffectEffectProperty skillEffect)
{
List <CharacterStateControl> list = new List <CharacterStateControl>();
if (actor == null || skillEffect == null)
{
return(list.ToArray());
}
CharacterStateControl[] skillTargetList = BattleStateManager.current.targetSelect.GetSkillTargetList(actor, skillEffect.target);
if (skillTargetList.Length == 0)
{
return(list.ToArray());
}
if (skillEffect.effectNumbers == EffectNumbers.Simple)
{
if (skillTargetList.Where((CharacterStateControl item) => item == actor.targetCharacter).Any <CharacterStateControl>())
{
list.Add(actor.targetCharacter);
}
else
{
list.Add(skillTargetList[0]);
}
}
else
{
list.AddRange(skillTargetList);
}
return(list.ToArray());
}
private IEnumerator PlaySkill(SkillStatus status, List <CharacterStateControl> targetList)
{
foreach (CharacterStateControl characterStateControl in this.GetTotalCharacters())
{
characterStateControl.OnChipTrigger(EffectStatusBase.EffectTriggerType.DamagePossibility);
}
foreach (AffectEffectProperty affectEffectProperty in status.affectEffect)
{
int hitNumber = 1;
if (AffectEffectProperty.IsDamage(affectEffectProperty.type))
{
hitNumber = affectEffectProperty.hitNumber;
}
for (int i = 0; i < hitNumber; i++)
{
IEnumerator playSkill = this.PlaySkill(affectEffectProperty, targetList);
while (playSkill.MoveNext())
{
yield return(null);
}
}
}
foreach (CharacterStateControl characterStateControl2 in this.GetTotalCharacters())
{
characterStateControl2.ClearGutsData();
}
this.sufferStatePropertyCounter.UpdateCount(SufferStateProperty.SufferType.CountGuard, null);
this.sufferStatePropertyCounter.UpdateCount(SufferStateProperty.SufferType.CountBarrier, null);
this.sufferStatePropertyCounter.UpdateCount(SufferStateProperty.SufferType.CountEvasion, null);
yield break;
}
private int HpSettingPercentage(CharacterStateControl target, AffectEffectProperty affectEffectProperty)
{
int num = Mathf.FloorToInt((float)target.extraMaxHp * affectEffectProperty.revivalPercent);
int result = num - target.hp;
target.hp = num;
return(result);
}
public SkillResults GetToleranceSkillResult(AffectEffectProperty affectEffectProperty, CharacterStateControl attackerCharacter, CharacterStateControl targetCharacter)
{
SkillResults skillResults = new SkillResults();
skillResults.useAffectEffectProperty = affectEffectProperty;
skillResults.hitIconAffectEffect = affectEffectProperty.type;
skillResults.attackCharacter = attackerCharacter;
skillResults.targetCharacter = targetCharacter;
if (!affectEffectProperty.OnHit(attackerCharacter, targetCharacter))
{
skillResults.onMissHit = true;
return(skillResults);
}
Strength affectEffectStrength = targetCharacter.tolerance.GetAffectEffectStrength(affectEffectProperty.type);
if (affectEffectStrength == Strength.Invalid)
{
skillResults.hitIconAffectEffect = AffectEffect.Invalid;
skillResults.onWeakHit = Strength.Invalid;
skillResults.onMissHit = false;
}
else if (targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.TurnBarrier))
{
skillResults.hitIconAffectEffect = AffectEffect.TurnBarrier;
skillResults.onWeakHit = Strength.None;
skillResults.onMissHit = false;
}
else if (targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.CountBarrier))
{
skillResults.hitIconAffectEffect = AffectEffect.CountBarrier;
skillResults.onWeakHit = Strength.None;
skillResults.onMissHit = false;
}
else if (targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.TurnEvasion))
{
skillResults.hitIconAffectEffect = AffectEffect.TurnEvasion;
skillResults.onWeakHit = Strength.None;
skillResults.onMissHit = false;
}
else if (targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.CountEvasion))
{
skillResults.hitIconAffectEffect = AffectEffect.CountEvasion;
skillResults.onWeakHit = Strength.None;
skillResults.onMissHit = false;
}
else
{
skillResults.hitIconAffectEffect = affectEffectProperty.type;
skillResults.onWeakHit = Strength.None;
skillResults.onMissHit = false;
if (affectEffectProperty.type == AffectEffect.Stun)
{
targetCharacter.currentSufferState.RemoveSufferState(SufferStateProperty.SufferType.Escape, false);
}
this.AddSufferStateOthers(targetCharacter, affectEffectProperty);
}
return(skillResults);
}
private int HpSettingFixable(CharacterStateControl target, AffectEffectProperty affectEffectProperty)
{
int num = affectEffectProperty.revivalPower;
num = Mathf.Min(num, target.extraMaxHp);
int result = num - target.hp;
target.hp = num;
return(result);
}
private HitEffectParams[] GetHitEffectParams()
{
List <HitEffectParams> list = new List <HitEffectParams>();
string[] array = new string[]
{
"EFF_COM_HIT_NORMAL",
"EFF_COM_HIT_WEAK",
"EFF_COM_HIT_CRITICAL",
"EFF_COM_S_HEAL",
"EFF_COM_HIT_WEAK"
};
for (int i = 0; i < this.data.hitIconList.Count; i++)
{
if (this.data.hitIconList[i].affectEffect == AffectEffect.Invalid)
{
HitEffectParams item = BattleEffectManager.Instance.GetEffect("EFF_COM_HIT_WEAK") as HitEffectParams;
list.Add(item);
}
else if (AffectEffectProperty.IsDamage(this.data.hitIconList[i].affectEffect))
{
if (this.data.hitIconList[i].isMiss)
{
HitEffectParams item2 = BattleEffectManager.Instance.GetEffect(array[0]) as HitEffectParams;
list.Add(item2);
}
else if (!base.stateManager.onEnableTutorial && this.data.hitIconList[i].extraEffectType == ExtraEffectType.Up)
{
HitEffectParams item3 = BattleEffectManager.Instance.GetEffect(AffectEffect.gimmickSpecialAttackUp.ToString()) as HitEffectParams;
list.Add(item3);
}
else if (!base.stateManager.onEnableTutorial && this.data.hitIconList[i].extraEffectType == ExtraEffectType.Down)
{
HitEffectParams item4 = BattleEffectManager.Instance.GetEffect(AffectEffect.gimmickSpecialAttackDown.ToString()) as HitEffectParams;
list.Add(item4);
}
else
{
HitEffectParams item5 = BattleEffectManager.Instance.GetEffect(array[(int)this.data.hitIconList[i].strength]) as HitEffectParams;
list.Add(item5);
}
}
else
{
HitEffectParams item6 = BattleEffectManager.Instance.GetEffect(this.data.hitIconList[i].affectEffect.ToString()) as HitEffectParams;
list.Add(item6);
}
}
return(list.ToArray());
}
private void ApUp(CharacterStateControl target, AffectEffectProperty affectEffectProperty)
{
int num;
if (affectEffectProperty.powerType == PowerType.Fixable)
{
num = affectEffectProperty.upPower;
}
else
{
num = Mathf.FloorToInt((float)target.maxAp * affectEffectProperty.upPercent);
}
target.ap += num;
}
private void ShowAttributeTolerance(HitIcon.Data data, AffectEffectProperty affectEffectProperty, bool up)
{
int num = 0;
float num2 = 0f;
string text = "HitIconAttributeToleranceUp";
string text2 = "HitIconStateToleranceUp";
string text3 = "HitIconAttributeToleranceDown";
string text4 = "HitIconStateToleranceDown";
for (int i = 0; i < affectEffectProperty.toleranceValue.Length; i++)
{
if (affectEffectProperty.toleranceValue[i] > 0f)
{
num = i;
num2 = affectEffectProperty.toleranceValue[i];
break;
}
}
if (num2 == 100f)
{
if (num <= 6)
{
data.middleMesh.text = this.GetString("HitIconAttributeAbsorption");
}
}
else if (num2 == 101f)
{
if (num <= 6)
{
data.middleMesh.text = this.GetString("HitIconInvalidAttribute");
}
else if (num > 6 && num < 100)
{
data.middleMesh.text = this.GetString("HitIconInvalidState");
}
}
else if (num <= 6)
{
data.middleMesh.text = this.GetString((!up) ? text3 : text);
}
else if (num > 6 && num < 100)
{
data.middleMesh.text = this.GetString((!up) ? text4 : text2);
}
this.ChangeFontTexture((!up) ? this.standardEffectFontTexture.blue : this.standardEffectFontTexture.red, new TextMeshPro[]
{
data.middleMesh
});
}
private int HpRevival(CharacterStateControl target, AffectEffectProperty affectEffectProperty)
{
int num;
if (affectEffectProperty.powerType == PowerType.Fixable)
{
num = affectEffectProperty.revivalPower;
}
else
{
num = Mathf.FloorToInt((float)target.extraMaxHp * affectEffectProperty.revivalPercent);
}
target.hp += num;
return(num);
}
public int GetHate()
{
if (AffectEffectProperty.IsDamage(this.type))
{
return(20);
}
if (Tolerance.OnInfluenceToleranceAffectEffect(this.type))
{
return(10);
}
if (this.type == AffectEffect.HpRevival || this.type == AffectEffect.Regenerate)
{
return(15);
}
return(5);
}
public SufferStateProperty.DamageRateResult GetCaseDamageRate(AffectEffectProperty affectEffectProperty, CharacterStateControl characterStateControl)
{
SufferStateProperty.DamageRateResult damageRateResult = new SufferStateProperty.DamageRateResult();
bool flag = affectEffectProperty.skillId.ToString() == BattleStateManager.PublicAttackSkillId;
foreach (List <SufferStateProperty.Data> list in this.dataDictionary.Values)
{
foreach (SufferStateProperty.Data data in list)
{
if (data.isActive)
{
if (data.recieveSkillType == 0 || (data.recieveSkillType == 1 && flag) || (data.recieveSkillType == 2 && !flag))
{
bool flag2 = data.recieveSkillTargetSubType == 1;
bool flag3 = data.recieveSkillTargetSubType == 2;
float[] array = new float[]
{
data.damagePercent,
data.damageRateForPhantomStudents,
data.damageRateForHeatHaze,
data.damageRateForGlacier,
data.damageRateForElectromagnetic,
data.damageRateForEarth,
data.damageRateForShaftOfLight,
data.damageRateForAbyss
};
int num = 0;
if (flag2)
{
num = (int)(affectEffectProperty.attribute + 1);
}
else if (flag3)
{
num = ((!(characterStateControl != null)) ? 0 : characterStateControl.characterDatas.tribe.ToInt32());
}
damageRateResult.damageRate += ((!affectEffectProperty.canUseAttribute) ? 0f : array[num]);
if (array[num] != 0f)
{
damageRateResult.dataList.Add(data);
}
}
}
}
}
return(damageRateResult);
}
public SkillResults GetDestructTargetSkillResult(AffectEffectProperty affectEffectProperty, CharacterStateControl attackerCharacter, CharacterStateControl targetCharacter)
{
SkillResults skillResults = new SkillResults();
skillResults.useAffectEffectProperty = affectEffectProperty;
skillResults.hitIconAffectEffect = affectEffectProperty.type;
skillResults.attackCharacter = attackerCharacter;
skillResults.targetCharacter = targetCharacter;
if (!affectEffectProperty.OnHit(attackerCharacter, targetCharacter))
{
skillResults.onMissHit = true;
return(skillResults);
}
targetCharacter.OnHitDestruct();
skillResults.onMissHit = false;
return(skillResults);
}
private void ClearTolerance(CharacterStateControl target, AffectEffectProperty affectEffectProperty)
{
Dictionary <SufferStateProperty.SufferType, float> dictionary = null;
if (affectEffectProperty.toleranceClearType == 0)
{
dictionary = new Dictionary <SufferStateProperty.SufferType, float>
{
{
SufferStateProperty.SufferType.ChangeToleranceUp,
affectEffectProperty.clearPoisonIncidenceRate
},
{
SufferStateProperty.SufferType.ChangeToleranceDown,
affectEffectProperty.clearPoisonIncidenceRate
}
};
}
else if (affectEffectProperty.toleranceClearType == 73)
{
dictionary = new Dictionary <SufferStateProperty.SufferType, float>
{
{
SufferStateProperty.SufferType.ChangeToleranceUp,
affectEffectProperty.clearPoisonIncidenceRate
}
};
}
else if (affectEffectProperty.toleranceClearType == 74)
{
dictionary = new Dictionary <SufferStateProperty.SufferType, float>
{
{
SufferStateProperty.SufferType.ChangeToleranceDown,
affectEffectProperty.clearPoisonIncidenceRate
}
};
}
foreach (KeyValuePair <SufferStateProperty.SufferType, float> keyValuePair in dictionary)
{
if (RandomExtension.Switch(keyValuePair.Value) && target.currentSufferState.FindSufferState(keyValuePair.Key))
{
target.currentSufferState.RemoveSufferState(keyValuePair.Key, false);
}
}
}
private void GetSkillDetailViewData(out GameWebAPI.RespDataMA_GetSkillDetailM.SkillDetailM dest, List <GameWebAPI.RespDataMA_GetSkillDetailM.SkillDetailM> source)
{
dest = null;
for (int i = 0; i < source.Count; i++)
{
if (dest == null)
{
dest = source[i];
}
AffectEffect affectEffect = ServerToBattleUtility.IntToAffectEffect(source[i].effectType);
if (AffectEffectProperty.IsDamage(affectEffect))
{
dest = source[i];
break;
}
}
}
public SkillResults GetApDrainSkillResult(AffectEffectProperty affectEffectProperty, CharacterStateControl attackerCharacter, CharacterStateControl targetCharacter)
{
SkillResults skillResults = new SkillResults();
skillResults.useAffectEffectProperty = affectEffectProperty;
skillResults.hitIconAffectEffect = affectEffectProperty.type;
skillResults.attackCharacter = attackerCharacter;
skillResults.targetCharacter = targetCharacter;
if (!affectEffectProperty.OnHit(attackerCharacter, targetCharacter))
{
skillResults.onMissHit = true;
return(skillResults);
}
if (targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.TurnBarrier))
{
skillResults.hitIconAffectEffect = AffectEffect.TurnBarrier;
skillResults.onMissHit = false;
}
else if (targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.CountBarrier))
{
skillResults.hitIconAffectEffect = AffectEffect.CountBarrier;
skillResults.onMissHit = false;
}
else if (targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.TurnEvasion))
{
skillResults.hitIconAffectEffect = AffectEffect.TurnEvasion;
skillResults.onMissHit = false;
}
else if (targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.CountEvasion))
{
skillResults.hitIconAffectEffect = AffectEffect.CountEvasion;
skillResults.onMissHit = false;
}
else
{
skillResults.hitIconAffectEffect = AffectEffect.ApDown;
skillResults.onMissHit = false;
int ap = targetCharacter.ap;
targetCharacter.ap -= affectEffectProperty.apDrainPower;
skillResults.attackPower = ap - targetCharacter.ap;
}
return(skillResults);
}
public void InitializeSkillExtraStatus()
{
List <ExtraEffectStatus> extraEffectStatus = BattleStateManager.current.battleStateData.extraEffectStatus;
List <ExtraEffectStatus> invocationList = ExtraEffectStatus.GetInvocationList(extraEffectStatus, EffectStatusBase.EffectTriggerType.Usually);
if (this.skillStatus.Length > 1)
{
AffectEffectProperty affectEffectFirst = this.skillStatus[1].GetAffectEffectFirst();
if (affectEffectFirst != null)
{
if (AffectEffectProperty.IsDamage(affectEffectFirst.type))
{
this.m_extraDeathblowSkillPower = ExtraEffectStatus.GetSkillPowerCorrectionValue(invocationList, affectEffectFirst, this);
}
this.m_extraDeathblowSkillHitRate = ExtraEffectStatus.GetSkillHitRateCorrectionValue(invocationList, affectEffectFirst, this);
}
}
if (this.skillStatus.Length > 2)
{
AffectEffectProperty affectEffectFirst2 = this.skillStatus[2].GetAffectEffectFirst();
if (affectEffectFirst2 != null)
{
if (AffectEffectProperty.IsDamage(affectEffectFirst2.type))
{
this.m_extraInheritanceSkillPower = ExtraEffectStatus.GetSkillPowerCorrectionValue(invocationList, affectEffectFirst2, this);
}
this.m_extraInheritanceSkillHitRate = ExtraEffectStatus.GetSkillHitRateCorrectionValue(invocationList, affectEffectFirst2, this);
}
}
if (this.skillStatus.Length > 3)
{
AffectEffectProperty affectEffectFirst3 = this.skillStatus[3].GetAffectEffectFirst();
if (affectEffectFirst3 != null)
{
if (AffectEffectProperty.IsDamage(affectEffectFirst3.type))
{
this.m_extraInheritanceSkillPower2 = ExtraEffectStatus.GetSkillPowerCorrectionValue(invocationList, affectEffectFirst3, this);
}
this.m_extraInheritanceSkillHitRate2 = ExtraEffectStatus.GetSkillHitRateCorrectionValue(invocationList, affectEffectFirst3, this);
}
}
}
private void SufferStatusClear(CharacterStateControl target, AffectEffectProperty affectEffectProperty)
{
Dictionary <SufferStateProperty.SufferType, float> dictionary = new Dictionary <SufferStateProperty.SufferType, float>
{
{
SufferStateProperty.SufferType.Poison,
affectEffectProperty.clearPoisonIncidenceRate
},
{
SufferStateProperty.SufferType.Confusion,
affectEffectProperty.clearConfusionIncidenceRate
},
{
SufferStateProperty.SufferType.Paralysis,
affectEffectProperty.clearParalysisIncidenceRate
},
{
SufferStateProperty.SufferType.Sleep,
affectEffectProperty.clearSleepIncidenceRate
},
{
SufferStateProperty.SufferType.Stun,
affectEffectProperty.clearStunIncidenceRate
},
{
SufferStateProperty.SufferType.SkillLock,
affectEffectProperty.clearSkillLockIncidenceRate
}
};
foreach (KeyValuePair <SufferStateProperty.SufferType, float> keyValuePair in dictionary)
{
if (RandomExtension.Switch(keyValuePair.Value) && target.currentSufferState.FindSufferState(keyValuePair.Key))
{
target.currentSufferState.RemoveSufferState(keyValuePair.Key, false);
}
}
}
private static SufferStateProperty.DamageRateResult GetReduceDamageRate(AffectEffectProperty affectEffectProperty, CharacterStateControl attackerCharacter, CharacterStateControl targetCharacter)
{
HaveSufferState currentSufferState = targetCharacter.currentSufferState;
SufferStateProperty.DamageRateResult damageRateResult = new SufferStateProperty.DamageRateResult();
damageRateResult.damageRate = 1f;
if (affectEffectProperty.powerType == PowerType.Percentage && currentSufferState.FindSufferState(SufferStateProperty.SufferType.CountGuard))
{
SufferStateProperty sufferStateProperty = currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.CountGuard);
SufferStateProperty.DamageRateResult caseDamageRate = sufferStateProperty.GetCaseDamageRate(affectEffectProperty, attackerCharacter);
if (BattleStateManager.current.battleStateData.IsChipSkill())
{
CharacterStateControl autoCounterCharacter = BattleStateManager.current.battleStateData.GetAutoCounterCharacter();
if (autoCounterCharacter.chipSkillId == SkillStatus.COUNTER_ATTACK_SKILL_ID)
{
caseDamageRate.damageRate = 0f;
}
}
float damageRate = Mathf.Max(1f - caseDamageRate.damageRate, 0f);
damageRateResult.damageRate = damageRate;
damageRateResult.dataList.AddRange(caseDamageRate.dataList);
}
return(damageRateResult);
}
private bool checkUseSkill(SkillStatus status, CharacterStateControl currentCharacter, CharacterStateControl tg)
{
bool isProtectEnableSkill = false;
foreach (AffectEffectProperty affectEffectProperty in status.affectEffect)
{
if (AffectEffectProperty.IsDamage(affectEffectProperty.type))
{
isProtectEnableSkill = true;
break;
}
}
List <SubStateSkillDetailsFunction.TargetData> list = new List <SubStateSkillDetailsFunction.TargetData>();
int num = 0;
for (int i = 0; i < status.affectEffect.Count; i++)
{
AffectEffectProperty affectEffectProperty2 = status.affectEffect[i];
if (AffectEffectProperty.IsDamage(affectEffectProperty2.type))
{
num += affectEffectProperty2.hitNumber;
}
}
bool flag = true;
AffectEffectProperty affectEffectProperty3 = null;
bool flag2 = false;
bool result = false;
bool flag3 = false;
EffectTarget effectTarget = EffectTarget.Enemy;
for (int j = 0; j < status.affectEffect.Count; j++)
{
DkLog.W("↓↓↓↓↓↓", false);
AffectEffectProperty affectEffectProperty4 = status.affectEffect[j];
if (j == 0)
{
effectTarget = affectEffectProperty4.target;
}
if (affectEffectProperty3 != null && affectEffectProperty3.target != affectEffectProperty4.target)
{
CharacterStateControl[] skillTargetList = base.stateManager.targetSelect.GetSkillTargetList(currentCharacter, affectEffectProperty4.target);
if (skillTargetList != null && skillTargetList.Length > 0)
{
currentCharacter.targetCharacter = skillTargetList[0];
}
if (effectTarget == affectEffectProperty4.target)
{
currentCharacter.targetCharacter = tg;
}
}
list = this.CreateTargetData(list, currentCharacter, affectEffectProperty4, isProtectEnableSkill, ref flag);
affectEffectProperty3 = affectEffectProperty4;
if (this.SwitchAffectEffect(affectEffectProperty4, currentCharacter, tg, list, ref flag3, ref flag2))
{
DkLog.W(string.Format("targetDataList {0} : currentSuffer.type {1} : tg {2} : skip {3}", new object[]
{
list.Count,
affectEffectProperty4.type,
string.Empty,
flag2
}), false);
if (!flag2)
{
result = true;
DkLog.W(string.Format("targetDataList.Count {0}", list.Count), false);
}
}
}
return(result);
}
public void ApplyShowHitIcon(AffectEffect affect, int onDamage, Strength onWeak, bool onMiss, bool onCrithical, bool isDrain, bool isCounter, bool isReflection, ExtraEffectType extraEffectType = ExtraEffectType.Non, AffectEffectProperty affectEffectProperty = null)
{
this.ApplyHitIconPlayAnimation(onWeak);
bool flag = false;
HitIcon.Data data = (!flag) ? this.standard : this.gimmick;
this.standard.gameObject.SetActive(!flag);
this.gimmick.gameObject.SetActive(flag);
base.transform.localScale = Vector3.one;
data.numMesh.text = string.Empty;
data.topMesh.text = string.Empty;
data.middleMesh.text = string.Empty;
data.bottomMesh.text = string.Empty;
this.upSprite.gameObject.SetActive(false);
this.downSprite.gameObject.SetActive(false);
if (onMiss)
{
this.ShowMiss(data);
}
else
{
switch (affect)
{
case AffectEffect.Damage:
case AffectEffect.ReferenceTargetHpRate:
case AffectEffect.HpBorderlineDamage:
case AffectEffect.HpBorderlineSpDamage:
case AffectEffect.DefenseThroughDamage:
case AffectEffect.SpDefenseThroughDamage:
case AffectEffect.RefHpRateNonAttribute:
this.ShowDamage(data, onDamage, onWeak, onCrithical, isCounter, isReflection, extraEffectType);
return;
case AffectEffect.AttackUp:
this.ShowAttackUp(data);
return;
case AffectEffect.AttackDown:
this.ShowAttackDown(data);
return;
case AffectEffect.DefenceUp:
this.ShowDefenceUp(data);
return;
case AffectEffect.DefenceDown:
this.ShowDefenceDown(data);
return;
case AffectEffect.SpAttackUp:
this.ShowSpAttackUp(data);
return;
case AffectEffect.SpAttackDown:
this.ShowSpAttackDown(data);
return;
case AffectEffect.SpDefenceUp:
this.ShowSpDefenceUp(data);
return;
case AffectEffect.SpDefenceDown:
this.ShowSpDefenceDown(data);
return;
case AffectEffect.SpeedUp:
this.ShowSpeedUp(data);
return;
case AffectEffect.SpeedDown:
this.ShowSpeedDown(data);
return;
case AffectEffect.CorrectionUpReset:
this.ShowCorrectionUpReset(data);
return;
case AffectEffect.CorrectionDownReset:
this.ShowCorrectionDownReset(data);
return;
case AffectEffect.HpRevival:
this.ShowHpRevival(data, onDamage, isDrain);
return;
case AffectEffect.Counter:
this.ShowCounter(data, onDamage);
return;
case AffectEffect.Reflection:
this.ShowReflection(data, onDamage);
return;
case AffectEffect.Protect:
this.ShowProtect(data);
return;
case AffectEffect.PowerCharge:
this.ShowPowerCharge(data);
return;
case AffectEffect.Destruct:
this.ShowDestruct(data);
return;
case AffectEffect.Paralysis:
this.ShowParalysis(data);
return;
case AffectEffect.Poison:
this.ShowPoison(data, onDamage);
return;
case AffectEffect.Sleep:
this.ShowSleep(data);
return;
case AffectEffect.SkillLock:
this.ShowSkillLock(data);
return;
case AffectEffect.HitRateUp:
this.ShowHitRateUp(data);
return;
case AffectEffect.HitRateDown:
this.ShowHitRateDown(data);
return;
case AffectEffect.InstantDeath:
this.ShowInstantDeath(data);
return;
case AffectEffect.Confusion:
this.ShowConfusion(data);
return;
case AffectEffect.Stun:
this.ShowStun(data);
return;
case AffectEffect.SufferStatusClear:
this.ShowSufferStatusClear(data);
return;
case AffectEffect.SatisfactionRateUp:
this.ShowSatisfactionRateUp(data);
return;
case AffectEffect.SatisfactionRateDown:
this.ShowSatisfactionRateDown(data);
return;
case AffectEffect.ApRevival:
this.ShowApRevival(data);
return;
case AffectEffect.ApUp:
this.ShowApUp(data);
return;
case AffectEffect.ApDown:
this.ShowApDown(data);
return;
case AffectEffect.ApConsumptionUp:
this.ShowApConsumptionUp(data);
return;
case AffectEffect.ApConsumptionDown:
this.ShowApConsumptionDown(data);
return;
case AffectEffect.TurnBarrier:
this.ShowTurnBarrier(data);
return;
case AffectEffect.CountBarrier:
this.ShowCountBarrier(data);
return;
case AffectEffect.Invalid:
this.ShowInvalid(data);
return;
case AffectEffect.Recommand:
this.ShowRecommand(data);
return;
case AffectEffect.DamageRateUp:
this.ShowDamageRateUp(data);
return;
case AffectEffect.DamageRateDown:
this.ShowDamageRateDown(data);
return;
case AffectEffect.Regenerate:
this.ShowRegenerate(data, onDamage);
return;
case AffectEffect.TurnEvasion:
this.ShowTurnEvasion(data);
return;
case AffectEffect.CountEvasion:
this.ShowCountEvasion(data);
return;
case AffectEffect.Escape:
this.ShowEscape(data);
return;
case AffectEffect.ChangeToleranceUp:
this.ShowAttributeTolerance(data, affectEffectProperty, true);
return;
case AffectEffect.ChangeToleranceDown:
this.ShowAttributeTolerance(data, affectEffectProperty, false);
return;
case AffectEffect.ClearTolerance:
this.ShowClearTolerance(data);
return;
}
NGUITools.SetActiveSelf(base.gameObject, false);
}
}
private static List <ExtraEffectStatus> GetTotalExtraEffectStatusList(List <ExtraEffectStatus> extraEffectStatusList, string[] monsterIntegrationIds, string groupId, Tolerance tolerance, string tribe, GrowStep growStep, AffectEffectProperty skillPropety, HaveSufferState currentSufferState, ExtraEffectStatus.ExtraTargetType targetType, EffectStatusBase.ExtraEffectType effectType)
{
List <ExtraEffectStatus> list = new List <ExtraEffectStatus>();
if (skillPropety != null)
{
bool flag = skillPropety.skillId.ToString() == BattleStateManager.PublicAttackSkillId;
List <ExtraEffectStatus> list2 = new List <ExtraEffectStatus>();
foreach (ExtraEffectStatus extraEffectStatus in extraEffectStatusList)
{
if (extraEffectStatus.TargetValue2 == "0")
{
list2.Add(extraEffectStatus);
}
else if (extraEffectStatus.TargetValue2 == "1")
{
if (flag)
{
list2.Add(extraEffectStatus);
}
}
else if (extraEffectStatus.TargetValue2 == "2" && !flag)
{
list2.Add(extraEffectStatus);
}
}
ConstValue.ResistanceType skillResistanceType = EffectStatusBase.GetSkillResistanceType(skillPropety);
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(list2, targetType, EffectStatusBase.ExtraTargetSubType.SkillAttribute, 0, effectType));
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(list2, targetType, EffectStatusBase.ExtraTargetSubType.SkillAttribute, (int)skillResistanceType, effectType));
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(list2, targetType, EffectStatusBase.ExtraTargetSubType.SkillId, 0, effectType));
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(list2, targetType, EffectStatusBase.ExtraTargetSubType.SkillId, skillPropety.skillId, effectType));
}
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(extraEffectStatusList, targetType, EffectStatusBase.ExtraTargetSubType.MonsterResistance, 0, effectType));
List <ConstValue.ResistanceType> attributeStrengthList = tolerance.GetAttributeStrengthList();
foreach (ConstValue.ResistanceType targetValue in attributeStrengthList)
{
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(extraEffectStatusList, targetType, EffectStatusBase.ExtraTargetSubType.MonsterResistance, (int)targetValue, effectType));
}
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(extraEffectStatusList, targetType, EffectStatusBase.ExtraTargetSubType.MonsterTribe, 0, effectType));
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(extraEffectStatusList, targetType, EffectStatusBase.ExtraTargetSubType.MonsterTribe, tribe.ToInt32(), effectType));
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(extraEffectStatusList, targetType, EffectStatusBase.ExtraTargetSubType.MonsterGroup, 0, effectType));
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(extraEffectStatusList, targetType, EffectStatusBase.ExtraTargetSubType.MonsterGroup, groupId.ToInt32(), effectType));
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(extraEffectStatusList, targetType, EffectStatusBase.ExtraTargetSubType.GrowStep, 0, effectType));
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(extraEffectStatusList, targetType, EffectStatusBase.ExtraTargetSubType.GrowStep, (int)growStep, effectType));
if (currentSufferState != null)
{
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(extraEffectStatusList, targetType, EffectStatusBase.ExtraTargetSubType.Suffer, 0, effectType));
IEnumerator enumerator3 = Enum.GetValues(typeof(SufferStateProperty.SufferType)).GetEnumerator();
try
{
while (enumerator3.MoveNext())
{
object obj = enumerator3.Current;
SufferStateProperty.SufferType sufferType = (SufferStateProperty.SufferType)obj;
if (sufferType != SufferStateProperty.SufferType.Null)
{
if (currentSufferState.FindSufferState(sufferType))
{
list.AddRange(ExtraEffectStatus.GetExtraEffectStatusList(extraEffectStatusList, targetType, EffectStatusBase.ExtraTargetSubType.Suffer, (int)sufferType, effectType));
}
}
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator3 as IDisposable)) != null)
{
disposable.Dispose();
}
}
}
list.AddRange(ExtraEffectStatus.GetMonsterIntegrationGroupList(extraEffectStatusList, monsterIntegrationIds, targetType, effectType));
return(list);
}
public static float GetSkillHitRateCorrectionValue(List <ExtraEffectStatus> extraEffectStatusList, AffectEffectProperty skillPropety, CharacterStateControl character)
{
List <ExtraEffectStatus> list = ChipEffectStatus.CheckStageEffectInvalid(extraEffectStatusList, character);
if (list.Count == 0)
{
return(skillPropety.hitRate);
}
int num = ServerToBattleUtility.PercentageToPermillion(skillPropety.hitRate);
float extraEffectCorrectionValue = ExtraEffectStatus.GetExtraEffectCorrectionValue(list, (float)num, character.characterStatus.monsterIntegrationIds, character.groupId, character.tolerance, character.characterDatas.tribe, character.characterDatas.growStep, skillPropety, character.currentSufferState, ExtraEffectStatus.GetExtraTargetType(character), EffectStatusBase.ExtraEffectType.SkillHit);
return(ServerToBattleUtility.PermillionToPercentage((int)extraEffectCorrectionValue));
}
public static int GetSkillPowerCorrectionValue(List <ExtraEffectStatus> extraEffectStatusList, AffectEffectProperty skillPropety, CharacterStateControl character)
{
List <ExtraEffectStatus> list = ChipEffectStatus.CheckStageEffectInvalid(extraEffectStatusList, character);
if (list.Count == 0)
{
return(skillPropety.GetPower(character));
}
return((int)ExtraEffectStatus.GetExtraEffectCorrectionValue(list, (float)skillPropety.GetPower(character), character.characterStatus.monsterIntegrationIds, character.groupId, character.tolerance, character.characterDatas.tribe, character.characterDatas.growStep, skillPropety, character.currentSufferState, ExtraEffectStatus.GetExtraTargetType(character), EffectStatusBase.ExtraEffectType.SkillPower));
}
public static int GetExtraEffectCorrectionValue(int areaId, List <ExtraEffectStatus> extraEffectStatusList, int baseValue, MonsterData[] chipPlayers, MonsterData[] chipEnemys, MonsterData chipTarget, AffectEffectProperty affectEffectProperty, EffectStatusBase.ExtraEffectType effectType)
{
List <ExtraEffectStatus> list = ChipEffectStatus.CheckStageEffectInvalid(areaId, extraEffectStatusList, chipPlayers, chipEnemys, chipTarget);
if (list.Count == 0)
{
return(baseValue);
}
bool flag = chipEnemys.Where((MonsterData item) => item.userMonster.userMonsterId == chipTarget.userMonster.userMonsterId).Any <MonsterData>();
GameWebAPI.RespDataMA_GetMonsterMG.MonsterM group = MonsterMaster.GetMonsterMasterByMonsterGroupId(chipTarget.monsterM.monsterGroupId).Group;
GameWebAPI.RespDataMA_MonsterIntegrationGroupMaster responseMonsterIntegrationGroupMaster = MasterDataMng.Instance().ResponseMonsterIntegrationGroupMaster;
GameWebAPI.RespDataMA_MonsterIntegrationGroupMaster.MonsterIntegrationGroup[] source = responseMonsterIntegrationGroupMaster.monsterIntegrationGroupM.Where((GameWebAPI.RespDataMA_MonsterIntegrationGroupMaster.MonsterIntegrationGroup item) => item.monsterId == chipTarget.monsterM.monsterId).ToArray <GameWebAPI.RespDataMA_MonsterIntegrationGroupMaster.MonsterIntegrationGroup>();
string[] monsterIntegrationIds = source.Select((GameWebAPI.RespDataMA_MonsterIntegrationGroupMaster.MonsterIntegrationGroup item) => item.monsterIntegrationId).ToArray <string>();
GameWebAPI.RespDataMA_GetMonsterResistanceM.MonsterResistanceM resistanceMaster = MonsterResistanceData.GetResistanceMaster(chipTarget.monsterM.resistanceId);
List <GameWebAPI.RespDataMA_GetMonsterResistanceM.MonsterResistanceM> uniqueResistanceList = MonsterResistanceData.GetUniqueResistanceList(chipTarget.GetResistanceIdList());
GameWebAPI.RespDataMA_GetMonsterResistanceM.MonsterResistanceM data = MonsterResistanceData.AddResistanceFromMultipleTranceData(resistanceMaster, uniqueResistanceList);
Tolerance tolerance = ServerToBattleUtility.ResistanceToTolerance(data);
GrowStep growStep = MonsterGrowStepData.ToGrowStep(group.growStep);
List <ExtraEffectStatus> totalExtraEffectStatusList = ExtraEffectStatus.GetTotalExtraEffectStatusList(list, monsterIntegrationIds, chipTarget.monsterM.monsterGroupId, tolerance, group.tribe, growStep, affectEffectProperty, null, (!flag) ? ExtraEffectStatus.ExtraTargetType.Player : ExtraEffectStatus.ExtraTargetType.Enemy, effectType);
if (totalExtraEffectStatusList.Count > 0)
{
return((int)ExtraEffectStatus.GetCorrectionValue((float)baseValue, totalExtraEffectStatusList));
}
return(baseValue);
}
private static float GetExtraEffectCorrectionValue(List <ExtraEffectStatus> extraEffectStatusList, float baseValue, string[] monsterIntegrationIds, string groupId, Tolerance tolerance, string tribe, GrowStep growStep, AffectEffectProperty skillPropety, HaveSufferState currentSufferState, ExtraEffectStatus.ExtraTargetType targetType, EffectStatusBase.ExtraEffectType effectType)
{
List <ExtraEffectStatus> totalExtraEffectStatusList = ExtraEffectStatus.GetTotalExtraEffectStatusList(extraEffectStatusList, monsterIntegrationIds, groupId, tolerance, tribe, growStep, skillPropety, currentSufferState, targetType, effectType);
if (totalExtraEffectStatusList.Count > 0)
{
return(ExtraEffectStatus.GetCorrectionValue(baseValue, totalExtraEffectStatusList));
}
return(baseValue);
}
private bool SwitchAffectEffect(AffectEffectProperty currentSuffer, CharacterStateControl currentCharacter, CharacterStateControl baseTarget, List <SubStateSkillDetailsFunction.TargetData> targetDataList, ref bool isEnableForPrevious, ref bool skip)
{
if (currentSuffer.type != AffectEffect.SkillBranch)
{
return(true);
}
DkLog.W("条件分岐判定処理開始", false);
if (currentSuffer.type == AffectEffect.SkillBranch && currentSuffer.skillBranchOverlap == 1)
{
isEnableForPrevious = false;
DkLog.W("重複可能だったのでフラグを下ろす", false);
}
DkLog.W("isEnableForPrevious : " + isEnableForPrevious, false);
if (currentSuffer.type == AffectEffect.SkillBranch && (currentSuffer.skillBranchOverlap != 0 || !isEnableForPrevious))
{
bool flag = false;
bool flag2 = currentSuffer.skillBranchTargetType == 4 || currentSuffer.skillBranchTargetType == 6;
this.targetList.Clear();
switch (currentSuffer.skillBranchTargetType)
{
case 1:
this.targetList.Add(currentCharacter);
break;
case 2:
this.targetList.Add(baseTarget);
break;
case 3:
case 4:
foreach (CharacterStateControl item in base.battleStateData.playerCharacters)
{
this.targetList.Add(item);
}
break;
case 5:
case 6:
foreach (CharacterStateControl item2 in base.battleStateData.enemies)
{
this.targetList.Add(item2);
}
break;
}
foreach (CharacterStateControl characterStateControl in this.targetList)
{
if (!(characterStateControl != null) || !characterStateControl.isDied)
{
CharacterStateControl characterStateControl2 = characterStateControl;
SkillBranchType skillBranchType = (SkillBranchType)currentSuffer.skillBranchType;
switch (skillBranchType)
{
case SkillBranchType.None:
break;
case SkillBranchType.SufferStatus:
if (characterStateControl2.currentSufferState.FindSufferState((SufferStateProperty.SufferType)currentSuffer.skillBranchTypeValue))
{
flag = true;
}
else if (flag2)
{
flag = false;
}
continue;
case SkillBranchType.HpRateUp:
{
float num = (float)characterStateControl2.hp / ((float)characterStateControl2.extraMaxHp * 1f) * 100f;
if (num >= (float)currentSuffer.skillBranchTypeValue)
{
flag = true;
}
else if (flag2)
{
flag = false;
}
continue;
}
case SkillBranchType.HpRateDown:
{
float num = (float)characterStateControl2.hp / ((float)characterStateControl2.extraMaxHp * 1f) * 100f;
if (num * 100f <= (float)currentSuffer.skillBranchTypeValue)
{
flag = true;
}
else if (flag2)
{
flag = false;
}
continue;
}
case SkillBranchType.MyHpRateUp:
{
float num = (float)characterStateControl2.hp / ((float)characterStateControl2.extraMaxHp * 1f) * 100f;
float num2 = (float)currentCharacter.hp / ((float)currentCharacter.extraMaxHp * 1f) * 100f;
if (num >= num2)
{
flag = true;
}
else if (flag2)
{
flag = false;
}
continue;
}
case SkillBranchType.MyHpRateDown:
{
float num = (float)characterStateControl2.hp / ((float)characterStateControl2.extraMaxHp * 1f) * 100f;
float num2 = (float)currentCharacter.hp / ((float)currentCharacter.extraMaxHp * 1f) * 100f;
if (num <= num2)
{
flag = true;
}
else if (flag2)
{
flag = false;
}
continue;
}
case SkillBranchType.BehaviorAlready:
if (currentSuffer.skillBranchTypeValue == 0)
{
if (characterStateControl2.skillOrder > currentCharacter.skillOrder)
{
flag = true;
}
else if (flag2)
{
flag = false;
}
}
else if (characterStateControl2.skillOrder < currentCharacter.skillOrder)
{
flag = true;
}
else if (flag2)
{
flag = false;
}
continue;
case SkillBranchType.Attribute:
continue;
case SkillBranchType.AttributeMerit:
continue;
case SkillBranchType.NotSufferStatus:
if (!characterStateControl2.currentSufferState.FindSufferState((SufferStateProperty.SufferType)currentSuffer.skillBranchTypeValue))
{
flag = true;
}
else if (flag2)
{
flag = false;
}
continue;
default:
if (skillBranchType != SkillBranchType.End)
{
continue;
}
break;
}
flag = true;
}
}
DkLog.W(string.Format("isEnable {0}", flag), false);
if (flag)
{
skip = false;
isEnableForPrevious = true;
}
else
{
skip = true;
}
foreach (SubStateSkillDetailsFunction.TargetData targetData in targetDataList)
{
targetData.isAllMiss = false;
}
return(false);
}
skip = true;
DkLog.W(string.Format("skip {0}", skip), false);
return(false);
}
private List <SubStateSkillDetailsFunction.TargetData> CreateTargetData(List <SubStateSkillDetailsFunction.TargetData> oldTargetDataList, CharacterStateControl currentCharacter, AffectEffectProperty currentSuffer, bool isProtectEnableSkill, ref bool enableDrawProtectMessage)
{
List <SubStateSkillDetailsFunction.TargetData> list = new List <SubStateSkillDetailsFunction.TargetData>();
CharacterStateControl[] array;
if (base.battleStateData.isConfusionAttack)
{
if (currentCharacter.isEnemy)
{
array = base.stateManager.targetSelect.GetSkillTargetList(base.battleStateData.playerCharacters[0], currentSuffer.target);
}
else
{
array = base.stateManager.targetSelect.GetSkillTargetList(base.battleStateData.enemies[0], currentSuffer.target);
}
}
else
{
array = base.stateManager.targetSelect.GetSkillTargetList(currentCharacter, currentSuffer.target);
}
if (array == null || array.Length == 0)
{
return(list);
}
bool flag = false;
if (currentSuffer.effectNumbers == EffectNumbers.Simple)
{
CharacterStateControl[] array2 = array.Where((CharacterStateControl item) => item.currentSufferState.FindSufferState(SufferStateProperty.SufferType.Protect)).ToArray <CharacterStateControl>();
if (base.battleStateData.isConfusionAttack)
{
flag = (isProtectEnableSkill && array2 != null && array2.Length > 0);
}
else
{
flag = (isProtectEnableSkill && array2 != null && array2.Length > 0 && currentCharacter.isEnemy != array[0].isEnemy);
}
if (flag)
{
array = CharacterStateControlSorter.SortedSufferStateGenerateStartTiming(array2, SufferStateProperty.SufferType.Protect);
if (currentCharacter.targetCharacter == array[0])
{
enableDrawProtectMessage = false;
}
currentCharacter.targetCharacter = array[0];
}
array = new CharacterStateControl[]
{
currentCharacter.targetCharacter
};
}
if (!currentSuffer.isMissThrough && oldTargetDataList.Count > 0)
{
List <CharacterStateControl> list2 = new List <CharacterStateControl>();
CharacterStateControl[] array3 = array;
for (int i = 0; i < array3.Length; i++)
{
CharacterStateControl target = array3[i];
SubStateSkillDetailsFunction.TargetData targetData = oldTargetDataList.Where((SubStateSkillDetailsFunction.TargetData item) => item.target == target).SingleOrDefault <SubStateSkillDetailsFunction.TargetData>();
bool flag2;
if (targetData != null)
{
flag2 = !targetData.isAllMiss;
}
else
{
flag2 = oldTargetDataList.Where((SubStateSkillDetailsFunction.TargetData item) => !item.isAllMiss).Any <SubStateSkillDetailsFunction.TargetData>();
}
if (flag2)
{
list2.Add(target);
}
}
if (list2.Count <= 0)
{
return(list);
}
array = list2.ToArray();
}
foreach (CharacterStateControl target2 in array)
{
list.Add(new SubStateSkillDetailsFunction.TargetData
{
target = target2,
isAllMiss = true,
onProtect = flag,
isDamage = isProtectEnableSkill
});
}
return(list);
}
