using System;
using System.Collections.Generic;
using Mevius.App;
using Mevius.Collaboration.FF7;
using Mevius.Common;
using Mevius.DataSheet;
using Mevius.Db;
using Mevius.Db.Event;
using Mevius.Debug;
using Mevius.Effect;
using Mevius.Field;
using Mevius.Gui;
using Mevius.Loader;
using Mevius.Motion;
using Mevius.Network;
using Mevius.Party;
using Mevius.Renderer;
using Mevius.Script;
using Mevius.Sound;
using Mevius.Zone;
using UnityEngine;

namespace Mevius.Battle
{
    public class BattleManager : BackgroundLoader, IDisposable, IManager
    {
        public BattleManager()
        {
            this.BattleHash = this.GetHashCode();
            ZoneActionSequenceExecutor._i.AddBackgourdLoader(ActionInfo.Type.Sequence_Battle, this);
            ZoneActionSequenceExecutor._i.AddBackgourdLoader(ActionInfo.Type.Sequence_BossBattle, this);
            ZoneActionSequenceExecutor i = ZoneActionSequenceExecutor._i;
            i.changeActionStartCallback2 = (ZoneActionSequenceExecutor.ChangeActionCallback)Delegate.Combine(i.changeActionStartCallback2, new ZoneActionSequenceExecutor.ChangeActionCallback(this.ChangeActionStart));
            ZoneActionSequenceExecutor i2 = ZoneActionSequenceExecutor._i;
            i2.changeActionEndCallback2 = (ZoneActionSequenceExecutor.ChangeActionCallback)Delegate.Combine(i2.changeActionEndCallback2, new ZoneActionSequenceExecutor.ChangeActionCallback(this.ChangeActionEnd));
            ZoneActionSequenceExecutor i3 = ZoneActionSequenceExecutor._i;
            i3.changeCameraStartCallback2 = (ZoneActionSequenceExecutor.ChangeCameraCallback)Delegate.Combine(i3.changeCameraStartCallback2, new ZoneActionSequenceExecutor.ChangeCameraCallback(this.ChangeActionCameraStart));
            ZoneActionSequenceExecutor i4 = ZoneActionSequenceExecutor._i;
            i4.changeCameraEndCallback2 = (ZoneActionSequenceExecutor.ChangeCameraCallback)Delegate.Combine(i4.changeCameraEndCallback2, new ZoneActionSequenceExecutor.ChangeCameraCallback(this.ChangeActionCameraEnd));
        }

        public string Name()
        {
            return "BattleManager";
        }

        public BattleManager.ResourceStep GetResourceStep()
        {
            return this._resourceStep;
        }

        public BattleManager.MultiBattleCmdStep GetMultiBattleCmdStep()
        {
            return this.m_multiBattleCmdStep;
        }

        public int GetActorCount()
        {
            return this._actorNameList.Count;
        }

        public bool LastBattleFlag
        {
            get
            {
                return this.m_lastBattle;
            }
        }

        public Vector3 BasePosition
        {
            get
            {
                return this._basePosition;
            }
            set
            {
                this._basePosition = value;
            }
        }

        public bool PartyMemberTurn
        {
            get
            {
                return this.m_partyMemberTurn;
            }
        }

        public bool MultiBattleIgnoreMemberActionCamera
        {
            get
            {
                return this.m_multiBattleIgnoreMemberActionCamera;
            }
            set
            {
                this.m_multiBattleIgnoreMemberActionCamera = value;
            }
        }

        public BattleManager.AutoAttackStrategyType AutoAttackStrategy
        {
            get
            {
                if (DbManager._i != null)
                {
                    return (BattleManager.AutoAttackStrategyType)DbManager._i._battle_auto_type;
                }
                return BattleManager.AutoAttackStrategyType.DefensiveType;
            }
            set
            {
                if (DbManager._i != null)
                {
                    DbManager._i._battle_auto_type = (ushort)value;
                }
            }
        }

        public bool IsMultiBattleTest
        {
            get
            {
                return this.m_bMultiBattleTest;
            }
            set
            {
                this.m_bMultiBattleTest = value;
            }
        }

        public List<BattleActor> ScreenOrderEnemyActorList
        {
            get
            {
                if (this.m_screenOrderEnemyActorList.Count == 0)
                {
                    this.CalcScreenOrderEnemyList();
                }
                return this.m_screenOrderEnemyActorList;
            }
        }

        public void TouchAreaEvent(bool isPressed, bool ignoreAttack)
        {
            if (isPressed)
            {
                this.m_guiTouchComponent.m_stateBit |= 3u;
            }
            else
            {
                this.m_guiTouchComponent.m_stateBit = 4u;
            }
            this.m_ignoreAttack = ignoreAttack;
        }

        public int RandCount
        {
            get
            {
                return this.m_randCount;
            }
        }

        public int DamageRandCount
        {
            get
            {
                return this.m_damageRandCount;
            }
        }

        public int MovementRandCount
        {
            get
            {
                return this.m_movementRandCount;
            }
        }

        public bool EnemyActionEndFlag
        {
            get
            {
                return this.m_enemyActionEndFlag;
            }
        }

        public BattleManager.ESubActionType SubActionType
        {
            get
            {
                return this.m_subActionType;
            }
            set
            {
                this.m_subActionType = value;
            }
        }

        public OptimaType OptimaType
        {
            get
            {
                return this.m_optimaType;
            }
            set
            {
                this.m_optimaType = value;
            }
        }

        public byte[] OptimaUseCounts
        {
            get
            {
                return this.m_optimaUseCounts;
            }
            set
            {
                this.m_optimaUseCounts = value;
            }
        }

        public BattleActor DQLogActor
        {
            get
            {
                return this.m_dqLogActor;
            }
            set
            {
                this.m_dqLogActor = value;
            }
        }

        public byte[] FF7AbilityUseCounts
        {
            get
            {
                return this.m_ff7AbilityUseCounts;
            }
            set
            {
                this.m_ff7AbilityUseCounts = value;
            }
        }

        public BattleManager.DrawAbility[] FF8DrawAbility
        {
            get
            {
                return this.ff8DrawAbility;
            }
        }

        public void Dispose()
        {
            ZoneActionSequenceExecutor i = ZoneActionSequenceExecutor._i;
            i.changeCameraEndCallback2 = (ZoneActionSequenceExecutor.ChangeCameraCallback)Delegate.Remove(i.changeCameraEndCallback2, new ZoneActionSequenceExecutor.ChangeCameraCallback(this.ChangeActionCameraEnd));
            ZoneActionSequenceExecutor i2 = ZoneActionSequenceExecutor._i;
            i2.changeCameraStartCallback2 = (ZoneActionSequenceExecutor.ChangeCameraCallback)Delegate.Remove(i2.changeCameraStartCallback2, new ZoneActionSequenceExecutor.ChangeCameraCallback(this.ChangeActionCameraStart));
            ZoneActionSequenceExecutor i3 = ZoneActionSequenceExecutor._i;
            i3.changeActionEndCallback2 = (ZoneActionSequenceExecutor.ChangeActionCallback)Delegate.Remove(i3.changeActionEndCallback2, new ZoneActionSequenceExecutor.ChangeActionCallback(this.ChangeActionEnd));
            ZoneActionSequenceExecutor i4 = ZoneActionSequenceExecutor._i;
            i4.changeActionStartCallback2 = (ZoneActionSequenceExecutor.ChangeActionCallback)Delegate.Remove(i4.changeActionStartCallback2, new ZoneActionSequenceExecutor.ChangeActionCallback(this.ChangeActionStart));
        }

        public override void Load(int actionIndex)
        {
            ActionInfo action = ZoneActionSequenceExecutor._i.GetAction(actionIndex);
            if (action != null)
            {
                this.currentBattleScene = action.GetElementAction().m3dd07754649a1e43955998e34289003c();
            }
            if (this._resourceStep == BattleManager.ResourceStep.None)
            {
                this._resourceStep = BattleManager.ResourceStep.Init;
            }
            this._enableUnloadRequest = false;
        }

        public override bool IsLoaded(int actionIndex)
        {
            return this._resourceStep == BattleManager.ResourceStep.EndRequestWait;
        }

        public override void Active(int actionIndex)
        {
            this._active = true;
            this.StartBattle();
        }

        public override void Deactive(int actionIndex)
        {
            this._step = BattleManager.BattleStep.ResourceStepUnload;
            this._active = false;
        }

        public override void Unload(int actionIndex)
        {
            this.resourceUnloadTaskId = 0u;
            if (this._resourceStep == BattleManager.ResourceStep.EndRequestWait)
            {
                this.resourceUnloadTaskId = Mevius.App.Api.CreateTaskId();
                this._resourceStep = BattleManager.ResourceStep.RemoveActor;
            }
        }

        public override void End(int actionIndex)
        {
        }

        public override bool IsUnloaded(int actionIndex)
        {
            return this._resourceStep == BattleManager.ResourceStep.None;
        }

        public override bool IsEndActionCamera(int actionIndex)
        {
            return this._active && this._step == BattleManager.BattleStep.ActionCameraEndWait;
        }

        public override bool IsEndResource(int actionIndex)
        {
            return this._enableUnloadRequest && this._step > BattleManager.BattleStep.PlayerTurnStart && this._step >= BattleManager.BattleStep.Result;
        }

        public override bool IsUnloadable(int actionIndex, string resourceName)
        {
            return true;
        }

        public override bool IsRequestNext(int actionIndex)
        {
            return this._step >= BattleManager.BattleStep.ResultEnd;
        }

        public void StartBattle()
        {
            if (this._step == BattleManager.BattleStep.None)
            {
                this.requestStartBattle = false;
                this._step = BattleManager.BattleStep.CreateActor;
            }
            else
            {
                this.requestStartBattle = true;
            }
        }

        public bool IsLoadResource()
        {
            return this._resourceStep != BattleManager.ResourceStep.None;
        }

        public bool IsBattleWin()
        {
            return BattleManager.BattleStep.ResultReady <= this._step && this._step <= BattleManager.BattleStep.ResultEnd;
        }

        public bool IsBattleEnd()
        {
            return this._step == BattleManager.BattleStep.Exit;
        }

        public static string GetEnemyActorName(int c)
        {
            return "enemy_" + c.ToString();
        }

        public static string GetBattlePlayerName()
        {
            return Mevius.Db.Api.GetPlayerName() + "_battle";
        }

        public static string GetBattlePlayerSubName()
        {
            return Mevius.Db.Api.GetPlayerName() + "_battle_sub";
        }

        public static string GetMultiMemberPlayerName(Mevius.Party.Api.PARTY_MEMBER_TYPE type)
        {
            string result = string.Empty;
            switch (type)
            {
            case Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_NPC1:
                result = Mevius.Db.Api.GetPlayerName() + "_battle2";
                break;
            case Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_NPC2:
                result = Mevius.Db.Api.GetPlayerName() + "_battle3";
                break;
            case Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_NPC3:
                result = Mevius.Db.Api.GetPlayerName() + "_battle4";
                break;
            case Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_ME:
                result = BattleManager.GetBattlePlayerName();
                break;
            }
            return result;
        }

        public BattleManager.BattleStep GetStep()
        {
            return this._step;
        }

        public void InitStep()
        {
            this._step = BattleManager.BattleStep.None;
        }

        public void ChangeActionStart()
        {
            if (ZoneActionSequenceExecutor._i.GetCurrentAction().IsBattle())
            {
            }
        }

        public void ChangeActionEnd()
        {
            ActionInfo prevAction = ZoneActionSequenceExecutor._i.GetPrevAction();
            ActionInfo currentAction = ZoneActionSequenceExecutor._i.GetCurrentAction();
            if ((prevAction != null && prevAction.IsBattle()) || (currentAction != null && currentAction.ActionType == ActionInfo.Type.Sequence_End))
            {
                this.InitStep();
            }
        }

        public void ChangeActionCameraStart()
        {
            ActionInfo currentActionCamera = Mevius.Zone.Api.GetCurrentActionCamera();
            ActionInfo nextActionCamera = Mevius.Zone.Api.GetNextActionCamera();
            if (currentActionCamera != null && currentActionCamera.IsBattle() && this.m_cameraManager != null)
            {
                FieldManager._i.fieldCameraController.fieldCamera.SetCamera(this.m_cameraManager.CameraSequence.Eye, this.m_cameraManager.CameraSequence.Aim, this.m_cameraManager.CameraSequence.Roll, Vector3.up, FieldManager._i.fieldCameraController.fieldCamera.nearClipPlane, FieldManager._i.fieldCameraController.fieldCamera.farClipPlane, this.m_cameraManager.CameraSequence.Fov, FieldManager._i.fieldCameraController.fieldCamera.fNumber);
            }
        }

        public void ChangeActionCameraEnd()
        {
            ActionInfo currentActionCamera = Mevius.Zone.Api.GetCurrentActionCamera();
            if (currentActionCamera != null)
            {
                if (currentActionCamera.IsBattle())
                {
                    bool bossLevel = false;
                    if (currentActionCamera.GetElementAction().m57804671548549f75a433d28698e5d1f() == "bosslevel" || currentActionCamera.ActionType == ActionInfo.Type.Sequence_BossBattle)
                    {
                        bossLevel = true;
                    }
                    string targetGadgetName = Mevius.Field.Api.GadgetRouteApi.GetTargetGadgetName();
                    int targetLevel = Mevius.Field.Api.BattleApi.GetTargetLevel(targetGadgetName, bossLevel, false, -1, Mevius.App.Api.GetMainJobTypeCurrentDeck());
                    Mevius.Battle.Api.SetBattleEnemyLevel(targetLevel);
                }
                ActionInfo actionInfo = currentActionCamera;
                if (currentActionCamera.IsBattle() || actionInfo.ActionType == ActionInfo.Type.Sequence_HitBossVisibleModel || actionInfo.ActionType == ActionInfo.Type.Sequence_AppearBoss)
                {
                    Mevius.Gui.Api.SetFieldMenuMode(GuiFieldMenu.Mode.ViewFull, false);
                    if (!Mevius.Zone.Api.IsCancelZoneActionSequence())
                    {
                        DbManager.TemporarySaveData temporarySaveData = Mevius.Db.Api.GetTemporarySaveData();
                        string targetGadgetName2 = Mevius.Field.Api.GadgetRouteApi.GetTargetGadgetName();
                        string stateChangeName = Mevius.Field.Api.GadgetRouteApi.GetStateChangeName(targetGadgetName2);
                        Cf2cd309e997d6caaa7b19cc23dfe235b.Cfa0ba6c176c70705c5a33b1796b4787d cfa0ba6c176c70705c5a33b1796b4787d = Cf2cd309e997d6caaa7b19cc23dfe235b.Find(stateChangeName);
                        bool flag = false;
                        if (temporarySaveData.type == DbManager.ActionSequenceType.Search)
                        {
                            string actionSequenceAreaBattle = Mevius.Field.Api.DatasheetApi.GetActionSequenceAreaBattle(targetGadgetName2);
                            if (!string.IsNullOrEmpty(actionSequenceAreaBattle))
                            {
                                flag = true;
                            }
                            bool flag2;
                            if (!string.IsNullOrEmpty(Mevius.Field.Api.BattleApi.GetBossName(targetGadgetName2, out flag2)) && flag2)
                            {
                                flag = true;
                            }
                        }
                        if (actionInfo.ActionType == ActionInfo.Type.Sequence_HitBossVisibleModel || actionInfo.ActionType == ActionInfo.Type.Sequence_AppearBoss)
                        {
                            flag = true;
                        }
                        else
                        {
                            string soundResourceName = Mevius.Sound.Api.GetSoundResourceName("Resident");
                            Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Field, soundResourceName, Mevius.DataSheet.Api.GetResidentString("EncountSe", "system_se_encount_in"), 1f, 0, 0, false, -1, 1f);
                        }
                        if (flag)
                        {
                            actionInfo = Mevius.Zone.Api.GetLastBattleAction();
                        }
                        if (BattleManager._i.IsFirstBattle())
                        {
                            this.m_isBgmRandSet = false;
                        }
                        if (!this.m_isBgmRandSet)
                        {
                            this.m_isBgmRandSet = true;
                            this.m_bgmRandValue = Mevius.Common.Random.GetInstance().GetUnsignedInteger();
                        }
                        this.PlayBattleBgm(actionInfo);
                    }
                }
            }
        }

        private void SetEnemyCamera(BattleActor actor)
        {
            if (this.m_boss)
            {
                if (this.CameraManager.CurrentCameraType != BattleCameraManager.CameraType.Action || !this.CameraManager.IsActionOwner(actor))
                {
                    this.CameraManager.SetInterpolation(0.5f, CameraSequence.BlendType.Curve, true);
                    this.CameraManager.InitTargetSelect(this.m_boss, this.m_playerActor, actor);
                    this.CameraManager.ChangeCamera(BattleCameraManager.CameraType.TargetSelect);
                }
            }
            else if (this.CameraManager.CurrentCameraType != BattleCameraManager.CameraType.Action)
            {
                string name = ExtensionElementIdDefinition.GetName(ExtensionElementIdDefinition.Index.BODY_CENTER);
                Vector3 position = actor.chara.GetElementIdTransform(name).position;
                Camera component = Mevius.Renderer.CameraManager.GetInstance().GetViewCameraGameObject().GetComponent<Camera>();
                Vector3 vector = component.WorldToViewportPoint(position);
                if (vector.x < 0f || vector.x > 1f || vector.y < 0f || vector.y > 1f || vector.z <= 0f)
                {
                    this.CameraManager.SetInterpolation(1f, CameraSequence.BlendType.Curve, true);
                    this.CameraManager.InitTwoShot(actor, this.m_playerActor, 0, false);
                    this.CameraManager.ChangeCamera(BattleCameraManager.CameraType.TwoShot);
                }
            }
            else if (!this.CameraManager.IsActionOwner(actor))
            {
                this.CameraManager.SetInterpolation(0.5f, CameraSequence.BlendType.Curve, true);
                this.CameraManager.InitTwoShot(actor, this.m_playerActor, 0, false);
                this.CameraManager.ChangeCamera(BattleCameraManager.CameraType.TwoShot);
            }
        }

        public void PlayBattleBgm(ActionInfo action)
        {
            string text = string.Empty;
            this.m_isJobBgm = false;
            if (action != null)
            {
                if (action.GetElementAction().m91e6a331d5ec22b58b96fcc04375134c().Length > 0)
                {
                    text = action.GetElementAction().m91e6a331d5ec22b58b96fcc04375134c();
                }
                else if (action.GetElementAction().m57804671548549f75a433d28698e5d1f() == "accent")
                {
                    text = Mevius.DataSheet.Api.GetResidentString("bgmBattleAccent", string.Empty);
                }
            }
            if (string.IsNullOrEmpty(text))
            {
                this.m_isJobBgm = true;
                int num;
                if (Mevius.App.Api.IsPartyMode())
                {
                    num = Mevius.Db.Api.GetCurrentCardDeck2() + 24;
                }
                else
                {
                    num = Mevius.Db.Api.GetCurrentCardDeck();
                    if (Mevius.Db.Api.GetParameter(DbManager.ParameterType.Current_Job) != 0)
                    {
                        num += 12;
                    }
                }
                text = BattleUtility.GetBgmName(num, this.m_bgmRandValue);
            }
            Mevius.Sound.Api.PlayBgm(BgmManager.BgmLayer.Bgm_Battle, text, 0, 1f);
        }

        public void CreateCameraManager()
        {
            this.m_cameraManager = new BattleCameraManager();
        }

        public void RemoveCameraManager()
        {
            if (this.m_cameraManager != null)
            {
                this.m_cameraManager.Dispose();
                this.m_cameraManager = null;
            }
        }

        public bool IsFirstBattle()
        {
            LinkedListNode<ActionInfo> currentActionCameraNode = Mevius.Zone.Api.GetCurrentActionCameraNode();
            LinkedListNode<ActionInfo> linkedListNode = null;
            if (currentActionCameraNode != null)
            {
                if (!currentActionCameraNode.Value.IsBattle())
                {
                    return false;
                }
                linkedListNode = currentActionCameraNode.Previous;
            }
            while (linkedListNode != null)
            {
                if (linkedListNode.Value.IsBattle())
                {
                    return false;
                }
                linkedListNode = linkedListNode.Previous;
            }
            return true;
        }

        public bool IsLastBattle()
        {
            LinkedListNode<ActionInfo> currentActionNode = Mevius.Zone.Api.GetCurrentActionNode();
            LinkedListNode<ActionInfo> linkedListNode = null;
            if (currentActionNode != null)
            {
                linkedListNode = currentActionNode.Next;
            }
            if (linkedListNode == null || linkedListNode.Value.ActionType == ActionInfo.Type.Sequence_Move)
            {
                return true;
            }
            while (linkedListNode != null)
            {
                if (linkedListNode.Value.IsBattle())
                {
                    return false;
                }
                linkedListNode = linkedListNode.Next;
            }
            return true;
        }

        public void SetBattleWin(float startWait = 0f)
        {
            if (!Mevius.App.Api.IsPartyMode() && this.m_lastBattle && !this.m_lastBgmVolumeChanged)
            {
                this.m_lastBgmVolumeChanged = true;
                BgmManager._i.ChangeCurrentBgmVolume(Mevius.DataSheet.Api.GetResidentFloat("bgmBattleVolumeOnWinning", 1f), 500);
            }
            this.m_actionStepWait = startWait;
            this._step = BattleManager.BattleStep.ResultReady;
        }

        public void SetBattleWinImmediate(bool killEnemy = true)
        {
            this.m_surfaceBlendAlpha = 1f;
            if (this.m_surfaceBlend == null)
            {
                this.m_surfaceBlend = MainLoop._i.gameObject.AddComponent<SurfaceBlend>();
            }
            this.m_surfaceBlend.SetAlpha(this.m_surfaceBlendAlpha);
            RenderUtility.GetInstance().SetViewCloneEnabled(true);
            int actionIndex = Mevius.Zone.Api.GetActionIndex();
            int num = -1;
            C098a168d3605b12448638cab8ccafe9d.C6a63ba3da59f35f0fee059da0f7321db c6a63ba3da59f35f0fee059da0f7321db = C098a168d3605b12448638cab8ccafe9d.Find(this.currentBattleScene);
            if (Mevius.App.Api.IsPartyMode())
            {
                DbManager.MultiBattleData multiBattleData = Mevius.Db.Api.GetMultiBattleData();
                if (multiBattleData != null)
                {
                    for (int i = 0; i < multiBattleData.enemyEscapeActionIndex.Length; i++)
                    {
                        if (multiBattleData.enemyEscapeActionIndex[i] == actionIndex || multiBattleData.enemyEscapeActionIndex[i] == -1)
                        {
                            num = i;
                            break;
                        }
                    }
                    for (int j = 0; j < this._entryBattleCharaSpecList.Count; j++)
                    {
                        string enemyActorName = BattleManager.GetEnemyActorName(j);
                        BattleActor battleActor = this.FindActor(enemyActorName);
                        if (battleActor != null)
                        {
                            if (c6a63ba3da59f35f0fee059da0f7321db.m4f63acfb743cb25115f76fc77af6151e(j) != 0 || battleActor.IsUnTarget())
                            {
                                multiBattleData.enemyEscapeActionIndex[num] = actionIndex;
                                if (0 <= battleActor.EnemyIndex && battleActor.EnemyIndex < multiBattleData.enemyEscapeCharaFlags.GetLength(1))
                                {
                                    multiBattleData.enemyEscapeCharaFlags[num, battleActor.EnemyIndex] = true;
                                }
                            }
                            if (battleActor.IsActiveTarget())
                            {
                                if (battleActor.IsNeedNotKill() || !killEnemy)
                                {
                                    if (num != -1)
                                    {
                                        multiBattleData.enemyEscapeActionIndex[num] = actionIndex;
                                        if (0 <= battleActor.EnemyIndex && battleActor.EnemyIndex < multiBattleData.enemyEscapeCharaFlags.GetLength(1))
                                        {
                                            multiBattleData.enemyEscapeCharaFlags[num, battleActor.EnemyIndex] = true;
                                        }
                                    }
                                }
                                else
                                {
                                    battleActor.SetHp(0, false, false);
                                    battleActor.OnDead();
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                DbManager.BattleData battleData = Mevius.Db.Api.GetBattleData();
                for (int k = 0; k < battleData.enemyEscapeActionIndex.Length; k++)
                {
                    if (battleData.enemyEscapeActionIndex[k] == actionIndex || battleData.enemyEscapeActionIndex[k] == -1)
                    {
                        num = k;
                        break;
                    }
                }
                for (int l = 0; l < this._entryBattleCharaSpecList.Count; l++)
                {
                    string enemyActorName2 = BattleManager.GetEnemyActorName(l);
                    BattleActor battleActor2 = this.FindActor(enemyActorName2);
                    if (battleActor2 != null)
                    {
                        if (c6a63ba3da59f35f0fee059da0f7321db.m4f63acfb743cb25115f76fc77af6151e(l) != 0 || battleActor2.IsUnTarget())
                        {
                            battleData.enemyEscapeActionIndex[num] = actionIndex;
                            if (0 <= battleActor2.EnemyIndex && battleActor2.EnemyIndex < battleData.enemyEscapeCharaFlags.GetLength(1))
                            {
                                battleData.enemyEscapeCharaFlags[num, battleActor2.EnemyIndex] = true;
                            }
                        }
                        if (battleActor2.IsActiveTarget())
                        {
                            if (battleActor2.IsNeedNotKill() || !killEnemy)
                            {
                                if (num != -1)
                                {
                                    battleData.enemyEscapeActionIndex[num] = actionIndex;
                                    if (0 <= battleActor2.EnemyIndex && battleActor2.EnemyIndex < battleData.enemyEscapeCharaFlags.GetLength(1))
                                    {
                                        battleData.enemyEscapeCharaFlags[num, battleActor2.EnemyIndex] = true;
                                    }
                                }
                            }
                            else
                            {
                                battleActor2.SetHp(0, false, false);
                                battleActor2.OnDead();
                            }
                        }
                    }
                }
                if (this.m_playerActor.IsSubActionSub())
                {
                    BattleManager._i.GetPlayerActorSub().UpdateStatusEffectActionEnd();
                }
                this.EndZone(this.m_subActionType == BattleManager.ESubActionType.JobAbility, false);
                this.ChangeActionValue(BattleManager.ChangeActionValueType.BattleEnd, false);
            }
            if (this.m_playerActor.IsSummon())
            {
                this.ProcChangeJob(false, true);
            }
            this.m_playerActor.OnBattleWin();
            if (this.m_playerActorSub != null)
            {
                this.m_playerActorSub.OnBattleWin();
            }
            int currentDeckIndex = BattleUtility.GetCurrentDeckIndex();
            string resultBgmName = BattleUtility.GetResultBgmName(currentDeckIndex);
            float volume = (!this.m_lastBattle) ? 1f : Mevius.DataSheet.Api.GetResidentFloat("bgmBattleVolumeOnWinning", 1f);
            ActionInfo currentActionCamera = Mevius.Zone.Api.GetCurrentActionCamera();
            if (currentActionCamera != null && currentActionCamera.GetElementAction().m097866f1118d7f9304b7e72288586ca3().Length > 0)
            {
                Mevius.Sound.Api.PlayBgm(BgmManager.BgmLayer.Bgm_ActionBottom, currentActionCamera.GetElementAction().m097866f1118d7f9304b7e72288586ca3(), 0, volume);
            }
            else if (!string.IsNullOrEmpty(resultBgmName) && this.m_lastBattle)
            {
                Mevius.Sound.Api.PlayBgm(BgmManager.BgmLayer.Bgm_Battle, resultBgmName, 0, volume);
            }
            this.EndBattle();
            this._step = BattleManager.BattleStep.Result;
        }

        public void OnLastBattleWin(BattleManager.LastBattleWinCameraType cameraType)
        {
            if (Mevius.Db.Api.GetBattleActionSequenceCurrentStep() == Mevius.Db.Api.GetBattleActionSequenceMaxStep() && !Mevius.Battle.Api.IsLastEnemyEscape())
            {
                bool flag = false;
                if (cameraType == BattleManager.LastBattleWinCameraType.Player)
                {
                    AppActor appActor = Mevius.App.Api.FindAppActor(Mevius.Db.Api.GetPlayerName());
                    if (appActor != null)
                    {
                        string replaceCharaSpecName = Mevius.Battle.Api.GetReplaceCharaSpecName(appActor.getSpec());
                        C95bcaea3352f97e159106604018eaa69.Cd665cdef191ff92708675209607d4634 cd665cdef191ff92708675209607d = C95bcaea3352f97e159106604018eaa69.Find(replaceCharaSpecName);
                        if (cd665cdef191ff92708675209607d != null && Mevius.Sound.Api.IsPlayStateSound(StateSound.StateSoundType.BattleWin0, "player", cd665cdef191ff92708675209607d))
                        {
                            int soundHandle = Mevius.Sound.Api.PlayStateSound(StateSound.StateSoundType.BattleWin0, "player", cd665cdef191ff92708675209607d, null, false);
                            flag = true;
                            GameObject gameObject = appActor.getGameObject();
                            if (gameObject)
                            {
                                FacialController component = gameObject.GetComponent<FacialController>();
                                if (component == null)
                                {
                                    return;
                                }
                                int playTime = Mevius.Sound.Api.GetPlayTime(soundHandle);
                                if (playTime > 0)
                                {
                                    PreciseTime preciseTime = new PreciseTime((float)playTime / 1000f * 0.9f);
                                    component.EnableLipsync = true;
                                    component.StartLipsync(preciseTime.GetSecond());
                                }
                                this.lastBattleWinActorObject = gameObject;
                            }
                        }
                    }
                }
                if (!flag && this.m_fairyActor != null)
                {
                    string text = Mevius.Db.Api.GetEquipment(Mevius.Db.Api.EQUIPMENT_TYPE.EQUIPMENT_TYPE_FAIRY, false, false);
                    text = Mevius.Db.Api.ChangeStoryEco(text);
                    C8f07bc7aaef5445b9988a9d210e42418.Ca060fd76133aa5c704d976700ed7cdd9 ca060fd76133aa5c704d976700ed7cdd = C8f07bc7aaef5445b9988a9d210e42418.Find(text);
                    if (ca060fd76133aa5c704d976700ed7cdd != null)
                    {
                        C95bcaea3352f97e159106604018eaa69.Cd665cdef191ff92708675209607d4634 cd665cdef191ff92708675209607d2 = C95bcaea3352f97e159106604018eaa69.Find(ca060fd76133aa5c704d976700ed7cdd.m4831fa9b93085e0ab5c88119c3c57882());
                        if (cd665cdef191ff92708675209607d2 != null)
                        {
                            Mevius.Sound.Api.PlayStateSound(StateSound.StateSoundType.BattleWin0, ca060fd76133aa5c704d976700ed7cdd.m4831fa9b93085e0ab5c88119c3c57882(), cd665cdef191ff92708675209607d2, null, false);
                        }
                    }
                }
            }
        }

        public void DeadPlayer()
        {
            this.m_playerActor.SetHp(0, false, true);
        }

        private void UpdateCamera()
        {
            if (Mevius.DataSheet.Api.GetResidentInteger("cameraUpdateTiming", 1) == 0)
            {
                this.UpdateCameraEntry();
            }
        }

        private void UpdateCameraEntry()
        {
            if (this.m_cameraManager != null)
            {
                this.m_cameraManager.Update();
                if (this.IsMultiFinishCamera())
                {
                    if (this.m_cameraManager.CurrentCameraType == BattleCameraManager.CameraType.Action)
                    {
                        if (this.m_cameraManager.IsActionEnd())
                        {
                            this.m_isMultiFinishCamera = false;
                            this.CameraManager.ChangeCamera(BattleCameraManager.CameraType.PartyAttack);
                            this.CameraManager.SetInterpolation(0f, CameraSequence.BlendType.Curve, true);
                            this.CameraManager.InitPartyAttack(this.m_boss, this.GetSelfActor(), this.m_actorList, true);
                        }
                    }
                    else
                    {
                        this.m_isMultiFinishCamera = false;
                    }
                }
            }
        }

        private void UpdateTime()
        {
            this.m_preciseTime += Mevius.App.Api.GetPreciseTimeForBattle();
            this.m_damageSourceManager.Update();
            this.m_manaObjectManager.Update();
            this.UpdateActionGuiActive();
            this.UpdateAbilityMessage();
        }

        private void UpdateSurfaceBlend()
        {
            if (this.m_surfaceBlend)
            {
                this.m_surfaceBlendAlpha -= Mevius.App.Api.GetDeltaTime();
                if (this.m_surfaceBlendAlpha < 0f)
                {
                    UnityEngine.Object.Destroy(this.m_surfaceBlend);
                    this.m_surfaceBlend = null;
                }
                else
                {
                    this.m_surfaceBlend.SetAlpha(this.m_surfaceBlendAlpha);
                }
            }
        }

        public void StartSlow(bool impactSE = false)
        {
            if (!this.IsBattleWin())
            {
                this.m_battleSlow.Start(impactSE);
                if (!Mevius.App.Api.IsPartyMode())
                {
                    Mevius.Gui.Api.SetBattleTargetButtonEnable(true);
                }
            }
        }

        public void EndSlow()
        {
            this.m_battleSlow.End();
        }

        public BattleSlow.StateType GetSlowState()
        {
            return this.m_battleSlow.State;
        }

        public bool OnBattleResult()
        {
            bool result = false;
            if (this.m_tutorialManager != null)
            {
                result = this.m_tutorialManager.OnBattleResult();
            }
            return result;
        }

        public void BattleResultEnd()
        {
        }

        public void ExitBattleResult()
        {
            if (this._step == BattleManager.BattleStep.ResultWait)
            {
                this._step = BattleManager.BattleStep.ResultIdleWait;
            }
        }

        public BattleManager.EncountType GetEncountType()
        {
            return BattleManager.EncountType.Normal;
        }

        public void SetAutoAttack(bool bAuto)
        {
            if (bAuto)
            {
                this.m_autoAttack = BattleManager.AutoAttackType.NormalAutoAttack;
            }
            else
            {
                this.m_autoAttack = BattleManager.AutoAttackType.Off;
            }
        }

        public bool IsAutoAttack()
        {
            return this.m_autoAttack != BattleManager.AutoAttackType.Off;
        }

        public BattleManager.AutoAttackType AutoAttack
        {
            get
            {
                return this.m_autoAttack;
            }
            set
            {
                this.m_autoAttack = value;
            }
        }

        public void StartTargetChangeMode()
        {
            if (Mevius.App.Api.IsPartyMode())
            {
                if (!this.IsTargetChangeMode() && this._step == BattleManager.BattleStep.MultiBattleInput)
                {
                    BattleManager._i.CameraManager.SetInterpolation(0.8f, CameraSequence.BlendType.Curve, false);
                    BattleManager._i.CameraManager.InitTargetChange(this.m_boss, this.m_playerActor, this.m_actorList);
                    BattleManager._i.CameraManager.ChangeCamera(BattleCameraManager.CameraType.TargetChange);
                }
            }
            else if (!this.IsTargetChangeMode() && this.IsPlayerTurn())
            {
                BattleManager._i.CameraManager.SetInterpolation(0.8f, CameraSequence.BlendType.Curve, false);
                BattleManager._i.CameraManager.InitTargetChange(this.m_boss, this.m_playerActor, this.m_actorList);
                BattleManager._i.CameraManager.ChangeCamera(BattleCameraManager.CameraType.TargetChange);
            }
        }

        public void EndTargetChangeMode(bool toTargetSelectCamera)
        {
            if (toTargetSelectCamera && this.m_cameraManager != null)
            {
                this.m_cameraManager.SetInterpolation(0.8f, CameraSequence.BlendType.Curve, false);
                this.m_cameraManager.InitTargetSelect(this.m_boss, this.m_playerActor, this.m_targetActor);
                this.m_cameraManager.ChangeCamera(BattleCameraManager.CameraType.TargetSelect);
            }
        }

        public bool IsTargetChangeMode()
        {
            return BattleManager._i.CameraManager != null && BattleManager._i.CameraManager.CurrentCameraType == BattleCameraManager.CameraType.TargetChange;
        }

        public bool IsBattleCameraDragging()
        {
            return this.m_inputCheck && this.m_playerActor.State == BattleActor.StateType.Idle && this.m_guiTouchComponent.IsDown();
        }

        public void Init()
        {
        }

        public void Final()
        {
        }

        public void PartyTest()
        {
        }

        private void _ChangeActorBattle2Field()
        {
            Mevius.App.Api.SetActiveFieldActors(Mevius.App.Api.ActiveFieldActorsLayer.Application, true);
            Mevius.Effect.Api.SetEffectActive(Mevius.Effect.Constants.EffectLayer.Field, true);
            Mevius.App.Api.SetActiveBattleActors(false);
            Mevius.Gui.Api.SetFieldMenuModeDirect(GuiFieldMenu.Mode.ViewFull, false);
        }

        public void ClearCurrentTarget()
        {
            this.m_targetActor = null;
        }

        public void SetCurrentTarget(BattleActor target)
        {
            this.m_targetActor = target;
        }

        public void Update()
        {
            if (this.requestStartBattle)
            {
                this.StartBattle();
            }
            this._UpdateResource();
            if (this.m_tutorialManager != null && this.m_tutorialManager.Update())
            {
                return;
            }
            switch (this._step)
            {
            case BattleManager.BattleStep.None:
                goto IL_1771;
            case BattleManager.BattleStep.CreateActor:
                if (Mevius.App.Api.IsPartyMode())
                {
                    foreach (Mevius.Party.Api.PARTY_MEMBER_TYPE party_MEMBER_TYPE in Mevius.Party.Api.GetPartyType())
                    {
                        if (party_MEMBER_TYPE != Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_EMPTY)
                        {
                            if (party_MEMBER_TYPE == Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_ME)
                            {
                                Mevius.Db.Api.CreatePartyResource(DbPartyManager.DbPartyTypes.DbPartyTypes_BATTLE);
                            }
                            else
                            {
                                Mevius.Db.Api.CreatePartyResource(party_MEMBER_TYPE, DbPartyManager.DbPartyTypes.DbPartyTypes_BATTLE);
                            }
                        }
                    }
                }
                else
                {
                    Mevius.Db.Api.CreatePartyResource(DbPartyManager.DbPartyTypes.DbPartyTypes_BATTLE);
                    Mevius.Db.Api.CreateSubPartyResource(DbPartyManager.DbPartyTypes.DbPartyTypes_BATTLE);
                }
                for (int j = 0; j < this._entryBattleCharaSpecList.Count; j++)
                {
                    C4d4f3a800432e94568175cb31ad3c78d.C51747b7e0e19ad065084a2c5a6d8421b c51747b7e0e19ad065084a2c5a6d8421b = C4d4f3a800432e94568175cb31ad3c78d.Find(this._entryBattleCharaSpecList[j]);
                    GameInstanceManager.CreateInstanceArg createInstanceArg = new GameInstanceManager.CreateInstanceArg();
                    createInstanceArg.resource = c51747b7e0e19ad065084a2c5a6d8421b.mc17ab063bf174d4fbb31c91f28a5f111();
                    createInstanceArg.callback = new GameInstanceManager.CreateInstanceCallBack(AppManager._i.appActorManager.delegateCreateActor);
                    createInstanceArg.callbacktag = new delegateCreateActorArg
                    {
                        spec = c51747b7e0e19ad065084a2c5a6d8421b.mc17ab063bf174d4fbb31c91f28a5f111(),
                        mode = ActorMode.ActorMode_BATTLE,
                        fieldType = FieldControllerType.FieldControllerType_NONE,
                        cinemaType = CinemaControllerType.CinemaControllerType_NONE,
                        battleType = BattleControllerType.BattleControllerType_DEFAULT,
                        talkType = TalkControllerType.TalkControllerType_NONE,
                        battleCharaSpec = c51747b7e0e19ad065084a2c5a6d8421b.m2406fe4ab939a17fa07b0f4590a53fad()
                    };
                    string enemyActorName = BattleManager.GetEnemyActorName(j);
                    Mevius.App.Api.CreateCharaInstanceCommand(enemyActorName, createInstanceArg);
                    this._actorNameList.Add(enemyActorName);
                }
                this.UpdateCamera();
                this._step = BattleManager.BattleStep.Init;
                goto IL_1771;
            case BattleManager.BattleStep.Init:
                this.UpdateInit();
                goto IL_1771;
            case BattleManager.BattleStep.EncountCameraWait:
                this.UpdateCamera();
                if (this.m_cameraManager.IsEnd())
                {
                    Mevius.Gui.Api.CreateBattleMenu();
                    this.LoadPlayerCardResources();
                    this._step = BattleManager.BattleStep.MenuCreateWait;
                }
                goto IL_1771;
            case BattleManager.BattleStep.MenuCreateWait:
                if (Mevius.Gui.Api.IsBattleMenuCreated() && GuiManager.Instance.cardManager.IsLoaded() && GuiManager.Instance.cardManager.IsCreated())
                {
                    GuiBattleMenu.Instance.IsZone = this.m_zone;
                    Mevius.Gui.Api.ShowBattleMenu(this.m_playerActor.JobType, this.m_playerActor.GetAbilityButtonInfo(), this.m_playerActor.GetJobAbilityTextResourceId(), BattleUtility.GetJobUseAttributeArray(this.m_playerActor.Deck, this.m_playerActor.IsSummon()), this.m_playerActor.Hp, this.m_playerActor.HpMax, this.m_playerActor.ManaUseNum, this.m_playerActor.JobAbilityUseManaUseNum, false);
                    GuiBattleMenu.Instance.SetJobChangeChargeTurn((int)this.m_playerJobChangeChargeTurn, true);
                    this.UpdateSubJobElementRing();
                    GuiBattleMenu.Instance.TimeLine.ClearIcons(true);
                    this._step = BattleManager.BattleStep.MenuShowWait;
                }
                goto IL_1771;
            case BattleManager.BattleStep.MenuShowWait:
                if (!Mevius.Gui.Api.IsBattleMenuShown())
                {
                    goto IL_1771;
                }
                this.m_lastBattle = this.IsLastBattle();
                this.m_lastBgmVolumeChanged = false;
                Mevius.Gui.Api.RemoveDelayLoadingIcon(NowLoadingManager.Layer.TopLevel, "TopLevel");
                if (this.m_manaObjectManager.IsDraw())
                {
                    string soundResourceName = Mevius.Sound.Api.GetSoundResourceName("Resident");
                    Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Gui, soundResourceName, "system_se_ce_battle_in", 1f, 0, 0, Vector3.zero, null, false, -1, 0, 1f);
                }
                Mevius.Gui.Api.AddBattleTouchAreaEvent(new GuiBattleMenu.TouchAreaEventHandler(this.TouchAreaEvent));
                if (!Mevius.App.Api.IsPartyMode() && Mevius.Db.Api.IsEnableClientSaveData(0u) && Mevius.Db.Api.HasBattleData() && Mevius.Db.Api.GetBattleData().step > 2)
                {
                    this.LoadData();
                    for (int k = 0; k < this.m_actorList.Count; k++)
                    {
                        BattleActor battleActor = this.m_actorList[k];
                        if (battleActor.IsEnemy() && battleActor.IsActiveTarget())
                        {
                            battleActor.CreateEnemyHpGauge();
                            battleActor.UpdateStatusEffectGui(true);
                        }
                    }
                    this.InitFairyActor();
                }
                else
                {
                    if (!Mevius.App.Api.IsPartyMode() && Mevius.Db.Api.HasBattleData())
                    {
                        this.LoadFF8Data();
                    }
                    if (Mevius.App.Api.IsPartyMode())
                    {
                        this.RestoreMultiData(true);
                        Array.Clear(this.m_enemyAiCommonCounters, 0, this.m_enemyAiCommonCounters.Length);
                    }
                    for (int l = 0; l < this.m_actorList.Count; l++)
                    {
                        BattleActor battleActor2 = this.m_actorList[l];
                        if (battleActor2.IsEnemy() && battleActor2.IsActiveTarget())
                        {
                            battleActor2.CreateEnemyHpGauge();
                            battleActor2.InitDebuffInvalid(true);
                        }
                    }
                    C098a168d3605b12448638cab8ccafe9d.C6a63ba3da59f35f0fee059da0f7321db c6a63ba3da59f35f0fee059da0f7321db = C098a168d3605b12448638cab8ccafe9d.Find(this.currentBattleScene);
                    if (c6a63ba3da59f35f0fee059da0f7321db != null && !string.IsNullOrEmpty(c6a63ba3da59f35f0fee059da0f7321db.mfa554940acbf37691763345305e1e3a4()))
                    {
                        C66d1c702408526ca44c99abdacae85fc.C713280ef8c2343697779d4832119f911 c713280ef8c2343697779d4832119f = C66d1c702408526ca44c99abdacae85fc.Find(c6a63ba3da59f35f0fee059da0f7321db.mfa554940acbf37691763345305e1e3a4());
                        if (c713280ef8c2343697779d4832119f != null)
                        {
                            Mevius.Gui.Api.CreateAutoClip(c713280ef8c2343697779d4832119f.mc21f35a8dc3c0a98fdcb2908689a6362(), c713280ef8c2343697779d4832119f.mb300c4a557ae7c3ac224cf5c9a6b78d1());
                        }
                        this._step = BattleManager.BattleStep.AutoClipWait;
                    }
                    else if (!Mevius.App.Api.IsPartyMode())
                    {
                        this.ProcStepBattleStatusEffect();
                        this._step = BattleManager.BattleStep.StepBattleEffect;
                        this.SaveData();
                    }
                    else if (!Mevius.Party.Api.IsFirstSnap())
                    {
                        this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.CurrentPlayer;
                        this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                    }
                    else
                    {
                        this.ProcStepBattleStatusEffect();
                        this._step = BattleManager.BattleStep.StepBattleEffect;
                        this.SaveData();
                    }
                }
                if (this.IsCountTimeBattle())
                {
                    this.m_jobChangeActionGauge = this.GetJobChangeActionGauge();
                    GuiBattleMenu.Instance.TimeLine.ActionGauge = this.m_actionGauge;
                    GuiBattleMenu.Instance.TimeLine.RecoveryGauge = Mathf.Max(this.m_actionGaugeDecrease - this.m_actionGauge, 0);
                    GuiBattleMenu.Instance.TimeLine.ActionGaugeMax = Mevius.DataSheet.Api.GetResidentInteger("ctbActionGaugeMax", 800);
                    GuiBattleMenu.Instance.TimeLine.JobChangeActionGaugeAmount = this.m_jobChangeActionGauge;
                    C43401f69745a04cbd6ee6dcffba76ae5.Ca4d3b5367a73030692d322e3f08669b5 ca4d3b5367a73030692d322e3f08669b = C43401f69745a04cbd6ee6dcffba76ae5.Find(this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59.mb95164dbb096f52883c4e02005721de1());
                    if (ca4d3b5367a73030692d322e3f08669b != null)
                    {
                        GuiBattleMenu.Instance.TimeLine.SubStrikeActionGaugeAmount = (int)ca4d3b5367a73030692d322e3f08669b.m8ffedb5dbe5912c2b2eb70f721a7dfac();
                    }
                    GuiBattleMenu.Instance.TimeLine.ActionPower = this.m_actionPower;
                    GuiBattleMenu.Instance.TimeLine.ActionPowerMax = (float)ca4d3b5367a73030692d322e3f08669b.mb340f1c79854e240a4cb690d3cacca53();
                    GuiBattleMenu.Instance.TimeLine.ResetActionGauge();
                }
                this.m_playerActor.UpdateStatusEffectGui(true);
                this.m_playerActor.UpdateJobAbilityGauge();
                this.m_playerActor.UpdateElementalGaugeGui();
                this.UpdateManaGui();
                if (GuiBattleMenu.Instance != null)
                {
                    GuiBattleMenu.Instance.UpdateSelectedEnemyGauge();
                }
                if (BattleUtility.GetElementInfluenceType() != 0)
                {
                    this.ShowElementInfluence();
                }
                if (Mevius.Db.Api.GetBattleData().padCombo > 0)
                {
                    Mevius.Gui.Api.ShowPadCombo((int)Mevius.Db.Api.GetBattleData().padCombo, BattleUtility.GetPadComboRate() * BattleUtility.GetPadDamageRate(), Mevius.Db.Api.GetBattleData().padDamageType == 2);
                    Mevius.Gui.Api.ShowPadTurnCount((int)Mevius.Db.Api.GetBattleData().padComboTurn);
                }
                goto IL_1771;
            case BattleManager.BattleStep.AutoClipWait:
                if (Mevius.Gui.Api.IsAutoClipFinish())
                {
                    this.ProcStepBattleStatusEffect();
                    this._step = BattleManager.BattleStep.StepBattleEffect;
                    this.SaveData();
                }
                goto IL_1771;
            case BattleManager.BattleStep.StepBattleEffect:
                this.m_actionStepWait -= Mevius.App.Api.GetDeltaTimeForBattle();
                if (this.m_actionStepWait <= 0f)
                {
                    this.m_actionStepWait = 0f;
                    this.ProcStepBattleStatusEffectEnd();
                    if (this.IsCountTimeBattle())
                    {
                        for (int m = 0; m < this.m_actorList.Count; m++)
                        {
                            BattleActor battleActor3 = this.m_actorList[m];
                            if (battleActor3 != null && battleActor3.IsActive())
                            {
                                battleActor3.ReadyAction();
                            }
                        }
                    }
                    this._step = BattleManager.BattleStep.BattleStart;
                    this.SaveData();
                }
                goto IL_1771;
            case BattleManager.BattleStep.BattleStart:
                this.UpdateBattleStart();
                goto IL_1771;
            case BattleManager.BattleStep.FairyTurnStart:
                if (this.m_fairyActor != null && !this.m_presetFairyEffect)
                {
                    this.ProcFairyEffectType(false);
                }
                this.m_presetFairyEffect = false;
                if (this.m_fairyEffectType != BattleManager.FairyEffectType.None)
                {
                    this.UpdateCamera();
                    this.UpdateTime();
                    this.m_fairyActor.Action(this.m_fairyEffectType);
                    BattleManager._i.CameraManager.SetInterpolation(0f, CameraSequence.BlendType.Curve, true);
                    BattleManager._i.CameraManager.InitAction("fairy1", this.m_playerActor, false, false);
                    BattleManager._i.CameraManager.ChangeCamera(BattleCameraManager.CameraType.Action);
                    this.Step = BattleManager.BattleStep.FairyTurn;
                    goto IL_1771;
                }
                if (this.IsCountTimeBattle())
                {
                    this.Step = BattleManager.BattleStep.CTBStart;
                    goto IL_E60;
                }
                this._step = BattleManager.BattleStep.PlayerTurnStart;
                break;
            case BattleManager.BattleStep.FairyTurn:
                this.UpdateCamera();
                this.UpdateTime();
                if (this.m_fairyActor.TurnEnd)
                {
                    this.HideBattleEnemyActionName();
                    Mevius.Gui.Api.ClearDQBattleLogText();
                    if (this.IsCountTimeBattle())
                    {
                        this.Step = BattleManager.BattleStep.CTBStart;
                    }
                    else
                    {
                        this.Step = BattleManager.BattleStep.PlayerTurnStart;
                    }
                }
                goto IL_1771;
            case BattleManager.BattleStep.PlayerTurnStart:
                break;
            case BattleManager.BattleStep.PlayerTurnStartWait:
                this.UpdateCamera();
                this.UpdateTime();
                if (this.m_playerActor != null)
                {
                    if (this.m_playerActor.IsSummon() && this.m_playerActor.IsDead())
                    {
                        if (this.m_playerActor.IsDeadIdle())
                        {
                            this.ProcChangeJob(false, false);
                        }
                    }
                    else if (this.m_playerActor.UpdateReadyAction())
                    {
                        if (GuiBattleMenu.Instance != null)
                        {
                            GuiBattleMenu.Instance.EnableMenuButton = true;
                        }
                        Mevius.Gui.Api.SetBattleTargetButtonEnable(true);
                        this._step = BattleManager.BattleStep.PlayerTurn;
                    }
                }
                goto IL_1771;
            case BattleManager.BattleStep.PlayerTurn:
                this.UpdatePlayerTurn();
                goto IL_1771;
            case BattleManager.BattleStep.CheckMultiBattleCmd:
                this.UpdateCamera();
                this.UpdateTime();
                this.UpdateMultiBattleCmd();
                goto IL_1771;
            case BattleManager.BattleStep.MultiBattleInputStart:
                this.m_updateReadyActionList.Clear();
                for (int n = 0; n < this.m_multiBattleActorList.Count; n++)
                {
                    BattleActor battleActor4 = this.m_multiBattleActorList[n];
                    if (battleActor4.IsActive())
                    {
                        battleActor4.OnTurnBegin();
                        if (battleActor4.ReadyAction())
                        {
                            this.m_updateReadyActionList.Add(battleActor4);
                        }
                    }
                    else
                    {
                        battleActor4.UpdateCardAbilityTurnCountGui();
                    }
                }
                this._step = BattleManager.BattleStep.MultiBattleInputStartWait;
                goto IL_1771;
            case BattleManager.BattleStep.MultiBattleInputStartWait:
            {
                bool flag = false;
                this.m_updatedList.Clear();
                for (int num = 0; num < this.m_updateReadyActionList.Count; num++)
                {
                    BattleActor battleActor5 = this.m_updateReadyActionList[num];
                    if (battleActor5.UpdateReadyAction())
                    {
                        this.m_updatedList.Add(battleActor5);
                    }
                    else
                    {
                        flag = true;
                    }
                }
                for (int num2 = 0; num2 < this.m_updatedList.Count; num2++)
                {
                    this.m_updateReadyActionList.Remove(this.m_updatedList[num2]);
                }
                if (flag)
                {
                    goto IL_1771;
                }
                this.m_playerActor = this.m_selfActor;
                if (!this.m_playerActor.IsDead() && (this.m_targetActor == null || !this.m_targetActor.IsActive()))
                {
                    this.UpdateSelectedTarget();
                }
                this.ChangeTargetSelectCamera(true);
                if (GuiBattleMenu.Instance != null)
                {
                    GuiBattleMenu.Instance.EnableMenuButton = true;
                }
                Mevius.Gui.Api.OnStartInput();
                if (this.m_playerActor.IsDead())
                {
                    Mevius.Gui.Api.ShowPlayerDeadTimer();
                    Mevius.Gui.Api.SetBattleTargetButtonEnable(false);
                }
                else
                {
                    Mevius.Gui.Api.ShowPlayerTurnTimer();
                    Mevius.Gui.Api.ShowDecideButton();
                    Mevius.Gui.Api.SetBattleTargetButtonEnable(true);
                }
                Mevius.Party.Api.ClearCommandStock();
                Mevius.Party.Api.ClearCommand();
                this._step = BattleManager.BattleStep.MultiBattleInput;
                goto IL_1771;
            }
            case BattleManager.BattleStep.MultiBattleInput:
                this.UpdateMultiBattleInput();
                goto IL_1771;
            case BattleManager.BattleStep.EnemyTurnStart:
                this.UpdateEnemyTurnStart();
                goto IL_1771;
            case BattleManager.BattleStep.EnemyTurnStartWait:
                this.UpdateEnemyTurnStartWait();
                goto IL_1771;
            case BattleManager.BattleStep.EnemyTurn:
                this.UpdateEnemyTurn();
                goto IL_1771;
            case BattleManager.BattleStep.CTBStart:
                goto IL_E60;
            case BattleManager.BattleStep.CTB:
                this.UpdateCTB();
                goto IL_1771;
            case BattleManager.BattleStep.EscapeCheck:
                if (GuiBattleMenu.Instance != null && GuiBattleMenu.Instance.Pausing)
                {
                    goto IL_1771;
                }
                this.UpdateEscapeCheck();
                goto IL_1771;
            case BattleManager.BattleStep.Escape:
            {
                if (GuiBattleMenu.Instance != null)
                {
                    GuiBattleMenu.Instance.EnableMenuButton = false;
                }
                if (this.m_playerActor != null)
                {
                    this.m_playerActor.OnBattleEscape();
                }
                AppActor appActor = Mevius.App.Api.FindAppActor(Mevius.Db.Api.GetPlayerName());
                if (appActor != null)
                {
                    FieldPlayerActor fieldPlayerActor = appActor.actors[0] as FieldPlayerActor;
                    if (fieldPlayerActor != null)
                    {
                        fieldPlayerActor.OnIdle();
                    }
                }
                Mevius.Gui.Api.AddFadeInstance(BattleManager.c_BattleEscapeFade, FadeManager.FadeLayer.FadeLayer_Default, 0f, 0f, 0f, 0f, 1f, 1f, false, 0);
                if (Mevius.Field.Api.IsCoop())
                {
                    Mevius.Gui.Api.AddFadeInstance(Resident.sc_CoopBattleEscapeFade, FadeManager.FadeLayer.FadeLayer_3D, 0f, 0f, 0f, 0f, 1f, 1f, false, 0);
                }
                Mevius.Zone.Api.CancelZoneActionSequence();
                this.connectTask = Mevius.App.Api.AddAsyncCommand(new AsyncCommandManager.AsyncCommandCallBack(MainLoop.waitTimeTask), 1f);
                this._step = BattleManager.BattleStep.EscapeWait;
                goto IL_1771;
            }
            case BattleManager.BattleStep.EscapeWait:
                if (!Mevius.App.Api.IsExistTaskId(this.connectTask) && !Mevius.Gui.Api.IsFadeing(BattleManager.c_BattleEscapeFade))
                {
                    this.RemoveCameraManager();
                    this.EndBattle();
                    if (Mevius.Field.Api.IsCoop())
                    {
                        Mevius.Gui.Api.ShowHideStampButtonLayer(Mevius.Gui.Api.StampLayer.ActionSequence, false);
                    }
                    Mevius.Gui.Api.HideBattleMenu();
                    this._ChangeActorBattle2Field();
                    this.m_tutorialManager = null;
                    this._step = BattleManager.BattleStep.CheckChara;
                }
                goto IL_1771;
            case BattleManager.BattleStep.CheckChara:
                Mevius.Db.Api.SetParameter(DbManager.ParameterType.Current_Job, 0);
                if (Mevius.Db.Api.IsRefreshJobChange())
                {
                    if (Mevius.Db.Api.IsPartyStatusNone(DbPartyManager.DbPartyTypes.DbPartyTypes_NONE))
                    {
                        Mevius.Db.Api.RemovePartyResource(DbPartyManager.DbPartyTypes.DbPartyTypes_FIELD);
                        this._step = BattleManager.BattleStep.CharaDeleteWait;
                    }
                }
                else
                {
                    this._step = BattleManager.BattleStep.ResourceStepUnloadWait;
                }
                goto IL_1771;
            case BattleManager.BattleStep.CharaDeleteWait:
                if (Mevius.Db.Api.IsPartyStatusNone(DbPartyManager.DbPartyTypes.DbPartyTypes_NONE))
                {
                    Mevius.Db.Api.CreatePartyResource(DbPartyManager.DbPartyTypes.DbPartyTypes_FIELD);
                    this._step = BattleManager.BattleStep.CharaCreateWait;
                }
                goto IL_1771;
            case BattleManager.BattleStep.CharaCreateWait:
                if (Mevius.Db.Api.IsPartyStatusNone(DbPartyManager.DbPartyTypes.DbPartyTypes_NONE))
                {
                    this._step = BattleManager.BattleStep.ResourceStepUnloadWait;
                }
                goto IL_1771;
            case BattleManager.BattleStep.ContinueCheck:
            {
                if (GuiBattleMenu.Instance != null && GuiBattleMenu.Instance.Pausing)
                {
                    goto IL_1771;
                }
                if (Mevius.Db.Api.GetClientContinueIdentifier() != 0u && Mevius.Db.Api.GetClientContinueIdentifier() == Mevius.Db.Api.GetServerConnectIdentifier())
                {
                    Mevius.Db.Api.SetClientContinueIdentifier(0u);
                    this.RevivePlayer();
                    if (Mevius.App.Api.IsPartyMode())
                    {
                        this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                        this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.CurrentPlayer;
                    }
                    else
                    {
                        this._step = BattleManager.BattleStep.FairyTurnStart;
                    }
                    goto IL_1771;
                }
                if (GuiBattleMenu.Instance != null)
                {
                    GuiBattleMenu.Instance.EnableMenuButton = false;
                }
                uint num3 = Mevius.Common.Random.GetInstance().GetUnsignedInteger();
                if (Mevius.Db.Api.getTicketCount(Mevius.Db.Api.TICKET_TYPE.TICKET_TYPE_RAISE) > 0u)
                {
                    num3 &= 4294967294u;
                }
                else
                {
                    num3 |= 1u;
                }
                Mevius.Db.Api.SetClientContinueIdentifier(num3);
                this.SaveData();
                this._step = BattleManager.BattleStep.ContinueCheckWait;
                goto IL_1771;
            }
            case BattleManager.BattleStep.ContinueCheckWait:
            {
                string battleContinueStr = Mevius.Gui.Util.GetBattleContinueStr();
                int num4 = Mevius.Gui.Util.CheckMessageBox(ref this.m_MsgHandle, "$msg_title_010", battleContinueStr, GuiMessageBox.Buttons.FromText, GuiMessageBox.Skin.Default, false, null, Mevius.Gui.Constants.SoundEffectKind.system_se_window_in, false);
                if (Mevius.Field.Api.BattleApi.IsContinueable())
                {
                    int num5 = num4;
                    if (num5 != 0)
                    {
                        if (num5 == 1)
                        {
                            this._step = BattleManager.BattleStep.Escape;
                        }
                    }
                    else
                    {
                        this._step = BattleManager.BattleStep.MagicStoneCheck;
                    }
                }
                else
                {
                    if (num4 == -1)
                    {
                        return;
                    }
                    this._step = BattleManager.BattleStep.Escape;
                }
                goto IL_1771;
            }
            case BattleManager.BattleStep.MagicStoneCheck:
            {
                GuiPopUpItemShop.Param param = new GuiPopUpItemShop.Param(null, Mevius.Db.Api.ShopListType.ShopListType_RAISE_TICKET, 1, null);
                GuiPopUpItemShop.Result result = Mevius.Gui.Api.BuyCheckFlow(param);
                if (result == GuiPopUpItemShop.Result.OK)
                {
                    this._step = BattleManager.BattleStep.Continue;
                }
                else
                {
                    this._step = BattleManager.BattleStep.WaitBuyMagicStone;
                }
                goto IL_1771;
            }
            case BattleManager.BattleStep.WaitBuyMagicStone:
                if (Mevius.Gui.Api.IsFinishBuyCheckFlow())
                {
                    this._step = BattleManager.BattleStep.ContinueCheck;
                    if (Mevius.Zone.Api.IsReturnToTitle())
                    {
                        this._step = BattleManager.BattleStep.Escape;
                    }
                }
                goto IL_1771;
            case BattleManager.BattleStep.Continue:
                this.connectTask = Mevius.App.Api.AddMainAsyncCommand(new AsyncCommandManager.AsyncCommandCallBack(NetworkManager.execCommandCoordinateWithIdentifier), "BattleContinue");
                this._step = BattleManager.BattleStep.ContinueWait;
                goto IL_1771;
            case BattleManager.BattleStep.ContinueWait:
                if (!Mevius.App.Api.IsExistTaskId(this.connectTask))
                {
                    if (Mevius.Zone.Api.IsReturnToTitle())
                    {
                        Mevius.Db.Api.SetClientContinueIdentifier(0u);
                        this._step = BattleManager.BattleStep.Escape;
                    }
                    else if (Mevius.Db.Api.GetClientContinueIdentifier() != Mevius.Db.Api.GetServerConnectIdentifier())
                    {
                        this._step = BattleManager.BattleStep.ContinueCheck;
                    }
                    else
                    {
                        if (GuiBattleMenu.Instance != null)
                        {
                            GuiBattleMenu.Instance.EnableMenuButton = true;
                        }
                        if (this.m_fairyActor != null)
                        {
                            this.m_fairyEffectType = BattleManager.FairyEffectType.Revive;
                            this.m_fairyActor.Action(this.m_fairyEffectType);
                            BattleManager._i.CameraManager.SetInterpolation(0f, CameraSequence.BlendType.Curve, true);
                            BattleManager._i.CameraManager.InitAction("fairy1", this.m_playerActor, false, false);
                            BattleManager._i.CameraManager.ChangeCamera(BattleCameraManager.CameraType.Action);
                            this._step = BattleManager.BattleStep.ContinueDirection;
                        }
                        else
                        {
                            this.RevivePlayer();
                            Mevius.Db.Api.SetClientContinueIdentifier(0u);
                            if (this.IsCountTimeBattle())
                            {
                                this._step = BattleManager.BattleStep.CTBStart;
                            }
                            else
                            {
                                this._step = BattleManager.BattleStep.PlayerTurnStart;
                            }
                        }
                    }
                }
                goto IL_1771;
            case BattleManager.BattleStep.ContinueDirection:
                this.UpdateCamera();
                if (this.m_fairyActor == null || this.m_fairyActor.TurnEnd)
                {
                    this.RevivePlayer();
                    this.HideBattleEnemyActionName();
                    Mevius.Gui.Api.ClearDQBattleLogText();
                    Mevius.Db.Api.SetClientContinueIdentifier(0u);
                    if (this.IsCountTimeBattle())
                    {
                        this._step = BattleManager.BattleStep.ContinueDirectionCTB;
                    }
                    else
                    {
                        this._step = BattleManager.BattleStep.PlayerTurnStart;
                    }
                }
                goto IL_1771;
            case BattleManager.BattleStep.ContinueDirectionCTB:
                this.UpdateCamera();
                if (this.m_playerActor.State == BattleActor.StateType.Idle)
                {
                    if (this.m_turnNum == 0)
                    {
                        this.m_playerActor.ReadyAction();
                        this._step = BattleManager.BattleStep.BattleStart;
                    }
                    else
                    {
                        GuiBattleMenu.Instance.ShowTimeLineEnd();
                        this._step = BattleManager.BattleStep.CTBStart;
                    }
                }
                goto IL_1771;
            case BattleManager.BattleStep.ResultReady:
                this.UpdateCamera();
                this.UpdateTime();
                if (Mevius.App.Api.IsPartyMode())
                {
                    if (!this.IsMultiFinishCamera())
                    {
                        this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.CurrentPlayer;
                        this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                    }
                }
                else
                {
                    if (this.CameraManager.IsActionEnd())
                    {
                        this.ChangeTargetSelectCamera(false);
                    }
                    this.m_actionStepWait += Mevius.App.Api.GetDeltaTimeForBattle();
                    if (this.m_actionStepWait > Mevius.DataSheet.Api.GetResidentFloat("battleEndWaitSec", 1.5f) && GuiBattleMenu.Instance != null && !GuiBattleMenu.Instance.Pausing && !this.m_playerActor.IsActionStep())
                    {
                        this.m_actionStepWait = 0f;
                        this.SetBattleWinImmediate(true);
                    }
                }
                goto IL_1771;
            case BattleManager.BattleStep.Result:
                if (BattleTest._i != null)
                {
                    this._step = BattleManager.BattleStep.Result2;
                }
                else if (Mevius.Db.Api.IsRefreshJobChange())
                {
                    if (Mevius.Db.Api.IsPartyStatusNone(DbPartyManager.DbPartyTypes.DbPartyTypes_NONE))
                    {
                        Mevius.Db.Api.RemovePartyResource(DbPartyManager.DbPartyTypes.DbPartyTypes_FIELD);
                        this._step = BattleManager.BattleStep.PreResultWait;
                    }
                }
                else
                {
                    this._step = BattleManager.BattleStep.Result2;
                }
                goto IL_1771;
            case BattleManager.BattleStep.PreResultWait:
                if (Mevius.Db.Api.IsPartyStatusNone(DbPartyManager.DbPartyTypes.DbPartyTypes_NONE))
                {
                    Mevius.Db.Api.CreatePartyResource(DbPartyManager.DbPartyTypes.DbPartyTypes_FIELD);
                    this._step = BattleManager.BattleStep.PreResultWait2;
                }
                goto IL_1771;
            case BattleManager.BattleStep.PreResultWait2:
                if (Mevius.Db.Api.IsPartyStatusNone(DbPartyManager.DbPartyTypes.DbPartyTypes_NONE))
                {
                    this._step = BattleManager.BattleStep.Result2;
                }
                goto IL_1771;
            case BattleManager.BattleStep.Result2:
            {
                Mevius.Gui.Api.CreateBattleResult();
                Mevius.Gui.Api.HideBattleMenu();
                this.RemoveCameraManager();
                int num6 = Mevius.Db.Api.GetCurrentCardDeck();
                if (Mevius.Db.Api.GetParameter(DbManager.ParameterType.Current_Job) != 0)
                {
                    num6 += 12;
                }
                C912567889466ef0cf80daa8b03815aff.C648971f118c7e1100318b6fb7ac13b59 equipmentJobDatasheetElemSlot = Mevius.Db.Api.GetEquipmentJobDatasheetElemSlot(num6);
                if (equipmentJobDatasheetElemSlot != null)
                {
                    FieldManager._i.fieldCameraController.SetupBattleResultCamera((CameraSequence.SituationType)equipmentJobDatasheetElemSlot.m261c1233e882c98e7c2e671f13628641());
                }
                Ca8cb6cbffd922889655adb017c6a8321.C0f50e5a11c18dca4fc58c614e707a8bf c0f50e5a11c18dca4fc58c614e707a8bf = Ca8cb6cbffd922889655adb017c6a8321.Find(FieldManager._i.fieldCameraController.MainCameraSequence.CurrentSequence);
                this.OnLastBattleWin((c0f50e5a11c18dca4fc58c614e707a8bf.m80342e8a00d836900948710e6ae6b000() == 0) ? BattleManager.LastBattleWinCameraType.Player : BattleManager.LastBattleWinCameraType.Fairy);
                this._ChangeActorBattle2Field();
                if (Mevius.Db.Api.IsSummonMode())
                {
                    Mevius.Db.Api.SetParameter(DbManager.ParameterType.Current_Job, 0);
                }
                AppActor appActor2 = Mevius.App.Api.FindAppActor(Mevius.Db.Api.GetPlayerName());
                FieldPlayerActor fieldPlayerActor2 = appActor2.actors[0] as FieldPlayerActor;
                if (BattleTest._i == null)
                {
                    ActionInfo nextAction = ZoneActionSequenceExecutor._i.GetNextAction();
                    if (nextAction == null || !nextAction.IsBattle())
                    {
                        fieldPlayerActor2.OnBattleResultEnd();
                    }
                    else
                    {
                        fieldPlayerActor2.OnBattleResult();
                    }
                }
                this._step = BattleManager.BattleStep.ResultWait;
                goto IL_1771;
            }
            case BattleManager.BattleStep.ResultWait:
                this.UpdateSurfaceBlend();
                this.UpdateCamera();
                goto IL_1771;
            case BattleManager.BattleStep.ResultIdleWait:
            {
                this.UpdateSurfaceBlend();
                ActionInfo nextAction2 = ZoneActionSequenceExecutor._i.GetNextAction();
                this.UpdateCamera();
                AppActor appActor3 = Mevius.App.Api.FindAppActor(Mevius.Db.Api.GetPlayerName());
                if (appActor3 == null)
                {
                    goto IL_1771;
                }
                FieldPlayerActor fieldPlayerActor3 = appActor3.actors[0] as FieldPlayerActor;
                if (fieldPlayerActor3.IsIdle() || (nextAction2 != null && nextAction2.IsBattle()))
                {
                    this._step = BattleManager.BattleStep.ResultEnd;
                }
                goto IL_1771;
            }
            case BattleManager.BattleStep.ResultEnd:
                if (this.m_surfaceBlend)
                {
                    UnityEngine.Object.Destroy(this.m_surfaceBlend);
                }
                this._step = BattleManager.BattleStep.ActionCameraEndWait;
                goto IL_1771;
            case BattleManager.BattleStep.ActionCameraEndWait:
                if (Mevius.Zone.Api.GetPlayMode() == ZoneStateMachine.PlayMode.PlayMode_BATTLE_TEST)
                {
                    this._step = BattleManager.BattleStep.ResourceStepUnload;
                }
                goto IL_1771;
            case BattleManager.BattleStep.ResourceStepUnload:
                this._step = BattleManager.BattleStep.ResourceStepUnloadWait;
                goto IL_1771;
            case BattleManager.BattleStep.ResourceStepUnloadWait:
                if (!Mevius.App.Api.IsExistTaskId(this.resourceUnloadTaskId))
                {
                    this._step = BattleManager.BattleStep.End;
                }
                goto IL_1771;
            case BattleManager.BattleStep.End:
                if (this.lastBattleWinActorObject != null)
                {
                    this.lastBattleWinActorObject.GetComponent<FacialController>().StopLipsync();
                    this.lastBattleWinActorObject = null;
                }
                this.m_damageSourceManager.Clear();
                this.m_playerActor = null;
                this._step = BattleManager.BattleStep.Exit;
                goto IL_1771;
            case BattleManager.BattleStep.Exit:
                goto IL_1771;
            default:
                goto IL_1771;
            }
            this.UpdateCamera();
            this.UpdateTime();
            if (Mevius.App.Api.IsPartyMode())
            {
                if (this.m_multiBattleSlotList.Count == 0)
                {
                    this.EndSlow();
                    this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.CurrentPlayer;
                    this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                }
                else
                {
                    int num7 = this.m_multiBattleSlotList[0];
                    for (int num8 = 0; num8 < this.m_multiBattleActorList.Count; num8++)
                    {
                        if (num7 == this.m_multiBattleActorList[num8].PartySlot)
                        {
                            this.m_multiBattleCurrentOrder = num8;
                            break;
                        }
                    }
                    BattleActor battleActor6 = this.m_multiBattleActorList[this.m_multiBattleCurrentOrder];
                    if (battleActor6.IsMultiMember())
                    {
                        this.m_partyMemberTurn = true;
                    }
                    else
                    {
                        this.m_partyMemberTurn = false;
                    }
                    if (!this.m_playerActor.IsMultiMember() && battleActor6.IsMultiMember())
                    {
                        this.CameraManager.ChangeCamera(BattleCameraManager.CameraType.PartyAttack);
                        this.CameraManager.SetInterpolation(0f, CameraSequence.BlendType.Curve, true);
                        this.CameraManager.InitPartyAttack(this.m_boss, battleActor6, this.m_actorList, true);
                    }
                    if (this.m_playerActor.IsMultiMember() && !battleActor6.IsMultiMember())
                    {
                        this.CameraManager.SetInterpolation(0.5f, CameraSequence.BlendType.Curve, true);
                        this.CameraManager.InitTargetSelect(this.m_boss, battleActor6, battleActor6.TargetActor);
                        this.CameraManager.ChangeCamera(BattleCameraManager.CameraType.TargetSelect);
                    }
                    this.m_playerActor = battleActor6;
                    if (!this.m_playerActor.IsDead() && (this.m_targetActor == null || !this.m_targetActor.IsActive()))
                    {
                        this.UpdateSelectedTarget();
                    }
                    this.ChangeTargetSelectCamera(false);
                    if (GuiBattleMenu.Instance != null)
                    {
                        GuiBattleMenu.Instance.EnableMenuButton = true;
                    }
                    Mevius.Gui.Api.OnStartPlayerTurn(this.m_playerActor);
                    this.m_playerActor.EndGuard(false);
                    this._step = BattleManager.BattleStep.PlayerTurn;
                }
            }
            else
            {
                this.UpdateElementInfluence();
                if (this.m_playerActor != null)
                {
                    if (this.m_targetActor == null || !this.m_targetActor.IsActive())
                    {
                        this.UpdateSelectedTarget();
                    }
                    this.ChangeTargetSelectCamera(true);
                    this.m_playerActor.OnTurnBegin();
                    if (this.m_playerActor.ReadyAction())
                    {
                        this._step = BattleManager.BattleStep.PlayerTurnStartWait;
                    }
                    else
                    {
                        if (GuiBattleMenu.Instance != null)
                        {
                            GuiBattleMenu.Instance.EnableMenuButton = true;
                        }
                        Mevius.Gui.Api.SetBattleTargetButtonEnable(true);
                        Mevius.Gui.Api.OnStartPlayerTurn(this.m_playerActor);
                        this._step = BattleManager.BattleStep.PlayerTurn;
                    }
                }
            }
            goto IL_1771;
            IL_E60:
            this.UpdateCTBStart();
            IL_1771:
            this.m_guiTouchComponent.Update();
        }

        public void UpdateEnd()
        {
        }

        public void LateUpdate()
        {
        }

        public void LateUpdateEnd()
        {
            if (Mevius.DataSheet.Api.GetResidentInteger("cameraUpdateTiming", 1) == 1)
            {
                BattleManager.BattleStep step = this._step;
                switch (step)
                {
                case BattleManager.BattleStep.Init:
                case BattleManager.BattleStep.EncountCameraWait:
                case BattleManager.BattleStep.BattleStart:
                case BattleManager.BattleStep.FairyTurnStart:
                case BattleManager.BattleStep.FairyTurn:
                case BattleManager.BattleStep.PlayerTurnStart:
                case BattleManager.BattleStep.PlayerTurnStartWait:
                case BattleManager.BattleStep.PlayerTurn:
                case BattleManager.BattleStep.CheckMultiBattleCmd:
                case BattleManager.BattleStep.MultiBattleInput:
                case BattleManager.BattleStep.EnemyTurnStartWait:
                case BattleManager.BattleStep.EnemyTurn:
                case BattleManager.BattleStep.CTBStart:
                case BattleManager.BattleStep.CTB:
                    break;
                default:
                    switch (step)
                    {
                    case BattleManager.BattleStep.ContinueDirection:
                    case BattleManager.BattleStep.ResultReady:
                        break;
                    default:
                        if (step != BattleManager.BattleStep.ResultWait && step != BattleManager.BattleStep.ResultIdleWait)
                        {
                            return;
                        }
                        break;
                    }
                    break;
                }
                this.UpdateCameraEntry();
            }
        }

        private void UpdateInit()
        {
            Mevius.Db.Api.SetParameter(DbManager.ParameterType.Current_Job_Enable, 1);
            this.m_randCount = 0;
            this.m_damageRandCount = 0;
            this.m_movementRandCount = 0;
            if (DebugOutput.Instance != null)
            {
                DebugOutput.Instance.ErrorLogList.Clear();
            }
            this.m_multiBattleIgnoreMemberActionCamera = (Mevius.DataSheet.Api.GetResidentInteger("multi_ignoreOtherActionCamera", 1) > 0);
            if (Mevius.Field.Api.IsCoop())
            {
                if (Mevius.Gui.Api.IsExistFade(Resident.sc_CoopBattleStartFade))
                {
                    Mevius.Gui.Api.RemoveFadeInstance(Resident.sc_CoopBattleStartFade);
                }
                Mevius.Gui.Api.ShowHideStampButtonLayer(Mevius.Gui.Api.StampLayer.ActionSequence, true);
                Mevius.Gui.Api.ShowHideStampButtonLayer(Mevius.Gui.Api.StampLayer.Menu, false);
            }
            DbManager.TemporarySaveData temporarySaveData = Mevius.Db.Api.GetTemporarySaveData();
            if (temporarySaveData.partyQuestServerUniqueIndex > 0u)
            {
                Mevius.Gui.Api.RemoveDelayLoadingIcon(NowLoadingManager.Layer.Resource, "CoopBattleStart");
            }
            if (Mevius.App.Api.IsPartyMode())
            {
                Mevius.Party.Api.SetUpSnap(true, false, -1, null, null);
                Mevius.Party.Api.SetBattleReady(true);
                Mevius.Party.Api.SetForceBattleStep(false, null, 0u);
            }
            if (Mevius.Db.Api.IsTutorial() && Mevius.Db.Api.GetTutorialStep() >= DbManager.TUTORIAL_STEP.TUTORIAL_STEP_BATTLE1 && Mevius.Db.Api.GetTutorialStep() <= DbManager.TUTORIAL_STEP.TUTORIAL_STEP_BATTLE4)
            {
                if (this.m_tutorialManager == null)
                {
                    this.m_tutorialManager = new BattleTutorialManager();
                }
                this.m_tutorialManager.Init();
            }
            else if (this.m_tutorialManager != null)
            {
                this.m_tutorialManager.Destroy();
                this.m_tutorialManager = null;
            }
            Physics.IgnoreLayerCollision(LayerMask.NameToLayer("Phy Bg"), LayerMask.NameToLayer("Phy Character"), true);
            if (!Mevius.Db.Api.IsEnableClientSaveData(0u) || !Mevius.Db.Api.HasBattleData())
            {
                this.SetRandomSeed(true);
            }
            this.CreateCameraManager();
            this._enableUnloadRequest = true;
            if (this.IsCountTimeBattle())
            {
                this.m_turnNum = 0;
            }
            else
            {
                this.m_turnNum = 1;
            }
            this.m_chainNum = 0;
            this.m_breakNum = 0;
            this.m_deadNum = 0;
            this.m_preciseTime = default(PreciseTime);
            this.m_lastEnemyEscape = false;
            Array.Clear(this.m_enemyAiCommonCounters, 0, this.m_enemyAiCommonCounters.Length);
            this.m_enemyActionEndFlag = false;
            this.m_playerJobChangeChargeTurn = Mevius.Db.Api.GetBattleData().playerJobChangeChargeTurn;
            this.m_playerJobChangeThroughTurn = 0;
            this.m_optimaType = (OptimaType)Mevius.Db.Api.GetBattleData().optimaType;
            Mevius.Db.Api.GetBattleData().optimaUseCounts.CopyTo(this.m_optimaUseCounts, 0);
            Mevius.Db.Api.GetBattleData().missionCount.CopyTo(this.m_missionCounts, 0);
            Mevius.Db.Api.GetBattleData().bossMissionCount.CopyTo(this.m_bossMissionCounts, 0);
            Mevius.Db.Api.GetBattleData().saveLongValues.CopyTo(this.m_saveLongValues, 0);
            Mevius.Db.Api.GetBattleData().bossSaveLongValues.CopyTo(this.m_bossSaveLongValues, 0);
            Mevius.Db.Api.GetBattleData().ff7AbilityUseCounts.CopyTo(this.m_ff7AbilityUseCounts, 0);
            this.m_activeActionOrderActor = null;
            this.m_stealActionOrderActor = null;
            this.m_activeActionOrderTime = 0f;
            this.m_actionOrderListCreateFlag = false;
            this.m_actionGauge = (int)Mevius.Db.Api.GetBattleData().actionGauge;
            this.m_actionGaugeDecrease = (int)Mevius.Db.Api.GetBattleData().actionGaugeDecrease;
            this.m_actionPower = Mevius.Db.Api.GetBattleData().actionPower;
            this.m_jobChangeActionGauge = 0;
            this.m_subActionType = BattleManager.ESubActionType.None;
            this.m_zone = false;
            this.m_fairyHour = Mevius.Db.Api.IsFariyHour();
            Mevius.Gui.Api.EndEncountFilter();
            this.m_boss = false;
            C098a168d3605b12448638cab8ccafe9d.C6a63ba3da59f35f0fee059da0f7321db c6a63ba3da59f35f0fee059da0f7321db = C098a168d3605b12448638cab8ccafe9d.Find(this.currentBattleScene);
            if (c6a63ba3da59f35f0fee059da0f7321db != null)
            {
                this.m_boss = (c6a63ba3da59f35f0fee059da0f7321db.ma0a6afb3ac1df6ef61e80ad44b921257() != 0);
            }
            Mevius.Field.Api.SetupDynamicShadow(Mevius.Field.Api.FieldDynamicShadowLayer.Field, true, (!this.m_boss) ? Mevius.DataSheet.Api.GetResidentFloat("DynamicShadow_BattleNormalLength", 25f) : Mevius.DataSheet.Api.GetResidentFloat("DynamicShadow_BattleBossLength", 50f));
            Mevius.App.Api.SetActiveFieldActors(Mevius.App.Api.ActiveFieldActorsLayer.Application, false);
            Mevius.Effect.Api.SetEffectActive(Mevius.Effect.Constants.EffectLayer.Field, false);
            Mevius.App.Api.SetActiveBattleActors(true);
            this.m_rootObject = new GameObject("Battle");
            this.m_damageSourceManager.RootObject = this.m_rootObject;
            this.m_manaObjectManager.RootObject = this.m_rootObject;
            this.m_manaObjectManager.Init();
            this.m_chaosBattle = (this.currentBattleScene == "btsc_03032" || c6a63ba3da59f35f0fee059da0f7321db.me739b90bdaa97257b7e5f1b05d9cff1b() == 1);
            if (this.currentBattleScene == "btsc_20500" || this.currentBattleScene == "btsc_20501")
            {
                GameObject gameObject = Mevius.App.Api.FindChrGameObject(Mevius.Db.Api.GetPlayerHandkerchiefName() + "_battle");
                if (gameObject != null)
                {
                    gameObject.SetActive(false);
                }
                gameObject = Mevius.App.Api.FindChrGameObject(Mevius.Db.Api.GetPlayerHandkerchiefName() + "_battle_sub");
                if (gameObject != null)
                {
                    gameObject.SetActive(false);
                }
            }
            this.m_shadowBlankBattle = (c6a63ba3da59f35f0fee059da0f7321db.me739b90bdaa97257b7e5f1b05d9cff1b() == 2);
            this.m_forceAllCameraBattle = (c6a63ba3da59f35f0fee059da0f7321db.md8a841fedd64f70fdb60335bbd2aa3b6() != 0);
            this.m_targetSelectCameraName = c6a63ba3da59f35f0fee059da0f7321db.m32e8b60e01e71bfdb0525891143b9a06();
            if (Mevius.Db.Api.GetParameter(DbManager.ParameterType.Current_Job) != 0)
            {
                this.m_playerActor = this.FindActor(BattleManager.GetBattlePlayerSubName());
                this.m_playerActorSub = this.FindActor(BattleManager.GetBattlePlayerName());
            }
            else
            {
                this.m_playerActor = this.FindActor(BattleManager.GetBattlePlayerName());
                this.m_playerActorSub = this.FindActor(BattleManager.GetBattlePlayerSubName());
            }
            Cb883df428c2c9659b15ca52864e9d4ca.C237921cb068a73a8c1084a4d121e9eaf c237921cb068a73a8c1084a4d121e9eaf = Cb883df428c2c9659b15ca52864e9d4ca.Find(this.m_placementEnemyId);
            if (this.m_playerActor != null && !Mevius.App.Api.IsPartyMode())
            {
                Animator animatorComponent = this.m_playerActor.chara.GetAnimatorComponent();
                animatorComponent.cullingMode = AnimatorCullingMode.AlwaysAnimate;
                this.m_playerActor.Init(string.Empty, 0, -1, -1);
                Vector3 basePosition = this._basePosition;
                float playerAreaRandomDistance = this.GetPlayerAreaRandomDistance();
                if (this.m_chaosBattle)
                {
                    basePosition.z -= playerAreaRandomDistance;
                }
                else
                {
                    basePosition.z += playerAreaRandomDistance;
                }
                float num = (!(this.m_playerActor.chara.GetCharacterControllerComponent() != null)) ? 2f : this.m_playerActor.chara.GetCharacterControllerComponent().height;
                RaycastHit raycastHit;
                if (Physics.Raycast(basePosition + Vector3.up * num * 0.5f, Vector3.down, out raycastHit, num, 1 << LayerMask.NameToLayer("Phy Bg")))
                {
                    basePosition.y = raycastHit.point.y;
                }
                this.m_playerActor.chara.SetPosition(basePosition);
            }
            if (this.m_playerActorSub != null)
            {
                Animator animatorComponent2 = this.m_playerActorSub.chara.GetAnimatorComponent();
                animatorComponent2.cullingMode = AnimatorCullingMode.AlwaysAnimate;
                this.m_playerActorSub.Init(string.Empty, 0, -1, -1);
                this.m_playerActorSub.chara.OnSetActive(false, true);
                this.m_playerActorSub.chara.gameObject.SetActive(false);
            }
            if (Mevius.App.Api.IsPartyMode())
            {
                this.m_selfActor = this.m_playerActor;
                this.m_multiBattleActorCursorHandle = Mevius.Effect.Api.CreateInstance(new Mevius.Effect.Api.CreateInstanceArg
                {
                    m_strResourceName = Mevius.Effect.Api.GetResourceName(Mevius.Effect.Constants.ResourceCategory.Resident, string.Empty),
                    m_strSubResource = "m_cursor_001",
                    m_BindActor = this.m_selfActor.chara.gameObject
                });
                Mevius.Db.Api.CalcPartyPlayerStatus();
                float[] array = new float[]
                {
                    c237921cb068a73a8c1084a4d121e9eaf.m9ca08cba800b5256b57c973554267e39(),
                    c237921cb068a73a8c1084a4d121e9eaf.m04b7d164deff4964328e2d4b2fd0e2b8(),
                    c237921cb068a73a8c1084a4d121e9eaf.m97d175d376f6d6f45eda78467c174b78(),
                    c237921cb068a73a8c1084a4d121e9eaf.m18a27162ce54a42e19dc14c318c23a67()
                };
                int[] partyType = Mevius.Party.Api.GetPartyType();
                int num2 = 0;
                foreach (Mevius.Party.Api.PARTY_MEMBER_TYPE party_MEMBER_TYPE in partyType)
                {
                    if (party_MEMBER_TYPE != Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_EMPTY)
                    {
                        BattleActor battleActor;
                        if (party_MEMBER_TYPE == Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_ME)
                        {
                            battleActor = this.m_playerActor;
                        }
                        else
                        {
                            battleActor = this.FindActor(BattleManager.GetMultiMemberPlayerName(party_MEMBER_TYPE));
                        }
                        if (battleActor != null)
                        {
                            Animator animatorComponent3 = battleActor.chara.GetAnimatorComponent();
                            animatorComponent3.cullingMode = AnimatorCullingMode.AlwaysAnimate;
                            battleActor.Init(string.Empty, 0, -1, -1);
                            Vector3 vector = this._basePosition;
                            float playerAreaRandomDistance2 = this.GetPlayerAreaRandomDistance();
                            vector.z += playerAreaRandomDistance2;
                            float y = array[battleActor.PartySlot];
                            vector = Quaternion.Euler(0f, y, 0f) * vector;
                            float num3 = (!(battleActor.chara.GetCharacterControllerComponent() != null)) ? 2f : battleActor.chara.GetCharacterControllerComponent().height;
                            RaycastHit raycastHit2;
                            if (Physics.Raycast(vector + Vector3.up * num3 * 0.5f, Vector3.down, out raycastHit2, num3, 1 << LayerMask.NameToLayer("Phy Bg")))
                            {
                                vector.y = raycastHit2.point.y;
                            }
                            battleActor.chara.SetPosition(vector);
                            this.m_multiBattleActorList.Add(battleActor);
                            battleActor.SetPartyOrder(this.m_multiBattleActorList.Count - 1);
                            num2++;
                        }
                    }
                }
            }
            Func<float>[] array2 = null;
            Func<float>[] array3 = null;
            Func<float>[] array4 = null;
            Func<float>[] array5 = null;
            if (c237921cb068a73a8c1084a4d121e9eaf != null)
            {
                array2 = new Func<float>[]
                {
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.me79b3896d74924620249b1ca9543f96d),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m89b09bf4e6d0a47ea90f4a7981d04822),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m4cc35f769c68fa36df439a0b7588264e),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m5120d7a91941cc55f9b139da91f90994),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m7125fece171c13241632c34efa9bdc3c),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m40146e80579bf525c519dae42e46f86d),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.mb736a3ba0a6d0fb19cf8f715997194ba),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m3bada6fca99ccb56c6bb19f7503be2b3)
                };
                if (this.m_chaosBattle)
                {
                    array3 = new Func<float>[]
                    {
                        new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m68679beefff2bdf1dedaafc6e1d1a832),
                        new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.mbeee0400debe0964be15fe1b7119a588),
                        new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m32bc3b1a81e0ba00fd5b451a952e665b),
                        new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m7b52294038d2a82176a8b77d5566ea65),
                        new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.me55a47d3b46b0183f439f35c8b2d776c),
                        new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m0d6b9bf8ea16ad57c2cbcf7b7207a86e),
                        new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.md21ff2f4d656d11735d7d9242028828a),
                        new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m584392ff1c47758a3231b32a471437fb)
                    };
                }
                array4 = new Func<float>[]
                {
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m4cee1898bad49c69662ef8ddd954cd58),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m97dc4b71502bb4e109fc09ef78781dc4),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m6fcadca601d250ee4cbb62de4488ee76),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.ma5e7a298ee233d691ec5f9868854d541),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m0614059609b90c3a8b330acbe76c1c84),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.madd3a312ec9e7dd8c184e45fc6e2de01),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.mc2e776ea5369aa95e124f50660cc5eab),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m81a58a0c83247bbbf072cf598c790aef)
                };
                array5 = new Func<float>[]
                {
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.mb9fd78ec381411f25aad5eb3dcb787b0),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m3ee26298066b90a1838a976a885dab4c),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m94ee0dfc3b5d03d6e0b40c2cfc16325c),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m6080cecabd47bd6018b4064e8d58d441),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m318feea5305438fbf603064c47bb6a67),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.mfe0c75eccbd2cff1ca53d6aaff7c242a),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m9c08dede829c0e820d512d32104f9f8e),
                    new Func<float>(c237921cb068a73a8c1084a4d121e9eaf.m987c6e57d115e88c42c04a8793972390)
                };
            }
            RaycastHit raycastHit3 = default(RaycastHit);
            int layerMask = 1 << LayerMask.NameToLayer("Phy Bg");
            int num4 = -1;
            for (int j = 0; j < this._entryBattleCharaSpecList.Count; j++)
            {
                string enemyActorName = BattleManager.GetEnemyActorName(j);
                BattleActor battleActor2 = this.FindActor(enemyActorName);
                if (battleActor2 != null)
                {
                    if (c237921cb068a73a8c1084a4d121e9eaf != null)
                    {
                        if (array2[j] != null && array4[j] != null)
                        {
                            Vector3 vector2 = new Vector3(array2[j](), 5f, array4[j]());
                            if (this.m_chaosBattle && array3 != null)
                            {
                                vector2.y = array3[j]();
                            }
                            else if (Physics.Raycast(vector2, Vector3.down, out raycastHit3, float.PositiveInfinity, layerMask))
                            {
                                vector2.y = raycastHit3.point.y;
                            }
                            battleActor2.SetPlacementPos(vector2);
                        }
                        if (array5[j] != null)
                        {
                            battleActor2.chara.transform.localEulerAngles = new Vector3(0f, array5[j](), 0f);
                        }
                    }
                    Animator animatorComponent4 = battleActor2.chara.GetAnimatorComponent();
                    animatorComponent4.cullingMode = AnimatorCullingMode.AlwaysAnimate;
                    C4d4f3a800432e94568175cb31ad3c78d.C51747b7e0e19ad065084a2c5a6d8421b c51747b7e0e19ad065084a2c5a6d8421b = C4d4f3a800432e94568175cb31ad3c78d.Find(this._entryBattleCharaSpecList[j]);
                    if (c51747b7e0e19ad065084a2c5a6d8421b != null && (int)c51747b7e0e19ad065084a2c5a6d8421b.ma225879fc7f6778cf12d05d9caf0cda3() != 0)
                    {
                        num4++;
                    }
                    battleActor2.Init(this._entryBattleCharaSpecList[j], this.m_enemyLevel, j, num4);
                    battleActor2.TargetActor = this.m_playerActor;
                    if (c6a63ba3da59f35f0fee059da0f7321db != null && c6a63ba3da59f35f0fee059da0f7321db.m4f63acfb743cb25115f76fc77af6151e(j) != 0)
                    {
                        battleActor2.State = BattleActor.StateType.StandBy;
                        battleActor2.chara.gameObject.SetActive(false);
                        battleActor2.LoopOffAiResidentEffect();
                        battleActor2.SaveFlagBits |= BattleActor.SaveFlagBitType.StandBy;
                    }
                    else
                    {
                        battleActor2.SetStateIdle(true, -1, -1);
                        PhysicsController physicsControllerComponent = battleActor2.chara.GetPhysicsControllerComponent();
                        if (physicsControllerComponent)
                        {
                            physicsControllerComponent.Reset(1f);
                        }
                    }
                }
            }
            this.InitSameCharaIndex();
            if (Mevius.App.Api.IsTrialMode())
            {
                this.m_autoAttack = BattleManager.AutoAttackType.FullAutoAttack;
            }
            else if (Mevius.Db.Api.IsTutorial())
            {
                this.m_autoAttack = BattleManager.AutoAttackType.Off;
            }
            bool flag = true;
            if (!Mevius.App.Api.IsPartyMode() && Mevius.Db.Api.IsEnableClientSaveData(0u) && Mevius.Db.Api.HasBattleData())
            {
                DbManager.BattleData battleData = Mevius.Db.Api.GetBattleData();
                flag = (battleData.step <= 2);
            }
            else
            {
                BattleUtility.SetOverMissionCount(MissionCountType.TurnMax, this.m_turnNum);
                BattleUtility.AddMissionCount(MissionCountType.TurnTotal, 1);
                for (int k = 0; k < this._entryBattleCharaSpecList.Count; k++)
                {
                    string enemyActorName2 = BattleManager.GetEnemyActorName(k);
                    BattleActor battleActor3 = this.FindActor(enemyActorName2);
                    if (battleActor3 != null)
                    {
                        BattleUtility.AddMissionCount(MissionCountType.EnemyHpTotal, battleActor3.HpMax);
                        BattleUtility.AddMissionCount(MissionCountType.EnemyBpTotal, battleActor3.BpMax);
                        if (battleActor3.IsActive() && battleActor3.Ai != null)
                        {
                            battleActor3.Ai.OnBehavior(BattleAiData.Pattern.TimingType.Init, string.Empty, null, true);
                        }
                    }
                }
                this.InitElementInfluence();
                this.SaveData();
            }
            this.ProcManToMan();
            if (Mevius.Party.Api.IsFirstSnap())
            {
                this.SaveMultiData();
            }
            Mevius.Gui.Api.ShowHideBillboard(false);
            if (flag)
            {
                Mevius.Gui.Api.RemoveDelayLoadingIcon(NowLoadingManager.Layer.TopLevel, "TopLevel");
                this.m_playerActor.onEncount();
                for (int l = 0; l < this.m_actorList.Count; l++)
                {
                    BattleActor battleActor4 = this.m_actorList[l];
                    if (battleActor4 != null && battleActor4.IsEnemy() && battleActor4.IsActive())
                    {
                        this.m_playerActor.TargetActor = battleActor4;
                        break;
                    }
                }
                if (Mevius.App.Api.IsPartyMode())
                {
                    this.m_targetActor = this.m_playerActor.TargetActor;
                }
                else
                {
                    this.UpdateSelectedTarget();
                }
                Vector3 forward = this.m_playerActor.TargetActor.chara.transform.position - this.m_playerActor.chara.transform.position;
                forward.y = 0f;
                this.m_playerActor.chara.transform.rotation = Quaternion.LookRotation(forward);
                for (int m = 0; m < this.m_multiBattleActorList.Count; m++)
                {
                    BattleActor battleActor5 = this.m_multiBattleActorList[m];
                    if (battleActor5.IsMultiMember())
                    {
                        Vector3 forward2 = this.m_playerActor.TargetActor.chara.transform.position - battleActor5.chara.transform.position;
                        forward2.y = 0f;
                        battleActor5.chara.transform.rotation = Quaternion.LookRotation(forward2);
                        battleActor5.onEncount();
                        battleActor5.TargetActor = this.m_playerActor.TargetActor;
                    }
                }
                this.InitFairyActor();
                this.m_cameraManager.InitTargetSelect(this.m_boss, this.m_playerActor, this.m_playerActor.TargetActor);
                this.m_cameraManager.CameraSequence.Charactor = this.m_playerActor.chara;
                this.m_cameraManager.ChangeCamera(BattleCameraManager.CameraType.Sequence);
                this._step = BattleManager.BattleStep.EncountCameraWait;
            }
            else
            {
                Mevius.Gui.Api.CreateBattleMenu();
                this.LoadPlayerCardResources();
                this._step = BattleManager.BattleStep.MenuCreateWait;
            }
            this.m_guiTouchComponent.m_stateBit = 0u;
            this.UpdateCamera();
            this.lastBattleWinActorObject = null;
        }

        private void UpdateBattleStart()
        {
            if (this.m_playerActor != null)
            {
                this.m_playerActor.OnBattleBegin();
            }
            BattleActor battleActor = null;
            bool flag = true;
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                BattleActor battleActor2 = this.m_actorList[i];
                if (battleActor2 != null && battleActor2.IsEnemy() && battleActor2.IsActive() && battleActor2.State != BattleActor.StateType.Idle && !battleActor2.IsActionEnd())
                {
                    battleActor = battleActor2;
                    flag = false;
                    break;
                }
            }
            bool flag2 = battleActor != null && battleActor.IsFlagBit(BattleActor.FlagBitType.AbilityInputWait);
            if (this.CameraManager.IsActionEnd() && !flag2)
            {
                if (battleActor != null && this.m_cameraManager.CurrentCameraType != BattleCameraManager.CameraType.TargetSelect)
                {
                    float interpSec;
                    CameraSequence.BlendType blendType;
                    if (!this.m_cameraManager.GetActionNextInterpInfo(out interpSec, out blendType))
                    {
                        interpSec = 0.5f;
                        blendType = CameraSequence.BlendType.Curve;
                    }
                    this.m_cameraManager.SetInterpolation(interpSec, blendType, true);
                    this.m_cameraManager.InitTargetSelect(this.m_boss, this.m_playerActor, battleActor);
                    this.m_cameraManager.ChangeCamera(BattleCameraManager.CameraType.TargetSelect);
                }
                else
                {
                    this.ChangeTargetSelectCamera(false);
                }
            }
            this.UpdateCamera();
            this.UpdateTime();
            if (!this.m_damageSourceManager.IsExist())
            {
                if (this.m_playerActor.Hp <= 0)
                {
                    if (this.m_playerActor.IsDeadIdle())
                    {
                        if (Mevius.Db.Api.IsTutorial() || Mevius.App.Api.IsTrialMode())
                        {
                            this.RevivePlayer();
                            this._step = BattleManager.BattleStep.PlayerTurnStart;
                        }
                        else if (Mevius.App.Api.IsPartyMode())
                        {
                            this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                            this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.CurrentPlayer;
                        }
                        else
                        {
                            this._step = BattleManager.BattleStep.ContinueCheck;
                        }
                        this.HideBattleEnemyActionName();
                        Mevius.Gui.Api.ClearDQBattleLogText();
                    }
                }
                else if (flag)
                {
                    bool flag3 = false;
                    for (int j = 0; j < this.m_actorList.Count; j++)
                    {
                        BattleActor battleActor3 = this.m_actorList[j];
                        if (battleActor3 != null && battleActor3.IsEnemy() && battleActor3.IsActive() && battleActor3.OnBattleBegin() && battleActor3.State == BattleActor.StateType.Ability)
                        {
                            if (!this.m_playerActor.IsDead() && this.m_playerActor.State != BattleActor.StateType.Guard)
                            {
                                this.m_playerActor.StartGuard();
                            }
                            if (this.m_boss)
                            {
                                if (this.CameraManager.CurrentCameraType != BattleCameraManager.CameraType.Action || !this.CameraManager.IsActionOwner(battleActor3))
                                {
                                    this.CameraManager.SetInterpolation(0.5f, CameraSequence.BlendType.Curve, true);
                                    this.CameraManager.InitTargetSelect(this.m_boss, this.m_playerActor, battleActor3);
                                    this.CameraManager.ChangeCamera(BattleCameraManager.CameraType.TargetSelect);
                                }
                            }
                            else if (this.CameraManager.CurrentCameraType != BattleCameraManager.CameraType.Action)
                            {
                                string name = ExtensionElementIdDefinition.GetName(ExtensionElementIdDefinition.Index.BODY_CENTER);
                                Vector3 position = battleActor3.chara.GetElementIdTransform(name).position;
                                Camera component = Mevius.Renderer.CameraManager.GetInstance().GetViewCameraGameObject().GetComponent<Camera>();
                                Vector3 vector = component.WorldToViewportPoint(position);
                                if (vector.x < 0f || vector.x > 1f || vector.y < 0f || vector.y > 1f || vector.z <= 0f)
                                {
                                    this.CameraManager.SetInterpolation(1f, CameraSequence.BlendType.Curve, true);
                                    this.CameraManager.InitTwoShot(battleActor3, this.m_playerActor, 0, false);
                                    this.CameraManager.ChangeCamera(BattleCameraManager.CameraType.TwoShot);
                                }
                            }
                            else if (!this.CameraManager.IsActionOwner(battleActor3))
                            {
                                this.CameraManager.SetInterpolation(1f, CameraSequence.BlendType.Curve, true);
                                this.CameraManager.InitTwoShot(battleActor3, this.m_playerActor, 0, false);
                                this.CameraManager.ChangeCamera(BattleCameraManager.CameraType.TwoShot);
                            }
                            flag3 = true;
                            break;
                        }
                    }
                    if (!flag3)
                    {
                        this.HideBattleEnemyActionName();
                        Mevius.Gui.Api.ClearDQBattleLogText();
                        if (!this.IsCountTimeBattle())
                        {
                            for (int k = 0; k < this.m_actorList.Count; k++)
                            {
                                BattleActor battleActor4 = this.m_actorList[k];
                                if (battleActor4 != null && battleActor4.IsEnemy() && battleActor4.IsActive())
                                {
                                    battleActor4.OnTurnEnd();
                                }
                            }
                        }
                        if (Mevius.App.Api.IsPartyMode())
                        {
                            this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                            this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.CurrentPlayer;
                        }
                        else
                        {
                            this._step = BattleManager.BattleStep.FairyTurnStart;
                        }
                        this.SaveData();
                    }
                }
            }
        }

        private void UpdatePlayerTurn()
        {
            if (Mevius.App.Api.IsPartyMode() && Mevius.Party.Api.IsExitPlayer())
            {
                this.Step = BattleManager.BattleStep.Escape;
                return;
            }
            this.UpdateCamera();
            this.UpdateTime();
            if (this.m_playerActor != null && this.m_playerActor.IsDead())
            {
                if (this.m_playerActor.IsDeadIdle())
                {
                    this.m_damageSourceManager.Clear();
                    if (this.m_playerActor.IsSummon())
                    {
                        this.ProcChangeJob(false, false);
                    }
                    else if (Mevius.Db.Api.IsTutorial() || Mevius.App.Api.IsTrialMode())
                    {
                        this.RevivePlayer();
                        this._step = BattleManager.BattleStep.PlayerTurnStart;
                    }
                    else if (Mevius.App.Api.IsPartyMode())
                    {
                        this.m_multiBattleSlotList.RemoveAt(0);
                        if (this.m_multiBattleSlotList.Count > 0)
                        {
                            this._step = BattleManager.BattleStep.PlayerTurnStart;
                        }
                        else
                        {
                            this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.CurrentPlayer;
                            this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                        }
                    }
                    else
                    {
                        this._step = BattleManager.BattleStep.ContinueCheck;
                    }
                }
                return;
            }
            this.m_battleSlow.Update(Mevius.App.Api.GetDeltaTime());
            if (this.m_playerActor == null)
            {
                return;
            }
            bool flag = true;
            bool flag2 = false;
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                if (this.m_actorList[i].IsEnemy() && !this.m_actorList[i].IsNeedNotKill())
                {
                    if (this.m_actorList[i].IsActive())
                    {
                        flag = false;
                        break;
                    }
                    if (this.m_actorList[i].IsRewardWait())
                    {
                        flag2 = true;
                    }
                }
            }
            if (flag)
            {
                if (this.CameraManager.IsActionEnd())
                {
                    this.ChangeTargetSelectCamera(false);
                }
                bool flag3 = this.m_damageSourceManager.IsExist();
                if (!flag2 && !flag3)
                {
                    this.SetBattleWin(0f);
                }
            }
            else if (this.IsPlayerActionEnd())
            {
                this.m_lasTouchPosInited = false;
                if (this.m_playerActor.IsTurnEnd())
                {
                    this.m_actionStepWait += Mevius.App.Api.GetDeltaTimeForBattle();
                    if (this.m_actionStepWait > Mevius.DataSheet.Api.GetResidentFloat("playerTurnEndWaitSec", 0.5f))
                    {
                        this.m_actionStepWait = 0f;
                        Mevius.App.Api.SetTimeScale(1f);
                        if (!this.IsCountTimeBattle())
                        {
                            this.m_playerActor.OnTurnEnd();
                            if (this.m_playerActorSub != null)
                            {
                                this.m_playerActorSub.OnTurnEnd();
                            }
                            this._step = BattleManager.BattleStep.EnemyTurnStart;
                        }
                        this.SaveData();
                        if (Mevius.App.Api.IsPartyMode())
                        {
                            this.m_multiBattleSlotList.RemoveAt(0);
                            if (this.m_multiBattleSlotList.Count > 0)
                            {
                                this._step = BattleManager.BattleStep.PlayerTurnStart;
                            }
                            else
                            {
                                this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.CurrentPlayer;
                                this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                            }
                        }
                    }
                }
                else if (this.CameraManager.IsActionEnd() || this.m_playerActor.State == BattleActor.StateType.Idle)
                {
                    if (this.m_playerActor.State != BattleActor.StateType.Ability && this.m_playerActor.State != BattleActor.StateType.CloseAttack && this.m_playerActor.TargetActor != null && !this.m_playerActor.TargetActor.IsActive())
                    {
                        this.m_playerActor.TargetActor = this.GetEnemyActor(this.m_playerActor.TargetActor);
                    }
                    this.ChangeTargetSelectCamera(false);
                }
            }
            else
            {
                if (this.CameraManager.IsActionEnd() && !this.m_playerActor.IsFairyActionWait())
                {
                    this.ChangeTargetSelectCamera(false);
                }
                Mevius.Renderer.CameraManager instance = Mevius.Renderer.CameraManager.GetInstance();
                if (instance != null)
                {
                    if (this.m_guiTouchComponent.IsPress() && this.m_playerActor.IsPlayerInputAccept())
                    {
                        Vector2 touchEmulatePosition = Mevius.App.Api.GetTouchEmulatePosition();
                        this.m_inputCheck = true;
                        this.m_inputTouch = true;
                        this.m_touchDownPos = touchEmulatePosition;
                        this.m_touchPos[0] = touchEmulatePosition;
                        this.m_touchPos[1] = touchEmulatePosition;
                    }
                    bool flag4 = false;
                    if (this.m_autoAttack != BattleManager.AutoAttackType.Off || Mevius.App.Api.IsPartyMode())
                    {
                        if (this.m_playerActor.IsPlayerInputAccept())
                        {
                            flag4 = true;
                        }
                        if (this.m_playerActor.ActionNum == 0)
                        {
                            flag4 = true;
                        }
                    }
                    else if (this.m_inputTouch)
                    {
                        if (this.m_guiTouchComponent.IsDown())
                        {
                            this.m_touchPos[0] = this.m_touchPos[1];
                            this.m_touchPos[1] = Mevius.App.Api.GetTouchEmulatePosition();
                            Vector2 presentationPosition = instance.GetPresentationPosition(this.m_touchDownPos);
                            Vector2 presentationPosition2 = instance.GetPresentationPosition(this.m_touchPos[0]);
                            Vector2 presentationPosition3 = instance.GetPresentationPosition(this.m_touchPos[1]);
                            presentationPosition.y /= instance.GetPresentationAspect();
                            presentationPosition2.y /= instance.GetPresentationAspect();
                            presentationPosition3.y /= instance.GetPresentationAspect();
                            float magnitude = (presentationPosition3 - presentationPosition).magnitude;
                            if (magnitude > 0.1f)
                            {
                                this.m_stayMove = true;
                            }
                        }
                        if (this.m_guiTouchComponent.IsUp())
                        {
                            if (!this.m_inputAccepted && this.m_playerActor.IsPlayerInputAccept() && !this.m_stayMove)
                            {
                                BattleActor battleActor = null;
                                if (this.IsTargetChangeMode())
                                {
                                    GameObject viewCameraGameObject = instance.GetViewCameraGameObject();
                                    if (viewCameraGameObject && viewCameraGameObject.GetComponent<Camera>())
                                    {
                                        Vector2 presentationPosition4 = instance.GetPresentationPosition(this.m_touchPos[1]);
                                        Vector2 a = presentationPosition4;
                                        a.y /= instance.GetPresentationAspect();
                                        float num = 1024f;
                                        string name = ExtensionElementIdDefinition.GetName(ExtensionElementIdDefinition.Index.BODY_CENTER);
                                        for (int j = 0; j < this.m_actorList.Count; j++)
                                        {
                                            BattleActor battleActor2 = this.m_actorList[j];
                                            if (battleActor2.IsEnemy() && battleActor2.IsActiveTarget())
                                            {
                                                Transform elementIdTransform = battleActor2.chara.GetElementIdTransform(name);
                                                if (elementIdTransform)
                                                {
                                                    Vector3 vector = viewCameraGameObject.GetComponent<Camera>().WorldToViewportPoint(elementIdTransform.position);
                                                    if (vector.z > 0f)
                                                    {
                                                        Vector3 v = vector;
                                                        v.y /= instance.GetPresentationAspect();
                                                        float num2 = Vector2.Distance(a, v);
                                                        bool flag5 = false;
                                                        Vector3 position = new Vector3(presentationPosition4.x, presentationPosition4.y, vector.z);
                                                        Vector3 b = viewCameraGameObject.GetComponent<Camera>().ViewportToWorldPoint(position);
                                                        float num3 = 0.5f;
                                                        C95bcaea3352f97e159106604018eaa69.Cd665cdef191ff92708675209607d4634 cd665cdef191ff92708675209607d = C95bcaea3352f97e159106604018eaa69.Find(battleActor2.chara.spec);
                                                        if (cd665cdef191ff92708675209607d != null)
                                                        {
                                                            num3 = cd665cdef191ff92708675209607d.m9c2eb8f9a248c0d1381a0c078b73c70c() * cd665cdef191ff92708675209607d.mbdaffba4ca6452435da172e215b2ed94();
                                                        }
                                                        if (Vector3.Distance(elementIdTransform.position, b) < num3)
                                                        {
                                                            flag5 = true;
                                                        }
                                                        else
                                                        {
                                                            float num4 = (!this.IsTargetChangeMode()) ? 0.125f : 0.25f;
                                                            if (num2 < num4)
                                                            {
                                                                flag5 = true;
                                                            }
                                                        }
                                                        if (flag5 && num2 < num)
                                                        {
                                                            battleActor = battleActor2;
                                                            num = num2;
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                }
                                bool flag6 = false;
                                if (battleActor != null && battleActor != this.m_targetActor)
                                {
                                    flag6 = true;
                                    this.m_targetActor = battleActor;
                                    this.m_inputCheck = false;
                                    string soundResourceName = Mevius.Sound.Api.GetSoundResourceName("Resident");
                                    Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Gui, soundResourceName, "system_se_cursor_01", 1f, 0, 0, Vector3.zero, null, false, -1, 0, 1f);
                                }
                                if (!flag6 && this.m_targetActor != null && this.m_targetActor.IsActive() && !this.m_ignoreAttack)
                                {
                                    this.CheckPlayerTargetChange();
                                    this.m_inputAccepted = true;
                                    this.m_inputCheck = false;
                                }
                            }
                            this.m_inputTouch = false;
                            this.m_inputCheck = false;
                            this.m_stayMove = false;
                        }
                    }
                    if (flag4)
                    {
                        this.m_autoAttackTimer += Mevius.App.Api.GetDeltaTime();
                        float residentFloat = Mevius.DataSheet.Api.GetResidentFloat("autoAttackWaitSec", 0f);
                        if (this.m_autoAttackTimer > residentFloat)
                        {
                            this.CheckPlayerTargetChange();
                            this.m_inputAccepted = true;
                        }
                        this.m_inputCheck = false;
                    }
                }
                if (this.IsBattleCameraDragging())
                {
                    if (!this.m_lasTouchPosInited)
                    {
                        this.m_lasTouchPosInited = true;
                        this.m_lastTouchPos = Mevius.App.Api.GetTouchEmulatePosition();
                    }
                    Vector2 v2 = Mevius.App.Api.GetTouchEmulatePosition() - this.m_lastTouchPos;
                    Camera component = Mevius.Renderer.CameraManager.GetInstance().GetViewCameraGameObject().GetComponent<Camera>();
                    if (Mathf.Abs(v2.x) >= 1.401298E-45f)
                    {
                        if (this.m_inputTouch || !this.m_cameraManager.IsTargetSelectForcus())
                        {
                        }
                        float num5 = component.ScreenToViewportPoint(v2).x * BattleManager.TargetSelectHrzAngleAdjust;
                        if (!Mevius.Db.Api.GetBattleCameraHrzRotReverse())
                        {
                            num5 *= -1f;
                        }
                        this.CameraManager.AddTargetSelectHrzAngle(num5);
                    }
                    if (Mathf.Abs(v2.y) >= 1.401298E-45f)
                    {
                        float num6 = component.ScreenToViewportPoint(v2).y * BattleManager.TargetSelectVrtAngleAdjust;
                        if (Mevius.Db.Api.GetBattleCameraVrtRotReverse())
                        {
                            num6 *= -1f;
                        }
                        this.CameraManager.AddTargetSelectVrtAngle(num6);
                    }
                    this.m_lastTouchPos = Mevius.App.Api.GetTouchEmulatePosition();
                }
                else
                {
                    if (this.m_playerActor.State != BattleActor.StateType.Ability && this.m_playerActor.State != BattleActor.StateType.CloseAttack && this.m_playerActor.TargetActor != null && !this.m_playerActor.TargetActor.IsActive())
                    {
                        this.m_playerActor.TargetActor = this.GetEnemyActor(this.m_playerActor.TargetActor);
                        if (this.CameraManager.CurrentCameraType != BattleCameraManager.CameraType.Action)
                        {
                            BattleManager._i.ChangeTargetSelectCamera(false);
                        }
                        this.m_playerActor.OnTurnTarget();
                    }
                    this.m_lasTouchPosInited = false;
                }
                if (this.m_inputAccepted)
                {
                    if (this.m_playerActor.IsPlayerInputAccept())
                    {
                        if (Mevius.App.Api.IsPartyMode())
                        {
                            this.m_playerActor.ProcMultiBattleAction();
                        }
                        else
                        {
                            bool flag7 = false;
                            if (this.m_autoAttack == BattleManager.AutoAttackType.FullAutoAttack)
                            {
                                flag7 = this.m_playerActor.AutoAbilityAttack();
                            }
                            if (!flag7)
                            {
                                this.m_playerActor.NormalAttack(Vector3.forward, true, false);
                            }
                        }
                        this.m_inputAccepted = false;
                        this.m_autoAttackTimer = 0f;
                    }
                    else if (Mevius.App.Api.IsPartyMode() && this.m_playerActor.ActionNum == 0)
                    {
                        this.m_playerActor.ProcMultiBattleAction();
                        this.m_inputAccepted = false;
                        this.m_autoAttackTimer = 0f;
                    }
                }
            }
            this.UpdateTest();
        }

        private void UpdateMultiBattleInput()
        {
            if (Mevius.App.Api.IsPartyMode() && Mevius.Party.Api.IsExitPlayer())
            {
                this.Step = BattleManager.BattleStep.Escape;
                return;
            }
            if (Mevius.Party.Api.IsNeedRevivalStep())
            {
                for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
                {
                    BattleActor battleActor = this.m_multiBattleActorList[i];
                    if (Mevius.Party.Api.ExecRevivalSlot(battleActor.PartySlot) != Mevius.Party.Api.ExecRevival.ExecRevival_NONE && battleActor.IsDead())
                    {
                        battleActor.OnRevive();
                        battleActor.OnTurnBegin();
                        if (battleActor.ReadyAction())
                        {
                        }
                        if (battleActor.PartyMemberType == Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_ME)
                        {
                            Mevius.Gui.Api.HidePlayerDeadTimer();
                            Mevius.Gui.Api.ShowPlayerTurnTimer();
                            Mevius.Gui.Api.ShowDecideButton();
                            Mevius.Gui.Api.SetBattleTargetButtonEnable(true);
                        }
                    }
                }
                this.m_multiBattleTurnStartTime = Mevius.Party.Api.GetBeginLimitTime();
                this.m_multiBattleTurnLimitTime = (ulong)Mevius.Party.Api.GetBaseLimitTime();
                this.m_multiBattleStartTime = Mevius.Party.Api.GetBeginBattleTime();
                this.ProcManToMan();
            }
            if (Mevius.Party.Api.IsExistForceSnap())
            {
                Mevius.App.Api.SetTimeScale(1f);
                this.EndSlow();
                this.m_playerActor.EndMultiBattleInput();
                this.m_playerActor.SendMultiBattleCommand(false);
                this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.MultiInputWait;
                this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                return;
            }
            this.UpdateCamera();
            this.UpdateTime();
            this.m_battleSlow.Update(Mevius.App.Api.GetDeltaTime());
            bool flag = true;
            bool flag2 = false;
            for (int j = 0; j < this.m_actorList.Count; j++)
            {
                if (this.m_actorList[j].IsEnemy() && !this.m_actorList[j].IsNeedNotKill())
                {
                    if (this.m_actorList[j].IsActive())
                    {
                        flag = false;
                        break;
                    }
                    if (this.m_actorList[j].IsRewardWait())
                    {
                        flag2 = true;
                    }
                }
            }
            if (flag)
            {
                if (!flag2)
                {
                    this.SetBattleWin(0f);
                }
            }
            else
            {
                if (Mevius.Party.Api.IsNeedSendSnap(true))
                {
                    for (int k = 0; k < this.m_multiBattleActorList.Count; k++)
                    {
                        BattleActor battleActor2 = this.m_multiBattleActorList[k];
                        if (battleActor2.PartyMemberType != Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_EMPTY && battleActor2.PartyMemberType != Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_ME)
                        {
                            if (!battleActor2.IsDead())
                            {
                                if (Mevius.Party.Api.IsAutoAiStatus(battleActor2.PartySlot) && !battleActor2.CommandInputEnd)
                                {
                                    battleActor2.AutoAbilityAttackMulti();
                                }
                            }
                        }
                    }
                }
                if (this.m_playerActor != null && this.m_playerActor.IsDead())
                {
                    if ((!Mevius.Party.Api.IsDestroyParty() && this.MultiBattleTimeLeftOfTurn <= 0) || Mevius.Party.Api.IsFinishCommand())
                    {
                        this.EndSlow();
                        for (int l = 0; l < this.m_multiBattleActorList.Count; l++)
                        {
                            BattleActor battleActor3 = this.m_multiBattleActorList[l];
                            if (battleActor3.PartyMemberType != Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_EMPTY && battleActor3.PartyMemberType != Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_ME)
                            {
                                if (Mevius.Party.Api.IsAutoAiStatus(battleActor3.PartySlot))
                                {
                                    battleActor3.UseActionPass(false, true);
                                    battleActor3.SendMultiBattleCommand(true);
                                }
                            }
                        }
                        this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.MultiInputWait;
                        this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                    }
                    return;
                }
                if (!this.IsPlayerInputEnd() && Mevius.Party.Api.IsFinishMyCommand())
                {
                    this.SetPlayerActionPass();
                }
                else if (this.IsPlayerInputEnd())
                {
                    this.m_lasTouchPosInited = false;
                    if (this.m_playerActor.IsTurnEnd())
                    {
                        Mevius.App.Api.SetTimeScale(1f);
                        this.EndSlow();
                        this.m_playerActor.EndMultiBattleInput();
                        this.m_playerActor.SendMultiBattleCommand(false);
                        this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.MultiInputWait;
                        this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                    }
                }
                else
                {
                    if (this.CameraManager.IsActionEnd() && !this.m_playerActor.IsFairyActionWait())
                    {
                        this.ChangeTargetSelectCamera(false);
                    }
                    Mevius.Renderer.CameraManager instance = Mevius.Renderer.CameraManager.GetInstance();
                    if (instance != null)
                    {
                        if (this.m_guiTouchComponent.IsPress() && this.m_playerActor.IsPlayerInputAccept())
                        {
                            Vector2 touchEmulatePosition = Mevius.App.Api.GetTouchEmulatePosition();
                            this.m_inputCheck = true;
                            this.m_inputTouch = true;
                            this.m_touchDownPos = touchEmulatePosition;
                            this.m_touchPos[0] = touchEmulatePosition;
                            this.m_touchPos[1] = touchEmulatePosition;
                        }
                        if (this.m_inputTouch)
                        {
                            if (this.m_guiTouchComponent.IsDown())
                            {
                                this.m_touchPos[0] = this.m_touchPos[1];
                                this.m_touchPos[1] = Mevius.App.Api.GetTouchEmulatePosition();
                                Vector2 presentationPosition = instance.GetPresentationPosition(this.m_touchDownPos);
                                Vector2 presentationPosition2 = instance.GetPresentationPosition(this.m_touchPos[0]);
                                Vector2 presentationPosition3 = instance.GetPresentationPosition(this.m_touchPos[1]);
                                presentationPosition.y /= instance.GetPresentationAspect();
                                presentationPosition2.y /= instance.GetPresentationAspect();
                                presentationPosition3.y /= instance.GetPresentationAspect();
                                float magnitude = (presentationPosition3 - presentationPosition).magnitude;
                                if (magnitude > 0.1f)
                                {
                                    this.m_stayMove = true;
                                }
                            }
                            if (this.m_guiTouchComponent.IsUp())
                            {
                                if (!this.m_inputAccepted && this.m_playerActor.IsPlayerInputAccept() && !this.m_stayMove)
                                {
                                    BattleActor battleActor4 = null;
                                    if (this.IsTargetChangeMode())
                                    {
                                        GameObject viewCameraGameObject = instance.GetViewCameraGameObject();
                                        if (viewCameraGameObject && viewCameraGameObject.GetComponent<Camera>())
                                        {
                                            Vector2 presentationPosition4 = instance.GetPresentationPosition(this.m_touchPos[1]);
                                            Vector2 a = presentationPosition4;
                                            a.y /= instance.GetPresentationAspect();
                                            float num = 1024f;
                                            string name = ExtensionElementIdDefinition.GetName(ExtensionElementIdDefinition.Index.BODY_CENTER);
                                            for (int m = 0; m < this.m_actorList.Count; m++)
                                            {
                                                BattleActor battleActor5 = this.m_actorList[m];
                                                if (battleActor5.IsEnemy() && battleActor5.IsActiveTarget())
                                                {
                                                    Transform elementIdTransform = battleActor5.chara.GetElementIdTransform(name);
                                                    if (elementIdTransform)
                                                    {
                                                        Vector3 vector = viewCameraGameObject.GetComponent<Camera>().WorldToViewportPoint(elementIdTransform.position);
                                                        if (vector.z > 0f)
                                                        {
                                                            Vector3 v = vector;
                                                            v.y /= instance.GetPresentationAspect();
                                                            float num2 = Vector2.Distance(a, v);
                                                            bool flag3 = false;
                                                            Vector3 position = new Vector3(presentationPosition4.x, presentationPosition4.y, vector.z);
                                                            Vector3 b = viewCameraGameObject.GetComponent<Camera>().ViewportToWorldPoint(position);
                                                            float num3 = 0.5f;
                                                            C95bcaea3352f97e159106604018eaa69.Cd665cdef191ff92708675209607d4634 cd665cdef191ff92708675209607d = C95bcaea3352f97e159106604018eaa69.Find(battleActor5.chara.spec);
                                                            if (cd665cdef191ff92708675209607d != null)
                                                            {
                                                                num3 = cd665cdef191ff92708675209607d.m9c2eb8f9a248c0d1381a0c078b73c70c() * cd665cdef191ff92708675209607d.mbdaffba4ca6452435da172e215b2ed94();
                                                            }
                                                            if (Vector3.Distance(elementIdTransform.position, b) < num3)
                                                            {
                                                                flag3 = true;
                                                            }
                                                            else
                                                            {
                                                                float num4 = (!this.IsTargetChangeMode()) ? 0.125f : 0.25f;
                                                                if (num2 < num4)
                                                                {
                                                                    flag3 = true;
                                                                }
                                                            }
                                                            if (flag3 && num2 < num)
                                                            {
                                                                battleActor4 = battleActor5;
                                                                num = num2;
                                                            }
                                                        }
                                                    }
                                                }
                                            }
                                        }
                                    }
                                    bool flag4 = false;
                                    if (battleActor4 != null && battleActor4 != this.m_targetActor)
                                    {
                                        flag4 = true;
                                        this.m_targetActor = battleActor4;
                                        this.m_inputCheck = false;
                                        string soundResourceName = Mevius.Sound.Api.GetSoundResourceName("Resident");
                                        Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Gui, soundResourceName, "system_se_cursor_01", 1f, 0, 0, Vector3.zero, null, false, -1, 0, 1f);
                                    }
                                    if (!flag4 && this.m_targetActor != null && this.m_targetActor.IsActive() && !this.m_ignoreAttack)
                                    {
                                        this.CheckPlayerTargetChange();
                                        this.m_inputAccepted = true;
                                        this.m_inputCheck = false;
                                    }
                                }
                                this.m_inputTouch = false;
                                this.m_inputCheck = false;
                                this.m_stayMove = false;
                            }
                        }
                    }
                    if (this.m_inputCheck && (this.m_playerActor.State == BattleActor.StateType.Idle || this.m_playerActor.State == BattleActor.StateType.Guard) && this.m_guiTouchComponent.IsDown())
                    {
                        if (!this.m_lasTouchPosInited)
                        {
                            this.m_lasTouchPosInited = true;
                            this.m_lastTouchPos = Mevius.App.Api.GetTouchEmulatePosition();
                        }
                        Vector2 v2 = Mevius.App.Api.GetTouchEmulatePosition() - this.m_lastTouchPos;
                        Camera component = Mevius.Renderer.CameraManager.GetInstance().GetViewCameraGameObject().GetComponent<Camera>();
                        if (Mathf.Abs(v2.x) >= 1.401298E-45f)
                        {
                            if (this.m_inputTouch || !this.m_cameraManager.IsTargetSelectForcus())
                            {
                            }
                            float num5 = component.ScreenToViewportPoint(v2).x * BattleManager.TargetSelectHrzAngleAdjust;
                            if (!Mevius.Db.Api.GetBattleCameraHrzRotReverse())
                            {
                                num5 *= -1f;
                            }
                            this.CameraManager.AddTargetSelectHrzAngle(num5);
                        }
                        if (Mathf.Abs(v2.y) >= 1.401298E-45f)
                        {
                            float num6 = component.ScreenToViewportPoint(v2).y * BattleManager.TargetSelectVrtAngleAdjust;
                            if (Mevius.Db.Api.GetBattleCameraVrtRotReverse())
                            {
                                num6 *= -1f;
                            }
                            this.CameraManager.AddTargetSelectVrtAngle(num6);
                        }
                        this.m_lastTouchPos = Mevius.App.Api.GetTouchEmulatePosition();
                    }
                    else
                    {
                        if (this.m_playerActor.State != BattleActor.StateType.Ability && this.m_playerActor.State != BattleActor.StateType.CloseAttack && this.m_playerActor.TargetActor != null && !this.m_playerActor.TargetActor.IsActive())
                        {
                            this.m_playerActor.TargetActor = this.GetEnemyActor(this.m_playerActor.TargetActor);
                            if (this.CameraManager.CurrentCameraType != BattleCameraManager.CameraType.Action)
                            {
                                BattleManager._i.ChangeTargetSelectCamera(false);
                            }
                            this.m_playerActor.OnTurnTarget();
                        }
                        this.m_lasTouchPosInited = false;
                    }
                    if (this.m_inputAccepted)
                    {
                        if (this.m_playerActor.IsPlayerInputAccept())
                        {
                            this.m_playerActor.NormalAttack(Vector3.forward, true, false);
                            this.m_inputAccepted = false;
                            this.m_autoAttackTimer = 0f;
                        }
                    }
                    else if (this.m_playerActor.PartyMemberType == Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_ME && this.MultiBattleTimeLeftOfTurn <= 0)
                    {
                        Mevius.Gui.Api.OnEndInput(Mevius.Gui.Api.EndInputType.TimeOver);
                        this.m_playerActor.UseActionPass(false, false);
                    }
                }
            }
        }

        private void UpdateEnemyTurnStart()
        {
            this.UpdateTime();
            this.m_partyMemberTurn = false;
            this.m_actionPriorityEnemyActorList.Clear();
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                BattleActor battleActor = this.m_actorList[i];
                if (battleActor != null && battleActor.IsEnemy())
                {
                    if (battleActor.IsActive())
                    {
                        battleActor.OnTurnBegin();
                    }
                    bool flag = false;
                    for (int j = 0; j < this.m_actionPriorityEnemyActorList.Count; j++)
                    {
                        if (battleActor.ActionPriority > this.m_actionPriorityEnemyActorList[j].ActionPriority)
                        {
                            this.m_actionPriorityEnemyActorList.Insert(j, battleActor);
                            flag = true;
                            break;
                        }
                    }
                    if (!flag)
                    {
                        this.m_actionPriorityEnemyActorList.Add(this.m_actorList[i]);
                    }
                }
            }
            Mevius.Gui.Api.SetBattleTargetButtonEnable(false);
            Mevius.Gui.Api.OnStartEnemyTurn();
            Mevius.Party.Api.ClearCommandStock();
            this._step = BattleManager.BattleStep.EnemyTurnStartWait;
        }

        private void UpdateEnemyTurnStartWait()
        {
            this.UpdateCamera();
            this.UpdateTime();
            bool flag = false;
            bool flag2 = false;
            if (Mevius.App.Api.IsPartyMode())
            {
                for (int i = 0; i < this.m_actionPriorityEnemyActorList.Count; i++)
                {
                    BattleActor battleActor = this.m_actionPriorityEnemyActorList[i];
                    if (battleActor.BreakState == BattleActor.BreakStateType.Recover)
                    {
                        return;
                    }
                }
            }
            for (int j = 0; j < this.m_actionPriorityEnemyActorList.Count; j++)
            {
                BattleActor battleActor2 = this.m_actionPriorityEnemyActorList[j];
                if (battleActor2.IsActive())
                {
                    if (!battleActor2.IsReadyAction())
                    {
                        battleActor2.ReadyAction();
                    }
                    if (battleActor2.ActionNum > 0)
                    {
                        if (battleActor2.UpdateReadyAction())
                        {
                            if (battleActor2.IsPlayer())
                            {
                                if (!battleActor2.AutoAbilityAttack())
                                {
                                    battleActor2.NormalAttack(Vector3.forward, true, false);
                                }
                                flag2 = true;
                            }
                            else if (battleActor2.OnAiBehavior())
                            {
                                flag2 = true;
                            }
                        }
                        else
                        {
                            flag = true;
                        }
                        if (flag2 || flag)
                        {
                            if (!battleActor2.IsTurnFlag(BattleActor.TurnFlagBitType.UpdateTurnBegin))
                            {
                                if (this.CameraManager.CurrentCameraType != BattleCameraManager.CameraType.Action || flag)
                                {
                                    if (this.m_boss)
                                    {
                                        this.CameraManager.SetInterpolation(0.5f, CameraSequence.BlendType.Curve, true);
                                        this.CameraManager.InitTargetSelect(this.m_boss, this.m_playerActor, battleActor2);
                                        this.CameraManager.ChangeCamera(BattleCameraManager.CameraType.TargetSelect);
                                    }
                                    else
                                    {
                                        string name = ExtensionElementIdDefinition.GetName(ExtensionElementIdDefinition.Index.BODY_CENTER);
                                        Vector3 position = battleActor2.chara.GetElementIdTransform(name).position;
                                        Camera component = Mevius.Renderer.CameraManager.GetInstance().GetViewCameraGameObject().GetComponent<Camera>();
                                        Vector3 vector = component.WorldToViewportPoint(position);
                                        if (vector.x < 0f || vector.x > 1f || vector.y < 0f || vector.y > 1f || vector.z <= 0f)
                                        {
                                            this.CameraManager.SetInterpolation(1f, CameraSequence.BlendType.Curve, true);
                                            this.CameraManager.InitTwoShot(battleActor2, this.m_playerActor, 0, false);
                                            this.CameraManager.ChangeCamera(BattleCameraManager.CameraType.TwoShot);
                                        }
                                    }
                                }
                                battleActor2.SetTurnFlag(BattleActor.TurnFlagBitType.UpdateTurnBegin);
                            }
                            break;
                        }
                    }
                }
            }
            if (!flag)
            {
                if (flag2)
                {
                    if (this.m_playerActor != null)
                    {
                        this.m_playerActor.UpdateActionGuiActive(false);
                    }
                    this._step = BattleManager.BattleStep.EnemyTurn;
                }
                else
                {
                    bool flag3 = true;
                    bool flag4 = false;
                    for (int k = 0; k < this.m_actionPriorityEnemyActorList.Count; k++)
                    {
                        if (this.m_actorList[k].IsActive() && !this.m_actorList[k].IsNeedNotKill())
                        {
                            flag3 = false;
                            break;
                        }
                        if (this.m_actorList[k].IsRewardWait())
                        {
                            flag4 = true;
                        }
                    }
                    if (flag3)
                    {
                        if (!flag4)
                        {
                            this.SetBattleWin(0f);
                        }
                    }
                    else
                    {
                        if (Mevius.App.Api.IsPartyMode())
                        {
                            this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                            this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.CurrentPlayer;
                        }
                        else
                        {
                            this._step = BattleManager.BattleStep.FairyTurnStart;
                        }
                        this.OnEnemyTurnEnd();
                    }
                }
            }
        }

        private void UpdateEnemyTurn()
        {
            this.UpdateCamera();
            this.UpdateTime();
            BattleActor battleActor = null;
            bool flag = true;
            bool flag2 = true;
            for (int i = 0; i < this.m_actionPriorityEnemyActorList.Count; i++)
            {
                BattleActor battleActor2 = this.m_actionPriorityEnemyActorList[i];
                if (battleActor2.IsActive())
                {
                    if (battleActor2.IsPlayer())
                    {
                        if (!battleActor2.IsActionEnd() && !battleActor2.IsPlayerInputAccept())
                        {
                            battleActor = battleActor2;
                            flag = false;
                            break;
                        }
                    }
                    else if (battleActor2.State != BattleActor.StateType.Idle && !battleActor2.IsActionEnd())
                    {
                        battleActor = battleActor2;
                        flag = false;
                        break;
                    }
                    if (battleActor2.ActionNum > 0 || !battleActor2.IsReadyAction())
                    {
                        flag2 = false;
                    }
                }
                else if (battleActor2.IsDeadWait())
                {
                    flag = false;
                }
            }
            bool flag3 = battleActor != null && battleActor.IsFlagBit(BattleActor.FlagBitType.AbilityInputWait);
            if (this.CameraManager.IsActionEnd() && !flag3)
            {
                if (battleActor != null && this.m_cameraManager.CurrentCameraType != BattleCameraManager.CameraType.TargetSelect)
                {
                    float interpSec;
                    CameraSequence.BlendType blendType;
                    if (!this.m_cameraManager.GetActionNextInterpInfo(out interpSec, out blendType))
                    {
                        interpSec = 0.5f;
                        blendType = CameraSequence.BlendType.Curve;
                    }
                    this.m_cameraManager.SetInterpolation(interpSec, blendType, true);
                    this.m_cameraManager.InitTargetSelect(this.m_boss, this.m_playerActor, battleActor);
                    this.m_cameraManager.ChangeCamera(BattleCameraManager.CameraType.TargetSelect);
                }
                else
                {
                    this.ChangeTargetSelectCamera(false);
                }
            }
            if (flag && !this.m_damageSourceManager.IsExist())
            {
                bool flag4 = false;
                if (this.m_playerActor.Hp <= 0 && !Mevius.App.Api.IsPartyMode())
                {
                    if (this.m_playerActor.IsDeadIdle())
                    {
                        if (this.m_playerActor.IsSummon())
                        {
                            this.ProcChangeJob(false, false);
                            this._step = BattleManager.BattleStep.PlayerTurnStart;
                        }
                        else if (Mevius.Db.Api.IsTutorial() || Mevius.App.Api.IsTrialMode())
                        {
                            this.RevivePlayer();
                            this._step = BattleManager.BattleStep.PlayerTurnStart;
                        }
                        else
                        {
                            this._step = BattleManager.BattleStep.ContinueCheck;
                        }
                        this.OnEnemyTurnEnd();
                    }
                    flag4 = true;
                }
                if (Mevius.App.Api.IsPartyMode())
                {
                    flag4 = true;
                    bool flag5 = true;
                    for (int j = 0; j < this.m_multiBattleActorList.Count; j++)
                    {
                        if (this.m_multiBattleActorList[j].Hp > 0)
                        {
                            flag4 = false;
                            break;
                        }
                        if (!this.m_multiBattleActorList[j].IsDeadIdle())
                        {
                            flag5 = false;
                            break;
                        }
                    }
                    if (flag4 && flag5)
                    {
                        this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                        this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.CurrentPlayer;
                        this.OnEnemyTurnEnd();
                    }
                }
                if (!flag4)
                {
                    if (!flag2)
                    {
                        for (int k = 0; k < this.m_actionPriorityEnemyActorList.Count; k++)
                        {
                            BattleActor battleActor3 = this.m_actionPriorityEnemyActorList[k];
                            if (battleActor3.IsActive())
                            {
                                if (!battleActor3.IsReadyAction())
                                {
                                    battleActor3.ReadyAction();
                                }
                                if (battleActor3.ActionNum > 0)
                                {
                                    bool flag6 = false;
                                    bool flag7 = false;
                                    if (battleActor3.UpdateReadyAction())
                                    {
                                        if (battleActor3.IsPlayer())
                                        {
                                            if (!battleActor3.AutoAbilityAttack())
                                            {
                                                battleActor3.NormalAttack(Vector3.forward, true, false);
                                            }
                                            flag6 = true;
                                        }
                                        else if (battleActor3.OnAiBehavior())
                                        {
                                            flag6 = true;
                                        }
                                    }
                                    else
                                    {
                                        flag7 = true;
                                    }
                                    if (flag7 || flag6)
                                    {
                                        if (!battleActor3.IsTurnFlag(BattleActor.TurnFlagBitType.UpdateTurnBegin))
                                        {
                                            this.SetEnemyCamera(battleActor3);
                                            battleActor3.SetTurnFlag(BattleActor.TurnFlagBitType.UpdateTurnBegin);
                                        }
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    else
                    {
                        bool flag8 = true;
                        bool flag9 = false;
                        for (int l = 0; l < this.m_actionPriorityEnemyActorList.Count; l++)
                        {
                            BattleActor battleActor4 = this.m_actionPriorityEnemyActorList[l];
                            if (battleActor4.IsActive() && !battleActor4.IsNeedNotKill())
                            {
                                flag8 = false;
                                break;
                            }
                            if (battleActor4.IsRewardWait())
                            {
                                flag9 = true;
                            }
                        }
                        if (flag8)
                        {
                            if (!flag9)
                            {
                                this.SetBattleWin(0f);
                            }
                        }
                        else
                        {
                            if (Mevius.App.Api.IsPartyMode())
                            {
                                this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                                this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.CurrentPlayer;
                            }
                            else
                            {
                                this._step = BattleManager.BattleStep.FairyTurnStart;
                            }
                            this.OnEnemyTurnEnd();
                        }
                    }
                }
                this.m_autoAttackTimer = 0f;
            }
            this.UpdateTest();
        }

        private void UpdateCTBStart()
        {
            this.m_activeActionOrderTime = 0f;
            GuiBattleMenu.Instance.TimeLine.ClearIcons(false);
            this.UpdateCamera();
            this.UpdateTime();
            if (this.m_turnNum == 0)
            {
                this.m_turnNum = 1;
                for (int i = 0; i < this.m_actorList.Count; i++)
                {
                    BattleActor battleActor = this.m_actorList[i];
                    if (battleActor != null && battleActor.IsActive())
                    {
                        battleActor.OnTurnBegin();
                    }
                }
            }
            else
            {
                for (int j = 0; j < this.m_actorList.Count; j++)
                {
                    BattleActor battleActor2 = this.m_actorList[j];
                    if (battleActor2 != null && battleActor2.IsActive())
                    {
                        battleActor2.ReadyAction();
                        battleActor2.OnTurnBegin();
                    }
                }
            }
            this.Step = BattleManager.BattleStep.CTB;
            this.CreateActionOrderList();
            this.NextActionOrderActor();
            this.UpdateTest();
        }

        private void UpdateCTB()
        {
            if (this.m_activeActionOrderActor.IsPlayer())
            {
                this.UpdatePlayerTurn();
            }
            else
            {
                this.UpdateCamera();
                this.UpdateTime();
            }
            if (!this.m_damageSourceManager.IsExist())
            {
                if (this.m_playerActor.Hp <= 0)
                {
                    if (this.m_playerActor.IsDeadIdle())
                    {
                        this.m_playerActor.OnTurnEnd();
                        this.m_playerActor.OnEnemyTurnEnd();
                        if (this.m_playerActorSub != null)
                        {
                            this.m_playerActorSub.OnTurnEnd();
                            this.m_playerActorSub.OnEnemyTurnEnd();
                        }
                        this._step = BattleManager.BattleStep.ContinueCheck;
                        BattleManager._i.ChangeActionValue(BattleManager.ChangeActionValueType.ProgressTurn, true);
                        this.m_turnNum++;
                        BattleUtility.SetOverMissionCount(MissionCountType.TurnMax, this.m_turnNum);
                        BattleUtility.AddMissionCount(MissionCountType.TurnTotal, 1);
                        this.SaveData();
                    }
                    return;
                }
                if (this.m_activeActionOrderActor.IsTimeLineActionEnd())
                {
                    this.m_activeActionOrderActor.OnCTBActionEnd();
                    if (this.m_activeActionOrderActor.IsEnemy())
                    {
                        bool flag = true;
                        bool flag2 = false;
                        for (int i = 0; i < this._entryBattleCharaSpecList.Count; i++)
                        {
                            string enemyActorName = BattleManager.GetEnemyActorName(i);
                            BattleActor battleActor = this.FindActor(enemyActorName);
                            if (battleActor != null)
                            {
                                if (battleActor.IsActive() && !battleActor.IsNeedNotKill())
                                {
                                    flag = false;
                                    break;
                                }
                                if (battleActor.IsRewardWait())
                                {
                                    flag2 = true;
                                }
                            }
                        }
                        if (flag && !flag2)
                        {
                            this.SetBattleWin(0f);
                            return;
                        }
                    }
                    bool flag3;
                    this.UpdateZone(out flag3);
                    if (this.m_activeActionOrderActor.IsActionAbilitySkill5402())
                    {
                        GuiBattleMenu.Instance.TimeLine.SyncIcons(this.m_actionOrderList);
                        this.m_activeActionOrderActor.OnTimeLineActionStart();
                    }
                    else if (this.m_actionOrderList.Count <= 0)
                    {
                        if (this.m_activeActionOrderActor.IsTurnEnd() || !this.m_activeActionOrderActor.IsActive())
                        {
                            this.m_activeActionOrderActor = null;
                            GuiBattleMenu.Instance.ShowTimeLineEnd();
                            this.m_playerActor.OnTurnEnd();
                            this.m_playerActor.OnEnemyTurnEnd();
                            if (this.m_playerActorSub != null)
                            {
                                this.m_playerActorSub.OnTurnEnd();
                                this.m_playerActorSub.OnEnemyTurnEnd();
                            }
                            BattleManager._i.ChangeActionValue(BattleManager.ChangeActionValueType.ProgressTurn, true);
                            this.Step = BattleManager.BattleStep.FairyTurnStart;
                            this.m_turnNum++;
                            BattleUtility.SetOverMissionCount(MissionCountType.TurnMax, this.m_turnNum);
                            BattleUtility.AddMissionCount(MissionCountType.TurnTotal, 1);
                            this.SaveData();
                        }
                    }
                    else
                    {
                        BattleActor battleActor2 = this.m_actionOrderList[0].Actor;
                        if (battleActor2.IsEnemy() && battleActor2.IsBreak())
                        {
                            battleActor2 = this.m_playerActor;
                        }
                        if (this.m_activeActionOrderActor == battleActor2 || this.m_activeActionOrderActor.IsEnemy() || this.m_activeActionOrderActor.IsTurnEnd())
                        {
                            this.NextActionOrderActor();
                        }
                    }
                }
            }
            if (this.m_actionOrderListCreateFlag)
            {
                this.m_actionOrderListCreateFlag = false;
                this.CreateActionOrderList();
            }
            this.UpdateTest();
        }

        public bool NextActionOrderActor()
        {
            if (this.IsCountTimeBattle() && 1 <= this.m_actionOrderList.Count)
            {
                GuiBattleMenu.Instance.TimeLine.SyncIcons(this.m_actionOrderList);
                BattleActor activeActionOrderActor = this.m_activeActionOrderActor;
                this.m_activeActionOrderActor = null;
                this.m_stealActionOrderActor = null;
                this.m_activeActionOrderActor = this.m_actionOrderList[0].Actor;
                if (this.m_activeActionOrderActor.IsEnemy())
                {
                    if (this.m_activeActionOrderActor.IsBreak())
                    {
                        this.m_stealActionOrderActor = this.m_activeActionOrderActor;
                        this.m_stealActionOrderActor.OnStolen();
                        this.m_activeActionOrderActor = this.m_playerActor;
                        this.m_activeActionOrderActor.OnSteal();
                        Mevius.Gui.Api.SetBattlePlayerActionName("$se001_ac001");
                        Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Gui, Mevius.Sound.Api.GetSoundResourceName("Resident"), "system_se_steal", 1f, 0, 0, false, -1, 1f);
                        BattleManager._i.ChangeActionValue(BattleManager.ChangeActionValueType.Steal, true);
                        BattleUtility.AddMissionCount(MissionCountType.StealCount, 1);
                        GuiBattleMenu.Instance.TimeLine.SetIconSteal(0);
                    }
                    else
                    {
                        this.SaveData();
                    }
                }
                this.m_activeActionOrderTime = this.m_actionOrderList[0].Time;
                this.m_actionOrderList.RemoveAt(0);
                if (activeActionOrderActor != this.m_activeActionOrderActor)
                {
                    if (this.m_activeActionOrderActor.IsPlayer())
                    {
                        if (GuiBattleMenu.Instance != null)
                        {
                            GuiBattleMenu.Instance.EnableMenuButton = true;
                        }
                        this.HideBattleEnemyActionName();
                        Mevius.Gui.Api.SetBattleTargetButtonEnable(true);
                    }
                    else
                    {
                        Mevius.Gui.Api.SetBattleTargetButtonEnable(false);
                    }
                }
                if (this.m_activeActionOrderActor.IsPlayer())
                {
                    if (this.m_targetActor == null || !this.m_targetActor.IsActive())
                    {
                        this.UpdateSelectedTarget();
                        this.ChangeTargetSelectCamera(false);
                    }
                    else if (this.m_activeActionOrderActor != activeActionOrderActor)
                    {
                        this.ChangeTargetSelectCamera(true);
                    }
                }
                else
                {
                    if (this.m_playerActor.State == BattleActor.StateType.Encount || this.m_playerActor.State == BattleActor.StateType.Idle)
                    {
                        this.m_playerActor.StartGuard();
                    }
                    if (activeActionOrderActor != null && activeActionOrderActor.IsPlayer())
                    {
                        this.ChangeTargetSelectCamera(true);
                    }
                    this.SetEnemyCamera(this.m_activeActionOrderActor);
                }
                this.m_activeActionOrderActor.OnTimeLineActionStart();
                return true;
            }
            return false;
        }

        public bool IsActionOrderActorTurnEnd()
        {
            if (this.IsSubStrike())
            {
                return false;
            }
            if (this.m_activeActionOrderActor != null)
            {
                if (this.m_activeActionOrderActor.IsEnemy())
                {
                    return true;
                }
                if (this.m_activeActionOrderActor.IsTimeLineActionStart())
                {
                    if (this.m_actionOrderList.Count <= 0)
                    {
                        return true;
                    }
                    if (this.m_activeActionOrderActor != this.m_actionOrderList[0].Actor && !this.m_actionOrderList[0].Actor.IsBreak())
                    {
                        return true;
                    }
                }
            }
            return false;
        }

        private void UpdateTest()
        {
            if (BattleTest._i != null && BattleTest._i.IsExitBattle())
            {
                this._step = BattleManager.BattleStep.Escape;
            }
        }

        public static HashSet<string> GetLoadCharaSpecList(string battleSceneName)
        {
            C098a168d3605b12448638cab8ccafe9d.C6a63ba3da59f35f0fee059da0f7321db c6a63ba3da59f35f0fee059da0f7321db = C098a168d3605b12448638cab8ccafe9d.Find(battleSceneName);
            if (c6a63ba3da59f35f0fee059da0f7321db != null)
            {
                string[] entryBtChSpecIds = new string[]
                {
                    c6a63ba3da59f35f0fee059da0f7321db.m2fd5b5d0d06c450dff7142d5979733e5(),
                    c6a63ba3da59f35f0fee059da0f7321db.m93a11a07c0e821939010621e4b4e30c8(),
                    c6a63ba3da59f35f0fee059da0f7321db.mbd2c58964e9a96e4216d06b8c21528e6(),
                    c6a63ba3da59f35f0fee059da0f7321db.m10d3240ae62c144d7c74f19bd3b619d5(),
                    c6a63ba3da59f35f0fee059da0f7321db.mdf64d7a7df53a5fef981025bf50c4d37(),
                    c6a63ba3da59f35f0fee059da0f7321db.m604f6040ea47dc38767da31f04751a7e(),
                    c6a63ba3da59f35f0fee059da0f7321db.mc734b5fc868261a5590ba6b7600c8143(),
                    c6a63ba3da59f35f0fee059da0f7321db.m538ad959898836ca9ca7cbe67965ee5b()
                };
                return BattleManager.GetLoadCharaSpecList(entryBtChSpecIds);
            }
            return new HashSet<string>();
        }

        public static HashSet<string> GetLoadCharaSpecList(string[] entryBtChSpecIds)
        {
            HashSet<string> hashSet = new HashSet<string>();
            foreach (string text in entryBtChSpecIds)
            {
                if (text.Length > 0)
                {
                    C4d4f3a800432e94568175cb31ad3c78d.C51747b7e0e19ad065084a2c5a6d8421b c51747b7e0e19ad065084a2c5a6d8421b = C4d4f3a800432e94568175cb31ad3c78d.Find(text);
                    if (c51747b7e0e19ad065084a2c5a6d8421b != null)
                    {
                        hashSet.Add(c51747b7e0e19ad065084a2c5a6d8421b.mc17ab063bf174d4fbb31c91f28a5f111());
                    }
                }
            }
            return hashSet;
        }

        private void _UpdateResource()
        {
            switch (this._resourceStep)
            {
            case BattleManager.ResourceStep.Init:
                Mevius.App.Api.SetActiveBattleActors(false);
                this._entryBattleCharaSpecList = new List<string>();
                this._actorNameList = new HashSet<string>();
                this._resourceStep = BattleManager.ResourceStep.LoadCharaSpec;
                break;
            case BattleManager.ResourceStep.LoadCharaSpec:
            {
                C098a168d3605b12448638cab8ccafe9d.C6a63ba3da59f35f0fee059da0f7321db c6a63ba3da59f35f0fee059da0f7321db = C098a168d3605b12448638cab8ccafe9d.Find(this.currentBattleScene);
                if (c6a63ba3da59f35f0fee059da0f7321db != null)
                {
                    string[] array = new string[]
                    {
                        c6a63ba3da59f35f0fee059da0f7321db.m2fd5b5d0d06c450dff7142d5979733e5(),
                        c6a63ba3da59f35f0fee059da0f7321db.m93a11a07c0e821939010621e4b4e30c8(),
                        c6a63ba3da59f35f0fee059da0f7321db.mbd2c58964e9a96e4216d06b8c21528e6(),
                        c6a63ba3da59f35f0fee059da0f7321db.m10d3240ae62c144d7c74f19bd3b619d5(),
                        c6a63ba3da59f35f0fee059da0f7321db.mdf64d7a7df53a5fef981025bf50c4d37(),
                        c6a63ba3da59f35f0fee059da0f7321db.m604f6040ea47dc38767da31f04751a7e(),
                        c6a63ba3da59f35f0fee059da0f7321db.mc734b5fc868261a5590ba6b7600c8143(),
                        c6a63ba3da59f35f0fee059da0f7321db.m538ad959898836ca9ca7cbe67965ee5b()
                    };
                    foreach (string text in array)
                    {
                        if (text.Length > 0)
                        {
                            this._entryBattleCharaSpecList.Add(text);
                        }
                    }
                    this._loadCharaSpecList = BattleManager.GetLoadCharaSpecList(array);
                    foreach (string name in this._loadCharaSpecList)
                    {
                        this.taskid = Mevius.Loader.Api.LoadCharaSpec(name);
                    }
                    this.m_placementPlayerDistanceStart = c6a63ba3da59f35f0fee059da0f7321db.m6420242b0837c42c1ad096b6b0ef0c9e();
                    this.m_placementPlayerDistanceEnd = c6a63ba3da59f35f0fee059da0f7321db.mb640213ed697bd8d174206d6e6162ddc();
                    this.m_placementEnemyId = c6a63ba3da59f35f0fee059da0f7321db.m80b0f7453b78bb411bfb6f96aff92d47();
                    if (BattleUtility.IsFF8Gimmick())
                    {
                        HashSet<string> hashSet = new HashSet<string>();
                        DbManager.BattleData battleData = Mevius.Db.Api.GetBattleData();
                        for (int j = 0; j < battleData.ff8AbilityUniqueIndexes.Length; j++)
                        {
                            this.m_ff8LoadAbilityIDs[j] = null;
                            if (battleData.ff8AbilityUniqueIndexes[j] != 0)
                            {
                                foreach (C4c26d468b97150ce002ae9a639f4ea2a.C1dc494102b702de4447e82ad4b8a1927 c1dc494102b702de4447e82ad4b8a in C4c26d468b97150ce002ae9a639f4ea2a.GetRecords())
                                {
                                    if (battleData.ff8AbilityUniqueIndexes[j] == c1dc494102b702de4447e82ad4b8a.mdabe095dc2209349fd26902efb69aa55())
                                    {
                                        this.m_ff8LoadAbilityIDs[j] = c1dc494102b702de4447e82ad4b8a.m3200e7d469baddbd48fb57787ece7fde();
                                        hashSet.Add(this.m_ff8LoadAbilityIDs[j]);
                                        break;
                                    }
                                }
                            }
                        }
                        HashSet<string> hashSet2 = new HashSet<string>();
                        foreach (string text2 in array)
                        {
                            C4d4f3a800432e94568175cb31ad3c78d.C51747b7e0e19ad065084a2c5a6d8421b c51747b7e0e19ad065084a2c5a6d8421b = C4d4f3a800432e94568175cb31ad3c78d.Find(text2);
                            if (c51747b7e0e19ad065084a2c5a6d8421b != null)
                            {
                                hashSet2.Add(text2);
                                int num = c51747b7e0e19ad065084a2c5a6d8421b.countm316681f2ec1aeb23e488797acbe9558f();
                                for (int l = 0; l < num; l++)
                                {
                                    string text3 = c51747b7e0e19ad065084a2c5a6d8421b.m2ea7d7fba19e1799d48d4ef2bd7d9dd0(l);
                                    if (string.IsNullOrEmpty(text3))
                                    {
                                        break;
                                    }
                                    hashSet2.Add(text3);
                                }
                            }
                        }
                        foreach (string id in hashSet2)
                        {
                            Cdbb9c6c5a1bc4309d61b9b14da7d84d2.C6482043a9b7c9dbdb5036d00c5bc1d8b c6482043a9b7c9dbdb5036d00c5bc1d8b = Cdbb9c6c5a1bc4309d61b9b14da7d84d2.Find(id);
                            if (c6482043a9b7c9dbdb5036d00c5bc1d8b != null)
                            {
                                C4c26d468b97150ce002ae9a639f4ea2a.C1dc494102b702de4447e82ad4b8a1927 c1dc494102b702de4447e82ad4b8a2 = C4c26d468b97150ce002ae9a639f4ea2a.Find(c6482043a9b7c9dbdb5036d00c5bc1d8b.m336099ebbdf163fa2188c0ac0728b7aa());
                                if (c1dc494102b702de4447e82ad4b8a2 != null)
                                {
                                    hashSet.Add(c1dc494102b702de4447e82ad4b8a2.m3200e7d469baddbd48fb57787ece7fde());
                                }
                            }
                        }
                        foreach (string abilityId in hashSet)
                        {
                            Mevius.Loader.Api.LoadAbility(abilityId);
                        }
                    }
                    if (Mevius.App.Api.IsPartyMode())
                    {
                        Mevius.Party.Api.RefreshResource();
                    }
                    this._resourceStep = BattleManager.ResourceStep.LoadCharaSpecWait;
                }
                else
                {
                    this._resourceStep = BattleManager.ResourceStep.End;
                }
                break;
            }
            case BattleManager.ResourceStep.LoadCharaSpecWait:
                if (!Mevius.App.Api.IsExistTaskId(this.taskid))
                {
                    if (Mevius.App.Api.IsPartyMode())
                    {
                        if (!Mevius.Db.Api.IsPartyStatusNone(DbPartyManager.DbPartyTypes.DbPartyTypes_NONE))
                        {
                            break;
                        }
                        if (!Mevius.Db.Api.IsPartyStatusNone(DbPartyManager.DbPartyTypes.DbPartyTypes_NONE))
                        {
                            break;
                        }
                        Mevius.Gui.Api.EndLoadingIcon();
                    }
                    this._resourceStep = BattleManager.ResourceStep.CreateActor;
                }
                break;
            case BattleManager.ResourceStep.CreateActor:
                this._resourceStep = BattleManager.ResourceStep.CreateActorWait;
                break;
            case BattleManager.ResourceStep.CreateActorWait:
                this._resourceStep = BattleManager.ResourceStep.EndRequestWait;
                break;
            case BattleManager.ResourceStep.RemoveActor:
                if (BattleUtility.IsFF8Gimmick())
                {
                    HashSet<string> hashSet3 = new HashSet<string>();
                    for (int m = 0; m < this.m_ff8LoadAbilityIDs.Length; m++)
                    {
                        if (!string.IsNullOrEmpty(this.m_ff8LoadAbilityIDs[m]))
                        {
                            hashSet3.Add(this.m_ff8LoadAbilityIDs[m]);
                        }
                    }
                    HashSet<string> hashSet4 = new HashSet<string>();
                    foreach (string text4 in this._entryBattleCharaSpecList)
                    {
                        C4d4f3a800432e94568175cb31ad3c78d.C51747b7e0e19ad065084a2c5a6d8421b c51747b7e0e19ad065084a2c5a6d8421b2 = C4d4f3a800432e94568175cb31ad3c78d.Find(text4);
                        if (c51747b7e0e19ad065084a2c5a6d8421b2 != null)
                        {
                            hashSet4.Add(text4);
                            int num2 = c51747b7e0e19ad065084a2c5a6d8421b2.countm316681f2ec1aeb23e488797acbe9558f();
                            for (int n = 0; n < num2; n++)
                            {
                                string text5 = c51747b7e0e19ad065084a2c5a6d8421b2.m2ea7d7fba19e1799d48d4ef2bd7d9dd0(n);
                                if (string.IsNullOrEmpty(text5))
                                {
                                    break;
                                }
                                hashSet4.Add(text5);
                            }
                        }
                    }
                    foreach (string id2 in hashSet4)
                    {
                        Cdbb9c6c5a1bc4309d61b9b14da7d84d2.C6482043a9b7c9dbdb5036d00c5bc1d8b c6482043a9b7c9dbdb5036d00c5bc1d8b2 = Cdbb9c6c5a1bc4309d61b9b14da7d84d2.Find(id2);
                        if (c6482043a9b7c9dbdb5036d00c5bc1d8b2 != null)
                        {
                            C4c26d468b97150ce002ae9a639f4ea2a.C1dc494102b702de4447e82ad4b8a1927 c1dc494102b702de4447e82ad4b8a3 = C4c26d468b97150ce002ae9a639f4ea2a.Find(c6482043a9b7c9dbdb5036d00c5bc1d8b2.m336099ebbdf163fa2188c0ac0728b7aa());
                            if (c1dc494102b702de4447e82ad4b8a3 != null)
                            {
                                hashSet3.Add(c1dc494102b702de4447e82ad4b8a3.m3200e7d469baddbd48fb57787ece7fde());
                            }
                        }
                    }
                    foreach (string abilityId2 in hashSet3)
                    {
                        Mevius.Loader.Api.UnLoadAbility(abilityId2);
                    }
                }
                for (int num3 = 0; num3 < this._entryBattleCharaSpecList.Count; num3++)
                {
                    string enemyActorName = BattleManager.GetEnemyActorName(num3);
                    Mevius.App.Api.RemoveCharaInstanceCommand(enemyActorName, new GameInstanceManager.RemoveInstanceArg
                    {
                        callback = new GameInstanceManager.CreateInstanceCallBack(AppManager._i.appActorManager.delegateRemoveActor),
                        callbacktag = null
                    });
                }
                Mevius.Db.Api.RemoveSubPartyResource(DbPartyManager.DbPartyTypes.DbPartyTypes_BATTLE);
                Mevius.Db.Api.RemovePartyResource(DbPartyManager.DbPartyTypes.DbPartyTypes_BATTLE);
                if (Mevius.App.Api.IsPartyMode())
                {
                    foreach (Mevius.Party.Api.PARTY_MEMBER_TYPE party_MEMBER_TYPE in Mevius.Party.Api.GetPartyType())
                    {
                        if (party_MEMBER_TYPE != Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_ME && party_MEMBER_TYPE != Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_EMPTY)
                        {
                            Mevius.Db.Api.RemovePartyResource(party_MEMBER_TYPE, DbPartyManager.DbPartyTypes.DbPartyTypes_BATTLE);
                        }
                    }
                }
                this._resourceStep = BattleManager.ResourceStep.RemoveActorWait;
                break;
            case BattleManager.ResourceStep.RemoveActorWait:
            {
                bool flag = true;
                for (int num5 = 0; num5 < this._entryBattleCharaSpecList.Count; num5++)
                {
                    string enemyActorName2 = BattleManager.GetEnemyActorName(num5);
                    if (Mevius.App.Api.FindChrGameObject(enemyActorName2))
                    {
                        flag = false;
                    }
                }
                if (!Mevius.Db.Api.IsPartyStatusNone(DbPartyManager.DbPartyTypes.DbPartyTypes_NONE))
                {
                    flag = false;
                }
                if (Mevius.App.Api.IsPartyMode() && (!Mevius.Db.Api.IsPartyStatusNone(Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_NPC1) || !Mevius.Db.Api.IsPartyStatusNone(Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_NPC2) || !Mevius.Db.Api.IsPartyStatusNone(Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_NPC3)))
                {
                    flag = false;
                }
                if (flag)
                {
                    this._resourceStep = BattleManager.ResourceStep.UnloadCharaSpec;
                }
                break;
            }
            case BattleManager.ResourceStep.UnloadCharaSpec:
                if (this._loadCharaSpecList != null)
                {
                    foreach (string name2 in this._loadCharaSpecList)
                    {
                        this.charaspecUnloadTaskId = Mevius.Loader.Api.UnLoadCharaSpec(name2);
                    }
                }
                if (Mevius.App.Api.IsPartyMode())
                {
                }
                this._resourceStep = BattleManager.ResourceStep.UnloadCharaSpecWait;
                break;
            case BattleManager.ResourceStep.UnloadCharaSpecWait:
                if (!Mevius.App.Api.IsExistTaskId(this.charaspecUnloadTaskId))
                {
                    this._resourceStep = BattleManager.ResourceStep.End;
                }
                break;
            case BattleManager.ResourceStep.End:
                this._entryBattleCharaSpecList = null;
                this._loadCharaSpecList = null;
                this._actorNameList = null;
                Mevius.App.Api.RemoveTaskId(this.resourceUnloadTaskId);
                this.resourceUnloadTaskId = 0u;
                this._resourceStep = BattleManager.ResourceStep.None;
                break;
            }
        }

        public void RequestEscape()
        {
            if (BattleUtility.IsDQGimmick())
            {
                Ce9a57996ed2aff549552eb8b4069e830.Ce67b34e0f86dcbb14f8a71b2a412a8e1 ce67b34e0f86dcbb14f8a71b2a412a8e = Ce9a57996ed2aff549552eb8b4069e830.Find(Mevius.Db.Api.GetRegionName());
                if (ce67b34e0f86dcbb14f8a71b2a412a8e != null)
                {
                    string soundResourceName = Mevius.Sound.Api.GetSoundResourceName(ce67b34e0f86dcbb14f8a71b2a412a8e.m08f3332c454ec6ddc95dc8807d6e9d2e());
                    Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Gui, soundResourceName, "46_Joutyu_SE_[036]escape", 1f, 0, 0, Vector3.zero, null, false, -1, 0, 1f);
                }
            }
            if (Mevius.App.Api.IsPartyMode())
            {
                Mevius.Party.Api.SetExitBattle();
            }
            else
            {
                this._step = BattleManager.BattleStep.Escape;
            }
        }

        public void UpdateEscapeCheck()
        {
            int num = Mevius.Gui.Util.CheckMessageBox(ref this.m_MsgHandle, "$msg_title_017", "$btl_msg_01", GuiMessageBox.Buttons.FromText, GuiMessageBox.Skin.Default, true, GuiMessageBox.DefaultFromTextButtonSE, Mevius.Gui.Constants.SoundEffectKind.system_se_window_in, false);
            if (num == -1)
            {
                return;
            }
            int num2 = num;
            if (num2 != 0)
            {
                if (num2 == 1)
                {
                    this._step = BattleManager.BattleStep.PlayerTurn;
                }
            }
            else if (Mevius.App.Api.IsPartyMode())
            {
                Mevius.Party.Api.SetExitBattle();
                this._step = BattleManager.BattleStep.PlayerTurn;
            }
            else
            {
                this._step = BattleManager.BattleStep.Escape;
            }
        }

        public void EndBattle()
        {
            Mevius.Gui.Api.RemoveBattleTouchAreaEvent(new GuiBattleMenu.TouchAreaEventHandler(this.TouchAreaEvent));
            this.ClearCurrentTarget();
            this.m_battleSlow.End();
            DbManager.BattleData battleData = Mevius.Db.Api.GetBattleData();
            if (!Mevius.App.Api.IsPartyMode())
            {
                for (int i = 0; i < battleData.manaElements.Length; i++)
                {
                    battleData.manaElements[i] = -1;
                }
                BattleActor battleActor = this.m_playerActor;
                if (this.IsCountTimeBattle() && battleActor.IsSubActionSub())
                {
                    battleActor = this.m_playerActorSub;
                }
                if (battleActor != null)
                {
                    battleActor.OnBattleEnd();
                    Array.Clear(battleData.statusEffectIds, 0, battleData.statusEffectIds.Length);
                    Array.Clear(battleData.statusEffectTurns, 0, battleData.statusEffectTurns.Length);
                    Array.Clear(battleData.statusEffectStates, 0, battleData.statusEffectStates.Length);
                    Array.Clear(battleData.statusEffectParams, 0, battleData.statusEffectParams.Length);
                    Array.Clear(battleData.statusEffectIds2, 0, battleData.statusEffectIds2.Length);
                    Array.Clear(battleData.statusEffectTurns2, 0, battleData.statusEffectTurns2.Length);
                    Array.Clear(battleData.statusEffectStates2, 0, battleData.statusEffectStates2.Length);
                    Array.Clear(battleData.statusEffectParams2, 0, battleData.statusEffectParams2.Length);
                    int[,] statusEffectEntries = battleActor.GetStatusEffectEntries();
                    int length = statusEffectEntries.GetLength(0);
                    int num = Math.Min(length, 16);
                    for (int j = 0; j < num; j++)
                    {
                        battleData.statusEffectIds[j] = statusEffectEntries[j, 0];
                        battleData.statusEffectTurns[j] = (sbyte)statusEffectEntries[j, 1];
                        battleData.statusEffectStates[j] = (byte)statusEffectEntries[j, 2];
                        battleData.statusEffectParams[j] = statusEffectEntries[j, 3];
                    }
                    if (16 < length)
                    {
                        num = length - 16;
                        for (int k = 0; k < num; k++)
                        {
                            int num2 = 16 + k;
                            battleData.statusEffectIds2[k] = statusEffectEntries[num2, 0];
                            battleData.statusEffectTurns2[k] = (sbyte)statusEffectEntries[num2, 1];
                            battleData.statusEffectStates2[k] = (byte)statusEffectEntries[num2, 2];
                            battleData.statusEffectParams2[k] = statusEffectEntries[num2, 3];
                        }
                    }
                    battleActor.ElementalGauge.GetOriginalValues().CopyTo(battleData.elementalGauge, 0);
                    battleActor.ManaElements.CopyTo(battleData.manaElements, 0);
                    battleData.abilityUseSuportCount = battleActor.AbilityUseSuportCount;
                }
                BattleActor battleActor2 = this.FindActor(BattleManager.GetBattlePlayerName());
                if (battleActor2 != null)
                {
                    Mevius.Db.Api.SetParameter(DbManager.ParameterType.Current_Hp, battleActor2.Hp);
                    Mevius.Db.Api.SetParameter(DbManager.ParameterType.Current_Ability_Point, battleActor2.ManaUseNum);
                    BattleActor.CardAbilityInfo[] cardAbilityInfos = battleActor2.CardAbilityInfos;
                    for (int l = 0; l < cardAbilityInfos.Length; l++)
                    {
                        battleData.cardAbilityChargeTurns[l] = (sbyte)cardAbilityInfos[l].chargeTurn;
                        battleData.cardAbilityUseCounts[l] = (ushort)cardAbilityInfos[l].useCount;
                        battleData.cardAbilityTurnUseCounts[l] = 0;
                    }
                    for (int m = 0; m < battleActor2.DQAbilityChargeTurns.Length; m++)
                    {
                        battleData.playerDqAbilityChargeTurns[0, m] = battleActor2.DQAbilityChargeTurns[m];
                    }
                    for (int n = 0; n < battleActor2.RevengeDamages.Length; n++)
                    {
                        battleData.playerRevengeDamages[0, n] = battleActor2.RevengeDamages[n];
                    }
                }
                BattleActor battleActor3 = this.FindActor(BattleManager.GetBattlePlayerSubName());
                if (battleActor3 != null)
                {
                    Mevius.Db.Api.SetParameter(DbManager.ParameterType.Current_Hp_Sub, battleActor3.Hp);
                    Mevius.Db.Api.SetParameter(DbManager.ParameterType.Current_Ability_Point_Sub, battleActor3.ManaUseNum);
                    BattleActor.CardAbilityInfo[] cardAbilityInfos = battleActor3.CardAbilityInfos;
                    for (int num3 = 0; num3 < cardAbilityInfos.Length; num3++)
                    {
                        battleData.subCardAbilityChargeTurns[num3] = (sbyte)cardAbilityInfos[num3].chargeTurn;
                        battleData.subCardAbilityUseCounts[num3] = (ushort)cardAbilityInfos[num3].useCount;
                        battleData.subCardAbilityTurnUseCounts[num3] = 0;
                    }
                    for (int num4 = 0; num4 < battleActor3.DQAbilityChargeTurns.Length; num4++)
                    {
                        battleData.playerDqAbilityChargeTurns[1, num4] = battleActor3.DQAbilityChargeTurns[num4];
                    }
                    for (int num5 = 0; num5 < battleActor3.RevengeDamages.Length; num5++)
                    {
                        battleData.playerRevengeDamages[1, num5] = battleActor3.RevengeDamages[num5];
                    }
                }
                if (battleActor2 != null && battleActor3 != null)
                {
                    if (Mevius.Db.Api.GetParameter(DbManager.ParameterType.Current_Job) != 0)
                    {
                        float num6 = (float)battleActor3.ManaUseNum / (float)battleActor3.JobAbilityUseManaUseNum;
                        battleActor2.ManaUseNum = (int)((float)battleActor2.JobAbilityUseManaUseNum * num6 + 0.5f);
                        Mevius.Db.Api.SetParameter(DbManager.ParameterType.Current_Ability_Point, battleActor2.ManaUseNum);
                    }
                    else
                    {
                        float num7 = (float)battleActor2.ManaUseNum / (float)battleActor2.JobAbilityUseManaUseNum;
                        battleActor3.ManaUseNum = (int)((float)battleActor3.JobAbilityUseManaUseNum * num7 + 0.5f);
                        Mevius.Db.Api.SetParameter(DbManager.ParameterType.Current_Ability_Point_Sub, battleActor3.ManaUseNum);
                    }
                }
                battleData.playerJobChangeChargeTurn = this.m_playerJobChangeChargeTurn;
                battleData.actionGauge = (ushort)this.m_actionGauge;
                battleData.actionGaugeDecrease = (ushort)this.m_actionGaugeDecrease;
                battleData.actionPower = this.m_actionPower;
                Array.Clear(battleData.manaAttributeUseNum, 0, battleData.manaAttributeUseNum.Length);
                this.m_ff7AbilityUseCounts.CopyTo(battleData.ff7AbilityUseCounts, 0);
                if (BattleUtility.IsFF8Gimmick())
                {
                    for (int num8 = 0; num8 < this.FF8DrawAbility.Length; num8++)
                    {
                        battleData.ff8AbilityUniqueIndexes[num8] = this.FF8DrawAbility[num8].id;
                        battleData.ff8AbilityCounts[num8] = (byte)this.FF8DrawAbility[num8].remainingCount;
                    }
                }
            }
            else
            {
                DbManager.MultiBattleData multiBattleData = Mevius.Db.Api.GetMultiBattleData();
                if (multiBattleData != null)
                {
                    multiBattleData.enemyEscapeActionIndex.CopyTo(battleData.enemyEscapeActionIndex, 0);
                    multiBattleData.enemyEscapeActionIndex.CopyTo(PartyManager._i.current_data.battle_data.enemyEscapeActionIndex, 0);
                    for (int num9 = 0; num9 < multiBattleData.enemyEscapeCharaFlags.GetLength(0); num9++)
                    {
                        for (int num10 = 0; num10 < multiBattleData.enemyEscapeCharaFlags.GetLength(1); num10++)
                        {
                            battleData.enemyEscapeCharaFlags[num9, num10] = multiBattleData.enemyEscapeCharaFlags[num9, num10];
                            PartyManager._i.current_data.battle_data.enemyEscapeCharaFlags[num9, num10] = multiBattleData.enemyEscapeCharaFlags[num9, num10];
                        }
                    }
                    for (int num11 = 0; num11 < this.m_multiBattleActorList.Count; num11++)
                    {
                        if (this.m_multiBattleActorList[num11].PartyMemberType == Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_ME)
                        {
                            int partySlot = this.m_multiBattleActorList[num11].PartySlot;
                            multiBattleData.abilityUseSuportCounts[partySlot] = this.m_multiBattleActorList[num11].AbilityUseSuportCount;
                            for (int num12 = 0; num12 < battleData.cardAbilityUseCounts.Length; num12++)
                            {
                                battleData.cardAbilityUseCounts[num12] = multiBattleData.cardAbilityUseCounts[partySlot, num12];
                                battleData.cardAbilityTurnUseCounts[num12] = 0;
                                PartyManager._i.current_data.battle_data.cardAbilityUseCounts[partySlot, num12] = multiBattleData.cardAbilityUseCounts[partySlot, num12];
                            }
                            break;
                        }
                    }
                }
            }
            BattleUtility.SetOverMissionCount(MissionCountType.TurnMax, this.m_turnNum);
            this.m_missionCounts.CopyTo(battleData.missionCount, 0);
            this.m_bossMissionCounts.CopyTo(battleData.bossMissionCount, 0);
            this.m_saveLongValues.CopyTo(battleData.saveLongValues, 0);
            this.m_bossSaveLongValues.CopyTo(battleData.bossSaveLongValues, 0);
            this.m_actionPriorityEnemyActorList.Clear();
            this.m_partyMemberTurn = false;
            this.m_selfActor = null;
            this.m_multiBattleActorList.Clear();
            this.m_multiBattleCurrentOrder = 0;
            this.m_multiBattleTurnLimitTime = 0UL;
            this.m_multiBattleTurnStartTime = 0UL;
            if (this.m_multiBattleActorCursorHandle != null)
            {
                Mevius.Effect.Api.SetEffectLoopOff(this.m_multiBattleActorCursorHandle);
            }
            this.m_randCount = 0;
            this.m_damageRandCount = 0;
            this.m_movementRandCount = 0;
            Mevius.App.Api.SetTimeScale(1f);
            this.m_damageSourceManager.Clear();
            this.m_manaObjectManager.Clear();
            UnityEngine.Object.Destroy(this.m_rootObject);
            Physics.IgnoreLayerCollision(LayerMask.NameToLayer("Phy Bg"), LayerMask.NameToLayer("Phy Character"), false);
            this.m_isMultiFinishCamera = false;
            if (BgmManager._i.BgmEffectOn)
            {
                BgmManager._i.SetBgmEffect(false, 1000);
            }
            Mevius.Sound.Api.StopSound(this.m_zoneSoundHandle, 1000);
            this.m_zoneSoundHandle = 0;
            this.m_dqSameNameDictionary = null;
        }

        public BattleManager.BattleStep Step
        {
            set
            {
                this._step = value;
            }
        }

        private void SetRandomSeed(bool init = false)
        {
            uint num;
            if (Mevius.App.Api.IsPartyMode() && init)
            {
                num = Mevius.Party.Api.GetInitSeed();
            }
            else
            {
                num = (uint)DateTime.Now.Ticks + (uint)Environment.TickCount;
            }
            this.m_rand.SetSeed(num);
            this.m_playerDamageRand.SetSeed(num);
            this.m_playerMovementRand.SetSeed(num);
            if (Mevius.App.Api.IsPartyMode())
            {
                DbManager.MultiBattleData multiBattleData = Mevius.Db.Api.GetMultiBattleData();
                multiBattleData.randSeed = num;
            }
            else
            {
                DbManager.BattleData battleData = Mevius.Db.Api.GetBattleData();
                battleData.randSeed = num;
            }
        }

        public void ResetPlayerDamageRandomSeed()
        {
            if (!Mevius.App.Api.IsPartyMode())
            {
                DbManager.BattleData battleData = Mevius.Db.Api.GetBattleData();
                this.m_playerDamageRand.SetSeed(battleData.randSeed);
                this.m_damageRandCount = 0;
            }
        }

        public void SaveData()
        {
            if (Mevius.Db.Api.IsTutorial() || this._step >= BattleManager.BattleStep.ResultReady)
            {
                return;
            }
            if (!Mevius.App.Api.IsPartyMode())
            {
                this.SaveSingleData();
            }
        }

        private void SaveSingleData()
        {
            Mevius.Db.Api.SetHasBattleData(true);
            DbManager.BattleData battleData = Mevius.Db.Api.GetBattleData();
            this.SetRandomSeed(false);
            battleData.version = BattleManager.SaveDataVersion;
            battleData.step = (int)this._step;
            battleData.turnNum = this.m_turnNum;
            battleData.chainNum = this.m_chainNum;
            battleData.breakNum = this.m_breakNum;
            battleData.deadNum = this.m_deadNum;
            battleData.playerHp = this.m_playerActor.Hp;
            if (this.m_playerActorSub != null)
            {
                battleData.playerSubHp = this.m_playerActorSub.Hp;
            }
            battleData.playerActionNum = (byte)this.m_playerActor.ActionNum;
            battleData.playerActionType = (byte)this.m_playerActor.PlayerActionType;
            battleData.playerNormalAttackNum = (byte)this.m_playerActor.NormalAttackNum;
            battleData.playerAreaState = (byte)this.m_playerActor.AreaState;
            battleData.playerPosX = this.m_playerActor.chara.transform.position.x;
            battleData.playerPosZ = this.m_playerActor.chara.transform.position.z;
            battleData.playerRot = this.m_playerActor.chara.transform.localEulerAngles.y;
            if (this.m_playerActor.PrevUseCardAbilityAttribute != ElementAttributeType.None)
            {
                battleData.prevUseCardAbilityAttributeBit = (ushort)(1 << (int)this.m_playerActor.PrevUseCardAbilityAttribute);
            }
            else
            {
                battleData.prevUseCardAbilityAttributeBit = 0;
            }
            if (this.m_playerActor.TargetActor != null)
            {
                battleData.playerTargetIndex = (sbyte)this.m_playerActor.TargetActor.EnemyIndex;
                this.m_playerActor.PinchAutoAbilityFlags.CopyTo(battleData.autoAbilityPinchFlags, 0);
            }
            else
            {
                battleData.playerTargetIndex = -1;
            }
            Array.Clear(battleData.statusEffectIds, 0, battleData.statusEffectIds.Length);
            Array.Clear(battleData.statusEffectTurns, 0, battleData.statusEffectTurns.Length);
            Array.Clear(battleData.statusEffectStates, 0, battleData.statusEffectStates.Length);
            Array.Clear(battleData.statusEffectParams, 0, battleData.statusEffectParams.Length);
            Array.Clear(battleData.statusEffectIds2, 0, battleData.statusEffectIds2.Length);
            Array.Clear(battleData.statusEffectTurns2, 0, battleData.statusEffectTurns2.Length);
            Array.Clear(battleData.statusEffectStates2, 0, battleData.statusEffectStates2.Length);
            Array.Clear(battleData.statusEffectParams2, 0, battleData.statusEffectParams2.Length);
            int[,] statusEffectEntries = this.m_playerActor.GetStatusEffectEntries();
            int length = statusEffectEntries.GetLength(0);
            int num = Math.Min(length, 16);
            for (int i = 0; i < num; i++)
            {
                battleData.statusEffectIds[i] = statusEffectEntries[i, 0];
                battleData.statusEffectTurns[i] = (sbyte)statusEffectEntries[i, 1];
                battleData.statusEffectStates[i] = (byte)statusEffectEntries[i, 2];
                battleData.statusEffectParams[i] = statusEffectEntries[i, 3];
            }
            if (16 < length)
            {
                num = length - 16;
                for (int j = 0; j < num; j++)
                {
                    int num2 = 16 + j;
                    battleData.statusEffectIds2[j] = statusEffectEntries[num2, 0];
                    battleData.statusEffectTurns2[j] = (sbyte)statusEffectEntries[num2, 1];
                    battleData.statusEffectStates2[j] = (byte)statusEffectEntries[num2, 2];
                    battleData.statusEffectParams2[j] = statusEffectEntries[num2, 3];
                }
            }
            this.m_playerActor.ElementalGauge.GetOriginalValues().CopyTo(battleData.elementalGauge, 0);
            BattleActor battleActor = this.FindActor(BattleManager.GetBattlePlayerName());
            Array.Clear(battleData.cardAbilityChargeTurns, 0, battleData.cardAbilityChargeTurns.Length);
            Array.Clear(battleData.cardAbilityUseCounts, 0, battleData.cardAbilityUseCounts.Length);
            if (battleActor != null)
            {
                BattleActor.CardAbilityInfo[] cardAbilityInfos = battleActor.CardAbilityInfos;
                for (int k = 0; k < cardAbilityInfos.Length; k++)
                {
                    battleData.cardAbilityChargeTurns[k] = (sbyte)cardAbilityInfos[k].chargeTurn;
                    battleData.cardAbilityUseCounts[k] = (ushort)cardAbilityInfos[k].useCount;
                    battleData.cardAbilityTurnUseCounts[k] = cardAbilityInfos[k].turnUseCount;
                }
                Mevius.Db.Api.SetParameter(DbManager.ParameterType.Current_Ability_Point, battleActor.ManaUseNum);
                for (int l = 0; l < 3; l++)
                {
                    battleData.playerDqAbilityChargeTurns[0, l] = battleActor.DQAbilityChargeTurns[l];
                }
                int num3 = 0;
                while (num3 < battleActor.ActionTimeList.Count && num3 < 32)
                {
                    battleData.playerActionTime[num3] = battleActor.ActionTimeList[num3];
                    num3++;
                }
                for (int m = 0; m < 3; m++)
                {
                    battleData.playerRevengeDamages[0, m] = battleActor.RevengeDamages[m];
                }
                battleData.playerSuccessiveActionNum = battleActor.SuccessiveActionNum;
            }
            Array.Clear(battleData.enemyStatusEffectIds, 0, battleData.enemyStatusEffectIds.Length);
            Array.Clear(battleData.enemyStatusEffectTurns, 0, battleData.enemyStatusEffectTurns.Length);
            Array.Clear(battleData.enemyStatusEffectStates, 0, battleData.enemyStatusEffectStates.Length);
            Array.Clear(battleData.enemyStatusEffectParams, 0, battleData.enemyStatusEffectParams.Length);
            for (int n = 0; n < this._entryBattleCharaSpecList.Count; n++)
            {
                string enemyActorName = BattleManager.GetEnemyActorName(n);
                BattleActor battleActor2 = this.FindActor(enemyActorName);
                if (battleActor2 != null)
                {
                    battleData.enemyYRots[n] = battleActor2.chara.transform.localEulerAngles.y;
                    battleData.enemyHps[n] = battleActor2.Hp;
                    battleData.enemyBps[n] = battleActor2.Bp;
                    battleData.enemyBpArmorDamages[n] = battleActor2.BpArmorDamage;
                    battleData.enemyBreakCounts[n] = (byte)battleActor2.BreakCount;
                    if (battleActor2.Ai != null)
                    {
                        for (int num4 = 0; num4 < 8; num4++)
                        {
                            battleData.enemyAiCounters[n, num4] = battleActor2.Ai.Counters[num4];
                        }
                        for (int num5 = 0; num5 < 8; num5++)
                        {
                            battleData.enemyAiCounters2[n, num5] = battleActor2.Ai.Counters[8 + num5];
                        }
                        battleData.enemyAiFlags[n] = battleActor2.Ai.Flag;
                        battleData.enemyAiSpCounters[n] = battleActor2.Ai.SpCounter;
                        battleData.enemyAiTakeDamageBit[n] = battleActor2.Ai.TakeDamageBit;
                        battleData.enemyAiTakeDamageAttributeBit[n] = battleActor2.Ai.TakeDamageAttributeBit;
                    }
                    battleData.enemyAttributeBit[n] = battleActor2.ElementAttributeBit;
                    battleData.enemyUnknownAttribute[n] = battleActor2.UnknownAttribute;
                    battleData.enemyAbsorbAttributeBit[n] = battleActor2.AbsorbAttributeBit;
                    battleData.enemyChangeBtCharaSpecId[n] = battleActor2.ChangeBtCharaSpecId;
                    int[,] statusEffectEntries2 = battleActor2.GetStatusEffectEntries();
                    int length2 = statusEffectEntries2.GetLength(0);
                    int num6 = Math.Min(length2, 16);
                    for (int num7 = 0; num7 < num6; num7++)
                    {
                        battleData.enemyStatusEffectIds[n, num7] = statusEffectEntries2[num7, 0];
                        battleData.enemyStatusEffectTurns[n, num7] = (sbyte)statusEffectEntries2[num7, 1];
                        battleData.enemyStatusEffectStates[n, num7] = (byte)statusEffectEntries2[num7, 2];
                        battleData.enemyStatusEffectParams[n, num7] = statusEffectEntries2[num7, 3];
                    }
                    if (16 < length2)
                    {
                        num6 = length2 - 16;
                        for (int num8 = 0; num8 < num6; num8++)
                        {
                            int num9 = 16 + num8;
                            battleData.enemyStatusEffectIds2[n, num8] = statusEffectEntries2[num9, 0];
                            battleData.enemyStatusEffectTurns2[n, num8] = (sbyte)statusEffectEntries2[num9, 1];
                            battleData.enemyStatusEffectStates2[n, num8] = (byte)statusEffectEntries2[num9, 2];
                            battleData.enemyStatusEffectParams2[n, num8] = statusEffectEntries2[num9, 3];
                        }
                    }
                    byte[] debuffInvalidCounts = battleActor2.DebuffInvalidCounts;
                    for (int num10 = 0; num10 < debuffInvalidCounts.Length; num10++)
                    {
                        battleData.enemyDebuffInvalidCounts[n, num10] = debuffInvalidCounts[num10];
                    }
                    battleData.enemyVisibleGroupNodeBits[n] = battleActor2.VisibleGroupNodeBits;
                    battleData.enemySaveFlagBits[n] = (uint)battleActor2.SaveFlagBits;
                    battleData.enemyHpLimitIndexs[n] = battleActor2.HpLimitIndex;
                    battleData.enemySameNameIndexes[n] = battleActor2.SameCharaIndex;
                    battleData.enemyHpLimitMotionIndexes[n] = battleActor2.HpLimitMotionIndex;
                    battleData.enemyDamagedActorIndexBits[n] = battleActor2.EnemyDamagedActorIndexBit;
                    battleData.enemyHpGaugeFixRates[n] = battleActor2.EnemyHpGaugeFixRate;
                    battleData.enemyActionNum[n] = (byte)battleActor2.ActionNum;
                    int count = battleActor2.ActionTimeList.Count;
                    if (0 < count)
                    {
                        battleData.enemyActionTimeStart[n] = battleActor2.ActionTimeList[0];
                        if (1 < count)
                        {
                            battleData.enemyActionTimeInterval[n] = battleActor2.ActionTimeInterval;
                        }
                    }
                    battleData.enemyActionNumMax[n] = (byte)battleActor2.ActionNumMax;
                    battleData.ff8EnemyDraweds[n] = ((!battleActor2.FF8EnemyDrawed) ? 0 : 1);
                }
            }
            for (int num11 = 0; num11 < battleData.manaElements.Length; num11++)
            {
                battleData.manaElements[num11] = -1;
            }
            this.m_playerActor.ManaElements.CopyTo(battleData.manaElements, 0);
            battleData.playerNormalAttackCombo = this.m_playerActor.NormalAttackCombo;
            battleData.abilityUseSuportCount = this.m_playerActor.AbilityUseSuportCount;
            this.m_enemyAiCommonCounters.CopyTo(battleData.enemyAiCommonCounters, 0);
            battleData.playerJobChangeChargeTurn = this.m_playerJobChangeChargeTurn;
            battleData.playerJobChangeThroughTurn = this.m_playerJobChangeThroughTurn;
            BattleActor battleActor3 = this.FindActor(BattleManager.GetBattlePlayerSubName());
            if (battleActor3 != null)
            {
                BattleActor.CardAbilityInfo[] cardAbilityInfos2 = battleActor3.CardAbilityInfos;
                for (int num12 = 0; num12 < cardAbilityInfos2.Length; num12++)
                {
                    battleData.subCardAbilityChargeTurns[num12] = (sbyte)cardAbilityInfos2[num12].chargeTurn;
                    battleData.subCardAbilityUseCounts[num12] = (ushort)cardAbilityInfos2[num12].useCount;
                    battleData.subCardAbilityTurnUseCounts[num12] = cardAbilityInfos2[num12].turnUseCount;
                }
                Mevius.Db.Api.SetParameter(DbManager.ParameterType.Current_Ability_Point_Sub, battleActor3.ManaUseNum);
                for (int num13 = 0; num13 < 3; num13++)
                {
                    battleData.playerDqAbilityChargeTurns[1, num13] = battleActor3.DQAbilityChargeTurns[num13];
                }
                for (int num14 = 0; num14 < 3; num14++)
                {
                    battleData.playerRevengeDamages[1, num14] = battleActor3.RevengeDamages[num14];
                }
            }
            battleData.fairyHour = this.m_fairyHour;
            battleData.optimaType = (sbyte)this.m_optimaType;
            this.m_optimaUseCounts.CopyTo(battleData.optimaUseCounts, 0);
            this.m_missionCounts.CopyTo(battleData.missionCount, 0);
            this.m_bossMissionCounts.CopyTo(battleData.bossMissionCount, 0);
            this.m_saveLongValues.CopyTo(battleData.saveLongValues, 0);
            this.m_bossSaveLongValues.CopyTo(battleData.bossSaveLongValues, 0);
            this.m_ff7AbilityUseCounts.CopyTo(battleData.ff7AbilityUseCounts, 0);
            battleData.actionGauge = (ushort)this.m_actionGauge;
            battleData.actionGaugeDecrease = (ushort)this.m_actionGaugeDecrease;
            battleData.actionPower = this.m_actionPower;
            battleData.isZone = ((!this.m_zone) ? 0 : 1);
            if (this.m_stealActionOrderActor != null)
            {
                battleData.ctbStealIndex = (sbyte)this.m_stealActionOrderActor.EnemyIndex;
            }
            else
            {
                battleData.ctbStealIndex = -1;
            }
            battleData.enemyActionEndFlag = this.m_enemyActionEndFlag;
            if (BattleUtility.IsFF8Gimmick())
            {
                for (int num15 = 0; num15 < this.FF8DrawAbility.Length; num15++)
                {
                    battleData.ff8AbilityUniqueIndexes[num15] = this.FF8DrawAbility[num15].id;
                    battleData.ff8AbilityCounts[num15] = (byte)this.FF8DrawAbility[num15].remainingCount;
                }
            }
            battleData.playerAbilityCombo = this.m_playerActor.AbilityCombo;
            this.m_playerActor.ManaAttributeUseNum.CopyTo(battleData.manaAttributeUseNum, 0);
            Mevius.App.Api.AddAsyncCommand(new AsyncCommandManager.AsyncCommandCallBack(DbManager.execClientSaveData), false);
        }

        public void LoadData()
        {
            DbManager.BattleData battleData = Mevius.Db.Api.GetBattleData();
            if (battleData.version == 0)
            {
                if (battleData.step == 40)
                {
                    battleData.step = 14;
                }
                else if (battleData.step >= 13)
                {
                    battleData.step += 2;
                }
                else if (battleData.step >= 12)
                {
                    battleData.step++;
                }
                battleData.version = 1;
            }
            if (battleData.version == 1)
            {
                if (battleData.step >= 6)
                {
                    battleData.step++;
                }
                battleData.version = 2;
            }
            if (battleData.version == 2)
            {
                if (battleData.step >= 34)
                {
                    battleData.step += 3;
                }
                else if (battleData.step >= 21)
                {
                    battleData.step += 2;
                }
                battleData.version = 3;
            }
            this._step = (BattleManager.BattleStep)battleData.step;
            this.m_rand.SetSeed(battleData.randSeed);
            this.m_playerDamageRand.SetSeed(battleData.randSeed);
            this.m_playerMovementRand.SetSeed(battleData.randSeed);
            this.m_turnNum = battleData.turnNum;
            this.m_chainNum = battleData.chainNum;
            this.m_breakNum = battleData.breakNum;
            this.m_deadNum = battleData.deadNum;
            this.m_playerJobChangeChargeTurn = battleData.playerJobChangeChargeTurn;
            this.m_playerJobChangeThroughTurn = battleData.playerJobChangeThroughTurn;
            this.m_fairyHour = battleData.fairyHour;
            if (Mevius.Db.Api.GetParameter(DbManager.ParameterType.Current_Job) != 0)
            {
                this.ProcChangeJob(true, false);
            }
            this.m_playerActor.SetPinchAutoAbilityFlags(battleData.autoAbilityPinchFlags);
            this.m_playerActor.SetHp(battleData.playerHp, false, false);
            if (this.m_playerActorSub != null)
            {
                this.m_playerActorSub.SetHp(battleData.playerSubHp, false, false);
            }
            this.m_playerActor.ActionNum = (int)battleData.playerActionNum;
            this.m_playerActor.NormalAttackNum = (int)battleData.playerNormalAttackNum;
            this.m_playerActor.AreaState = (BattleActor.AreaStateType)battleData.playerAreaState;
            Mevius.Gui.Api.SetBattlePlayerAttackCount((int)battleData.playerActionNum, GuiBattlePlayerTurnEffect.None);
            this.m_playerActor.PlayerActionType = (PlayerActionType)battleData.playerActionType;
            if ((int)battleData.prevUseCardAbilityIndex != -1)
            {
                battleData.prevUseCardAbilityAttributeBit = (ushort)(1 << this.m_playerActor.CardAbilityInfos[(int)battleData.prevUseCardAbilityIndex].displayCosts[0]);
                battleData.prevUseCardAbilityIndex = -1;
            }
            for (int i = 0; i < 7; i++)
            {
                if (((int)battleData.prevUseCardAbilityAttributeBit & 1 << i) != 0)
                {
                    this.m_playerActor.PrevUseCardAbilityAttribute = (ElementAttributeType)i;
                    break;
                }
            }
            string enemyActorName = BattleManager.GetEnemyActorName((int)battleData.playerTargetIndex);
            BattleActor targetActor = this.FindActor(enemyActorName);
            this.m_targetActor = targetActor;
            this.m_playerActor.TargetActor = targetActor;
            bool flag = false;
            Vector3 vector = new Vector3(battleData.playerPosX, 0f, battleData.playerPosZ);
            if (this.ChaosBattle)
            {
                float num = (!(this.m_playerActor.chara.GetCharacterControllerComponent() != null)) ? 2f : this.m_playerActor.chara.GetCharacterControllerComponent().height;
                RaycastHit raycastHit;
                if (!Physics.Raycast(vector + Vector3.up * num * 0.5f, Vector3.down, out raycastHit, num, 1 << LayerMask.NameToLayer("Phy Bg")))
                {
                    flag = true;
                }
            }
            if (!flag)
            {
                this.m_playerActor.chara.transform.position = vector;
                this.m_playerActor.chara.transform.localEulerAngles = new Vector3(0f, battleData.playerRot, 0f);
            }
            this.m_playerActor.NormalAttackCombo = battleData.playerNormalAttackCombo;
            this.m_playerActor.SuccessiveActionNum = battleData.playerSuccessiveActionNum;
            this.m_playerActor.AbilityCombo = battleData.playerAbilityCombo;
            this.m_playerActor.AbilityUseSuportCount = battleData.abilityUseSuportCount;
            battleData.manaAttributeUseNum.CopyTo(this.m_playerActor.ManaAttributeUseNum, 0);
            if (this.IsCountTimeBattle())
            {
                this.m_playerActor.CreateActionTimeList(battleData.playerActionTime);
            }
            int num2 = -1;
            int actionIndex = Mevius.Zone.Api.GetActionIndex();
            for (int j = 0; j < battleData.enemyEscapeActionIndex.Length; j++)
            {
                if (battleData.enemyEscapeActionIndex[j] == actionIndex)
                {
                    num2 = j;
                    break;
                }
            }
            for (int k = 0; k < this._entryBattleCharaSpecList.Count; k++)
            {
                string enemyActorName2 = BattleManager.GetEnemyActorName(k);
                BattleActor battleActor = this.FindActor(enemyActorName2);
                if (battleActor != null)
                {
                    if (!flag)
                    {
                        battleActor.chara.transform.localEulerAngles = new Vector3(0f, battleData.enemyYRots[k], 0f);
                    }
                    battleActor.SetHp(battleData.enemyHps[k], false, false);
                    battleActor.Bp = battleData.enemyBps[k];
                    battleActor.BreakCount = (int)battleData.enemyBreakCounts[k];
                    battleActor.BpArmorDamage = battleData.enemyBpArmorDamages[k];
                    if (battleActor.Ai != null)
                    {
                        for (int l = 0; l < 8; l++)
                        {
                            battleActor.Ai.Counters[l] = battleData.enemyAiCounters[k, l];
                        }
                        for (int m = 0; m < 8; m++)
                        {
                            battleActor.Ai.Counters[8 + m] = battleData.enemyAiCounters2[k, m];
                        }
                        battleActor.Ai.Flag = battleData.enemyAiFlags[k];
                        battleActor.Ai.SpCounter = battleData.enemyAiSpCounters[k];
                        battleActor.Ai.TakeDamageBit = battleData.enemyAiTakeDamageBit[k];
                        battleActor.Ai.TakeDamageAttributeBit = battleData.enemyAiTakeDamageAttributeBit[k];
                    }
                    if (battleData.version <= 2)
                    {
                        if (battleData.enemyAttributeBit[k] != 0)
                        {
                            battleActor.ElementAttributeBit = battleData.enemyAttributeBit[k];
                        }
                        if (battleData.enemyChangeAttributeBit[k] != 0)
                        {
                            battleActor.ElementAttributeBit = battleData.enemyChangeAttributeBit[k];
                        }
                    }
                    else
                    {
                        battleActor.ElementAttributeBit = battleData.enemyAttributeBit[k];
                    }
                    if (battleData.enemyAbsorbAttributeBit[k] != 0)
                    {
                        battleActor.AbsorbAttributeBit = battleData.enemyAbsorbAttributeBit[k];
                    }
                    battleActor.UnknownAttribute = battleData.enemyUnknownAttribute[k];
                    battleActor.SetChangeBtCharaSpecId(battleData.enemyChangeBtCharaSpecId[k], false);
                    List<int[]> list = new List<int[]>();
                    for (int n = 0; n < battleData.enemyStatusEffectIds.GetLength(1); n++)
                    {
                        if (battleData.enemyStatusEffectIds[k, n] != 0)
                        {
                            list.Add(new int[]
                            {
                                battleData.enemyStatusEffectIds[k, n],
                                (int)battleData.enemyStatusEffectTurns[k, n],
                                (int)battleData.enemyStatusEffectStates[k, n],
                                battleData.enemyStatusEffectParams[k, n]
                            });
                        }
                    }
                    for (int num3 = 0; num3 < battleData.enemyStatusEffectIds2.GetLength(1); num3++)
                    {
                        if (battleData.enemyStatusEffectIds2[k, num3] != 0)
                        {
                            list.Add(new int[]
                            {
                                battleData.enemyStatusEffectIds2[k, num3],
                                (int)battleData.enemyStatusEffectTurns2[k, num3],
                                (int)battleData.enemyStatusEffectStates2[k, num3],
                                battleData.enemyStatusEffectParams2[k, num3]
                            });
                        }
                    }
                    battleActor.SetStatusEffectEntries(list.ToArray());
                    for (int num4 = 0; num4 < battleData.enemyDebuffInvalidCounts.GetLength(1); num4++)
                    {
                        battleActor.SetDebuffInvalidCount(num4, battleData.enemyDebuffInvalidCounts[k, num4]);
                    }
                    if (battleActor.IsVisibleGroupNodeBp())
                    {
                        battleActor.VisibleGroupNodeBits = battleData.enemyVisibleGroupNodeBits[k];
                        battleActor.chara.SetVisibleGroupNode(battleActor.VisibleGroupNodeBits);
                    }
                    battleActor.SaveFlagBits = (BattleActor.SaveFlagBitType)battleData.enemySaveFlagBits[k];
                    battleActor.HpLimitIndex = battleData.enemyHpLimitIndexs[k];
                    battleActor.SameCharaIndex = battleData.enemySameNameIndexes[k];
                    battleActor.HpLimitMotionIndex = battleData.enemyHpLimitMotionIndexes[k];
                    battleActor.EnemyDamagedActorIndexBit = battleData.enemyDamagedActorIndexBits[k];
                    battleActor.EnemyHpGaugeFixRate = battleData.enemyHpGaugeFixRates[k];
                    battleActor.ActionNumMax = (int)battleData.enemyActionNumMax[k];
                    if (this.IsCountTimeBattle())
                    {
                        battleActor.CreateActionTimeList((int)battleData.enemyActionNum[k], battleData.enemyActionTimeStart[k], battleData.enemyActionTimeInterval[k]);
                    }
                    battleActor.FF8EnemyDrawed = (battleData.ff8EnemyDraweds[k] != 0);
                    bool escape = false;
                    if (num2 != -1 && battleData.enemyEscapeCharaFlags[num2, k])
                    {
                        escape = true;
                    }
                    battleActor.OnRestore(this._step, escape, true, true);
                }
            }
            battleData.enemyAiCommonCounters.CopyTo(this.m_enemyAiCommonCounters, 0);
            this.m_enemyActionEndFlag = battleData.enemyActionEndFlag;
            this.m_optimaType = (OptimaType)battleData.optimaType;
            battleData.optimaUseCounts.CopyTo(this.m_optimaUseCounts, 0);
            battleData.ff7AbilityUseCounts.CopyTo(this.m_ff7AbilityUseCounts, 0);
            this.LoadFF8Data();
            if (this.IsCountTimeBattle())
            {
                this.m_zone = (battleData.isZone != 0);
                if (this.m_zone)
                {
                    string soundResourceName = Mevius.Sound.Api.GetSoundResourceName("Resident");
                    this.m_zoneSoundHandle = Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Gui, soundResourceName, "system_se_mzone_loop", 1f, 0, 0, false, -1, 1f);
                }
                GuiBattleMenu.Instance.IsZone = this.m_zone;
                this.CreateActionOrderList();
                this.NextActionOrderActor();
                string enemyActorName3 = BattleManager.GetEnemyActorName((int)battleData.ctbStealIndex);
                this.m_stealActionOrderActor = this.FindActor(enemyActorName3);
                if (this.m_stealActionOrderActor != null)
                {
                    GuiBattleMenu.Instance.TimeLine.SetIconSteal(0);
                }
            }
            this.m_cameraManager.InitTargetSelect(this.m_boss, this.m_playerActor, this.m_playerActor.TargetActor);
            this.m_cameraManager.ChangeCamera(BattleCameraManager.CameraType.TargetSelect);
            this.UpdateCameraEntry();
            this.m_playerActor.OnRestore(this._step, false, true, true);
            if (this.m_playerActorSub != null && this.m_playerActorSub.IsSummon())
            {
                this.m_playerActorSub.OnRestoreSummon();
            }
            this.InitSameCharaIndex();
            this.ProcManToMan();
        }

        public void LoadFF8Data()
        {
            if (BattleUtility.IsFF8Gimmick())
            {
                DbManager.BattleData battleData = Mevius.Db.Api.GetBattleData();
                for (int i = 0; i < this.FF8DrawAbility.Length; i++)
                {
                    this.FF8DrawAbility[i].id = battleData.ff8AbilityUniqueIndexes[i];
                    foreach (C4c26d468b97150ce002ae9a639f4ea2a.C1dc494102b702de4447e82ad4b8a1927 c1dc494102b702de4447e82ad4b8a in C4c26d468b97150ce002ae9a639f4ea2a.GetRecords())
                    {
                        if (this.FF8DrawAbility[i].id == c1dc494102b702de4447e82ad4b8a.mdabe095dc2209349fd26902efb69aa55())
                        {
                            this.FF8DrawAbility[i].Datasheet = c1dc494102b702de4447e82ad4b8a;
                            break;
                        }
                    }
                    this.FF8DrawAbility[i].remainingCount = (int)battleData.ff8AbilityCounts[i];
                }
            }
        }

        public void AddActor(BattleActor btActor)
        {
            if (Mevius.App.Api.IsPartyMode())
            {
                int[] partyType = Mevius.Party.Api.GetPartyType();
                int count = this.m_actorList.Count;
                for (int i = 0; i < count; i++)
                {
                    if (btActor.IsPlayer())
                    {
                        if (this.m_actorList[i].IsPlayer() && btActor.PartySlot < this.m_actorList[i].PartySlot)
                        {
                            this.m_actorList.Insert(i, btActor);
                            return;
                        }
                    }
                    else if (this.m_actorList[i].IsPlayer())
                    {
                        this.m_actorList.Insert(i, btActor);
                        return;
                    }
                }
                this.m_actorList.Add(btActor);
            }
            else
            {
                this.m_actorList.Add(btActor);
            }
        }

        public void RemoveActor(BattleActor btActor)
        {
            this.m_actorList.Remove(btActor);
        }

        public BattleActor FindActor(string name)
        {
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                if (this.m_actorList[i].chara.Name == name)
                {
                    return this.m_actorList[i];
                }
            }
            return null;
        }

        public BattleActor FindActor(uint actorIndexBit)
        {
            if ((actorIndexBit & 4278190080u) != 0u)
            {
                for (int i = 0; i < this.m_actorList.Count; i++)
                {
                    if (this.m_actorList[i].IsPlayer())
                    {
                        uint num = 1u << this.m_actorList[i].PartySlot + 24;
                        if ((actorIndexBit & num) != 0u)
                        {
                            return this.m_actorList[i];
                        }
                    }
                }
            }
            else if ((actorIndexBit & 16777215u) != 0u)
            {
                for (int j = 0; j < this.m_actorList.Count; j++)
                {
                    if (this.m_actorList[j].IsEnemy())
                    {
                        uint num2 = 1u << this.m_actorList[j].EnemyIndex;
                        if ((actorIndexBit & num2) != 0u)
                        {
                            return this.m_actorList[j];
                        }
                    }
                }
            }
            return null;
        }

        public BattleActor GetPlayerActor()
        {
            return this.m_playerActor;
        }

        public BattleActor GetPlayerActorSub()
        {
            return this.m_playerActorSub;
        }

        public bool GetPlayerHp(out int hp, out int maxHp)
        {
            hp = 0;
            maxHp = 0;
            if (this.m_playerActor != null)
            {
                hp = this.m_playerActor.Hp;
                maxHp = this.m_playerActor.HpMax;
                return true;
            }
            return false;
        }

        public void UseNormalAttack()
        {
            if (this.m_playerActor != null)
            {
                if (Mevius.App.Api.IsPartyMode())
                {
                    if (this._step == BattleManager.BattleStep.MultiBattleInput && this.m_playerActor.IsPlayerInputAccept())
                    {
                        this.m_playerActor.NormalAttack(Vector3.forward, true, false);
                    }
                }
                else if (this.IsPlayerTurn() && this.m_playerActor.IsPlayerInputAccept())
                {
                    this.m_playerActor.NormalAttack(Vector3.forward, true, false);
                }
            }
        }

        public void UseJobAbility()
        {
            if (this.m_playerActor != null)
            {
                if (Mevius.App.Api.IsPartyMode())
                {
                    if (this._step == BattleManager.BattleStep.MultiBattleInput)
                    {
                        this.m_playerActor.UseJobAbility(true, false);
                    }
                }
                else if (this.IsPlayerTurn())
                {
                    if (this.IsZone())
                    {
                        this.m_playerActor.UseSubAction(true);
                    }
                    else
                    {
                        this.m_playerActor.UseJobAbility(true, false);
                    }
                }
            }
        }

        public void UseCardAbility(int index)
        {
            if (this.m_playerActor != null)
            {
                if (Mevius.App.Api.IsPartyMode())
                {
                    if (this._step == BattleManager.BattleStep.MultiBattleInput)
                    {
                        this.m_playerActor.UseCardAbility(index, true, false);
                    }
                }
                else if (this.IsPlayerTurn())
                {
                    this.m_playerActor.UseCardAbility(index, true, false);
                }
            }
        }

        public void UseDrawAbility(int index)
        {
            if (this.m_playerActor != null && !Mevius.App.Api.IsPartyMode() && this.IsPlayerTurn() && BattleUtility.IsFF8Gimmick())
            {
                if (index == 0)
                {
                    this.m_playerActor.RequestUseFF8Draw();
                }
                else if (index == 1)
                {
                    this.m_playerActor.RequestUseFF8Ability(0);
                }
                else if (index == 2)
                {
                    this.m_playerActor.RequestUseFF8Ability(1);
                }
                else if (index == 3)
                {
                    this.m_playerActor.RequestUseFF8Ability(2);
                }
                else
                {
                    this.m_playerActor.UseCardAbility(index, true, false);
                }
            }
        }

        public void UseRecast(ElementAttributeType elementAttr)
        {
            if (this.m_playerActor != null)
            {
                if (Mevius.App.Api.IsPartyMode())
                {
                    if (this._step == BattleManager.BattleStep.MultiBattleInput)
                    {
                        this.m_playerActor.UseRecast(elementAttr, true, false);
                    }
                }
                else if (this.IsPlayerTurn())
                {
                    this.m_playerActor.UseRecast(elementAttr, true, false);
                }
            }
        }

        public void UseJobChange()
        {
            if (this.m_playerActor != null && this.IsPlayerTurn())
            {
                this.m_playerActor.UseJobChange();
            }
        }

        public bool EnableJobChange()
        {
            return this.IsPlayerTurn() && this.m_playerActor != null && this.m_playerActor.IsPlayerInput() && this.CanJobChange();
        }

        public bool CanJobChange()
        {
            if (this.IsCountTimeBattle())
            {
                return this.m_jobChangeActionGauge <= this.m_actionGauge || this.IsZone();
            }
            return (!this.m_playerActorSub.IsSummon() || !this.m_playerActorSub.IsDead()) && BattleManager._i.PlayerJobChangeChargeTurn == 0;
        }

        public void UseOptimaChange(int optimaType)
        {
            if (this.m_playerActor != null && this.IsPlayerTurn())
            {
                this.m_playerActor.UseOptimaChange(optimaType);
            }
        }

        public BattleCameraManager CameraManager
        {
            get
            {
                return this.m_cameraManager;
            }
        }

        public void CreateDamageSource(string id, BattleActor owner, BattleActor target, Vector3 parentDamageSourcePos, BattleDamageSource parentDamageSource = null, bool bind = false, bool multi = false, bool origin = false)
        {
            if (owner != null)
            {
                owner.SetAbsorbEffectLoopOff();
            }
            this.m_damageSourceManager.CreateDamageSource(id, owner, target, parentDamageSourcePos, parentDamageSource, bind, multi, origin);
        }

        public void CreateMana(BattleActor actor, Vector3 pos, int num = 1, bool hitMove = false, int almightyProb = 0, int multiNum = 0)
        {
            this.CreateMana(actor, pos, ElementAttributeType.None, num, hitMove, almightyProb, multiNum, false);
        }

        public void CreateMana(BattleActor actor, Vector3 pos, ElementAttributeType attribute, int num = 1, bool hitMove = false, int almightyProb = 0, int multiNum = 0, bool checkElementalGaugeStatusEffect = false)
        {
            int num2 = 0;
            if (Mevius.App.Api.IsPartyMode())
            {
                BattleActor selfActor = this.GetSelfActor();
                if (multiNum != 0)
                {
                    for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
                    {
                        bool flag = BattleUtility.IsUseAttribute(this.m_multiBattleActorList[i], attribute, checkElementalGaugeStatusEffect);
                        int almightyProb2 = 0;
                        int num3 = multiNum;
                        if (actor == this.m_multiBattleActorList[i])
                        {
                            almightyProb2 = almightyProb;
                            num3 = num;
                        }
                        for (int j = 0; j < num3; j++)
                        {
                            ElementAttributeType elementAttributeType;
                            if (flag)
                            {
                                elementAttributeType = this.m_multiBattleActorList[i].CreateMana(pos, attribute, hitMove, almightyProb2);
                            }
                            else
                            {
                                elementAttributeType = this.m_multiBattleActorList[i].CreateMana(pos, hitMove, almightyProb2);
                            }
                            if (actor == selfActor && this.m_multiBattleActorList[i] == selfActor && elementAttributeType != ElementAttributeType.None)
                            {
                                num2++;
                                if (elementAttributeType != ElementAttributeType.OriginalMax)
                                {
                                    BattleUtility.AddMissionCount(MissionCountType.CreateManaAttribute0 + (int)elementAttributeType, 1);
                                }
                            }
                        }
                    }
                }
                else
                {
                    BattleActor battleActor = actor;
                    if (battleActor == null)
                    {
                        battleActor = selfActor;
                    }
                    if (battleActor != null)
                    {
                        bool flag2 = BattleUtility.IsUseAttribute(battleActor, attribute, checkElementalGaugeStatusEffect);
                        for (int k = 0; k < num; k++)
                        {
                            ElementAttributeType elementAttributeType2;
                            if (flag2)
                            {
                                elementAttributeType2 = battleActor.CreateMana(pos, attribute, hitMove, almightyProb);
                            }
                            else
                            {
                                elementAttributeType2 = battleActor.CreateMana(pos, hitMove, almightyProb);
                            }
                            if (elementAttributeType2 != ElementAttributeType.None && actor == selfActor)
                            {
                                num2++;
                                if (elementAttributeType2 != ElementAttributeType.OriginalMax)
                                {
                                    BattleUtility.AddMissionCount(MissionCountType.CreateManaAttribute0 + (int)elementAttributeType2, 1);
                                }
                            }
                        }
                    }
                }
            }
            else
            {
                BattleActor battleActor2 = actor;
                if (battleActor2 == null)
                {
                    battleActor2 = this.m_playerActor;
                }
                if (this.IsSubAction() && battleActor2.IsSubActionSub())
                {
                    battleActor2 = this.GetPlayerActorSub();
                }
                bool flag3 = BattleUtility.IsUseAttribute(battleActor2, attribute, checkElementalGaugeStatusEffect);
                for (int l = 0; l < num; l++)
                {
                    ElementAttributeType elementAttributeType3;
                    if (flag3)
                    {
                        elementAttributeType3 = battleActor2.CreateMana(pos, attribute, hitMove, almightyProb);
                    }
                    else
                    {
                        elementAttributeType3 = battleActor2.CreateMana(pos, hitMove, almightyProb);
                    }
                    if (elementAttributeType3 != ElementAttributeType.None && actor == this.m_playerActor)
                    {
                        num2++;
                        if (elementAttributeType3 != ElementAttributeType.OriginalMax)
                        {
                            BattleUtility.AddMissionCount(MissionCountType.CreateManaAttribute0 + (int)elementAttributeType3, 1);
                        }
                    }
                }
            }
            if (num2 != 0)
            {
                BattleUtility.AddMissionCount(MissionCountType.CreateManaTotal, num2);
            }
            this.UpdateManaGui();
        }

        public void CreateMana(BattleActor actor, Vector3 pos, Vector3 targetPos, bool multiAll = false)
        {
            if (Mevius.App.Api.IsPartyMode())
            {
                BattleActor selfActor = this.GetSelfActor();
                if (multiAll)
                {
                    for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
                    {
                        ElementAttributeType elementAttributeType = this.m_multiBattleActorList[i].CreateMana(pos, targetPos);
                        if (actor == selfActor && this.m_multiBattleActorList[i] == selfActor && elementAttributeType != ElementAttributeType.None)
                        {
                            if (elementAttributeType != ElementAttributeType.OriginalMax)
                            {
                                BattleUtility.AddMissionCount(MissionCountType.CreateManaAttribute0 + (int)elementAttributeType, 1);
                            }
                            BattleUtility.AddMissionCount(MissionCountType.CreateManaTotal, 1);
                        }
                    }
                }
                else if (actor != null)
                {
                    ElementAttributeType elementAttributeType2 = actor.CreateMana(pos, targetPos);
                    if (elementAttributeType2 != ElementAttributeType.None && actor == selfActor)
                    {
                        if (elementAttributeType2 != ElementAttributeType.OriginalMax)
                        {
                            BattleUtility.AddMissionCount(MissionCountType.CreateManaAttribute0 + (int)elementAttributeType2, 1);
                        }
                        BattleUtility.AddMissionCount(MissionCountType.CreateManaTotal, 1);
                    }
                }
            }
            else
            {
                BattleActor battleActor = this.m_playerActor;
                if (this.IsSubAction() && battleActor.IsSubActionSub())
                {
                    battleActor = this.GetPlayerActorSub();
                }
                ElementAttributeType elementAttributeType3 = battleActor.CreateMana(pos, targetPos);
                if (elementAttributeType3 != ElementAttributeType.None && actor == battleActor)
                {
                    if (elementAttributeType3 != ElementAttributeType.OriginalMax)
                    {
                        BattleUtility.AddMissionCount(MissionCountType.CreateManaAttribute0 + (int)elementAttributeType3, 1);
                    }
                    BattleUtility.AddMissionCount(MissionCountType.CreateManaTotal, 1);
                }
            }
            this.UpdateManaGui();
        }

        public bool IsDrawingMana()
        {
            return this.m_manaObjectManager.IsDrawing();
        }

        public void ClearMana()
        {
            this.m_manaObjectManager.Clear();
        }

        public void RequestRemoveMana()
        {
            this.m_manaObjectManager.RequestRemove();
        }

        public void AddReservedMana(ElementAttributeType type)
        {
            this.m_playerActor.AddReservedMana(type);
        }

        public void ClearReservedMana()
        {
            this.m_playerActor.ClearReservedMana();
        }

        public void AddTakeDamageTotal(BattleActor owner, BattleActor target, int value)
        {
            if (owner != null && target != null && owner == this.GetSelfActor() && target.IsEnemy())
            {
                BattleUtility.AddMissionCount(MissionCountType.TakeDamageTotal, value);
            }
        }

        public void GiveDamageMissionCount(BattleActor target, BattleActor owner, int value)
        {
            if (value > 0 && owner != null && target != null && target == this.GetSelfActor())
            {
                BattleUtility.AddMissionCount(MissionCountType.GiveDamageTotal, value);
                BattleUtility.SetOverMissionCount(MissionCountType.GiveDamageMax, value);
                if (owner.IsEnemy())
                {
                    BattleUtility.AddMissionCount(MissionCountType.EnemyGiveDamageTotal, value);
                    BattleUtility.SetOverMissionCount(MissionCountType.EnemyGiveDamageMax, value);
                }
            }
        }

        public void AddRecoveryTotal(BattleActor actor, int value)
        {
            if (actor != null && (actor == this.GetSelfActor() || actor == this.m_playerActorSub))
            {
                BattleUtility.AddMissionCount(MissionCountType.RecoveryTotal, value);
            }
        }

        public int ChainNum
        {
            get
            {
                return this.m_chainNum;
            }
            set
            {
                this.m_chainNum = value;
            }
        }

        public int TurnNum
        {
            get
            {
                return this.m_turnNum;
            }
        }

        private Vector3 GetCameraAimPos(bool checkActor = true)
        {
            bool flag = false;
            Vector2 vector = default(Vector2);
            Vector2 vector2 = default(Vector2);
            if (checkActor)
            {
                for (int i = 0; i < this.m_actorList.Count; i++)
                {
                    BattleActor battleActor = this.m_actorList[i];
                    if (battleActor != null && (battleActor.IsPlayer() || (battleActor.IsEnemy() && battleActor.IsActive())))
                    {
                        if (flag)
                        {
                            if (battleActor.chara.transform.position.x < vector.x)
                            {
                                vector.x = battleActor.chara.transform.position.x;
                            }
                            if (vector2.x < battleActor.chara.transform.position.x)
                            {
                                vector2.x = battleActor.chara.transform.position.x;
                            }
                            if (battleActor.chara.transform.position.z < vector.y)
                            {
                                vector.y = battleActor.chara.transform.position.z;
                            }
                            if (vector2.y < battleActor.chara.transform.position.z)
                            {
                                vector2.y = battleActor.chara.transform.position.z;
                            }
                        }
                        else
                        {
                            vector.Set(battleActor.chara.transform.position.x, battleActor.chara.transform.position.z);
                            vector2 = vector;
                            flag = true;
                        }
                    }
                }
            }
            Vector3 zero = Vector3.zero;
            zero.x = (vector.x + vector2.x) / 2f;
            zero.z = (vector.y + vector2.y) / 2f;
            return zero;
        }

        public int EnemyLevel
        {
            get
            {
                return this.m_enemyLevel;
            }
            set
            {
                this.m_enemyLevel = value;
            }
        }

        public BattleActor GetEnemyActor(BattleActor targetActor)
        {
            BattleActor result = null;
            Vector3 normalized = (targetActor.chara.transform.position - this.m_playerActor.chara.transform.position).normalized;
            float num = 180f;
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                BattleActor battleActor = this.m_actorList[i];
                if (battleActor != null && battleActor.IsEnemy() && battleActor.IsActiveTarget())
                {
                    Vector3 normalized2 = (battleActor.chara.transform.position - this.m_playerActor.chara.transform.position).normalized;
                    float num2 = Vector3.Angle(normalized, normalized2);
                    if (num2 < num)
                    {
                        num = num2;
                        result = battleActor;
                    }
                }
            }
            return result;
        }

        public bool IsPlayerActionEnd()
        {
            if (Mevius.App.Api.IsPartyMode())
            {
                return this.m_playerActor.MultiTurnEnd && (this.m_playerActor.State == BattleActor.StateType.Idle || this.m_playerActor.State == BattleActor.StateType.Guard);
            }
            return this.m_playerActor.IsChangeTurn();
        }

        public bool IsPlayerInputEnd()
        {
            return this.m_playerActor.CommandInputEnd;
        }

        public uint GetRandomUnsignedInteger()
        {
            this.m_randCount++;
            return this.m_rand.GetUnsignedInteger();
        }

        public float GetRandomSingleFloat()
        {
            this.m_randCount++;
            return this.m_rand.GetSingleFloat();
        }

        public uint GetPlayerDamageRandomUnsignedInteger()
        {
            this.m_damageRandCount++;
            return this.m_playerDamageRand.GetUnsignedInteger();
        }

        public float GetPlayerDamageRandomSingleFloat()
        {
            this.m_damageRandCount++;
            return this.m_playerDamageRand.GetSingleFloat();
        }

        public uint GetPlayerMovementRandomUnsignedInteger()
        {
            this.m_movementRandCount++;
            return this.m_playerMovementRand.GetUnsignedInteger();
        }

        public float GetPlayerMovementRandomSingleFloat()
        {
            this.m_movementRandCount++;
            return this.m_playerMovementRand.GetSingleFloat();
        }

        public PreciseTime GetPreciseTime()
        {
            return this.m_preciseTime;
        }

        public List<BattleActor> GetActorList()
        {
            return this.m_actorList;
        }

        public void SetPlayerTargetActor(int enemyIndex)
        {
            string enemyActorName = BattleManager.GetEnemyActorName(enemyIndex);
            BattleActor battleActor = this.FindActor(enemyActorName);
            if (battleActor != null)
            {
                this.m_targetActor = battleActor;
                this.m_playerActor.TargetActor = battleActor;
                if (this.m_cameraManager.CurrentCameraType == BattleCameraManager.CameraType.TwoShot || this.m_cameraManager.CurrentCameraType == BattleCameraManager.CameraType.TargetSelect)
                {
                    this.m_cameraManager.SetInterpolation(0.25f, CameraSequence.BlendType.Curve, true);
                    this.m_cameraManager.InitTargetSelect(this.m_boss, this.m_playerActor, this.m_playerActor.TargetActor);
                    this.m_cameraManager.ChangeCamera(BattleCameraManager.CameraType.TargetSelect);
                }
            }
        }

        public void SetTargetActor(BattleActor actor)
        {
            if (this.m_playerActor.TargetActor != actor)
            {
                this.m_playerActor.TargetActor = actor;
                if (this.m_cameraManager.CurrentCameraType == BattleCameraManager.CameraType.TwoShot || this.m_cameraManager.CurrentCameraType == BattleCameraManager.CameraType.TargetSelect)
                {
                    this.m_cameraManager.SetInterpolation(1f, CameraSequence.BlendType.Curve, true);
                }
                this.m_cameraManager.InitTargetSelect(this.m_boss, this.m_playerActor, this.m_playerActor.TargetActor);
                this.m_cameraManager.ChangeCamera(BattleCameraManager.CameraType.TargetSelect);
            }
        }

        public void EnemyTurnTarget()
        {
            if (this.m_boss)
            {
                return;
            }
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                BattleActor battleActor = this.m_actorList[i];
                if (battleActor != null && battleActor.IsEnemy() && battleActor.IsActive())
                {
                    battleActor.OnTurnTarget();
                }
            }
        }

        public void UpdateManaGui()
        {
            BattleActor battleActor = this.GetSelfActor();
            if (this.IsSubAction() && battleActor.IsSubActionSub())
            {
                battleActor = this.GetPlayerActorSub();
            }
            if (battleActor != null)
            {
                battleActor.UpdateManaGui();
            }
        }

        public bool HasGuiActive()
        {
            if (this.m_playerActor == null)
            {
                return false;
            }
            bool flag = this.m_playerActor.IsPlayerInputAccept();
            if (Mevius.App.Api.IsPartyMode())
            {
                flag = (flag && this._step == BattleManager.BattleStep.MultiBattleInput);
            }
            else
            {
                flag = (flag && (this._step == BattleManager.BattleStep.PlayerTurnStart || this.IsPlayerTurn()));
            }
            return flag;
        }

        public void UpdateActionGuiActive()
        {
            if (this.m_playerActor != null)
            {
                if (this.PartyMemberTurn)
                {
                    this.m_playerActor.UpdateActionGuiActive(false);
                }
                else
                {
                    this.m_playerActor.UpdateActionGuiActive(this.HasGuiActive());
                }
            }
        }

        public void UpdateJobAbilityGauge()
        {
            if (this.m_playerActor != null)
            {
                this.m_playerActor.UpdateJobAbilityGauge();
            }
        }

        public BattleDebugParameter DebugParameter
        {
            get
            {
                return null;
            }
        }

        public void GetEnemyCenterPosDist(out Vector3 pos, out float farDistance)
        {
            pos = Vector3.zero;
            int num = 0;
            farDistance = 0f;
            List<BattleActor> actorList = BattleManager._i.GetActorList();
            for (int i = 0; i < actorList.Count; i++)
            {
                BattleActor battleActor = this.m_actorList[i];
                if (battleActor.IsEnemy() && battleActor.IsActiveTarget())
                {
                    pos += battleActor.chara.transform.position;
                    num++;
                }
            }
            if (num != 0)
            {
                pos /= (float)num;
                for (int j = 0; j < actorList.Count; j++)
                {
                    BattleActor battleActor2 = this.m_actorList[j];
                    if (battleActor2.IsEnemy() && battleActor2.IsActiveTarget())
                    {
                        float num2 = Vector3.Distance(pos, battleActor2.chara.transform.position);
                        if (num2 > farDistance)
                        {
                            farDistance = num2;
                        }
                    }
                }
            }
        }

        public void UpdateTargetSelectCameraFocus()
        {
            Mevius.Renderer.CameraManager instance = Mevius.Renderer.CameraManager.GetInstance();
            if (instance != null)
            {
                GameObject viewCameraGameObject = instance.GetViewCameraGameObject();
                if (viewCameraGameObject && viewCameraGameObject.GetComponent<Camera>())
                {
                    Vector3 vector = Vector3.forward;
                    vector.y = 0f;
                    vector = vector.normalized;
                    vector = Quaternion.Euler(0f, this.m_cameraManager.GetTargetSelectHrzAngle(), 0f) * vector;
                    int num = 0;
                    BattleManager.AutoFocusInfo[] array = new BattleManager.AutoFocusInfo[2];
                    for (int i = 0; i < 2; i++)
                    {
                        array[i] = new BattleManager.AutoFocusInfo();
                    }
                    string name = ExtensionElementIdDefinition.GetName(ExtensionElementIdDefinition.Index.BODY_CENTER);
                    for (int j = 0; j < this.m_actorList.Count; j++)
                    {
                        BattleActor battleActor = this.m_actorList[j];
                        if (battleActor.IsEnemy() && battleActor.IsActiveTarget())
                        {
                            Transform elementIdTransform = battleActor.chara.GetElementIdTransform(name);
                            if (elementIdTransform)
                            {
                                Vector3 vector2 = viewCameraGameObject.GetComponent<Camera>().WorldToViewportPoint(elementIdTransform.position);
                                if (0f <= vector2.x && vector2.x <= 1f && 0f <= vector2.y && vector2.y <= 1f && 0f < vector2.z)
                                {
                                    num++;
                                }
                                Vector3 vector3 = elementIdTransform.position - this.m_playerActor.chara.transform.position;
                                vector3.y = 0f;
                                vector3 = vector3.normalized;
                                float num2 = Vector3.Dot(vector, vector3);
                                num2 = Mathf.Clamp(num2, -1f, 1f);
                                float num3 = Mathf.Acos(num2);
                                if (Vector3.Cross(vector, vector3).y < 0f)
                                {
                                    if (num3 < array[0].radian)
                                    {
                                        array[0].actor = battleActor;
                                        array[0].radian = num3;
                                        array[0].dir = vector3;
                                    }
                                }
                                else if (num3 < array[1].radian)
                                {
                                    array[1].actor = battleActor;
                                    array[1].radian = num3;
                                    array[1].dir = vector3;
                                }
                            }
                        }
                    }
                    int num4 = -1;
                    if (array[0].actor != null && array[1].actor == null)
                    {
                        num4 = 0;
                    }
                    else if (array[0].actor == null && array[1].actor != null)
                    {
                        num4 = 1;
                    }
                    else if (array[0].actor != null && array[1].actor != null && num <= 1)
                    {
                        if (array[0].radian < array[1].radian)
                        {
                            num4 = 0;
                        }
                        else
                        {
                            num4 = 1;
                        }
                    }
                    if (num4 != -1)
                    {
                        this.m_playerActor.TargetActor = array[num4].actor;
                        float num5 = array[num4].radian;
                        if (Vector3.Cross(vector, array[num4].dir).y < 0f)
                        {
                            num5 *= -1f;
                        }
                        this.m_cameraManager.SetTargetSelectTargetPos(this.m_playerActor.TargetActor.chara.transform.position, true);
                    }
                }
            }
        }

        public void UpdateSelectedTarget()
        {
            if (this._step >= BattleManager.BattleStep.ResultReady)
            {
                return;
            }
            if (Mevius.App.Api.IsPartyMode())
            {
                for (int i = this.m_actorList.Count - 1; i >= 0; i--)
                {
                    BattleActor battleActor = this.m_actorList[i];
                    if (battleActor.IsEnemy() && battleActor.IsActiveTarget())
                    {
                        this.m_targetActor = battleActor;
                        this.CheckPlayerTargetChange();
                        break;
                    }
                }
            }
            else
            {
                Mevius.Renderer.CameraManager instance = Mevius.Renderer.CameraManager.GetInstance();
                if (instance != null)
                {
                    GameObject viewCameraGameObject = instance.GetViewCameraGameObject();
                    if (viewCameraGameObject && viewCameraGameObject.GetComponent<Camera>())
                    {
                        int num = int.MaxValue;
                        float num2 = float.MaxValue;
                        BattleActor battleActor2 = null;
                        BattleActor battleActor3 = null;
                        string name = ExtensionElementIdDefinition.GetName(ExtensionElementIdDefinition.Index.BODY_CENTER);
                        Vector3 position = this.m_playerActor.chara.GetElementIdTransform(name).position;
                        Vector3 vector = viewCameraGameObject.GetComponent<Camera>().WorldToViewportPoint(position);
                        Vector3 lhs = this.m_playerActor.chara.transform.rotation * Vector3.forward;
                        for (int j = 0; j < this.m_actorList.Count; j++)
                        {
                            BattleActor battleActor4 = this.m_actorList[j];
                            if (battleActor4.IsEnemy() && battleActor4.IsActiveTarget() && !battleActor4.IsNeedNotKill())
                            {
                                if (battleActor4.Hp < num)
                                {
                                    num = battleActor4.Hp;
                                    battleActor2 = battleActor4;
                                    Transform elementIdTransform = battleActor4.chara.GetElementIdTransform(name);
                                    num2 = Vector3.Distance((!elementIdTransform) ? battleActor4.chara.transform.position : elementIdTransform.position, position);
                                }
                                else if (battleActor4.Hp == num)
                                {
                                    Transform elementIdTransform2 = battleActor4.chara.GetElementIdTransform(name);
                                    Vector3 a = (!elementIdTransform2) ? battleActor4.chara.transform.position : elementIdTransform2.position;
                                    Vector3 normalized = (a - position).normalized;
                                    normalized.y = 0f;
                                    float num3 = Vector3.Distance(a, position);
                                    if (num3 < num2)
                                    {
                                        num2 = num3;
                                        if (Vector3.Dot(lhs, normalized) >= 0f)
                                        {
                                            battleActor2 = battleActor4;
                                        }
                                        else
                                        {
                                            battleActor3 = battleActor4;
                                        }
                                    }
                                }
                            }
                        }
                        BattleActor battleActor5 = null;
                        if (battleActor2 != null)
                        {
                            battleActor5 = battleActor2;
                        }
                        else if (battleActor3 != null)
                        {
                            battleActor5 = battleActor3;
                        }
                        if (battleActor5 != null)
                        {
                            this.m_targetActor = battleActor5;
                            this.CheckPlayerTargetChange();
                        }
                    }
                }
            }
        }

        public BattleActor GetTargetActor()
        {
            return this.m_targetActor;
        }

        public void OnPlayerHit(bool critical, bool actionFirstHit, bool isBreakJust)
        {
            if (critical && !MainLoop.DisableTapEffect)
            {
                Mevius.Effect.Api.CreateInstance(new Mevius.Effect.Api.CreateInstanceArg
                {
                    m_strResourceName = Mevius.Effect.Api.GetResourceName(Mevius.Effect.Constants.ResourceCategory.Resident, string.Empty),
                    m_strSubResource = "critical_001"
                });
            }
            if (actionFirstHit)
            {
                if (Mevius.App.Api.IsPartyMode())
                {
                    for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
                    {
                        this.m_multiBattleActorList[i].OnPlayerHit();
                    }
                }
                else
                {
                    this.m_playerActor.OnPlayerHit();
                }
            }
            if ((critical || isBreakJust) && this.m_fairyActor != null)
            {
                this.m_fairyActor.PlayMotion("b_break1", false);
            }
        }

        public void OnPlayerDamage()
        {
            if (this.m_fairyActor != null)
            {
                this.m_fairyActor.OnPlayerDamage();
            }
        }

        public float GetInputWaitingTime()
        {
            return this.m_battleSlow.CurrentSlowTime;
        }

        public float GetTotalInputWaitTime()
        {
            return this.m_battleSlow.TotalSlowTime;
        }

        public bool IsInputWaiting()
        {
            return this.m_battleSlow.IsInBattleSlow();
        }

        public string GetSlowDebugInfo()
        {
            return this.m_battleSlow.GetDebugInfo();
        }

        public float GetPlayerAreaRandomDistance()
        {
            return this.m_placementPlayerDistanceStart + Mevius.Battle.Api.GetPlayerMovementRandomSingleFloat() * (this.m_placementPlayerDistanceEnd - this.m_placementPlayerDistanceStart);
        }

        public float GetPlayerAreaDistanceStart()
        {
            return this.m_placementPlayerDistanceStart;
        }

        public float GetPlayerAreaDistanceEnd()
        {
            return this.m_placementPlayerDistanceEnd;
        }

        public int GetPlayerActionNumBase()
        {
            if (this.m_playerActor != null)
            {
                return this.m_playerActor.GetActionNumBase();
            }
            return 0;
        }

        public void OnPlayerActionStart(bool freeAction, bool subActionMainAction)
        {
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                BattleActor battleActor = this.m_actorList[i];
                battleActor.OnPlayerActionStart(freeAction, subActionMainAction);
            }
            GuiBattleMenu.Instance.TimeLine.SetIconEffect(0, GuiBattleTimeLineIconEffect.Action);
        }

        public void OnPlayerActionEnd()
        {
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                BattleActor battleActor = this.m_actorList[i];
                battleActor.OnPlayerActionEnd();
            }
        }

        public void OnEnemyActionStart()
        {
            if (Mevius.App.Api.IsPartyMode())
            {
                for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
                {
                    this.m_multiBattleActorList[i].OnEnemyActionStart();
                }
            }
            else
            {
                this.m_playerActor.OnEnemyActionStart();
                if (this.m_playerActorSub != null)
                {
                    this.m_playerActorSub.OnEnemyActionStart();
                }
            }
        }

        public void OnEnemyActionEnd()
        {
            this.m_enemyActionEndFlag = true;
            if (Mevius.App.Api.IsPartyMode())
            {
                for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
                {
                    this.m_multiBattleActorList[i].OnEnemyActionEnd();
                }
            }
            else
            {
                this.m_playerActor.OnEnemyActionEnd();
                if (this.m_playerActorSub != null)
                {
                    this.m_playerActorSub.OnEnemyActionEnd();
                }
            }
        }

        public void OnEnemyTurnEnd()
        {
            this.HideBattleEnemyActionName();
            Mevius.Gui.Api.ClearDQBattleLogText();
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                BattleActor battleActor = this.m_actorList[i];
                if (battleActor != null && battleActor.IsEnemy() && battleActor.IsActive())
                {
                    battleActor.OnTurnEnd();
                }
            }
            if (Mevius.App.Api.IsPartyMode())
            {
                for (int j = 0; j < this.m_multiBattleActorList.Count; j++)
                {
                    this.m_multiBattleActorList[j].OnEnemyTurnEnd();
                }
            }
            else
            {
                this.m_playerActor.OnEnemyTurnEnd();
                if (this.m_playerActorSub != null)
                {
                    this.m_playerActorSub.OnEnemyTurnEnd();
                }
            }
            this.m_turnNum++;
            BattleUtility.SetOverMissionCount(MissionCountType.TurnMax, this.m_turnNum);
            BattleUtility.AddMissionCount(MissionCountType.TurnTotal, 1);
            this.SaveData();
        }

        public void ChangeTargetSelectCamera(bool force = false)
        {
            if ((this.m_cameraManager.CurrentCameraType != BattleCameraManager.CameraType.TargetSelect || force) && !this.IsMultiFinishCamera())
            {
                float interpSec;
                CameraSequence.BlendType blendType;
                if (!this.m_cameraManager.GetActionNextInterpInfo(out interpSec, out blendType))
                {
                    interpSec = 0.5f;
                    blendType = CameraSequence.BlendType.Curve;
                }
                if (this.m_playerActor.TargetActor.IsUsePlayerMotion() && this._step == BattleManager.BattleStep.PlayerTurnStart)
                {
                    interpSec = 0f;
                }
                this.m_cameraManager.SetInterpolation(interpSec, blendType, true);
                this.m_cameraManager.InitTargetSelect(this.m_boss, this.m_playerActor, this.m_playerActor.TargetActor);
                this.m_cameraManager.ChangeCamera(BattleCameraManager.CameraType.TargetSelect);
            }
        }

        public void CheckPlayerTargetChange()
        {
            if (this.m_targetActor != this.m_playerActor.TargetActor && !this.m_playerActor.IsStatusEffectEntry(BattleStatusEffect.GroupType.Provoke))
            {
                this.m_playerActor.OnTargetChange();
                this.m_playerActor.TargetActor = this.m_targetActor;
            }
        }

        public int GetEnemyNum(bool ignoreEnemyNeedNotToKill = true)
        {
            int num = 0;
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                BattleActor battleActor = this.m_actorList[i];
                if (battleActor != null && battleActor.IsEnemy() && battleActor.IsActiveTarget())
                {
                    if (ignoreEnemyNeedNotToKill)
                    {
                        if (!battleActor.IsNeedNotKill())
                        {
                            num++;
                        }
                    }
                    else
                    {
                        num++;
                    }
                }
            }
            return num;
        }

        public bool IsDamageSourceExist()
        {
            return this.m_damageSourceManager.IsExist();
        }

        public string ReplaceDamageSourceId(string id, BattleActor owner)
        {
            return this.m_damageSourceManager.ReplaceDamageSourceId(id, owner);
        }

        public void OnEnemyNoActionPlayerActionContinue()
        {
            if (Mevius.App.Api.IsPartyMode())
            {
                return;
            }
            if (BattleManager._i.IsCountTimeBattle())
            {
                return;
            }
            if (this.IsPlayerTurn())
            {
                bool flag = false;
                for (int i = 0; i < this.m_actorList.Count; i++)
                {
                    BattleActor battleActor = this.m_actorList[i];
                    if (battleActor != null && !battleActor.IsPlayer() && battleActor.IsActive())
                    {
                        if (battleActor.IsNextTurnAction())
                        {
                            flag = false;
                            break;
                        }
                        flag = true;
                    }
                }
                if (flag)
                {
                    if (this.m_fairyActor != null)
                    {
                        this.ProcFairyEffectType(true);
                    }
                    if (this.m_fairyEffectType == BattleManager.FairyEffectType.None)
                    {
                        if (Mevius.Db.Api.GetBattleData().padCombo > 0 && Mevius.Db.Api.GetBattleData().padComboTurn <= 1)
                        {
                            return;
                        }
                        this.m_playerActor.UpdatePadComboTurn();
                        if (this.m_playerActor != null)
                        {
                            this.m_playerActor.OnTurnEnd();
                        }
                        if (this.m_playerActorSub != null)
                        {
                            this.m_playerActorSub.OnTurnEnd();
                        }
                        this.OnEnemyTurnEnd();
                        if (this.m_playerActor != null)
                        {
                            this.m_playerActor.OnTurnBegin();
                            this.m_playerActor.ReadyAction();
                            if (!this.m_playerActor.IsDead() && (this.m_targetActor == null || !this.m_targetActor.IsActive()))
                            {
                                this.UpdateSelectedTarget();
                            }
                        }
                    }
                }
            }
        }

        public BattleFairyActor FairyActor
        {
            get
            {
                return this.m_fairyActor;
            }
        }

        public void OnTutorialTrigger(BattleTutorialManager.TriggerType trigger)
        {
            if (this.m_tutorialManager != null)
            {
                this.m_tutorialManager.OnTrigger(trigger);
            }
        }

        private void InitFairyActor()
        {
            this.m_fairyActor = null;
            AppActor appActor = Mevius.App.Api.FindAppActor(Mevius.Db.Api.GetPlayerFairyName() + "_battle");
            if (appActor != null && appActor.getGameObject().activeInHierarchy)
            {
                this.m_fairyActor = (appActor.actors[1] as BattleFairyActor);
                this.m_fairyActor.SetIdle();
                this.m_fairyActor.InitIdlePos();
                if (this.m_playerActor != null && this.m_playerActor.IsSummon())
                {
                    this.m_fairyActor.Chara.ShowHideModel(false, true);
                }
            }
        }

        public void OnFairyEffect()
        {
            switch (this.m_fairyEffectType)
            {
            case BattleManager.FairyEffectType.Revive:
                this.RevivePlayer();
                break;
            case BattleManager.FairyEffectType.Heal:
            {
                Mevius.Effect.Api.CreateInstance(new Mevius.Effect.Api.CreateInstanceArg
                {
                    m_strResourceName = Mevius.Effect.Api.GetResourceName(Mevius.Effect.Constants.ResourceCategory.Resident, string.Empty),
                    m_strSubResource = "keal_002",
                    m_BindActor = this.m_playerActor.chara.gameObject
                });
                float recoverRate = (float)Mevius.DataSheet.Api.GetResidentInteger("fairyEffect0val1", 20) * 0.01f;
                this.m_playerActor.RecoverHpMaxRate(recoverRate);
                Mevius.Gui.Constants.PopupStatusKind kind = Mevius.Gui.Constants.PopupStatusKind.Full;
                Mevius.Gui.Constants.PopupStatusEffect effect = Mevius.Gui.Constants.PopupStatusEffect.None;
                string value = string.Empty;
                C02688ac2fa3465c4dc969e664556169f.Cdb83ac7b1b94f482a747dd16b359c48f cdb83ac7b1b94f482a747dd16b359c48f = C02688ac2fa3465c4dc969e664556169f.Find("6");
                if (cdb83ac7b1b94f482a747dd16b359c48f != null && this.m_playerActor.AddStatusEffect(cdb83ac7b1b94f482a747dd16b359c48f, Mevius.DataSheet.Api.GetResidentInteger("fairyEffect0val2", 3), BattleStatusEffect.StateType.Normal, 0, true, true))
                {
                    value = cdb83ac7b1b94f482a747dd16b359c48f.m8d891e45af2849894b2221fd8edc72c0();
                }
                Transform elementIdTransform = this.m_playerActor.chara.GetElementIdTransform(ExtensionElementIdDefinition.GetName(ExtensionElementIdDefinition.Index.MAGIC_HIT));
                Mevius.Gui.Api.AddStatusPopup(kind, effect, value, elementIdTransform, Vector2.zero, false);
                Mevius.Gui.Api.ShowPopup();
                string soundResourceName = Mevius.Sound.Api.GetSoundResourceName("Resident");
                Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Field_3D, soundResourceName, "system_se_ed_hp_recovery", 1f, 0, 0, this.m_playerActor.chara.transform.position, null, false, -1, 0, 1f);
                break;
            }
            case BattleManager.FairyEffectType.Rescue:
            {
                int residentInteger = Mevius.DataSheet.Api.GetResidentInteger("fairyEffect1val1", 2);
                if (residentInteger > 0)
                {
                    Transform elementIdTransform2 = this.m_fairyActor.Chara.GetElementIdTransform(ExtensionElementIdDefinition.GetName(ExtensionElementIdDefinition.Index.BODY_CENTER));
                    Vector3 position;
                    if (elementIdTransform2)
                    {
                        position = elementIdTransform2.position;
                    }
                    else
                    {
                        position = this.m_fairyActor.Chara.transform.position;
                    }
                    float num = 0.75f;
                    float d = num + 0.5f;
                    float num2 = 180f;
                    float num3 = 90f;
                    for (int i = 0; i < residentInteger; i++)
                    {
                        Vector3 a = Quaternion.AngleAxis(num2, Vector3.up) * this.m_fairyActor.Chara.transform.forward;
                        Vector3 vector = position + a * num;
                        Vector3 pos = vector + a * d;
                        pos.y += 2.5f;
                        this.CreateMana(null, pos, vector, false);
                        num2 += num3;
                    }
                }
                string soundResourceName2 = Mevius.Sound.Api.GetSoundResourceName("Resident");
                Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Field_3D, soundResourceName2, "system_se_ce_battle_in", 1f, 0, 0, this.m_fairyActor.Chara.transform.position, null, false, -1, 0, 1f);
                break;
            }
            case BattleManager.FairyEffectType.Cheer:
            {
                this.m_fairyActor.CheerEffect = true;
                Mevius.Effect.Api.CreateInstance(new Mevius.Effect.Api.CreateInstanceArg
                {
                    m_strResourceName = Mevius.Effect.Api.GetResourceName(Mevius.Effect.Constants.ResourceCategory.Resident, string.Empty),
                    m_strSubResource = "fairy_eff_001",
                    m_BindActor = this.m_playerActor.chara.gameObject
                });
                string soundResourceName3 = Mevius.Sound.Api.GetSoundResourceName("Resident");
                Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Field_3D, soundResourceName3, "fairy_eff_001", 1f, 0, 0, this.m_playerActor.chara.transform.position, null, false, -1, 0, 1f);
                break;
            }
            case BattleManager.FairyEffectType.Encourage:
            {
                this.m_playerActor.TargetActor.BreakCount++;
                Mevius.Gui.Api.ShowBreakBonusEffect();
                Mevius.Effect.Api.CreateInstance(new Mevius.Effect.Api.CreateInstanceArg
                {
                    m_strResourceName = Mevius.Effect.Api.GetResourceName(Mevius.Effect.Constants.ResourceCategory.Resident, string.Empty),
                    m_strSubResource = "fairy_eff_002",
                    m_BindActor = this.m_playerActor.chara.gameObject
                });
                string soundResourceName4 = Mevius.Sound.Api.GetSoundResourceName("Resident");
                Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Field_3D, soundResourceName4, "fairy_eff_002", 1f, 0, 0, this.m_playerActor.chara.transform.position, null, false, -1, 0, 1f);
                break;
            }
            }
            this.m_fairyEffectType = BattleManager.FairyEffectType.None;
        }

        private void ProcFairyEffectType(bool preset)
        {
            if (this.m_playerActor != null && this.m_playerActor.IsSummon())
            {
                return;
            }
            if (preset && this.m_presetFairyEffect)
            {
                return;
            }
            uint num = Mevius.Battle.Api.GetRandomUnsignedInteger() % 100u;
            this.m_presetFairyEffect = preset;
            this.m_fairyEffectType = BattleManager.FairyEffectType.None;
            int num2 = 0;
            int num3 = Mevius.DataSheet.Api.GetResidentInteger("fairyEffect0prob", 10);
            if (this.m_fairyHour)
            {
                num3 <<= 1;
            }
            num2 += num3;
            if ((ulong)num < (ulong)((long)num2))
            {
                if (this.m_playerActor.GetHpRate() < (float)Mevius.DataSheet.Api.GetResidentInteger("fairyEffect0val0", 30) * 0.01f)
                {
                    this.m_fairyEffectType = BattleManager.FairyEffectType.Heal;
                }
            }
            else
            {
                num3 = Mevius.DataSheet.Api.GetResidentInteger("fairyEffect1prob", 3);
                if (this.m_fairyHour)
                {
                    num3 <<= 1;
                }
                num2 += num3;
                if ((ulong)num < (ulong)((long)num2))
                {
                    if (this.m_playerActor.ManaElements.Length <= Mevius.DataSheet.Api.GetResidentInteger("fairyEffect1val0", 4))
                    {
                        this.m_fairyEffectType = BattleManager.FairyEffectType.Rescue;
                    }
                }
                else if (this.PlayerJobChangeThroughTurn != 1)
                {
                    int num4 = this.m_turnNum;
                    if (preset)
                    {
                        num4++;
                    }
                    if (num4 >= Mevius.DataSheet.Api.GetResidentInteger("fairyEffect2prob1", 5))
                    {
                        num3 = Mevius.DataSheet.Api.GetResidentInteger("fairyEffect2prob", 2);
                        if (this.m_fairyHour)
                        {
                            num3 <<= 1;
                        }
                        num2 += num3;
                        if ((ulong)num < (ulong)((long)num2))
                        {
                            this.m_fairyEffectType = BattleManager.FairyEffectType.Cheer;
                        }
                    }
                }
            }
        }

        public bool ProcFairyEncourage()
        {
            bool result = false;
            if (this.m_playerActor != null && this.m_playerActor.IsSummon())
            {
                return result;
            }
            if (this.m_fairyActor != null && this.m_breakNum >= Mevius.DataSheet.Api.GetResidentInteger("fairyEffect3prob1", 2))
            {
                uint num = Mevius.Battle.Api.GetRandomUnsignedInteger() % 100u;
                int num2 = Mevius.DataSheet.Api.GetResidentInteger("fairyEffect3prob", 10);
                if (this.m_fairyHour)
                {
                    num2 <<= 1;
                }
                if ((ulong)num < (ulong)((long)num2))
                {
                    this.m_fairyEffectType = BattleManager.FairyEffectType.Encourage;
                    this.m_fairyActor.Action(this.m_fairyEffectType);
                    BattleManager._i.CameraManager.SetInterpolation(0f, CameraSequence.BlendType.Curve, true);
                    BattleManager._i.CameraManager.InitAction("fairyB1", this.m_playerActor, false, false);
                    BattleManager._i.CameraManager.ChangeCamera(BattleCameraManager.CameraType.Action);
                    result = true;
                }
            }
            return result;
        }

        public void SetFairyFollowPlayer(bool flag)
        {
            if (this.m_fairyActor != null)
            {
                this.m_fairyActor.FollowPlayer = flag;
            }
        }

        public void HideGuardFairy()
        {
            if (this.m_fairyActor != null)
            {
                this.m_fairyActor.HideGuard();
            }
        }

        public void ShowGuardFairy()
        {
            if (this.m_fairyActor != null)
            {
                this.m_fairyActor.ShowGuard();
            }
        }

        public bool IsUseDebugParameter()
        {
            return false;
        }

        public void IncrementBreakNum()
        {
            this.m_breakNum++;
            BattleUtility.AddMissionCount(MissionCountType.BreakCount, 1);
        }

        public int DeadNum
        {
            get
            {
                return this.m_deadNum;
            }
            set
            {
                this.m_deadNum = value;
            }
        }

        public int GetScoreTurnNum()
        {
            return this.m_turnNum + this.m_deadNum * Mevius.DataSheet.Api.GetResidentInteger("scoreDeadTurn", 10);
        }

        public bool LastEnemyEscape
        {
            get
            {
                return this.m_lastEnemyEscape;
            }
            set
            {
                this.m_lastEnemyEscape = value;
            }
        }

        public bool ChaosBattle
        {
            get
            {
                return this.m_chaosBattle;
            }
        }

        public bool ShadowBlankBattle
        {
            get
            {
                return this.m_shadowBlankBattle;
            }
        }

        public bool ForceAllCamera
        {
            get
            {
                return this.m_forceAllCameraBattle;
            }
        }

        public string TargetSelectCameraName
        {
            get
            {
                return this.m_targetSelectCameraName;
            }
        }

        public bool IsLowerFpsEnable()
        {
            return (this.IsPlayerTurn() && !this.IsPlayerActionEnd() && this.m_playerActor.State == BattleActor.StateType.Idle && !Mevius.App.Api.IsButtonStay(InputType.InputType_TouchEmulate) && !this.m_guiTouchComponent.IsPress() && !this.m_guiTouchComponent.IsUp()) || this.GetSlowState() == BattleSlow.StateType.Slow;
        }

        public void CreateMethodCache()
        {
            Mevius.Battle.Api.GetRandomUnsignedInteger();
            Mevius.Battle.Api.GetRandomSingleFloat();
            this.CreateDamageSource(string.Empty, null, null, Vector3.zero, null, false, false, false);
            this.m_damageSourceManager.CreateMethodCache();
            this.m_manaObjectManager.CreateMethodCache();
            this.CreateMana(null, Vector3.zero, 0, false, 0, 0);
            this.UpdateManaGui();
            this.OnPlayerHit(false, false, false);
            BattleUtility.AddMissionCount(MissionCountType.None, 0);
            BattleUtility.AddBattleScore(0L);
            this.GetScoreTurnNum();
            this.AddTakeDamageTotal(null, null, 0);
            this.GiveDamageMissionCount(null, null, 0);
            this.AddRecoveryTotal(null, 0);
            BattleDamage.HitArg arg = new BattleDamage.HitArg();
            BattleDamage.OnHit(arg);
            BattleDamage.ProcElementAbilitySkill(null, null, Vector3.zero);
            BattleActor battleActor = new BattleActor();
            bool flag;
            battleActor.OnHit(out flag, false, false);
            battleActor.OnDamage(out flag, out flag, out flag, null, null);
            battleActor.IsActionTargetValidHitFirst(null);
            int num = 0;
            battleActor.ProcStatusEffectShield(ref num);
            battleActor.GetStatusEffectValue(BattleStatusEffect.ProcType.None);
            battleActor.GetUseCardAbilitySkillNum(DbManager.AbilitySkillType.ABILITYSKILL_TYPE_NONE);
            battleActor.IsUseCardAbilitySkill(DbManager.AbilitySkillType.ABILITYSKILL_TYPE_NONE);
            battleActor.IsBreakDamage();
            string jobAbilityId = battleActor.JobAbilityId;
            battleActor.ActionFlagBit = battleActor.ActionFlagBit;
            battleActor.CalcBreakDamage(out num, out num, out num, 0, null, false, false, false);
            battleActor.UpdateBreakState();
            battleActor.AddHp(0);
            battleActor.PlayMotion(string.Empty);
            battleActor.UpdateCardAbilityManaGui();
            battleActor.ActionFlagBit = battleActor.ActionFlagBit;
            battleActor.GetEffectResource(out jobAbilityId, out jobAbilityId, 0, string.Empty, string.Empty, Vector3.zero, null);
            battleActor.GetSoundResource(out jobAbilityId, out jobAbilityId, 0, string.Empty, string.Empty, Vector3.zero, null);
            BattleAi battleAi = new BattleAi(string.Empty, null);
            battleAi.OnBehavior(BattleAiData.Pattern.TimingType.HpBpDamageHit, string.Empty, null, true);
            C9834a30e5f3368ef11b898eb90b12c5b.Find(string.Empty);
            IEnumerator<C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c> enumerator = C9834a30e5f3368ef11b898eb90b12c5b.GetRecords().GetEnumerator();
            if (enumerator.MoveNext())
            {
                C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c = enumerator.Current;
                if (c03df96e967d7177ede70d5c100f08e3c != null)
                {
                    c03df96e967d7177ede70d5c100f08e3c.m1467af6649f8c2c42db7965d4a2e590e();
                    c03df96e967d7177ede70d5c100f08e3c.m99d4196c8ddc2c84aa2a035182a3e754();
                    c03df96e967d7177ede70d5c100f08e3c.m2a2088e5423c9ed60aaf8024bb799763();
                    c03df96e967d7177ede70d5c100f08e3c.ma32fcd1fe2598c2edcfa5cdbeb0eb64f();
                    c03df96e967d7177ede70d5c100f08e3c.med3b109a0c7b9aaffc8f700ad530010f();
                    c03df96e967d7177ede70d5c100f08e3c.m31a2bc12a6fb70b72bfab3e85b658b3e();
                    c03df96e967d7177ede70d5c100f08e3c.m0a3adefa2ef034c2e9556ec82f7fa3c6();
                    c03df96e967d7177ede70d5c100f08e3c.m056cb6b23e1a1553df9a90eb3f5f804b();
                    c03df96e967d7177ede70d5c100f08e3c.mcdcc634daaa800ae30b0d9aa90d524cc();
                    c03df96e967d7177ede70d5c100f08e3c.m6374ec9bd9c83aa1592cd25bdd68315e();
                    c03df96e967d7177ede70d5c100f08e3c.m1ff35aae1a721dffe2c7ec2dfb4c573e();
                    c03df96e967d7177ede70d5c100f08e3c.m957592ac75221a66cc4d1fa3831c59b8();
                    c03df96e967d7177ede70d5c100f08e3c.m4a78ffda98410f820411120ffcbc8045();
                    c03df96e967d7177ede70d5c100f08e3c.m7b9ab26a81a7c308786cde1f6d7a628e();
                    c03df96e967d7177ede70d5c100f08e3c.md808a0de5cbd11616a88a9cfc181753d();
                    c03df96e967d7177ede70d5c100f08e3c.m87234b3ed2f74e5f979716260f759e77();
                    c03df96e967d7177ede70d5c100f08e3c.m5047a0ec8a5d083680dafc9a8766f38d();
                    c03df96e967d7177ede70d5c100f08e3c.m6a0716d2cc5a8d6f657bf217d26e449b();
                    c03df96e967d7177ede70d5c100f08e3c.m6e92409504ed0c8c5b06e0a97c95bb63();
                    c03df96e967d7177ede70d5c100f08e3c.m29e3d40ae989c1d5785b5175bd5d0659();
                    c03df96e967d7177ede70d5c100f08e3c.m110ab6d4a20f2042ea550a01b97a30dc();
                    c03df96e967d7177ede70d5c100f08e3c.m8a3ffcd9c8f5af823c8a42a71565561e();
                    c03df96e967d7177ede70d5c100f08e3c.m263e4f2d1158904e07d8b215e1b035db();
                    c03df96e967d7177ede70d5c100f08e3c.m0e119ce81d6d2a560389412592ca044c();
                    c03df96e967d7177ede70d5c100f08e3c.m9de5ae9d57303574e103e01b0c68c64d();
                    c03df96e967d7177ede70d5c100f08e3c.m5c7889c5b289e0849003f848e3f114c2();
                    c03df96e967d7177ede70d5c100f08e3c.m300216fe52c281630be5243bc8792ac2();
                    c03df96e967d7177ede70d5c100f08e3c.m99ff033c8247b70cbf541c4f00743dc9();
                    c03df96e967d7177ede70d5c100f08e3c.mb7c766a732e8d499ba6266ceaea417b6();
                    c03df96e967d7177ede70d5c100f08e3c.m86c5afc171f03c9baf7a9139d2c41bce();
                    c03df96e967d7177ede70d5c100f08e3c.mb4581b0c1c70816dbf7d2f28a87d55ae();
                    c03df96e967d7177ede70d5c100f08e3c.m811d2e53ea755f3830f5d97c8659fa1a();
                    c03df96e967d7177ede70d5c100f08e3c.m27948f4a0a5b32c2cf5b9550638a8c0c();
                    c03df96e967d7177ede70d5c100f08e3c.mfd7dfab5a03d8ac4040c8f598d517f0e();
                    c03df96e967d7177ede70d5c100f08e3c.me1c89bd544968a60816bc0b8e7b47a80();
                    c03df96e967d7177ede70d5c100f08e3c.m3a0d719c78ea3fae223cbf90b27ddc4f();
                    c03df96e967d7177ede70d5c100f08e3c.m1fea426dbc01abe4ac8facc5922a4813();
                    c03df96e967d7177ede70d5c100f08e3c.m2f3946dc86ba631c2fd16e6a9c6a714d();
                    c03df96e967d7177ede70d5c100f08e3c.m769a09740a1f46fc210b96ec17661da3();
                    c03df96e967d7177ede70d5c100f08e3c.m8663cd5d4e1bc28767c331587c5e8c32();
                    c03df96e967d7177ede70d5c100f08e3c.m759297b117b1f8fd9d42d531f3ef0f57();
                    c03df96e967d7177ede70d5c100f08e3c.m2c84f4a27d7efcd43161ea09563e314c();
                    c03df96e967d7177ede70d5c100f08e3c.mb17e5317c2a4fabba931b37a2e132c30();
                    c03df96e967d7177ede70d5c100f08e3c.m81f2266d072bf1e2634dd52decf119c5();
                    c03df96e967d7177ede70d5c100f08e3c.m5ad98d8a4cc2ec46c1ce7f385308e190();
                    c03df96e967d7177ede70d5c100f08e3c.mf426d0370819321cdca2df293f879469();
                    c03df96e967d7177ede70d5c100f08e3c.m8df6f86ebc5a2bfa5faee3054abfb443();
                    c03df96e967d7177ede70d5c100f08e3c.m44e96effc875ccd74e5023188a133a3a();
                    c03df96e967d7177ede70d5c100f08e3c.m47c0bd9f846c206b0b1cfdc278197dc5();
                    c03df96e967d7177ede70d5c100f08e3c.m886c64f77fafec63eda86595020883b9();
                    c03df96e967d7177ede70d5c100f08e3c.md9be087c8546e79969b04aa147c95bd6();
                    c03df96e967d7177ede70d5c100f08e3c.mac71ccd4bca5cfd056283422119c7c87();
                    c03df96e967d7177ede70d5c100f08e3c.m818cea48064d16af78d875b7f9c08fd0();
                    c03df96e967d7177ede70d5c100f08e3c.mb000a687470e13e29bbc7b874a8790d4();
                    c03df96e967d7177ede70d5c100f08e3c.m3a86498917093d62903fbe764a4fb67b();
                    c03df96e967d7177ede70d5c100f08e3c.m08617b6ba6b9a4e8e3b0e9619c6242f3();
                    c03df96e967d7177ede70d5c100f08e3c.m7a3b01306f0dde97c1f8713269e2e654();
                    c03df96e967d7177ede70d5c100f08e3c.m4a993a247ee44db08a2315a9ef58e674();
                    c03df96e967d7177ede70d5c100f08e3c.me54b3f3916dc0372b1b1954a7b30a347();
                    c03df96e967d7177ede70d5c100f08e3c.m84b7abab746d84abc1b35ed36b399916();
                    c03df96e967d7177ede70d5c100f08e3c.mb7e19e5ecacf66b59ef3bcbee973f0a7();
                    c03df96e967d7177ede70d5c100f08e3c.m71a0a24b533eafcd9951afaa941ddb43();
                    c03df96e967d7177ede70d5c100f08e3c.mcf041a3ccfd72b02bc7be50cd0b53e59();
                    c03df96e967d7177ede70d5c100f08e3c.m409e2d1af9fc2038e724dc25fe2d7999();
                    c03df96e967d7177ede70d5c100f08e3c.mf63eb4bd0711665cfef96eb0479e6a9b();
                    c03df96e967d7177ede70d5c100f08e3c.m19b8e48aa75c46f41bdd3dcf7cd70c1b();
                    c03df96e967d7177ede70d5c100f08e3c.m7b132ff2e691551f14040db4fe1c55fd();
                    c03df96e967d7177ede70d5c100f08e3c.m42059cddf83c1c61e1166efe751c69c7();
                    c03df96e967d7177ede70d5c100f08e3c.m2a2b1998964a658b4466e0fb5d8d287e();
                    c03df96e967d7177ede70d5c100f08e3c.meefffad531472590bfabdd34ef2416d5();
                    c03df96e967d7177ede70d5c100f08e3c.me4d51864a41cc3a3cca5aa95df5f7be1();
                    c03df96e967d7177ede70d5c100f08e3c.mb2ed0c384b8846ff6ea2540893eb129d();
                    c03df96e967d7177ede70d5c100f08e3c.m4fe9637c6ceff1377cd197d89cc75ecb();
                    c03df96e967d7177ede70d5c100f08e3c.m7e3ef2af79ede7a79f5c6b60c6c76b42();
                    c03df96e967d7177ede70d5c100f08e3c.md1e6aba89f9c5ad20e35aa11ae23fa5b();
                    c03df96e967d7177ede70d5c100f08e3c.mcb0705fc1591f54a27e304ca1797ff48();
                    c03df96e967d7177ede70d5c100f08e3c.m86dda0cf32427b50fd3c267b534fe474();
                    c03df96e967d7177ede70d5c100f08e3c.mb0b61ed8ee0084b324022b1734ae7922();
                    c03df96e967d7177ede70d5c100f08e3c.m7627e1e10877dff2168f653f6ad85c13();
                }
            }
            IEnumerator<C24514bd3adc3e26e926bc8e966ad6873.Ccf5a35e5c2bf1875ddd37dc4036aee50> enumerator2 = C24514bd3adc3e26e926bc8e966ad6873.GetRecords().GetEnumerator();
            if (enumerator2.MoveNext())
            {
                C24514bd3adc3e26e926bc8e966ad6873.Ccf5a35e5c2bf1875ddd37dc4036aee50 ccf5a35e5c2bf1875ddd37dc4036aee = enumerator2.Current;
                if (ccf5a35e5c2bf1875ddd37dc4036aee != null)
                {
                    ccf5a35e5c2bf1875ddd37dc4036aee.mdd7654f5eb3dbf6005e3d264c4988d11();
                    ccf5a35e5c2bf1875ddd37dc4036aee.m8f1a83a29c6d41a8a2932d9b43091924();
                }
            }
            this.OnTutorialTrigger(BattleTutorialManager.TriggerType.EnemyBroken);
            Mevius.Db.Api.GetDropElementCountTable();
            Mevius.Db.Api.GetDropElementTypeTable();
            Mevius.Gui.Api.SetBattleCardAbilityElementCount(0, 0, 0, 0);
            this.ChainNum = this.ChainNum;
        }

        public Vector3 GetBackStepBaseDir()
        {
            Vector3 result;
            if (!this.ChaosBattle)
            {
                result = Vector3.forward;
            }
            else
            {
                result = Vector3.back;
            }
            return result;
        }

        public int GetEnemyAiCommonCounter(int index)
        {
            return (int)this.m_enemyAiCommonCounters[index];
        }

        public void SetEnemyAiCommonCounter(int index, int value)
        {
            this.m_enemyAiCommonCounters[index] = (short)value;
        }

        public byte PlayerJobChangeChargeTurn
        {
            get
            {
                return this.m_playerJobChangeChargeTurn;
            }
            set
            {
                if (!Mevius.App.Api.IsPartyMode() && this.m_playerJobChangeChargeTurn != value && GuiBattleMenu.Instance != null)
                {
                    GuiBattleMenu.Instance.SetJobChangeChargeTurn((int)value, false);
                }
                this.m_playerJobChangeChargeTurn = value;
            }
        }

        public byte PlayerJobChangeThroughTurn
        {
            get
            {
                return this.m_playerJobChangeThroughTurn;
            }
            set
            {
                this.m_playerJobChangeThroughTurn = value;
            }
        }

        public void ProcChangeJob(bool loadData = false, bool summonEnd = false)
        {
            if (!loadData)
            {
                Mevius.Db.Api.SetParameter(DbManager.ParameterType.Current_Job, (Mevius.Db.Api.GetParameter(DbManager.ParameterType.Current_Job) == 0) ? 1 : 0);
            }
            BattleActor battleActor;
            BattleActor battleActor2;
            if (Mevius.Db.Api.GetParameter(DbManager.ParameterType.Current_Job) != 0)
            {
                battleActor = this.FindActor(BattleManager.GetBattlePlayerName());
                battleActor2 = this.FindActor(BattleManager.GetBattlePlayerSubName());
            }
            else
            {
                battleActor = this.FindActor(BattleManager.GetBattlePlayerSubName());
                battleActor2 = this.FindActor(BattleManager.GetBattlePlayerName());
            }
            if (!summonEnd)
            {
                battleActor.chara.OnSetActive(false, true);
                battleActor.chara.gameObject.SetActive(false);
                battleActor2.chara.PhysicsResetPose();
                battleActor2.chara.gameObject.SetActive(true);
                battleActor2.chara.OnSetActive(true, true);
            }
            bool flag = this.IsPartyChange();
            if (!loadData)
            {
                ElementAttributeType[] jobUseAttributeArray = BattleUtility.GetJobUseAttributeArray(battleActor2.Deck, true);
                int[,] statusEffectEntries = battleActor.GetStatusEffectEntries();
                int[][] array = new int[statusEffectEntries.GetLength(0)][];
                int i = 0;
                while (i < array.GetLength(0))
                {
                    C02688ac2fa3465c4dc969e664556169f.Cdb83ac7b1b94f482a747dd16b359c48f cdb83ac7b1b94f482a747dd16b359c48f = C02688ac2fa3465c4dc969e664556169f.Find(statusEffectEntries[i, 0].ToString());
                    if (cdb83ac7b1b94f482a747dd16b359c48f == null)
                    {
                        goto IL_24B;
                    }
                    BattleStatusEffect.ProcType[] array2 = new BattleStatusEffect.ProcType[]
                    {
                        (BattleStatusEffect.ProcType)cdb83ac7b1b94f482a747dd16b359c48f.m337a17f130ee70b7376c74e7685ff24d(),
                        (BattleStatusEffect.ProcType)cdb83ac7b1b94f482a747dd16b359c48f.m722c29f56d15d8cd013e7822bdaa0eca(),
                        (BattleStatusEffect.ProcType)cdb83ac7b1b94f482a747dd16b359c48f.m57d64ec3f60c3c0db44ef991bd39ae67()
                    };
                    bool[] array3 = new bool[]
                    {
                        BattleUtility.IsStatusEffectProcForce(array2[0]) || BattleUtility.IsStatusEffectProcDeforce(array2[0]),
                        BattleUtility.IsStatusEffectProcForce(array2[1]) || BattleUtility.IsStatusEffectProcDeforce(array2[1]),
                        BattleUtility.IsStatusEffectProcForce(array2[2]) || BattleUtility.IsStatusEffectProcDeforce(array2[2])
                    };
                    if (!array3[0] && !array3[1] && !array3[2])
                    {
                        goto IL_24B;
                    }
                    bool flag2 = false;
                    for (int j = 0; j < array2.Length; j++)
                    {
                        if (array3[j])
                        {
                            BattleStatusEffect.ProcType procType = array2[j];
                            ElementAttributeType elementAttributeType = ElementAttributeType.None;
                            if (BattleStatusEffect.ProcType.ElementalGaugeMaxFire <= procType && procType <= BattleStatusEffect.ProcType.ElementalGaugeMaxDark)
                            {
                                elementAttributeType = (ElementAttributeType)(procType - 110);
                            }
                            else if (BattleStatusEffect.ProcType.ElementalGaugeZeroFire <= procType && procType <= BattleStatusEffect.ProcType.ElementalGaugeZeroDark && jobUseAttributeArray.Length > 1)
                            {
                                elementAttributeType = (ElementAttributeType)(procType - 120);
                            }
                            for (int k = 0; k < jobUseAttributeArray.Length; k++)
                            {
                                if (jobUseAttributeArray[k] == elementAttributeType)
                                {
                                    flag2 = true;
                                    break;
                                }
                            }
                        }
                    }
                    if (flag2)
                    {
                        goto IL_24B;
                    }
                    IL_29A:
                    i++;
                    continue;
                    IL_24B:
                    array[i] = new int[4];
                    array[i][0] = statusEffectEntries[i, 0];
                    array[i][1] = statusEffectEntries[i, 1];
                    array[i][2] = statusEffectEntries[i, 2];
                    array[i][3] = statusEffectEntries[i, 3];
                    goto IL_29A;
                }
                bool manToMan = battleActor.ManToMan;
                int hpMax = battleActor.HpMax;
                battleActor.ClearStatusEffectEntries();
                battleActor.ManToMan = false;
                float num = (float)battleActor.HpMax / (float)hpMax;
                battleActor.SetHp((int)((float)battleActor.Hp * num + 0.5f), false, false);
                int hpMax2 = battleActor2.HpMax;
                battleActor2.SetStatusEffectEntries(array);
                battleActor2.ManToMan = manToMan;
                float num2 = (float)battleActor2.HpMax / (float)hpMax2;
                battleActor2.SetHp((int)((float)battleActor2.Hp * num2 + 0.5f), false, false);
                battleActor.TransferMana(battleActor2);
                int deck;
                int deck2;
                if (Mevius.Db.Api.GetParameter(DbManager.ParameterType.Current_Job) != 0)
                {
                    deck = Mevius.Db.Api.GetCurrentCardDeck();
                    deck2 = Mevius.Db.Api.GetCurrentCardDeck() + 12;
                }
                else
                {
                    deck = Mevius.Db.Api.GetCurrentCardDeck() + 12;
                    deck2 = Mevius.Db.Api.GetCurrentCardDeck();
                }
                ElementAttributeType[] jobUseAttributeArray2 = BattleUtility.GetJobUseAttributeArray(deck, battleActor.IsSummon());
                ElementAttributeType[] jobUseAttributeArray3 = BattleUtility.GetJobUseAttributeArray(deck2, battleActor2.IsSummon());
                List<ElementAttributeType> list = new List<ElementAttributeType>();
                foreach (ElementAttributeType elementAttributeType2 in jobUseAttributeArray2)
                {
                    bool flag3 = false;
                    foreach (ElementAttributeType elementAttributeType3 in jobUseAttributeArray3)
                    {
                        if (elementAttributeType2 == elementAttributeType3)
                        {
                            flag3 = true;
                            break;
                        }
                    }
                    if (!flag3)
                    {
                        list.Add(elementAttributeType2);
                    }
                }
                if (list.Count > 0)
                {
                    for (int n = 0; n <= 5; n++)
                    {
                        if (battleActor2.IsAutoAbility(DbManager.AutoAbilityType.AUTOABILITYTYPE_CS1400 + n))
                        {
                            battleActor2.ConvertManaElement((ElementAttributeType)n, list);
                            if (!summonEnd)
                            {
                                this.UpdateManaGui();
                            }
                            break;
                        }
                    }
                }
                battleActor2.ActionNum = battleActor.ActionNum;
                battleActor2.SuccessiveActionNum = battleActor.SuccessiveActionNum;
                battleActor2.ActionNumDecrementFlag = battleActor.ActionNumDecrementFlag;
                battleActor2.AbilityCombo = battleActor.AbilityCombo;
                battleActor2.AbilityUseSuportCount = battleActor.AbilityUseSuportCount;
                battleActor.ManaAttributeUseNum.CopyTo(battleActor2.ManaAttributeUseNum, 0);
                if (battleActor.IsSummon())
                {
                    Vector3 basePosition = this._basePosition;
                    float playerAreaRandomDistance = this.GetPlayerAreaRandomDistance();
                    if (this.m_chaosBattle)
                    {
                        basePosition.z -= playerAreaRandomDistance;
                    }
                    else
                    {
                        basePosition.z += playerAreaRandomDistance;
                    }
                    Vector3 vector = -basePosition.normalized;
                    float num3 = (!(battleActor2.chara.GetCharacterControllerComponent() != null)) ? 2f : battleActor2.chara.GetCharacterControllerComponent().height;
                    RaycastHit raycastHit;
                    if (Physics.Raycast(basePosition + Vector3.up * num3 * 0.5f, Vector3.down, out raycastHit, num3, 1 << LayerMask.NameToLayer("Phy Bg")))
                    {
                        basePosition.y = raycastHit.point.y;
                    }
                    battleActor2.chara.transform.position = basePosition;
                    battleActor2.chara.transform.rotation = battleActor.chara.transform.rotation;
                    battleActor2.chara.OnSetRotDirection(battleActor.chara.GetRotDirection());
                    if (this.m_fairyActor != null)
                    {
                        this.m_fairyActor.Chara.ShowHideModel(true, true);
                    }
                }
                else
                {
                    battleActor2.chara.transform.position = battleActor.chara.transform.position;
                    if (battleActor2.IsSummon())
                    {
                        battleActor2.chara.transform.rotation = Quaternion.LookRotation(-this.GetBackStepBaseDir());
                        battleActor2.chara.OnSetRotDirection(Vector3.zero);
                        if (this.m_fairyActor != null)
                        {
                            this.m_fairyActor.Chara.ShowHideModel(false, true);
                        }
                    }
                    else
                    {
                        battleActor2.chara.transform.rotation = battleActor.chara.transform.rotation;
                        battleActor2.chara.OnSetRotDirection(battleActor.chara.GetRotDirection());
                    }
                }
                if (!flag)
                {
                    float hpRate = battleActor.GetHpRate();
                    if ((int)(hpRate * 100f) != (int)(battleActor2.GetHpRate() * 100f))
                    {
                        int num4 = (int)((float)battleActor2.HpMax * hpRate + 0.5f);
                        if (num4 < 1)
                        {
                            num4 = 1;
                        }
                        battleActor2.SetHp(num4, false, true);
                    }
                    else
                    {
                        battleActor2.SetHp(battleActor2.Hp, false, true);
                    }
                }
                else
                {
                    battleActor2.UpdatePinchAutoAbility();
                }
                battleActor2.TargetActor = battleActor.TargetActor;
                float num5 = (float)battleActor.ManaUseNum / (float)battleActor.JobAbilityUseManaUseNum;
                float num6 = (float)battleActor2.ManaUseNum / (float)battleActor2.JobAbilityUseManaUseNum;
                if ((int)(num5 * 100f) != (int)(num6 * 100f))
                {
                    battleActor2.ManaUseNum = (int)((float)battleActor2.JobAbilityUseManaUseNum * num5 + 0.5f);
                    if (num5 < 1f && battleActor2.ManaUseNum == battleActor2.JobAbilityUseManaUseNum)
                    {
                        battleActor2.ManaUseNum--;
                    }
                }
                battleActor2.PrevUseCardAbilityAttribute = battleActor.PrevUseCardAbilityAttribute;
                battleActor2.CardAbilityInfos[4].chargeTurn = battleActor.CardAbilityInfos[4].chargeTurn;
                battleActor2.CardAbilityInfos[4].useCount = battleActor.CardAbilityInfos[4].useCount;
                battleActor2.CardAbilityInfos[4].turnUseCount = battleActor.CardAbilityInfos[4].turnUseCount;
            }
            battleActor2.State = battleActor.State;
            if (this.IsCountTimeBattle())
            {
                battleActor2.CopyActionTimeList(battleActor.ActionTimeList);
            }
            battleActor.SetWeaponEffectLoopOff();
            battleActor.LoopOffSeraResidentEffect();
            battleActor2.SetEnchantWeaponEffect();
            battleActor2.SetSeraResidentEffect();
            if (!summonEnd)
            {
                this.m_cameraManager.OnJobChange(battleActor, battleActor2);
            }
            this.m_playerActor = battleActor2;
            this.m_playerActorSub = battleActor;
            if (!loadData)
            {
                if (Mevius.Db.Api.IsSummonMode() && Mevius.DataSheet.Api.GetResidentInteger("ff10UseSummonRecast", 1) != 0)
                {
                    BattleActor battleActor3;
                    if (this.m_playerActor.IsSummon())
                    {
                        battleActor3 = this.m_playerActor;
                    }
                    else
                    {
                        battleActor3 = this.m_playerActorSub;
                    }
                    int num7;
                    int residentInteger;
                    if (this.m_playerActor == battleActor3)
                    {
                        num7 = Mevius.DataSheet.Api.GetResidentInteger("ff10DefaultSummonBackRecast", 0);
                        int num8;
                        if (battleActor3.GetAutoAbilityParam(DbManager.AutoAbilityType.AUTOABILITYTYPE_CS1835, out num8))
                        {
                            num7 += num8;
                        }
                        residentInteger = Mevius.DataSheet.Api.GetResidentInteger("ff10MinSummonBackRecast", 0);
                    }
                    else
                    {
                        num7 = Mevius.DataSheet.Api.GetResidentInteger("ff10DefaultSummonRecast", 2);
                        int num9;
                        if (battleActor3.GetAutoAbilityParam(DbManager.AutoAbilityType.AUTOABILITYTYPE_CS1834, out num9))
                        {
                            num7 += num9;
                        }
                        residentInteger = Mevius.DataSheet.Api.GetResidentInteger("ff10MinSummonRecast", 0);
                    }
                    if (num7 < residentInteger)
                    {
                        num7 = residentInteger;
                    }
                    this.PlayerJobChangeChargeTurn = (byte)num7;
                }
                else
                {
                    int num10;
                    this.m_playerActor.GetAutoAbilityParam(DbManager.AutoAbilityType.AUTOABILITYTYPE_CS1410, out num10);
                    this.PlayerJobChangeChargeTurn = (byte)num10;
                }
                if (this.m_playerActor.ActionNum == 0)
                {
                    BattleManager._i.OnEnemyNoActionPlayerActionContinue();
                }
                if (!summonEnd)
                {
                    this.m_playerActor.JobChangeIn(flag);
                }
            }
            for (int num11 = 0; num11 < this.m_actorList.Count; num11++)
            {
                BattleActor battleActor4 = this.m_actorList[num11];
                if (battleActor4 != null && battleActor4.IsEnemy() && battleActor4.IsActive())
                {
                    battleActor4.TargetActor = this.m_playerActor;
                }
            }
            if (!loadData && !summonEnd)
            {
                Mevius.Gui.Api.ShowBattleMenu(this.m_playerActor.JobType, this.m_playerActor.GetAbilityButtonInfo(), string.Empty, BattleUtility.GetJobUseAttributeArray(this.m_playerActor.Deck, this.m_playerActor.IsSummon()), this.m_playerActor.Hp, this.m_playerActor.HpMax, this.m_playerActor.ManaUseNum, this.m_playerActor.JobAbilityUseManaUseNum, true);
                string name;
                string linkageName;
                this.GetJobAbilityName(out name, out linkageName);
                Mevius.Gui.Api.SetBattleJobAbilityName(name, linkageName);
                this.m_playerActor.UpdateCardAbilityTurnCountGui();
                this.m_playerActor.UpdateStatusEffectGui(false);
                this.UpdateManaGui();
                this.m_playerActor.ElementalGauge.Reset();
                this.m_playerActor.UpdateElementalGaugeGui();
                Mevius.Gui.Api.SetBattlePlayerActionName(string.Empty);
                C8f07bc7aaef5445b9988a9d210e42418.Ca060fd76133aa5c704d976700ed7cdd9 equipmentDatasheetElem = Mevius.Db.Api.GetEquipmentDatasheetElem(Mevius.Db.Api.EQUIPMENT_TYPE.EQUIPMENT_TYPE_JOB, Mevius.Db.Api.GetParameter(DbManager.ParameterType.Current_Job) != 0, false);
                if (equipmentDatasheetElem != null)
                {
                    ElementAttributeType type = ElementAttributeType.None;
                    for (int num12 = 0; num12 <= 5; num12++)
                    {
                        if (battleActor2.IsAutoAbility(DbManager.AutoAbilityType.AUTOABILITYTYPE_CS1400 + num12))
                        {
                            type = (ElementAttributeType)num12;
                            break;
                        }
                    }
                    if (flag)
                    {
                        Mevius.Gui.Api.ShowBattlePartyChange(equipmentDatasheetElem.ma34fa63dee4ab185df72b3bbf2f2c471(), type);
                    }
                    else
                    {
                        Mevius.Gui.Api.ShowBattleJobChange(equipmentDatasheetElem.ma34fa63dee4ab185df72b3bbf2f2c471(), type);
                    }
                }
            }
            if (!summonEnd)
            {
                this.UpdateSubJobElementRing();
            }
            if (!loadData && !summonEnd)
            {
                if (!flag)
                {
                    Mevius.Effect.Api.CreateInstance(new Mevius.Effect.Api.CreateInstanceArg
                    {
                        m_strResourceName = Mevius.Effect.Api.GetResourceName(Mevius.Effect.Constants.ResourceCategory.Resident, string.Empty),
                        m_strSubResource = "change_001",
                        m_BindActor = this.m_playerActor.chara.gameObject
                    });
                }
                Mevius.Sound.Api.StopSound(this.m_jobChangeSoundHandle, 100);
                this.m_jobChangeSoundHandle = this.m_playerActor.PlayStateSound(StateSound.StateSoundType.JobChange);
                GameObject gameObject = this.m_playerActor.chara.gameObject;
                if (gameObject)
                {
                    FacialController component = gameObject.GetComponent<FacialController>();
                    if (component != null)
                    {
                        int playTime = Mevius.Sound.Api.GetPlayTime(this.m_jobChangeSoundHandle);
                        if (playTime > 0)
                        {
                            PreciseTime preciseTime = new PreciseTime((float)playTime / 1000f * 0.9f);
                            component.EnableLipsync = true;
                            component.StartLipsync(preciseTime.GetSecond());
                        }
                    }
                }
                string soundResourceName = Mevius.Sound.Api.GetSoundResourceName("Resident");
                Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Field_3D, soundResourceName, "system_se_jobchange", 1f, 0, 0, this.m_playerActor.chara.transform.position, null, false, -1, 0, 1f);
                if (this.m_isJobBgm)
                {
                    int num13 = Mevius.Db.Api.GetCurrentCardDeck();
                    if (Mevius.Db.Api.GetParameter(DbManager.ParameterType.Current_Job) != 0)
                    {
                        num13 += 12;
                    }
                    string bgmName = BattleUtility.GetBgmName(num13, this.m_bgmRandValue);
                    Mevius.Sound.Api.PlayBgm(BgmManager.BgmLayer.Bgm_Battle, bgmName, 0, 1f);
                }
                if (flag)
                {
                    BattleUtility.AddMissionCount(MissionCountType.MemberChangeCount, 1);
                }
                else
                {
                    BattleUtility.AddMissionCount(MissionCountType.JobChangeCount, 1);
                }
            }
            if (this.IsCountTimeBattle() && !loadData)
            {
                this.m_jobChangeActionGauge = this.GetJobChangeActionGauge();
                GuiBattleMenu.Instance.TimeLine.JobChangeActionGaugeAmount = this.m_jobChangeActionGauge;
                C43401f69745a04cbd6ee6dcffba76ae5.Ca4d3b5367a73030692d322e3f08669b5 ca4d3b5367a73030692d322e3f08669b = C43401f69745a04cbd6ee6dcffba76ae5.Find(this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59.mb95164dbb096f52883c4e02005721de1());
                if (ca4d3b5367a73030692d322e3f08669b != null)
                {
                    GuiBattleMenu.Instance.TimeLine.SubStrikeActionGaugeAmount = (int)ca4d3b5367a73030692d322e3f08669b.m8ffedb5dbe5912c2b2eb70f721a7dfac();
                }
                this.m_activeActionOrderActor = this.m_playerActor;
                this.CreateActionOrderList();
            }
            this.SetFairyFollowPlayer(true);
        }

        public void AddStatusEffectEnemy(BattleActor owner, int statusEffectId, int prob, int turn)
        {
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                BattleActor battleActor = this.m_actorList[i];
                if (battleActor != null && battleActor.IsEnemy() && battleActor.IsActive() && (long)prob > (long)((ulong)(Mevius.Battle.Api.GetRandomUnsignedInteger() % 100u)))
                {
                    Mevius.Gui.Constants.PopupStatusKind kind;
                    Mevius.Gui.Constants.PopupStatusEffect effect;
                    string value;
                    BattleUtility.AddStatusEffect(out kind, out effect, out value, owner, battleActor, statusEffectId, turn, BattleStatusEffect.StateType.Normal, 0, true, true);
                    if (!string.IsNullOrEmpty(value))
                    {
                        Transform transform = battleActor.chara.GetElementIdTransform(ExtensionElementIdDefinition.GetName(ExtensionElementIdDefinition.Index.MAGIC_GUARD));
                        if (!transform)
                        {
                            transform = battleActor.chara.transform;
                        }
                        Vector2 bindOffset = new Vector2(Mevius.Common.Random.GetInstance().GetSingleFloat() * 100f - 50f, Mevius.Common.Random.GetInstance().GetSingleFloat() * 100f - 50f);
                        Mevius.Gui.Api.AddStatusPopup(kind, effect, value, transform, bindOffset, true);
                        Mevius.Gui.Api.ShowPopup();
                    }
                    battleActor.UpdateStatusEffectGui(false);
                }
            }
        }

        public void CreateBreakEffect()
        {
            Mevius.Effect.Api.DestroyEffect(this.m_breakEffectHandle);
            this.m_breakEffectHandle = Mevius.Effect.Api.CreateInstance(new Mevius.Effect.Api.CreateInstanceArg
            {
                m_strResourceName = Mevius.Effect.Api.GetResourceName(Mevius.Effect.Constants.ResourceCategory.Resident, string.Empty),
                m_strSubResource = "break_fil_001"
            });
        }

        private void LoadPlayerCardResources()
        {
            BattleActor battleActor = this.FindActor(BattleManager.GetBattlePlayerName());
            this.LoadCardResource(battleActor);
            if (Mevius.App.Api.IsPartyMode())
            {
                for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
                {
                    if (this.m_multiBattleActorList[i] != null && this.m_multiBattleActorList[i].C648971f118c7e1100318b6fb7ac13b59Card != null)
                    {
                        GuiManager.Instance.cardManager.LoadRequest(int.Parse(this.m_multiBattleActorList[i].C648971f118c7e1100318b6fb7ac13b59Card.m293ab5c86c3157596fd9889d9de244b1().Substring(3)));
                    }
                }
            }
            else
            {
                GuiManager.Instance.cardManager.LoadRequest(int.Parse(battleActor.C648971f118c7e1100318b6fb7ac13b59Card.m293ab5c86c3157596fd9889d9de244b1().Substring(3)));
                BattleActor battleActor2 = this.FindActor(BattleManager.GetBattlePlayerSubName());
                if (battleActor2 != null)
                {
                    this.LoadCardResource(battleActor2);
                    GuiManager.Instance.cardManager.LoadRequest(int.Parse(battleActor2.C648971f118c7e1100318b6fb7ac13b59Card.m293ab5c86c3157596fd9889d9de244b1().Substring(3)));
                }
            }
        }

        private void LoadCardResource(BattleActor actor)
        {
            if (actor != null)
            {
                for (int i = 0; i < actor.CardAbilityInfos.Length; i++)
                {
                    if (!string.IsNullOrEmpty(actor.CardAbilityInfos[i].cardIconName))
                    {
                        GuiManager.Instance.cardManager.LoadRequest(int.Parse(actor.CardAbilityInfos[i].cardIconName.Substring(3)));
                    }
                }
            }
        }

        private void UpdateSubJobElementRing()
        {
            if (GuiBattleMenu.Instance == null)
            {
                return;
            }
            ElementAttributeType[] jobUseAttributeArray;
            if (Mevius.Db.Api.GetParameter(DbManager.ParameterType.Current_Job) != 0)
            {
                jobUseAttributeArray = BattleUtility.GetJobUseAttributeArray(Mevius.Db.Api.GetCurrentCardDeck(), false);
            }
            else
            {
                jobUseAttributeArray = BattleUtility.GetJobUseAttributeArray(Mevius.Db.Api.GetCurrentCardDeck() + 12, false);
            }
            GuiBattleMenu.Instance.SetSubJobElementalGauge(jobUseAttributeArray);
        }

        public BattleActor GetEnemyTargetActor(BattleActor actor)
        {
            BattleActor result;
            if (Mevius.App.Api.IsPartyMode())
            {
                int statusEffectProvokeParam = actor.GetStatusEffectProvokeParam();
                if (statusEffectProvokeParam != -1)
                {
                    result = this.m_multiBattleActorList[statusEffectProvokeParam];
                }
                else
                {
                    List<BattleActor> list = new List<BattleActor>();
                    List<BattleActor> list2 = new List<BattleActor>();
                    for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
                    {
                        if (this.m_multiBattleActorList[i].IsActive())
                        {
                            if ((1 << this.m_multiBattleActorList[i].PartySlot & actor.EnemyTargetIndexBit) == 0)
                            {
                                list.Add(this.m_multiBattleActorList[i]);
                            }
                            list2.Add(this.m_multiBattleActorList[i]);
                        }
                    }
                    if (list.Count == 0)
                    {
                        actor.EnemyTargetIndexBit = 0;
                        list = list2;
                    }
                    if (0 < list.Count)
                    {
                        int index = (int)((ulong)this.GetRandomUnsignedInteger() % (ulong)((long)list.Count));
                        result = list[index];
                    }
                    else
                    {
                        result = BattleManager._i.GetPlayerActor();
                    }
                }
            }
            else
            {
                result = BattleManager._i.GetPlayerActor();
            }
            return result;
        }

        public BattleActor GetEnemyTargetActorAttackAll()
        {
            BattleActor result = null;
            if (Mevius.App.Api.IsPartyMode() && 2 < this.m_multiBattleActorList.Count)
            {
                List<BattleActor> list = new List<BattleActor>();
                for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
                {
                    if (this.m_multiBattleActorList[i].IsActive())
                    {
                        list.Add(this.m_multiBattleActorList[i]);
                    }
                }
                if (2 < list.Count)
                {
                    float[,] array = new float[list.Count, 2];
                    Vector3[] array2 = new Vector3[list.Count];
                    for (int j = 0; j < list.Count; j++)
                    {
                        array[j, 0] = float.MaxValue;
                        array[j, 1] = float.MaxValue;
                        array2[j] = this.m_multiBattleActorList[j].chara.transform.position;
                        array2[j].y = 0f;
                    }
                    for (int k = 0; k < list.Count - 1; k++)
                    {
                        for (int l = k + 1; l < list.Count; l++)
                        {
                            float num = Vector3.Distance(array2[k], array2[l]);
                            int[] array3 = new int[]
                            {
                                k,
                                l
                            };
                            for (int m = 0; m < array3.Length; m++)
                            {
                                for (int n = 0; n < 2; n++)
                                {
                                    int num2 = array3[m];
                                    if (num < array[num2, n])
                                    {
                                        if (n == 0)
                                        {
                                            array[num2, n + 1] = array[num2, n];
                                        }
                                        array[num2, n] = num;
                                        break;
                                    }
                                }
                            }
                        }
                    }
                    float num3 = float.MaxValue;
                    for (int num4 = 0; num4 < list.Count; num4++)
                    {
                        float num5 = array[num4, 0] + array[num4, 1];
                        if (num5 < num3)
                        {
                            num3 = num5;
                            result = list[num4];
                        }
                    }
                }
            }
            return result;
        }

        public List<BattleActor> GetMultiBattleActorList()
        {
            return this.m_multiBattleActorList;
        }

        public BattleActor GetMultiBattleActorByIndex(int index)
        {
            if (index >= 0 && index < this.m_multiBattleActorList.Count)
            {
                return this.m_multiBattleActorList[index];
            }
            return null;
        }

        public int GetMultiBattleCurrentOrder()
        {
            return this.m_multiBattleCurrentOrder;
        }

        public BattleActor GetSelfActor()
        {
            if (Mevius.App.Api.IsPartyMode())
            {
                return this.m_selfActor;
            }
            return this.GetPlayerActor();
        }

        public void SetPlayerActionPass()
        {
            if (this.m_selfActor == this.m_playerActor && !this.m_selfActor.CommandInputEnd)
            {
                if (Mevius.Party.Api.HasCommandStock())
                {
                    Mevius.Gui.Api.OnEndInput(Mevius.Gui.Api.EndInputType.ActionFinished);
                }
                else
                {
                    Mevius.Gui.Api.OnEndInput(Mevius.Gui.Api.EndInputType.Pass);
                }
                this.m_selfActor.UseActionPass(false, false);
                this.EndSlow();
            }
        }

        private void UpdateMultiBattleCmd()
        {
            if (!Mevius.App.Api.IsPartyMode())
            {
                return;
            }
            if (Mevius.App.Api.IsPartyMode() && Mevius.Party.Api.IsExitPlayer())
            {
                this.Step = BattleManager.BattleStep.Escape;
                return;
            }
            if (Mevius.Party.Api.IsExistForceSnap())
            {
                Mevius.Party.Api.ClearCommandStock();
                int[] array = new int[8];
                for (int i = 0; i < this._entryBattleCharaSpecList.Count; i++)
                {
                    string enemyActorName = BattleManager.GetEnemyActorName(i);
                    BattleActor battleActor = this.FindActor(enemyActorName);
                    if (battleActor != null)
                    {
                        array[i] = battleActor.Hp;
                    }
                }
                Mevius.Party.Api.SetUpSnap(true, true, this.m_selfActor.Hp, this.m_selfActor.ManaElements, array);
                this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.SnapSyncWait;
                return;
            }
            if (this.m_snapType == Mevius.Party.Api.SnapStepType.SnapStepType_NONE)
            {
                this.m_snapType = Mevius.Party.Api.GetSnapStepType();
            }
            switch (this.m_multiBattleCmdStep)
            {
            case BattleManager.MultiBattleCmdStep.SendSnap:
                if (!Mevius.Party.Api.IsWaitSendSnap())
                {
                    Mevius.Party.Api.SendSnap();
                    this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.SnapSync;
                }
                break;
            case BattleManager.MultiBattleCmdStep.SnapSync:
                if (Mevius.Party.Api.IsExistNextSnap())
                {
                    int[] array2 = new int[8];
                    for (int j = 0; j < this._entryBattleCharaSpecList.Count; j++)
                    {
                        string enemyActorName2 = BattleManager.GetEnemyActorName(j);
                        BattleActor battleActor2 = this.FindActor(enemyActorName2);
                        if (battleActor2 != null)
                        {
                            array2[j] = battleActor2.Hp;
                        }
                    }
                    Mevius.Party.Api.SetUpSnap(true, true, this.m_selfActor.Hp, this.m_selfActor.ManaElements, array2);
                    this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                    this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.SnapSyncWait;
                }
                else if (Mevius.Party.Api.IsNeedSendSnap(true))
                {
                    this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.SendSnap;
                }
                break;
            case BattleManager.MultiBattleCmdStep.SnapSyncWait:
                if (!Mevius.Party.Api.WaitPartySnap(true))
                {
                    Mevius.Party.Api.SetUpSnapHp();
                    this.RestoreMultiData(false);
                    this.m_snapType = Mevius.Party.Api.GetSnapStepType();
                    switch (this.m_snapType)
                    {
                    case Mevius.Party.Api.SnapStepType.SnapStepType_INIT:
                        this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.CurrentPlayer;
                        break;
                    case Mevius.Party.Api.SnapStepType.SnapStepType_INPUT:
                        this.SetCurrentTarget(this.m_selfActor.TargetActor);
                        this.m_partyMemberTurn = false;
                        this.HideBattleEnemyActionName();
                        this._step = BattleManager.BattleStep.MultiBattleInputStart;
                        break;
                    case Mevius.Party.Api.SnapStepType.SnapStepType_PARTY:
                    {
                        this.m_randCount = 0;
                        this.m_damageRandCount = 0;
                        this.m_movementRandCount = 0;
                        this.m_multiBattleSlotList.Clear();
                        int[] partyType = Mevius.Party.Api.GetPartyType();
                        for (int k = 0; k < partyType.Length; k++)
                        {
                            if (partyType[k] != 4)
                            {
                                int num = k;
                                ulong partyCommandTime = Mevius.Party.Api.GetPartyCommandTime(num);
                                if (partyCommandTime != 0UL)
                                {
                                    int[,] commandStock = Mevius.Party.Api.GetCommandStock(num, true);
                                    bool flag = true;
                                    for (int l = 0; l < commandStock.GetLength(0); l++)
                                    {
                                        if (commandStock[l, 0] >= 1 && commandStock[l, 0] <= 4)
                                        {
                                            flag = false;
                                            break;
                                        }
                                    }
                                    if (flag)
                                    {
                                        for (int m = 0; m < this.m_multiBattleActorList.Count; m++)
                                        {
                                            BattleActor battleActor3 = this.m_multiBattleActorList[m];
                                            if (battleActor3.PartySlot == num && battleActor3.IsPlayer() && battleActor3.IsActive())
                                            {
                                                battleActor3.UseActionPass(flag, false);
                                                break;
                                            }
                                        }
                                    }
                                    else
                                    {
                                        int index = 0;
                                        bool flag2 = false;
                                        for (int n = 0; n < this.m_multiBattleSlotList.Count; n++)
                                        {
                                            if (partyCommandTime < Mevius.Party.Api.GetPartyCommandTime(this.m_multiBattleSlotList[n]))
                                            {
                                                flag2 = true;
                                                index = n;
                                                break;
                                            }
                                        }
                                        if (flag2)
                                        {
                                            this.m_multiBattleSlotList.Insert(index, num);
                                        }
                                        else
                                        {
                                            this.m_multiBattleSlotList.Add(num);
                                        }
                                    }
                                }
                            }
                        }
                        Mevius.Gui.Api.OnFinishCommand();
                        this.HideBattleEnemyActionName();
                        this._step = BattleManager.BattleStep.PlayerTurnStart;
                        break;
                    }
                    case Mevius.Party.Api.SnapStepType.SnapStepType_ENEMY:
                        this.m_randCount = 0;
                        this.m_damageRandCount = 0;
                        this.m_movementRandCount = 0;
                        this.SetCurrentTarget(this.m_selfActor.TargetActor);
                        this.HideBattleEnemyActionName();
                        this._step = BattleManager.BattleStep.EnemyTurnStart;
                        break;
                    case Mevius.Party.Api.SnapStepType.SnapStepType_UNINIT:
                        if (this.m_lastBattle && !this.m_lastBgmVolumeChanged)
                        {
                            this.m_lastBgmVolumeChanged = true;
                            BgmManager._i.ChangeCurrentBgmVolume(Mevius.DataSheet.Api.GetResidentFloat("bgmBattleVolumeOnWinning", 1f), 500);
                        }
                        Mevius.Party.Api.ClearCommandStock();
                        this.SetBattleWinImmediate(true);
                        break;
                    }
                    this.m_multiBattleTurnStartTime = Mevius.Party.Api.GetBeginLimitTime();
                    this.m_multiBattleTurnLimitTime = (ulong)Mevius.Party.Api.GetBaseLimitTime();
                    this.m_multiBattleStartTime = Mevius.Party.Api.GetBeginBattleTime();
                }
                else if (Mevius.Party.Api.IsExistNextSnap())
                {
                    int[] array3 = new int[8];
                    for (int num2 = 0; num2 < this._entryBattleCharaSpecList.Count; num2++)
                    {
                        string enemyActorName3 = BattleManager.GetEnemyActorName(num2);
                        BattleActor battleActor4 = this.FindActor(enemyActorName3);
                        if (battleActor4 != null)
                        {
                            array3[num2] = battleActor4.Hp;
                        }
                    }
                    Mevius.Party.Api.SetUpSnap(true, true, this.m_selfActor.Hp, this.m_selfActor.ManaElements, array3);
                    this._step = BattleManager.BattleStep.CheckMultiBattleCmd;
                    this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.SnapSyncWait;
                }
                break;
            case BattleManager.MultiBattleCmdStep.MultiInputWait:
                if (Mevius.Party.Api.IsNeedRevivalStep())
                {
                    for (int num3 = 0; num3 < this.m_multiBattleActorList.Count; num3++)
                    {
                        if (Mevius.Party.Api.ExecRevivalSlot(this.m_multiBattleActorList[num3].PartySlot) != Mevius.Party.Api.ExecRevival.ExecRevival_NONE && this.m_multiBattleActorList[num3].IsDead())
                        {
                            this.m_multiBattleActorList[num3].OnRevive();
                            this.m_multiBattleActorList[num3].OnTurnBegin();
                            if (this.m_multiBattleActorList[num3].ReadyAction())
                            {
                            }
                            if (this.m_multiBattleActorList[num3].PartyMemberType == Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_ME)
                            {
                                Mevius.Gui.Api.HidePlayerDeadTimer();
                            }
                        }
                    }
                    this.m_multiBattleTurnStartTime = Mevius.Party.Api.GetBeginLimitTime();
                    this.m_multiBattleTurnLimitTime = (ulong)Mevius.Party.Api.GetBaseLimitTime();
                    this.m_multiBattleStartTime = Mevius.Party.Api.GetBeginBattleTime();
                }
                if (Mevius.Party.Api.IsNeedSendSnap(true))
                {
                    for (int num4 = 0; num4 < this.m_multiBattleActorList.Count; num4++)
                    {
                        BattleActor battleActor5 = this.m_multiBattleActorList[num4];
                        if (battleActor5.PartyMemberType != Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_EMPTY && battleActor5.PartyMemberType != Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_ME)
                        {
                            if (!battleActor5.IsDead())
                            {
                                if (Mevius.Party.Api.IsAutoAiStatus(battleActor5.PartySlot) && !battleActor5.CommandInputEnd)
                                {
                                    battleActor5.AutoAbilityAttackMulti();
                                }
                            }
                        }
                    }
                }
                if (Mevius.Party.Api.IsFinishCommand())
                {
                    for (int num5 = 0; num5 < this.m_multiBattleActorList.Count; num5++)
                    {
                        BattleActor battleActor6 = this.m_multiBattleActorList[num5];
                        if (battleActor6.PartyMemberType != Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_EMPTY && battleActor6.PartyMemberType != Mevius.Party.Api.PARTY_MEMBER_TYPE.PARTY_MEMBER_TYPE_ME)
                        {
                            battleActor6.EndMultiBattleInput();
                        }
                    }
                    for (int num6 = 0; num6 < this.m_multiBattleActorList.Count; num6++)
                    {
                        PartyCommonSaveData.PartyCommandType commandDecideIndex = Mevius.Party.Api.GetCommandDecideIndex(this.m_multiBattleActorList[num6].PartySlot);
                        if (PartyCommonSaveData.PartyCommandType.DECIDE1 <= commandDecideIndex && commandDecideIndex <= PartyCommonSaveData.PartyCommandType.DECIDE4)
                        {
                            this.m_multiBattleActorList[num6].ActionOrder = (byte)(commandDecideIndex - PartyCommonSaveData.PartyCommandType.DECIDE1 + 1);
                        }
                        else
                        {
                            this.m_multiBattleActorList[num6].ActionOrder = 0;
                        }
                    }
                    this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.CurrentPlayer;
                }
                break;
            case BattleManager.MultiBattleCmdStep.CurrentPlayer:
                if (Mevius.Party.Api.IsNeedSendSnap(true))
                {
                    this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.SendSnap;
                }
                else
                {
                    this.m_multiBattleCmdStep = BattleManager.MultiBattleCmdStep.SnapSync;
                }
                this.SaveMultiData();
                break;
            }
        }

        public BattleManaObjectManager BattleManaObjectManager
        {
            get
            {
                return this.m_manaObjectManager;
            }
        }

        public void SaveMultiData()
        {
            DbManager.MultiBattleData multiBattleData = Mevius.Db.Api.GetMultiBattleData();
            if (multiBattleData == null)
            {
                return;
            }
            this.SetRandomSeed(false);
            multiBattleData.version = BattleManager.MultiSaveDataVersion;
            multiBattleData.step = (int)this._step;
            multiBattleData.turnNum = this.m_turnNum;
            multiBattleData.chainNum = this.m_chainNum;
            multiBattleData.breakNum = this.m_breakNum;
            multiBattleData.deadNum = this.m_deadNum;
            Array.Clear(multiBattleData.statusEffectIds, 0, multiBattleData.statusEffectIds.Length);
            Array.Clear(multiBattleData.statusEffectTurns, 0, multiBattleData.statusEffectTurns.Length);
            Array.Clear(multiBattleData.statusEffectStates, 0, multiBattleData.statusEffectStates.Length);
            Array.Clear(multiBattleData.statusEffectParams, 0, multiBattleData.statusEffectParams.Length);
            for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
            {
                BattleActor battleActor = this.m_multiBattleActorList[i];
                int partySlot = battleActor.PartySlot;
                multiBattleData.playerHp[partySlot] = battleActor.Hp;
                multiBattleData.playerActionNum[partySlot] = (byte)battleActor.ActionNum;
                multiBattleData.playerNormalAttackNum[partySlot] = (byte)battleActor.NormalAttackNum;
                if (battleActor.PrevUseCardAbilityAttribute != ElementAttributeType.None)
                {
                    multiBattleData.prevUseCardAbilityAttributeBit[partySlot] = (ushort)(1 << (int)battleActor.PrevUseCardAbilityAttribute);
                }
                else
                {
                    multiBattleData.prevUseCardAbilityAttributeBit[partySlot] = 0;
                }
                multiBattleData.playerActionOrder[partySlot] = battleActor.ActionOrder;
                for (int j = 0; j < battleActor.PinchAutoAbilityFlags.Length; j++)
                {
                    multiBattleData.autoAbilityPinchFlags[partySlot, j] = battleActor.PinchAutoAbilityFlags[j];
                }
                int[,] statusEffectEntries = battleActor.GetStatusEffectEntries();
                for (int k = 0; k < statusEffectEntries.GetLength(0); k++)
                {
                    multiBattleData.statusEffectIds[partySlot, k] = (ushort)statusEffectEntries[k, 0];
                    multiBattleData.statusEffectTurns[partySlot, k] = (sbyte)statusEffectEntries[k, 1];
                    multiBattleData.statusEffectStates[partySlot, k] = (byte)statusEffectEntries[k, 2];
                    multiBattleData.statusEffectParams[partySlot, k] = statusEffectEntries[k, 3];
                }
                BattleActor.CardAbilityInfo[] cardAbilityInfos = battleActor.CardAbilityInfos;
                for (int l = 0; l < cardAbilityInfos.Length; l++)
                {
                    multiBattleData.cardAbilityChargeTurns[partySlot, l] = (sbyte)cardAbilityInfos[l].chargeTurn;
                    multiBattleData.cardAbilityUseCounts[partySlot, l] = (ushort)cardAbilityInfos[l].useCount;
                }
                multiBattleData.unRecoveryNum[partySlot] = (byte)battleActor.GetManaUnRecoveryNum();
                ElementAttributeType[] manaElements = battleActor.ManaElements;
                for (int m = 0; m < multiBattleData.manaElements.GetLength(1); m++)
                {
                    if (m < manaElements.Length)
                    {
                        multiBattleData.manaElements[partySlot, m] = (int)manaElements[m];
                    }
                    else
                    {
                        multiBattleData.manaElements[partySlot, m] = -1;
                    }
                }
                int[] originalValues = battleActor.ElementalGauge.GetOriginalValues();
                for (int n = 0; n < originalValues.Length; n++)
                {
                    multiBattleData.elementalGauge[partySlot, n] = (ushort)originalValues[n];
                }
                multiBattleData.manaUseNum[partySlot] = battleActor.ManaUseNum;
                for (int num = 0; num < battleActor.RevengeDamages.Length; num++)
                {
                    multiBattleData.playerRevengeDamages[partySlot, num] = battleActor.RevengeDamages[num];
                }
                multiBattleData.abilityUseSuportCounts[partySlot] = battleActor.AbilityUseSuportCount;
            }
            multiBattleData.playerActionType[0] = (byte)this.m_randCount;
            multiBattleData.playerActionType[1] = (byte)this.m_damageRandCount;
            multiBattleData.playerActionType[2] = (byte)this.m_movementRandCount;
            Array.Clear(multiBattleData.enemyStatusEffectIds, 0, multiBattleData.enemyStatusEffectIds.Length);
            Array.Clear(multiBattleData.enemyStatusEffectTurns, 0, multiBattleData.enemyStatusEffectIds.Length);
            Array.Clear(multiBattleData.enemyStatusEffectStates, 0, multiBattleData.enemyStatusEffectIds.Length);
            Array.Clear(multiBattleData.enemyStatusEffectParams, 0, multiBattleData.enemyStatusEffectIds.Length);
            for (int num2 = 0; num2 < this._entryBattleCharaSpecList.Count; num2++)
            {
                string enemyActorName = BattleManager.GetEnemyActorName(num2);
                BattleActor battleActor2 = this.FindActor(enemyActorName);
                if (battleActor2 != null)
                {
                    multiBattleData.enemyHps[num2] = battleActor2.Hp;
                    multiBattleData.enemyBps[num2] = battleActor2.Bp;
                    multiBattleData.enemyBpArmorDamages[num2] = battleActor2.BpArmorDamage;
                    multiBattleData.enemyBreakCounts[num2] = (byte)battleActor2.BreakCount;
                    if (battleActor2.Ai != null)
                    {
                        for (int num3 = 0; num3 < 16; num3++)
                        {
                            multiBattleData.enemyAiCounters[num2, num3] = battleActor2.Ai.Counters[num3];
                        }
                        multiBattleData.enemyAiFlags[num2] = battleActor2.Ai.Flag;
                        multiBattleData.enemyAiSpCounters[num2] = battleActor2.Ai.SpCounter;
                        multiBattleData.enemyAiTakeDamageBit[num2] = battleActor2.Ai.TakeDamageBit;
                        multiBattleData.enemyAiTakeDamageAttributeBit[num2] = battleActor2.Ai.TakeDamageAttributeBit;
                    }
                    multiBattleData.enemyAttributeBit[num2] = battleActor2.ElementAttributeBit;
                    multiBattleData.enemyUnknownAttribute[num2] = battleActor2.UnknownAttribute;
                    multiBattleData.enemyAbsorbAttributeBit[num2] = battleActor2.AbsorbAttributeBit;
                    multiBattleData.enemyChangeBtCharaSpecId[num2] = battleActor2.ChangeBtCharaSpecId;
                    int[,] statusEffectEntries2 = battleActor2.GetStatusEffectEntries();
                    int num4 = Math.Min(statusEffectEntries2.GetLength(0), multiBattleData.enemyStatusEffectIds.GetLength(1));
                    for (int num5 = 0; num5 < num4; num5++)
                    {
                        multiBattleData.enemyStatusEffectIds[num2, num5] = (ushort)statusEffectEntries2[num5, 0];
                        multiBattleData.enemyStatusEffectTurns[num2, num5] = (sbyte)statusEffectEntries2[num5, 1];
                        multiBattleData.enemyStatusEffectStates[num2, num5] = (byte)statusEffectEntries2[num5, 2];
                        multiBattleData.enemyStatusEffectParams[num2, num5] = statusEffectEntries2[num5, 3];
                    }
                    byte[] debuffInvalidCounts = battleActor2.DebuffInvalidCounts;
                    for (int num6 = 0; num6 < debuffInvalidCounts.Length; num6++)
                    {
                        multiBattleData.enemyDebuffInvalidCounts[num2, num6] = debuffInvalidCounts[num6];
                    }
                    multiBattleData.enemyBoss[num2] = ((!battleActor2.IsNeedNotKill()) ? 1 : 0);
                    multiBattleData.enemyHpLimitIndexs[num2] = battleActor2.HpLimitIndex;
                    multiBattleData.enemySaveFlagBits[num2] = (uint)battleActor2.SaveFlagBits;
                    multiBattleData.enemyDamagedActorIndexBits[num2] = battleActor2.EnemyDamagedActorIndexBit;
                    multiBattleData.enemyHpGaugeFixRates[num2] = battleActor2.EnemyHpGaugeFixRate;
                }
            }
            this.m_enemyAiCommonCounters.CopyTo(multiBattleData.enemyAiCommonCounters, 0);
            multiBattleData.enemyActionEndFlag = this.m_enemyActionEndFlag;
        }

        public void RestoreMultiData(bool bInit = false)
        {
            DbManager.MultiBattleData multiBattleData = Mevius.Db.Api.GetMultiBattleData();
            if (multiBattleData == null)
            {
                return;
            }
            bool flag = false;
            if (DebugOutput.Instance != null)
            {
                flag = true;
            }
            bool restart = !Mevius.Party.Api.IsFirstSnap() && bInit;
            uint randSeed = multiBattleData.randSeed;
            this._step = (BattleManager.BattleStep)multiBattleData.step;
            this.m_rand.SetSeed(randSeed);
            this.m_playerDamageRand.SetSeed(randSeed);
            this.m_playerMovementRand.SetSeed(randSeed);
            this.m_turnNum = multiBattleData.turnNum;
            this.m_chainNum = multiBattleData.chainNum;
            this.m_breakNum = multiBattleData.breakNum;
            this.m_deadNum = multiBattleData.deadNum;
            for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
            {
                BattleActor battleActor = this.m_multiBattleActorList[i];
                int partySlot = battleActor.PartySlot;
                int hp = battleActor.Hp;
                battleActor.SetHp(multiBattleData.playerHp[partySlot], true, true);
                if (hp <= 0 && multiBattleData.playerHp[partySlot] > 0)
                {
                    battleActor.OnRestore(this._step, false, true, restart);
                }
                else if (hp > 0 && multiBattleData.playerHp[partySlot] <= 0)
                {
                    battleActor.OnRestore(this._step, false, true, restart);
                }
                else if (bInit)
                {
                    battleActor.OnRestore(this._step, false, true, restart);
                }
                if (flag && hp != multiBattleData.playerHp[partySlot])
                {
                    string item = string.Format("Hp [{0}] -> [{1}] : Slot[{2}]", hp, multiBattleData.playerHp[partySlot], partySlot);
                    DebugOutput.Instance.ErrorLogList.Add(item);
                }
                if (flag && battleActor.ActionNum != (int)multiBattleData.playerActionNum[partySlot])
                {
                    string item2 = string.Format("ActionNum [{0}] -> [{1}] : Slot[{2}]", battleActor.ActionNum, multiBattleData.playerActionNum[partySlot], partySlot);
                    DebugOutput.Instance.ErrorLogList.Add(item2);
                }
                battleActor.ActionNum = (int)multiBattleData.playerActionNum[partySlot];
                battleActor.NormalAttackNum = (int)multiBattleData.playerNormalAttackNum[partySlot];
                for (int j = 0; j < 7; j++)
                {
                    if (((int)multiBattleData.prevUseCardAbilityAttributeBit[partySlot] & 1 << j) != 0)
                    {
                        battleActor.PrevUseCardAbilityAttribute = (ElementAttributeType)j;
                    }
                }
                battleActor.ActionOrder = multiBattleData.playerActionOrder[partySlot];
                bool[] array = new bool[multiBattleData.autoAbilityPinchFlags.GetLength(1)];
                for (int k = 0; k < array.Length; k++)
                {
                    array[k] = multiBattleData.autoAbilityPinchFlags[partySlot, k];
                }
                battleActor.SetPinchAutoAbilityFlags(array);
                int length = multiBattleData.statusEffectIds.GetLength(1);
                int[][] array2 = new int[length][];
                for (int l = 0; l < length; l++)
                {
                    if (multiBattleData.statusEffectIds[partySlot, l] != 0)
                    {
                        array2[l] = new int[4];
                        array2[l][0] = (int)multiBattleData.statusEffectIds[partySlot, l];
                        array2[l][1] = (int)multiBattleData.statusEffectTurns[partySlot, l];
                        array2[l][2] = (int)multiBattleData.statusEffectStates[partySlot, l];
                        array2[l][3] = multiBattleData.statusEffectParams[partySlot, l];
                    }
                }
                battleActor.SetStatusEffectEntries(array2);
                BattleActor.CardAbilityInfo[] cardAbilityInfos = battleActor.CardAbilityInfos;
                for (int m = 0; m < cardAbilityInfos.Length; m++)
                {
                    cardAbilityInfos[m].chargeTurn = (int)multiBattleData.cardAbilityChargeTurns[partySlot, m];
                    cardAbilityInfos[m].useCount = (int)multiBattleData.cardAbilityUseCounts[partySlot, m];
                }
                battleActor.SetManaUnRecoveryNum((int)multiBattleData.unRecoveryNum[partySlot]);
                int[] array3 = new int[multiBattleData.manaElements.GetLength(1)];
                for (int n = 0; n < array3.Length; n++)
                {
                    array3[n] = multiBattleData.manaElements[partySlot, n];
                }
                if (flag)
                {
                    bool flag2 = false;
                    ElementAttributeType[] manaElements = battleActor.GetManaElements();
                    for (int num = 0; num < manaElements.Length; num++)
                    {
                        if (manaElements[num] != (ElementAttributeType)array3[num])
                        {
                            flag2 = true;
                            break;
                        }
                    }
                    if (flag2)
                    {
                        long num2 = 0L;
                        for (int num3 = 0; num3 < 16; num3++)
                        {
                            long num4 = (num3 >= manaElements.Length) ? 0L : ((long)manaElements[num3] + 1L);
                            num2 = num2 * 10L + num4;
                        }
                        long num5 = 0L;
                        for (int num6 = 0; num6 < 16; num6++)
                        {
                            long num7 = (num6 >= array3.Length) ? 0L : ((long)array3[num6] + 1L);
                            num5 = num5 * 10L + num7;
                        }
                        string item3 = string.Format("Element [{0}] -> [{1}] : Slot[{2}]", num2, num5, partySlot);
                        DebugOutput.Instance.ErrorLogList.Add(item3);
                    }
                }
                battleActor.SetManaElement(array3);
                int[] array4 = new int[multiBattleData.elementalGauge.GetLength(1)];
                for (int num8 = 0; num8 < array4.Length; num8++)
                {
                    array4[num8] = (int)multiBattleData.elementalGauge[partySlot, num8];
                }
                battleActor.ElementalGauge.Init(array4);
                battleActor.ManaUseNum = multiBattleData.manaUseNum[partySlot];
                for (int num9 = 0; num9 < battleActor.RevengeDamages.Length; num9++)
                {
                    battleActor.RevengeDamages[num9] = multiBattleData.playerRevengeDamages[partySlot, num9];
                }
                battleActor.AbilityUseSuportCount = multiBattleData.abilityUseSuportCounts[partySlot];
            }
            int num10 = (int)multiBattleData.playerActionType[0];
            int num11 = (int)multiBattleData.playerActionType[1];
            int num12 = (int)multiBattleData.playerActionType[2];
            if (flag)
            {
                if (num10 != this.m_randCount)
                {
                    string item4 = string.Format("RandCount [{0}] -> [{1}]", this.m_randCount, num10);
                    DebugOutput.Instance.ErrorLogList.Add(item4);
                }
                if (num11 != this.m_damageRandCount)
                {
                    string item5 = string.Format("damageRandCount [{0}] -> [{1}]", this.m_damageRandCount, num11);
                    DebugOutput.Instance.ErrorLogList.Add(item5);
                }
                if (num12 != this.m_movementRandCount)
                {
                    string item6 = string.Format("movementRandCount [{0}] -> [{1}]", this.m_movementRandCount, num12);
                    DebugOutput.Instance.ErrorLogList.Add(item6);
                }
            }
            this.UpdateManaGui();
            this.UpdateJobAbilityGauge();
            this.m_selfActor.UpdateCardAbilityTurnCountGui();
            this.m_selfActor.UpdateStatusEffectGui(false);
            for (int num13 = 0; num13 < this._entryBattleCharaSpecList.Count; num13++)
            {
                string enemyActorName = BattleManager.GetEnemyActorName(num13);
                BattleActor battleActor2 = this.FindActor(enemyActorName);
                if (battleActor2 != null)
                {
                    int hp2 = battleActor2.Hp;
                    battleActor2.SetHp(multiBattleData.enemyHps[num13], false, false);
                    int bp = battleActor2.Bp;
                    battleActor2.Bp = multiBattleData.enemyBps[num13];
                    uint saveFlagBits = (uint)battleActor2.SaveFlagBits;
                    battleActor2.SaveFlagBits = (BattleActor.SaveFlagBitType)multiBattleData.enemySaveFlagBits[num13];
                    if (hp2 <= 0 && multiBattleData.enemyHps[num13] > 0)
                    {
                        battleActor2.chara.gameObject.SetActive(true);
                        battleActor2.chara.SetupBind();
                        battleActor2.SetStateIdle(true, -1, 0);
                        battleActor2.OnRestore(this._step, false, true, restart);
                        battleActor2.CreateEnemyHpGauge();
                    }
                    else if (hp2 > 0 && multiBattleData.enemyHps[num13] <= 0)
                    {
                        battleActor2.OnRestore(this._step, false, true, restart);
                    }
                    else if (bp != multiBattleData.enemyBps[num13])
                    {
                        battleActor2.OnRestore(this._step, false, true, restart);
                    }
                    else if (bInit)
                    {
                        battleActor2.OnRestore(this._step, false, true, restart);
                    }
                    else if (saveFlagBits != (uint)battleActor2.SaveFlagBits)
                    {
                        battleActor2.OnRestore(this._step, false, true, restart);
                        if (battleActor2.IsActiveTarget())
                        {
                            battleActor2.CreateEnemyHpGauge();
                        }
                    }
                    if (flag)
                    {
                        if (hp2 != multiBattleData.enemyHps[num13])
                        {
                            string item7 = string.Format("Hp [{0}] -> [{1}] : Enemy[{2}]", hp2, multiBattleData.enemyHps[num13], num13);
                            DebugOutput.Instance.ErrorLogList.Add(item7);
                        }
                        if (bp != multiBattleData.enemyBps[num13])
                        {
                            string item8 = string.Format("Bp [{0}] -> [{1}] : Enemy[{2}]", bp, multiBattleData.enemyBps[num13], num13);
                            DebugOutput.Instance.ErrorLogList.Add(item8);
                        }
                    }
                    battleActor2.BreakCount = (int)multiBattleData.enemyBreakCounts[num13];
                    battleActor2.BpArmorDamage = multiBattleData.enemyBpArmorDamages[num13];
                    if (battleActor2.Ai != null)
                    {
                        for (int num14 = 0; num14 < 16; num14++)
                        {
                            battleActor2.Ai.Counters[num14] = multiBattleData.enemyAiCounters[num13, num14];
                        }
                        battleActor2.Ai.Flag = multiBattleData.enemyAiFlags[num13];
                        battleActor2.Ai.SpCounter = multiBattleData.enemyAiSpCounters[num13];
                        battleActor2.Ai.TakeDamageBit = multiBattleData.enemyAiTakeDamageBit[num13];
                        battleActor2.Ai.TakeDamageAttributeBit = multiBattleData.enemyAiTakeDamageAttributeBit[num13];
                    }
                    battleActor2.ElementAttributeBit = multiBattleData.enemyAttributeBit[num13];
                    if (multiBattleData.enemyAbsorbAttributeBit[num13] != 0)
                    {
                        battleActor2.AbsorbAttributeBit = multiBattleData.enemyAbsorbAttributeBit[num13];
                    }
                    battleActor2.UnknownAttribute = multiBattleData.enemyUnknownAttribute[num13];
                    battleActor2.SetChangeBtCharaSpecId(multiBattleData.enemyChangeBtCharaSpecId[num13], true);
                    List<int[]> list = new List<int[]>();
                    for (int num15 = 0; num15 < multiBattleData.enemyStatusEffectIds.GetLength(1); num15++)
                    {
                        if (multiBattleData.enemyStatusEffectIds[num13, num15] != 0)
                        {
                            list.Add(new int[]
                            {
                                (int)multiBattleData.enemyStatusEffectIds[num13, num15],
                                (int)multiBattleData.enemyStatusEffectTurns[num13, num15],
                                (int)multiBattleData.enemyStatusEffectStates[num13, num15],
                                multiBattleData.enemyStatusEffectParams[num13, num15]
                            });
                        }
                    }
                    battleActor2.SetStatusEffectEntries(list.ToArray());
                    for (int num16 = 0; num16 < multiBattleData.enemyDebuffInvalidCounts.GetLength(1); num16++)
                    {
                        battleActor2.SetDebuffInvalidCount(num16, multiBattleData.enemyDebuffInvalidCounts[num13, num16]);
                    }
                    battleActor2.HpLimitIndex = multiBattleData.enemyHpLimitIndexs[num13];
                    battleActor2.EnemyDamagedActorIndexBit = multiBattleData.enemyDamagedActorIndexBits[num13];
                    battleActor2.EnemyHpGaugeFixRate = multiBattleData.enemyHpGaugeFixRates[num13];
                    battleActor2.UpdateHpGaugeFixRate();
                    if (battleActor2.Ai != null)
                    {
                        battleActor2.Ai.OnBehavior(BattleAiData.Pattern.TimingType.BattleRestart, string.Empty, null, true);
                    }
                }
            }
            multiBattleData.enemyAiCommonCounters.CopyTo(this.m_enemyAiCommonCounters, 0);
            this.m_enemyActionEndFlag = multiBattleData.enemyActionEndFlag;
            this.m_rand.SetSeed(randSeed);
            this.m_playerDamageRand.SetSeed(randSeed);
            this.m_playerMovementRand.SetSeed(randSeed);
            this.ProcManToMan();
        }

        public int MultiBattleTimeLeftOfTurn
        {
            get
            {
                ulong realtimeFromServer = Mevius.Db.Api.GetRealtimeFromServer();
                if (realtimeFromServer >= this.m_multiBattleTurnStartTime)
                {
                    ulong num = realtimeFromServer - this.m_multiBattleTurnStartTime;
                    ulong num2 = (num > this.m_multiBattleTurnLimitTime) ? 0UL : (this.m_multiBattleTurnLimitTime - num);
                    return (int)num2;
                }
                return (int)this.m_multiBattleTurnLimitTime;
            }
        }

        public int MultiBattleTimeLeft
        {
            get
            {
                ulong realtimeFromServer = Mevius.Db.Api.GetRealtimeFromServer();
                if (realtimeFromServer >= this.m_multiBattleStartTime)
                {
                    ulong num = realtimeFromServer - this.m_multiBattleStartTime;
                    ulong num2 = (num > (ulong)Mevius.Party.Api.GetBaseBattleTime()) ? 0UL : ((ulong)Mevius.Party.Api.GetBaseBattleTime() - num);
                    return (int)num2;
                }
                return (int)Mevius.Party.Api.GetBaseBattleTime();
            }
        }

        public string GetPlayerCommandStr()
        {
            return this.GetSelfActor().CommandStr;
        }

        public void CancelMultiBattleCommand()
        {
            if (this.m_selfActor != null)
            {
                this.m_selfActor.CancelMultiBattleCommand();
            }
        }

        public int GetTargetGlobalIndex(BattleActor actor)
        {
            if (this.m_actorList.Contains(actor))
            {
                return this.m_actorList.IndexOf(actor);
            }
            return -1;
        }

        public BattleActor GetTargetByGlobalIndex(int globalIndex)
        {
            if (globalIndex < 0 || globalIndex >= this.m_actorList.Count)
            {
                return null;
            }
            return this.m_actorList[globalIndex];
        }

        public void OnDead(BattleActor actor)
        {
            if (Mevius.App.Api.IsPartyMode() && this.GetEnemyNum(true) == 0 && !actor.IsNeedNotKill())
            {
                this.m_cameraManager.SetInterpolation(0f, CameraSequence.BlendType.Curve, true);
                this.m_cameraManager.InitAction("a_samon_Death1", actor, false, true);
                this.m_cameraManager.ChangeCamera(BattleCameraManager.CameraType.Action);
                this.m_isMultiFinishCamera = true;
                string residentString = Mevius.DataSheet.Api.GetResidentString("multi_battleWinSe", string.Empty);
                string soundResourceName = Mevius.Sound.Api.GetSoundResourceName("Resident");
                Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Field, soundResourceName, residentString, 1f, 0, 0, false, -1, 1f);
            }
            if (this.IsCountTimeBattle())
            {
                this.CreateActionOrderList();
            }
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                if (this.m_actorList[i].IsActive() && !this.m_actorList[i].IsParty(actor))
                {
                    this.m_actorList[i].RemoveStatusEffectProvoke(actor.GetActorIndex());
                }
            }
            this.ProcManToMan();
        }

        public bool IsMultiFinishCamera()
        {
            return this.m_isMultiFinishCamera;
        }

        public BattleActor GetMultiRangeAttackEnemyActor(BattleActor baseActor)
        {
            BattleActor result = null;
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                BattleActor battleActor = this.m_actorList[i];
                if (battleActor != null && battleActor.IsActiveTarget() && battleActor.IsParty(baseActor) && battleActor != baseActor)
                {
                    result = battleActor;
                    break;
                }
            }
            return result;
        }

        public bool IsActionOrder(BattleActor actor, int order)
        {
            bool result = false;
            if (actor.IsPlayer())
            {
                int num = 0;
                for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
                {
                    if (this.m_multiBattleActorList[i].IsActive() && num < (int)this.m_multiBattleActorList[i].ActionOrder)
                    {
                        num = (int)this.m_multiBattleActorList[i].ActionOrder;
                    }
                }
                if (order > num)
                {
                    order = num;
                }
                if ((int)actor.ActionOrder == order)
                {
                    result = true;
                }
            }
            return result;
        }

        private void ProcStepBattleStatusEffect()
        {
            if (Mevius.App.Api.IsPartyMode())
            {
                Ca9c714c662dfae389ad7332e5dd00832.C8336e7718a740dd523525fa2b510e66d c8336e7718a740dd523525fa2b510e66d = Ca9c714c662dfae389ad7332e5dd00832.Find(Mevius.Party.Api.GetExecPartyQuestId());
                if (c8336e7718a740dd523525fa2b510e66d != null)
                {
                    for (int i = 0; i < c8336e7718a740dd523525fa2b510e66d.countm7d751ca6c95f2ed72a6a44b64c7f6a3a(); i++)
                    {
                        int num = (int)c8336e7718a740dd523525fa2b510e66d.mc3bf00c1484f7500bd390511556ece1c(i);
                        if (num != 0)
                        {
                            for (int j = 0; j < this.m_actorList.Count; j++)
                            {
                                BattleActor battleActor = this.m_actorList[j];
                                bool flag = false;
                                switch (c8336e7718a740dd523525fa2b510e66d.mda0e8565dc6726aedc8e2d10263b779c(i))
                                {
                                case 0:
                                    flag = battleActor.IsPlayer();
                                    break;
                                case 1:
                                    flag = battleActor.IsEnemy();
                                    break;
                                case 2:
                                    flag = true;
                                    break;
                                }
                                if (flag)
                                {
                                    C02688ac2fa3465c4dc969e664556169f.Cdb83ac7b1b94f482a747dd16b359c48f cdb83ac7b1b94f482a747dd16b359c48f = C02688ac2fa3465c4dc969e664556169f.Find(num.ToString());
                                    if (cdb83ac7b1b94f482a747dd16b359c48f != null)
                                    {
                                        int num2 = 0;
                                        if (cdb83ac7b1b94f482a747dd16b359c48f.m192357c760b657018e12cbbc41dc3f10() == 1)
                                        {
                                            num2 = battleActor.GetStatusEffectValue(BattleStatusEffect.ProcType.DebuffResist);
                                            if (battleActor.IsPlayer())
                                            {
                                                BattleStatusEffect.GroupType group = (BattleStatusEffect.GroupType)cdb83ac7b1b94f482a747dd16b359c48f.mdde7487838082c3392fafe3e5e31ccbf();
                                                num2 += battleActor.GetAutoAbilityResistParam(group);
                                            }
                                        }
                                        if (num2 < 100 || c8336e7718a740dd523525fa2b510e66d.m2ae80ea97d128cc60c3f2610338ed920(j) == 3)
                                        {
                                            battleActor.AddStatusEffect(num, (int)c8336e7718a740dd523525fa2b510e66d.mf4e6b242ee507cd08c3707b60299ec90(i), (BattleStatusEffect.StateType)c8336e7718a740dd523525fa2b510e66d.m2ae80ea97d128cc60c3f2610338ed920(i), 0, true, true);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if (!string.IsNullOrEmpty(c8336e7718a740dd523525fa2b510e66d.mf119062052a4666233881e867cab2601()))
                    {
                        Mevius.Gui.Api.ShowBattleEnemyActionName(c8336e7718a740dd523525fa2b510e66d.mf119062052a4666233881e867cab2601(), ElementAttributeBitType.None);
                    }
                    this.m_actionStepWait = c8336e7718a740dd523525fa2b510e66d.m0c6eaf36fbfa3402bd62c34dfb395f84();
                }
            }
            else
            {
                Caa051806b3598cc4aa2892b0900bdadb.C7515a628c1d13daf08c8a160fb5c564e targetStepBattle = Mevius.Field.Api.BattleApi.GetTargetStepBattle(Mevius.Field.Api.GadgetRouteApi.GetTargetGadgetName(), Mevius.App.Api.GetMainJobTypeCurrentDeck());
                if (targetStepBattle != null)
                {
                    for (int k = 0; k < this.m_actorList.Count; k++)
                    {
                        BattleActor battleActor2 = this.m_actorList[k];
                        int num3 = targetStepBattle.countmb57e26cd0e324c1a15a0a5ac67c8bcb8();
                        for (int l = 0; l < num3; l++)
                        {
                            bool flag2 = false;
                            switch (targetStepBattle.mcda129cdb90d44290bfd861ec0e267ed(l))
                            {
                            case 0:
                                flag2 = battleActor2.IsPlayer();
                                break;
                            case 1:
                                flag2 = battleActor2.IsEnemy();
                                break;
                            case 2:
                                flag2 = true;
                                break;
                            }
                            if (flag2)
                            {
                                int num4 = targetStepBattle.mcb8f7a8bc0418595a425e2e33e0ae58b(l);
                                if (num4 != 0)
                                {
                                    C02688ac2fa3465c4dc969e664556169f.Cdb83ac7b1b94f482a747dd16b359c48f cdb83ac7b1b94f482a747dd16b359c48f2 = C02688ac2fa3465c4dc969e664556169f.Find(num4.ToString());
                                    if (cdb83ac7b1b94f482a747dd16b359c48f2 != null)
                                    {
                                        int num5 = 0;
                                        if (cdb83ac7b1b94f482a747dd16b359c48f2.m192357c760b657018e12cbbc41dc3f10() == 1)
                                        {
                                            num5 = battleActor2.GetStatusEffectValue(BattleStatusEffect.ProcType.DebuffResist);
                                            if (battleActor2.IsPlayer())
                                            {
                                                BattleStatusEffect.GroupType group2 = (BattleStatusEffect.GroupType)cdb83ac7b1b94f482a747dd16b359c48f2.mdde7487838082c3392fafe3e5e31ccbf();
                                                num5 += battleActor2.GetAutoAbilityResistParam(group2);
                                            }
                                        }
                                        if (num5 < 100 || targetStepBattle.m3a95f7864c6b38c040f47215e96999ff(l) == 3)
                                        {
                                            battleActor2.AddStatusEffect(num4, targetStepBattle.m89a634dfa79f4f4cb1d29743824831f1(l), (BattleStatusEffect.StateType)targetStepBattle.m3a95f7864c6b38c040f47215e96999ff(l), 0, true, true);
                                        }
                                    }
                                }
                            }
                        }
                    }
                    if (!string.IsNullOrEmpty(targetStepBattle.m45e96b96d732ec81ba48ae2c57532fde()))
                    {
                        Mevius.Gui.Api.ShowBattleEnemyActionName(targetStepBattle.m45e96b96d732ec81ba48ae2c57532fde(), ElementAttributeBitType.None);
                    }
                    this.m_actionStepWait = targetStepBattle.m0c339662fb6db5a8bd740b17ffbc47ae();
                }
            }
        }

        private void ProcStepBattleStatusEffectEnd()
        {
            if (!Mevius.App.Api.IsPartyMode() && this.m_playerActor != null)
            {
                for (int i = 0; i <= 3; i++)
                {
                    if (this.m_playerActor.IsAutoAbility(DbManager.AutoAbilityType.AUTOABILITYTYPE_CS1077 + i))
                    {
                        for (int j = 0; j < this.m_actorList.Count; j++)
                        {
                            BattleActor battleActor = this.m_actorList[j];
                            battleActor.RemoveStatusEffect(BattleStatusEffect.GroupType.AttributeEnhanceCapter8Fire + i, BattleStatusEffect.StateType.SuperStrong);
                        }
                    }
                }
            }
        }

        private void InitElementInfluence()
        {
            if (this.m_turnNum != 1 || !this.IsFirstBattle())
            {
                return;
            }
            int elementInfluenceType = BattleUtility.GetElementInfluenceType();
            if (elementInfluenceType != 0)
            {
                DbManager.BattleData battleData = Mevius.Db.Api.GetBattleData();
                battleData.elementInfluenceTurn = (sbyte)this.CalcElementInfluenceTurn(elementInfluenceType);
                battleData.elementInfluenceTurnNext = (sbyte)this.CalcElementInfluenceTurn(elementInfluenceType);
                List<ElementAttributeType> elementInfluenceAttributeList = this.GetElementInfluenceAttributeList(elementInfluenceType);
                if (elementInfluenceAttributeList.Count > 0)
                {
                    battleData.elementInfluenceAttribute = (sbyte)elementInfluenceAttributeList[(int)((ulong)this.GetRandomUnsignedInteger() % (ulong)((long)elementInfluenceAttributeList.Count))];
                    elementInfluenceAttributeList.Remove((ElementAttributeType)battleData.elementInfluenceAttribute);
                    battleData.elementInfluenceAttributeNext = (sbyte)elementInfluenceAttributeList[(int)((ulong)this.GetRandomUnsignedInteger() % (ulong)((long)elementInfluenceAttributeList.Count))];
                }
                else
                {
                    battleData.elementInfluenceAttribute = -1;
                    battleData.elementInfluenceAttributeNext = -1;
                }
                battleData.elementInfluenceRate = this.CalcElementInfluenceRate(elementInfluenceType);
                battleData.elementInfluenceRateNext = this.CalcElementInfluenceRate(elementInfluenceType);
            }
        }

        private void UpdateElementInfluence()
        {
            if (this.m_turnNum == 1 && this.IsFirstBattle())
            {
                return;
            }
            int elementInfluenceType = BattleUtility.GetElementInfluenceType();
            if (elementInfluenceType != 0)
            {
                DbManager.BattleData battleData = Mevius.Db.Api.GetBattleData();
                DbManager.BattleData battleData2 = battleData;
                battleData2.elementInfluenceTurn -= 1;
                if ((int)battleData.elementInfluenceTurn <= 0)
                {
                    battleData.elementInfluenceTurn = battleData.elementInfluenceTurnNext;
                    battleData.elementInfluenceAttribute = battleData.elementInfluenceAttributeNext;
                    battleData.elementInfluenceRate = battleData.elementInfluenceRateNext;
                    battleData.elementInfluenceTurnNext = (sbyte)this.CalcElementInfluenceTurn(elementInfluenceType);
                    List<ElementAttributeType> elementInfluenceAttributeList = this.GetElementInfluenceAttributeList(elementInfluenceType);
                    elementInfluenceAttributeList.Remove((ElementAttributeType)battleData.elementInfluenceAttribute);
                    int count = elementInfluenceAttributeList.Count;
                    if (count > 0)
                    {
                        battleData.elementInfluenceAttributeNext = (sbyte)elementInfluenceAttributeList[(int)((ulong)this.GetRandomUnsignedInteger() % (ulong)((long)count))];
                    }
                    else
                    {
                        battleData.elementInfluenceAttributeNext = -1;
                    }
                    battleData.elementInfluenceRateNext = this.CalcElementInfluenceRate(elementInfluenceType);
                    this.ShowElementInfluence();
                }
                else if (this.m_turnNum == 1)
                {
                    this.ShowElementInfluence();
                }
                else
                {
                    Mevius.Gui.Api.ShowElementInfluenceTurn(0, (int)battleData.elementInfluenceTurn);
                }
            }
        }

        public void ShowElementInfluence()
        {
            DbManager.BattleData battleData = Mevius.Db.Api.GetBattleData();
            Mevius.Gui.Api.ShowElementInfluenceRate(0, (ElementAttributeType)battleData.elementInfluenceAttribute, battleData.elementInfluenceRate);
            Mevius.Gui.Api.ShowElementInfluenceTurn(0, (int)battleData.elementInfluenceTurn);
            Mevius.Gui.Api.ShowElementInfluenceRate(1, (ElementAttributeType)battleData.elementInfluenceAttributeNext, battleData.elementInfluenceRateNext);
            Mevius.Gui.Api.ShowElementInfluenceTurn(1, (int)battleData.elementInfluenceTurnNext);
        }

        private int CalcElementInfluenceTurn(int type)
        {
            int residentInteger;
            int residentInteger2;
            if (type == 1)
            {
                residentInteger = Mevius.DataSheet.Api.GetResidentInteger("elementInfluenceTurnMin", 2);
                residentInteger2 = Mevius.DataSheet.Api.GetResidentInteger("elementInfluenceTurnMax", 2);
            }
            else
            {
                residentInteger = Mevius.DataSheet.Api.GetResidentInteger("elementInfluence2TurnMin", 2);
                residentInteger2 = Mevius.DataSheet.Api.GetResidentInteger("elementInfluence2TurnMax", 2);
            }
            int num = residentInteger2 - residentInteger;
            if (num != 0)
            {
                return residentInteger + (int)((ulong)this.GetRandomUnsignedInteger() % (ulong)((long)(num + 1)));
            }
            return residentInteger;
        }

        private float CalcElementInfluenceRate(int type)
        {
            float residentFloat;
            float residentFloat2;
            if (type == 1)
            {
                if ((this.GetRandomUnsignedInteger() & 1u) == 0u)
                {
                    residentFloat = Mevius.DataSheet.Api.GetResidentFloat("elementInfluenceRateLowMin", 0.1f);
                    residentFloat2 = Mevius.DataSheet.Api.GetResidentFloat("elementInfluenceRateLowMax", 0.5f);
                }
                else
                {
                    residentFloat = Mevius.DataSheet.Api.GetResidentFloat("elementInfluenceRateHighMin", 1.5f);
                    residentFloat2 = Mevius.DataSheet.Api.GetResidentFloat("elementInfluenceRateHighMax", 2f);
                }
            }
            else
            {
                residentFloat = Mevius.DataSheet.Api.GetResidentFloat("elementInfluence2RateHighMin", 1.5f);
                residentFloat2 = Mevius.DataSheet.Api.GetResidentFloat("elementInfluence2RateHighMax", 2f);
            }
            return residentFloat + (residentFloat2 - residentFloat) * this.GetRandomSingleFloat();
        }

        private List<ElementAttributeType> GetElementInfluenceAttributeList(int type)
        {
            ElementAttributeType[] jobUseAttributeArray = BattleUtility.GetJobUseAttributeArray(this.m_playerActor.Deck, true);
            List<ElementAttributeType> list = new List<ElementAttributeType>(jobUseAttributeArray);
            if (type == 1)
            {
                for (int i = 0; i < this.m_actorList.Count; i++)
                {
                    if (this.m_actorList[i].IsActiveTarget() && this.m_actorList[i].IsEnemy() && !this.m_actorList[i].UnknownAttribute)
                    {
                        ElementAttributeType attributeTypeFromBit = BattleUtility.GetAttributeTypeFromBit((int)this.m_actorList[i].GetElementAttributeBit());
                        if (attributeTypeFromBit != ElementAttributeType.None && !list.Contains(attributeTypeFromBit))
                        {
                            list.Add(attributeTypeFromBit);
                        }
                    }
                }
            }
            return list;
        }

        public int[] MissionCounts
        {
            get
            {
                return this.m_missionCounts;
            }
        }

        public int[] BossMissionCounts
        {
            get
            {
                return this.m_bossMissionCounts;
            }
        }

        public long[] SaveLongValues
        {
            get
            {
                return this.m_saveLongValues;
            }
        }

        public long[] BossSaveLongValues
        {
            get
            {
                return this.m_bossSaveLongValues;
            }
        }

        public void ShowHidePlayer(bool show, bool setMotionController = true)
        {
            if (Mevius.App.Api.IsPartyMode())
            {
                for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
                {
                    BattleActor battleActor = this.m_multiBattleActorList[i];
                    battleActor.chara.ShowHideModel(show, setMotionController);
                    battleActor.ShowHideWeaponEffect(show);
                }
            }
            else
            {
                if (this.m_playerActor != null)
                {
                    this.m_playerActor.chara.ShowHideModel(show, setMotionController);
                    this.m_playerActor.ShowHideWeaponEffect(show);
                }
                if (this.m_fairyActor != null)
                {
                    this.m_fairyActor.Chara.ShowHideModel(show, setMotionController);
                }
            }
        }

        public void InitSameCharaIndex()
        {
            if (!BattleUtility.IsDQGimmick())
            {
                return;
            }
            this.m_dqSameNameDictionary = new Dictionary<string, sbyte>(this._entryBattleCharaSpecList.Count >> 1);
            Dictionary<string, int> dictionary = new Dictionary<string, int>(this._entryBattleCharaSpecList.Count);
            for (int i = 0; i < this._entryBattleCharaSpecList.Count; i++)
            {
                string enemyActorName = BattleManager.GetEnemyActorName(i);
                BattleActor battleActor = this.FindActor(enemyActorName);
                if (battleActor != null && !battleActor.IsStandBy())
                {
                    C4d4f3a800432e94568175cb31ad3c78d.C51747b7e0e19ad065084a2c5a6d8421b c51747b7e0e19ad065084a2c5a6d8421b = C4d4f3a800432e94568175cb31ad3c78d.Find(this._entryBattleCharaSpecList[i]);
                    if (c51747b7e0e19ad065084a2c5a6d8421b != null)
                    {
                        string text = c51747b7e0e19ad065084a2c5a6d8421b.mf1c02fa779f434db21d5e8bf97e8f0b9();
                        sbyte b;
                        if ((int)battleActor.SameCharaIndex == -1)
                        {
                            if (dictionary.ContainsKey(text))
                            {
                                Dictionary<string, int> dictionary3;
                                Dictionary<string, int> dictionary2 = dictionary3 = dictionary;
                                string key2;
                                string key = key2 = text;
                                int num = dictionary3[key2];
                                dictionary2[key] = num + 1;
                            }
                            else
                            {
                                dictionary[text] = 1;
                            }
                        }
                        else if (this.m_dqSameNameDictionary.TryGetValue(text, out b))
                        {
                            if ((int)b < (int)battleActor.SameCharaIndex)
                            {
                                this.m_dqSameNameDictionary[text] = battleActor.SameCharaIndex;
                            }
                        }
                        else
                        {
                            this.m_dqSameNameDictionary[text] = battleActor.SameCharaIndex;
                        }
                    }
                }
            }
            foreach (KeyValuePair<string, int> keyValuePair in dictionary)
            {
                if (1 < keyValuePair.Value)
                {
                    sbyte b2 = 0;
                    for (int j = 0; j < this._entryBattleCharaSpecList.Count; j++)
                    {
                        string enemyActorName2 = BattleManager.GetEnemyActorName(j);
                        BattleActor battleActor2 = this.FindActor(enemyActorName2);
                        if (battleActor2 != null && !battleActor2.IsStandBy() && (int)battleActor2.SameCharaIndex == -1)
                        {
                            C4d4f3a800432e94568175cb31ad3c78d.C51747b7e0e19ad065084a2c5a6d8421b c51747b7e0e19ad065084a2c5a6d8421b2 = C4d4f3a800432e94568175cb31ad3c78d.Find(this._entryBattleCharaSpecList[j]);
                            if (c51747b7e0e19ad065084a2c5a6d8421b2 != null && c51747b7e0e19ad065084a2c5a6d8421b2.mf1c02fa779f434db21d5e8bf97e8f0b9() == keyValuePair.Key)
                            {
                                battleActor2.SameCharaIndex = b2;
                                this.m_dqSameNameDictionary[keyValuePair.Key] = b2;
                                b2 += 1;
                            }
                        }
                    }
                }
            }
        }

        public void UpdateSameNameIndex(BattleActor targetActor)
        {
            if (!BattleUtility.IsDQGimmick())
            {
                return;
            }
            C4d4f3a800432e94568175cb31ad3c78d.C51747b7e0e19ad065084a2c5a6d8421b c51747b7e0e19ad065084a2c5a6d8421b = C4d4f3a800432e94568175cb31ad3c78d.Find(targetActor.BattleCharaSpec);
            if (c51747b7e0e19ad065084a2c5a6d8421b != null)
            {
                string text = c51747b7e0e19ad065084a2c5a6d8421b.mf1c02fa779f434db21d5e8bf97e8f0b9();
                List<sbyte> list = new List<sbyte>(this._entryBattleCharaSpecList.Count);
                for (int i = 0; i < this._entryBattleCharaSpecList.Count; i++)
                {
                    string enemyActorName = BattleManager.GetEnemyActorName(i);
                    BattleActor battleActor = this.FindActor(enemyActorName);
                    if (battleActor != null && battleActor.IsActive() && battleActor != targetActor)
                    {
                        C4d4f3a800432e94568175cb31ad3c78d.C51747b7e0e19ad065084a2c5a6d8421b c51747b7e0e19ad065084a2c5a6d8421b2 = C4d4f3a800432e94568175cb31ad3c78d.Find(this._entryBattleCharaSpecList[i]);
                        if (c51747b7e0e19ad065084a2c5a6d8421b2 != null && text == c51747b7e0e19ad065084a2c5a6d8421b2.mf1c02fa779f434db21d5e8bf97e8f0b9())
                        {
                            if ((int)battleActor.SameCharaIndex == -1)
                            {
                                battleActor.SameCharaIndex = 0;
                            }
                            list.Add(battleActor.SameCharaIndex);
                        }
                    }
                }
                sbyte b = -1;
                if (list.Count != 0 && this.m_dqSameNameDictionary.TryGetValue(text, out b))
                {
                    int num = 0;
                    do
                    {
                        b += 1;
                        if (26 <= (int)b)
                        {
                            b = 0;
                        }
                        if (!list.Contains(b))
                        {
                            break;
                        }
                    }
                    while (++num <= 26);
                    this.m_dqSameNameDictionary[text] = b;
                }
                else
                {
                    this.m_dqSameNameDictionary.Add(text, 0);
                }
                targetActor.SameCharaIndex = b;
            }
        }

        public bool IsPartyChange()
        {
            return this.m_playerActor != null && this.m_playerActorSub != null && this.m_playerActor.GetJobCardPlayerType() != this.m_playerActorSub.GetJobCardPlayerType();
        }

        public byte PlayerFinishCount
        {
            get
            {
                return this.m_playerFinishCount;
            }
            set
            {
                this.m_playerFinishCount = value;
            }
        }

        public void RecoverPlayerSubHp(int value)
        {
            if (!this.IsPartyChange())
            {
                return;
            }
            if (this.m_playerActorSub.IsSummon())
            {
                return;
            }
            this.m_playerActorSub.AddHp(value);
            this.AddRecoveryTotal(this.m_playerActorSub, value);
        }

        public void RecoverPlayerSubHpMaxRate(float rate)
        {
            if (!this.IsPartyChange())
            {
                return;
            }
            if (this.m_playerActorSub.IsSummon())
            {
                return;
            }
            int value = (int)((float)this.m_playerActorSub.HpMax * rate + 0.5f);
            this.m_playerActorSub.AddHp(value);
            this.AddRecoveryTotal(this.m_playerActorSub, value);
        }

        public void RecoverPlayerSub(BattleDamage.DamageInfo damageInfo)
        {
            if (!this.IsPartyChange())
            {
                return;
            }
            if (this.m_playerActorSub.IsSummon())
            {
                return;
            }
            if (!this.m_playerActor.IsStatusEffectEntry(BattleStatusEffect.ProcType.HPRecoverDisable))
            {
                if (damageInfo.powerType == DamageSourcePowerType.OwnerHpMaxRate || damageInfo.powerType == DamageSourcePowerType.TargetHpMaxRate || damageInfo.powerType == DamageSourcePowerType.TargetFixHpMaxRate)
                {
                    this.m_playerActorSub.AddHp((int)((float)this.m_playerActorSub.HpMax / 100f * (float)damageInfo.power + 0.5f));
                }
                else if (damageInfo.powerType == DamageSourcePowerType.OwnerHpRate || damageInfo.powerType == DamageSourcePowerType.TargetHpRate || damageInfo.powerType == DamageSourcePowerType.TargetFixHpRate)
                {
                    this.m_playerActorSub.AddHp((int)((float)this.m_playerActorSub.Hp / 100f * (float)damageInfo.power + 0.5f));
                }
                else
                {
                    this.m_playerActorSub.AddHp(-damageInfo.damage);
                }
            }
        }

        public void PartyAIOnBehavior(BattleAiData.Pattern.TimingType timing, BattleActor actor, string argStr = "", BattleDamage.DamageInfo damageInfo = null)
        {
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                BattleActor battleActor = this.m_actorList[i];
                if (battleActor != actor && battleActor.IsActive() && battleActor.Ai != null && battleActor.IsParty(actor))
                {
                    battleActor.Ai.OnBehavior(timing, argStr, damageInfo, true);
                }
            }
        }

        public void CalcScreenOrderEnemyList()
        {
            this.m_screenOrderEnemyActorList.Clear();
            this.m_screenOrderEnemyPosList.Clear();
            Mevius.Renderer.CameraManager instance = Mevius.Renderer.CameraManager.GetInstance();
            if (instance == null)
            {
                return;
            }
            GameObject viewCameraGameObject = instance.GetViewCameraGameObject();
            if (viewCameraGameObject == null)
            {
                return;
            }
            Camera component = viewCameraGameObject.GetComponent<Camera>();
            if (component == null)
            {
                return;
            }
            string name = ExtensionElementIdDefinition.GetName(ExtensionElementIdDefinition.Index.BODY_CENTER);
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                BattleActor battleActor = this.m_actorList[i];
                if (battleActor.IsEnemy() && battleActor.IsActiveTarget())
                {
                    Transform elementIdTransform = battleActor.chara.GetElementIdTransform(name);
                    if (elementIdTransform)
                    {
                        Vector3 item = component.WorldToViewportPoint(elementIdTransform.position);
                        if (item.z > 0f)
                        {
                            bool flag = false;
                            for (int j = 0; j < this.m_screenOrderEnemyActorList.Count; j++)
                            {
                                Vector3 vector = this.m_screenOrderEnemyPosList[j];
                                if (item.x < vector.x)
                                {
                                    flag = true;
                                    this.m_screenOrderEnemyActorList.Insert(j, battleActor);
                                    this.m_screenOrderEnemyPosList.Insert(j, item);
                                    break;
                                }
                            }
                            if (!flag)
                            {
                                this.m_screenOrderEnemyActorList.Add(battleActor);
                                this.m_screenOrderEnemyPosList.Add(item);
                            }
                        }
                    }
                }
            }
        }

        public void InitDQAbility()
        {
            if (BattleUtility.IsDQGimmick())
            {
                Mevius.Db.Api.JOB_TYPE parameter = (Mevius.Db.Api.JOB_TYPE)Mevius.Db.Api.GetParameter(DbManager.ParameterType.JobAttribute);
                Mevius.Db.Api.JOB_TYPE parameter2 = (Mevius.Db.Api.JOB_TYPE)Mevius.Db.Api.GetParameter(DbManager.ParameterType.JobAttribute_Sub);
                if (parameter == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_FORCE || parameter2 == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_FORCE)
                {
                    DbManager.DQAbility[] array = Mevius.Db.Api.GetDQAbilityWarrior();
                    for (int i = 0; i < array.Length; i++)
                    {
                        Mevius.Loader.Api.LoadAbility(array[i].id);
                    }
                }
                if (parameter == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_TECHNIQUE || parameter2 == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_TECHNIQUE)
                {
                    DbManager.DQAbility[] array = Mevius.Db.Api.GetDQAbilityRanger();
                    for (int j = 0; j < array.Length; j++)
                    {
                        Mevius.Loader.Api.LoadAbility(array[j].id);
                    }
                }
                if (parameter == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_INTELLECT || parameter2 == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_INTELLECT)
                {
                    DbManager.DQAbility[] array = Mevius.Db.Api.GetDQAbilityMage();
                    for (int k = 0; k < array.Length; k++)
                    {
                        Mevius.Loader.Api.LoadAbility(array[k].id);
                    }
                }
                if (parameter == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_MARTIAL || parameter2 == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_MARTIAL)
                {
                    DbManager.DQAbility[] array = Mevius.Db.Api.GetDQAbilityMartialArtist();
                    for (int l = 0; l < array.Length; l++)
                    {
                        Mevius.Loader.Api.LoadAbility(array[l].id);
                    }
                }
            }
        }

        public void EndDQAbility()
        {
            if (BattleUtility.IsDQGimmick())
            {
                Mevius.Db.Api.JOB_TYPE parameter = (Mevius.Db.Api.JOB_TYPE)Mevius.Db.Api.GetParameter(DbManager.ParameterType.JobAttribute);
                Mevius.Db.Api.JOB_TYPE parameter2 = (Mevius.Db.Api.JOB_TYPE)Mevius.Db.Api.GetParameter(DbManager.ParameterType.JobAttribute_Sub);
                if (parameter == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_FORCE || parameter2 == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_FORCE)
                {
                    DbManager.DQAbility[] array = Mevius.Db.Api.GetDQAbilityWarrior();
                    for (int i = 0; i < array.Length; i++)
                    {
                        Mevius.Loader.Api.UnLoadAbility(array[i].id);
                    }
                }
                if (parameter == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_TECHNIQUE || parameter2 == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_TECHNIQUE)
                {
                    DbManager.DQAbility[] array = Mevius.Db.Api.GetDQAbilityRanger();
                    for (int j = 0; j < array.Length; j++)
                    {
                        Mevius.Loader.Api.UnLoadAbility(array[j].id);
                    }
                }
                if (parameter == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_INTELLECT || parameter2 == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_INTELLECT)
                {
                    DbManager.DQAbility[] array = Mevius.Db.Api.GetDQAbilityMage();
                    for (int k = 0; k < array.Length; k++)
                    {
                        Mevius.Loader.Api.UnLoadAbility(array[k].id);
                    }
                }
                if (parameter == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_MARTIAL || parameter2 == Mevius.Db.Api.JOB_TYPE.JOB_TYPE_MARTIAL)
                {
                    DbManager.DQAbility[] array = Mevius.Db.Api.GetDQAbilityMartialArtist();
                    for (int l = 0; l < array.Length; l++)
                    {
                        Mevius.Loader.Api.UnLoadAbility(array[l].id);
                    }
                }
            }
        }

        public void InitFF7Ability()
        {
            if (!BattleUtility.IsFF7Gimmick())
            {
                return;
            }
            FF7MateriaSheet ff7CurrentMateriaSet = Mevius.Db.Api.GetFF7CurrentMateriaSet();
            if (ff7CurrentMateriaSet == null)
            {
                return;
            }
            C1a80abc65223cbedf4c65f351d473ca0.C68ded254e0859e604ece0328b8447fa0 dsElement = ff7CurrentMateriaSet.DsElement;
            if (dsElement != null)
            {
                List<Ceaf68fb2356fb8b84facc86d2fe79f0e.Cca912973d2eb55c3b74a5c95a6475670> list = new List<Ceaf68fb2356fb8b84facc86d2fe79f0e.Cca912973d2eb55c3b74a5c95a6475670>();
                List<C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c> list2 = new List<C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c>();
                string displayText = Mevius.Gui.Util.GetGuiText("$edit_mate_004").GetDisplayText();
                for (int i = 0; i < 3; i++)
                {
                    MateriaSlotInfo materiaSlotInfo = ff7CurrentMateriaSet.GetMateriaSlotInfo(i);
                    if (materiaSlotInfo != null)
                    {
                        int materiaSlotLevel = ff7CurrentMateriaSet.GetMateriaSlotLevel(i);
                        string str = "ff7_" + i.ToString();
                        int num = 0;
                        int count = materiaSlotInfo.abilityInfos.Count;
                        for (int j = 0; j < count; j++)
                        {
                            string text = str + "_" + num.ToString();
                            num++;
                            Ceaf68fb2356fb8b84facc86d2fe79f0e.Cca912973d2eb55c3b74a5c95a6475670 cca912973d2eb55c3b74a5c95a = new Ceaf68fb2356fb8b84facc86d2fe79f0e.Cca912973d2eb55c3b74a5c95a6475670();
                            cca912973d2eb55c3b74a5c95a.setmea95f268a19fafbae355590c72e0af82(text);
                            if (materiaSlotInfo.abilityInfos[j].attributes.Count != 0)
                            {
                                string baseAbilityId = Mevius.Collaboration.FF7.Api.GetBaseAbilityId(materiaSlotInfo.abilityInfos[j]);
                                Ceaf68fb2356fb8b84facc86d2fe79f0e.Cca912973d2eb55c3b74a5c95a6475670 cca912973d2eb55c3b74a5c95a2 = Ceaf68fb2356fb8b84facc86d2fe79f0e.Find(baseAbilityId);
                                if (cca912973d2eb55c3b74a5c95a2 != null)
                                {
                                    BattleUtility.CopyBattleAbility(cca912973d2eb55c3b74a5c95a2, cca912973d2eb55c3b74a5c95a);
                                    list.Add(cca912973d2eb55c3b74a5c95a);
                                    cca912973d2eb55c3b74a5c95a.me37bd2195ab85215257357867bf1f31f = displayText + (i + 1).ToString();
                                    cca912973d2eb55c3b74a5c95a.mba50449bb16149be0cb9107b3332af55 = text + "_0";
                                    if (materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Magic2 || materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Magic4)
                                    {
                                        cca912973d2eb55c3b74a5c95a.m943a4f44a5b790adf5f199abcd9f8eda[0] = "b_ab_magic3";
                                        Array.Clear(cca912973d2eb55c3b74a5c95a.m8f4006d551650d0f2bbc0cccda58f301, 0, cca912973d2eb55c3b74a5c95a.m943a4f44a5b790adf5f199abcd9f8eda.Length);
                                        cca912973d2eb55c3b74a5c95a.m8f4006d551650d0f2bbc0cccda58f301[0] = Mevius.DataSheet.Api.GetResidentString("ff7MateriaCameraMagicSequence", "none");
                                        Array.Clear(cca912973d2eb55c3b74a5c95a.m8f4006d551650d0f2bbc0cccda58f301, 1, cca912973d2eb55c3b74a5c95a.m8f4006d551650d0f2bbc0cccda58f301.Length - 1);
                                    }
                                    else if (materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Physics2 || materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Physics4)
                                    {
                                        cca912973d2eb55c3b74a5c95a.m943a4f44a5b790adf5f199abcd9f8eda[0] = "b_ab_attack3";
                                    }
                                    else if (materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.None)
                                    {
                                        cca912973d2eb55c3b74a5c95a.m8f4006d551650d0f2bbc0cccda58f301[0] = Mevius.DataSheet.Api.GetResidentString("ff7MateriaCameraMagic", "none");
                                        Array.Clear(cca912973d2eb55c3b74a5c95a.m8f4006d551650d0f2bbc0cccda58f301, 1, cca912973d2eb55c3b74a5c95a.m8f4006d551650d0f2bbc0cccda58f301.Length - 1);
                                    }
                                    int num2 = 0;
                                    C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c = C9834a30e5f3368ef11b898eb90b12c5b.Find(baseAbilityId.ToString());
                                    if (c03df96e967d7177ede70d5c100f08e3c != null)
                                    {
                                        bool flag = false;
                                        float maf2cbc7dd405e1877acc7668fe3a8f1c = 0f;
                                        if (materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Magic2 || materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Magic4)
                                        {
                                            C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c2 = new C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c();
                                            list2.Add(c03df96e967d7177ede70d5c100f08e3c2);
                                            c03df96e967d7177ede70d5c100f08e3c2.setm2fdc5dfffb1b3d841ac3f8230f882c53(text + "_" + num2.ToString());
                                            num2++;
                                            c03df96e967d7177ede70d5c100f08e3c2.m232ee576923851b2f6b50a1e96174ebf = 2f;
                                            c03df96e967d7177ede70d5c100f08e3c2.m231ee77ce8c939b2457cb3ca8ab78f93 = 1;
                                            int num3 = 0;
                                            if (materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Magic2)
                                            {
                                                num3 = 1;
                                            }
                                            else if (materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Magic4)
                                            {
                                                num3 = 3;
                                            }
                                            c03df96e967d7177ede70d5c100f08e3c2.m882baa1c0fb70bc90216be0d2aa79ddd = 1;
                                            c03df96e967d7177ede70d5c100f08e3c2.m86cd0ccc62cd5f3f8eb9461852b6cd85 = (float)num3;
                                            c03df96e967d7177ede70d5c100f08e3c2.mfa094e7f6620ef2b4d68b4544c65408f = 0.25f;
                                            c03df96e967d7177ede70d5c100f08e3c2.m2c8f11c2c6c9758a89a28fa2469923c3[0] = text + "_" + num2.ToString();
                                            c03df96e967d7177ede70d5c100f08e3c2.m8deb8b75848d2f5f6b14a04e263f6e9b = text + "_" + (num2 + 1).ToString();
                                            flag = true;
                                            maf2cbc7dd405e1877acc7668fe3a8f1c = (float)num3 * 0.25f;
                                        }
                                        C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c3 = new C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c();
                                        list2.Add(c03df96e967d7177ede70d5c100f08e3c3);
                                        BattleUtility.CopyBattleDamageSource(c03df96e967d7177ede70d5c100f08e3c, c03df96e967d7177ede70d5c100f08e3c3);
                                        c03df96e967d7177ede70d5c100f08e3c3.setm2fdc5dfffb1b3d841ac3f8230f882c53(text + "_" + num2.ToString());
                                        num2++;
                                        bool flag2 = !string.IsNullOrEmpty(c03df96e967d7177ede70d5c100f08e3c3.m141fbc6685aa36c47b8b7c97eeff932b);
                                        string m141fbc6685aa36c47b8b7c97eeff932b = c03df96e967d7177ede70d5c100f08e3c3.m141fbc6685aa36c47b8b7c97eeff932b;
                                        float num4;
                                        float num5;
                                        Mevius.Collaboration.FF7.Api.GetAbilityPowerCoef(out num4, out num5, materiaSlotInfo.abilityInfos[j]);
                                        short num6 = (short)((float)Mevius.DataSheet.Api.GetResidentInteger("ff7MateriaAttackPower", 600) + (float)materiaSlotLevel * Mevius.DataSheet.Api.GetResidentFloat("ff7MateriaAttackPowerLvCoef", 1f) + 0.5f);
                                        bool flag3 = materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Physics1 || materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Physics2 || materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Physics4 || materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.PhysicsAll || materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Physics1All;
                                        if (c03df96e967d7177ede70d5c100f08e3c3.m7e024ed285de34a9f7483eb072477c80 != 0)
                                        {
                                            if (flag3)
                                            {
                                                c03df96e967d7177ede70d5c100f08e3c3.md11d39aa00a1b29455aa77cfc8557a01 = 1;
                                                c03df96e967d7177ede70d5c100f08e3c3.m1d0fa7d9f03c7e86ed69e0ee8a565ee0 = 1;
                                            }
                                            c03df96e967d7177ede70d5c100f08e3c3.m7e024ed285de34a9f7483eb072477c80 = (int)((float)num6 * num4 + 0.5f);
                                            c03df96e967d7177ede70d5c100f08e3c3.m8bafa3580a38581118515f64dbe08697 = (short)((float)num6 * num5 + 0.5f);
                                            Mevius.Collaboration.FF7.Api.SetDamageSourceAttribute(c03df96e967d7177ede70d5c100f08e3c3, materiaSlotInfo.abilityInfos[j]);
                                            if (!flag2)
                                            {
                                                Mevius.Collaboration.FF7.Api.SetDamageSourceDebuff(c03df96e967d7177ede70d5c100f08e3c3, materiaSlotInfo.abilityInfos[j]);
                                            }
                                        }
                                        if (materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Physics2 || materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Physics4)
                                        {
                                            c03df96e967d7177ede70d5c100f08e3c3.m882baa1c0fb70bc90216be0d2aa79ddd = 1;
                                            int num7 = 0;
                                            if (materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Physics2)
                                            {
                                                num7 = 1;
                                            }
                                            else if (materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Physics4)
                                            {
                                                num7 = 3;
                                            }
                                            C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c4 = c03df96e967d7177ede70d5c100f08e3c3;
                                            for (int k = 0; k < num7; k++)
                                            {
                                                C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c5 = new C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c();
                                                list2.Add(c03df96e967d7177ede70d5c100f08e3c5);
                                                BattleUtility.CopyBattleDamageSource(c03df96e967d7177ede70d5c100f08e3c3, c03df96e967d7177ede70d5c100f08e3c5);
                                                c03df96e967d7177ede70d5c100f08e3c5.setm2fdc5dfffb1b3d841ac3f8230f882c53(text + "_" + num2.ToString());
                                                c03df96e967d7177ede70d5c100f08e3c5.m141fbc6685aa36c47b8b7c97eeff932b = string.Empty;
                                                c03df96e967d7177ede70d5c100f08e3c5.maf2cbc7dd405e1877acc7668fe3a8f1c = 0.125f;
                                                if (k == num7 - 1)
                                                {
                                                    c03df96e967d7177ede70d5c100f08e3c5.m882baa1c0fb70bc90216be0d2aa79ddd = 0;
                                                }
                                                c03df96e967d7177ede70d5c100f08e3c4.m141fbc6685aa36c47b8b7c97eeff932b = text + "_" + num2.ToString();
                                                num2++;
                                                c03df96e967d7177ede70d5c100f08e3c4 = c03df96e967d7177ede70d5c100f08e3c5;
                                            }
                                        }
                                        if (flag2)
                                        {
                                            C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c6 = new C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c();
                                            list2.Add(c03df96e967d7177ede70d5c100f08e3c6);
                                            C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c7 = C9834a30e5f3368ef11b898eb90b12c5b.Find(m141fbc6685aa36c47b8b7c97eeff932b);
                                            if (c03df96e967d7177ede70d5c100f08e3c7 != null)
                                            {
                                                BattleUtility.CopyBattleDamageSource(c03df96e967d7177ede70d5c100f08e3c7, c03df96e967d7177ede70d5c100f08e3c6);
                                            }
                                            c03df96e967d7177ede70d5c100f08e3c6.setm2fdc5dfffb1b3d841ac3f8230f882c53(text + "_" + num2.ToString());
                                            c03df96e967d7177ede70d5c100f08e3c3.m141fbc6685aa36c47b8b7c97eeff932b = c03df96e967d7177ede70d5c100f08e3c6.m1467af6649f8c2c42db7965d4a2e590e();
                                            num2++;
                                            if (flag3)
                                            {
                                                c03df96e967d7177ede70d5c100f08e3c6.md11d39aa00a1b29455aa77cfc8557a01 = 1;
                                                c03df96e967d7177ede70d5c100f08e3c6.m1d0fa7d9f03c7e86ed69e0ee8a565ee0 = 1;
                                            }
                                            float num8 = 1f;
                                            if (materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Magic1All || materiaSlotInfo.abilityInfos[j].changeTarget == ChangeAbility.Physics1All)
                                            {
                                                num8 = Mevius.DataSheet.Api.GetResidentFloat("ff7MateriaAttackPowerAreaFocusCoef", 0.5f);
                                            }
                                            c03df96e967d7177ede70d5c100f08e3c6.m7e024ed285de34a9f7483eb072477c80 = (int)((float)num6 * num4 * num8 + 0.5f);
                                            c03df96e967d7177ede70d5c100f08e3c6.m8bafa3580a38581118515f64dbe08697 = (short)((float)num6 * num5 * num8 + 0.5f);
                                            Mevius.Collaboration.FF7.Api.SetDamageSourceAttribute(c03df96e967d7177ede70d5c100f08e3c6, materiaSlotInfo.abilityInfos[j]);
                                            Mevius.Collaboration.FF7.Api.SetDamageSourceDebuff(c03df96e967d7177ede70d5c100f08e3c6, materiaSlotInfo.abilityInfos[j]);
                                        }
                                        if (flag)
                                        {
                                            C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c8 = new C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c();
                                            list2.Add(c03df96e967d7177ede70d5c100f08e3c8);
                                            BattleUtility.CopyBattleDamageSource(c03df96e967d7177ede70d5c100f08e3c3, c03df96e967d7177ede70d5c100f08e3c8);
                                            c03df96e967d7177ede70d5c100f08e3c8.setm2fdc5dfffb1b3d841ac3f8230f882c53(text + "_" + num2.ToString());
                                            num2++;
                                            c03df96e967d7177ede70d5c100f08e3c8.maf2cbc7dd405e1877acc7668fe3a8f1c = maf2cbc7dd405e1877acc7668fe3a8f1c;
                                            c03df96e967d7177ede70d5c100f08e3c3.m882baa1c0fb70bc90216be0d2aa79ddd = 1;
                                        }
                                        if (materiaSlotInfo.abilityInfos[j].buffs.Count > 0)
                                        {
                                            C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c9 = new C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c();
                                            list2.Add(c03df96e967d7177ede70d5c100f08e3c9);
                                            c03df96e967d7177ede70d5c100f08e3c9.setm2fdc5dfffb1b3d841ac3f8230f882c53(text + "_ae");
                                            c03df96e967d7177ede70d5c100f08e3c9.meaeea622f2586f161d1b5d11201c0a69 = 1;
                                            c03df96e967d7177ede70d5c100f08e3c9.mda5f5a0a10736238394cfb52a181ed8d = 3;
                                            c03df96e967d7177ede70d5c100f08e3c9.mda5c5330c6e22693cd8160b7b6526591 = 1;
                                            Mevius.Collaboration.FF7.Api.SetDamageSourceBuff(c03df96e967d7177ede70d5c100f08e3c9, materiaSlotInfo.abilityInfos[j]);
                                        }
                                    }
                                }
                            }
                            else
                            {
                                string noAttributeBaseAbilityId = Mevius.Collaboration.FF7.Api.GetNoAttributeBaseAbilityId(materiaSlotInfo.abilityInfos[j]);
                                Ceaf68fb2356fb8b84facc86d2fe79f0e.Cca912973d2eb55c3b74a5c95a6475670 cca912973d2eb55c3b74a5c95a3 = Ceaf68fb2356fb8b84facc86d2fe79f0e.Find(noAttributeBaseAbilityId);
                                if (cca912973d2eb55c3b74a5c95a3 != null)
                                {
                                    BattleUtility.CopyBattleAbility(cca912973d2eb55c3b74a5c95a3, cca912973d2eb55c3b74a5c95a);
                                    list.Add(cca912973d2eb55c3b74a5c95a);
                                    cca912973d2eb55c3b74a5c95a.me37bd2195ab85215257357867bf1f31f = displayText + (i + 1).ToString();
                                    cca912973d2eb55c3b74a5c95a.mba50449bb16149be0cb9107b3332af55 = text + "_0";
                                    if (j < count - 1)
                                    {
                                        cca912973d2eb55c3b74a5c95a.mfcd8fc0409c28788a0e376aad388f005 = str + "_" + num.ToString();
                                        cca912973d2eb55c3b74a5c95a.m26d85265ed945179cb5be06cc1527a30 = -1;
                                    }
                                    if (materiaSlotInfo.abilityInfos[j].debuffs.Count > 0)
                                    {
                                        cca912973d2eb55c3b74a5c95a.m8f4006d551650d0f2bbc0cccda58f301[0] = Mevius.DataSheet.Api.GetResidentString("ff7MateriaCameraDebuff", "none");
                                        Array.Clear(cca912973d2eb55c3b74a5c95a.m8f4006d551650d0f2bbc0cccda58f301, 1, cca912973d2eb55c3b74a5c95a.m8f4006d551650d0f2bbc0cccda58f301.Length - 1);
                                    }
                                    else
                                    {
                                        cca912973d2eb55c3b74a5c95a.m8f4006d551650d0f2bbc0cccda58f301[0] = Mevius.DataSheet.Api.GetResidentString("ff7MateriaCameraBuff", "none");
                                        Array.Clear(cca912973d2eb55c3b74a5c95a.m8f4006d551650d0f2bbc0cccda58f301, 1, cca912973d2eb55c3b74a5c95a.m8f4006d551650d0f2bbc0cccda58f301.Length - 1);
                                    }
                                    C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c10 = C9834a30e5f3368ef11b898eb90b12c5b.Find(noAttributeBaseAbilityId);
                                    if (c03df96e967d7177ede70d5c100f08e3c10 != null)
                                    {
                                        C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c11 = new C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c();
                                        list2.Add(c03df96e967d7177ede70d5c100f08e3c11);
                                        c03df96e967d7177ede70d5c100f08e3c11.setm2fdc5dfffb1b3d841ac3f8230f882c53(text + "_0");
                                        BattleUtility.CopyBattleDamageSource(c03df96e967d7177ede70d5c100f08e3c10, c03df96e967d7177ede70d5c100f08e3c11);
                                        c03df96e967d7177ede70d5c100f08e3c11.m7e024ed285de34a9f7483eb072477c80 = 0;
                                        c03df96e967d7177ede70d5c100f08e3c11.m8bafa3580a38581118515f64dbe08697 = 0;
                                        c03df96e967d7177ede70d5c100f08e3c11.mbd10f0aef2b7c61687371c0f7de385d7 = 0;
                                        c03df96e967d7177ede70d5c100f08e3c11.m36dde0bc3246e78f0bd51c3450d9bc69 = 0;
                                        c03df96e967d7177ede70d5c100f08e3c11.m994d4e1ad0d9eda07321fcfbe6e87287 = 0;
                                        c03df96e967d7177ede70d5c100f08e3c11.mf72ce828fb91fc639faaf341de2096f5 = 0;
                                        c03df96e967d7177ede70d5c100f08e3c11.m072c238da24e5125a477c2c5b84ee8d8 = 0;
                                        c03df96e967d7177ede70d5c100f08e3c11.mdc5b205500ea1ed16341d9a4d9bee4a9 = 0;
                                        c03df96e967d7177ede70d5c100f08e3c11.mf72b3b01d0de212265226b9dfba2c5ea = 0;
                                        c03df96e967d7177ede70d5c100f08e3c11.m5d4c3b300c28febb20f7abbf7beaad79 = 0;
                                        c03df96e967d7177ede70d5c100f08e3c11.m05ced7e20b8e7ecfe1d5eec04f8a8958 = 0;
                                        c03df96e967d7177ede70d5c100f08e3c11.m70a7e54f6c07644bf87e004421d927b1 = 0;
                                        c03df96e967d7177ede70d5c100f08e3c11.m5e403dbef69e407e4b9a5b563c445fde = 0;
                                        c03df96e967d7177ede70d5c100f08e3c11.mb79886ee572ee2f554c46f5145cf8416 = 0;
                                        if (materiaSlotInfo.abilityInfos[j].debuffs.Count != 0)
                                        {
                                            Mevius.Collaboration.FF7.Api.SetDamageSourceDebuff(c03df96e967d7177ede70d5c100f08e3c11, materiaSlotInfo.abilityInfos[j]);
                                            c03df96e967d7177ede70d5c100f08e3c11.m141fbc6685aa36c47b8b7c97eeff932b = text + "_1";
                                            C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c12 = new C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c();
                                            list2.Add(c03df96e967d7177ede70d5c100f08e3c12);
                                            c03df96e967d7177ede70d5c100f08e3c12.setm2fdc5dfffb1b3d841ac3f8230f882c53(text + "_1");
                                            c03df96e967d7177ede70d5c100f08e3c12.mda5c5330c6e22693cd8160b7b6526591 = 2;
                                            c03df96e967d7177ede70d5c100f08e3c12.mc0e85657175b2f596f858b8e10884392 = 1;
                                            if (materiaSlotInfo.abilityInfos[j].buffs.Count > 0)
                                            {
                                                C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c c03df96e967d7177ede70d5c100f08e3c13 = new C9834a30e5f3368ef11b898eb90b12c5b.C03df96e967d7177ede70d5c100f08e3c();
                                                list2.Add(c03df96e967d7177ede70d5c100f08e3c13);
                                                c03df96e967d7177ede70d5c100f08e3c13.setm2fdc5dfffb1b3d841ac3f8230f882c53(text + "_ae");
                                                c03df96e967d7177ede70d5c100f08e3c13.meaeea622f2586f161d1b5d11201c0a69 = 1;
                                                c03df96e967d7177ede70d5c100f08e3c13.mda5f5a0a10736238394cfb52a181ed8d = 3;
                                                c03df96e967d7177ede70d5c100f08e3c13.mda5c5330c6e22693cd8160b7b6526591 = 1;
                                                Mevius.Collaboration.FF7.Api.SetDamageSourceBuff(c03df96e967d7177ede70d5c100f08e3c13, materiaSlotInfo.abilityInfos[j]);
                                            }
                                        }
                                        else if (materiaSlotInfo.abilityInfos[j].buffs.Count != 0)
                                        {
                                            Mevius.Collaboration.FF7.Api.SetDamageSourceBuff(c03df96e967d7177ede70d5c100f08e3c11, materiaSlotInfo.abilityInfos[j]);
                                        }
                                    }
                                }
                            }
                        }
                    }
                }
                this.m_ff7Ability = ScriptableObject.CreateInstance<Ceaf68fb2356fb8b84facc86d2fe79f0e>();
                this.m_ff7Ability.dataLines = list.ToArray();
                this.m_ff7Ability.Register();
                for (int l = 0; l < this.m_ff7Ability.dataLines.Length; l++)
                {
                    Mevius.Loader.Api.LoadAbility(this.m_ff7Ability.dataLines[l].m03efb1c6d38a191c6a0ae0c5f55ec129());
                }
                this.m_ff7DamageSource = ScriptableObject.CreateInstance<C9834a30e5f3368ef11b898eb90b12c5b>();
                this.m_ff7DamageSource.dataLines = list2.ToArray();
                this.m_ff7DamageSource.Register();
            }
        }

        public void EndFF7Ability()
        {
            if (!BattleUtility.IsFF7Gimmick())
            {
                return;
            }
            if (this.m_ff7Ability != null)
            {
                for (int i = 0; i < this.m_ff7Ability.dataLines.Length; i++)
                {
                    Mevius.Loader.Api.UnLoadAbility(this.m_ff7Ability.dataLines[i].m03efb1c6d38a191c6a0ae0c5f55ec129());
                }
                this.m_ff7Ability.Unregister();
                UnityEngine.Object.DestroyImmediate(this.m_ff7Ability);
                this.m_ff7Ability = null;
            }
            if (this.m_ff7DamageSource != null)
            {
                this.m_ff7DamageSource.Unregister();
                UnityEngine.Object.DestroyImmediate(this.m_ff7DamageSource);
                this.m_ff7DamageSource = null;
            }
        }

        public void InitFF8Ability()
        {
            if (!BattleUtility.IsFF8Gimmick())
            {
                return;
            }
            for (int i = 0; i < this.ff8DrawAbility.Length; i++)
            {
                if (this.ff8DrawAbility[i] == null)
                {
                    this.ff8DrawAbility[i] = new BattleManager.DrawAbility();
                }
            }
        }

        public void EndFF8Ability()
        {
            if (!BattleUtility.IsFF8Gimmick())
            {
                return;
            }
            for (int i = 0; i < this.ff8DrawAbility.Length; i++)
            {
                if (this.ff8DrawAbility[i] != null)
                {
                    this.ff8DrawAbility[i].Clear();
                }
            }
        }

        public bool IsFreeAbility()
        {
            return false;
        }

        public void RevivePlayer()
        {
            this.m_playerActor.OnRevive();
            if (this.m_playerActorSub != null && this.m_playerActorSub.IsSummon())
            {
                this.m_playerActorSub.OnReviveSummon();
            }
            if (BattleUtility.IsOptima())
            {
                this.m_optimaUseCounts[0] = (byte)Mevius.Db.Api.GetOptimaLevelAttacker();
                this.m_optimaUseCounts[1] = (byte)Mevius.Db.Api.GetOptimaLevelBlaster();
                this.m_optimaUseCounts[2] = (byte)Mevius.Db.Api.GetOptimaLevelDefender();
            }
            if (BattleUtility.IsFF7Gimmick())
            {
                FF7MateriaSheet ff7CurrentMateriaSet = Mevius.Db.Api.GetFF7CurrentMateriaSet();
                if (ff7CurrentMateriaSet != null)
                {
                    C1a80abc65223cbedf4c65f351d473ca0.C68ded254e0859e604ece0328b8447fa0 dsElement = ff7CurrentMateriaSet.DsElement;
                    if (dsElement != null)
                    {
                        byte b = dsElement.m47f624eef22687da96fbcbb211db2c8e();
                        for (int i = 0; i < this.m_ff7AbilityUseCounts.Length; i++)
                        {
                            this.m_ff7AbilityUseCounts[i] = b;
                        }
                    }
                }
            }
            if (this.IsCountTimeBattle())
            {
                float num = 1f;
                Caa051806b3598cc4aa2892b0900bdadb.C7515a628c1d13daf08c8a160fb5c564e targetStepBattle = Mevius.Field.Api.BattleApi.GetTargetStepBattle(Mevius.Field.Api.GadgetRouteApi.GetTargetGadgetName(), Mevius.App.Api.GetMainJobTypeCurrentDeck());
                if (targetStepBattle != null && BattleTest._i == null)
                {
                    num += (float)targetStepBattle.m5b49e9c72574a286a4b602ef72eff9f1() / 100f;
                }
                if (num != 0f && this.m_playerActor != null && this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59 != null)
                {
                    C43401f69745a04cbd6ee6dcffba76ae5.Ca4d3b5367a73030692d322e3f08669b5 ca4d3b5367a73030692d322e3f08669b = C43401f69745a04cbd6ee6dcffba76ae5.Find(this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59.mb95164dbb096f52883c4e02005721de1());
                    if (ca4d3b5367a73030692d322e3f08669b != null)
                    {
                        this.m_actionPower = (float)ca4d3b5367a73030692d322e3f08669b.mb340f1c79854e240a4cb690d3cacca53();
                        GuiBattleMenu.Instance.TimeLine.ActionPower = this.m_actionPower;
                    }
                }
            }
            this.ProcManToMan();
        }

        public void HideBattleEnemyActionName()
        {
            this.m_abilityMessageTime = new PreciseTime(0f);
            Mevius.Gui.Api.HideBattleEnemyActionName();
        }

        public void UpdateAbilityMessage()
        {
            if (this.m_abilityMessageTime.GetSecond() > 0f)
            {
                this.m_abilityMessageTime -= Mevius.App.Api.GetPreciseTimeForBattle();
                if (this.m_abilityMessageTime.GetSecond() <= 0f)
                {
                    Mevius.Gui.Api.HideBattleEnemyActionName();
                }
            }
        }

        public bool IsShowAbilityMessage()
        {
            return this.m_abilityMessageTime.GetSecond() > 0f;
        }

        public void ShowAbilityMessage(string name, ElementAttributeBitType attributeBit, float sec)
        {
            if (0f < sec)
            {
                Mevius.Gui.Api.ShowBattleEnemyActionName(name, attributeBit);
                this.m_abilityMessageTime = new PreciseTime(sec);
            }
        }

        public void HideAbilityMessage()
        {
            if (this.IsShowAbilityMessage())
            {
                this.m_abilityMessageTime = new PreciseTime(0f);
                Mevius.Gui.Api.HideBattleEnemyActionName();
            }
        }

        public int GetMultiRoleTypeCount(int type, bool isActive)
        {
            int num = 0;
            for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
            {
                if (this.m_multiBattleActorList[i] != null && (int)this.m_multiBattleActorList[i].C648971f118c7e1100318b6fb7ac13b59.m3466576105ab362c4a8efc294dbbdd80() == type && (!isActive || this.m_multiBattleActorList[i].IsActive()))
                {
                    num++;
                }
            }
            return num;
        }

        public void ProcManToMan()
        {
            int enemyNum = this.GetEnemyNum(false);
            if (Mevius.App.Api.IsPartyMode())
            {
                int num = -1;
                if (enemyNum == 1)
                {
                    for (int i = 0; i < this.m_multiBattleActorList.Count; i++)
                    {
                        if (!this.m_multiBattleActorList[i].IsDead())
                        {
                            if (num != -1)
                            {
                                num = -1;
                                break;
                            }
                            num = i;
                        }
                    }
                }
                for (int j = 0; j < this.m_multiBattleActorList.Count; j++)
                {
                    this.m_multiBattleActorList[j].SetManToMan(j == num);
                }
            }
            else if (enemyNum == 1 && !this.m_playerActor.IsDead())
            {
                this.m_playerActor.SetManToMan(true);
            }
            else
            {
                this.m_playerActor.SetManToMan(false);
            }
        }

        public bool IsCountTimeBattle()
        {
            return this.SecondPartBattleTest || Mevius.Db.Api.IsSelectedStory(1);
        }

        public void CreateActionOrderList()
        {
            if (this.m_turnNum == 0)
            {
                return;
            }
            this.m_actionOrderList.Clear();
            List<BattleActor> list = new List<BattleActor>(this.m_actorList.Count);
            for (int i = 0; i < this.m_actorList.Count; i++)
            {
                BattleActor battleActor = this.m_actorList[i];
                if (battleActor != null && battleActor.IsEnemy() && battleActor.IsActive())
                {
                    bool flag = false;
                    for (int j = 0; j < list.Count; j++)
                    {
                        if (battleActor.ActionPriority > list[j].ActionPriority)
                        {
                            list.Insert(j, battleActor);
                            flag = true;
                            break;
                        }
                    }
                    if (!flag)
                    {
                        list.Add(battleActor);
                    }
                }
            }
            list.Insert(0, this.m_playerActor);
            if (this.IsZone())
            {
                int zoneActionNum = this.GetZoneActionNum();
                for (int k = 0; k < zoneActionNum; k++)
                {
                    this.m_actionOrderList.Add(new BattleManager.ActionOrderInfo(this.m_playerActor, 0f, true));
                }
            }
            for (int l = 0; l < list.Count; l++)
            {
                List<float> actionTimeList = list[l].ActionTimeList;
                int count = actionTimeList.Count;
                for (int m = 0; m < count; m++)
                {
                    bool flag2 = false;
                    int count2 = this.m_actionOrderList.Count;
                    for (int n = 0; n < count2; n++)
                    {
                        if (actionTimeList[m] < this.m_actionOrderList[n].Time)
                        {
                            this.m_actionOrderList.Insert(n, new BattleManager.ActionOrderInfo(list[l], actionTimeList[m], false));
                            flag2 = true;
                            break;
                        }
                    }
                    if (!flag2)
                    {
                        this.m_actionOrderList.Add(new BattleManager.ActionOrderInfo(list[l], actionTimeList[m], false));
                    }
                }
            }
            GuiBattleMenu.Instance.TimeLine.SyncIcons(this.m_actionOrderList);
            if (this.m_activeActionOrderActor != null && (!this.m_activeActionOrderActor.IsTimeLineActionStart() || this.m_activeActionOrderActor.IsActionAbilitySkill5402()))
            {
                for (int num = 0; num < this.m_actionOrderList.Count; num++)
                {
                    if (this.m_actionOrderList[num].Actor == this.m_activeActionOrderActor)
                    {
                        this.m_actionOrderList.RemoveAt(num);
                        break;
                    }
                }
            }
        }

        public int GetZoneActionNum()
        {
            if (this.IsZone())
            {
                return this.m_actionGauge / 100;
            }
            return 0;
        }

        public BattleActor StealActionOrderActor
        {
            get
            {
                return this.m_stealActionOrderActor;
            }
        }

        public bool IsPlayerTurn()
        {
            if (this.IsCountTimeBattle())
            {
                return this._step == BattleManager.BattleStep.CTB && this.m_activeActionOrderActor != null && this.m_activeActionOrderActor.IsPlayer();
            }
            return this._step == BattleManager.BattleStep.PlayerTurn;
        }

        public bool IsEnemyTurn()
        {
            if (this.IsCountTimeBattle())
            {
                return this._step == BattleManager.BattleStep.CTB && this.m_activeActionOrderActor != null && this.m_activeActionOrderActor.IsEnemy();
            }
            return this._step == BattleManager.BattleStep.EnemyTurnStart || this._step == BattleManager.BattleStep.EnemyTurn;
        }

        public float ActiveActionOrderTime
        {
            get
            {
                return this.m_activeActionOrderTime;
            }
        }

        public void RequestCreateActionOrderList()
        {
            this.m_actionOrderListCreateFlag = true;
        }

        public void ChangeActionValue(BattleManager.ChangeActionValueType type, bool updateGui = true)
        {
            if (!this.IsCountTimeBattle())
            {
                return;
            }
            if (this.IsZone())
            {
                return;
            }
            if (this.m_playerActor != null && this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59 != null)
            {
                C43401f69745a04cbd6ee6dcffba76ae5.Ca4d3b5367a73030692d322e3f08669b5 ca4d3b5367a73030692d322e3f08669b = C43401f69745a04cbd6ee6dcffba76ae5.Find(this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59.mb95164dbb096f52883c4e02005721de1());
                if (ca4d3b5367a73030692d322e3f08669b != null)
                {
                    int num = (int)ca4d3b5367a73030692d322e3f08669b.mb340f1c79854e240a4cb690d3cacca53();
                    int residentInteger = Mevius.DataSheet.Api.GetResidentInteger("ctbActionGaugeMax", 800);
                    float num2 = 1f;
                    Caa051806b3598cc4aa2892b0900bdadb.C7515a628c1d13daf08c8a160fb5c564e targetStepBattle = Mevius.Field.Api.BattleApi.GetTargetStepBattle(Mevius.Field.Api.GadgetRouteApi.GetTargetGadgetName(), Mevius.App.Api.GetMainJobTypeCurrentDeck());
                    if (targetStepBattle != null && BattleTest._i == null)
                    {
                        num2 += (float)targetStepBattle.m5b49e9c72574a286a4b602ef72eff9f1() / 100f;
                    }
                    switch (type)
                    {
                    case BattleManager.ChangeActionValueType.ActionPlayer:
                    {
                        int value = this.m_actionGauge + (int)(((float)ca4d3b5367a73030692d322e3f08669b.m0d4848e106bd680cfd1196f8ba0c3d42() + this.m_actionPower) * num2);
                        float recover = (float)ca4d3b5367a73030692d322e3f08669b.m1d2f620da6509c5de5188e913f3c0742() / 100f;
                        this.SetActionGauge(value, residentInteger, recover, updateGui);
                        if (num2 != 0f)
                        {
                            float value2 = this.m_actionPower + ca4d3b5367a73030692d322e3f08669b.mc276dff0be9d55356493915ce0070e33();
                            this.SetActionPower(value2, (float)num);
                        }
                        break;
                    }
                    case BattleManager.ChangeActionValueType.KillEnemy:
                    {
                        int value3 = this.m_actionGauge + (int)((float)ca4d3b5367a73030692d322e3f08669b.mffa9952c38b62a6eada7503c4de83482() * num2);
                        this.SetActionGauge(value3, residentInteger, 0f, updateGui);
                        if (num2 != 0f)
                        {
                            float value4 = this.m_actionPower + (float)ca4d3b5367a73030692d322e3f08669b.m20d90c80b763769e240a44e9347cf29a();
                            this.SetActionPower(value4, (float)num);
                        }
                        break;
                    }
                    case BattleManager.ChangeActionValueType.Steal:
                    {
                        int value5 = this.m_actionGauge + (int)((float)ca4d3b5367a73030692d322e3f08669b.m135ec1c46a38ce63faae8044f737b817() * num2);
                        this.SetActionGauge(value5, residentInteger, 0f, updateGui);
                        if (num2 != 0f)
                        {
                            float value6 = this.m_actionPower + (float)ca4d3b5367a73030692d322e3f08669b.ma774aa87a223efb82099d5ba203a6622();
                            this.SetActionPower(value6, (float)num);
                        }
                        break;
                    }
                    case BattleManager.ChangeActionValueType.ActionEnemy:
                    {
                        int value7 = this.m_actionGauge + (int)(((float)(this.m_actionGauge * (int)ca4d3b5367a73030692d322e3f08669b.md348615865b30fc23159943e470701f1()) / 100f + this.m_actionPower * (float)ca4d3b5367a73030692d322e3f08669b.m2a4ecb387a60b0c66ac23d1dfb5e1cde() / 100f) * num2);
                        this.SetActionGauge(value7, residentInteger, 0f, updateGui);
                        if (num2 != 0f)
                        {
                            float value8 = this.m_actionPower + this.m_actionPower * (float)ca4d3b5367a73030692d322e3f08669b.md9ee2a013615a45d7fd85b22d6e4f527() / 100f;
                            this.SetActionPower(value8, (float)num);
                        }
                        break;
                    }
                    case BattleManager.ChangeActionValueType.ProgressTurn:
                    {
                        int value9 = this.m_actionGauge + (int)((float)(this.m_actionGauge * (int)ca4d3b5367a73030692d322e3f08669b.md2ff17394ade512fba8c9c4e5bf87632()) / 100f * num2);
                        this.SetActionGauge(value9, residentInteger, 0f, updateGui);
                        if (num2 != 0f)
                        {
                            float value10 = this.m_actionPower + this.m_actionPower * (float)ca4d3b5367a73030692d322e3f08669b.maf550547d585eb4e42c34d19eea74403() / 100f;
                            this.SetActionPower(value10, (float)num);
                        }
                        break;
                    }
                    case BattleManager.ChangeActionValueType.BattleEnd:
                    {
                        int value11 = this.m_actionGauge + (int)(((float)(this.m_actionGauge * (int)ca4d3b5367a73030692d322e3f08669b.md348615865b30fc23159943e470701f1()) / 100f + (float)ca4d3b5367a73030692d322e3f08669b.mf73a728d036d8e88a559e7efa5f2dae7()) * num2);
                        this.SetActionGauge(value11, residentInteger, 0f, updateGui);
                        if (num2 != 0f)
                        {
                            float value12 = this.m_actionPower + this.m_actionPower * (float)ca4d3b5367a73030692d322e3f08669b.md9ee2a013615a45d7fd85b22d6e4f527() / 100f + (float)ca4d3b5367a73030692d322e3f08669b.mfd01d9f5ba5b7994703058402fef27e6();
                            this.SetActionPower(value12, (float)num);
                        }
                        break;
                    }
                    }
                }
            }
        }

        public void DecrementActionGaugeSubStrike()
        {
            if (this.m_playerActor != null)
            {
                C43401f69745a04cbd6ee6dcffba76ae5.Ca4d3b5367a73030692d322e3f08669b5 ca4d3b5367a73030692d322e3f08669b = C43401f69745a04cbd6ee6dcffba76ae5.Find(this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59.mb95164dbb096f52883c4e02005721de1());
                if (ca4d3b5367a73030692d322e3f08669b != null)
                {
                    int actionGauge = this.m_actionGauge - (int)ca4d3b5367a73030692d322e3f08669b.m8ffedb5dbe5912c2b2eb70f721a7dfac();
                    this.SetActionGauge(actionGauge);
                }
            }
        }

        public void DecrementActionGaugeZoneAction()
        {
            int actionGauge = this.m_actionGauge - Mevius.DataSheet.Api.GetResidentInteger("ctbDecrementActionGaugeZoneAction", 100);
            this.SetActionGauge(actionGauge);
        }

        public void DecrementActionGaugeJobChange()
        {
            int actionGauge = this.m_actionGauge - this.m_jobChangeActionGauge;
            this.SetActionGauge(actionGauge);
        }

        public int GetJobChangeActionGauge()
        {
            if (this.m_playerActor != null && this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59 != null)
            {
                C43401f69745a04cbd6ee6dcffba76ae5.Ca4d3b5367a73030692d322e3f08669b5 ca4d3b5367a73030692d322e3f08669b = C43401f69745a04cbd6ee6dcffba76ae5.Find(this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59.mb95164dbb096f52883c4e02005721de1());
                if (ca4d3b5367a73030692d322e3f08669b != null)
                {
                    int num;
                    this.m_playerActor.GetAutoAbilityParam(DbManager.AutoAbilityType.AUTOABILITYTYPE_CS1410, out num);
                    this.PlayerJobChangeChargeTurn = (byte)num;
                    return (int)ca4d3b5367a73030692d322e3f08669b.m38abe99a7fb15538a9e7e7a339aba947() - (4 - num) * 100;
                }
            }
            return 0;
        }

        public float ActionPower
        {
            get
            {
                return this.m_actionPower;
            }
        }

        public void SetActionPower(float value)
        {
            if (this.m_playerActor != null && this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59 != null)
            {
                C43401f69745a04cbd6ee6dcffba76ae5.Ca4d3b5367a73030692d322e3f08669b5 ca4d3b5367a73030692d322e3f08669b = C43401f69745a04cbd6ee6dcffba76ae5.Find(this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59.mb95164dbb096f52883c4e02005721de1());
                if (ca4d3b5367a73030692d322e3f08669b != null)
                {
                    this.SetActionPower(value, (float)ca4d3b5367a73030692d322e3f08669b.mb340f1c79854e240a4cb690d3cacca53());
                }
            }
        }

        private void SetActionPower(float value, float valueMax)
        {
            value = Math.Max(value, 0f);
            value = Math.Min(value, valueMax);
            this.m_actionPower = value;
            GuiBattleMenu.Instance.TimeLine.ActionPower = value;
            GuiBattleMenu.Instance.TimeLine.ActionPowerMax = valueMax;
        }

        public int ActionGauge
        {
            get
            {
                return this.m_actionGauge;
            }
        }

        public void SetActionGauge(int value)
        {
            this.SetActionGauge(value, Mevius.DataSheet.Api.GetResidentInteger("ctbActionGaugeMax", 800), 0f, true);
        }

        private void SetActionGauge(int value, int valueMax, float recover, bool updateGui = true)
        {
            value = Math.Max(value, 0);
            value = Math.Min(value, valueMax);
            if (value < this.m_actionGauge)
            {
                if (!this.IsZone())
                {
                    this.m_actionGaugeDecrease = this.m_actionGauge;
                }
            }
            else if (value < this.m_actionGaugeDecrease && recover != 0f)
            {
                value += (int)((float)(this.m_actionGaugeDecrease - value) * recover + 0.5f);
                value = Math.Max(value, 0);
                value = Math.Min(value, valueMax);
            }
            this.m_actionGauge = value;
            if (GuiBattleMenu.Instance.TimeLine != null && updateGui)
            {
                GuiBattleMenu.Instance.TimeLine.ActionGaugeMax = valueMax;
                GuiBattleMenu.Instance.TimeLine.ActionGauge = this.m_actionGauge;
                GuiBattleMenu.Instance.TimeLine.RecoveryGauge = Mathf.Max(this.m_actionGaugeDecrease - this.m_actionGauge, 0);
            }
        }

        public int ActionGaugeDecrease
        {
            get
            {
                return this.m_actionGaugeDecrease;
            }
            set
            {
                this.m_actionGaugeDecrease = value;
            }
        }

        public void ProcSubStrikeStart(bool end)
        {
            BattleActor battleActor;
            BattleActor battleActor2;
            if (Mevius.Db.Api.GetParameter(DbManager.ParameterType.Current_Job) != 0)
            {
                if (end)
                {
                    battleActor = this.FindActor(BattleManager.GetBattlePlayerName());
                    battleActor2 = this.FindActor(BattleManager.GetBattlePlayerSubName());
                }
                else
                {
                    battleActor = this.FindActor(BattleManager.GetBattlePlayerSubName());
                    battleActor2 = this.FindActor(BattleManager.GetBattlePlayerName());
                }
            }
            else if (end)
            {
                battleActor = this.FindActor(BattleManager.GetBattlePlayerSubName());
                battleActor2 = this.FindActor(BattleManager.GetBattlePlayerName());
            }
            else
            {
                battleActor = this.FindActor(BattleManager.GetBattlePlayerName());
                battleActor2 = this.FindActor(BattleManager.GetBattlePlayerSubName());
            }
            battleActor.chara.OnSetActive(false, true);
            battleActor.chara.gameObject.SetActive(false);
            battleActor2.chara.PhysicsResetPose();
            battleActor2.chara.gameObject.SetActive(true);
            battleActor2.chara.OnSetActive(true, true);
            bool flag = this.IsPartyChange();
            if (!end)
            {
                int[,] statusEffectEntries = battleActor.GetStatusEffectEntries();
                int[][] array = new int[statusEffectEntries.GetLength(0)][];
                for (int i = 0; i < array.GetLength(0); i++)
                {
                    array[i] = new int[4];
                    array[i][0] = statusEffectEntries[i, 0];
                    array[i][1] = statusEffectEntries[i, 1];
                    array[i][2] = statusEffectEntries[i, 2];
                    array[i][3] = statusEffectEntries[i, 3];
                }
                bool manToMan = battleActor.ManToMan;
                int hpMax = battleActor2.HpMax;
                battleActor2.SetStatusEffectEntries(array);
                battleActor2.ManToMan = manToMan;
                float num = (float)battleActor2.HpMax / (float)hpMax;
                battleActor2.SetHp((int)((float)battleActor2.Hp * num + 0.5f), false, false);
            }
            battleActor2.chara.transform.position = battleActor.chara.transform.position;
            battleActor2.chara.transform.rotation = battleActor.chara.transform.rotation;
            battleActor2.chara.OnSetRotDirection(battleActor.chara.GetRotDirection());
            battleActor2.ActionNum = battleActor.ActionNum;
            battleActor2.NormalAttackCombo = battleActor.NormalAttackCombo;
            battleActor2.SuccessiveActionNum = battleActor.SuccessiveActionNum;
            battleActor2.ActionNumDecrementFlag = battleActor.ActionNumDecrementFlag;
            battleActor2.AbilityCombo = battleActor.AbilityCombo;
            battleActor2.AbilityUseSuportCount = battleActor.AbilityUseSuportCount;
            battleActor.ManaAttributeUseNum.CopyTo(battleActor2.ManaAttributeUseNum, 0);
            if (!flag)
            {
                float hpRate = battleActor.GetHpRate();
                if ((int)(hpRate * 100f) != (int)(battleActor2.GetHpRate() * 100f))
                {
                    int num2 = (int)((float)battleActor2.HpMax * hpRate + 0.5f);
                    if (num2 < 1)
                    {
                        num2 = 1;
                    }
                    battleActor2.SetHp(num2, false, true);
                }
                else
                {
                    battleActor2.SetHp(battleActor2.Hp, false, true);
                }
            }
            battleActor2.TargetActor = battleActor.TargetActor;
            float num3 = (float)battleActor.ManaUseNum / (float)battleActor.JobAbilityUseManaUseNum;
            float num4 = (float)battleActor2.ManaUseNum / (float)battleActor2.JobAbilityUseManaUseNum;
            if ((int)(num3 * 100f) != (int)(num4 * 100f))
            {
                battleActor2.ManaUseNum = (int)((float)battleActor2.JobAbilityUseManaUseNum * num3 + 0.5f);
                if (num3 < 1f && battleActor2.ManaUseNum == battleActor2.JobAbilityUseManaUseNum)
                {
                    battleActor2.ManaUseNum--;
                }
            }
            battleActor2.PrevUseCardAbilityAttribute = battleActor.PrevUseCardAbilityAttribute;
            battleActor2.State = battleActor.State;
            battleActor2.CopyActionTimeList(battleActor.ActionTimeList);
            battleActor.SetWeaponEffectLoopOff();
            battleActor.LoopOffSeraResidentEffect();
            battleActor2.SetEnchantWeaponEffect();
            battleActor2.SetSeraResidentEffect();
            this.m_cameraManager.OnJobChange(battleActor, battleActor2);
            this.m_playerActor = battleActor2;
            this.m_playerActorSub = battleActor;
            if (this.m_playerActor.ActionNum == 0)
            {
                BattleManager._i.OnEnemyNoActionPlayerActionContinue();
            }
            if (end)
            {
                battleActor2.SubActionMainIn();
            }
            else
            {
                battleActor2.SubActionSubIn();
            }
            if (!flag)
            {
                Mevius.Effect.Api.CreateInstance(new Mevius.Effect.Api.CreateInstanceArg
                {
                    m_strResourceName = Mevius.Effect.Api.GetResourceName(Mevius.Effect.Constants.ResourceCategory.Resident, string.Empty),
                    m_strSubResource = "change_001",
                    m_BindActor = battleActor2.chara.gameObject
                });
            }
            Mevius.Sound.Api.StopSound(this.m_jobChangeSoundHandle, 100);
            this.m_jobChangeSoundHandle = this.m_playerActor.PlayStateSound(StateSound.StateSoundType.JobChange);
            GameObject gameObject = battleActor2.chara.gameObject;
            if (gameObject)
            {
                FacialController component = gameObject.GetComponent<FacialController>();
                if (component != null)
                {
                    int playTime = Mevius.Sound.Api.GetPlayTime(this.m_jobChangeSoundHandle);
                    if (playTime > 0)
                    {
                        PreciseTime preciseTime = new PreciseTime((float)playTime / 1000f * 0.9f);
                        component.EnableLipsync = true;
                        component.StartLipsync(preciseTime.GetSecond());
                    }
                }
            }
            string soundResourceName = Mevius.Sound.Api.GetSoundResourceName("Resident");
            Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Field_3D, soundResourceName, "system_se_jobchange", 1f, 0, 0, this.m_playerActor.chara.transform.position, null, false, -1, 0, 1f);
            this.SetFairyFollowPlayer(true);
            if (end)
            {
                this.CreateActionOrderList();
            }
        }

        public bool CanUseSubStrike()
        {
            if (this.m_playerActor != null)
            {
                C43401f69745a04cbd6ee6dcffba76ae5.Ca4d3b5367a73030692d322e3f08669b5 ca4d3b5367a73030692d322e3f08669b = C43401f69745a04cbd6ee6dcffba76ae5.Find(this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59.mb95164dbb096f52883c4e02005721de1());
                if (ca4d3b5367a73030692d322e3f08669b != null)
                {
                    return (int)ca4d3b5367a73030692d322e3f08669b.m8ffedb5dbe5912c2b2eb70f721a7dfac() <= this.m_actionGauge;
                }
            }
            return false;
        }

        public bool IsSubAction()
        {
            return this.SubActionType != BattleManager.ESubActionType.None;
        }

        public bool IsSubStrike()
        {
            return this.SubActionType == BattleManager.ESubActionType.Ability;
        }

        public bool IsZone()
        {
            return this.m_zone;
        }

        private void UpdateZone(out bool zoneStart)
        {
            zoneStart = false;
            if (this.m_zone)
            {
                if (this.m_actionGauge <= 0)
                {
                    this.EndZone(false, false);
                }
            }
            else if (Mevius.DataSheet.Api.GetResidentInteger("ctbActionGaugeMax", 800) <= this.m_actionGauge)
            {
                if (this.m_playerActor != null)
                {
                    C43401f69745a04cbd6ee6dcffba76ae5.Ca4d3b5367a73030692d322e3f08669b5 ca4d3b5367a73030692d322e3f08669b = C43401f69745a04cbd6ee6dcffba76ae5.Find(this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59.mb95164dbb096f52883c4e02005721de1());
                    if (ca4d3b5367a73030692d322e3f08669b != null)
                    {
                        this.m_actionPower = (float)ca4d3b5367a73030692d322e3f08669b.mb340f1c79854e240a4cb690d3cacca53();
                        GuiBattleMenu.Instance.TimeLine.ActionPower = this.m_actionPower;
                    }
                }
                this.m_zone = true;
                this.m_actionGaugeDecrease = 0;
                string soundResourceName = Mevius.Sound.Api.GetSoundResourceName("Resident");
                Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Gui, soundResourceName, "system_se_mzone_in", 1f, 0, 0, false, -1, 1f);
                this.m_zoneSoundHandle = Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Gui, soundResourceName, "system_se_mzone_loop", 1f, 0, 0, false, -1, 1f);
                Mevius.Effect.Api.CreateInstance(new Mevius.Effect.Api.CreateInstanceArg
                {
                    m_strResourceName = Mevius.Effect.Api.GetResourceName(Mevius.Effect.Constants.ResourceCategory.Resident, string.Empty),
                    m_strSubResource = "mzone_fil_001",
                    m_bIgnoreTimeScale = true
                });
                this.CreateActionOrderList();
                BattleUtility.AddMissionCount(MissionCountType.ZoneCount, 1);
                for (int i = 0; i < this._entryBattleCharaSpecList.Count; i++)
                {
                    string enemyActorName = BattleManager.GetEnemyActorName(i);
                    BattleActor battleActor = this.FindActor(enemyActorName);
                    if (battleActor != null && battleActor.IsActive() && battleActor.Ai != null)
                    {
                        battleActor.Ai.OnBehavior(BattleAiData.Pattern.TimingType.ZoneStart, string.Empty, null, true);
                    }
                }
                if (this.m_playerActor != null)
                {
                    this.m_playerActor.UpdateJobAbilityGauge();
                }
                zoneStart = true;
                GuiBattleMenu.Instance.TimeLine.RecoveryGauge = Mathf.Max(this.m_actionGaugeDecrease - this.m_actionGauge, 0);
                GuiBattleMenu.Instance.ShowMobiusZone();
            }
            GuiBattleMenu.Instance.IsZone = this.m_zone;
        }

        public void EndZone(bool jobAbility, bool createActionOrderList)
        {
            if (this.m_zone)
            {
                this.m_zone = false;
                this.m_subActionType = BattleManager.ESubActionType.None;
                this.m_actionPower = 0f;
                Mevius.Sound.Api.StopSound(this.m_zoneSoundHandle, 1000);
                this.m_zoneSoundHandle = 0;
                string soundResourceName = Mevius.Sound.Api.GetSoundResourceName("Resident");
                Mevius.Sound.Api.CreateSound(SoundManager.SoundCategory.Gui, soundResourceName, "system_se_mzone_end", 1f, 0, 0, false, -1, 1f);
                if (jobAbility && this.m_playerActor != null)
                {
                    C43401f69745a04cbd6ee6dcffba76ae5.Ca4d3b5367a73030692d322e3f08669b5 ca4d3b5367a73030692d322e3f08669b = C43401f69745a04cbd6ee6dcffba76ae5.Find(this.m_playerActor.C648971f118c7e1100318b6fb7ac13b59.mb95164dbb096f52883c4e02005721de1());
                    if (ca4d3b5367a73030692d322e3f08669b != null)
                    {
                        this.m_actionGauge = this.m_actionGauge * (int)ca4d3b5367a73030692d322e3f08669b.m31caf9df2e1e38cb41fe408d2a600a06() / 100;
                        GuiBattleMenu.Instance.TimeLine.ActionGauge = this.m_actionGauge;
                    }
                }
                if (createActionOrderList)
                {
                    this.CreateActionOrderList();
                }
                this.m_activeActionOrderActor.UpdateJobAbilityGauge();
                GuiBattleMenu.Instance.IsZone = this.m_zone;
            }
        }

        public void GetJobAbilityName(out string mainJobAbilityName, out string subJobAblityName)
        {
            BattleActor battleActor = this.m_playerActor;
            if (this.IsCountTimeBattle() && battleActor.IsSubActionSub())
            {
                battleActor = this.m_playerActorSub;
            }
            if (battleActor != null)
            {
                if (this.IsCountTimeBattle() && this.IsZone())
                {
                    BattleActor battleActor2 = this.m_playerActorSub;
                    if (battleActor == battleActor2)
                    {
                        battleActor2 = this.m_playerActor;
                    }
                    if (battleActor2 != null)
                    {
                        if (this.m_playerActor.IsJobAbilityGaugeMax())
                        {
                            mainJobAbilityName = battleActor2.GetJobAbilityTextResourceId();
                            subJobAblityName = battleActor.GetJobAbilityTextResourceId();
                        }
                        else
                        {
                            mainJobAbilityName = battleActor2.GetJobAbilityTextResourceId();
                            subJobAblityName = string.Empty;
                        }
                    }
                    else
                    {
                        mainJobAbilityName = battleActor.GetJobAbilityTextResourceId();
                        subJobAblityName = string.Empty;
                    }
                }
                else
                {
                    mainJobAbilityName = battleActor.GetJobAbilityTextResourceId();
                    subJobAblityName = string.Empty;
                }
            }
            else
            {
                mainJobAbilityName = string.Empty;
                subJobAblityName = string.Empty;
            }
        }

        private const float DirectTargetSelectCheckDist = 0.125f;

        private const float DirectTargetSelectCheckDistTargetView = 0.25f;

        private const float InputViewportMax = 0.9375f;

        private const float InputViewportMin = 0.171875f;

        public static BattleManager _i = new BattleManager();

        private static readonly byte SaveDataVersion = 3;

        private static readonly byte MultiSaveDataVersion = 0;

        private uint charaspecUnloadTaskId;

        private uint resourceUnloadTaskId;

        private BattleManager.BattleStep _step;

        private uint connectTask;

        private BattleManager.ResourceStep _resourceStep;

        private BattleManager.MultiBattleCmdStep m_multiBattleCmdStep;

        private BattleManager.MultiBattleCmdStep m_multiBattleCmdStepAfterSync;

        private BattleManager.BattleStep m_stepAfterSync;

        private Mevius.Party.Api.SnapStepType m_snapType;

        private HashSet<string> _actorNameList;

        private float m_actionStepWait;

        private bool m_lastBattle;

        private bool m_lastBgmVolumeChanged;

        public string currentBattleScene;

        private int m_enemyLevel;

        private List<string> _entryBattleCharaSpecList;

        private HashSet<string> _loadCharaSpecList;

        private BattleCameraManager m_cameraManager;

        private Vector3 _basePosition = Vector3.zero;

        private int m_breakNum;

        private int m_chainNum;

        private int m_turnNum;

        private int m_deadNum;

        private float m_placementPlayerDistanceStart;

        private float m_placementPlayerDistanceEnd;

        private string m_placementEnemyId;

        public bool m_boss;

        private bool m_chaosBattle;

        private bool m_shadowBlankBattle;

        private bool m_forceAllCameraBattle;

        private string m_targetSelectCameraName;

        private BattleActor m_playerActor;

        private BattleActor m_playerActorSub;

        private BattleActor m_selfActor;

        private BattleActor m_targetActor;

        private BattleFairyActor m_fairyActor;

        private bool m_partyMemberTurn;

        private List<BattleActor> m_multiBattleActorList = new List<BattleActor>();

        private int m_multiBattleCurrentOrder;

        private List<int> m_multiBattleSlotList = new List<int>();

        private List<BattleActor> m_updateReadyActionList = new List<BattleActor>(4);

        private List<BattleActor> m_updatedList = new List<BattleActor>(4);

        private Mevius.Effect.Api.EffectHandle m_multiBattleActorCursorHandle;

        private ulong m_multiBattleStartTime;

        private ulong m_multiBattleTurnStartTime;

        private ulong m_multiBattleTurnLimitTime;

        private bool m_multiBattleIgnoreMemberActionCamera;

        private Vector2 m_touchDownPos;

        private Vector2[] m_touchPos = new Vector2[2];

        private bool m_inputCheck;

        private bool m_inputTouch;

        private bool m_stayMove;

        private static float TargetSelectHrzAngleAdjust = 55f;

        private static float TargetSelectVrtAngleAdjust = 85f;

        private bool m_inputAccepted;

        private Vector2 m_lastTouchPos;

        private bool m_lasTouchPosInited;

        private BattleManager.AutoAttackType m_autoAttack;

        private float m_autoAttackTimer;

        private GameObject m_rootObject;

        private List<BattleActor> m_actorList = new List<BattleActor>();

        private List<BattleActor> m_actionPriorityEnemyActorList = new List<BattleActor>();

        private BattleDamageSourceManager m_damageSourceManager = new BattleDamageSourceManager();

        private BattleManaObjectManager m_manaObjectManager = new BattleManaObjectManager();

        private Mevius.Gui.Api.GuiHandle m_MsgHandle;

        private BattleSlow m_battleSlow = new BattleSlow();

        private BattleTutorialManager m_tutorialManager;

        private SurfaceBlend m_surfaceBlend;

        private float m_surfaceBlendAlpha;

        private bool m_bMultiBattleTest;

        private List<BattleActor> m_screenOrderEnemyActorList = new List<BattleActor>();

        private List<Vector3> m_screenOrderEnemyPosList = new List<Vector3>();

        private BattleManager.BattleGuiTouchComponent m_guiTouchComponent = new BattleManager.BattleGuiTouchComponent();

        public bool m_ignoreAttack;

        private BattleManager.FairyEffectType m_fairyEffectType;

        private bool m_presetFairyEffect;

        private bool m_lastEnemyEscape;

        private Mevius.Common.Random m_rand = new Mevius.Common.Random();

        private Mevius.Common.Random m_playerDamageRand = new Mevius.Common.Random();

        private Mevius.Common.Random m_playerMovementRand = new Mevius.Common.Random();

        private int m_randCount;

        private int m_damageRandCount;

        private int m_movementRandCount;

        private PreciseTime m_preciseTime = default(PreciseTime);

        public int BattleHash;

        private short[] m_enemyAiCommonCounters = new short[4];

        private bool m_enemyActionEndFlag;

        private byte m_playerJobChangeChargeTurn;

        private byte m_playerJobChangeThroughTurn;

        private int m_jobChangeSoundHandle;

        private bool m_fairyHour;

        private bool m_isJobBgm;

        private bool m_isBgmRandSet;

        private uint m_bgmRandValue;

        private Mevius.Effect.Api.EffectHandle m_breakEffectHandle;

        private bool m_isMultiFinishCamera;

        private OptimaType m_optimaType = OptimaType.None;

        private byte[] m_optimaUseCounts = new byte[3];

        private int[] m_missionCounts = new int[128];

        private int[] m_bossMissionCounts = new int[128];

        private long[] m_saveLongValues = new long[16];

        private long[] m_bossSaveLongValues = new long[16];

        private byte m_playerFinishCount;

        private Ceaf68fb2356fb8b84facc86d2fe79f0e m_ff7Ability;

        private C9834a30e5f3368ef11b898eb90b12c5b m_ff7DamageSource;

        private byte[] m_ff7AbilityUseCounts = new byte[3];

        private PreciseTime m_abilityMessageTime = default(PreciseTime);

        private List<BattleManager.ActionOrderInfo> m_actionOrderList = new List<BattleManager.ActionOrderInfo>();

        private BattleActor m_activeActionOrderActor;

        private BattleActor m_stealActionOrderActor;

        private float m_activeActionOrderTime;

        private bool m_actionOrderListCreateFlag;

        private int m_actionGauge;

        private int m_actionGaugeDecrease;

        private float m_actionPower;

        private int m_jobChangeActionGauge;

        private BattleManager.ESubActionType m_subActionType;

        private bool m_zone;

        private int m_zoneSoundHandle;

        private BattleActor m_dqLogActor;

        private Dictionary<string, sbyte> m_dqSameNameDictionary;

        private BattleManager.DrawAbility[] ff8DrawAbility = new BattleManager.DrawAbility[3];

        private string[] m_ff8LoadAbilityIDs = new string[3];

        private GameObject lastBattleWinActorObject;

        private bool _active;

        private bool _enableUnloadRequest;

        private bool requestStartBattle;

        public static string c_BattleEscapeFade = "BattleEscapeFade";

        private uint taskid;

        public bool SecondPartBattleTest;

        public enum BattleStep
        {
            None,
            CreateActor,
            Init,
            EncountCameraWait,
            MenuCreateWait,
            MenuShowWait,
            AutoClipWait,
            StepBattleEffect,
            BattleStart,
            FairyTurnStart,
            FairyTurn,
            PlayerTurnStart,
            PlayerTurnStartWait,
            PlayerTurn,
            CheckMultiBattleCmd,
            MultiBattleInputStart,
            MultiBattleInputStartWait,
            MultiBattleInput,
            EnemyTurnStart,
            EnemyTurnStartWait,
            EnemyTurn,
            CTBStart,
            CTB,
            EscapeCheck,
            Escape,
            EscapeWait,
            CheckChara,
            CharaDeleteWait,
            CharaCreateWait,
            ContinueCheck,
            ContinueCheckWait,
            MagicStoneCheck,
            WaitBuyMagicStone,
            Continue,
            ContinueWait,
            ContinueDirection,
            ContinueDirectionCTB,
            ResultReady,
            Result,
            PreResultWait,
            PreResultWait2,
            Result2,
            ResultWait,
            ResultIdleWait,
            ResultEnd,
            ActionCameraEndWait,
            ResourceStepUnload,
            ResourceStepUnloadWait,
            End,
            Exit
        }

        public enum ResourceStep
        {
            None,
            Init,
            LoadCharaSpec,
            LoadCharaSpecWait,
            CreateActor,
            CreateActorWait,
            EndRequestWait,
            RemoveActor,
            RemoveActorWait,
            UnloadCharaSpec,
            UnloadCharaSpecWait,
            End
        }

        public enum MultiBattleCmdStep
        {
            None,
            SendSnap,
            SnapSync,
            SnapSyncWait,
            MultiInputWait,
            CurrentPlayer
        }

        public enum AutoAttackType
        {
            Off,
            NormalAutoAttack,
            FullAutoAttack
        }

        public enum AutoAttackStrategyType
        {
            DefensiveType,
            BreakType,
            AttackType,
            StrategyTypeMax
        }

        public enum AutoJobAbilityType
        {
            NoUse,
            UseBreak,
            UseBpArmor,
            Use
        }

        private class BattleGuiTouchComponent : GuiTouchEventComponent.IPressEvent
        {
            public void GuiOnPress(bool isPressed)
            {
                BattleManager._i.m_ignoreAttack = false;
                if (isPressed && UICamera.touchCount == 1)
                {
                    this.m_stateBit |= 3u;
                }
                else if (!isPressed && UICamera.touchCount == 1)
                {
                    this.m_stateBit = 4u;
                }
            }

            public bool GuiOnLongPress(GameObject go)
            {
                return false;
            }

            public void Update()
            {
                this.m_stateBit &= 2u;
            }

            public bool IsPress()
            {
                return (this.m_stateBit & 1u) != 0u;
            }

            public bool IsDown()
            {
                return (this.m_stateBit & 2u) != 0u;
            }

            public bool IsUp()
            {
                return (this.m_stateBit & 4u) != 0u;
            }

            public uint m_stateBit;

            public enum StateType
            {
                Press = 1,
                Down,
                Up = 4
            }
        }

        public enum FairyEffectType
        {
            None,
            Revive,
            Heal,
            Rescue,
            Cheer,
            Encourage
        }

        public struct ActionOrderInfo
        {
            public ActionOrderInfo(BattleActor actor, float time, bool isZone = false)
            {
                this.Actor = actor;
                this.Time = time;
                this.IsZone = isZone;
            }

            public BattleActor Actor;

            public float Time;

            public bool IsZone;
        }

        public enum ChangeActionValueType
        {
            ActionPlayer,
            KillEnemy,
            Steal,
            ActionEnemy,
            ProgressTurn,
            BattleEnd
        }

        public enum ESubActionType
        {
            None,
            Ability,
            JobAbility
        }

        public class DrawAbility
        {
            public DrawAbility()
            {
                this.id = 0;
                this.Datasheet = null;
                this.remainingCount = 0;
            }

            public void Clear()
            {
                this.id = 0;
                this.remainingCount = 0;
                this.Datasheet = null;
            }

            public int id;

            public C4c26d468b97150ce002ae9a639f4ea2a.C1dc494102b702de4447e82ad4b8a1927 Datasheet;

            public int remainingCount;
        }

        public enum LastBattleWinCameraType
        {
            Player,
            Fairy
        }

        public enum EncountType
        {
            Normal,
            Caution
        }

        private class AutoFocusInfo
        {
            public BattleActor actor;

            public float radian = 3.14159274f;

            public Vector3 dir;
        }
    }
}