private static bool CheckSkillSpecies(string effectTriggerValue, CharacterStateControl characterStateControl)
{
return(ChipEffectStatus.CheckSkillSendBase(characterStateControl) && (effectTriggerValue == "0" || characterStateControl.characterDatas.tribe == effectTriggerValue));
}
protected override IEnumerator MainRoutine()
{
if (base.hierarchyData.onAutoPlay != 0)
{
yield return(null);
yield break;
}
base.stateManager.uiControl.SetHudCollider(true);
for (;;)
{
base.battleStateData.commandSelectTweenTargetCamera.transitionScale = Time.timeScale;
if (!this.isOutCharacterView && !base.stateManager.time.isPause && Input.GetKeyUp(KeyCode.Mouse0))
{
this.isOutCharacterView = true;
if (base.battleStateData.enableRotateCam)
{
base.stateManager.cameraControl.StopCameraMotionAction("0007_commandCharaView");
base.stateManager.cameraControl.StopCameraMotionAction("BigBoss/0007_commandCharaView");
}
base.stateManager.cameraControl.PlayTweenCameraMotion(base.battleStateData.commandSelectTweenTargetCamera, null);
base.stateManager.cameraControl.SetCameraLengthAction(base.battleStateData.commandSelectTweenTargetCamera);
}
this.UpdateTarget();
if (base.battleStateData.isShowMenuWindow || base.battleStateData.isShowRevivalWindow)
{
base.stateManager.callAction.HideMonsterDescription();
base.stateManager.callAction.ForceHideSkillDescription();
}
if (base.hierarchyData.onAutoPlay != 0)
{
break;
}
if (base.battleStateData.onSkillTrigger)
{
goto Block_10;
}
if (!this.isOutCharacterView || this.lastCharacter == null || this.lastCharacter != this.currentCharacter.targetCharacter || base.battleStateData.commandSelectTweenTargetCamera.isMoving)
{
base.stateManager.uiControl.ApplyCurrentSelectArrow(true, base.stateManager.uiControl.GetHUDCenterPosition2DFunction(this.currentCharacter), this.currentCharacter.myIndex);
base.stateManager.uiControl.RepositionCharacterHUDPosition(base.battleStateData.GetTotalCharacters());
}
if (this.isOutCharacterView)
{
this.lastCharacter = this.currentCharacter.targetCharacter;
}
yield return(null);
}
if (base.hierarchyData.onAutoPlay == 2)
{
base.stateManager.targetSelect.AutoPlayCharacterAndSkillSelectFunction(this.currentCharacter);
}
else if (base.hierarchyData.onAutoPlay == 1)
{
base.stateManager.targetSelect.AutoPlayCharacterAndAttackSelectFunction(this.currentCharacter);
}
Block_10:
base.stateManager.uiControl.ApplyCurrentSelectArrow(false, default(Vector3), 0);
base.stateManager.uiControl.SetHudCollider(false);
yield break;
}
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();
}
}
}
public SkillResults GetOtherSkillResult(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);
}
skillResults.onMissHit = false;
AffectEffect type = affectEffectProperty.type;
switch (type)
{
case AffectEffect.CorrectionUpReset:
this.CorrectionUpReset(targetCharacter);
break;
case AffectEffect.CorrectionDownReset:
this.CorrectionDownReset(targetCharacter);
break;
case AffectEffect.HpRevival:
{
int num = this.HpRevival(targetCharacter, affectEffectProperty);
skillResults.attackPower = num;
skillResults.originalAttackPower = num;
break;
}
default:
switch (type)
{
case AffectEffect.HpSettingFixable:
{
int num2 = this.HpSettingFixable(targetCharacter, affectEffectProperty);
if (num2 > 0)
{
skillResults.hitIconAffectEffect = AffectEffect.HpRevival;
}
else
{
skillResults.hitIconAffectEffect = AffectEffect.Damage;
}
num2 = Mathf.Abs(num2);
skillResults.attackPower = num2;
skillResults.originalAttackPower = num2;
break;
}
case AffectEffect.HpSettingPercentage:
{
int num3 = this.HpSettingPercentage(targetCharacter, affectEffectProperty);
if (num3 > 0)
{
skillResults.hitIconAffectEffect = AffectEffect.HpRevival;
}
else
{
skillResults.hitIconAffectEffect = AffectEffect.Damage;
}
num3 = Mathf.Abs(num3);
skillResults.attackPower = num3;
skillResults.originalAttackPower = num3;
break;
}
case AffectEffect.Escape:
if (targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.Escape))
{
skillResults.onMissHit = true;
}
else
{
this.AddSufferStateOthers(targetCharacter, affectEffectProperty);
}
break;
case AffectEffect.Nothing:
break;
default:
if (type != AffectEffect.ApUp)
{
if (type != AffectEffect.ApDown)
{
if (type != AffectEffect.SufferStatusClear)
{
if (type != AffectEffect.Recommand)
{
this.AddSufferStateOthers(targetCharacter, affectEffectProperty);
}
else
{
targetCharacter.isRecommand = true;
}
}
else
{
this.SufferStatusClear(targetCharacter, affectEffectProperty);
}
}
else
{
this.ApDown(targetCharacter, affectEffectProperty);
}
}
else
{
this.ApUp(targetCharacter, affectEffectProperty);
}
break;
case AffectEffect.ClearTolerance:
this.ClearTolerance(targetCharacter, affectEffectProperty);
break;
}
break;
case AffectEffect.HateUp:
this.HateUp(targetCharacter, affectEffectProperty);
break;
case AffectEffect.HateDown:
this.HateDown(targetCharacter, affectEffectProperty);
break;
}
return(skillResults);
}
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);
}
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 void HateDown(CharacterStateControl target, AffectEffectProperty affectEffectProperty)
{
target.hate += affectEffectProperty.downPower;
}
private static bool CheckInvocation(string targetType, string targetSubType, string targetValue, string targetValue2, string effectType, string effectValue, string effectTrigger, string effectTriggerValue, int monsterGroupId, CharacterStateControl characterStateControl, int areaId)
{
if (effectType.ToInt32() == 56 && !ChipEffectStatus.CheckCounter(characterStateControl))
{
return(false);
}
switch (effectTrigger.ToInt32())
{
case 3:
case 4:
return(ChipEffectStatus.CheckWaveLoop(effectTriggerValue));
case 5:
return(ChipEffectStatus.CheckHpPercentage(effectTriggerValue, characterStateControl.hp, characterStateControl.extraMaxHp));
case 7:
return(ChipEffectStatus.CheckHpFixed(effectTriggerValue, characterStateControl.hp));
case 8:
case 9:
return(ChipEffectStatus.CheckRoundLoop(effectTriggerValue));
case 10:
return(ChipEffectStatus.CheckKill(effectTriggerValue, characterStateControl));
case 11:
return(ChipEffectStatus.CheckArea(effectTriggerValue, areaId));
case 12:
return(ChipEffectStatus.CheckAttackStarted(effectType, effectValue, characterStateControl));
case 13:
return(ChipEffectStatus.CheckSufferHit(effectTriggerValue, characterStateControl));
case 15:
return(ChipEffectStatus.CheckSkillStartedApMax(effectType, effectValue, characterStateControl));
case 16:
return(ChipEffectStatus.CheckAttackCommandedTarget(characterStateControl));
case 17:
return(ChipEffectStatus.CheckSkillSpecies(effectTriggerValue, characterStateControl));
case 18:
return(ChipEffectStatus.CheckSkillTargetSpecies(effectTriggerValue, characterStateControl));
case 19:
return(ChipEffectStatus.CheckSkillStartedSendAttribute(targetSubType, targetValue, targetValue2, effectTriggerValue, characterStateControl));
case 20:
return(ChipEffectStatus.CheckSkillStartedRecieveAttribute(targetSubType, targetValue, targetValue2, effectTriggerValue, characterStateControl));
case 22:
return(ChipEffectStatus.CheckMonsterGroupId(effectTriggerValue, monsterGroupId));
case 23:
return(ChipEffectStatus.CheckMonsterIntegrationGroupId(effectTriggerValue, characterStateControl.characterStatus.monsterIntegrationIds));
case 24:
return(ChipEffectStatus.CheckSkillDamageSend(characterStateControl));
case 25:
return(ChipEffectStatus.CheckSkillDamageRecieve(characterStateControl));
case 28:
case 29:
return(true);
case 37:
return(ChipEffectStatus.CheckSufferHit(effectTriggerValue, characterStateControl));
}
return(true);
}
public static float GetChipEffectValueToFloat(GameWebAPI.RespDataMA_ChipEffectM.ChipEffect[] chipEffects, float baseValue, CharacterStateControl character, EffectStatusBase.ExtraEffectType effectType)
{
return(ChipEffectStatus.GetChipEffectValueToFloat(chipEffects, baseValue, character.isEnemy, character.characterStatus.monsterIntegrationIds, character.groupId, character.tolerance, character.characterDatas.tribe, character.characterDatas.growStep, null, character.currentSufferState, ChipEffectStatus.GetTargetType(character, character), effectType, 0));
}
private static bool CheckSkillDamageRecieve(CharacterStateControl characterStateControl)
{
AffectEffectProperty[] skillRecieveBase = ChipEffectStatus.GetSkillRecieveBase(characterStateControl);
return(skillRecieveBase.Where((AffectEffectProperty item) => item.ThisSkillIsAttack).Any <AffectEffectProperty>());
}
private static bool CheckSkillSendBase(CharacterStateControl characterStateControl)
{
return(characterStateControl != null && characterStateControl == BattleStateManager.current.battleStateData.currentSelectCharacterState);
}
private static bool CheckSkillDamageSend(CharacterStateControl characterStateControl)
{
return(ChipEffectStatus.CheckSkillSendBase(characterStateControl) && characterStateControl.currentSkillStatus.ThisSkillIsAttack);
}
private static bool CheckSkillStartedRecieveAttribute(string targetSubType, string targetValue, string targetValue2, string effectTriggerValue, CharacterStateControl characterStateControl)
{
CharacterStateControl currentSelectCharacterState = BattleStateManager.current.battleStateData.currentSelectCharacterState;
SkillStatus currentSkillStatus = currentSelectCharacterState.currentSkillStatus;
List <AffectEffectProperty> affectEffect = currentSkillStatus.affectEffect;
foreach (AffectEffectProperty affectEffectProperty in affectEffect)
{
if (affectEffectProperty.ThisSkillIsAttack)
{
CharacterStateControl[] targets = ChipEffectStatus.GetTargets(currentSelectCharacterState, affectEffectProperty);
if (targets.Where((CharacterStateControl item) => item == characterStateControl).Any <CharacterStateControl>())
{
if (ChipEffectStatus.CheckSkillAttribute(affectEffectProperty, currentSkillStatus.skillType == SkillType.Attack, targetSubType, targetValue, targetValue2, effectTriggerValue))
{
return(true);
}
}
}
}
return(false);
}
private static bool CheckSkillStartedSendAttribute(string targetSubType, string targetValue, string targetValue2, string effectTriggerValue, CharacterStateControl characterStateControl)
{
if (ChipEffectStatus.CheckSkillSendBase(characterStateControl))
{
SkillStatus currentSkillStatus = characterStateControl.currentSkillStatus;
List <AffectEffectProperty> affectEffect = currentSkillStatus.affectEffect;
foreach (AffectEffectProperty affectEffectProperty in affectEffect)
{
if (affectEffectProperty.ThisSkillIsAttack)
{
CharacterStateControl[] targets = ChipEffectStatus.GetTargets(characterStateControl, affectEffectProperty);
if (!targets.Where((CharacterStateControl item) => item == characterStateControl).Any <CharacterStateControl>())
{
if (ChipEffectStatus.CheckSkillAttribute(affectEffectProperty, currentSkillStatus.skillType == SkillType.Attack, targetSubType, targetValue, targetValue2, effectTriggerValue))
{
return(true);
}
}
}
}
return(false);
}
return(false);
}
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
}));
}
public static int GetSkillPowerCorrectionValue(GameWebAPI.RespDataMA_ChipEffectM.ChipEffect[] chipEffects, AffectEffectProperty skillPropety, CharacterStateControl character, int attackNum = 0)
{
return((int)ChipEffectStatus.GetChipEffectValueToFloat(chipEffects, (float)skillPropety.GetPower(character), character.isEnemy, character.characterStatus.monsterIntegrationIds, character.groupId, character.tolerance, character.characterDatas.tribe, character.characterDatas.growStep, skillPropety, character.currentSufferState, ChipEffectStatus.GetTargetType(character, character), EffectStatusBase.ExtraEffectType.SkillPower, attackNum));
}
public static SkillResults GetStageDamageSkillResult(AffectEffectProperty affectEffectProperty, CharacterStateControl attackerCharacter, CharacterStateControl targetCharacter)
{
SkillResults skillResults = new SkillResults();
skillResults.useAffectEffectProperty = affectEffectProperty;
skillResults.hitIconAffectEffect = AffectEffect.Damage;
skillResults.attackCharacter = null;
skillResults.targetCharacter = targetCharacter;
skillResults.onMissHit = !affectEffectProperty.OnHit(attackerCharacter, targetCharacter);
skillResults.onWeakHit = targetCharacter.tolerance.GetAttributeStrength(affectEffectProperty.attribute);
if (skillResults.onMissHit)
{
return(skillResults);
}
if (affectEffectProperty.powerType == PowerType.Percentage && skillResults.onWeakHit == Strength.Invalid)
{
skillResults.hitIconAffectEffect = AffectEffect.Invalid;
}
else if (targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.TurnBarrier))
{
skillResults.hitIconAffectEffect = AffectEffect.TurnBarrier;
}
else if (targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.CountBarrier))
{
skillResults.hitIconAffectEffect = AffectEffect.CountBarrier;
}
else if (targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.TurnEvasion))
{
skillResults.hitIconAffectEffect = AffectEffect.TurnEvasion;
}
else if (targetCharacter.currentSufferState.FindSufferState(SufferStateProperty.SufferType.CountEvasion))
{
skillResults.hitIconAffectEffect = AffectEffect.CountEvasion;
}
else
{
int num;
if (affectEffectProperty.powerType == PowerType.Fixable)
{
num = affectEffectProperty.damagePower;
skillResults.onWeakHit = Strength.None;
}
else
{
SufferStateProperty.DamageRateResult reduceDamageRate = SkillStatus.GetReduceDamageRate(affectEffectProperty, attackerCharacter, targetCharacter);
skillResults.damageRateResult = reduceDamageRate;
float attributeDamegeResult = SkillStatus.GetAttributeDamegeResult(skillResults.onWeakHit);
num = (int)(affectEffectProperty.damagePercent * (float)targetCharacter.hp * reduceDamageRate.damageRate * attributeDamegeResult);
}
if (skillResults.onWeakHit != Strength.Drain)
{
targetCharacter.hp -= num;
}
else
{
targetCharacter.hp += num;
}
skillResults.attackPower = num;
skillResults.originalAttackPower = num;
}
return(skillResults);
}
public static float GetSkillDamageCorrectionValue(GameWebAPI.RespDataMA_ChipEffectM.ChipEffect[] chipEffects, AffectEffectProperty skillPropety, CharacterStateControl character)
{
return(ChipEffectStatus.GetChipEffectValueToFloat(chipEffects, 1f, character.isEnemy, character.characterStatus.monsterIntegrationIds, character.groupId, character.tolerance, character.characterDatas.tribe, character.characterDatas.growStep, skillPropety, character.currentSufferState, ChipEffectStatus.GetTargetType(character, character), EffectStatusBase.ExtraEffectType.SkillDamage, 0));
}
public void OnAttackUseAttackerAp(CharacterStateControl attackCharacter)
{
attackCharacter.ap -= this.GetCorrectedAp(attackCharacter);
}
public static List <ExtraEffectStatus> CheckStageEffectInvalid(List <ExtraEffectStatus> extraEffectStatusList, CharacterStateControl characterStateControl)
{
List <ExtraEffectStatus> list = new List <ExtraEffectStatus>();
foreach (ExtraEffectStatus extraEffectStatus in extraEffectStatusList)
{
if (!ChipEffectStatus.CheckStageEffectInvalid(characterStateControl, extraEffectStatus))
{
list.Add(extraEffectStatus);
}
}
return(list);
}
public void AddSufferStateOthers(CharacterStateControl target, AffectEffectProperty affectEffectProperty)
{
SufferStateProperty.Data data = new SufferStateProperty.Data(affectEffectProperty, base.battleStateData.currentLastGenerateStartTimingSufferState);
target.currentSufferState.SetSufferState(data, null);
base.battleStateData.currentLastGenerateStartTimingSufferState++;
}
private static ChipEffectStatus.TargetType GetTargetType(CharacterStateControl actor, CharacterStateControl target)
{
ChipEffectStatus.TargetType result;
if (actor == target)
{
result = ChipEffectStatus.TargetType.Actor;
}
else if (!actor.isEnemy)
{
if (!target.isEnemy)
{
result = ChipEffectStatus.TargetType.Player;
}
else
{
result = ChipEffectStatus.TargetType.Enemy;
}
}
else if (target.isEnemy)
{
result = ChipEffectStatus.TargetType.Player;
}
else
{
result = ChipEffectStatus.TargetType.Enemy;
}
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);
}
public void SetSufferState(SufferStateProperty.Data data, CharacterStateControl status = null)
{
SufferStateProperty sufferStateProperty = this.sufferStatePropertyDictionary[data.sufferType];
sufferStateProperty.AddSufferStateProperty(data);
}
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);
}
public int GetPowerFirst(CharacterStateControl characterStateControl = null)
{
AffectEffectProperty affectEffectAttackFirst = this.GetAffectEffectAttackFirst();
return((affectEffectAttackFirst == null) ? 0 : affectEffectAttackFirst.GetPower(characterStateControl));
}
private IEnumerator PlayerWinnerAction()
{
base.stateManager.SetBattleScreen(BattleScreen.PlayerWinner);
base.stateManager.time.SetPlaySpeed(false, false);
base.stateManager.uiControlMulti.HideAllDIalog();
base.stateManager.uiControlMulti.ShowWinnerUI();
base.stateManager.uiControl.ShowHidePlayerWinnerButton(false);
base.battleStateData.isSkipWinnerAction = false;
if (base.battleStateData.totalRoundNumber <= base.hierarchyData.speedClearRound && base.hierarchyData.speedClearRound > 0)
{
base.stateManager.battleUiComponents.playerWinnerUi.SpeedClearObjActive(true);
}
float startTime = Time.time;
base.stateManager.soundPlayer.TryStopBGM();
foreach (AlwaysEffectParams alwaysEffectParams in base.battleStateData.revivalReservedEffect)
{
alwaysEffectParams.gameObject.SetActive(false);
}
base.stateManager.threeDAction.ShowAliveCharactersAction(base.battleStateData.GetTotalCharacters());
IEnumerator motionResetAliveCharacterAction = base.stateManager.threeDAction.MotionResetAliveCharacterAction(base.battleStateData.playerCharacters);
while (motionResetAliveCharacterAction.MoveNext())
{
yield return(null);
}
Action playWinMotion = delegate()
{
base.stateManager.threeDAction.PlayAnimationCharacterAction(CharacterAnimationType.win, new CharacterStateControl[]
{
base.battleStateData.playerCharacters[base.battleStateData.lastAttackPlayerCharacterIndex]
});
};
IEnumerator WinMotionWaitAction = base.stateManager.time.WaitForCertainPeriodTimeAction(base.stateManager.stateProperty.winActionStartMotionWaitSecond, null, playWinMotion);
float waitTime = base.stateManager.uiProperty.winActionShowNextButtonWaitSecond;
IEnumerator waitNextButton = base.stateManager.time.WaitForCertainPeriodTimeAction(waitTime, null, null);
base.stateManager.cameraControl.StopCameraMotionAction("0007_commandCharaView");
base.stateManager.cameraControl.StopCameraMotionAction("BigBoss/0007_commandCharaView");
base.stateManager.cameraControl.StopCameraMotionAction("0002_command");
CharacterStateControl cameraTargetCharacter = base.battleStateData.playerCharacters[base.battleStateData.lastAttackPlayerCharacterIndex];
if (cameraTargetCharacter.isDied)
{
for (int j = 0; j < base.battleStateData.playerCharacters.Length; j++)
{
if (!base.battleStateData.playerCharacters[j].isDied)
{
cameraTargetCharacter = base.battleStateData.playerCharacters[j];
}
}
}
base.battleStateData.winCameraMotionInternalResources.StartAutoChange(cameraTargetCharacter.CharacterParams);
SoundPlayer.PlayBattleWinBGM();
if (base.stateManager.onServerConnect)
{
IEnumerator sendClearResult = base.stateManager.multiFunction.SendClearResult();
while (waitNextButton.MoveNext() || sendClearResult.MoveNext())
{
WinMotionWaitAction.MoveNext();
yield return(null);
}
}
else
{
while (waitNextButton.MoveNext())
{
WinMotionWaitAction.MoveNext();
yield return(null);
}
}
base.stateManager.uiControl.ShowHidePlayerWinnerButton(true);
while (!base.battleStateData.isSkipWinnerAction)
{
WinMotionWaitAction.MoveNext();
yield return(null);
}
float endTime = Time.time;
while (endTime - startTime < 3f)
{
endTime = Time.time;
yield return(null);
}
SoundPlayer.StopBattleWinBGM();
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);
}
public void CharacterWaveReset(int waveNumber, bool isRecover = false)
{
this.BattleWaveChangeResourcesCleaning();
base.battleStateData.enemies = base.battleStateData.preloadEnemies[waveNumber];
base.battleStateData.leaderEnemyCharacter = base.battleStateData.enemies[base.hierarchyData.leaderCharacter];
int cameraType = base.hierarchyData.batteWaves[waveNumber].cameraType;
string spawnPointId = ResourcesPath.ReservedID.SpawnPoints.GetSpawnPointId(base.battleStateData.enemies.Length, base.battleMode, cameraType);
SpawnPointParams @object = base.battleStateData.preloadSpawnPoints.GetObject(spawnPointId);
base.battleStateData.ApplySpawnPoint(@object);
foreach (CharacterParams characterParams in base.battleStateData.preloadEnemiesParams.GetAllObject())
{
characterParams.gameObject.SetActive(false);
}
Dictionary <string, int> dictionary = new Dictionary <string, int>();
for (int j = 0; j < base.battleStateData.enemies.Length; j++)
{
string prefabId = base.battleStateData.enemies[j].characterStatus.prefabId;
int num = 0;
if (dictionary.ContainsKey(prefabId))
{
Dictionary <string, int> dictionary2;
string key;
(dictionary2 = dictionary)[key = prefabId] = dictionary2[key] + 1;
num = dictionary[prefabId];
}
else
{
dictionary.Add(prefabId, 0);
}
this.WaveResetEnemyResetupFunction(prefabId, num, j, isRecover);
int index = base.battleStateData.playerCharacters.Length + j;
base.stateManager.uiControl.ApplyCharacterHudBoss(index, base.hierarchyData.batteWaves[waveNumber].enemiesBossFlag[j]);
base.stateManager.uiControl.ApplyCharacterHudContent(index, base.battleStateData.enemies[j]);
base.stateManager.uiControl.ApplyCharacterHudReset(index);
}
base.stateManager.uiControl.ApplyBigBossCharacterHudBoss(false);
base.stateManager.uiControl.ApplyBigBossCharacterHudContent(base.battleStateData.enemies[0]);
base.stateManager.uiControl.ApplyBigBossCharacterHudReset();
for (int k = 0; k < base.battleStateData.playerCharacters.Length; k++)
{
this.WaveResetPlayerResetupFunction(k);
CharacterStateControl characterStateControl = base.battleStateData.playerCharacters[k];
if (!characterStateControl.isDied)
{
if (!isRecover)
{
if (characterStateControl.WaveCountInitialize(base.hierarchyData.batteWaves[waveNumber].hpRevivalPercentage))
{
base.battleStateData.isRoundStartHpRevival[k] = true;
}
}
if (waveNumber == 0)
{
base.stateManager.uiControl.ApplyCharacterHudBoss(k, false);
base.stateManager.uiControl.ApplyCharacterHudContent(k, characterStateControl);
base.stateManager.uiControl.ApplyCharacterHudReset(k);
}
}
}
}
private static bool CheckSkillStartedApMax(string effectType, string effectValue, CharacterStateControl characterStateControl)
{
return(ChipEffectStatus.CheckSkillSendBase(characterStateControl) && characterStateControl.ap == characterStateControl.maxAp);
}
