using DG.Tweening;
using DG.Tweening.Core;
using DG.Tweening.Plugins.Options;
using IVDataFormat;
using Spine.Unity;
using System.Collections;
using System.Collections.Generic;
using System.Numerics;
using UnityEngine;
using UnityEngine.Events;
using Quaternion = UnityEngine.Quaternion;
using Random = UnityEngine.Random;
using Vector3 = UnityEngine.Vector3;

public class IVSkill : MonoBehaviour
{
    [System.Serializable]
    public struct stSkillSequence
    {
        public float time;
        public UnityEvent method;
    }

    #region Skill Settings
    [SerializeField] // 스킬 종류.
    protected eSkillType skillType;

    [SerializeField, Space(10)] // 상태이상.
    protected eSkillDebuff debuff;

    [SerializeField, Space(10)] // 타겟/캐릭터 따라다님.
    protected bool bTrace = false;
    [SerializeField] // 적 끌어당김.
    protected bool bPull = false;
    [SerializeField] // 사거리.
    protected int iRange = 1000000;
    [SerializeField] // 총 연출 시간.
    protected float fPlayTime = 1f;
    [SerializeField]
    protected float ShakeStrength = 0f;
    [SerializeField]
    protected int iVibrato = 10;
    [SerializeField]
    protected int useFrom;

    // 발사체 시작 위치.
    [SerializeField, Space(10)]
    protected Transform trfShotStart;
    // 발사체.
    [SerializeField, Space(10)]
    protected Transform[] trfShots;
    protected TweenerCore<Vector3, Vector3, VectorOptions>[] twcShots;
    [SerializeField, Space(10)]
    protected SpriteRenderer[] sprShotItems;
    // 스킬 범위.
    [SerializeField, Space(10)]
    protected Collider[] colliders;
    // 최대 타격 횟수. 발사체 1개를 연속 발사하는 경우에만 사용.
    [SerializeField]
    protected int iMaxShot;
    protected int iShot;

    [SerializeField, Space(10)]
    protected IVBullet[] bullets;
    [SerializeField]
    protected IVSummon summon;

    // 스킬 연출 및 기능.
    [SerializeField, Space(10)]
    protected stSkillSequence[] skillSequences;

    protected SkeletonAnimation[] skAnims;
    protected ParticleSystem[] ptcEffects;
    protected AudioSource[] asEffects;

    #endregion Skill Settings
    public int idNumber = -1;

    #region Variables
    protected BattleMgr battleMgr;
    protected Transform trfObject;

    // 재생중.
    Coroutine playSkillCoroutine;
    protected bool IsPlaying => playSkillCoroutine != null;

    // 아군 스킬인지.
    private bool _bFriendlySkill;
    protected bool bFriendlySkill
    {
        get => _bFriendlySkill;
        set
        {
            if(_bFriendlySkill != value)
            {
                _bFriendlySkill = value;
                TargetTags = Bitset32.GetMask(bFriendlySkill ? EntityTag.Enemy : EntityTag.Player);
            }
        }
    }
    public Bitset32.Mask TargetTags { get; private set; }

    protected IBattleEntity caster;
    protected Transform casterTransform => caster != null ? (caster as Entity).transform : null;
    protected UnityEngine.Vector2 casterPos => caster != null ? (caster as Entity).transform.position : UnityEngine.Vector2.zero;
    // 타겟.
    protected IBattleEntity target;
    protected Transform targetTransform => target != null ? (target as Entity).transform : null;
    protected UnityEngine.Vector2 targetPos => target != null ? (target as Entity).transform.position : UnityEngine.Vector2.zero;
    protected float sqrtDistToTarget => target != null ? ((UnityEngine.Vector2)transform.position - targetPos).sqrMagnitude : 9999f;
    // 여러명 타겟
    protected List<IBattleEntity> targets;
    // 추적 타겟.
    protected Transform trfTrace = null;

    // 크리티컬 배율.
    protected float fCrtDam = 0f;
    // 크리티컬 확률.
    protected int iCrtRate = 0;
    // 데미지1.
    protected BigInteger biDmg = 0;
    // 값.
    protected float fRate = 0f;
    // 소환물 공격간격
    protected float fSummonInterval = 0.3f;

    // 상태이상 수치, 시간.
    protected BigInteger biDebuffValue;
    protected float fDebuffTime;
    protected bool bfront;

    // 같은 대상인지 구분
    protected int iDamCnt = 0;

    // 직선으로 날려보낼 거리
    protected float fDistance;
    // 날라가는 시간, 딜레이 시간
    protected float fTime, fDelayTime;
    protected float fx = 0, fy = 0;
    protected int iSplit;
    private Vector3[] SavePos = new Vector3[13];
    #endregion Variables

    #region Init
    // 초기화.
    public void Init(BattleMgr mgr)
    {
        battleMgr = mgr;
        skAnims = transform.GetComponentsInChildren<SkeletonAnimation>(true);
        asEffects = transform.GetComponentsInChildren<AudioSource>(true);
        ptcEffects = transform.GetComponentsInChildren<ParticleSystem>(true);

        twcShots = new TweenerCore<Vector3, Vector3, VectorOptions>[trfShots.Length];
        targets = new List<IBattleEntity>();

        _bFriendlySkill = true;
        TargetTags = Bitset32.GetMask(EntityTag.Enemy);
    }

    // 사거리 가져오기.
    public int GetRange()
    {
        return iRange / dConst.RangeDivide;
    }
    #endregion Init

    #region SetOption
    // 상태이상.
    public void SetDebuff(BigInteger bivalue, float ftime)
    {
        biDebuffValue = bivalue;
        fDebuffTime = ftime;
    }

    public void MoveToShotPos(int ishotNum)
    {
        if (transform.Find("trfObject") != null)
            trfObject = transform.Find("trfObject");

        trfObject.position = trfShots[ishotNum].position;
    }

    public void SetTransform()
    {
        for (int i = 0; i < trfShots.Length; i++)
        {
            trfShots[i].position = trfShotStart.position + Vector3.up * 4f;
            trfShots[i].gameObject.SetActive(true);
        }
    }

    public void SetSplit(int isplit)
    {
        iSplit = isplit;
    }

    public void SetDistance(float fdt)
    {
        fDistance = fdt;
    }

    public void SetBulletTime(float ftime)
    {
        fTime = ftime;
    }

    public void SetDelayTime(float ftime)
    {
        fDelayTime = ftime;
    }

    public void SetX(float x)
    {
        fx = x;
    }

    public void SetY(float y)
    {
        fy = y;
    }

    public void setDistanceRandom()
    {
        fDistance = Random.Range(5, 12);
    }

    public void setFront()
    {
        bfront = battleMgr.GetIsFront(bFriendlySkill);
        ChangeFront(bfront);
    }

    public void setSummonAttackInterval(float finterval)
    {
        fSummonInterval = finterval;
    }

    public void StartFade(int inum)
    {
        if(useFrom == 0)
        {
            if (inum > 0)
                battleMgr.SkillFade(true);
            else
                battleMgr.SkillFade(false);
        }
    }

    #endregion

    #region Base Method
    protected void LateUpdate()
    {
        if (bTrace && trfTrace != null)
            transform.position = trfTrace.position;
    }

    private void ChangeFront(bool bFrontRight)
    {
        if (bFrontRight)
        {
            transform.localScale = Global.V3_1;
        }
        else
        {
            transform.localScale = Global.V3_1XRev;
        }
    }

    protected IEnumerator PlaySkill()
    {
        float elapsed = 0f;

        int currentSequenceIndex = 0;
        float offset = 0f;

        while(elapsed < fPlayTime)
        {
            if(currentSequenceIndex < skillSequences.Length)
            {
                var sequence = skillSequences[currentSequenceIndex];

                if (offset + sequence.time <= elapsed)
                {
                    sequence.method?.Invoke();
                    offset += sequence.time;
                    ++currentSequenceIndex;
                }
            }

            elapsed += Time.deltaTime;
            yield return null;
        }

        playSkillCoroutine = null;
        gameObject.SetActive(false);
    }

    public void StopSkill()
    {
        if (!IsPlaying) return;

        StopCoroutine(playSkillCoroutine);

        for (int i = 0; i < skAnims.Length; ++i)
        {
            skAnims[i].enabled = false;
        }

        for (int i = 0; i < trfShots.Length; ++i)
        {
            if (twcShots[i] != null && twcShots[i].IsPlaying())
                twcShots[i].Pause();

            trfShots[i].gameObject?.SetActive(false);
        }

        for (int i = 0; i < ptcEffects.Length; ++i)
        {
            ptcEffects[i]?.Stop();
        }

        for (int i = 0; i < asEffects.Length; ++i)
        {
            asEffects[i]?.Stop();
        }

        target = null;
        playSkillCoroutine = null;
        gameObject.SetActive(false);
    }
    #endregion Base Method

    #region Control Method
    // 애니메이션 재생.
    public void PlayAnimation(int index)
    {
        if (index < 0 || index >= skAnims.Length)
            return;
        skAnims[index].enabled = true;
        skAnims[index].AnimationState.SetAnimation(0, "animation", false);
    }

    public void SetAnimation(string name)
    {
        if(skAnims[0] != null)
        {
            skAnims[0].enabled = true;
            if(name == "idle")
                skAnims[0].AnimationState.SetAnimation(0, "idle", true);
            else if (name == "move")
                skAnims[0].AnimationState.SetAnimation(0, "move", true);
            else
                skAnims[0].AnimationState.SetAnimation(0, name, false);
        }
    }

    // 사운드 재생.
    public void PlaySound(int index)
    {
        if (index < 0 || index >= asEffects.Length)
            return;
        if (SoundMgr.Instance.EfcOn)
        {
            asEffects[index].Play();
        }
    }

    // 사운드 랜덤 재생.
    public void PlaySoundRandom(int istartindex)
    {
        if (SoundMgr.Instance.EfcOn)
        {
            int index = Random.Range(istartindex, asEffects.Length);
            asEffects[index].Play();
        }
    }

    // 카메라 흔들기.
    public void ShakeCamera1(float fstrength)
    {
        IVCameraController.SShakeCamera(0.1f, fstrength);
    }

    // 카메라 흔들기.
    public void ShakeCamera3(float fstrength)
    {
        IVCameraController.SShakeCamera(0.3f, fstrength);
    }

    // 카메라 흔들기.
    public void ShakeCamera5(float fstrength)
    {
        IVCameraController.SShakeCamera(0.5f, fstrength);
    }

    // 카메라 흔들기.
    public void ShakeCamera10(float fstrength)
    {
        IVCameraController.SShakeCamera(1f, fstrength);
    }
    #endregion Control Method

    #region Shot Method
    public void SetBullet()
    {
        for (int i = 0; i < bullets.Length; ++i)
        {
            bullets[i].SetStatus(battleMgr, biDmg, fCrtDam, iCrtRate, idNumber, ShakeStrength, iVibrato, useFrom);
        }
    }

    // 직선으로 발사 메서드를 사용하기 전에, SetDistance를 가장 먼저 시퀀스에 포함시켜 날려보낼 거리를 할당필요
    // 직선으로 발사
    public void ShotToFront(float ftime)
    {
        if (target != null || twcShots.Length < 1)
            return;

        Vector3 v3endpos = targetPos;
        
        Vector3 v3driection = (v3endpos - trfShotStart.position).normalized;
        v3endpos = trfShotStart.position +  v3driection * fDistance;
        trfShots[0].position = trfShotStart.position;
        trfShots[0].right = v3driection;
        trfShots[0].gameObject.SetActive(true);
        twcShots[0] = trfShots[0].DOMove(v3endpos, ftime).SetEase(Ease.Linear).SetAutoKill(true);
    }

    private IEnumerator ShotToAngle(float ftime)
    {
        float sum = 0f;
        float addAngle = 360f / trfShots.Length;
        Vector3 direction;
        Vector3 dir = Vector3.left;
        for (int i = 0; i < trfShots.Length; i++)
        {
            trfShots[i].position = trfShotStart.position;
            trfShots[i].gameObject.SetActive(true);
            direction = Quaternion.Euler(0, 0, sum) * dir;
            twcShots[i] = trfShots[i].DOMove(trfShotStart.position + direction * fDistance, ftime).SetEase(Ease.Linear).SetAutoKill(true);
            trfShots[i].rotation = Quaternion.Euler(0, 0, sum);
            yield return YieldInstructionCache.WaitForSeconds(0.02f);
            sum += -addAngle;
        }
    }

    public void ShotToAngleDelay(float ftime)
    {
        for(int i = 0; i < trfShots.Length; i++)
        {
            trfShots[i].gameObject.SetActive(false);
        }
        StartCoroutine(ShotToAngle(ftime));
    }

    public void ThrowToTarget(float ftime)
    {
        Vector3 endpos;

        trfShots[0].position = trfShotStart.position;

        if (useFrom == 0)
        {
            if (TargetFinder.TryFindNearest(casterPos, TargetTags, out var target))
                endpos = (target as Entity).transform.position;
            else
                endpos = Vector3.zero;
        }
        else
        {
            endpos = battleMgr.GetPlayer().transform.position;
        }

        float dist = Vector3.Distance(trfShotStart.position, endpos);
        trfShots[0].rotation = Quaternion.identity;

        trfShots[0].DOJump(endpos, dist * 0.3f , 1, ftime).SetEase(Ease.OutCubic); // ftime
        trfShots[0].DORotate(new Vector3(0, 0, Random.Range(120, 360)), 1f);
    }

    public void ThrowToFront(float ftime)
    {
        trfShots[0].position = trfShotStart.position;
        Vector3 v3endpos;

        if (battleMgr.GetIsFront(bFriendlySkill))
            v3endpos = trfShotStart.position + (Vector3.right * fDistance);
        else
            v3endpos = trfShotStart.position + (Vector3.left * fDistance);

        trfShots[0].DOJump(v3endpos, 4f, 1, ftime);
    }

    public void ThrowToRandom(float ftime)
    {
        StartCoroutine(ThrowToRandomDelay(ftime));
    }

    public IEnumerator ThrowToRandomDelay(float ftime)
    {
        for (int i = 0; i < trfShots.Length; i++)
        {
            trfShots[i].position = trfShotStart.position;
            Vector3 v3endpos;

            v3endpos = trfShots[i].position + Random.insideUnitSphere * Random.Range(8, 15);
            trfShots[i].rotation = Quaternion.identity;

            trfShots[i].DOJump(v3endpos, 4f, 1, ftime);
            trfShots[i].DORotate(new Vector3(0, 0, Random.Range(120, 360)), 1f);
            yield return YieldInstructionCache.WaitForSeconds(0.1f);
        }
    }
    
    public void ThrowToRandomChain(float ftime)
    {
        for(int i = 1; i < sprShotItems.Length; i++)
        {
            sprShotItems[i].enabled = false;
        }

        trfShots[0].position = trfShotStart.position;

        if (TargetFinder.TryFindNearest(casterPos, TargetTags, out var target))
            SavePos[0] = (target as Entity).transform.position;
        else
            SavePos[0] = Vector3.zero;

        trfShots[0].rotation = Quaternion.identity;

        trfShots[0].DOJump(SavePos[0], 2f, 1, 0.5f); // ftime
        trfShots[0].DORotate(new Vector3(0, 0, Random.Range(120, 360)), 1f);

        StartCoroutine(ThrowToRandomChainRepeat(1, ftime));
    }

    public IEnumerator ThrowToRandomChainRepeat(int icnt, float ftime)
    {
        yield return new WaitForSeconds(0.5f);

        ftime *= 0.5f;

        int saveCnt = 0;
        int splitNum = 2;
        int throwCnt = iSplit;
        
        for (int i = icnt; i < trfShots.Length; i++)
        {
            sprShotItems[i].enabled = true;
            trfShots[i].position = SavePos[(i-1)/ iSplit];
            SavePos[i] = trfShots[i].position + Random.insideUnitSphere * Random.Range((12 / splitNum) + 2, (14 / splitNum) + 2);
            trfShots[i].rotation = Quaternion.identity;
            trfShots[i].DOMove(SavePos[i],ftime);
            trfShots[i].DORotate(new Vector3(0, 0, Random.Range(120, 360)), 1f);

            saveCnt++;

            if (i >= throwCnt)
            {
                yield return new WaitForSeconds(ftime);
                for(int j = 0; j < throwCnt; j++)
                {
                    sprShotItems[j].enabled = false;
                }
                throwCnt = iSplit + throwCnt* iSplit;
                //ftime *= 0.5f;
                splitNum++;
            }        
        }      
    }

    // 좌우 직선으로 발사 (대각선 x)
    public void ShotToFrontHorizon(float ftime)
    {
        Vector3 v3endpos;

        if (battleMgr.GetIsFront(bFriendlySkill))
            v3endpos = trfShotStart.position + (Vector3.right * fDistance);
        else
            v3endpos = trfShotStart.position + (Vector3.left * fDistance);

        trfShots[0].position = trfShotStart.position;
        trfShots[0].gameObject.SetActive(true);
        twcShots[0] = trfShots[0].DOMove(v3endpos, ftime).SetEase(Ease.Linear).SetAutoKill(true);
    }

    // 발사 메서드를 사용하기 전에, SetDistance를 가장 먼저 시퀀스에 포함시켜 날려보낼 거리를 할당필요
    // 화면을 가로지르는 투사체 발사

    private IEnumerator CrossScreenToTargetDelay(int icol, float fdelay)
    {
        Vector3 v3startpos, v3endpos, v3targetpos;
        v3targetpos = trfShotStart.position + new Vector3(fx, fy, 0);

        if (bfront)
        {
            v3startpos = v3targetpos + Vector3.left * fDistance;
            v3endpos = v3targetpos + Vector3.right * fDistance;
        }
        else
        {
            v3startpos = v3targetpos + Vector3.right * fDistance;
            v3endpos = v3targetpos + Vector3.left * fDistance;
        }

        trfShots[icol].position = v3startpos;
        trfShots[icol].gameObject.SetActive(true);
        yield return new WaitForSeconds(fdelay);
        twcShots[icol] = trfShots[icol].DOMove(v3endpos, fTime).SetEase(Ease.Linear).SetAutoKill(true);
    }

    public void CrossScreenToTarget(int icol)
    {
        if (target != null || twcShots.Length < 1)
            return;

        StartCoroutine(CrossScreenToTargetDelay(icol, fDelayTime));
    }

    // 단일 타겟에게 발사.
    public void ShotToTarget(float ftime)
    {
        if (twcShots.Length < 1) return;

        if (TargetFinder.TryFindNearest(casterPos, TargetTags, out target))
        {
            trfShots[0].position = trfShotStart.position;
            trfShots[0].gameObject.SetActive(true);
            twcShots[0] = trfShots[0].DOMove(targetPos, ftime).SetEase(Ease.OutQuint).SetAutoKill(true);
        }
    }

    // 복수 타겟에게 발사.
    public void ShotToTargets(float ftime)
    {
        targets = TargetFinder.GetNears(casterPos, TargetTags, twcShots.Length);

        for (int i = 0; i < targets.Count; i++)
        {
            var target = targets[i] as Entity;

            if (target is null)
            {
                trfShots[i].gameObject.SetActive(false);
                continue;
            }
            
            trfShots[i].position = trfShotStart.position;
            trfShots[i].gameObject.SetActive(true);
            twcShots[i] = trfShots[i].DOMove(target.transform.position, ftime).SetEase(Ease.Linear).SetAutoKill(true);
        }
    }

    // 단일 타겟에게 발사 후 이어서 발사 및 데미지.
    HashSet<IBattleEntity> trainShotExceptSet = new();
    public void ShotToTargetTrain(float ftime)
    {
        if (target is null || twcShots.Length < 1) return;

        trainShotExceptSet.Clear();

        iShot++;
        trfShotStart.position = casterPos;
        trainShotExceptSet.Add(target);

        trfShots[0].position = trfShotStart.position;
        trfShots[0].gameObject.SetActive(true);
        twcShots[0] = trfShots[0].DOMove(targetPos, ftime).SetEase(Ease.Linear).SetAutoKill(false).OnComplete(ShotTrainDamage);
    }

    // 현재 타겟에게 데미지 후 다른 타겟에게 이어서 발사.
    protected void ShotTrainDamage()
    {
        SendDamageSingle();

        iShot++;
        // 최대 횟수면 중지.
        if (iShot > iMaxShot)
        {
            twcShots[0].Kill(false);
            return;
        }

        // 다른 타겟 없으면 중지.
        if (!TargetFinder.TryFindNearest(trfShots[0].position, TargetTags, out var newTarget, trainShotExceptSet))
        {
            twcShots[0].Kill(false);
            StopSkill();
            return;
        }

        target = newTarget;
        trainShotExceptSet.Add(newTarget);

        float distance = UnityEngine.Vector2.SqrMagnitude(targetPos - (UnityEngine.Vector2)trfShots[0].position);
        if (distance > 12 * 12)
        {
            twcShots[0].Kill(false);
            StopSkill();
            return;
        }

        // 위치 변경 후 다시 재생.
        twcShots[0].ChangeValues(trfShots[0].position, targetPos);
        twcShots[0].Restart();
    }

    // 콜라이더 하나만 사용할 때 사용가능 콜라이더 범위안에 적에게 발사
    private void ShotToBounds()
    {
        if (!TargetFinder.TryFindNearest(casterPos, colliders[0].bounds, TargetTags, out target))
        {
            skAnims[0].timeScale = 1.0f;
            if (skAnims[0].AnimationName != "idle")
                SetAnimation("idle");

            return;
        }

        if (transform.position.x > targetPos.x)
            transform.localScale = Global.V3_1XRev;
        else
            transform.localScale = Global.V3_1;

        skAnims[0].timeScale = 3.0f;
        SetAnimation("attack");

        SendDamageSingle();
    }

    public IEnumerator ShotToBoundsContinue(float ftime)
    {
        int icount = 0;
        float itick = 0f;
        while(icount < 100 && itick < ftime)
        {
            ShotToBounds();
            icount++;
            yield return new WaitForSeconds(0.2f);
            itick += 0.2f;

            if (itick >= ftime || icount >= 100)
                StopCoroutine(nameof(ShotToBoundsContinue));
        }
    }

    public void corShotToBoundsContinue(float ftime)
    {
        StartCoroutine(ShotToBoundsContinue(ftime));
    }
    #endregion Shot Method

    #region Damage Method
    public void SetSummon()
    {
        summon.SetStatus(biDmg, fCrtDam,iCrtRate, fPlayTime - 2f, battleMgr.GetPlayer().transform.position, idNumber, fSummonInterval);
    }

    public void SendDamage(IBattleEntity battleEntity)
    {
        var creature = battleEntity as CreatureBase;
        if (creature != null)
        {
            switch (debuff)
            {
                case eSkillDebuff.Stun: creature.SetStun(fDebuffTime); break;
                case eSkillDebuff.DecMove: creature.SetDecMove(fDebuffTime, (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi)); break;
                case eSkillDebuff.Push: creature.PushFrame((float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi)); break;
                case eSkillDebuff.DamageSec: creature.SetDamageSec(fDebuffTime, biDebuffValue, fCrtDam, iCrtRate, idNumber); break;
            }
        }

        battleEntity.GetDamage(biDmg, fCrtDam, iCrtRate, idNumber);
    }

    // 전체 데미지.
    public void SendDamageAll()
    {
        battleMgr.LoopAllBattleEntities((battleEntity) =>
        {
            if((battleEntity as Entity).HasTagsAny(TargetTags))
            {
                SendDamage(battleEntity);
            }
            return true;
        });
    }

    // 단일 데미지.
    public void SendDamageSingle()
    {
        SendDamage(target);

        if (bFriendlySkill)
            IVCameraController.SShakeCamera(0.1f, ShakeStrength, iVibrato);
    }

    public void SendDamageMultiful()
    {
        for(int i = 0; i < targets.Count; i++)
        {
            SendDamage(targets[i]);
        }

        targets.Clear();
    }

    // 범위 데미지.
    public void SendDamageBounds(int boundindex)
    {
        if (boundindex >= colliders.Length) return;

        var bound = colliders[boundindex].bounds;
        battleMgr.LoopAllBattleEntities((battleEntity) =>
        {
            Entity entity = battleEntity as Entity;
            if (entity.HasTagsAny(TargetTags) && bound.Contains(entity.transform.position))
            {
                SendDamage(battleEntity);
            }
            return true;
        });

        if (bFriendlySkill)
            IVCameraController.SShakeCamera(0.1f, ShakeStrength, iVibrato);
    }

    public void SendDamageBoundsDt(int boundindex)
    {
        if (boundindex >= colliders.Length) return;

        var bound = colliders[boundindex].bounds;
        battleMgr.LoopAllBattleEntities((battleEntity) =>
        {
            Entity entity = battleEntity as Entity;
            if (entity.HasTagsAny(TargetTags) && bound.Contains(entity.transform.position))
            {
                float sqrDist = (entity.transform.position - bound.center).sqrMagnitude;

                if (sqrDist <= fDistance * fDistance)
                    SendDamage(battleEntity);
            }
            return true;
        });

        if (bFriendlySkill)
            IVCameraController.SShakeCamera(0.1f, ShakeStrength, iVibrato);
    }

    // 하나의 콜라이더만 사용할 때 사용 (몬스터를 관통하는 투사체류)
    public void CorSendDamageBoundsContinue(float ftime)
    {
        StartCoroutine(SendDamageBoundsContinue(ftime));
    }

    private IEnumerator SendDamageBoundsContinue(float duration)
    {
        float tick = 0f;
        while(duration > tick)
        {
            SendDamageBounds(0);
            yield return YieldInstructionCache.WaitForSeconds(0.2f);
        }
    }

    public void AddDamCnt()
    {
        iDamCnt++;
    }
    #endregion Damage Method

    #region Move Method
    public void RushToEnemy(float fdt)
    {
        if(useFrom == 0)
            battleMgr.RushToEnemy(fdt);
        else
            battleMgr.RushToEnemy(fdt, useFrom);
    }

    // 사용전 setDistance 설정 필요
    public void RushToDir(int dir)
    {
        battleMgr.RushToDir(dir, fDistance, bfront);
    }
    #endregion

    #region Debuff Method
    public void DebuffSingle(eSkillDebuff eDebuff)
    {
        switch (eDebuff)
        {
            case eSkillDebuff.Stun: // 기절
                DebuffStunSingle();
                break;
            case eSkillDebuff.DecMove: // 둔화
                DebuffDecMovSingle();
                break;
            case eSkillDebuff.Push: // 넉백
                DebuffPushSingle();
                break;
            case eSkillDebuff.DamageSec:// 출혈
                DebuffDamageSecSingle();
                break;
        }
    }

    public void DebuffBounds(eSkillDebuff eDebuff, int boundsIndex)
    {
        switch (eDebuff)
        {
            case eSkillDebuff.Stun: // 기절
                DebuffStunBounds(boundsIndex);
                break;
            case eSkillDebuff.DecMove: // 둔화
                DebuffDecMovBounds(boundsIndex);
                break;
            case eSkillDebuff.Push: // 넉백
                DebuffPushBounds(boundsIndex);
                break;
            case eSkillDebuff.DamageSec:// 출혈
                DebuffDamageSecBounds(boundsIndex);
                break;
            case eSkillDebuff.Pull: // 끌어당기기
                DebuffPushPullBounds(boundsIndex);
                break;
        }
    }

    public void DebuffAll(eSkillDebuff eDebuff)
    {
        switch (eDebuff)
        {
            case eSkillDebuff.Stun: DebuffStunAll(); break; // 기절
            case eSkillDebuff.DecMove: DebuffDecMovAll(); break; // 둔화
            case eSkillDebuff.Push: DebuffPushAll(); break; // 넉백
            case eSkillDebuff.DamageSec: DebuffDamageSecAll(); break; // 출혈
        }
    }

    // 전체 둔화.
    public void DebuffDecMovAll()
    {
        float fdebuffValue = (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi);
        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.DecMovToEnemyAll(fDebuffTime, fdebuffValue);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.DecMovToFriendlyAll(fDebuffTime, fdebuffValue);
        }
    }

    // 단일 둔화.
    public void DebuffDecMovSingle()
    {
        float fdebuffValue = (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi);
        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.DecMovToEnemy(target, fDebuffTime, fdebuffValue);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.DecMovToFriendly(fDebuffTime, fdebuffValue);
        }
    }

    // 범위 둔화.
    public void DebuffDecMovBounds(int boundindex)
    {
        if (boundindex >= colliders.Length)
            return;

        float fdebuffValue = (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi);
        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.DecMovToEnemy(colliders[boundindex].bounds, fDebuffTime, fdebuffValue);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.DecMovToFriendly(colliders[boundindex].bounds, fDebuffTime, fdebuffValue);
        }
    }

    // 전체 출혈.
    public void DebuffDamageSecAll()
    {
        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.DamageSecToEnemyAll(fDebuffTime, biDebuffValue, fCrtDam, iCrtRate, idNumber);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.DamageSecToFriendlyAll(fDebuffTime, biDebuffValue, fCrtDam, iCrtRate);
        }
    }

    // 단일 출혈.
    public void DebuffDamageSecSingle()
    {
        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.DamageSecToEnemy(target, fDebuffTime, biDebuffValue, fCrtDam, iCrtRate, idNumber);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.DamageSecToFriendly(fDebuffTime, biDebuffValue, fCrtDam, iCrtRate);
        }
    }

    // 범위 출혈.
    public void DebuffDamageSecBounds(int boundindex)
    {
        if (boundindex >= colliders.Length)
            return;

        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.DamageSecToEnemy(colliders[boundindex].bounds, fDebuffTime, biDebuffValue, fCrtDam, iCrtRate, iDamCnt, idNumber);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.DamageSecToFriendly(colliders[boundindex].bounds, fDebuffTime, biDebuffValue, fCrtDam, iCrtRate, iDamCnt);
        }
    }

    // 전체 기절.
    public void DebuffStunAll()
    {
        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.StunToEnemyAll(fDebuffTime);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.StunToFriendlyAll(fDebuffTime);
        }
    }

    // 단일 기절.
    public void DebuffStunSingle()
    {
        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.StunToEnemy(target, fDebuffTime);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.StunToFriendly(fDebuffTime);
        }
    }

    // 범위 기절.
    public void DebuffStunBounds(int boundindex)
    {
        if (boundindex >= colliders.Length)
            return;

        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.StunToEnemy(colliders[boundindex].bounds, fDebuffTime);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.StunToFriendly(colliders[boundindex].bounds, fDebuffTime);
        }
    }

    // 전체 넉백.
    public void DebuffPushAll()
    {
        float fdebuffValue = (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi);
        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.PushToEnemyAll(fdebuffValue);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.PushToFriendlyAll(fdebuffValue);
        }
    }

    // 단일 넉백.
    public void DebuffPushSingle()
    {
        float fdebuffValue = (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi);
        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.PushToEnemy(target, fdebuffValue, iDamCnt);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.PushToFriendly(fdebuffValue, iDamCnt);
        }
    }

    // 범위 넉백.
    public void DebuffPushBounds(int boundindex)
    {
        if (boundindex >= colliders.Length)
            return;

        float fdebuffValue = (float)BigInteger.Divide(biDebuffValue, dConst.RateMaxBi);
        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.PushToEnemy(colliders[boundindex].bounds, fdebuffValue, iDamCnt);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.PushToFriendly(colliders[boundindex].bounds, fdebuffValue, iDamCnt);
        }
    }
    
    // 범위 끌어당기기
    public void DebuffPushPullBounds(int boundindex)
    {
        if (boundindex >= colliders.Length)
            return;

        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.PullToEnemy(colliders[boundindex].bounds, biDebuffValue, trfShots[boundindex]);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.PullToFriendly(colliders[boundindex].bounds, biDebuffValue, trfShots[boundindex]);
        }
    }
    #endregion Debuff Method

    #region Heal Method
    // 전체 힐.
    public void SendHealAll()
    {
        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.HealToFriendly(fRate);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.HealToEnemyAll(fRate);
        }
    }

    // 단일 힐.
    public void SendHealSingle()
    {
        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.HealToFriendly(fRate);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.HealToEnemy(target, fRate);
        }
    }

    // 범위 힐.
    public void SendHealRange(int boundindex)
    {
        if (boundindex >= colliders.Length)
            return;

        // 아군이 사용한 스킬.
        if (bFriendlySkill)
        {
            battleMgr.HealToFriendly(colliders[boundindex].bounds, fRate);
        }
        // 적이 사용한 스킬.
        else
        {
            battleMgr.HealToEnemy(colliders[boundindex].bounds, fRate);
        }
    }
    #endregion Heal Method

    #region Start Skill
    public void StartSkill(bool bfriendskill, float fcrtdam, int icrtrate, BigInteger biDmg, IBattleEntity caster, IBattleEntity target, bool bright)
    {
        this.caster = caster;
        this.target = target;

        switch (skillType)
        {
            // 시전자 위치에서 일정 범위에 데미지.
            case eSkillType.RangeValueAtUse:
                StartSkillRange(bfriendskill, casterPos, fcrtdam, icrtrate, biDmg, bright);
                break;
            // 타겟 위치에서 일정 범위에 데미지.
            case eSkillType.RangeValueAtTarget:
                StartSkillRange(bfriendskill, targetPos, fcrtdam, icrtrate, biDmg, bright);
                break;

            // 시전자를 따라다니며 일정 범위에 데미지.
            case eSkillType.RangeValueTraceUse:
                StartSkillRangeTrace(bfriendskill, casterTransform, fcrtdam, icrtrate, biDmg, bright);
                break;

            // 타겟을 따라다니며 일정 범위에 데미지.
            case eSkillType.RangeValueTraceTarget:
                StartSkillRangeTrace(bfriendskill, targetTransform, fcrtdam, icrtrate, biDmg, bright);
                break;

            // 시전자 위치에서 타겟에 데미지.
            case eSkillType.OneValueAtUse:
                StartSkillTarget(bfriendskill, casterPos, fcrtdam, icrtrate, biDmg, bright, target);
                break;

            // 타겟 위치에서 타겟에 데미지.
            case eSkillType.OneValueAtTarget:
                StartSkillTarget(bfriendskill, targetPos, fcrtdam, icrtrate, biDmg, bright, target);
                break;

            // 시전자를 따라다니며 타겟에 데미지.
            case eSkillType.OneValueTraceUse:
                StartSkillTargetTrace(bfriendskill, casterTransform, fcrtdam, icrtrate, biDmg, bright, target);
                break;

            // 타겟을 따라다니며 타겟에 데미지.
            case eSkillType.OneValueTraceTarget:
                StartSkillTargetTrace(bfriendskill, targetTransform, fcrtdam, icrtrate, biDmg, bright, target);
                break;
        }
    }

    // 타겟 데미지.
    protected void StartSkillTarget(bool bfriendskill, Vector3 v3pos, float fcrtdam, int icrtrate, BigInteger bidmg, bool bright, IBattleEntity target)
    {
        if (IsPlaying) return;

        bFriendlySkill = bfriendskill;
        fCrtDam = fcrtdam;
        iCrtRate = icrtrate;
        biDmg = bidmg;
        this.target = target;
        iShot = 0;

        transform.position = v3pos;
        if (ptcEffects.Length == 0)
            ChangeFront(bright);
        gameObject.SetActive(true);
        playSkillCoroutine = StartCoroutine(PlaySkill());
    }

    // 타겟 데미지(타겟 트레이스).
    protected void StartSkillTargetTrace(bool bfriendskill, Transform trftrace, float fcrtdam, int icrtrate, BigInteger bidmg, bool bright, IBattleEntity target)
    {
        if (IsPlaying) return;

        trfTrace = trftrace;

        bFriendlySkill = bfriendskill;
        fCrtDam = fcrtdam;
        iCrtRate = icrtrate;
        biDmg = bidmg;
        this.target = target;
        iShot = 0;

        transform.position = trftrace.position;
        if (ptcEffects.Length == 0)
            ChangeFront(bright);
        gameObject.SetActive(true);
        playSkillCoroutine = StartCoroutine(PlaySkill());
    }

    // 범위 데미지.
    protected void StartSkillRange(bool bfriendskill, Vector3 v3pos, float fcrtdam, int icrtrate, BigInteger bidmg, bool bright)
    {
        if (IsPlaying) return;

        bFriendlySkill = bfriendskill;
        fCrtDam = fcrtdam;
        iCrtRate = icrtrate;
        biDmg = bidmg;

        transform.position = v3pos;
        if (ptcEffects.Length == 0)
            ChangeFront(bright);
        gameObject.SetActive(true);
        playSkillCoroutine = StartCoroutine(PlaySkill());
    }

    // 범위 데미지(타겟 트레이스).
    protected void StartSkillRangeTrace(bool bfriendskill, Transform trftrace, float fcrtdam, int icrtrate, BigInteger bidmg, bool bright)
    {
        if (IsPlaying) return;

        trfTrace = trftrace;

        bFriendlySkill = bfriendskill;
        fCrtDam = fcrtdam;
        iCrtRate = icrtrate;
        biDmg = bidmg;

        transform.position = trftrace.position;
        if (ptcEffects.Length == 0)
            ChangeFront(bright);
        gameObject.SetActive(true);
        playSkillCoroutine = StartCoroutine(PlaySkill());
    }
    #endregion Start Skill
}