using System;
using System.Collections;
using System.Collections.Generic;
using System.Linq;
using TMPro;
using UnityEngine;
using UnityEngine.SceneManagement;
using UnityEngine.UI;

public class BattleSystem : MonoBehaviour
{
    public enum BattleState
    {
        Disabled = 0,
        Intro = 1,
        PlayerTurn = 2,
        PlayerUseRound = 3,
        Dialogue = 4,
        Cutscene = 5,
        EnemyTurn = 6,
        Finished = 7
    }

    public enum BattlePlayerTurnState
    {
        ACT = 0,
        ITEM = 1,
        FIGHT = 2,
        SPARE = 3,
        FINISHED = 4
    }

    public enum EndBattleTypes
    {
        Default = 0,
        Instant = 1,
        GameOver = 2
    }

    public enum BattleEnemyRemoveAnimation
    {
        Flee = 0,
        Lost = 1,
        Spare = 2
    }

    public enum BottomBarWindows
    {
        None = 0,
        Fight_EnemySelection = 1,
        Fight_AttackBar = 2,
        Item_SelectItem = 3,
        Spare_EnemySelection = 4,
        Item_MemberSelection = 5,
        Act_SelectAction = 6,
        Act_EnemySelection = 7,
        Act_MemberSelection = 8
    }

    private static BattleSystem instance;

    [Header("- References -")]
    [SerializeField]
    private AudioSource audioSource;

    public static BattleChatbox BattleChatbox;

    public static BattlePartyMember CurrentTurnPartyMember;

    [SerializeField]
    private BattleAction DefaultAction_Check;

    public GameObject BattleBox;

    [SerializeField]
    private Animator BattleBox_Animator;

    [SerializeField]
    private GameObject BattleBox_Collisions;

    [SerializeField]
    private GameObject BattleBox_Soul;

    [Space(5f)]
    [SerializeField]
    private GameObject BattleUI;

    public string CurrentBattleScript;

    public GameObject CurrentBattleScriptGameobject;

    [Header("UI")]
    [Header("Battle Numbers")]
    public BattleNumberSprites BattleNumbers_SpecificText;

    public BattleNumberSprites BattleNumbers_Default;

    public BattleNumberSprites BattleNumbers_Golden;

    [Header("Bottom Bar")]
    [SerializeField]
    private RectTransform BottomBar_Transform;

    [Header("TP Bar")]
    [SerializeField]
    private RectTransform TPBar_Transform;

    [SerializeField]
    private Image TPBar_Bar;

    [SerializeField]
    private Image TPBar_BarDropper;

    [SerializeField]
    private Image TPBar_BarTopper;

    [SerializeField]
    private TextMeshProUGUI TPBar_TPAmount;

    [Header("Prefabs")]
    [SerializeField]
    private GameObject BattlePrefab_PartyMember;

    [SerializeField]
    private GameObject BattlePrefab_PartyMemberStatus;

    [SerializeField]
    private GameObject BattlePrefab_EnemySelectionStatus;

    [SerializeField]
    private GameObject BattlePrefab_PlayerAttackBar;

    public GameObject BattlePrefab_Effect_PartyMemberAttack;

    [SerializeField]
    private GameObject BattlePrefab_BattleNumbers;

    [SerializeField]
    private Animator BehindBoxAttackFade_Animator;

    [Header("Holders")]
    [SerializeField]
    private GameObject Holder_BattlePartyMembers;

    [SerializeField]
    private GameObject Holder_BattlePartyMemberStatuses;

    [SerializeField]
    private GameObject Holder_Enemies;

    [SerializeField]
    private GameObject Holder_EnemySelection;

    [SerializeField]
    private GameObject Holder_AttackBars;

    [SerializeField]
    private GameObject Holder_Effects;

    public GameObject Holder_Bullets;

    [Header("Backgrounds")]
    [SerializeField]
    private SpriteRenderer DefaultBackgroundBox1;

    [SerializeField]
    private SpriteRenderer DefaultBackgroundBox2;

    [Header("UI Windows")]
    public GameObject BattleWindow_EnemySelection;

    [SerializeField]
    private GameObject BattleWindow_AttackBars;

    public GameObject BattleWindow_ActItemSelection;

    [SerializeField]
    private GameObject BattleWindow_PartyMemberSelection;

    [Header("- Dialogue -")]
    [SerializeField]
    private CHATBOXTEXT Dialogue_UseItem;

    [SerializeField]
    private CHATBOXTEXT Dialogue_SpareSuccessful;

    [SerializeField]
    private CHATBOXTEXT Dialogue_SpareFail;

    [SerializeField]
    private CHATBOXTEXT Dialogue_SpareFail_PossiblePacify;

    [SerializeField]
    private CHATBOXTEXT Dialogue_BattleWon;

    [Space(10f)]
    [SerializeField]
    private CHATBOXTEXT Dialogue_DefaultSpell_HealPrayer;

    [SerializeField]
    private CHATBOXTEXT Dialogue_DefaultSpell_IceShock;

    [SerializeField]
    private CHATBOXTEXT Dialogue_DefaultSpell_RudeBuster;

    [SerializeField]
    private CHATBOXTEXT Dialogue_DefaultSpell_UltimatHeal;

    [SerializeField]
    private CHATBOXTEXT Dialogue_DefaultSpell_FailedPacify;

    [SerializeField]
    private CHATBOXTEXT Dialogue_DefaultSpell_SleepMist;

    [Header("- Sounds -")]
    public AudioClip SFX_soul_damage;

    public AudioClip SFX_battle_start;

    public AudioClip SFX_menu_move;

    public AudioClip SFX_menu_select;

    public AudioClip SFX_menu_deny;

    public AudioClip SFX_fight_slash;

    public AudioClip SFX_fight_critical;

    public AudioClip SFX_intro_stomp;

    public AudioClip SFX_enemy_damage;

    public AudioClip sfx_enemy_spare;

    public AudioClip sfx_enemy_spareblink;

    public AudioClip SFX_heal;

    public AudioClip SFX_EnemyFlee;

    public AudioClip SFX_graze;

    public AudioClip SFX_StrongerThanYouSansResponse;

    [Header("- Default Spell Sounds -")]
    [SerializeField]
    private AudioClip SFX_RudeBuster_Fire;

    [SerializeField]
    private AudioClip SFX_RudeBuster_Hit;

    [SerializeField]
    private AudioClip SFX_SleepMist;

    [SerializeField]
    private AudioClip SFX_IceShock;

    public static BattleState CurrentBattleState;

    [Header("- Effects -")]
    public GameObject Effect_Heal;

    public GameObject Effect_Spare;

    public GameObject Effect_SoulRipOut;

    public GameObject Effect_SoulInsert;

    public GameObject Effect_RudeBuster_Projectile;

    public GameObject Effect_RudeBuster_Explosion;

    public GameObject Effect_SleepMist;

    public GameObject Effect_IceShock_Individual;

    [Header("- Battle Settings -")]
    public static bool CurrentlyInBattle;

    public BattleState PreviousBattleState;

    private BattleState LastBattleState;

    public Battle CurrentBattle;

    public int BattleSetting_TPAmount;

    public List<BattlePartyMemberUse> CurrentPlayerMoves = new List<BattlePartyMemberUse>();

    public List<BattlePartyMember> BattlePartyMembers = new List<BattlePartyMember>();

    public List<BattleActiveEnemy> BattleActiveEnemies = new List<BattleActiveEnemy>();

    public BattlePlayerTurnState CurrentBattlePlayerTurnState;

    public int CurrentPlayerTurnSelectionIndex;

    public float CurrentPossibleEXP;

    public float CurrentDDTotal;

    public List<BattleEnemyAttack> QueuedBattleAttacks = new List<BattleEnemyAttack>();

    private List<GameObject> CurrentlyActiveAttacks = new List<GameObject>();

    public List<BattleAction> QueuedBattleActions = new List<BattleAction>();

    private int PlayerturnCount;

    private int EnemyturnCount;

    private int TotalturnCount;

    [Header("- Stored Values -")]
    private bool LightworldMenu_CouldBeOpened;

    private bool DarkworldMenu_CouldBeOpened;

    public bool CurrentlyRunningAction;

    private Coroutine currentAttackTimerCoroutine;

    private CameraManager currentMainCamera;

    [Header("- Temporary Debug -")]
    public TextMeshProUGUI debugText;

    public CHATBOXTEXT testText;

    public GameObject dialogueBubble;

    private Vector2 BattlePartyMemberScrolling_TargetPos;

    private bool skipIntroForBattle;

    private int EnemyDamageBattleNumberOffset = 1;

    public static BattleSystem Instance => instance;

    public event Action<int> Event_OnPlayerTurn;

    public event Action<List<BattlePartyMemberUse>> Event_OnPlayerUseRound;

    public event Action<int> Event_OnEnemyAttackTurn;

    public event Action<Battle> Event_OnBattleStart;

    public event Action<Battle, EndBattleTypes> Event_OnBattleEnd;

    public event Action<BattleState, BattleState> Event_OnBattleStateChange;

    public event Action<BattleActiveEnemy, float, BattlePartyMember> Event_OnEnemyDamaged;

    public event Action<BattleActiveEnemy, float, BattlePartyMember> Event_OnEnemyKilled;

    public event Action<BattleActiveEnemy, bool, BattlePartyMember> Event_OnEnemySpared;

    public event Action<BattlePartyMember, float> Event_OnMemberDamaged;

    private void Awake()
    {
        instance = this;
        UnityEngine.Object.DontDestroyOnLoad(base.gameObject);
        BattleWindow_EnemySelection.SetActive(value: false);
        BattleWindow_AttackBars.SetActive(value: false);
        BattleWindow_ActItemSelection.SetActive(value: false);
        BattleWindow_PartyMemberSelection.SetActive(value: false);
    }

    private void Start()
    {
        BattleChatbox = BattleChatbox.Instance;
        BattleBox_Soul.SetActive(value: false);
        BattleBox_Collisions.SetActive(value: false);
        SceneManager.activeSceneChanged += ChangedActiveScene;
    }

    private void Update()
    {
        UpdateTPBarUI();
        UpdateBottomBarUI();
        UpdateDefaultBackground();
        BattleStateUpdate();
        UpdateBattleGraphicPositions();
        if (CurrentTurnPartyMember == null)
        {
            debugText.text = "current battle state: " + CurrentBattleState.ToString() + "\nCurrentTurnPartyMember: none";
        }
        else
        {
            debugText.text = "current battle state: " + CurrentBattleState.ToString() + "\nCurrentTurnPartyMember: " + CurrentTurnPartyMember.PartyMemberInBattle.PartyMemberName;
        }
        if (PreviousBattleState != CurrentBattleState)
        {
            OnBattleStateChange(CurrentBattleState, PreviousBattleState);
            LastBattleState = PreviousBattleState;
            PreviousBattleState = CurrentBattleState;
            BattleState_OnUpdate();
        }
    }

    private void UpdateBattleGraphicPositions()
    {
        if (currentMainCamera == null)
        {
            currentMainCamera = CameraManager.instance;
        }
        else
        {
            base.transform.position = (Vector2)currentMainCamera.transform.position;
        }
    }

    private void BattleStateUpdate()
    {
        switch (CurrentBattleState)
        {
            case BattleState.Intro:
                BattleChatbox.AllowInput = false;
                if (!skipIntroForBattle)
                {
                    if (Intro_AllPartyMembersInPosition() && Intro_AllEnemiesInPosition())
                    {
                        PlayBattleSoundEffect(SFX_intro_stomp);
                        BattleUI.SetActive(value: true);
                        MusicManager.PlaySong(CurrentBattle.BattleSong, FadePreviousSong: false, 0f);
                        CurrentBattleState = BattleState.PlayerTurn;
                    }
                    else
                    {
                        Intro_UpdatePartyMembersPositions();
                        Intro_UpdateEnemyPositions();
                    }
                }
                else
                {
                    DefaultBackgroundBox1.color = Color.white;
                    DefaultBackgroundBox2.color = Color.white;
                    UI_FADE.Instance.StartFadeOut(3f);
                    Intro_ForcefullySetPartyMembersPositions();
                    Intro_ForcefullySetEnemyPositions();
                    BattleUI.SetActive(value: true);
                    MusicManager.PlaySong(CurrentBattle.BattleSong, FadePreviousSong: false, 0f);
                    CurrentBattleState = BattleState.PlayerTurn;
                }
                break;
            case BattleState.PlayerTurn:
                BattleChatbox.AllowInput = false;
                break;
            case BattleState.Finished:
                BattleChatbox.AllowInput = true;
                break;
        }
    }

    private void BattleState_OnUpdate()
    {
        CheckForValidBattleEnd();
        switch (CurrentBattleState)
        {
            case BattleState.PlayerTurn:
                {
                    foreach (BattlePartyMember battlePartyMember in BattlePartyMembers)
                    {
                        battlePartyMember.PartyMemberStatus.ResetMemberIcon();
                    }
                    PerRound_HealDownedMembers();
                    for (int i = 0; i < BattlePartyMembers.Count; i++)
                    {
                        BattlePartyMembers[i].PartyMemberInBattle_AfterImageParticleRenderer.Stop();
                    }
                    if (LastBattleState == BattleState.Intro)
                    {
                        PartyMembers_AllPlayAnimations("Intro");
                    }
                    else
                    {
                        PartyMembers_AllPlayAnimations("Idle");
                    }
                    if (LastBattleState == BattleState.EnemyTurn)
                    {
                        CloseBattleBox();
                    }
                    foreach (BattlePartyMember battlePartyMember2 in BattlePartyMembers)
                    {
                        battlePartyMember2.IsDefending = false;
                        battlePartyMember2.SkippingTurn = false;
                    }
                    OpenBottomBarWindow(BottomBarWindows.None);
                    CurrentPlayerMoves.Clear();
                    CurrentBattlePlayerTurnState = BattlePlayerTurnState.ACT;
                    CurrentPlayerTurnSelectionIndex = 0;
                    BattleState_PlayerTurn_UpdateCurrentlySelectedStatus();
                    OnPlayerTurn();
                    break;
                }
            case BattleState.PlayerUseRound:
                EnemyDamageBattleNumberOffset = 1;
                ResetAllPartyMemberStatuses();
                CurrentBattlePlayerTurnState = BattlePlayerTurnState.ACT;
                BattleChatbox.EndText();
                StartCoroutine(BattlePlayerTurn_RunMoves());
                OnPlayerUseRound();
                break;
            case BattleState.Dialogue:
                {
                    bool flag = false;
                    foreach (BattleActiveEnemy battleActiveEnemy in BattleActiveEnemies)
                    {
                        if (battleActiveEnemy == null)
                        {
                            MonoBehaviour.print("how?");
                        }
                        if (battleActiveEnemy.QueuedDialogue.Count != 0)
                        {
                            flag = true;
                        }
                    }
                    foreach (BattleActiveEnemy battleActiveEnemy2 in BattleActiveEnemies)
                    {
                        if (battleActiveEnemy2.Enemy_MercyAmount >= 100f)
                        {
                            ActiveEnemies_PlayAnimation(battleActiveEnemy2, "Spare");
                        }
                        else
                        {
                            ActiveEnemies_PlayAnimation(battleActiveEnemy2, "Idle");
                        }
                    }
                    if (flag)
                    {
                        StartCoroutine(BattleDialogue_RunEnemyDialogue());
                    }
                    else
                    {
                        CurrentBattleState = BattleState.EnemyTurn;
                    }
                    break;
                }
            case BattleState.EnemyTurn:
                OnEnemyAttackTurn();
                DEBUG_EnableMarkiplier.ChangeMarkiplierState(DEBUG_EnableMarkiplier.MarkiplierEmotions.Default);
                OpenBattleBox();
                CreateAllQueuedAttacks();
                break;
            case BattleState.Cutscene:
                break;
        }
    }

    private IEnumerator BattlePlayerTurn_RunMoves()
    {
        yield return null;
        List<BattlePartyMemberUse> Moves = CurrentPlayerMoves;
        DEBUG_EnableMarkiplier.ChangeMarkiplierState(DEBUG_EnableMarkiplier.MarkiplierEmotions.CheekyGrin);
        List<BattlePartyMemberUse> list = new List<BattlePartyMemberUse>();
        List<BattlePartyMemberUse> fightMoves = new List<BattlePartyMemberUse>();
        foreach (BattlePartyMemberUse item in Moves)
        {
            if (item.BattleMove == BattlePlayerMove.Action || item.BattleMove == BattlePlayerMove.Item || item.BattleMove == BattlePlayerMove.Spare)
            {
                list.Add(item);
            }
            else if (item.BattleMove == BattlePlayerMove.Fight)
            {
                fightMoves.Add(item);
            }
        }
        foreach (BattlePartyMemberUse item2 in list)
        {
            CheckForValidBattleEnd();
            if (CurrentBattleState == BattleState.Finished)
            {
                continue;
            }
            if (item2.BattleMove == BattlePlayerMove.Item)
            {
                CurrentBattlePlayerTurnState = BattlePlayerTurnState.ITEM;
                MembersUseItems(new List<BattlePartyMemberUse> { item2 });
                while (CurrentBattlePlayerTurnState == BattlePlayerTurnState.ITEM)
                {
                    yield return new WaitForSeconds(0.015f);
                }
            }
            else if (item2.BattleMove == BattlePlayerMove.Action)
            {
                CurrentBattlePlayerTurnState = BattlePlayerTurnState.ACT;
                MemberUseActions(new List<BattlePartyMemberUse> { item2 });
                while (CurrentBattlePlayerTurnState == BattlePlayerTurnState.ACT || CurrentlyRunningAction)
                {
                    yield return new WaitForSeconds(0.25f);
                }
            }
            else if (item2.BattleMove == BattlePlayerMove.Spare)
            {
                CurrentBattlePlayerTurnState = BattlePlayerTurnState.SPARE;
                MembersSpare(new List<BattlePartyMemberUse> { item2 });
                while (CurrentBattlePlayerTurnState == BattlePlayerTurnState.SPARE)
                {
                    yield return new WaitForSeconds(0.015f);
                }
            }
        }
        CheckForValidBattleEnd();
        if (CurrentBattleState == BattleState.Finished)
        {
            yield break;
        }
        if (fightMoves.Count > 0)
        {
            CurrentBattlePlayerTurnState = BattlePlayerTurnState.FIGHT;
            CreateNewAttackBars(fightMoves);
            while (CurrentBattlePlayerTurnState == BattlePlayerTurnState.FIGHT)
            {
                yield return new WaitForSeconds(0.015f);
            }
        }
        CurrentBattleState = BattleState.Dialogue;
        PartyMembers_AllPlayAnimations("Idle");
        foreach (BattlePartyMemberUse item3 in Moves)
        {
            if (item3.BattleMove == BattlePlayerMove.Defend && item3.targetPartyMember.PartyMember_Health > 0f)
            {
                item3.targetPartyMember.IsDefending = true;
                PartyMembers_MemberPlayAnimation(item3.targetPartyMember, "Defend", 1f);
            }
        }
    }

    public void QueueBattleActions(IEnumerable<BattleAction> actions)
    {
        QueuedBattleActions.AddRange(actions);
    }

    private IEnumerator BattleDialogue_RunEnemyDialogue()
    {
        List<GameObject> createdBubbles = new List<GameObject>();
        bool allDialoguesCompleted;
        do
        {
            allDialoguesCompleted = true;
            List<BattleBubbleChatbox> activeBubbles = new List<BattleBubbleChatbox>();
            foreach (GameObject item in createdBubbles)
            {
                UnityEngine.Object.Destroy(item);
            }
            foreach (BattleActiveEnemy battleActiveEnemy in BattleActiveEnemies)
            {
                if (battleActiveEnemy.QueuedDialogue.Count > 0 && battleActiveEnemy.TextIndex < battleActiveEnemy.QueuedDialogue[0].Textboxes[0].Text.Length)
                {
                    if (!(battleActiveEnemy.QueuedDialogue[0].Textboxes[0].Text[battleActiveEnemy.TextIndex] == "") && !(battleActiveEnemy.QueuedDialogue[0].Textboxes[0].Text[battleActiveEnemy.TextIndex] == ""))
                    {
                        BattleBubbleChatbox battleBubbleChatbox = NewDialogueForEnemy(battleActiveEnemy, battleActiveEnemy.QueuedDialogue[0], battleActiveEnemy.TextIndex, 0, battleActiveEnemy.QueuedDialogueBubble[0]);
                        activeBubbles.Add(battleBubbleChatbox);
                        createdBubbles.Add(battleBubbleChatbox.gameObject);
                    }
                    allDialoguesCompleted = false;
                }
                else
                {
                    Debug.Log(battleActiveEnemy.EnemyInBattle.EnemyName + " has no more dialogue.");
                    battleActiveEnemy.TextIndex = 0;
                }
            }
            DEBUG_EnableMarkiplier.ChangeMarkiplierState(DEBUG_EnableMarkiplier.MarkiplierEmotions.Annoyed);
            if (activeBubbles.Count <= 0)
            {
                continue;
            }
            yield return new WaitUntil(() => activeBubbles.All((BattleBubbleChatbox bubble) => bubble.FinishedShowingText));
            float waitTime = 2f;
            float elapsedTime = 0f;
            bool playerPressedConfirm = false;
            while (elapsedTime < waitTime)
            {
                if (Input.GetKeyDown(PlayerInput.Instance.Key_Confirm) && !GonerMenu.Instance.GonerMenuOpen && !GonerMenu.Instance.gonerMenuWasOpen)
                {
                    playerPressedConfirm = true;
                    break;
                }
                elapsedTime += Time.deltaTime;
                yield return null;
            }
            if (playerPressedConfirm)
            {
                yield return new WaitForEndOfFrame();
            }
            foreach (BattleActiveEnemy battleActiveEnemy2 in BattleActiveEnemies)
            {
                battleActiveEnemy2.TextIndex++;
                if (battleActiveEnemy2.QueuedDialogue.Count > 0 && battleActiveEnemy2.TextIndex < battleActiveEnemy2.QueuedDialogue[0].Textboxes[0].Text.Length)
                {
                    allDialoguesCompleted = false;
                }
            }
        }
        while (!allDialoguesCompleted);
        foreach (GameObject item2 in createdBubbles)
        {
            UnityEngine.Object.Destroy(item2);
        }
        foreach (BattleActiveEnemy battleActiveEnemy3 in BattleActiveEnemies)
        {
            if (battleActiveEnemy3.QueuedDialogue.Count >= 1)
            {
                battleActiveEnemy3.QueuedDialogue.RemoveAt(0);
            }
            if (battleActiveEnemy3.QueuedDialogueBubble.Count >= 1)
            {
                battleActiveEnemy3.QueuedDialogueBubble.RemoveAt(0);
            }
            if (battleActiveEnemy3.SpecificTextIndexes.Count >= 1)
            {
                battleActiveEnemy3.SpecificTextIndexes.RemoveAt(0);
            }
        }
        Debug.Log("finished!");
        CurrentBattleState = BattleState.EnemyTurn;
    }

    public static void BattleState_PlayerTurn_UpdateCurrentlySelectedStatus()
    {
        if (CurrentBattleState != BattleState.PlayerTurn)
        {
            return;
        }
        bool flag = true;
        for (int i = 0; i < instance.BattlePartyMembers.Count; i++)
        {
            if (instance.BattlePartyMembers[i].PartyMember_Health > 0f)
            {
                flag = false;
                break;
            }
        }
        if (flag)
        {
            for (int j = 0; j < instance.BattlePartyMembers.Count; j++)
            {
                instance.BattlePartyMembers[j].PartyMemberStatus.CurrentlySelected = false;
                instance.BattlePartyMembers[j].PartyMemberStatus.StatusTabOpened = false;
            }
            return;
        }
        for (int k = 0; k < instance.BattlePartyMembers.Count; k++)
        {
            if (k == instance.CurrentPlayerTurnSelectionIndex)
            {
                if (!(instance.BattlePartyMembers[k].PartyMember_Health > 0f) || instance.BattlePartyMembers[k].SkippingTurn)
                {
                    IncrementCurrentPartyMemberStatusSelected();
                    break;
                }
                instance.BattlePartyMembers[k].PartyMemberStatus.CurrentlySelected = true;
                instance.BattlePartyMembers[k].PartyMemberStatus.StatusTabOpened = true;
            }
            else
            {
                instance.BattlePartyMembers[k].PartyMemberStatus.CurrentlySelected = false;
                instance.BattlePartyMembers[k].PartyMemberStatus.StatusTabOpened = false;
            }
        }
    }

    public static void IncrementCurrentPartyMemberStatusSelected()
    {
        instance.CurrentPlayerTurnSelectionIndex++;
        BattleState_PlayerTurn_UpdateCurrentlySelectedStatus();
        if (instance.CurrentPlayerTurnSelectionIndex >= instance.BattlePartyMembers.Count)
        {
            instance.CurrentPlayerTurnSelectionIndex = 0;
            instance.ResetAllPartyMemberStatuses();
            CurrentBattleState = BattleState.PlayerUseRound;
            CurrentTurnPartyMember = null;
        }
        else
        {
            CurrentTurnPartyMember = instance.BattlePartyMembers[instance.CurrentPlayerTurnSelectionIndex];
            if (CurrentTurnPartyMember != null && CurrentTurnPartyMember.PartyMember_Health <= 0f)
            {
                IncrementCurrentPartyMemberStatusSelected();
            }
        }
    }

    public static void UndoPreviousCurrentPartyMemberStatusSelected()
    {
        if (Instance.BattlePartyMembers[Instance.CurrentPlayerTurnSelectionIndex].PartyMember_Health > 0f)
        {
            Instance.PartyMembers_MemberPlayAnimation(Instance.BattlePartyMembers[Instance.CurrentPlayerTurnSelectionIndex], "Idle");
        }
        instance.CurrentPlayerTurnSelectionIndex--;
        while (instance.CurrentPlayerTurnSelectionIndex >= 0 && !(instance.BattlePartyMembers[instance.CurrentPlayerTurnSelectionIndex].PartyMember_Health > 0f))
        {
            instance.CurrentPlayerTurnSelectionIndex--;
        }
        if (instance.CurrentPlayerTurnSelectionIndex < 0)
        {
            for (int i = 0; i < instance.BattlePartyMembers.Count; i++)
            {
                if (instance.BattlePartyMembers[i].PartyMember_Health > 0f)
                {
                    instance.CurrentPlayerTurnSelectionIndex = i;
                    break;
                }
            }
        }
        instance.BattlePartyMembers[instance.CurrentPlayerTurnSelectionIndex].PartyMemberStatus.CurrentlySelected = true;
        if (instance.CurrentPlayerMoves.Count > 0)
        {
            if (instance.CurrentPlayerMoves[instance.CurrentPlayerMoves.Count - 1].Item_ToUse != null)
            {
                if (instance.CurrentPlayerMoves[instance.CurrentPlayerMoves.Count - 1].StoredItemOriginalIndex > -1)
                {
                    DarkworldInventory.Instance.PlayerInventory.Insert(instance.CurrentPlayerMoves[instance.CurrentPlayerMoves.Count - 1].StoredItemOriginalIndex, instance.CurrentPlayerMoves[instance.CurrentPlayerMoves.Count - 1].Item_ToUse);
                }
                else
                {
                    DarkworldInventory.Instance.PlayerInventory.Add(instance.CurrentPlayerMoves[instance.CurrentPlayerMoves.Count - 1].Item_ToUse);
                }
            }
            if (instance.CurrentPlayerMoves[instance.CurrentPlayerMoves.Count - 1].BattleMove == BattlePlayerMove.Defend)
            {
                Instance.AddTP(-16);
            }
            if (instance.CurrentPlayerMoves[instance.CurrentPlayerMoves.Count - 1].Action_ToRun != null && instance.CurrentPlayerMoves[instance.CurrentPlayerMoves.Count - 1].Action_ToRun.TPRequired > 0)
            {
                instance.AddTP(instance.CurrentPlayerMoves[instance.CurrentPlayerMoves.Count - 1].Action_ToRun.TPRequired);
            }
            instance.CurrentPlayerMoves.RemoveAt(instance.CurrentPlayerMoves.Count - 1);
        }
        CurrentTurnPartyMember = instance.BattlePartyMembers[instance.CurrentPlayerTurnSelectionIndex];
        BattleState_PlayerTurn_UpdateCurrentlySelectedStatus();
    }

    private void ResetAllPartyMemberStatuses()
    {
        foreach (BattlePartyMember battlePartyMember in BattlePartyMembers)
        {
            battlePartyMember.PartyMemberStatus.CurrentlySelected = false;
            battlePartyMember.PartyMemberStatus.SelectedIndex = 0;
        }
    }

    public void HideAllBattleWindows()
    {
        BattleWindow_EnemySelection.SetActive(value: false);
        BattleWindow_AttackBars.SetActive(value: false);
        BattleWindow_ActItemSelection.SetActive(value: false);
        BattleWindow_PartyMemberSelection.SetActive(value: false);
    }

    private void UpdateTPBarUI()
    {
        if (CurrentBattleState == BattleState.Disabled || CurrentBattleState == BattleState.Intro)
        {
            TPBar_Transform.anchoredPosition = Vector2.Lerp(TPBar_Transform.anchoredPosition, new Vector2(-300f, 0f), 12f * Time.fixedDeltaTime);
        }
        else
        {
            TPBar_Transform.anchoredPosition = Vector2.Lerp(TPBar_Transform.anchoredPosition, new Vector2(0f, 0f), 12f * Time.fixedDeltaTime);
        }
        float num = BattleSetting_TPAmount;
        TPBar_Bar.fillAmount = Mathf.Lerp(TPBar_Bar.fillAmount, num / 100f, 4f * Time.deltaTime);
        TPBar_BarDropper.fillAmount = Mathf.Lerp(TPBar_BarDropper.fillAmount, num / 100f - 0.015f, 3f * Time.deltaTime);
        TPBar_BarTopper.fillAmount = Mathf.Lerp(TPBar_BarTopper.fillAmount, num / 100f + 0.015f, 6f * Time.deltaTime);
        TPBar_TPAmount.text = num.ToString();
    }

    public void AddTP(int Amount)
    {
        BattleSetting_TPAmount = Mathf.Clamp(BattleSetting_TPAmount + Amount, 0, 100);
        UpdateTPBarUI();
    }

    private void UpdateBottomBarUI()
    {
        if (CurrentPlayerTurnSelectionIndex % 3 == 0 && CurrentPlayerTurnSelectionIndex != 0)
        {
            BattlePartyMemberScrolling_TargetPos = new Vector2(-1280 * (CurrentPlayerTurnSelectionIndex / 3), 0f);
        }
        ((RectTransform)Holder_BattlePartyMemberStatuses.transform).anchoredPosition = Vector2.Lerp(((RectTransform)Holder_BattlePartyMemberStatuses.transform).anchoredPosition, BattlePartyMemberScrolling_TargetPos, 15f * Time.fixedDeltaTime);
        switch (CurrentBattleState)
        {
            case BattleState.Disabled:
                BottomBar_Transform.anchoredPosition = Vector2.Lerp(BottomBar_Transform.anchoredPosition, new Vector2(0f, -400f), 12f * Time.fixedDeltaTime);
                break;
            case BattleState.PlayerTurn:
                BottomBar_Transform.anchoredPosition = Vector2.Lerp(BottomBar_Transform.anchoredPosition, new Vector2(0f, 0f), 12f * Time.fixedDeltaTime);
                break;
        }
    }

    private void UpdateDefaultBackground()
    {
        if (!CurrentlyInBattle)
        {
            DefaultBackgroundBox1.color = Color.Lerp(DefaultBackgroundBox1.color, new Color(1f, 1f, 1f, 0f), 12f * Time.fixedDeltaTime);
            DefaultBackgroundBox2.color = Color.Lerp(DefaultBackgroundBox2.color, new Color(1f, 1f, 1f, 0f), 12f * Time.fixedDeltaTime);
        }
        else
        {
            DefaultBackgroundBox1.color = Color.Lerp(DefaultBackgroundBox1.color, new Color(1f, 1f, 1f, 1f), 12f * Time.fixedDeltaTime);
            DefaultBackgroundBox2.color = Color.Lerp(DefaultBackgroundBox2.color, new Color(1f, 1f, 1f, 1f), 12f * Time.fixedDeltaTime);
        }
    }

    private void ChangedActiveScene(Scene current, Scene next)
    {
        BattleBox_Collisions.SetActive(value: false);
    }

    public static void PlayBattleSoundEffect(AudioClip clip, float volume = 1f, float pitch = 1f)
    {
        if (instance != null && instance.audioSource != null)
        {
            instance.audioSource.pitch = pitch;
            instance.audioSource.PlayOneShot(clip, volume);
        }
    }

    public static void StartBattle(Battle Battle, Vector2 EnemyStartPosition, bool SkipIntro = false)
    {
        CurrentlyInBattle = true;
        PlayerManager.Instance._PlayerState = PlayerManager.PlayerState.Battle;
        PlayerManager.Instance.gameObject.SetActive(value: false);
        PartyMemberSystem.Instance.SetAllPartyMembersActive(ActiveSelf: false);
        instance.LightworldMenu_CouldBeOpened = LightworldMenu.Instance.CanOpenMenu;
        instance.DarkworldMenu_CouldBeOpened = DarkworldMenu.Instance.CanOpenMenu;
        DarkworldMenu.Instance.CanOpenMenu = false;
        LightworldMenu.Instance.CanOpenMenu = false;
        instance.SetupBattleScript(Battle);
        instance.skipIntroForBattle = SkipIntro;
        instance.ResetAllBattleEvents();
        DEBUG_EnableMarkiplier.ChangeMarkiplierState(DEBUG_EnableMarkiplier.MarkiplierEmotions.Horror);
        instance.CurrentPossibleEXP = 0f;
        instance.CurrentDDTotal = 0f;
        MusicManager.StopSong(Fade: false, 0f);
        instance.BattlePartyMembers.Clear();
        instance.QueuedBattleActions.Clear();
        List<BattleAction> actions = new List<BattleAction> { instance.DefaultAction_Check };
        instance.QueueBattleActions(actions);
        instance.SetupPartyMembersInBattle(Battle);
        instance.CurrentBattle = Battle;
        for (int i = 0; i < instance.BattlePartyMembers.Count; i++)
        {
            foreach (BattleAction partyMember_DefaultSpell in instance.BattlePartyMembers[i].PartyMemberInBattle.PartyMember_DefaultSpells)
            {
                instance.QueuedBattleActions.Add(partyMember_DefaultSpell);
            }
        }
        instance.SetupEnemiesInBattle(Battle, EnemyStartPosition);
        CurrentBattleState = BattleState.Intro;
        PlayBattleSoundEffect(instance.SFX_battle_start);
    }

    public static void EndBattle(EndBattleTypes EndType = EndBattleTypes.Default)
    {
        switch (EndType)
        {
            case EndBattleTypes.Default:
                instance.StartCoroutine(instance.EndBattle_Default());
                DEBUG_EnableMarkiplier.ChangeMarkiplierState(DEBUG_EnableMarkiplier.MarkiplierEmotions.Default);
                break;
            case EndBattleTypes.Instant:
                instance.StartCoroutine(instance.EndBattle_Instant());
                break;
            case EndBattleTypes.GameOver:
                instance.StartCoroutine(instance.EndBattle_GameOver());
                break;
        }
    }

    private IEnumerator EndBattle_Default()
    {
        yield return null;
        CurrentlyInBattle = false;
        instance.ResetAllBattleEvents();
        if (currentAttackTimerCoroutine != null)
        {
            StopCoroutine(currentAttackTimerCoroutine);
        }
        EndEnemyAttackTurn(RevertToPlayerTurn: false);
        UnityEngine.Object.Destroy(CurrentBattleScriptGameobject);
        Battle_PlayerSoul.Instance.CurrentSoulState = Battle_PlayerSoul.SoulState.Disabled;
        Battle_PlayerSoul.Instance.gameObject.SetActive(value: false);
        RefundAllMoveItems();
        MusicManager.StopSong(Fade: false, 0f);
        CurrentBattleState = BattleState.Disabled;
        instance.PreviousBattleState = BattleState.Disabled;
        bool allPartyMembersAtTarget = false;
        while (!allPartyMembersAtTarget)
        {
            allPartyMembersAtTarget = true;
            yield return null;
            for (int i = 0; i < BattlePartyMembers.Count; i++)
            {
                BattlePartyMembers[i].PartyMemberInBattle_AfterImageParticleRenderer.Stop();
                GameObject partyMemberInBattle_Gameobjects = BattlePartyMembers[i].PartyMemberInBattle_Gameobjects;
                Vector3 vector = BattlePartyMembers[i].StoredOriginalOverworldPosition;
                partyMemberInBattle_Gameobjects.transform.position = Vector3.MoveTowards(partyMemberInBattle_Gameobjects.transform.position, vector, 30f * Time.deltaTime);
                if (BattlePartyMembers[i].PartyMemberInBattle.StartFromPlayer)
                {
                    Animator anim = PlayerManager.Instance._PMove._anim;
                    BattlePartyMembers[i].PartyMemberInBattle_Animator.runtimeAnimatorController = anim.runtimeAnimatorController;
                    if (PlayerManager.Instance._PMove.InDarkworld)
                    {
                        BattlePartyMembers[i].PartyMemberInBattle_Animator.Play("DARKWORLD_KRIS_IDLE");
                    }
                    else
                    {
                        BattlePartyMembers[i].PartyMemberInBattle_Animator.Play("OVERWORLD_NOELLE_IDLE");
                    }
                    BattlePartyMembers[i].PartyMemberInBattle_Animator.SetFloat("MOVEMENTX", anim.GetFloat("MOVEMENTX"));
                    BattlePartyMembers[i].PartyMemberInBattle_Animator.SetFloat("MOVEMENTY", anim.GetFloat("MOVEMENTY"));
                }
                else
                {
                    Animator anim = PartyMemberSystem.Instance.HasMemberInParty(BattlePartyMembers[i].PartyMemberInBattle).PartyMemberFollowSettings.SusieAnimator;
                    BattlePartyMembers[i].PartyMemberInBattle_Animator.runtimeAnimatorController = anim.runtimeAnimatorController;
                    BattlePartyMembers[i].PartyMemberInBattle_Animator.Play("Idle");
                    BattlePartyMembers[i].PartyMemberInBattle_Animator.SetFloat("VelocityX", anim.GetFloat("VelocityX"));
                    BattlePartyMembers[i].PartyMemberInBattle_Animator.SetFloat("VelocityY", anim.GetFloat("VelocityY"));
                    BattlePartyMembers[i].PartyMemberInBattle_Animator.SetFloat("VelocityMagnitude", 0f);
                }
                if (partyMemberInBattle_Gameobjects.transform.position != vector)
                {
                    allPartyMembersAtTarget = false;
                    continue;
                }
                BattlePartyMembers[i].PartyMemberInBattle_MainSpriteRenderer.enabled = false;
                if (BattlePartyMembers[i].PartyMemberInBattle.StartFromPlayer)
                {
                    PlayerManager.Instance.gameObject.SetActive(value: true);
                }
                else
                {
                    PartyMemberSystem.Instance.HasMemberInParty(BattlePartyMembers[i].PartyMemberInBattle)?.PartyMemberTransform.gameObject.SetActive(value: true);
                }
            }
        }
        PlayerManager.Instance._PlayerState = PlayerManager.PlayerState.Game;
        PlayerManager.Instance.gameObject.SetActive(value: true);
        PartyMemberSystem.Instance.SetAllPartyMembersActive(ActiveSelf: true);
        DarkworldMenu.Instance.CanOpenMenu = DarkworldMenu_CouldBeOpened;
        LightworldMenu.Instance.CanOpenMenu = LightworldMenu_CouldBeOpened;
        instance.OnBattleEnd(instance.CurrentBattle, EndBattleTypes.Default);
        instance.CurrentBattle = null;
        instance.BattlePartyMembers.Clear();
        ClearBattleSystem();
    }

    private IEnumerator EndBattle_Instant()
    {
        yield return null;
        CurrentlyInBattle = false;
        PlayerManager.Instance._PlayerState = PlayerManager.PlayerState.Game;
        PlayerManager.Instance.gameObject.SetActive(value: true);
        PartyMemberSystem.Instance.SetAllPartyMembersActive(ActiveSelf: true);
        RefundAllMoveItems();
        DarkworldMenu.Instance.CanOpenMenu = DarkworldMenu_CouldBeOpened;
        LightworldMenu.Instance.CanOpenMenu = LightworldMenu_CouldBeOpened;
        CloseBattleBox(DisableSoulEffect: true);
        UnityEngine.Object.Destroy(CurrentBattleScriptGameobject);
        instance.ResetAllBattleEvents();
        if (currentAttackTimerCoroutine != null)
        {
            StopCoroutine(currentAttackTimerCoroutine);
        }
        EndEnemyAttackTurn(RevertToPlayerTurn: false);
        BattleUI.SetActive(value: false);
        Battle_PlayerSoul.Instance.CurrentSoulState = Battle_PlayerSoul.SoulState.Disabled;
        Battle_PlayerSoul.Instance.gameObject.SetActive(value: false);
        MusicManager.StopSong(Fade: false, 0f);
        instance.BattlePartyMembers.Clear();
        instance.OnBattleEnd(instance.CurrentBattle, EndBattleTypes.Instant);
        instance.CurrentBattle = null;
        CurrentBattleState = BattleState.Disabled;
        instance.PreviousBattleState = BattleState.Disabled;
        ClearBattleSystem();
    }

    private IEnumerator EndBattle_GameOver()
    {
        yield return null;
        CurrentlyInBattle = false;
        PlayerManager.Instance.gameObject.SetActive(value: false);
        PlayerManager.Instance._PlayerState = PlayerManager.PlayerState.Cutscene;
        DarkworldMenu.Instance.CanOpenMenu = DarkworldMenu_CouldBeOpened;
        LightworldMenu.Instance.CanOpenMenu = LightworldMenu_CouldBeOpened;
        CloseBattleBox(DisableSoulEffect: true);
        ResetAllBattleEvents();
        RefundAllMoveItems();
        if (currentAttackTimerCoroutine != null)
        {
            StopCoroutine(currentAttackTimerCoroutine);
        }
        EndEnemyAttackTurn(RevertToPlayerTurn: false);
        BattleUI.SetActive(value: false);
        instance.OnBattleEnd(instance.CurrentBattle, EndBattleTypes.GameOver);
        Battle_PlayerSoul.Instance.CurrentSoulState = Battle_PlayerSoul.SoulState.Disabled;
        Battle_PlayerSoul.Instance.gameObject.SetActive(value: false);
        UnityEngine.Object.Destroy(CurrentBattleScriptGameobject);
        MusicManager.StopSong(Fade: false, 0f);
        instance.CurrentBattle = null;
        BattlePartyMembers.Clear();
        CurrentBattle = null;
        CurrentBattleState = BattleState.Disabled;
        PreviousBattleState = BattleState.Disabled;
        ClearBattleSystem();
    }

    private void ClearBattleSystem()
    {
        StopAllCoroutines();
        BattleWindow_AttackBars.GetComponent<BattleAttackWindow>().ClearAttackBars();
        for (int i = 0; i < Holder_BattlePartyMembers.transform.childCount; i++)
        {
            UnityEngine.Object.Destroy(Holder_BattlePartyMembers.transform.GetChild(i).gameObject);
        }
        BattlePartyMembers.Clear();
        foreach (BattleActiveEnemy battleActiveEnemy in BattleActiveEnemies)
        {
            UnityEngine.Object.Destroy(battleActiveEnemy.EnemyInBattle_Gameobject);
        }
        BattleBubbleChatbox[] array = UnityEngine.Object.FindObjectsByType<BattleBubbleChatbox>(FindObjectsSortMode.None);
        for (int j = 0; j < array.Length; j++)
        {
            UnityEngine.Object.Destroy(array[j].gameObject);
        }
        BattleSetting_TPAmount = 0;
        CurrentDDTotal = 0f;
        CurrentPossibleEXP = 0f;
        CurrentPlayerMoves.Clear();
        for (int k = 0; k < Holder_BattlePartyMemberStatuses.transform.childCount; k++)
        {
            UnityEngine.Object.Destroy(Holder_BattlePartyMemberStatuses.transform.GetChild(k).gameObject);
        }
        for (int l = 0; l < Holder_EnemySelection.transform.childCount; l++)
        {
            UnityEngine.Object.Destroy(Holder_EnemySelection.transform.GetChild(l).gameObject);
        }
        for (int m = 0; m < Holder_Effects.transform.childCount; m++)
        {
            UnityEngine.Object.Destroy(Holder_Effects.transform.GetChild(m).gameObject);
        }
        BattleActiveEnemies.Clear();
        CurrentBattlePlayerTurnState = BattlePlayerTurnState.ACT;
    }

    public void CheckForValidBattleEnd()
    {
        if (CurrentBattleState == BattleState.Finished || BattleActiveEnemies.Count > 0)
        {
            return;
        }
        CurrentBattleState = BattleState.Finished;
        StopCoroutine("BattlePlayerTurn_RunMoves");
        foreach (BattlePartyMember battlePartyMember in BattlePartyMembers)
        {
            if (battlePartyMember.PartyMember_Health <= 0f)
            {
                battlePartyMember.PartyMember_Health = 0f;
                HealPartyMember(battlePartyMember, Mathf.FloorToInt(battlePartyMember.PartyMember_MaxHealth / 12f));
            }
            if (battlePartyMember.PartyMemberInBattle.StartFromPlayer)
            {
                PlayerManager.Instance._PlayerHealth = Mathf.FloorToInt(battlePartyMember.PartyMember_Health);
            }
            else
            {
                battlePartyMember.ActiveMemberInBattle.CurrentHealth = Mathf.FloorToInt(battlePartyMember.PartyMember_Health);
            }
        }
        PartyMembers_AllPlayAnimations("Victory");
        BattleChatbox.StoredAdditiveValues.Clear();
        BattleChatbox.StoredAdditiveValues.Add(CurrentDDTotal.ToString());
        SecurePlayerPrefs.SetSecureInt("TotalCash", SecurePlayerPrefs.GetSecureInt("TotalCash") + Mathf.FloorToInt(CurrentDDTotal));
        if (CurrentPossibleEXP > 0f)
        {
            BattleChatbox.StoredAdditiveValues.Add(" ;You became stronger.");
        }
        else
        {
            BattleChatbox.StoredAdditiveValues.Add(" ");
        }
        BattleChatbox.AllowInput = true;
        StartCoroutine(BattleEnd_DisplayVictoryDialogue());
    }

    private IEnumerator BattleEnd_DisplayVictoryDialogue()
    {
        yield return null;
        BattleChatbox.TextVisible = true;
        BattleChatbox.RunText(Dialogue_BattleWon, 0, null, ResetCurrentTextIndex: false);
        if (CurrentPossibleEXP > 0f)
        {
            PlayBattleSoundEffect(SFX_StrongerThanYouSansResponse, 0.75f, 2f);
        }
        while (BattleChatbox.ChatIsCurrentlyRunning)
        {
            yield return null;
        }
        EndBattle();
    }

    private void Intro_UpdatePartyMembersPositions()
    {
        for (int i = 0; i < BattlePartyMembers.Count; i++)
        {
            Vector2 vector = BattlePartyMembers[i].PartyMemberInBattle_Gameobjects.transform.position;
            Vector2 storedPartyMembePositions = BattlePartyMembers[i].StoredPartyMembePositions;
            Vector2 normalized = (storedPartyMembePositions - vector).normalized;
            float num = 32f;
            Vector2 vector2 = vector + normalized * num * Time.fixedDeltaTime;
            if (Vector2.Distance(vector2, storedPartyMembePositions) < Vector2.Distance(vector, storedPartyMembePositions))
            {
                BattlePartyMembers[i].PartyMemberInBattle_Gameobjects.transform.position = vector2;
                ParticleSystem.TextureSheetAnimationModule textureSheetAnimation = BattlePartyMembers[i].PartyMemberInBattle_AfterImageParticleRenderer.textureSheetAnimation;
                if (textureSheetAnimation.GetSprite(0) != BattlePartyMembers[i].PartyMemberInBattle_MainSpriteRenderer.sprite)
                {
                    textureSheetAnimation.SetSprite(0, BattlePartyMembers[i].PartyMemberInBattle_MainSpriteRenderer.sprite);
                }
                BattlePartyMembers[i].PartyMemberInBattle_Gameobjects.GetComponentInChildren<ParticleSystem>().Play();
            }
            else
            {
                BattlePartyMembers[i].PartyMemberInBattle_Gameobjects.transform.position = storedPartyMembePositions;
                BattlePartyMembers[i].PartyMemberInBattle_Gameobjects.GetComponentInChildren<ParticleSystem>().Stop();
            }
        }
    }

    private void Intro_ForcefullySetPartyMembersPositions()
    {
        for (int i = 0; i < BattlePartyMembers.Count; i++)
        {
            Vector2 storedPartyMembePositions = BattlePartyMembers[i].StoredPartyMembePositions;
            BattlePartyMembers[i].PartyMemberInBattle_Gameobjects.transform.position = storedPartyMembePositions;
            BattlePartyMembers[i].PartyMemberInBattle_Gameobjects.GetComponentInChildren<ParticleSystem>().Stop();
        }
    }

    private void Intro_UpdateEnemyPositions()
    {
        for (int i = 0; i < BattleActiveEnemies.Count; i++)
        {
            Vector2 vector = BattleActiveEnemies[i].EnemyInBattle_Gameobject.transform.position;
            Vector2 storedEnemyPositions = BattleActiveEnemies[i].StoredEnemyPositions;
            Vector2 normalized = (storedEnemyPositions - vector).normalized;
            float num = 32f;
            Vector2 vector2 = vector + normalized * num * Time.fixedDeltaTime;
            if (Vector2.Distance(vector2, storedEnemyPositions) < Vector2.Distance(vector, storedEnemyPositions))
            {
                BattleActiveEnemies[i].EnemyInBattle_Gameobject.transform.position = vector2;
                ParticleSystem.TextureSheetAnimationModule textureSheetAnimation = BattleActiveEnemies[i].EnemyInBattle_AfterImageParticleRenderer.textureSheetAnimation;
                if (textureSheetAnimation.GetSprite(0) != BattleActiveEnemies[i].EnemyInBattle_MainSpriteRenderer.sprite)
                {
                    textureSheetAnimation.SetSprite(0, BattleActiveEnemies[i].EnemyInBattle_MainSpriteRenderer.sprite);
                }
                BattleActiveEnemies[i].EnemyInBattle_AfterImageParticleRenderer.GetComponentInChildren<ParticleSystem>().Play();
            }
            else
            {
                BattleActiveEnemies[i].EnemyInBattle_Gameobject.transform.position = storedEnemyPositions;
                BattleActiveEnemies[i].EnemyInBattle_AfterImageParticleRenderer.GetComponentInChildren<ParticleSystem>().Stop();
            }
        }
    }

    private void Intro_ForcefullySetEnemyPositions()
    {
        for (int i = 0; i < BattleActiveEnemies.Count; i++)
        {
            Vector2 storedEnemyPositions = BattleActiveEnemies[i].StoredEnemyPositions;
            BattleActiveEnemies[i].EnemyInBattle_Gameobject.transform.position = storedEnemyPositions;
            BattleActiveEnemies[i].EnemyInBattle_AfterImageParticleRenderer.GetComponentInChildren<ParticleSystem>().Stop();
        }
    }

    private bool Intro_AllPartyMembersInPosition()
    {
        for (int i = 0; i < BattlePartyMembers.Count; i++)
        {
            if (Vector2.Distance(BattlePartyMembers[i].PartyMemberInBattle_Gameobjects.transform.position, BattlePartyMembers[i].StoredPartyMembePositions) > 0.1f)
            {
                return false;
            }
        }
        return true;
    }

    private bool Intro_AllEnemiesInPosition()
    {
        for (int i = 0; i < BattleActiveEnemies.Count; i++)
        {
            if (Vector2.Distance(BattleActiveEnemies[i].EnemyInBattle_Gameobject.transform.position, BattleActiveEnemies[i].StoredEnemyPositions) > 0.1f)
            {
                return false;
            }
        }
        return true;
    }

    public void PartyMembers_AllPlayAnimations(string anim, float Time = 0f, bool PreventDownedAnimations = true)
    {
        for (int i = 0; i < BattlePartyMembers.Count; i++)
        {
            if (PreventDownedAnimations && BattlePartyMembers[i].PartyMember_Health <= 0f)
            {
                BattlePartyMembers[i].PartyMemberInBattle_Animator.Play("Down", 0, Time);
            }
            else
            {
                BattlePartyMembers[i].PartyMemberInBattle_Animator.Play(anim, 0, Time);
            }
        }
    }

    public void PartyMembers_MemberPlayAnimation(BattlePartyMember member, string anim, float Time = 0f)
    {
        if (member != null && member.PartyMemberInBattle_Gameobjects != null && member.PartyMemberInBattle_Animator != null)
        {
            member.PartyMemberInBattle_Animator.Play(anim, 0, Time);
        }
    }

    public void ActiveEnemies_PlayAnimation(BattleActiveEnemy target, string anim, float Time = 0f)
    {
        if (target != null && target.EnemyInBattle_Gameobject != null && target.EnemyInBattle_Animator != null)
        {
            target.EnemyInBattle_Animator.Play(anim, 0, Time);
        }
    }

    public void ActiveEnemies_AllPlayAnimation(string anim, float Time = 0f)
    {
        foreach (BattleActiveEnemy battleActiveEnemy in BattleActiveEnemies)
        {
            ActiveEnemies_PlayAnimation(battleActiveEnemy, anim, Time);
        }
    }

    private void SetupPartyMembersInBattle(Battle Battle)
    {
        PartyMember[] partyMembers = Battle.PartyMembers;
        for (int i = 0; i < partyMembers.Length; i++)
        {
            AddPartyMemberToBattle(partyMembers[i], Battle.PartyMemberPositions[i] + (Vector2)base.transform.position);
        }
        CurrentTurnPartyMember = instance.BattlePartyMembers[instance.CurrentPlayerTurnSelectionIndex];
    }

    private void AddPartyMemberToBattle(PartyMember member, Vector2 pos)
    {
        GameObject gameObject = UnityEngine.Object.Instantiate(BattlePrefab_PartyMember, Holder_BattlePartyMembers.transform);
        gameObject.name = member.PartyMemberName;
        BattlePartyMember battlePartyMember = new BattlePartyMember();
        Animator componentInChildren = gameObject.GetComponentInChildren<Animator>();
        if (componentInChildren != null)
        {
            componentInChildren.runtimeAnimatorController = member.PartyMemberBattleAnimator;
        }
        else
        {
            Debug.LogWarning("Failed to get Animator in children of Battle Member!");
        }
        if (member.StartFromPlayer)
        {
            gameObject.transform.position = PlayerManager.Instance._PMove._anim.transform.position;
            battlePartyMember.StoredOriginalOverworldPosition = PlayerManager.Instance._PMove._anim.transform.position;
            battlePartyMember.PartyMember_Health = PlayerManager.Instance._PlayerHealth;
            battlePartyMember.PartyMember_MaxHealth = PlayerManager.Instance._PlayerMaxHealth;
        }
        else if (member != null)
        {
            ActivePartyMember activePartyMember = (battlePartyMember.ActiveMemberInBattle = PartyMemberSystem.Instance.HasMemberInParty(member));
            Transform specificMemberTransform = PartyMemberSystem.Instance.GetSpecificMemberTransform(member);
            if (specificMemberTransform != null)
            {
                gameObject.transform.position = specificMemberTransform.position;
                battlePartyMember.StoredOriginalOverworldPosition = activePartyMember.PartyMemberFollowSettings.SusieAnimator.transform.position;
            }
            else
            {
                gameObject.transform.position = PlayerManager.Instance._PMove._anim.transform.position;
                battlePartyMember.StoredOriginalOverworldPosition = PlayerManager.Instance._PMove._anim.transform.position;
            }
            battlePartyMember.PartyMember_Health = activePartyMember.CurrentHealth;
            battlePartyMember.PartyMember_MaxHealth = member.MaximumHealth;
        }
        else
        {
            gameObject.transform.position = PlayerManager.Instance._PMove._anim.transform.position;
            battlePartyMember.StoredOriginalOverworldPosition = PlayerManager.Instance._PMove._anim.transform.position;
            battlePartyMember.PartyMember_Health = 1f;
            battlePartyMember.PartyMember_MaxHealth = 1f;
            Debug.LogError("member in AddPartyMemberToBattle() is null!! WTF!!");
        }
        BattlePartyMembers.Add(battlePartyMember);
        battlePartyMember.PartyMemberInBattle_Gameobjects = gameObject;
        battlePartyMember.PartyMemberInBattle = member;
        battlePartyMember.StoredPartyMembePositions = pos;
        battlePartyMember.PartyMemberInBattle_Animator = componentInChildren;
        Transform[] componentsInChildren = gameObject.GetComponentsInChildren<Transform>();
        foreach (Transform transform in componentsInChildren)
        {
            if (transform.name == "Sprite")
            {
                battlePartyMember.PartyMemberInBattle_MainSpriteRenderer = transform.GetComponent<SpriteRenderer>();
            }
        }
        componentsInChildren = gameObject.GetComponentsInChildren<Transform>();
        foreach (Transform transform2 in componentsInChildren)
        {
            if (transform2.name == "AfterImage")
            {
                battlePartyMember.PartyMemberInBattle_AfterImageParticleRenderer = transform2.GetComponent<ParticleSystem>();
            }
        }
        DelayForMemberIntro(componentInChildren);
        SetupNewPartyMemberStatus(member, battlePartyMember);
    }

    private void SetupNewPartyMemberStatus(PartyMember member, BattlePartyMember battleMember)
    {
        GameObject obj = UnityEngine.Object.Instantiate(BattlePrefab_PartyMemberStatus, Holder_BattlePartyMemberStatuses.transform);
        BattlePartyMemberStatus component = obj.GetComponent<BattlePartyMemberStatus>();
        obj.name = member.PartyMemberName + "_Status";
        battleMember.PartyMemberStatus = component;
        component.TargetPartyMember = battleMember;
        component.MemberIcon.sprite = member.PartyMemberBattleIcon;
        component.MemberIcon.rectTransform.sizeDelta = new Vector2(member.PartyMemberBattleIcon.textureRect.width * 2f, member.PartyMemberBattleIcon.textureRect.height * 2f);
        component.MemberNameIcon.texture = member.PartyMemberBattle_NameIcon.texture;
        component.MemberNameIcon.rectTransform.sizeDelta = new Vector2(member.PartyMemberBattle_NameIcon.texture.width * 2, member.PartyMemberBattle_NameIcon.texture.height * 2);
        component.BoxOutline.color = member.PartyMemberColor;
        component.HealthBar.color = member.PartyMemberColor;
        component.SpecialLines1.color = member.PartyMemberColor;
        component.SpecialLines2.color = member.PartyMemberColor;
        component.HasActAbility = !member.HasMagic;
        component.UpdateButtonSprites();
    }

    private IEnumerator DelayForMemberIntro(Animator anim)
    {
        yield return new WaitForSeconds(0.01f);
        anim.Play("IntroIdle");
    }

    public void DamagePartyMember(BattlePartyMember Target, int Damage)
    {
        if (Target != null && Target.PartyMember_Health > 0f)
        {
            float partyMember_Health = Target.PartyMember_Health;
            this.Event_OnMemberDamaged(Target, Damage);
            Target.PartyMember_Health -= Damage;
            if (Target.PartyMember_Health <= 0f && partyMember_Health > 0f)
            {
                Target.PartyMember_Health = 0f - Mathf.Ceil(Target.PartyMember_MaxHealth / 2f);
                DisplayBattleNumbers(BattleNumbers_SpecificText, 0, Target.PartyMemberInBattle_Gameobjects.transform.position, Color.red);
                PartyMembers_MemberPlayAnimation(Target, "Down");
            }
            else
            {
                DisplayBattleNumbers(BattleNumbers_Default, Damage, Target.PartyMemberInBattle_Gameobjects.transform.position, Color.white);
                if (!Target.IsDefending)
                {
                    ShakePartyMember(Target, 0.25f, 2f);
                    StartCoroutine(PartyMember_HurtAnimDelay(Target));
                    PartyMembers_MemberPlayAnimation(Target, "Hurt");
                }
                else
                {
                    ShakePartyMember(Target, 0.17f);
                }
            }
            if (!SettingsManager.Instance.GetBoolSettingValue("SimpleVFX"))
            {
                CutsceneUtils.ShakeTransform(currentMainCamera.transform, 0.125f, 0.25f);
            }
        }
        CheckAllPartyMemberDead();
    }

    private void CheckAllPartyMemberDead()
    {
        bool flag = true;
        foreach (BattlePartyMember battlePartyMember in BattlePartyMembers)
        {
            if (battlePartyMember.PartyMember_Health > 0f)
            {
                flag = false;
            }
        }
        if (flag)
        {
            Battle_GameOver.Instance.PossibleDeathMessages = CurrentBattle.GameOverDialogues;
            Battle_GameOver.Instance.PlayGameOver(BattleBox_Soul.transform.position);
            EndBattle(EndBattleTypes.GameOver);
        }
    }

    public void HealPartyMember(BattlePartyMember Target, int HealAmount, bool ForceNumbersOnly = false)
    {
        if (Target == null)
        {
            return;
        }
        float partyMember_Health = Target.PartyMember_Health;
        Target.PartyMember_Health += HealAmount;
        UnityEngine.Object.Instantiate(Effect_Heal, Target.PartyMemberInBattle_Gameobjects.transform.position, Quaternion.identity);
        FlashMemberLight(Target);
        if (Target.PartyMember_Health >= Target.PartyMember_MaxHealth && !ForceNumbersOnly)
        {
            Target.PartyMember_Health = Target.PartyMember_MaxHealth;
            DisplayBattleNumbers(BattleNumbers_SpecificText, 3, Target.PartyMemberInBattle_Gameobjects.transform.position, Color.green);
            if (partyMember_Health <= 0f)
            {
                PartyMembers_MemberPlayAnimation(Target, "Idle");
            }
        }
        else
        {
            DisplayBattleNumbers(BattleNumbers_Default, HealAmount, Target.PartyMemberInBattle_Gameobjects.transform.position, Color.green);
            if (partyMember_Health <= 0f && Target.PartyMember_Health > 0f)
            {
                PartyMembers_MemberPlayAnimation(Target, "Idle");
            }
        }
        PlayBattleSoundEffect(SFX_heal, 0.75f);
    }

    private void PerRound_HealDownedMembers()
    {
        foreach (BattlePartyMember battlePartyMember in BattlePartyMembers)
        {
            battlePartyMember.SkippingTurn = false;
            if (battlePartyMember.PartyMember_Health <= 0f)
            {
                HealPartyMember(battlePartyMember, Mathf.CeilToInt(battlePartyMember.PartyMember_MaxHealth / 8f));
            }
        }
    }

    private IEnumerator PartyMember_HurtAnimDelay(BattlePartyMember Target)
    {
        yield return new WaitForSeconds(1f);
        PartyMembers_MemberPlayAnimation(Target, "Idle");
    }

    private void SetupEnemiesInBattle(Battle Battle, Vector2 startPos)
    {
        BattleEnemy[] enemies = Battle.Enemies;
        for (int i = 0; i < enemies.Length; i++)
        {
            AddEnemyToBattle(enemies[i], startPos, Battle.EnemyPositions[i] + (Vector2)base.transform.position);
        }
    }

    private void SetupBattleScript(Battle Battle)
    {
        if (Battle != null && Battle.BattleScriptPrefab != null)
        {
            GameObject gameObject = (CurrentBattleScriptGameobject = UnityEngine.Object.Instantiate(Battle.BattleScriptPrefab));
            CurrentBattleScript = Battle.BattleScriptMainComponent;
            gameObject.name = Battle.BattleScriptPrefab.name;
        }
        else
        {
            Debug.LogError("SetupBattleScript FAILED! Either Battle or BattleScriptPrefab are null!");
        }
    }

    private void AddEnemyToBattle(BattleEnemy enemy, Vector2 startPos, Vector2 endPos)
    {
        GameObject gameObject = UnityEngine.Object.Instantiate(enemy.EnemyPrefab, Holder_Enemies.transform);
        gameObject.name = enemy.name;
        gameObject.transform.position = startPos;
        Animator component = gameObject.GetComponent<Animator>();
        BattleActiveEnemy battleActiveEnemy = new BattleActiveEnemy();
        BattleActiveEnemies.Add(battleActiveEnemy);
        battleActiveEnemy.EnemyInBattle_Gameobject = gameObject;
        battleActiveEnemy.EnemyInBattle = enemy;
        battleActiveEnemy.StoredEnemyPositions = endPos;
        battleActiveEnemy.EnemyInBattle_Animator = component;
        CurrentDDTotal += enemy.DarkDollars;
        Transform[] componentsInChildren = gameObject.GetComponentsInChildren<Transform>();
        foreach (Transform transform in componentsInChildren)
        {
            if (transform.name == "Sprite")
            {
                battleActiveEnemy.EnemyInBattle_MainSpriteRenderer = transform.GetComponent<SpriteRenderer>();
            }
        }
        componentsInChildren = gameObject.GetComponentsInChildren<Transform>();
        foreach (Transform transform2 in componentsInChildren)
        {
            if (transform2.name == "AfterImage")
            {
                battleActiveEnemy.EnemyInBattle_AfterImageParticleRenderer = transform2.GetComponent<ParticleSystem>();
            }
        }
        battleActiveEnemy.Enemy_Health = enemy.EnemyMaxHealth;
        battleActiveEnemy.Enemy_MaxHealth = enemy.EnemyMaxHealth;
        SetupEnemyStatus(enemy, battleActiveEnemy);
    }

    private void SetupEnemyStatus(BattleEnemy enemy, BattleActiveEnemy enemybattle)
    {
        GameObject obj = UnityEngine.Object.Instantiate(BattlePrefab_EnemySelectionStatus, Holder_EnemySelection.transform);
        BattleEnemyStatus component = obj.GetComponent<BattleEnemyStatus>();
        obj.name = enemy.name + "_Status";
        enemybattle.EnemyStatus = component;
        component.ActiveEnemy = enemybattle;
    }

    public void GlowEnemy(BattleActiveEnemy enemy, string SpecilizedAnim = "")
    {
        Enemy_TargetSelectionGlow[] array = UnityEngine.Object.FindObjectsOfType<Enemy_TargetSelectionGlow>();
        for (int i = 0; i < array.Length; i++)
        {
            array[i].CurrentlyTargetted = false;
        }
        Array.Clear(array, 0, array.Length);
        if (enemy == null)
        {
            return;
        }
        array = enemy.EnemyInBattle_Gameobject.GetComponentsInChildren<Enemy_TargetSelectionGlow>();
        for (int j = 0; j < array.Length; j++)
        {
            if (SpecilizedAnim == "")
            {
                array[j].CurrentlyTargetted = true;
            }
            else
            {
                array[j].PlayGlowSpecializedAnimation(SpecilizedAnim);
            }
        }
    }

    public void GlowMember(BattlePartyMember member, string SpecilizedAnim = "")
    {
        Enemy_TargetSelectionGlow[] array = UnityEngine.Object.FindObjectsOfType<Enemy_TargetSelectionGlow>();
        for (int i = 0; i < array.Length; i++)
        {
            array[i].CurrentlyTargetted = false;
        }
        Array.Clear(array, 0, array.Length);
        if (member == null)
        {
            return;
        }
        array = member.PartyMemberInBattle_Gameobjects.GetComponentsInChildren<Enemy_TargetSelectionGlow>();
        for (int j = 0; j < array.Length; j++)
        {
            if (SpecilizedAnim == "")
            {
                array[j].CurrentlyTargetted = true;
            }
            else
            {
                array[j].PlayGlowSpecializedAnimation(SpecilizedAnim);
            }
        }
    }

    public Enemy_TargetSelectionGlow[] GetEnemyGlows(BattleActiveEnemy enemy, string SpecilizedAnim = "")
    {
        return enemy.EnemyInBattle_Gameobject.GetComponentsInChildren<Enemy_TargetSelectionGlow>();
    }

    public void FlashMemberLight(BattlePartyMember member)
    {
        instance.GlowMember(member, "SingleGlow");
    }

    private void RemoveEnemyFromBattle(BattleActiveEnemy target, bool PlayRemoveAnimation = false, BattleEnemyRemoveAnimation animation = BattleEnemyRemoveAnimation.Flee)
    {
        if (target == null || !BattleActiveEnemies.Contains(target))
        {
            return;
        }
        StopCoroutine("ShakeEnemy");
        UnityEngine.Object.Destroy(target.EnemyStatus.gameObject);
        if (!PlayRemoveAnimation)
        {
            UnityEngine.Object.Destroy(target.EnemyInBattle_Gameobject);
        }
        else
        {
            if (animation == BattleEnemyRemoveAnimation.Flee)
            {
                BattleEnemyRemoveAnimation_Flee(target);
            }
            if (animation == BattleEnemyRemoveAnimation.Spare)
            {
                BattleEnemyRemoveAnimation_Spare(target);
            }
        }
        BattleActiveEnemies.Remove(target);
    }

    private void OpenBattleBox(bool DisableSoulEffect = false)
    {
        StartCoroutine(OpenBattleBox_Timed());
        if (BattlePartyMembers.Count > 0)
        {
            if (!DisableSoulEffect)
            {
                UnityEngine.Object.Instantiate(Effect_SoulRipOut).transform.position = BattlePartyMembers[0].StoredPartyMembePositions + new Vector2(0f, 0.6f);
            }
            StartCoroutine(LerpSoulToPosition(BattlePartyMembers[0].StoredPartyMembePositions + new Vector2(0f, 0.6f), BattleBox_Collisions.transform.position, 0.25f));
        }
        else
        {
            BattleBox_Soul.transform.position = BattleBox_Collisions.transform.position;
            BattleBox_Soul.GetComponent<Battle_PlayerSoul>().CurrentSoulState = Battle_PlayerSoul.SoulState.Disabled;
        }
    }

    public void CloseBattleBox(bool DisableSoulEffect = false)
    {
        StartCoroutine(CloseBattleBox_Timed(DisableSoulEffect));
        if (BattlePartyMembers.Count > 0)
        {
            if (BattlePartyMembers[0] != null)
            {
                StartCoroutine(LerpSoulToPosition(Battle_PlayerSoul.Instance.transform.position, BattlePartyMembers[0].StoredPartyMembePositions + new Vector2(0f, 0.6f), 0.25f));
                if (!DisableSoulEffect)
                {
                    UnityEngine.Object.Instantiate(Effect_SoulInsert).transform.position = BattlePartyMembers[0].StoredPartyMembePositions + new Vector2(0f, 0.6f);
                }
            }
            else
            {
                Debug.LogWarning("BattlePartyMembers[0] was null when trying to close battle box and lerp soul");
            }
        }
        else
        {
            BattleBox_Soul.transform.position = BattleBox_Collisions.transform.position;
            BattleBox_Soul.GetComponent<Battle_PlayerSoul>().CurrentSoulState = Battle_PlayerSoul.SoulState.Disabled;
        }
    }

    private IEnumerator LerpSoulToPosition(Vector3 start, Vector3 end, float time)
    {
        float elapsed = 0f;
        BattleBox_Soul.GetComponent<Battle_PlayerSoul>().CurrentSoulState = Battle_PlayerSoul.SoulState.Disabled;
        BattleBox_Soul.SetActive(value: true);
        while (elapsed < time)
        {
            BattleBox_Soul.transform.position = Vector3.Lerp(start, end, elapsed / time);
            elapsed += Time.deltaTime;
            yield return null;
        }
        BattleBox_Soul.transform.position = end;
    }

    private IEnumerator OpenBattleBox_Timed()
    {
        BattleBox_Animator.Play("BattleBox_FadeIn");
        BehindBoxAttackFade_Animator.Play("BehindBoxFade_FadeIn", -1, 0f);
        yield return new WaitForSeconds(0.4f);
        BattleBox_Collisions.SetActive(value: true);
        BattleBox_Soul.GetComponent<Battle_PlayerSoul>().CurrentSoulState = Battle_PlayerSoul.SoulState.Active;
    }

    private IEnumerator CloseBattleBox_Timed(bool DisableBoxEffect = false)
    {
        if (!DisableBoxEffect)
        {
            BattleBox_Animator.Play("BattleBox_FadeOut");
        }
        else
        {
            BattleBox_Animator.Play("BattleBox_Hidden");
        }
        BehindBoxAttackFade_Animator.Play("BehindBoxFade_FadeOut", -1, 0f);
        FadePartyMembersAndEnemies(1f, 0.5f);
        BattleBox_Soul.GetComponent<Battle_PlayerSoul>().CurrentSoulState = Battle_PlayerSoul.SoulState.Disabled;
        yield return new WaitForSeconds(0.4f);
        BattleBox_Collisions.SetActive(value: false);
    }

    private void CreateAllQueuedAttacks()
    {
        float num = 395248f;
        foreach (BattleEnemyAttack queuedBattleAttack in QueuedBattleAttacks)
        {
            if (num == 395248f)
            {
                num = queuedBattleAttack.AttackTime;
            }
            if (queuedBattleAttack.AttackPrefab != null)
            {
                GameObject gameObject = UnityEngine.Object.Instantiate(queuedBattleAttack.AttackPrefab, BattleBox.transform.position, Quaternion.identity);
                gameObject.name = queuedBattleAttack.AttackPrefab.name;
                CurrentlyActiveAttacks.Add(gameObject);
            }
            if (queuedBattleAttack.FadeCharactersAway)
            {
                FadePartyMembersAndEnemies(0f, 0.5f);
            }
        }
        if (num != -1f)
        {
            currentAttackTimerCoroutine = StartCoroutine(EnemyAttackTimer(num));
        }
    }

    private IEnumerator EnemyAttackTimer(float AttackLength)
    {
        yield return new WaitForSeconds(AttackLength);
        EndEnemyAttackTurn();
        yield return new WaitForSeconds(0.2f);
        Battle_PlayerSoul.Instance.CurrentSoulState = Battle_PlayerSoul.SoulState.Disabled;
        BattleBox_Soul.SetActive(value: false);
        currentAttackTimerCoroutine = null;
    }

    public void EndEnemyAttackTurn(bool RevertToPlayerTurn = true)
    {
        foreach (GameObject currentlyActiveAttack in CurrentlyActiveAttacks)
        {
            UnityEngine.Object.Destroy(currentlyActiveAttack.gameObject);
        }
        foreach (BattleEnemyAttack queuedBattleAttack in QueuedBattleAttacks)
        {
            if (!queuedBattleAttack.ClearBulletHolderChildren)
            {
                continue;
            }
            Transform[] componentsInChildren = Holder_Bullets.GetComponentsInChildren<Transform>();
            foreach (Transform transform in componentsInChildren)
            {
                if (transform != Holder_Bullets.transform)
                {
                    UnityEngine.Object.Destroy(transform.gameObject);
                }
            }
        }
        CurrentlyActiveAttacks.Clear();
        QueuedBattleAttacks.Clear();
        if (RevertToPlayerTurn)
        {
            CurrentBattleState = BattleState.PlayerTurn;
        }
    }

    public static void OpenBottomBarWindow(BottomBarWindows Window)
    {
        switch (Window)
        {
            case BottomBarWindows.None:
                instance.HideAllBattleWindows();
                BattleChatbox.Instance.TextVisible = true;
                break;
            case BottomBarWindows.Fight_EnemySelection:
                instance.BattleWindow_EnemySelection.GetComponent<BattleEnemySelectionMenu>().MenuContext = BattleEnemySelectionMenu.BattleEnemySelectionWindow_Context.Fight;
                instance.BattleWindow_EnemySelection.GetComponent<BattleEnemySelectionMenu>().ResetSoulToRestPosition();
                instance.BattleWindow_EnemySelection.SetActive(value: true);
                instance.BattleWindow_EnemySelection.GetComponent<BattleEnemySelectionMenu>().currentIndex = 0;
                instance.BattleWindow_EnemySelection.GetComponent<BattleEnemySelectionMenu>().UpdateGraphics();
                BattleChatbox.Instance.TextVisible = false;
                break;
            case BottomBarWindows.Fight_AttackBar:
                instance.BattleWindow_AttackBars.SetActive(value: true);
                BattleChatbox.Instance.TextVisible = false;
                break;
            case BottomBarWindows.Item_SelectItem:
                instance.BattleWindow_ActItemSelection.GetComponent<BattleActItemWindow>().ResetBattleActItemWindow();
                instance.BattleWindow_ActItemSelection.SetActive(value: true);
                instance.BattleWindow_ActItemSelection.GetComponent<BattleActItemWindow>().AddDarkworldInventoryToSelectables();
                instance.BattleWindow_ActItemSelection.GetComponent<BattleActItemWindow>().Debounce_AllowInput();
                instance.BattleWindow_ActItemSelection.GetComponent<BattleActItemWindow>().UpdateCurrentSelection();
                BattleChatbox.Instance.TextVisible = false;
                break;
            case BottomBarWindows.Act_SelectAction:
                instance.BattleWindow_ActItemSelection.GetComponent<BattleActItemWindow>().ResetBattleActItemWindow();
                instance.BattleWindow_ActItemSelection.SetActive(value: true);
                instance.BattleWindow_ActItemSelection.GetComponent<BattleActItemWindow>().AddActionsToSelectables(instance.QueuedBattleActions);
                instance.BattleWindow_ActItemSelection.GetComponent<BattleActItemWindow>().Debounce_AllowInput();
                instance.BattleWindow_ActItemSelection.GetComponent<BattleActItemWindow>().UpdateCurrentSelection();
                BattleChatbox.Instance.TextVisible = false;
                break;
            case BottomBarWindows.Act_EnemySelection:
                instance.BattleWindow_EnemySelection.GetComponent<BattleEnemySelectionMenu>().MenuContext = BattleEnemySelectionMenu.BattleEnemySelectionWindow_Context.Act;
                instance.BattleWindow_EnemySelection.GetComponent<BattleEnemySelectionMenu>().ResetSoulToRestPosition();
                instance.BattleWindow_EnemySelection.SetActive(value: true);
                instance.BattleWindow_EnemySelection.GetComponent<BattleEnemySelectionMenu>().currentIndex = 0;
                instance.BattleWindow_EnemySelection.GetComponent<BattleEnemySelectionMenu>().UpdateGraphics();
                BattleChatbox.Instance.TextVisible = false;
                break;
            case BottomBarWindows.Act_MemberSelection:
                instance.BattleWindow_PartyMemberSelection.GetComponent<BattleMemberSelectionMenu>().MenuContext = BattleMemberSelectionMenu.BattleMemberSelectionWindow_Context.Act;
                instance.BattleWindow_PartyMemberSelection.SetActive(value: true);
                BattleChatbox.Instance.TextVisible = false;
                break;
            case BottomBarWindows.Item_MemberSelection:
                instance.BattleWindow_PartyMemberSelection.GetComponent<BattleMemberSelectionMenu>().MenuContext = BattleMemberSelectionMenu.BattleMemberSelectionWindow_Context.Item;
                instance.BattleWindow_PartyMemberSelection.SetActive(value: true);
                break;
            case BottomBarWindows.Spare_EnemySelection:
                instance.BattleWindow_EnemySelection.GetComponent<BattleEnemySelectionMenu>().MenuContext = BattleEnemySelectionMenu.BattleEnemySelectionWindow_Context.Spare;
                instance.BattleWindow_EnemySelection.GetComponent<BattleEnemySelectionMenu>().ResetSoulToRestPosition();
                instance.BattleWindow_EnemySelection.SetActive(value: true);
                instance.BattleWindow_EnemySelection.GetComponent<BattleEnemySelectionMenu>().UpdateGraphics();
                BattleChatbox.Instance.TextVisible = false;
                break;
        }
    }

    public static void AddNewPlayerMove(BattlePlayerMove move, BattlePartyMember partyMember, int targetEnemy = 0, BattlePartyMember targetMember = null, BattleAction targetAction = null, InventoryItem targetItem = null, int storedItemIndex = 0)
    {
        BattlePartyMemberUse battlePartyMemberUse = new BattlePartyMemberUse();
        battlePartyMemberUse.BattleMove = move;
        battlePartyMemberUse.targetPartyMember = partyMember;
        battlePartyMemberUse.targetMember = targetMember;
        battlePartyMemberUse.Item_ToUse = targetItem;
        battlePartyMemberUse.StoredItemOriginalIndex = storedItemIndex;
        battlePartyMemberUse.Action_ToRun = targetAction;
        if (targetEnemy < 0 || targetEnemy > instance.BattleActiveEnemies.Count)
        {
            battlePartyMemberUse.targetEnemy = null;
        }
        else
        {
            battlePartyMemberUse.targetEnemy = instance.BattleActiveEnemies[targetEnemy];
        }
        if (battlePartyMemberUse.Action_ToRun != null && battlePartyMemberUse.Action_ToRun.TPRequired > 0)
        {
            instance.AddTP(-battlePartyMemberUse.Action_ToRun.TPRequired);
        }
        instance.CurrentPlayerMoves.Add(battlePartyMemberUse);
    }

    private void MembersUseItems(List<BattlePartyMemberUse> Moves)
    {
        StartCoroutine(UseMemberItemsTimed(Moves));
    }

    private IEnumerator UseMemberItemsTimed(List<BattlePartyMemberUse> Moves)
    {
        List<BattlePartyMemberUse> list = new List<BattlePartyMemberUse>();
        foreach (BattlePartyMemberUse Move in Moves)
        {
            if (Move.BattleMove == BattlePlayerMove.Item && Move.Item_ToUse != null)
            {
                MonoBehaviour.print(Move);
                list.Add(Move);
            }
        }
        foreach (BattlePartyMemberUse validmove in list)
        {
            PartyMembers_MemberPlayAnimation(validmove.targetPartyMember, "UseItem");
            OpenBottomBarWindow(BottomBarWindows.None);
            BattleChatbox.Instance.StoredAdditiveValues.Clear();
            BattleChatbox.Instance.StoredAdditiveValues.Add(validmove.targetPartyMember.PartyMemberInBattle.PartyMemberName);
            BattleChatbox.Instance.StoredAdditiveValues.Add(validmove.Item_ToUse.ItemName);
            BattleChatbox.AllowInput = true;
            BattleChatbox.RunText(Dialogue_UseItem, 0, null, ResetCurrentTextIndex: false);
            yield return new WaitForSeconds(0.33f);
            if (validmove.targetMember == null)
            {
                foreach (BattlePartyMember battlePartyMember in BattlePartyMembers)
                {
                    HealPartyMember(battlePartyMember, validmove.Item_ToUse.HealthAddition);
                }
            }
            else
            {
                HealPartyMember(validmove.targetMember, validmove.Item_ToUse.HealthAddition);
            }
            while (BattleChatbox.ChatIsCurrentlyRunning)
            {
                yield return null;
            }
        }
        Instance.CurrentBattlePlayerTurnState = BattlePlayerTurnState.FINISHED;
    }

    private void MemberUseActions(List<BattlePartyMemberUse> Moves)
    {
        StartCoroutine(UseMemberActionsTimed(Moves));
    }

    private IEnumerator UseMemberActionsTimed(List<BattlePartyMemberUse> Moves)
    {
        List<BattlePartyMemberUse> list = new List<BattlePartyMemberUse>();
        foreach (BattlePartyMemberUse Move in Moves)
        {
            if (Move.BattleMove == BattlePlayerMove.Action && Move.Action_ToRun != null)
            {
                MonoBehaviour.print(Move);
                list.Add(Move);
            }
        }
        foreach (BattlePartyMemberUse validmove in list)
        {
            instance.CurrentlyRunningAction = true;
            OpenBottomBarWindow(BottomBarWindows.None);
            BattleChatbox.Instance.StoredAdditiveValues.Clear();
            BattleChatbox.Instance.StoredAdditiveValues.Add(validmove.targetPartyMember.PartyMemberInBattle.PartyMemberName);
            switch (validmove.Action_ToRun.ActionTarget)
            {
                case BattleAction.BattleActionTarget.PartyMember:
                    BattleChatbox.Instance.StoredAdditiveValues.Add(validmove.targetMember.PartyMemberInBattle.PartyMemberName);
                    break;
                case BattleAction.BattleActionTarget.Enemy:
                    BattleChatbox.Instance.StoredAdditiveValues.Add(validmove.targetEnemy.EnemyInBattle.EnemyName);
                    break;
            }
            yield return new WaitForSeconds(0.33f);
            if (validmove.Action_ToRun.BattleScript_FunctionToRun.Contains('>'))
            {
                string battleScript_FunctionToRun = validmove.Action_ToRun.BattleScript_FunctionToRun;
                battleScript_FunctionToRun = battleScript_FunctionToRun.Replace(">", "");
                Component component = this;
                component.GetType().GetMethod(battleScript_FunctionToRun).Invoke(component, new object[1] { validmove });
            }
            else
            {
                Component component2 = CurrentBattleScriptGameobject.GetComponent(CurrentBattleScript);
                component2.GetType().GetMethod(validmove.Action_ToRun.BattleScript_FunctionToRun).Invoke(component2, new object[1] { validmove });
            }
            while (instance.CurrentlyRunningAction)
            {
                yield return null;
            }
        }
        Instance.CurrentBattlePlayerTurnState = BattlePlayerTurnState.FINISHED;
    }

    private void MembersSpare(List<BattlePartyMemberUse> Moves)
    {
        StartCoroutine(AllMembersTrySpare(Moves));
    }

    private IEnumerator AllMembersTrySpare(List<BattlePartyMemberUse> Moves)
    {
        List<BattlePartyMemberUse> list = new List<BattlePartyMemberUse>();
        foreach (BattlePartyMemberUse Move in Moves)
        {
            if (Move.BattleMove == BattlePlayerMove.Spare && Move.targetEnemy != null)
            {
                MonoBehaviour.print(Move);
                list.Add(Move);
            }
        }
        foreach (BattlePartyMemberUse validmove in list)
        {
            PartyMembers_MemberPlayAnimation(validmove.targetPartyMember, "Spare");
            OpenBottomBarWindow(BottomBarWindows.None);
            BattleChatbox.Instance.StoredAdditiveValues.Clear();
            BattleChatbox.Instance.StoredAdditiveValues.Add(validmove.targetPartyMember.PartyMemberInBattle.PartyMemberName);
            BattleChatbox.Instance.StoredAdditiveValues.Add(validmove.targetEnemy.EnemyInBattle.EnemyName);
            BattleChatbox.AllowInput = true;
            if (validmove.targetEnemy.Enemy_MercyAmount >= 100f)
            {
                BattleChatbox.RunText(Dialogue_SpareSuccessful, 0, null, ResetCurrentTextIndex: false);
            }
            else if (validmove.targetEnemy.Enemy_IsTired)
            {
                BattleChatbox.RunText(Dialogue_SpareFail_PossiblePacify, 0, null, ResetCurrentTextIndex: false);
            }
            else
            {
                BattleChatbox.RunText(Dialogue_SpareFail, 0, null, ResetCurrentTextIndex: false);
            }
            yield return new WaitForSeconds(0.33f);
            if (validmove.targetEnemy.Enemy_MercyAmount > 100f)
            {
                SpareEnemy(validmove.targetEnemy, 0f, validmove.targetPartyMember, validmove.targetEnemy.Enemy_Spareable);
            }
            else
            {
                SpareEnemy(validmove.targetEnemy, validmove.targetEnemy.EnemyInBattle.DefaultSpareAmount, validmove.targetPartyMember, validmove.targetEnemy.Enemy_Spareable);
            }
            while (BattleChatbox.ChatIsCurrentlyRunning)
            {
                yield return null;
            }
        }
        Instance.CurrentBattlePlayerTurnState = BattlePlayerTurnState.FINISHED;
    }

    public void RefundAllMoveItems()
    {
        if (Instance.CurrentPlayerMoves.Count <= 0)
        {
            return;
        }
        for (int i = 0; i < Instance.CurrentPlayerMoves.Count; i++)
        {
            BattlePartyMemberUse battlePartyMemberUse = Instance.CurrentPlayerMoves[i];
            if (battlePartyMemberUse.Item_ToUse != null && CurrentPlayerTurnSelectionIndex <= i)
            {
                if (battlePartyMemberUse.StoredItemOriginalIndex > -1)
                {
                    DarkworldInventory.Instance.PlayerInventory.Insert(battlePartyMemberUse.StoredItemOriginalIndex, battlePartyMemberUse.Item_ToUse);
                }
                else
                {
                    DarkworldInventory.Instance.PlayerInventory.Add(battlePartyMemberUse.Item_ToUse);
                }
            }
        }
    }

    public static BattlePartyMember GetPartyMember(PartyMember member)
    {
        foreach (BattlePartyMember battlePartyMember in instance.BattlePartyMembers)
        {
            if (battlePartyMember.PartyMemberInBattle == member)
            {
                return battlePartyMember;
            }
        }
        return null;
    }

    private void CreateNewAttackBars(List<BattlePartyMemberUse> Moves)
    {
        BattleWindow_AttackBars.GetComponent<BattleAttackWindow>().ClearAttackBars();
        List<BattlePartyMemberUse> list = new List<BattlePartyMemberUse>();
        foreach (BattlePartyMemberUse Move in Moves)
        {
            if (Move.BattleMove == BattlePlayerMove.Fight && Move.targetPartyMember != null)
            {
                MonoBehaviour.print(Move);
                list.Add(Move);
            }
        }
        foreach (BattlePartyMemberUse item in list)
        {
            BattleAttackBar component = UnityEngine.Object.Instantiate(BattlePrefab_PlayerAttackBar, Holder_AttackBars.transform).GetComponent<BattleAttackBar>();
            component.TargetPartyMember = item.targetPartyMember;
            component.TargetActiveEnemy = item.targetEnemy;
            component.UpdateGraphics();
        }
        OpenBottomBarWindow(BottomBarWindows.Fight_AttackBar);
        BattleWindow_AttackBars.GetComponent<BattleAttackWindow>().SetupAttackBarPositions();
    }

    public void ShakePartyMember(BattlePartyMember target, float multiplier = 1f, float duration = 1f)
    {
        Transform target2 = null;
        if (target != null && target.PartyMemberInBattle_Gameobjects != null)
        {
            target2 = target.PartyMemberInBattle_Gameobjects.transform;
        }
        StartCoroutine(ShakeTarget(target2, multiplier, duration));
    }

    public void ShakeEnemy(BattleActiveEnemy target, float multiplier = 1f, float duration = 1f)
    {
        Transform target2 = null;
        if (target != null && target.EnemyInBattle_Gameobject != null)
        {
            target2 = target.EnemyInBattle_Gameobject.transform;
        }
        StartCoroutine(ShakeTarget(target2, multiplier, duration));
    }

    private IEnumerator ShakeTarget(Transform target, float multiplier = 1f, float duration = 1f)
    {
        if (target != null)
        {
            Vector3 originalPosition = target.position;
            float elapsedTime = 0f;
            while (multiplier > 0f && !(target == null))
            {
                float num = UnityEngine.Random.Range(-1f, 1f) * multiplier;
                target.position = new Vector2(originalPosition.x + num, originalPosition.y);
                elapsedTime += Time.fixedDeltaTime;
                multiplier -= Time.fixedDeltaTime * (1f / duration);
                yield return null;
            }
            if (target != null)
            {
                target.position = originalPosition;
            }
        }
    }

    public void DamageEnemy(BattleActiveEnemy target, float Damage, BattlePartyMember Inflictor, float posOffset = 0.6f, bool TransferRemainingDamage = false)
    {
        StartCoroutine(DamageEnemyAnimated(target, Damage, Inflictor, posOffset, TransferRemainingDamage));
    }

    public void SpareEnemy(BattleActiveEnemy target, float Amount, BattlePartyMember Inflictor, bool wasSpareable)
    {
        StartCoroutine(SpareEnemyAnimated(target, Amount, Inflictor, wasSpareable));
    }

    private BattleActiveEnemy GetNewTarget()
    {
        foreach (BattleActiveEnemy battleActiveEnemy in BattleActiveEnemies)
        {
            if (battleActiveEnemy != null && battleActiveEnemy.EnemyInBattle != null && battleActiveEnemy.Enemy_Health > 0f)
            {
                return battleActiveEnemy;
            }
        }
        return null;
    }

    private IEnumerator DamageEnemyAnimated(BattleActiveEnemy target, float Damage, BattlePartyMember Inflictor, float posOffset = 0.6f, bool TransferRemainingDamage = false)
    {
        OnEnemyDamaged(target, Damage, Inflictor);
        if (target == null || !target.Enemy_ConsideredInBattle)
        {
            target = GetNewTarget();
            if (target == null || !target.Enemy_ConsideredInBattle)
            {
                MonoBehaviour.print("null");
                yield break;
            }
        }
        if (target.Enemy_Health - Damage <= 0f)
        {
            OnEnemyKilled(target, Damage, Inflictor);
            PlayBattleSoundEffect(SFX_enemy_damage, 0.5f);
            float num = Mathf.Max(Damage - target.Enemy_Health, 0f);
            if (target.EnemyInBattle_Gameobject != null)
            {
                Vector3 vector = target.EnemyInBattle_Gameobject.transform.position + new Vector3(0f, posOffset * (float)EnemyDamageBattleNumberOffset, 0f);
                DisplayBattleNumbers(BattleNumbers_SpecificText, 6, vector + new Vector3(0f, posOffset * (float)EnemyDamageBattleNumberOffset, 0f), Color.white, FlippedAnimation: true);
                DisplayBattleNumbers(BattleNumbers_Default, Mathf.CeilToInt(Damage - num), vector, Inflictor.PartyMemberInBattle.PartyMemberColor_Highlighted, FlippedAnimation: true);
                EnemyDamageBattleNumberOffset++;
            }
            CurrentPossibleEXP += target.EnemyInBattle.EXP;
            RemoveEnemyFromBattle(target, PlayRemoveAnimation: true);
            if (TransferRemainingDamage)
            {
                target = GetNewTarget();
                if (target != null)
                {
                    DamageEnemy(target, num, Inflictor);
                }
            }
            yield break;
        }
        if (target != null && target.EnemyInBattle_Animator != null)
        {
            if (Mathf.CeilToInt(Damage) <= 0)
            {
                DisplayBattleNumbers(BattleNumbers_SpecificText, 2, target.EnemyInBattle_Gameobject.transform.position + new Vector3(0f, posOffset * (float)EnemyDamageBattleNumberOffset, 0f), Inflictor.PartyMemberInBattle.PartyMemberColor_Highlighted, FlippedAnimation: true);
            }
            else
            {
                target.Enemy_Health -= Damage;
                target.Enemy_Health = Math.Clamp(target.Enemy_Health, 0f, target.Enemy_MaxHealth);
                PlayBattleSoundEffect(SFX_enemy_damage, 0.5f);
                target.EnemyInBattle_Animator.Play("Hurt", -1, 0f);
                if (target.Enemy_Health > 0f)
                {
                    ShakeEnemy(target, 0.25f, 2f);
                }
                DisplayBattleNumbers(BattleNumbers_Default, Mathf.CeilToInt(Damage), target.EnemyInBattle_Gameobject.transform.position + new Vector3(0f, posOffset * (float)EnemyDamageBattleNumberOffset, 0f), Inflictor.PartyMemberInBattle.PartyMemberColor_Highlighted, FlippedAnimation: true);
            }
            EnemyDamageBattleNumberOffset++;
        }
        yield return new WaitForSeconds(1f);
        if (target != null && target.EnemyInBattle_Animator != null)
        {
            if (target.Enemy_MercyAmount < 100f)
            {
                target.EnemyInBattle_Animator.Play("Idle");
            }
            else
            {
                target.EnemyInBattle_Animator.Play("Spare");
            }
        }
    }

    private IEnumerator SpareEnemyAnimated(BattleActiveEnemy target, float amount, BattlePartyMember inflictor, bool enemyWasSpareable)
    {
        if (target == null || target.Enemy_Health <= 0f || target.EnemyInBattle_Gameobject == null || !target.Enemy_ConsideredInBattle)
        {
            target = GetNewTarget();
            if (target == null)
            {
                Debug.LogWarning("No new targets available to spare?");
                yield break;
            }
        }
        _ = target.Enemy_MercyAmount;
        float newMercyAmount = Mathf.Clamp(target.Enemy_MercyAmount + amount, 0f, 100f);
        bool willBeSpareable = newMercyAmount >= 100f;
        if (willBeSpareable && !enemyWasSpareable)
        {
            target.EnemyInBattle_Animator.Play("Spare");
            target.Enemy_Spareable = true;
        }
        yield return null;
        OnEnemySpared(target, willBeSpareable, inflictor);
        target.Enemy_MercyAmount = newMercyAmount;
        PlayBattleSoundEffect(sfx_enemy_spareblink, 0.5f);
        if (newMercyAmount >= 100f)
        {
            if (!enemyWasSpareable)
            {
                if (target.EnemyInBattle_Gameobject != null)
                {
                    DisplayBattleNumbers(BattleNumbers_SpecificText, 4, target.EnemyInBattle_Gameobject.transform.position + new Vector3(-1f, 0.6f * (float)EnemyDamageBattleNumberOffset, 0f), Color.white, FlippedAnimation: true);
                }
            }
            else
            {
                RemoveEnemyFromBattle(target, PlayRemoveAnimation: true, BattleEnemyRemoveAnimation.Spare);
            }
        }
        else if (target.EnemyInBattle_Gameobject != null)
        {
            GlowEnemy(target, "FailedSpare");
            DisplayBattleNumbers(BattleNumbers_Golden, Mathf.CeilToInt(amount), target.EnemyInBattle_Gameobject.transform.position + new Vector3(-2f, 0.6f * (float)EnemyDamageBattleNumberOffset, 0f), Color.white, FlippedAnimation: true, IncludePercentSprite: true, IncludePlusSprite: true);
        }
    }

    public void DisplayBattleNumbers(BattleNumberSprites Numbers, int NumberToDisplay, Vector2 PositionToDisplay, Color NumberColors, bool FlippedAnimation = false, bool IncludePercentSprite = false, bool IncludePlusSprite = false)
    {
        GameObject gameObject = UnityEngine.Object.Instantiate(BattlePrefab_BattleNumbers, Holder_Effects.transform);
        gameObject.transform.position = PositionToDisplay;
        if (FlippedAnimation)
        {
            gameObject.GetComponent<Animator>().Play("BattleEffect_NumberPopIn_Flipped");
        }
        string text = NumberToDisplay.ToString();
        float num = Numbers.NumberSprites[0].textureRect.width / Numbers.NumberSprites[0].pixelsPerUnit;
        Vector2 vector = PositionToDisplay;
        Vector2 vector2 = Vector2.zero;
        if (IncludePlusSprite)
        {
            GameObject obj = new GameObject("Digit_Plus");
            obj.transform.SetParent(gameObject.transform);
            obj.transform.position = PositionToDisplay + new Vector2(num, 0f);
            vector += new Vector2(num * 2f, 0f);
            SpriteRenderer spriteRenderer = obj.AddComponent<SpriteRenderer>();
            spriteRenderer.sprite = Numbers.NumberSprites[12];
            spriteRenderer.sortingLayerName = "Battle_AboveBox";
            spriteRenderer.color = NumberColors;
        }
        for (int i = 0; i < text.Length; i++)
        {
            GameObject obj2 = new GameObject("Digit_" + text[i]);
            obj2.transform.SetParent(gameObject.transform);
            vector2 = new Vector2(vector.x + (float)i * num, vector.y);
            obj2.transform.position = vector2;
            SpriteRenderer spriteRenderer2 = obj2.AddComponent<SpriteRenderer>();
            if (text[i] == '-')
            {
                spriteRenderer2.sprite = Numbers.NumberSprites[10];
            }
            else
            {
                int num2 = int.Parse(text[i].ToString());
                spriteRenderer2.sprite = Numbers.NumberSprites[num2];
            }
            spriteRenderer2.sortingLayerName = "Battle_AboveBox";
            spriteRenderer2.color = NumberColors;
        }
        if (IncludePercentSprite)
        {
            GameObject obj3 = new GameObject("Digit_Percentage");
            obj3.transform.SetParent(gameObject.transform);
            obj3.transform.position = vector2 + new Vector2(num, 0f);
            SpriteRenderer spriteRenderer3 = obj3.AddComponent<SpriteRenderer>();
            spriteRenderer3.sprite = Numbers.NumberSprites[11];
            spriteRenderer3.sortingLayerName = "Battle_AboveBox";
            spriteRenderer3.color = NumberColors;
        }
    }

    public BattleBubbleChatbox NewDialogueForEnemy(BattleActiveEnemy targetEnemy, CHATBOXTEXT text, int TextIndex, int AdditionalTextIndex, GameObject DialogueBubblePrefab)
    {
        GameObject obj = UnityEngine.Object.Instantiate(DialogueBubblePrefab);
        BattleBubbleChatbox component = obj.GetComponent<BattleBubbleChatbox>();
        obj.transform.position = targetEnemy.EnemyInBattle_Gameobject.transform.position + new Vector3(-1.25f, 0.75f);
        component.RunText(text, TextIndex, AdditionalTextIndex);
        return component;
    }

    private void FadePartyMembersAndEnemies(float targetOpacity, float duration)
    {
        foreach (BattlePartyMember battlePartyMember in BattlePartyMembers)
        {
            if (battlePartyMember.PartyMemberInBattle_MainSpriteRenderer != null)
            {
                StartCoroutine(FadeSpriteRenderer(battlePartyMember.PartyMemberInBattle_MainSpriteRenderer, targetOpacity, duration));
            }
        }
        foreach (BattleActiveEnemy battleActiveEnemy in BattleActiveEnemies)
        {
            if (battleActiveEnemy.EnemyInBattle_Gameobject != null)
            {
                SpriteRenderer[] componentsInChildren = battleActiveEnemy.EnemyInBattle_Gameobject.GetComponentsInChildren<SpriteRenderer>();
                foreach (SpriteRenderer spriteRenderer in componentsInChildren)
                {
                    StartCoroutine(FadeSpriteRenderer(spriteRenderer, targetOpacity, duration));
                }
            }
        }
    }

    private IEnumerator FadeSpriteRenderer(SpriteRenderer spriteRenderer, float targetOpacity, float duration)
    {
        if (spriteRenderer != null)
        {
            Color originalColor = spriteRenderer.color;
            float startOpacity = originalColor.a;
            float elapsedTime = 0f;
            while (elapsedTime < duration)
            {
                elapsedTime += Time.deltaTime;
                float a = Mathf.Lerp(startOpacity, targetOpacity, elapsedTime / duration);
                if (spriteRenderer != null)
                {
                    spriteRenderer.color = new Color(originalColor.r, originalColor.g, originalColor.b, a);
                }
                yield return null;
            }
            if (spriteRenderer != null)
            {
                spriteRenderer.color = new Color(originalColor.r, originalColor.g, originalColor.b, targetOpacity);
            }
        }
        else
        {
            Debug.LogWarning("FadeSpriteRenderer Failed | spriteRenderer is missing or null?");
        }
    }

    public void DefaultAct_Check(BattlePartyMemberUse action)
    {
        Instance.PartyMembers_MemberPlayAnimation(action.targetPartyMember, "DefaultAct");
        CHATBOXTEXT enemyCheckText = action.targetEnemy.EnemyInBattle.EnemyCheckText;
        BattleChatbox.AllowInput = true;
        BattleChatbox.RunText(enemyCheckText, 0, null, ResetCurrentTextIndex: false);
    }

    public void BattleEnemyRemoveAnimation_Flee(BattleActiveEnemy target)
    {
        StartCoroutine(BattleEnemyRemoveAnimation_Flee_Coroutine(target));
    }

    private IEnumerator BattleEnemyRemoveAnimation_Flee_Coroutine(BattleActiveEnemy target)
    {
        target.Enemy_ConsideredInBattle = false;
        ParticleSystem enemyAfterImage = target.EnemyInBattle_AfterImageParticleRenderer.GetComponentInChildren<ParticleSystem>();
        GameObject enemyGameobject = target.EnemyInBattle_Gameobject;
        enemyGameobject.transform.Find("SweatDroplet").GetComponent<Animator>().Play("BattleEnemy_Sweat");
        PlayBattleSoundEffect(SFX_EnemyFlee, 1.5f);
        ActiveEnemies_PlayAnimation(target, "Hurt");
        yield return new WaitForSeconds(0.5f);
        Vector3 TargetPosition = enemyGameobject.transform.position + new Vector3(15f, 0f, 0f);
        ParticleSystem.TextureSheetAnimationModule textureSheetAnimation = enemyAfterImage.textureSheetAnimation;
        ParticleSystem.EmissionModule emission = enemyAfterImage.emission;
        emission.rateOverTimeMultiplier = 120f;
        textureSheetAnimation.SetSprite(0, target.EnemyInBattle_MainSpriteRenderer.sprite);
        enemyAfterImage.Play();
        UnityEngine.Object.Destroy(enemyGameobject, 3f);
        while (enemyGameobject != null && enemyGameobject.transform.position != TargetPosition)
        {
            yield return null;
            if (enemyGameobject != null)
            {
                enemyGameobject.transform.position = Vector3.Lerp(enemyGameobject.transform.position, TargetPosition, 2f * Time.deltaTime);
            }
        }
    }

    public void BattleEnemyRemoveAnimation_Spare(BattleActiveEnemy target)
    {
        StartCoroutine(BattleEnemyRemoveAnimation_Spare_Coroutine(target));
    }

    private IEnumerator BattleEnemyRemoveAnimation_Spare_Coroutine(BattleActiveEnemy target)
    {
        target.Enemy_ConsideredInBattle = false;
        ParticleSystem particleSystem = null;
        ParticleSystem[] componentsInChildren = target.EnemyInBattle_AfterImageParticleRenderer.gameObject.transform.parent.GetComponentsInChildren<ParticleSystem>();
        foreach (ParticleSystem particleSystem2 in componentsInChildren)
        {
            _ = particleSystem2.name == "AfterImage";
            if (particleSystem2.name == "AfterImage_Spared")
            {
                particleSystem = particleSystem2;
            }
        }
        GameObject enemyGameobject = target.EnemyInBattle_Gameobject;
        UnityEngine.Object.Instantiate(Effect_Spare, target.EnemyInBattle_Gameobject.transform.position, Quaternion.identity);
        GlowEnemy(target, "Spared");
        PlayBattleSoundEffect(sfx_enemy_spare, 1.5f);
        ActiveEnemies_PlayAnimation(target, "Spare");
        Vector3 TargetPosition = enemyGameobject.transform.position + new Vector3(15f, 0f, 0f);
        ParticleSystem.TextureSheetAnimationModule textureSheetAnimation = particleSystem.textureSheetAnimation;
        ParticleSystem.EmissionModule emission = particleSystem.emission;
        emission.rateOverTimeMultiplier = 120f;
        textureSheetAnimation.SetSprite(0, target.EnemyInBattle_MainSpriteRenderer.sprite);
        particleSystem.Play();
        UnityEngine.Object.Destroy(enemyGameobject, 3f);
        while (enemyGameobject != null && enemyGameobject.transform.position != TargetPosition)
        {
            yield return null;
            if (enemyGameobject != null)
            {
                enemyGameobject.transform.position = Vector3.Lerp(enemyGameobject.transform.position, TargetPosition, 0.5f * Time.deltaTime);
            }
        }
    }

    public void Battle_FinishRunningActions()
    {
        CurrentlyRunningAction = false;
    }

    private void ResetAllBattleEvents()
    {
        PlayerturnCount = 0;
        EnemyturnCount = 0;
        TotalturnCount = 0;
    }

    private void OnPlayerTurn()
    {
        PlayerturnCount++;
        TotalturnCount++;
        this.Event_OnPlayerTurn?.Invoke(PlayerturnCount);
    }

    private void OnPlayerUseRound()
    {
        this.Event_OnPlayerUseRound?.Invoke(CurrentPlayerMoves);
    }

    private void OnEnemyAttackTurn()
    {
        EnemyturnCount++;
        this.Event_OnEnemyAttackTurn?.Invoke(EnemyturnCount);
    }

    private void OnBattleStart(Battle Battle)
    {
        MonoBehaviour.print("Battle has begun");
        this.Event_OnBattleStart?.Invoke(CurrentBattle);
    }

    private void OnBattleEnd(Battle Battle, EndBattleTypes EndType)
    {
        this.Event_OnBattleEnd?.Invoke(Battle, EndType);
    }

    private void OnBattleStateChange(BattleState NewState, BattleState OldState)
    {
        this.Event_OnBattleStateChange?.Invoke(NewState, OldState);
    }

    private void OnMemberDamaged(BattlePartyMember targetMember, float damage)
    {
        this.Event_OnMemberDamaged?.Invoke(targetMember, damage);
    }

    private void OnEnemyDamaged(BattleActiveEnemy targetEnemy, float damage, BattlePartyMember inflictor)
    {
        this.Event_OnEnemyDamaged?.Invoke(targetEnemy, damage, inflictor);
    }

    private void OnEnemyKilled(BattleActiveEnemy targetEnemy, float damage, BattlePartyMember inflictor)
    {
        this.Event_OnEnemyKilled?.Invoke(targetEnemy, damage, inflictor);
    }

    private void OnEnemySpared(BattleActiveEnemy targetEnemy, bool wasSpareable, BattlePartyMember inflictor)
    {
        this.Event_OnEnemySpared?.Invoke(targetEnemy, wasSpareable, inflictor);
    }

    public void DefaultSpell_HealPrayer(BattlePartyMemberUse action)
    {
        if (action != null && action.targetMember != null)
        {
            PartyMembers_MemberPlayAnimation(action.targetPartyMember, "DefaultSpell");
            StartCoroutine(DefaultSpell_HealPrayer_Delay(action.targetMember, action.targetPartyMember));
        }
    }

    private IEnumerator DefaultSpell_HealPrayer_Delay(BattlePartyMember target, BattlePartyMember inflictor)
    {
        yield return null;
        HealPartyMember(target, GetPartyMember(inflictor.PartyMemberInBattle).PartyMemberInBattle.MAGIC * 5);
        BattleChatbox.AllowInput = false;
        BattleChatbox.RunText(Dialogue_DefaultSpell_HealPrayer, 0, null, ResetCurrentTextIndex: false);
        yield return new WaitForSeconds(0.25f);
        BattleChatbox.AllowInput = true;
    }

    public void DefaultSpell_IceShock(BattlePartyMemberUse action)
    {
        if (action != null && action.targetEnemy != null)
        {
            PartyMembers_MemberPlayAnimation(action.targetPartyMember, "DefaultSpell");
            StartCoroutine(DefaultSpell_IceShock_Delay(action.targetEnemy, action.targetPartyMember));
        }
    }

    private IEnumerator DefaultSpell_IceShock_Delay(BattleActiveEnemy target, BattlePartyMember inflictor)
    {
        yield return null;
        BattleChatbox.AllowInput = false;
        BattleChatbox.RunText(Dialogue_DefaultSpell_IceShock, 0, null, ResetCurrentTextIndex: false);
        PlayBattleSoundEffect(SFX_IceShock);
        Vector3[] iceshock_offests = new Vector3[3]
        {
            new Vector3(-3f, 0f, 0f),
            new Vector3(-1f, 0f, 0f),
            new Vector3(-2f, -1f, 0f)
        };
        List<Animator> iceshockAnimators = new List<Animator>();
        for (int i = 0; i < 3; i++)
        {
            GameObject gameObject = UnityEngine.Object.Instantiate(Effect_IceShock_Individual, Holder_Effects.transform);
            gameObject.transform.position = target.EnemyInBattle_Gameobject.transform.position + Vector3.one * 1.6f;
            gameObject.transform.position += iceshock_offests[i];
            iceshockAnimators.Add(gameObject.GetComponentInChildren<Animator>());
            yield return new WaitForSeconds(0.1f);
        }
        foreach (Animator item in iceshockAnimators)
        {
            if (item != null)
            {
                item.Play("Explode");
            }
        }
        float damage = 30 * (inflictor.PartyMemberInBattle.MAGIC - 10) + 90 + UnityEngine.Random.Range(1, 10);
        DamageEnemy(target, damage, inflictor);
        yield return new WaitForSeconds(0.3f);
        foreach (Animator item2 in iceshockAnimators)
        {
            UnityEngine.Object.Destroy(item2.transform.parent.gameObject);
        }
        iceshockAnimators.Clear();
        BattleChatbox.AllowInput = true;
    }

    public void DefaultSpell_Pacify(BattlePartyMemberUse action)
    {
        if (action != null && action.targetEnemy != null)
        {
            PartyMembers_MemberPlayAnimation(action.targetPartyMember, "DefaultSpell");
            StartCoroutine(DefaultSpell_Pacify_Delay(action.targetEnemy, action.targetPartyMember));
        }
    }

    private IEnumerator DefaultSpell_Pacify_Delay(BattleActiveEnemy target, BattlePartyMember inflictor)
    {
        yield return new WaitForSeconds(0.25f);
        GlowEnemy(target, "FailedPacify");
        BattleChatbox.AllowInput = false;
        BattleChatbox.RunText(Dialogue_DefaultSpell_FailedPacify, 0, null, ResetCurrentTextIndex: false);
        yield return new WaitForSeconds(0.25f);
        BattleChatbox.AllowInput = true;
    }

    public void DefaultSpell_SleepMist(BattlePartyMemberUse action)
    {
        if (action != null && action.targetEnemy != null)
        {
            PartyMembers_MemberPlayAnimation(action.targetPartyMember, "DefaultSpell");
            StartCoroutine(DefaultSpell_SleepMist_Delay(action.targetPartyMember));
        }
    }

    private IEnumerator DefaultSpell_SleepMist_Delay(BattlePartyMember inflictor)
    {
        yield return new WaitForSeconds(0.25f);
        foreach (BattleActiveEnemy battleActiveEnemy in BattleActiveEnemies)
        {
            UnityEngine.Object.Instantiate(Effect_SleepMist, battleActiveEnemy.EnemyInBattle_Gameobject.transform.position + new Vector3(0f, 0.4f, 0f), Quaternion.identity).transform.parent = Holder_Effects.transform;
        }
        PlayBattleSoundEffect(SFX_SleepMist);
        BattleChatbox.AllowInput = false;
        BattleChatbox.RunText(Dialogue_DefaultSpell_SleepMist, 0, null, ResetCurrentTextIndex: false);
        yield return new WaitForSeconds(0.25f);
        BattleChatbox.AllowInput = true;
    }

    public void SusieSpell_UltimatHeal(BattlePartyMemberUse action)
    {
        if (action != null && action.targetMember != null)
        {
            PartyMembers_MemberPlayAnimation(action.targetPartyMember, "DefaultSpell");
            StartCoroutine(SusieSpell_UltimateHeal_Delay(action.targetMember, action.targetPartyMember));
        }
    }

    private IEnumerator SusieSpell_UltimateHeal_Delay(BattlePartyMember target, BattlePartyMember inflictor)
    {
        yield return null;
        HealPartyMember(target, GetPartyMember(inflictor.PartyMemberInBattle).PartyMemberInBattle.MAGIC + 1, ForceNumbersOnly: true);
        BattleChatbox.AllowInput = false;
        BattleChatbox.RunText(Dialogue_DefaultSpell_UltimatHeal, 0, null, ResetCurrentTextIndex: false);
        yield return new WaitForSeconds(0.25f);
        BattleChatbox.AllowInput = true;
    }

    public void SusieSpell_RudeBuster(BattlePartyMemberUse action)
    {
        if (action != null && action.targetEnemy != null)
        {
            PartyMembers_MemberPlayAnimation(action.targetPartyMember, "DefaultSpell");
            StartCoroutine(DefaultSpell_RudeBuster_Delay(action.targetEnemy, action.targetPartyMember));
        }
    }

    private IEnumerator DefaultSpell_RudeBuster_Delay(BattleActiveEnemy target, BattlePartyMember inflictor)
    {
        BattleChatbox.AllowInput = false;
        yield return new WaitForSeconds(0.5f);
        BattleChatbox.RunText(Dialogue_DefaultSpell_RudeBuster, 0, null, ResetCurrentTextIndex: false);
        yield return new WaitForSeconds(0.1f);
        PartyMembers_MemberPlayAnimation(inflictor, "Spell_RudeBuster");
        yield return new WaitForSeconds(0.517f);
        PlayBattleSoundEffect(SFX_RudeBuster_Fire);
        GameObject RudeBusterProjectile = UnityEngine.Object.Instantiate(Effect_RudeBuster_Projectile, inflictor.PartyMemberInBattle_Gameobjects.transform.position + Vector3.up * 0.4f, Quaternion.identity);
        RudeBusterProjectile.transform.parent = Holder_Effects.transform;
        bool ProjectileCurrentlyActive = true;
        bool DealAdditionalDamage = false;
        CutsceneUtils.MoveTransformOnArc(RudeBusterProjectile.transform, target.EnemyInBattle_Gameobject.transform.position + Vector3.up * 0.4f, -1f, 0.433f, rotateAlongArc: true);
        while (ProjectileCurrentlyActive)
        {
            if (Input.GetKeyDown(PlayerInput.Instance.Key_Confirm))
            {
                DealAdditionalDamage = true;
            }
            if (RudeBusterProjectile.transform.position == target.EnemyInBattle_Gameobject.transform.position + Vector3.up * 0.4f)
            {
                ProjectileCurrentlyActive = false;
            }
            yield return null;
        }
        RudeBusterProjectile.GetComponentInChildren<ParticleSystem>().transform.parent = null;
        UnityEngine.Object.Destroy(RudeBusterProjectile);
        float num = 11 * inflictor.PartyMemberInBattle.ATK + 5 * inflictor.PartyMemberInBattle.MAGIC - 3 * target.EnemyInBattle.DF;
        if (DealAdditionalDamage)
        {
            num += 30f;
        }
        UnityEngine.Object.Instantiate(Effect_RudeBuster_Explosion, target.EnemyInBattle_Gameobject.transform.position + Vector3.up * 0.4f, Quaternion.identity).transform.parent = Holder_Effects.transform;
        PlayBattleSoundEffect(SFX_RudeBuster_Hit);
        DamageEnemy(target, num, inflictor);
        BattleChatbox.AllowInput = true;
    }
}