public void UpdateCount(SufferStateProperty.SufferType key, SkillStatus skillStatus = null)
{
List <SufferStatePropertyCounter.CountData> list = null;
this.countDictionary.TryGetValue(key, out list);
if (list == null || list.Count == 0)
{
return;
}
using (List <SufferStatePropertyCounter.CountData> .Enumerator enumerator = list.GetEnumerator())
{
while (enumerator.MoveNext())
{
SufferStatePropertyCounter.CountData countData = enumerator.Current;
HaveSufferState currentSufferState = countData.characterStateControl.currentSufferState;
if (currentSufferState.FindSufferState(key))
{
SufferStateProperty sufferStateProperty = currentSufferState.GetSufferStateProperty(key);
SufferStateProperty.Data[] array = sufferStateProperty.GetNotIsMultiHitThroughDatas();
if (!string.IsNullOrEmpty(countData.id))
{
array = array.Where((SufferStateProperty.Data item) => countData.id == item.id).ToArray <SufferStateProperty.Data>();
}
if (array.Length > 0)
{
sufferStateProperty.AddCurrentKeepCount(array, -1, skillStatus, countData.characterStateControl);
}
}
}
}
}
public HaveSufferState()
{
this.sufferStatePropertyDictionary = new Dictionary <SufferStateProperty.SufferType, SufferStateProperty>();
Array values = Enum.GetValues(typeof(SufferStateProperty.SufferType));
IEnumerator enumerator = values.GetEnumerator();
try
{
while (enumerator.MoveNext())
{
object obj = enumerator.Current;
SufferStateProperty.SufferType sufferType = (SufferStateProperty.SufferType)obj;
SufferStateProperty value = new SufferStateProperty(sufferType);
this.sufferStatePropertyDictionary.Add(sufferType, value);
}
}
finally
{
IDisposable disposable;
if ((disposable = (enumerator as IDisposable)) != null)
{
disposable.Dispose();
}
}
}
private float GetSkillHitRateCorrectionValue(CharacterStateControl attacker)
{
float num = 0f;
List <ExtraEffectStatus> extraEffectStatus = BattleStateManager.current.battleStateData.extraEffectStatus;
List <ExtraEffectStatus> invocationList = ExtraEffectStatus.GetInvocationList(extraEffectStatus, EffectStatusBase.EffectTriggerType.Usually);
num += ExtraEffectStatus.GetSkillHitRateCorrectionValue(invocationList, this, attacker) - this.hitRate;
num += attacker.chipAddHit;
foreach (int num2 in attacker.potencyChipIdList.Keys)
{
GameWebAPI.RespDataMA_ChipEffectM.ChipEffect chipEffectDataToId = ChipDataMng.GetChipEffectDataToId(num2.ToString());
GameWebAPI.RespDataMA_ChipEffectM.ChipEffect[] chipEffects = new GameWebAPI.RespDataMA_ChipEffectM.ChipEffect[]
{
chipEffectDataToId
};
num += ChipEffectStatus.GetSkillHitRateCorrectionValue(chipEffects, this, attacker);
}
SufferStateProperty sufferStateProperty = attacker.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.HitRateUp);
if (sufferStateProperty.isActive)
{
num += sufferStateProperty.upPercent;
}
SufferStateProperty sufferStateProperty2 = attacker.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.HitRateDown);
if (sufferStateProperty2.isActive)
{
num -= sufferStateProperty2.downPercent;
}
num += attacker.leaderSkillResult.hitRateUpPercent;
return(num);
}
public IEnumerator RunSufferBeforeCommand(List <CharacterStateControl> sortedCharacters, CharacterStateControl sortedCharacter)
{
if (sortedCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.Stun))
{
this.onStun = true;
this.onFreeze = true;
sortedCharacter.currentSufferState.RemoveSufferState(SufferStateProperty.SufferType.Stun, false);
}
if (sortedCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.Sleep))
{
this.onSleep = true;
this.onFreeze = true;
}
SufferStateProperty powerChargeSuffer = sortedCharacter.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.PowerCharge);
if (powerChargeSuffer.isActive)
{
this.onPowerCharge = true;
if (!powerChargeSuffer.OnInvocationPowerChargeAttack)
{
this.onFreeze = true;
}
}
if (sortedCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.Escape))
{
SufferStateProperty suffer = sortedCharacter.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.Escape);
if (suffer.GetNearCurrentKeepRound() < 1)
{
if (suffer.GetAheadEscapeResult())
{
this.onEscape = true;
this.onFreeze = true;
}
else
{
sortedCharacter.currentSufferState.RemoveSufferState(SufferStateProperty.SufferType.Escape, false);
string format = StringMaster.GetString("BattleNotice-21");
string str = string.Format(format, sortedCharacter.characterDatas.name);
base.stateManager.uiControl.ApplyWarning(str, sortedCharacter.isEnemy);
IEnumerator animation = this.Animation(sortedCharacter);
while (animation.MoveNext())
{
yield return(null);
}
}
}
else
{
string format2 = StringMaster.GetString("BattleNotice-19");
string str2 = string.Format(format2, suffer.GetNearCurrentKeepRound());
base.stateManager.uiControl.ApplyWarning(str2, sortedCharacter.isEnemy);
IEnumerator animation2 = this.Animation(sortedCharacter);
while (animation2.MoveNext())
{
yield return(null);
}
}
}
yield break;
}
protected override IEnumerator MainRoutine()
{
CharacterStateControl attacker = base.battleStateData.currentSelectCharacterState;
if ((!attacker.isEnemy && !RandomExtension.Switch(base.hierarchyData.playerPursuitPercentage)) || (attacker.isEnemy && !RandomExtension.Switch(base.hierarchyData.enemyPursuitPercentage)))
{
yield break;
}
if (!attacker.currentSkillStatus.ThisSkillIsAttack)
{
yield break;
}
bool isConfusion = false;
SufferStateProperty confusionSuffer = attacker.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.Confusion);
if (confusionSuffer.isActive && confusionSuffer.GetOccurrenceFreeze())
{
isConfusion = true;
}
CharacterStateControl[] targets;
if (!isConfusion)
{
targets = ((!attacker.isEnemy) ? base.battleStateData.enemies : base.battleStateData.playerCharacters);
}
else
{
targets = (attacker.isEnemy ? base.battleStateData.enemies : base.battleStateData.playerCharacters);
}
int count = 0;
for (int i = 0; i < targets.Length; i++)
{
if (targets[i].isDied)
{
count++;
}
}
if (count == targets.Length)
{
yield break;
}
do
{
attacker.targetCharacter = targets[UnityEngine.Random.Range(0, targets.Length)];
}while (attacker.targetCharacter.isDied);
attacker.isSelectSkill = attacker.SkillIdToIndexOf(base.stateManager.publicAttackSkillId);
base.SetState(typeof(SubStatePvPSkillDetailsFunction));
while (base.isWaitState)
{
yield return(null);
}
yield break;
}
private static int CompareSpeedBase(CharacterStateControl x, CharacterStateControl y, bool checkRandom = false, bool checkBath = true)
{
if (x == y)
{
return(0);
}
float num = (float)x.extraSpeed;
float num2 = (float)y.extraSpeed;
if (checkRandom)
{
num = x.randomedSpeed;
num2 = y.randomedSpeed;
}
else
{
num += (float)x.extraSpeed * x.leaderSkillResult.speedUpPercent;
num2 += (float)y.extraSpeed * y.leaderSkillResult.speedUpPercent;
}
if (checkBath)
{
SufferStateProperty sufferStateProperty = x.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.SpeedUp);
if (sufferStateProperty.isActive)
{
num += (float)x.extraSpeed * sufferStateProperty.upPercent;
}
SufferStateProperty sufferStateProperty2 = x.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.SpeedDown);
if (sufferStateProperty2.isActive)
{
num -= (float)x.extraSpeed * sufferStateProperty2.downPercent;
}
SufferStateProperty sufferStateProperty3 = y.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.SpeedUp);
if (sufferStateProperty3.isActive)
{
num2 += (float)y.extraSpeed * sufferStateProperty3.upPercent;
}
SufferStateProperty sufferStateProperty4 = y.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.SpeedDown);
if (sufferStateProperty4.isActive)
{
num2 -= (float)y.extraSpeed * sufferStateProperty4.downPercent;
}
}
if (num > num2)
{
return(-1);
}
if (num < num2)
{
return(1);
}
return(0);
}
public void RoundUpdate()
{
SufferStateProperty.SufferType[] array = new SufferStateProperty.SufferType[]
{
SufferStateProperty.SufferType.Poison,
SufferStateProperty.SufferType.Confusion,
SufferStateProperty.SufferType.Paralysis,
SufferStateProperty.SufferType.Sleep,
SufferStateProperty.SufferType.Stun,
SufferStateProperty.SufferType.SkillLock,
SufferStateProperty.SufferType.AttackUp,
SufferStateProperty.SufferType.AttackDown,
SufferStateProperty.SufferType.DefenceUp,
SufferStateProperty.SufferType.DefenceDown,
SufferStateProperty.SufferType.SpAttackUp,
SufferStateProperty.SufferType.SpAttackDown,
SufferStateProperty.SufferType.SpDefenceUp,
SufferStateProperty.SufferType.SpDefenceDown,
SufferStateProperty.SufferType.SpeedUp,
SufferStateProperty.SufferType.SpeedDown,
SufferStateProperty.SufferType.Counter,
SufferStateProperty.SufferType.Reflection,
SufferStateProperty.SufferType.Protect,
SufferStateProperty.SufferType.PowerCharge,
SufferStateProperty.SufferType.HitRateUp,
SufferStateProperty.SufferType.HitRateDown,
SufferStateProperty.SufferType.SatisfactionRateUp,
SufferStateProperty.SufferType.SatisfactionRateDown,
SufferStateProperty.SufferType.ApRevival,
SufferStateProperty.SufferType.ApConsumptionUp,
SufferStateProperty.SufferType.ApConsumptionDown,
SufferStateProperty.SufferType.TurnBarrier,
SufferStateProperty.SufferType.DamageRateUp,
SufferStateProperty.SufferType.DamageRateDown,
SufferStateProperty.SufferType.Regenerate,
SufferStateProperty.SufferType.TurnEvasion,
SufferStateProperty.SufferType.Escape,
SufferStateProperty.SufferType.ChangeToleranceUp,
SufferStateProperty.SufferType.ChangeToleranceDown
};
foreach (SufferStateProperty.SufferType key in array)
{
this.sufferStatePropertyDictionary[key].AddCurrentKeepRound(-1);
}
SufferStateProperty sufferStateProperty = this.sufferStatePropertyDictionary[SufferStateProperty.SufferType.Escape];
if (sufferStateProperty.isActive)
{
sufferStateProperty.SaveAheadEscapeResult();
}
}
public int GetCorrectedAp(CharacterStateControl user)
{
int num = this.needAp;
SufferStateProperty sufferStateProperty = user.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.ApConsumptionUp);
if (sufferStateProperty.isActive)
{
num += sufferStateProperty.upPower;
}
SufferStateProperty sufferStateProperty2 = user.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.ApConsumptionDown);
if (sufferStateProperty2.isActive)
{
num -= sufferStateProperty2.downPower;
}
return(num);
}
public void RunSufferAfterCommand(List <CharacterStateControl> sortedCharacters, CharacterStateControl sortedCharacter)
{
base.stateManager.uiControl.HideCharacterHUDFunction();
SufferStateProperty sufferStateProperty = sortedCharacter.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.Paralysis);
if (sufferStateProperty.isActive && sufferStateProperty.GetOccurrenceFreeze())
{
this.onFreeze = true;
this.onParalysis = true;
}
SufferStateProperty sufferStateProperty2 = sortedCharacter.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.Confusion);
if (sufferStateProperty2.isActive && sufferStateProperty2.GetOccurrenceFreeze())
{
sortedCharacter.isSelectSkill = sortedCharacter.SkillIdToIndexOf(base.stateManager.publicAttackSkillId);
this.onConfusion = true;
CharacterStateControl characterStateControl;
for (;;)
{
characterStateControl = sortedCharacters[UnityEngine.Random.Range(0, sortedCharacters.Count)];
if (!characterStateControl.isDied)
{
if (sortedCharacter.isEnemy)
{
if (characterStateControl.isEnemy)
{
break;
}
}
else if (!characterStateControl.isEnemy)
{
goto Block_8;
}
}
}
sortedCharacter.targetCharacter = characterStateControl;
return;
Block_8:
sortedCharacter.targetCharacter = characterStateControl;
}
}
public void AddCountDictionary(SufferStateProperty.SufferType key, CharacterStateControl value, string[] ids = null)
{
if (!this.countDictionary.ContainsKey(key))
{
this.countDictionary.Add(key, new List <SufferStatePropertyCounter.CountData>());
}
HaveSufferState currentSufferState = value.currentSufferState;
if (currentSufferState.FindSufferState(key))
{
SufferStateProperty sufferStateProperty = currentSufferState.GetSufferStateProperty(key);
SufferStateProperty.Data[] array = sufferStateProperty.GetIsMultiHitThroughDatas();
if (ids != null)
{
array = array.Where((SufferStateProperty.Data item) => ids.Contains(item.id)).ToArray <SufferStateProperty.Data>();
}
if (array.Length > 0)
{
sufferStateProperty.AddCurrentKeepCount(array, -1, null, null);
}
SufferStateProperty.Data[] array2 = sufferStateProperty.GetNotIsMultiHitThroughDatas();
if (ids != null)
{
array2 = array2.Where((SufferStateProperty.Data item) => ids.Contains(item.id)).ToArray <SufferStateProperty.Data>();
}
if (array2.Length > 0)
{
SufferStateProperty.Data[] array3 = array2;
for (int i = 0; i < array3.Length; i++)
{
SufferStateProperty.Data notIsMultiHitThroughData = array3[i];
if (!this.countDictionary[key].Where((SufferStatePropertyCounter.CountData item) => item.characterStateControl == value && item.id == notIsMultiHitThroughData.id).Any <SufferStatePropertyCounter.CountData>())
{
SufferStatePropertyCounter.CountData countData = new SufferStatePropertyCounter.CountData();
countData.characterStateControl = value;
countData.id = notIsMultiHitThroughData.id;
this.countDictionary[key].Add(countData);
}
}
}
}
}
private IEnumerator PlayStagingChipEffect(List <SubStatePlayChipEffect.ReturnData> returnDataList)
{
foreach (SubStatePlayChipEffect.ReturnData returnData in returnDataList)
{
foreach (KeyValuePair <int, List <GameWebAPI.RespDataMA_ChipEffectM.ChipEffect> > data in returnData.dictionary)
{
foreach (GameWebAPI.RespDataMA_ChipEffectM.ChipEffect chipEffect in data.Value)
{
if (!returnData.characterStateControl.isDied || chipEffect.effectTrigger.ToInt32() == 6)
{
SufferStateProperty death = returnData.characterStateControl.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.InstantDeath);
if (death == null || !death.isActive || death.isMiss || chipEffect.effectTrigger.ToInt32() == 6)
{
if (chipEffect.effectType.ToInt32() == 60 || chipEffect.effectType.ToInt32() == 56)
{
SkillStatus status = base.hierarchyData.GetSkillStatus(chipEffect.effectValue);
CharacterStateControl target = this.GetTarget(returnData.characterStateControl, chipEffect);
if (status == null || target == null)
{
returnData.characterStateControl.AddChipEffectCount(chipEffect.chipEffectId.ToInt32(), 1);
}
else
{
IEnumerator function = this.ChipSkillDetailsFunction(returnData.characterStateControl, data.Key, chipEffect, status, target);
while (function.MoveNext())
{
object obj = function.Current;
yield return(obj);
}
}
}
}
}
}
}
}
yield break;
}
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 static int CompareGenreationStartTimingBase(CharacterStateControl x, CharacterStateControl y, SufferStateProperty.SufferType sufferType)
{
if (x == y)
{
return(0);
}
int num = 0;
SufferStateProperty sufferStateProperty = x.currentSufferState.GetSufferStateProperty(sufferType);
SufferStateProperty sufferStateProperty2 = y.currentSufferState.GetSufferStateProperty(sufferType);
if (sufferStateProperty.generationStartTiming < sufferStateProperty2.generationStartTiming)
{
num = -1;
}
else if (sufferStateProperty.generationStartTiming > sufferStateProperty2.generationStartTiming)
{
num = 1;
}
if (Mathf.Abs(num) == 1)
{
return(num);
}
return(RandomExtension.IntPlusMinus());
}
private IEnumerator PoisonFunction()
{
List <CharacterStateControl> characters = this.GetSufferCharacters(SufferStateProperty.SufferType.Poison);
if (characters.Count == 0)
{
yield break;
}
foreach (CharacterStateControl characterStateControl in base.stateManager.battleStateData.GetTotalCharacters())
{
base.stateManager.threeDAction.ShowAliveCharactersAction(new CharacterStateControl[]
{
characterStateControl
});
base.stateManager.threeDAction.PlayIdleAnimationUndeadCharactersAction(new CharacterStateControl[]
{
characterStateControl
});
}
base.stateManager.SetBattleScreen(BattleScreen.PoisonHit);
foreach (CharacterStateControl characterStateControl2 in this.GetTotalCharacters())
{
characterStateControl2.OnChipTrigger(EffectStatusBase.EffectTriggerType.DamagePossibility);
}
if (base.hierarchyData.batteWaves[base.battleStateData.currentWaveNumber].cameraType == 1)
{
base.stateManager.cameraControl.PlayCameraMotionAction("BigBoss/0002_command", base.battleStateData.stageSpawnPoint, true);
}
else
{
base.stateManager.cameraControl.PlayCameraMotionAction("0002_command", base.battleStateData.stageSpawnPoint, true);
}
List <CharacterStateControl> currentDeathCharacters = new List <CharacterStateControl>();
List <int> damage = new List <int>();
List <bool> isMiss = new List <bool>();
CharacterStateControl currentDeathBigBoss = null;
bool playedDeadSE = false;
for (int k = 0; k < characters.Count; k++)
{
SufferStateProperty sufferStateProperty = characters[k].currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.Poison);
int poisonDamageFluctuation = sufferStateProperty.GetPoisonDamageFluctuation(characters[k]);
characters[k].hp -= poisonDamageFluctuation;
damage.Add(poisonDamageFluctuation);
isMiss.Add(false);
if (!characters[k].isDied)
{
base.stateManager.threeDAction.PlayAnimationCharacterAction(CharacterAnimationType.hit, new CharacterStateControl[]
{
characters[k]
});
}
else
{
if (base.hierarchyData.batteWaves[base.battleStateData.currentWaveNumber].cameraType == 1 && characters[k].isEnemy)
{
base.stateManager.threeDAction.PlayAnimationCharacterAction(CharacterAnimationType.strongHit, new CharacterStateControl[]
{
characters[k]
});
currentDeathBigBoss = characters[k];
}
else
{
Action deathEffectPlay = delegate()
{
if (!playedDeadSE)
{
this.stateManager.soundPlayer.PlayDeathSE();
}
playedDeadSE = true;
};
base.stateManager.threeDAction.PlayDeadAnimationCharacterAction(deathEffectPlay, characters[k]);
}
currentDeathCharacters.Add(characters[k]);
}
HitEffectParams item = BattleEffectManager.Instance.GetEffect(AffectEffect.Poison.ToString()) as HitEffectParams;
this.use_effect_params_.Add(item);
base.stateManager.threeDAction.PlayHitEffectAction(this.use_effect_params_[k], characters[k]);
}
foreach (CharacterStateControl characterStateControl3 in this.GetTotalCharacters())
{
characterStateControl3.ClearGutsData();
}
List <HitIcon> hitIconlist = new List <HitIcon>();
Vector3[] hitIconPositions = this.GetHitIconPositions(characters);
for (int m = 0; m < characters.Count; m++)
{
HitIcon item2 = base.stateManager.uiControl.ApplyShowHitIcon(m, hitIconPositions[m], AffectEffect.Poison, damage[m], Strength.None, isMiss[m], false, false, false, false, ExtraEffectType.Non, true, null);
hitIconlist.Add(item2);
}
base.stateManager.uiControl.HideCharacterHUDFunction();
base.stateManager.uiControl.ShowCharacterHUDFunction(characters.ToArray());
if (this.use_effect_params_.Count > 0)
{
base.stateManager.soundPlayer.TryPlaySE(this.use_effect_params_[0]);
}
Action hudReposition = delegate()
{
foreach (CharacterStateControl characterStateControl5 in characters)
{
this.stateManager.uiControl.RepositionCharacterHUDPosition(new CharacterStateControl[]
{
characterStateControl5
});
}
for (int n = 0; n < characters.Count; n++)
{
Vector3 fixableCharacterCenterPosition2DFunction = this.stateManager.uiControl.GetFixableCharacterCenterPosition2DFunction(characters[n]);
hitIconlist[n].HitIconReposition(fixableCharacterCenterPosition2DFunction);
}
};
if (currentDeathBigBoss != null)
{
base.stateManager.uiControl.Fade(Color.white, 1f, 1f);
}
float waitSecond = base.stateManager.stateProperty.poisonHitEffectWaitSecond + ((currentDeathCharacters.Count <= 0) ? 0f : 1f);
IEnumerator wait = base.stateManager.time.WaitForCertainPeriodTimeAction(waitSecond, hudReposition, null);
while (wait.MoveNext())
{
yield return(null);
}
if (this.use_effect_params_.Count > 0)
{
base.stateManager.soundPlayer.TryStopSE(this.use_effect_params_[0]);
}
base.stateManager.soundPlayer.StopHitEffectSE();
foreach (CharacterStateControl characterStateControl4 in currentDeathCharacters)
{
characterStateControl4.isDiedJustBefore = true;
}
if (base.battleMode != BattleMode.PvP)
{
if (currentDeathBigBoss != null)
{
base.stateManager.cameraControl.StopCameraMotionAction("0002_command");
IEnumerator transitionCount = base.stateManager.threeDAction.BigBossExitAction(currentDeathBigBoss);
while (transitionCount.MoveNext())
{
yield return(null);
}
}
this.subStateEnemiesItemDroppingFunction.Init(currentDeathCharacters.ToArray());
base.SetState(this.subStateEnemiesItemDroppingFunction.GetType());
while (base.isWaitState)
{
yield return(null);
}
if (currentDeathBigBoss != null)
{
base.stateManager.cameraControl.StopCameraMotionAction("skillA");
}
}
yield break;
}
public static SkillResults GetSkillResults(AffectEffectProperty affectEffectProperty, CharacterStateControl attackerCharacter, CharacterStateControl targetCharacter, bool onRandomAttack = true, int attackNum = 0)
{
SkillResults skillResults = new SkillResults();
LeaderSkillResult leaderSkillResult = attackerCharacter.leaderSkillResult;
HaveSufferState currentSufferState = attackerCharacter.currentSufferState;
HaveSufferState currentSufferState2 = targetCharacter.currentSufferState;
float[] array = new float[2];
skillResults.useAffectEffectProperty = affectEffectProperty;
skillResults.hitIconAffectEffect = AffectEffect.Damage;
skillResults.attackCharacter = attackerCharacter;
skillResults.targetCharacter = targetCharacter;
if (targetCharacter.isDied)
{
return(skillResults);
}
skillResults.onWeakHit = ((!affectEffectProperty.canUseAttribute) ? Strength.None : targetCharacter.tolerance.GetAttributeStrength(affectEffectProperty.attribute));
if (attackerCharacter.hittingTheTargetType == BattleInvariant.Type.Non)
{
skillResults.onMissHit = !affectEffectProperty.OnHit(attackerCharacter, targetCharacter);
}
else if (attackerCharacter.hittingTheTargetType == BattleInvariant.Type.Up)
{
skillResults.onMissHit = false;
}
else if (attackerCharacter.hittingTheTargetType == BattleInvariant.Type.Down)
{
skillResults.onMissHit = true;
}
if (skillResults.onWeakHit == Strength.None || skillResults.onWeakHit == Strength.Weak)
{
if (attackerCharacter.criticalTheTargetType == BattleInvariant.Type.Non)
{
float num = affectEffectProperty.satisfactionRate;
SufferStateProperty sufferStateProperty = currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.SatisfactionRateUp);
if (sufferStateProperty.isActive)
{
num += sufferStateProperty.upPercent;
}
SufferStateProperty sufferStateProperty2 = currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.SatisfactionRateDown);
if (sufferStateProperty2.isActive)
{
num -= sufferStateProperty2.downPercent;
}
if (attackerCharacter.isSelectSkill > 0)
{
num += leaderSkillResult.satisfactionRateUpPercent;
}
num += attackerCharacter.chipAddCritical;
skillResults.onCriticalHit = RandomExtension.Switch(num);
}
else if (attackerCharacter.criticalTheTargetType == BattleInvariant.Type.Up)
{
skillResults.onCriticalHit = true;
}
else if (attackerCharacter.criticalTheTargetType == BattleInvariant.Type.Down)
{
skillResults.onCriticalHit = false;
}
}
if (!skillResults.onMissHit)
{
if (affectEffectProperty.powerType == PowerType.Percentage && skillResults.onWeakHit == Strength.Invalid)
{
skillResults.hitIconAffectEffect = AffectEffect.Invalid;
skillResults.onMissHit = false;
skillResults.onWeakHit = Strength.Invalid;
skillResults.onCriticalHit = false;
}
else if (skillResults.targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.TurnBarrier))
{
skillResults.hitIconAffectEffect = AffectEffect.TurnBarrier;
skillResults.onMissHit = false;
skillResults.onWeakHit = Strength.None;
skillResults.onCriticalHit = false;
}
else if (skillResults.targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.CountBarrier))
{
skillResults.hitIconAffectEffect = AffectEffect.CountBarrier;
skillResults.onMissHit = false;
skillResults.onWeakHit = Strength.None;
skillResults.onCriticalHit = false;
}
else if (skillResults.targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.TurnEvasion))
{
skillResults.hitIconAffectEffect = AffectEffect.TurnEvasion;
skillResults.onMissHit = false;
skillResults.onWeakHit = Strength.None;
skillResults.onCriticalHit = false;
}
else if (skillResults.targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.CountEvasion))
{
skillResults.hitIconAffectEffect = AffectEffect.CountEvasion;
skillResults.onMissHit = false;
skillResults.onWeakHit = Strength.None;
skillResults.onCriticalHit = false;
}
else if (affectEffectProperty.type == AffectEffect.ReferenceTargetHpRate)
{
SufferStateProperty.DamageRateResult reduceDamageRate = SkillStatus.GetReduceDamageRate(affectEffectProperty, attackerCharacter, targetCharacter);
skillResults.damageRateResult = reduceDamageRate;
float attributeDamegeResult = SkillStatus.GetAttributeDamegeResult(skillResults.onWeakHit);
float num2 = 1f;
if (skillResults.onCriticalHit)
{
num2 = 1.2f;
}
int num3 = (int)(affectEffectProperty.damagePercent * (float)targetCharacter.hp);
for (int i = 0; i < array.Length; i++)
{
array[i] = (float)num3 * attributeDamegeResult * num2 * reduceDamageRate.damageRate;
}
}
else if (affectEffectProperty.type == AffectEffect.RefHpRateNonAttribute)
{
SufferStateProperty.DamageRateResult reduceDamageRate2 = SkillStatus.GetReduceDamageRate(affectEffectProperty, attackerCharacter, targetCharacter);
skillResults.damageRateResult = reduceDamageRate2;
float num4 = 1f;
if (skillResults.onCriticalHit)
{
num4 = 1.2f;
}
int num5 = (int)(affectEffectProperty.damagePercent * (float)targetCharacter.hp);
for (int j = 0; j < array.Length; j++)
{
array[j] = (float)num5 * num4 * reduceDamageRate2.damageRate;
}
}
else if (affectEffectProperty.powerType == PowerType.Percentage)
{
bool flag = affectEffectProperty.techniqueType == TechniqueType.Physics;
float attributeDamegeResult2 = SkillStatus.GetAttributeDamegeResult(skillResults.onWeakHit);
float num6 = 1f;
if (skillResults.onCriticalHit)
{
num6 = 1.2f;
}
float num7 = 1f;
if (onRandomAttack)
{
num7 = UnityEngine.Random.Range(0.85f, 1f);
}
SufferStateProperty.DamageRateResult reduceDamageRate3 = SkillStatus.GetReduceDamageRate(affectEffectProperty, attackerCharacter, targetCharacter);
skillResults.damageRateResult = reduceDamageRate3;
float num8 = 1f;
if (flag)
{
SufferStateProperty sufferStateProperty3 = targetCharacter.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.Counter);
if (sufferStateProperty3.isActive)
{
num8 *= sufferStateProperty3.recieveDamageRate;
}
}
else
{
SufferStateProperty sufferStateProperty4 = targetCharacter.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.Reflection);
if (sufferStateProperty4.isActive)
{
num8 *= sufferStateProperty4.recieveDamageRate;
}
}
float num9 = 1f;
SufferStateProperty sufferStateProperty5 = currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.PowerCharge);
if (sufferStateProperty5.isActive)
{
if (flag)
{
num9 *= sufferStateProperty5.physicUpPercent;
}
else
{
num9 *= sufferStateProperty5.specialUpPercent;
}
}
float num10 = 1f;
float num11 = 0f;
float num12 = 0f;
SufferStateProperty sufferStateProperty6 = currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.DamageRateUp);
if (sufferStateProperty6.isActive)
{
SufferStateProperty.DamageRateResult caseDamageRate = sufferStateProperty6.GetCaseDamageRate(affectEffectProperty, targetCharacter);
num11 += caseDamageRate.damageRate;
}
SufferStateProperty sufferStateProperty7 = currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.DamageRateDown);
if (sufferStateProperty7.isActive)
{
SufferStateProperty.DamageRateResult caseDamageRate2 = sufferStateProperty7.GetCaseDamageRate(affectEffectProperty, targetCharacter);
num12 += caseDamageRate2.damageRate;
}
num10 = Mathf.Max(0f, num10 + num11 - num12);
for (int k = 0; k < array.Length; k++)
{
int num13 = 0;
float num14 = 1f;
foreach (int num15 in attackerCharacter.potencyChipIdList.Keys)
{
GameWebAPI.RespDataMA_ChipEffectM.ChipEffect chipEffectDataToId = ChipDataMng.GetChipEffectDataToId(num15.ToString());
if (k != 0 || chipEffectDataToId.effectTrigger.ToInt32() != 11)
{
GameWebAPI.RespDataMA_ChipEffectM.ChipEffect[] chipEffects = new GameWebAPI.RespDataMA_ChipEffectM.ChipEffect[]
{
chipEffectDataToId
};
num13 += ChipEffectStatus.GetSkillPowerCorrectionValue(chipEffects, affectEffectProperty, attackerCharacter, attackNum);
num14 += ChipEffectStatus.GetSkillDamageCorrectionValue(chipEffects, affectEffectProperty, attackerCharacter);
}
}
float num16 = 1f;
foreach (int num17 in targetCharacter.potencyChipIdList.Keys)
{
GameWebAPI.RespDataMA_ChipEffectM.ChipEffect chipEffectDataToId2 = ChipDataMng.GetChipEffectDataToId(num17.ToString());
if (k != 0 || chipEffectDataToId2.effectTrigger.ToInt32() != 11)
{
GameWebAPI.RespDataMA_ChipEffectM.ChipEffect[] chipEffects2 = new GameWebAPI.RespDataMA_ChipEffectM.ChipEffect[]
{
chipEffectDataToId2
};
num16 += ChipEffectStatus.GetSkillDamageCorrectionValue(chipEffects2, affectEffectProperty, targetCharacter);
}
}
float num18 = 0f;
float num19 = 0f;
SkillStatus.CalculationBasePower(ref num18, ref num19, flag, k == 0, attackerCharacter, targetCharacter);
int num20;
if (k == 0)
{
num20 = affectEffectProperty.GetPower(attackerCharacter);
}
else
{
List <ExtraEffectStatus> extraEffectStatus = BattleStateManager.current.battleStateData.extraEffectStatus;
List <ExtraEffectStatus> invocationList = ExtraEffectStatus.GetInvocationList(extraEffectStatus, EffectStatusBase.EffectTriggerType.Usually);
num20 = ExtraEffectStatus.GetSkillPowerCorrectionValue(invocationList, affectEffectProperty, attackerCharacter);
}
if (affectEffectProperty.type == AffectEffect.DefenseThroughDamage || affectEffectProperty.type == AffectEffect.SpDefenseThroughDamage)
{
num19 = (float)affectEffectProperty.DefenseThrough;
}
if (num18 <= 0f)
{
array[k] = 0f;
}
else
{
num18 = Mathf.Max(num18, 0f);
num19 = Mathf.Max(num19, 1f);
float num21 = (float)attackerCharacter.level * 0.01f + 1f;
float num22 = (float)(num20 + num13) * (1f + leaderSkillResult.damageUpPercent);
float num23 = num21 * num22 * num18 * num9 / num19 + 2f;
float num24 = num14 * num16 * reduceDamageRate3.damageRate * num8 * num7 * num6 * attributeDamegeResult2 * num10;
array[k] = num23 * num24;
}
}
}
else if (affectEffectProperty.powerType == PowerType.Fixable)
{
for (int l = 0; l < array.Length; l++)
{
array[l] = (float)affectEffectProperty.damagePower;
}
skillResults.onWeakHit = Strength.None;
}
}
skillResults.originalAttackPower = Mathf.FloorToInt(array[0]);
skillResults.attackPower = Mathf.FloorToInt(array[1]);
if (skillResults.hitIconAffectEffect == AffectEffect.Damage && skillResults.attackPower <= 0)
{
skillResults.onMissHit = true;
skillResults.onCriticalHit = false;
}
if (skillResults.onWeakHit != Strength.Drain)
{
targetCharacter.hp -= skillResults.attackPower;
}
else
{
targetCharacter.hp += skillResults.attackPower;
}
if (skillResults.attackPower < skillResults.originalAttackPower)
{
skillResults.extraEffectType = ExtraEffectType.Down;
}
else if (skillResults.attackPower > skillResults.originalAttackPower)
{
skillResults.extraEffectType = ExtraEffectType.Up;
}
else
{
skillResults.extraEffectType = ExtraEffectType.Non;
}
return(skillResults);
}
private IEnumerator InstantDeathFunction()
{
List <CharacterStateControl> characters = BattleFunctionUtility.GetSufferCharacters(SufferStateProperty.SufferType.InstantDeath, base.battleStateData);
bool playedDeadSE = false;
Dictionary <CharacterStateControl, bool> hit = new Dictionary <CharacterStateControl, bool>(characters.Count);
if (characters.Count == 0)
{
yield break;
}
List <HitIcon> hitIconlist = new List <HitIcon>();
Vector3[] hitIconPositions = BattleFunctionUtility.GetHitIconPositions(base.stateManager.uiControl, characters);
for (int i = 0; i < characters.Count; i++)
{
SufferStateProperty sufferStateProperty = characters[i].currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.InstantDeath);
hit.Add(characters[i], sufferStateProperty.isMiss);
HitIcon item = base.stateManager.uiControl.ApplyShowHitIcon(i, hitIconPositions[i], AffectEffect.InstantDeath, 0, Strength.None, sufferStateProperty.isMiss, false, false, false, false, ExtraEffectType.Non, true, null);
hitIconlist.Add(item);
}
this.ShowDigimon(characters);
this.PlayCamera(characters);
base.stateManager.cameraControl.PlayCameraShake();
base.stateManager.uiControl.ShowCharacterHUDFunction(characters.ToArray());
Action hudReposition = delegate()
{
foreach (CharacterStateControl characterStateControl2 in characters)
{
this.stateManager.uiControl.RepositionCharacterHUDPosition(new CharacterStateControl[]
{
characterStateControl2
});
}
for (int j = 0; j < characters.Count; j++)
{
Vector3 fixableCharacterCenterPosition2DFunction = this.stateManager.uiControl.GetFixableCharacterCenterPosition2DFunction(characters[j]);
hitIconlist[j].HitIconReposition(fixableCharacterCenterPosition2DFunction);
}
};
float waitSecond = base.stateManager.stateProperty.skillAfterWaitSecond;
IEnumerator wait = base.stateManager.time.WaitForCertainPeriodTimeAction(waitSecond, hudReposition, null);
while (wait.MoveNext())
{
yield return(null);
}
base.stateManager.cameraControl.StopCameraShake();
foreach (CharacterStateControl characterStateControl in characters)
{
if (!hit[characterStateControl])
{
Action deathEffectPlay = delegate()
{
if (!playedDeadSE)
{
this.stateManager.soundPlayer.PlayDeathSE();
}
playedDeadSE = true;
};
base.stateManager.threeDAction.PlayDeadAnimationCharacterAction(deathEffectPlay, characterStateControl);
characterStateControl.Kill();
characterStateControl.isDiedJustBefore = true;
}
characterStateControl.currentSufferState.RemoveSufferState(SufferStateProperty.SufferType.InstantDeath, false);
}
IEnumerator end_wait = base.stateManager.time.WaitForCertainPeriodTimeAction(base.stateManager.stateProperty.skillAfterWaitSecond, null, null);
while (end_wait.MoveNext())
{
yield return(null);
}
yield break;
}
private static void CalculationBasePower(ref float attackCalced, ref float defenceCalced, bool isPhysics, bool isExtra, CharacterStateControl attackerCharacter, CharacterStateControl targetCharacter)
{
HaveSufferState currentSufferState = attackerCharacter.currentSufferState;
HaveSufferState currentSufferState2 = targetCharacter.currentSufferState;
float num = 0f;
float num2 = 0f;
float num3 = 0f;
float num4 = 0f;
int num5;
int num6;
if (isExtra)
{
num5 = ((!isPhysics) ? attackerCharacter.specialAttackPower : attackerCharacter.attackPower);
num6 = ((!isPhysics) ? targetCharacter.specialDefencePower : targetCharacter.defencePower);
}
else
{
num5 = ((!isPhysics) ? attackerCharacter.extraSpecialAttackPower : attackerCharacter.extraAttackPower);
num6 = ((!isPhysics) ? targetCharacter.extraSpecialDefencePower : targetCharacter.extraDefencePower);
}
float num7 = (!isPhysics) ? attackerCharacter.leaderSkillResult.specialAttackUpPercent : attackerCharacter.leaderSkillResult.attackUpPercent;
float num8 = (!isPhysics) ? targetCharacter.leaderSkillResult.specialDefenceUpPercent : targetCharacter.leaderSkillResult.defenceUpPercent;
float num9 = num7 * (float)num5;
float num10 = num8 * (float)num6;
global::Debug.Log(string.Format("onLeaderAttackUp {0} | onLeaderDefenceUp {1}", num9, num10));
SufferStateProperty.SufferType sufferType = SufferStateProperty.SufferType.AttackUp;
SufferStateProperty.SufferType sufferType2 = SufferStateProperty.SufferType.AttackDown;
SufferStateProperty.SufferType sufferType3 = SufferStateProperty.SufferType.DefenceUp;
SufferStateProperty.SufferType sufferType4 = SufferStateProperty.SufferType.DefenceDown;
if (!isPhysics)
{
sufferType = SufferStateProperty.SufferType.SpAttackUp;
sufferType2 = SufferStateProperty.SufferType.SpAttackDown;
sufferType3 = SufferStateProperty.SufferType.SpDefenceUp;
sufferType4 = SufferStateProperty.SufferType.SpDefenceDown;
}
SufferStateProperty sufferStateProperty = currentSufferState.GetSufferStateProperty(sufferType);
if (sufferStateProperty.isActive)
{
num = sufferStateProperty.upPercent * (float)num5;
}
SufferStateProperty sufferStateProperty2 = currentSufferState.GetSufferStateProperty(sufferType2);
if (sufferStateProperty2.isActive)
{
num2 = sufferStateProperty2.downPercent * (float)num5;
}
SufferStateProperty sufferStateProperty3 = currentSufferState2.GetSufferStateProperty(sufferType3);
if (sufferStateProperty3.isActive)
{
num3 = sufferStateProperty3.upPercent * (float)num6;
}
SufferStateProperty sufferStateProperty4 = currentSufferState2.GetSufferStateProperty(sufferType4);
if (sufferStateProperty4.isActive)
{
num4 = sufferStateProperty4.downPercent * (float)num6;
}
attackCalced = (float)num5 + num - num2 + num9;
defenceCalced = (float)num6 + num3 - num4 + num10;
attackCalced = Mathf.Min(attackCalced, (float)num5 * 3f);
attackCalced = Mathf.Max(attackCalced, 0f);
defenceCalced = Mathf.Min(defenceCalced, (float)num6 * 3f);
defenceCalced = Mathf.Max(defenceCalced, 0f);
global::Debug.Log("=========================================");
global::Debug.Log("onAttackUp : " + num);
global::Debug.Log("onAttackDown : " + num2);
global::Debug.Log("onDefenceUp : " + num3);
global::Debug.Log("onDefenceDown : " + num4);
global::Debug.Log(string.Format("攻撃 {0}/(上限{1}/下限{2}/基礎{3})", new object[]
{
attackCalced,
(float)num5 * 3f,
0f,
num5
}));
global::Debug.Log(string.Format("防御 {0}/(上限{1}/下限{2}/基礎{3})", new object[]
{
defenceCalced,
(float)num6 * 3f,
0f,
num6
}));
}
private IEnumerator HitEffectFunction(SufferStateProperty.SufferType[] sufferTypes, CharacterAnimationType characterAnimationType)
{
List <CharacterStateControl> characters = new List <CharacterStateControl>();
foreach (SufferStateProperty.SufferType sufferType in sufferTypes)
{
List <CharacterStateControl> sufferCharacters = this.GetSufferCharacters(sufferType);
foreach (CharacterStateControl characterStateControl in sufferCharacters)
{
SufferStateProperty sufferStateProperty = characterStateControl.currentSufferState.GetSufferStateProperty(sufferType);
if (sufferStateProperty.isTurnRate && !characters.Contains(characterStateControl))
{
characters.Add(characterStateControl);
}
}
}
if (characters.Count == 0)
{
yield break;
}
base.stateManager.uiControl.HideCharacterHUDFunction();
base.stateManager.SetBattleScreen(BattleScreen.PoisonHit);
if (base.hierarchyData.batteWaves[base.battleStateData.currentWaveNumber].cameraType == 1)
{
base.stateManager.cameraControl.PlayCameraMotionAction("BigBoss/0002_command", base.battleStateData.stageSpawnPoint, true);
}
else
{
base.stateManager.cameraControl.PlayCameraMotionAction("0002_command", base.battleStateData.stageSpawnPoint, true);
}
HitEffectParams[] hitEffectParams = null;
foreach (SufferStateProperty.SufferType sufferType2 in sufferTypes)
{
string key = sufferType2.ToString();
HitEffectParams[] @object = base.battleStateData.hitEffects.GetObject(key);
if (@object != null)
{
hitEffectParams = @object;
break;
}
}
base.stateManager.soundPlayer.TryPlaySE(hitEffectParams[0]);
for (int k = 0; k < characters.Count; k++)
{
base.stateManager.threeDAction.PlayAnimationCharacterAction(characterAnimationType, new CharacterStateControl[]
{
characters[k]
});
base.stateManager.threeDAction.PlayHitEffectAction(hitEffectParams[k], characters[k]);
}
float waitSecond = base.stateManager.stateProperty.poisonHitEffectWaitSecond;
IEnumerator wait = base.stateManager.time.WaitForCertainPeriodTimeAction(waitSecond, null, null);
while (wait.MoveNext())
{
yield return(null);
}
for (int l = 0; l < characters.Count; l++)
{
base.stateManager.threeDAction.StopHitEffectAction(new HitEffectParams[]
{
hitEffectParams[l]
});
}
base.stateManager.soundPlayer.TryStopSE(hitEffectParams[0]);
base.stateManager.soundPlayer.StopHitEffectSE();
yield break;
}
public int[] getOverrideTolerances(ref bool doOverrideData)
{
int[] array = new int[14];
SufferStateProperty sufferStateProperty = this.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.ChangeToleranceUp);
if (sufferStateProperty.dataDictionary.Count != 0)
{
doOverrideData = true;
foreach (List <SufferStateProperty.Data> list in sufferStateProperty.dataDictionary.Values)
{
foreach (SufferStateProperty.Data data in list)
{
if (data.isActive)
{
for (int i = 0; i < array.Length; i++)
{
if ((int)data.toleranceValue[i] >= 100)
{
if (array[i] < 100)
{
array[i] = (int)data.toleranceValue[i];
}
}
else if (array[i] < 100)
{
array[i] += (int)data.toleranceValue[i];
}
}
}
}
}
}
sufferStateProperty = this.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.ChangeToleranceDown);
if (sufferStateProperty.dataDictionary.Count != 0)
{
doOverrideData = true;
foreach (List <SufferStateProperty.Data> list2 in sufferStateProperty.dataDictionary.Values)
{
foreach (SufferStateProperty.Data data2 in list2)
{
if (data2.isActive)
{
for (int j = 0; j < array.Length; j++)
{
if ((int)data2.toleranceValue[j] >= 100)
{
if (array[j] < 100)
{
array[j] = (int)data2.toleranceValue[j];
}
}
else if (array[j] < 100)
{
array[j] += (int)data2.toleranceValue[j];
}
}
}
}
}
}
return(array);
}
protected override IEnumerator MainRoutine()
{
CharacterStateControl attacker = base.battleStateData.currentSelectCharacterState;
if ((!attacker.isEnemy && !RandomExtension.Switch(base.hierarchyData.playerPursuitPercentage)) || (attacker.isEnemy && !RandomExtension.Switch(base.hierarchyData.enemyPursuitPercentage)))
{
yield break;
}
if (!attacker.currentSkillStatus.ThisSkillIsAttack)
{
yield break;
}
bool isConfusion = false;
SufferStateProperty confusionSuffer = attacker.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.Confusion);
if (confusionSuffer.isActive && confusionSuffer.GetOccurrenceFreeze())
{
isConfusion = true;
}
CharacterStateControl[] targets;
if (!isConfusion)
{
targets = ((!attacker.isEnemy) ? base.battleStateData.enemies : base.battleStateData.playerCharacters);
}
else
{
targets = (attacker.isEnemy ? base.battleStateData.enemies : base.battleStateData.playerCharacters);
}
int count = 0;
for (int i = 0; i < targets.Length; i++)
{
if (targets[i].isDied)
{
count++;
}
}
if (count == targets.Length)
{
yield break;
}
int index = 0;
do
{
index = UnityEngine.Random.Range(0, targets.Length);
attacker.targetCharacter = targets[index];
}while (attacker.targetCharacter.isDied);
base.stateManager.uiControl.ApplyTurnActionBarSwipeout(true);
base.stateManager.uiControl.ApplySkillName(true, StringMaster.GetString("BattleUI-46"), attacker);
IEnumerator wait2 = base.stateManager.time.WaitForCertainPeriodTimeAction(0.5f, null, null);
while (wait2.MoveNext())
{
object obj = wait2.Current;
yield return(obj);
}
base.stateManager.uiControl.ApplyTurnActionBarSwipeout(false);
attacker.isSelectSkill = attacker.SkillIdToIndexOf(base.stateManager.publicAttackSkillId);
attacker.isMultiAreaRandomDamageSkill = true;
base.SetState(typeof(SubStateMultiSkillDetailsFunction));
while (base.isWaitState)
{
yield return(null);
}
base.SetState(typeof(SubStatePlayChipEffect));
while (base.isWaitState)
{
yield return(null);
}
attacker.isMultiAreaRandomDamageSkill = false;
yield break;
}
private IEnumerator RegenerateFunction()
{
List <CharacterStateControl> characters = this.GetSufferCharacters(SufferStateProperty.SufferType.Regenerate);
if (characters.Count == 0)
{
yield break;
}
foreach (CharacterStateControl characterStateControl in base.stateManager.battleStateData.GetTotalCharacters())
{
base.stateManager.threeDAction.ShowAliveCharactersAction(new CharacterStateControl[]
{
characterStateControl
});
base.stateManager.threeDAction.PlayIdleAnimationUndeadCharactersAction(new CharacterStateControl[]
{
characterStateControl
});
}
base.stateManager.uiControl.HideCharacterHUDFunction();
base.stateManager.SetBattleScreen(BattleScreen.PoisonHit);
if (base.hierarchyData.batteWaves[base.battleStateData.currentWaveNumber].cameraType == 1)
{
base.stateManager.cameraControl.PlayCameraMotionAction("BigBoss/0002_command", base.battleStateData.stageSpawnPoint, true);
}
else
{
base.stateManager.cameraControl.PlayCameraMotionAction("0002_command", base.battleStateData.stageSpawnPoint, true);
}
HitEffectParams regenerate_effect = BattleEffectManager.Instance.GetEffect(AffectEffect.HpRevival.ToString()) as HitEffectParams;
this.use_effect_params_.Add(regenerate_effect);
List <int> damage = new List <int>();
List <bool> isMiss = new List <bool>();
for (int j = 0; j < characters.Count; j++)
{
SufferStateProperty sufferStateProperty = characters[j].currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.Regenerate);
int regenerate = sufferStateProperty.GetRegenerate(characters[j]);
characters[j].hp += regenerate;
damage.Add(regenerate);
isMiss.Add(false);
base.stateManager.threeDAction.PlayAnimationCharacterAction(CharacterAnimationType.revival, new CharacterStateControl[]
{
characters[j]
});
}
base.stateManager.soundPlayer.TryPlaySE(regenerate_effect);
List <HitIcon> hitIconlist = new List <HitIcon>();
Vector3[] hitIconPositions = this.GetHitIconPositions(characters);
for (int k = 0; k < characters.Count; k++)
{
HitIcon item = base.stateManager.uiControl.ApplyShowHitIcon(k, hitIconPositions[k], AffectEffect.Regenerate, damage[k], Strength.None, isMiss[k], false, false, false, false, ExtraEffectType.Non, true, null);
hitIconlist.Add(item);
}
base.stateManager.uiControl.ShowCharacterHUDFunction(characters.ToArray());
Action hudReposition = delegate()
{
foreach (CharacterStateControl characterStateControl2 in characters)
{
this.stateManager.uiControl.RepositionCharacterHUDPosition(new CharacterStateControl[]
{
characterStateControl2
});
}
for (int l = 0; l < characters.Count; l++)
{
Vector3 fixableCharacterCenterPosition2DFunction = this.stateManager.uiControl.GetFixableCharacterCenterPosition2DFunction(characters[l]);
hitIconlist[l].HitIconReposition(fixableCharacterCenterPosition2DFunction);
}
};
float waitSecond = base.stateManager.stateProperty.poisonHitEffectWaitSecond;
IEnumerator wait = base.stateManager.time.WaitForCertainPeriodTimeAction(waitSecond, hudReposition, null);
while (wait.MoveNext())
{
yield return(null);
}
base.stateManager.soundPlayer.TryStopSE(regenerate_effect);
base.stateManager.soundPlayer.StopHitEffectSE();
yield break;
}
public void SetSufferState(SufferStateProperty.Data data, CharacterStateControl status = null)
{
SufferStateProperty sufferStateProperty = this.sufferStatePropertyDictionary[data.sufferType];
sufferStateProperty.AddSufferStateProperty(data);
}
public void RoundCountingFunction(CharacterStateControl[] totalCharacters, int[] apRevivals)
{
foreach (CharacterStateControl characterStateControl in this.GetTotalCharacters())
{
if (!characterStateControl.isDied)
{
SufferStateProperty sufferStateProperty = characterStateControl.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.Sleep);
if (sufferStateProperty.isActive && sufferStateProperty.GetSleepGetupOccurrence())
{
characterStateControl.currentSufferState.RemoveSufferState(SufferStateProperty.SufferType.Sleep, false);
}
}
}
for (int j = 0; j < totalCharacters.Length; j++)
{
CharacterStateControl characterStateControl2 = totalCharacters[j];
if (!characterStateControl2.isDied)
{
bool flag = false;
if (characterStateControl2.currentSufferState.FindSufferState(SufferStateProperty.SufferType.ApRevival))
{
int revivalAp = characterStateControl2.currentSufferState.GetSufferStateProperty(SufferStateProperty.SufferType.ApRevival).GetRevivalAp(characterStateControl2.maxAp);
characterStateControl2.ap += revivalAp;
characterStateControl2.upAp += revivalAp;
flag = true;
}
if (apRevivals != null)
{
int num = apRevivals[j];
if (num > 0)
{
flag = true;
characterStateControl2.ap += num;
characterStateControl2.upAp += num;
}
}
if (characterStateControl2.StartMyRoundApUp() || flag)
{
int num2;
if (characterStateControl2.isEnemy)
{
num2 = base.battleStateData.playerCharacters.Length + characterStateControl2.myIndex;
}
else
{
num2 = characterStateControl2.myIndex;
}
base.battleStateData.isRoundStartApRevival[num2] = true;
}
}
else
{
characterStateControl2.ApZero();
}
characterStateControl2.HateReset();
}
base.battleStateData.totalRoundNumber++;
if (!base.battleStateData.GetCharactersDeath(true))
{
base.battleStateData.currentRoundNumber++;
}
base.stateManager.uiControl.ApplyWaveAndRound(base.battleStateData.currentWaveNumber, base.battleStateData.currentRoundNumber);
foreach (CharacterStateControl characterStateControl3 in this.GetTotalCharacters())
{
if (!characterStateControl3.isDied)
{
characterStateControl3.currentSufferState.RoundUpdate();
}
}
}
