ylsj/Assets/Scripts/Core/Client/NewBattle/Controller/RPGPlayerController.cs

using UnityEngine;
using System.Collections;
using System.Collections.Generic;
using Chronos;
using UnityEngine.PostProcessing;
using Cinemachine;
using UnityGameFramework.Runtime;
using GameFramework.Event;
using AdonGameKit;

/// <summary>
/// 角色控制
/// </summary>
public class RPGPlayerController : MonoBehaviour
{
    ///// <summary>
    ///// 单键
    ///// </summary>
    //private static RPGPlayerController m_Instance;

    ///// <summary>
    ///// 看向的目标
    ///// </summary>
    //private HeadLookAtTarget mHeadLookAtTarget = null;

    ///// <summary>
    ///// 攻击锁定时间
    ///// </summary>
    //private float mAttackLockTime = 0;

    ///// <summary>
    ///// A按键信息(普通攻击)
    ///// </summary>
    //private List<KeyComboInfo> mKeyInfoJ = null;

    ///// <summary>
    ///// N按键信息(冲刺)
    ///// </summary>
    //private List<KeyComboInfo> mKeyInfoI = null;

    ///// <summary>
    ///// 武器技能
    ///// </summary>
    //private List<KeyComboInfo> mKeyInfoK = null;

    ///// <summary>
    ///// 必杀
    ///// </summary>
    //private List<KeyComboInfo> mKeyInfoL = null;

    ///// <summary>
    ///// 所以连击信息
    ///// </summary>
    //private List<ComboData> mAllComboInfos = new List<ComboData>();

    ///// <summary>
    ///// 当前按键宏列表
    ///// </summary>
    //private List<E_KeyType> mCurKeys = new List<E_KeyType>();

    ///// <summary>
    ///// 当前的连击列表
    ///// </summary>
    //private List<KeyComboInfo> mCurCombos = new List<KeyComboInfo>();

    ///// <summary>
    ///// 当前连击信息
    ///// </summary>
    //public KeyComboInfo mCurComboInfo = null;

    ///// <summary>
    ///// 当前连击索引
    ///// </summary>
    //private int mCurComboIndex = 1;

    ///// <summary>
    ///// 是否
    ///// </summary>
    //private bool mPush = false;

    ///// <summary>
    ///// 推进的速度
    ///// </summary>
    //private float mPushSpeed = 20;

    ///// <summary>
    ///// 推进时间
    ///// </summary>
    //private float mPushTime = 0.35f;

    ///// <summary>
    ///// 推进的方向
    ///// </summary>
    //private Vector3 mPushDir = Vector3.zero;

    ///// <summary>
    ///// 移动中
    ///// </summary>
    //private bool mMoveing = false;

    ///// <summary>
    ///// 是否淡入移动动画
    ///// </summary>
    //private bool bCrossMoveAni = false;

    ///// <summary>
    ///// 相机动画
    ///// </summary>
    ////private Animator _cameraAnimator = null;

    ///// <summary>
    ///// 0 默认状态，1相机自由状态，2锁定状态
    ///// </summary>
    //private int _cameraType = 0;

    ///// <summary>
    ///// 当前控制的角色
    ///// </summary>
    //private Role mRole = null;

    ///// <summary>
    ///// 是否锁定连招中
    ///// </summary>
    //private bool bLockCombo = false;

    ///// <summary>
    ///// 是否可移动
    ///// </summary>
    //private bool bCanMove = true;

    ///// <summary>
    ///// 是否检测静止状态
    ///// </summary>
    //private bool IsCheckIdle = true;

    ///// <summary>
    ///// 最后一个生效的慢动作角色
    ///// </summary>
    //private Role slowTimeRole = null;

    ///// <summary>
    ///// 玩家播放速度
    ///// </summary>
    //private float _playerSpeed = 1.0f;

    //private Transform _cmFollowPos;


    //public Camera mainCamera;

    //public float comboSpaceTime = 5;
    //public float comboNowTime = 0;

    //private int _castSkillIndex = 0;

    //public HeroGameVo_Yanling _castYLSkillVO = null;

    ///// <summary>
    ///// 后期文件
    ///// </summary>
    //PostProcessingProfile _PostProcessingProfile;

    ///// <summary>
    ///// 根时钟
    ///// </summary>
    //private Clock _clockRoot;
    ///// <summary>
    ///// 玩家时钟
    ///// </summary>
    //private Clock _clockPlayer;
    ///// <summary>
    ///// 敌人时钟
    ///// </summary>
    //private Clock _clockEnemy;

    ///// <summary>
    ///// 提示箭头的目标
    ///// </summary>
    //private Transform tipArrowTarget = null;


    //public Timeline time
    //{
    //    get
    //    {
    //        return GetComponent<Timeline>();
    //    }
    //}
    ///// <summary>
    ///// 单键
    ///// </summary>
    //public static RPGPlayerController Instance
    //{
    //    get
    //    {
    //        if (m_Instance == null)
    //        {
    //            GameObject obj = new GameObject("RPGPlayerController");
    //            m_Instance = obj.AddComponent<RPGPlayerController>();
                
    //        }

    //        return m_Instance;
    //    }
    //}

    ///// <summary>
    ///// 玩家
    ///// </summary>
    //public Role Player
    //{
    //    get
    //    {
    //        return mRole;
    //    }
    //}

    ///// <summary>
    ///// 开始
    ///// </summary>
    //private void Start()
    //{
    //    _clockRoot = Timekeeper.instance.Clock("Root");
    //    _clockPlayer = Timekeeper.instance.Clock("Player");
    //    _clockEnemy = Timekeeper.instance.Clock("Enemy");
    //    //_PostProcessingProfile = Camera.main.GetComponent<PostProcessingBehaviour>().profile;

    //    //BattleCanvas.Instance.SetCorrectCameraUI(this.CorrectCamera);
    //}

    ///// <summary>
    ///// 设置控制的玩家
    ///// </summary>
    //public void SetPlayer(Role role)
    //{
    //    if (role == null)
    //    {
    //        return;
    //    }

    //    if (mRole != null && mRole != role && mRole.isDie == false)
    //    {
    //        mRole.IsTeamLeader = false;
    //        mRole.mBehaviorTree.SetVariableValue("followTarget", role.transform);
    //        mRole.mBehaviorTree.EnableBehavior();
    //        mRole.mNavMeshAgent.enabled = false;
    //        mRole.HidemArrow();
    //        Rigidbody rbody = mRole.GetComponent<Rigidbody>();
    //        Destroy(rbody);
    //        GameObject cm = mRole.gameObject.transform.Find("CMStateDrivenCamera").gameObject;
    //        if (cm)
    //        {
    //            cm.SetActive(true);
    //        }
    //    }

    //    mRole = role;
    //    mRole.IsTeamLeader = true;
    //    mHeadLookAtTarget = mRole.GetComponentInChildren<HeadLookAtTarget>();
    //    mRole.mBehaviorTree.SetVariableValue("followTarget", null);
    //    mRole.mBehaviorTree.DisableBehavior();
    //    mRole.mNavMeshAgent.enabled = true;
    //    mRole.PlayAnimation("Idle");

    //    Rigidbody rb = mRole.GetComponent<Rigidbody>();
    //    if (rb == null)
    //    {
    //        rb = mRole.gameObject.AddComponent<Rigidbody>();
    //        rb.useGravity = false;
    //        rb.isKinematic = true;
    //    }
    //    mKeyInfoJ = mRole.GetKeyComboInfo(E_KeyType.J);
    //    mKeyInfoK = mRole.GetKeyComboInfo(E_KeyType.K);
    //    mKeyInfoL = mRole.GetKeyComboInfo(E_KeyType.L);
    //    mKeyInfoI = mRole.GetKeyComboInfo(E_KeyType.I);

    //    /// 更新血量
    //    BattleCanvas.Instance.ShowPlayerHP(mRole.mData.HP_Final, mRole.mData.MaxHP_Final);
    //    // 更新能量条
    //    BattleCanvas.Instance.ShowPlayerPower(mRole.mData.MP_Final, mRole.mData.MaxMP_Final);
    //    // 更新按键
    //    BattleCanvas.Instance.UpdatePlayerKey(mRole);

    //    m_Instance = this;

    //    // 连击
    //    mAllComboInfos.Clear();
    //    ComboData data = new ComboData(E_ComboType.Common);
    //    sm_skill skill = GameConfigData.Ins.GetskillMo(int.Parse(role.mData.GetSKillNormal()));
    //    data.comboInfos.Clear();
    //    KeyComboInfo kInfo = new KeyComboInfo();
    //    kInfo.Key = E_KeyType.J;
    //    kInfo.Skill = skill;
    //    data.comboInfos.Add(kInfo);
    //    while (skill.nextSkill > 0)
    //    {
    //        skill = GameConfigData.Ins.GetskillMo(skill.nextSkill);
    //        kInfo = new KeyComboInfo();
    //        kInfo.Key = E_KeyType.J;
    //        kInfo.Skill = skill;

    //        data.comboInfos.Add(kInfo);
    //    }
    //    mAllComboInfos.Add(data);

    //    // 动画帧移动事件
    //    mRole.mSkillEvent.mOnSkillFire = AnimationEvent_Attack;
    //    mRole.mSkillEvent.PlayerSkill = AnimationEvent_PlayerSkill;

    //    ShowEffect("Juese_chuchang");
    //    JoystickHelper.JoystickMoveStart_AC = JoystickMoveStart;
    //    JoystickHelper.JoystickMove_AC = JoystickMove;
    //    JoystickHelper.JoystickMoveEnd_AC = JoystickMoveEnd;
    //    //JoystickHelper.KeyDownJ_AC = KeyDownJ;
    //    JoystickHelper.KeyDownK_AC = KeyDownK;
    //    JoystickHelper.KeyDownL_AC = KeyDownL;
    //    JoystickHelper.KeyDownI_AC = KeyDownI;
    //    JoystickHelper.KeySkill_YL1 = KeySkillYanling1;
    //    JoystickHelper.KeySkill_YL2 = KeySkillYanling2;
    //    JoystickHelper.KeySkill_YL3 = KeySkillYanling3;
    //    JoystickHelper.KeySkill_HT1 = KeySkillHeti1;
    //    JoystickHelper.KeySkill_HT2 = KeySkillHeti2;
    //    JoystickHelper.KeySkill_HT3 = KeySkillHeti3;
    //    JoystickHelper.KeySkill_HT4 = KeySkillHeti4;

    //    //CMCameraManager.Instance.ResetRole(role);


        
    //}
    ///// <summary>
    ///// 晚于更新(角色控制)
    ///// </summary>
    //private void LateUpdate()
    //{
    //    if (IsCheckIdle)
    //    {
    //        // 攻击锁定期间无法操作
    //        mAttackLockTime -= Time.unscaledDeltaTime;
    //        if (mAttackLockTime > 0)
    //        {
    //            return;
    //        }
    //        else
    //        {
    //            if (IsPlaying())
    //            {
    //                return;
    //            }

    //            // 判断有没有后续连击
    //            if (mCurCombos.Count > 0)
    //            {
    //                KeyComboInfo info = mCurCombos[0];
    //                mCurCombos.RemoveAt(0);

    //                PlayComboAnimation(info);

    //                mCurComboIndex++;

    //                return;
    //            }
    //        }

    //        Invoke("LateIdle", 0.1f);
    //        IsCheckIdle = false;
    //    }
    //}

    ///// <summary>
    ///// 极限闪避提示开始
    ///// </summary>
    //public void OnSlowTimeStart(Role role)
    //{
    //    if (role == mRole.TargetRole)
    //    {
    //        slowTimeRole = role;
    //        RPGEffectManager.Instance.ShouDodgeTip();
    //    }
    //}

    ///// <summary>
    ///// 极限闪避提示结束
    ///// </summary>
    //public void OnSlowTimeEnd(Role role)
    //{
    //    if (role == mRole.TargetRole)
    //    {
    //        RPGEffectManager.Instance.HideDodgeTip();
    //        slowTimeRole = null;
    //    }
    //}

    ///// <summary>
    ///// 摇杆开始移动
    ///// </summary>
    //public void JoystickMoveStart()
    //{
    //    if (bCanMove == false)
    //    {
    //        return;
    //    }

    //    if (bLockCombo)
    //    {
    //        return;
    //    }

    //    if (Player == null)
    //    {
    //        return;
    //    }

    //    ClearCombos(false);
    //    bCrossMoveAni = true;
    //    PlayAnimation("Walk", 0.25f);

    //    ProcedureComponent procedureObj = GameObject.Find("YLGameFramework").transform.Find("Procedure").gameObject.GetComponent<ProcedureComponent>();
    //    if (procedureObj.CurrentProcedure != null &&
    //        (procedureObj.CurrentProcedure.GetType().ToString() == "GameFrameworkYLSJ.ProcedureNoviceGuideStart" ||
    //        procedureObj.CurrentProcedure.GetType().ToString() == "GameFrameworkYLSJ.ProcedureNoviceGuideAtoB"))
    //    {
    //        YL_BattleNovice novice = PanelHelper.Instance.GetPanelByName("YL_BattleNovice").GetComponent<YL_BattleNovice>();
    //        novice.HideMask();
    //        PanelHelper.Instance.ClosePanel("YL_BattleNovice");
    //    }
    //    else if (procedureObj.CurrentProcedure == null)
    //    {
    //        TimeControl.Instance.GameNormal();
    //    }
    //}

    ///// <summary>
    ///// 摇杆移动中
    ///// </summary>
    ///// <param name="v2Dir"></param>
    //public void JoystickMove(Vector2 v2Dir)
    //{
    //    //if (bCanMove == false)
    //    //{
    //    //    return;
    //    //}

    //    //if (bLockCombo)
    //    //{
    //    //    return;
    //    //}

    //    //if (Player == null)
    //    //{
    //    //    return;
    //    //}

    //    //// 推进中 不可移动
    //    //if (mPush)
    //    //{
    //    //    return;
    //    //}

    //    //// buff状态不可移动中
    //    //if (Player.buffCanMove == false)
    //    //{
    //    //    return;
    //    //}

    //    //if (v2Dir.magnitude < 0.01f)
    //    //{
    //    //    return;
    //    //}

    //    //if (bCrossMoveAni == false)
    //    //{
    //    //    bCrossMoveAni = true;
    //    //    PlayAnimation("Walk", 0.25f);
    //    //}

    //    //mMoveing = true;
    //    //CheckNearTarget();

    //    //if (Player.TargetRole == null)
    //    //{
    //    //    Player.cameraLock = false;
    //    //    if (_cameraType != 1)
    //    //    {
    //    //        SwitchCameraState(false);
    //    //        _cameraType = 1;

    //    //    }
    //    //    this.ConvertMoveByCM(v2Dir);
    //    //}
    //    //else
    //    //{
    //    //    Player.cameraLock = true;
    //    //    if (_cameraType != 2)
    //    //    {
    //    //        SwitchCameraState(false);
    //    //        _cameraType = 2;
    //    //    }
    //    //    this.ConvertMoveByTargt(v2Dir);
    //    //}
    //}

    //public void SwitchCameraState(bool update)
    //{
    //    if (update)
    //    {
    //        Player.cameraState++;
    //    }
    //    if (Player.cameraState > 1)
    //    {
    //        Player.cameraState = 0;
    //    }
    //    if (Player.cameraLock)
    //    {
    //        Player.mBattleCameraAnim.Play("Locking");
    //    }
    //    else
    //    {
    //        switch (Player.cameraState)
    //        {
    //            case 0:
    //                Player.mBattleCameraAnim.Play("DefaultOne");
    //                break;
    //            case 1:
    //                Player.mBattleCameraAnim.Play("DefaultTwo");
    //                break;
    //        }
    //    }

    //}
    ///// <summary>
    ///// 自由移动
    ///// </summary>
    ///// <param name="v2Dir"></param>
    //public void ConvertMoveByCM(Vector2 v2Dir)
    //{
    //    Vector3 joyDir = new Vector3(v2Dir.x, 0, v2Dir.y);
    //    Vector3 cmForward = Camera.main.transform.forward;
    //    cmForward.y = 0;
    //    float angle = Vector3.Angle(Vector3.forward, joyDir);
    //    if (v2Dir.x < 0)
    //    {
    //        angle = -angle;
    //    }
    //    float cmAngle = Vector3.Angle(Vector3.forward, cmForward);
    //    if (cmForward.magnitude < 0.1f)
    //    {
    //        cmAngle = 0.0f;
    //    }
    //    if (cmForward.x < 0)
    //    {
    //        cmAngle = -cmAngle;
    //    }
    //    angle += cmAngle;

    //    // 旋转速度
    //    float actualTurnSpeed = 720;
    //    Quaternion targetRotation = Quaternion.RotateTowards(Player.transform.rotation, Quaternion.AngleAxis(angle, Vector3.up), actualTurnSpeed * Time.deltaTime);
    //    Player.transform.rotation = targetRotation;

    //    // 每次刚起步有个缓动过程
    //    if (_playerSpeed < 1)
    //    {
    //        _playerSpeed += Time.deltaTime * 2.5f;
    //    }
    //    float speed = Player.mData.MSP_Final * _playerSpeed;
    //    Player.mNavMeshAgent.velocity = Player.transform.forward * speed;

    //    if (_lastLookTarget)
    //    {
    //        buffTime = Time.time;
    //        _lastLookTarget = null;
    //    }
    //}

    //private float buffTime = 0;
    //private Role _lastLookTarget = null;

    ///// <summary>
    ///// 围绕目标移动
    ///// </summary>
    ///// <param name="v2Dir"></param>
    //public void ConvertMoveByTargt(Vector2 v2Dir)
    //{
    //    // 由目标模式进入相机模式，0.5秒内不再进入目标模式,防止临界区来回切换
    //    if (buffTime + 0.5 > Time.time)
    //    {
    //        ConvertMoveByCM(v2Dir);

    //        return;
    //    }

    //    _lastLookTarget = mRole.TargetRole;
    //    Vector3 pos = mRole.TargetRole.transform.position;
    //    pos.y = Player.transform.position.y;
    //    Player.transform.LookAt(pos);

    //    // 每次刚起步有个缓动过程
    //    if (_playerSpeed < 1)
    //    {
    //        _playerSpeed += Time.deltaTime * 2.5f;
    //    }
    //    float speed = Player.mData.MSP_Final * _playerSpeed;

    //    // 到达2米距离不再向目标移动
    //    float dis = Vector3.Distance(Player.transform.position, Player.TargetRole.transform.position);
    //    if (dis <= 2.0f)
    //    {
    //        if (Mathf.Abs(v2Dir.x) > 0.01f || v2Dir.y > 0.01f)
    //        {
    //            v2Dir.y = 0;
    //        }
    //    }

    //    Vector3 joyDir = (Player.transform.right * v2Dir.x) + (Player.transform.forward * v2Dir.y);
    //    Player.mNavMeshAgent.velocity = joyDir * speed;
    //}

    ///// <summary>
    ///// 摇杆移动结束
    ///// </summary>
    //public void JoystickMoveEnd()
    //{
    //    if (bLockCombo)
    //    {
    //        return;
    //    }

    //    if (Player == null)
    //    {
    //        return;
    //    }

    //    // 停止移动后有个轻微惯性
    //    Player.mNavMeshAgent.velocity = Player.transform.forward * 2;

    //    PlayAnimation("Idle", 0.2f);
    //    mMoveing = false;
    //    bCrossMoveAni = false;
    //}

    ///// <summary>
    ///// 按键J
    ///// </summary>
    //public void KeyDownJ()
    //{
    //    if (Player == null)
    //    {
    //        return;
    //    }

    //    if (bLockCombo)
    //    {
    //        return;
    //    }

    //    // buff状态不可攻击状态中
    //    if (Player.buffCanAttack == false)
    //    {
    //        return;
    //    }

    //    CheckNearTarget();

    //    PressKey(E_KeyType.J);
    //}

    ///// <summary>
    ///// 按键K 武器
    ///// </summary>
    //private void KeyDownK()
    //{
    //    if (bLockCombo)
    //    {
    //        return;
    //    }

    //    if (Player == null)
    //    {
    //        return;
    //    }

    //    // buff状态不可攻击状态中
    //    if (Player.buffCanAttack == false)
    //    {
    //        return;
    //    }
    //}

    ///// <summary>
    ///// 按键L 必杀
    ///// </summary>
    //private void KeyDownL()
    //{
    //    if (bLockCombo)
    //    {
    //        return;
    //    }

    //    if (Player == null)
    //    {
    //        return;
    //    }

    //    // buff状态不可攻击状态中
    //    if (Player.buffCanAttack == false)
    //    {
    //        return;
    //    }

    //    GameDateManager.Instance.PlayerUseSkillCount++;

    //    CheckNearTarget();

    //    PressKey(E_KeyType.L);
    //}

    ///// <summary>
    ///// 按键I
    ///// </summary>
    //public void KeyDownI()
    //{
    //    if (bLockCombo)
    //    {
    //        return;
    //    }

    //    if (Player == null)
    //    {
    //        return;
    //    }

    //    // buff状态不可攻击状态中
    //    if (Player.buffCanAttack == false || Player.buffCanMove == false)
    //    {
    //        return;
    //    }

    //    Player.mInvincible = true;
    //    float speed = 3.0f;
    //    float dis = 2.0f;
    //    Vector3 dir = Vector3.zero;
    //    if (mMoveing == false)
    //    {
    //        dir = -Player.transform.forward;
    //        speed = Player.mData.MSP_Final * 0.5f;
    //        dis = 1.5f;
    //        PlayAnimation("Dodge");
    //    }
    //    else
    //    {
    //        dir = Player.transform.forward;
    //        speed = Player.mData.MSP_Final * 2;
    //        dis = 4.0f;
    //        PlayAnimation("Rush");
    //    }

    //    // 执行闪避慢动作
    //    if (slowTimeRole != null)
    //    {
    //        // 恢复能量
    //        Player.mData.UpdateMP(2, true);
    //        ShowEffect("Juese_shanbi_00");

    //        _PostProcessingProfile.eyeAdaptation.enabled = true;
    //        _PostProcessingProfile.motionBlur.enabled = true;

    //        MotionBlurModel.Settings mbSet = _PostProcessingProfile.motionBlur.settings;
    //        mbSet.frameBlending = 1;
    //        _PostProcessingProfile.motionBlur.settings = mbSet;

    //        // 角色执行了极限闪避，只播放动作无需实际进行位移闪避
    //        _clockEnemy.localTimeScale = 0.03f;
    //        _clockPlayer.localTimeScale = 0.2f;

    //        Invoke("FreeSlowTimePlayer", 1);
    //        Invoke("FreeSlowTimeEnemy", 5);
    //        return;
    //    }
    //    else
    //    {
    //        bLockCombo = true;
    //        IsCheckIdle = true;
    //        ShowEffect("Juese_shanbi_00");
    //    }

    //    // 法师 传送门闪避
    //    if (Player.mData.TID == 202011)
    //    {
    //        Player.gameObject.AddComponent<RoleDodgeDoor>().Init(Player, dir, speed);
    //    }
    //    else
    //    {
    //        Player.gameObject.AddComponent<RoleDodge>().Init(Player, dir, speed);
    //    }
    //}

    ///// <summary>
    ///// 释放慢动作
    ///// </summary>
    //private void FreeSlowTimePlayer()
    //{
    //    Player.mInvincible = false;
    //    _clockPlayer.localTimeScale = 1;
    //}

    ///// <summary>
    ///// 释放慢动作
    ///// </summary>
    //private void FreeSlowTimeEnemy()
    //{
    //    _PostProcessingProfile.motionBlur.enabled = false;
    //    _PostProcessingProfile.eyeAdaptation.enabled = false;
    //    _clockEnemy.localTimeScale = 1;
    //}

    ///// <summary>
    ///// 消耗蓝
    ///// </summary>
    ///// <param name="skillID"></param>
    //private void CostMP(string skillID)
    //{
    //    sm_skill skill = sm_skill.GetMoByID(int.Parse(skillID));
    //    if (skill != null)
    //    {
    //        Player.mData.UpdateMP(-skill.costPowerPoint, true);
    //    }
    //}

    //public void OnSkillYanling(HeroGameVo_Yanling yanlingVO, int index)
    //{
    //    sm_skill smsk = GameConfigData.Ins.GetskillMo(int.Parse(BattleCanvas.Instance.GetSkillID(index)));
    //    if (smsk.aim == (int)BattleDefine.ERoleAIMType.EROLE_AIM_TARGET ||
    //        smsk.aim == (int)BattleDefine.ERoleAIMType.EROLE_AIM_TARGETAROUND ||
    //        smsk.aim == (int)BattleDefine.ERoleAIMType.EROLE_AIM_RONDOMMOREENEMY)
    //    {
    //        if (Player.TargetRole == null)
    //        {
    //            return;
    //        }
    //        _castSkillIndex = index;
    //        _castYLSkillVO = yanlingVO;
    //        CostMP(BattleCanvas.Instance.GetSkillID(_castSkillIndex));
    //        X2Battle.X2BattleManager.Instance.mBulletModel.OnCastSkill(
    //        Player.mData.UID, BattleCanvas.Instance.GetSkillID(_castSkillIndex),
    //        false, X2Battle.EBulletCastPoint.ECAST_POINT_DEFLUAT, int.Parse(Player.TargetRole.ID()), false);
    //        //EventComponent nowEvent = GameEntry.GetComponent<EventComponent>();
    //        //nowEvent.FireNow(this, new BattleEventYLSkillFeatureS(yanlingVO));

    //    }
    //    else if (smsk.aim == (int)BattleDefine.ERoleAIMType.EROLE_AIM_SELF ||
    //        smsk.aim == (int)BattleDefine.ERoleAIMType.EROLE_AIM_SELFAROUND ||
    //        smsk.aim == (int)BattleDefine.ERoleAIMType.EROLE_AIM_ALLFRIENDS)
    //    {
    //        _castSkillIndex = index;
    //        _castYLSkillVO = yanlingVO;
    //        EventComponent nowEvent = GameEntry.GetComponent<EventComponent>();
    //        nowEvent.FireNow(this, new BattleEventYLSkillFeatureS(yanlingVO));
    //    }
    //}

    //public void SkillYanLingFeatureEnd()
    //{
    //    CostMP(BattleCanvas.Instance.GetSkillID(_castSkillIndex));
    //    PlayAnimation("YLJ_S");
    //    X2Battle.X2BattleManager.Instance.mBulletModel.OnCastSkill(
    //    Player.mData.UID, BattleCanvas.Instance.GetSkillID(_castSkillIndex),
    //    false, X2Battle.EBulletCastPoint.ECAST_POINT_DEFLUAT, int.Parse(Player.TargetRole.ID()), false);
    //}



    //public void KeySkillYanling1()
    //{
    //    if (Player.TargetRole == null)
    //    {
    //        return;
    //    }
    //    TimeControl.Instance.EnemyTimePause();
    //    HeroGameVo_Yanling yanlingVO = Player.mData.mHeroVo.yanling[1];
    //    _castSkillIndex = 3;
    //    EventComponent nowEvent = GameEntry.GetComponent<EventComponent>();
    //    nowEvent.FireNow(this, new BattleEventYLSkillFeatureS(yanlingVO));
    //}

    //public void KeySkillYanling2()
    //{
    //    if (Player.TargetRole == null)
    //    {
    //        return;
    //    }
    //    TimeControl.Instance.EnemyTimePause();
    //    HeroGameVo_Yanling yanlingVO = Player.mData.mHeroVo.yanling[2];
    //    _castSkillIndex = 4;
    //    EventComponent nowEvent = GameEntry.GetComponent<EventComponent>();
    //    nowEvent.FireNow(this, new BattleEventYLSkillFeatureS(yanlingVO));
    //}

    //public void KeySkillYanling3()
    //{
    //    if (Player.TargetRole == null)
    //    {
    //        return;
    //    }
    //    TimeControl.Instance.EnemyTimePause();
    //    HeroGameVo_Yanling yanlingVO = Player.mData.mHeroVo.yanling[3];
    //    _castSkillIndex = 5;
    //    EventComponent nowEvent = GameEntry.GetComponent<EventComponent>();
    //    nowEvent.FireNow(this, new BattleEventYLSkillFeatureS(yanlingVO));
    //}

    //public void KeySkillHeti1()
    //{
    //    if (Player.TargetRole == null)
    //    {
    //        return;
    //    }
    //    TimeControl.Instance.EnemyTimePause();
    //    CostMP(BattleCanvas.Instance.GetSkillID(6));
    //    PlayAnimation("HTJ_S");
    //    X2Battle.X2BattleManager.Instance.mBulletModel.OnCastSkill(
    //           Player.mData.UID, BattleCanvas.Instance.GetSkillID(6),
    //           false, X2Battle.EBulletCastPoint.ECAST_POINT_DEFLUAT, int.Parse(Player.TargetRole.ID()), false);
    //}

    //public void KeySkillHeti2()
    //{
    //    if (Player.TargetRole == null)
    //    {
    //        return;
    //    }
    //    TimeControl.Instance.EnemyTimePause();
    //    CostMP(BattleCanvas.Instance.GetSkillID(7));
    //    PlayAnimation("HTJ_S");
    //    X2Battle.X2BattleManager.Instance.mBulletModel.OnCastSkill(
    //           Player.mData.UID, BattleCanvas.Instance.GetSkillID(7),
    //           false, X2Battle.EBulletCastPoint.ECAST_POINT_DEFLUAT, int.Parse(Player.TargetRole.ID()), false);
    //}

    //public void KeySkillHeti3()
    //{
    //    if (Player.TargetRole == null)
    //    {
    //        return;
    //    }
    //    TimeControl.Instance.EnemyTimePause();
    //    CostMP(BattleCanvas.Instance.GetSkillID(8));
    //    PlayAnimation("HTJ_S");
    //    X2Battle.X2BattleManager.Instance.mBulletModel.OnCastSkill(
    //           Player.mData.UID, BattleCanvas.Instance.GetSkillID(8),
    //           false, X2Battle.EBulletCastPoint.ECAST_POINT_DEFLUAT, int.Parse(Player.TargetRole.ID()), false);
    //}

    //public void KeySkillHeti4()
    //{
    //    if (Player.TargetRole == null)
    //    {
    //        return;
    //    }
    //    TimeControl.Instance.EnemyTimePause();
    //    CostMP(BattleCanvas.Instance.GetSkillID(9));
    //    PlayAnimation("HTJ_S");
    //    X2Battle.X2BattleManager.Instance.mBulletModel.OnCastSkill(
    //           Player.mData.UID, BattleCanvas.Instance.GetSkillID(9),
    //           false, X2Battle.EBulletCastPoint.ECAST_POINT_DEFLUAT, int.Parse(Player.TargetRole.ID()), false);
    //}

    ///// <summary>
    ///// 延迟静止
    ///// </summary>
    //private void LateIdle()
    //{
    //    if (Player)
    //    {
    //        Player.mInvincible = false;
    //    }

    //    // 清除按键列表
    //    ClearCombos(true);
    //}

    ///// <summary>
    ///// 更新
    ///// </summary>
    //private void FixedUpdate()
    //{
    //    // 推进
    //    if (mPush)
    //    {
    //        mPushTime -= Time.deltaTime;
    //        if (mPushTime > 0)
    //        {
    //            Player.mNavMeshAgent.velocity = mPushDir * mPushSpeed;
    //        }
    //        else
    //        {
    //            Player.mNavMeshAgent.velocity = Vector3.zero;
    //            mPush = false;
    //        }
    //    }
    //}

    ///// <summary>
    ///// 更新
    ///// </summary>
    //private void Update()
    //{
    //    //if (Input.touchCount > 0 || Input.GetMouseButtonDown(0))
    //    //{
    //    //    this.CorrectCamera();
    //    //}

    //    // combo
    //    this.comboNowTime -= Time.deltaTime;
    //    if (this.comboNowTime <= 0)
    //    {
    //        LocalSettings.BattleComboCount = 0;
    //    }

    //    if (Player != null)
    //    {
    //        // 刷新箭头方向
    //        for (int i = 0; i < Player.mArrows.Count; i++)
    //        {
    //            if (i >= RoleManager.Instance.GetLiveMonsters().Count)
    //            {
    //                Player.mArrows[i].gameObject.SetActive(false);
    //            }
    //            else
    //            {
    //                if (RoleManager.Instance.GetLiveMonsters()[i] != null)
    //                {
    //                    Player.mArrows[i].gameObject.SetActive(true);
    //                    Vector3 lookPos = RoleManager.Instance.GetLiveMonsters()[i].transform.position;
    //                    lookPos.y = Player.mArrows[i].position.y;
    //                    Player.mArrows[i].LookAt(lookPos);
    //                }
    //                else
    //                {
    //                    Player.mArrows[i].gameObject.SetActive(false);
    //                }
    //            }
    //        }

    //        // 提示箭头
    //        if (tipArrowTarget != null)
    //        {
    //            Vector3 lookPos = tipArrowTarget.position;
    //            lookPos.y = Player.mTipArrowTran.position.y;
    //            Player.mTipArrowTran.LookAt(lookPos);

    //            Player.UpdatemTipArrow(tipArrowTarget);
    //        }
    //    }
    //}

    ///// <summary>
    ///// 显示提示箭头
    ///// </summary>
    ///// <param name="tipTarget"></param>
    //public void ShowTipArrow(Transform tipTarget)
    //{
    //    tipArrowTarget = tipTarget;
    //    Player.mTipArrowTran.gameObject.SetActive(true);
    //}

    ///// <summary>
    ///// 隐藏提示箭头
    ///// </summary>
    //public void HideTipArrow()
    //{
    //    tipArrowTarget = null;
    //    Player.mTipArrowTran.gameObject.SetActive(false);
    //}


    //void UpdateScoreDisplay(float newScore)
    //{
    //    //cmVC.m_XAxis.Value = newScore;
    //}
    //public void CorrectCameraComplete()
    //{
    //    Transform cmTrans = mRole.transform.Find("CMStateDrivenCamera/CMDefault1");
    //    CinemachineVirtualCamera cmVC = cmTrans.GetComponent<CinemachineVirtualCamera>();
    //    CinemachineTransposer transposer = cmVC.GetCinemachineComponent<CinemachineTransposer>();
    //    transposer.m_BindingMode = CinemachineTransposer.BindingMode.SimpleFollowWithWorldUp;
    //}

    //public void CorrectCameraFollow()
    //{
    //    Transform cmTrans = mRole.transform.Find("CMStateDrivenCamera/CMDefault1");
    //    CinemachineVirtualCamera cmVC = cmTrans.GetComponent<CinemachineVirtualCamera>();
    //    CinemachineStateDrivenCamera cmSDC = cmVC.transform.parent.GetComponent<CinemachineStateDrivenCamera>();
    //    cmSDC.Follow = this._cmFollowPos;
    //}

    ///// <summary>
    ///// 按键
    ///// </summary>
    ///// <param name="keyType">按键类型</param>
    //public void PressKey(E_KeyType keyType)
    //{
    //    // 主角不是待机状态，中断
    //    //*//if (mRole.roleStateName != "RoleState_Idle")
    //    //*//{
    //    //*//return;
    //    //*//}

    //    // 人物死亡 中断
    //    if (mRole.isDie)
    //    {
    //        return;
    //    }

    //    // 连招锁定中，按键无效
    //    if (bLockCombo)
    //    {
    //        return;
    //    }

    //    if (mCurKeys.Count < 1)
    //    {
    //        KeyEvent(keyType);
    //    }
    //    else
    //    {
    //        mCurKeys.Add(keyType);

    //        // 检测连击
    //        if (IsCombo(mCurKeys))
    //        {
    //            return;
    //        }

    //        // 有后续连击，中断，等待连击播放完
    //        if (mCurCombos.Count > 0)
    //        {
    //            return;
    //        }

    //        // 没有匹配到连击，清除按键列表
    //        ClearCombos();

    //        KeyEvent(keyType);
    //    }
    //}

    ///// <summary>
    ///// 按键事件
    ///// </summary>
    ///// <param name="keyType">按键类型</param>
    //private void KeyEvent(E_KeyType keyType)
    //{
    //    // 没有播放其他动作才可执行新动作
    //    if (IsPlaying() == false)
    //    {
    //        // do nothing
    //    }
    //    else
    //    {
    //        return;
    //    }

    //    // 普通攻击
    //    if (keyType == E_KeyType.J)
    //    {
    //        bCanMove = false;
    //        for (int i = 0; i < mKeyInfoJ.Count; i++)
    //        {
    //            if (i == 0)
    //            {
    //                PlayComboAnimation(mKeyInfoJ[i]);
    //            }

    //            mCurKeys.Add(mKeyInfoJ[i].Key);
    //        }
    //    }
    //    // 冲刺/闪避
    //    else if (keyType == E_KeyType.I)
    //    {
    //        for (int i = 0; i < mKeyInfoI.Count; i++)
    //        {
    //            if (i == 0)
    //            {
    //                PlayComboAnimation(mKeyInfoI[i]);
    //            }

    //            mCurKeys.Add(mKeyInfoI[i].Key);
    //        }
    //    }
    //    // 武器技能
    //    else if (keyType == E_KeyType.K)
    //    {
    //        ClearCombos();
    //        bLockCombo = true;

    //        for (int i = 0; i < mKeyInfoK.Count; i++)
    //        {
    //            if (i == 0)
    //            {
    //                PlayComboAnimation(mKeyInfoK[i]);
    //            }
    //            else
    //            {
    //                mCurCombos.Add(mKeyInfoK[i]);
    //            }
    //        }
    //    }
    //    // 必杀
    //    else if (keyType == E_KeyType.L)
    //    {
    //        ClearCombos();
    //        bLockCombo = true;

    //        for (int i = 0; i < mKeyInfoL.Count; i++)
    //        {
    //            if (i == 0)
    //            {
    //                PlayComboAnimation(mKeyInfoL[i]);
    //            }
    //            else
    //            {
    //                mCurCombos.Add(mKeyInfoL[i]);
    //            }
    //        }
    //    }
    //}

    ///// <summary>
    ///// 检测最近的目标（参数false时有目标则不进行搜索，参数true时重新搜索最近的目标）
    ///// </summary>
    ///// <param name="forceFind">是否强制搜索</param>
    ///// <returns></returns>
    //private Role CheckNearTarget(bool forceFind = false)
    //{
    //    if (forceFind == false && Player.TargetRole != null)
    //    {
    //        float dis = Vector3.Distance(Player.TargetRole.transform.position, mRole.transform.position);
    //        if (dis <= Player.mData.ORG_Final)
    //        {
    //            return Player.TargetRole;
    //        }
    //    }

    //    Role targetRole = null;
    //    // 检测 离的最近的玩家
    //    Collider[] colliders = Physics.OverlapSphere(mRole.transform.position, Player.mData.ORG_Final, 1 << LayerMask.NameToLayer("Enemy"));
    //    if (colliders != null && colliders.Length > 0)
    //    {
    //        float minDis = 9999;

    //        for (int i = 0; i < colliders.Length; i++)
    //        {
    //            float dis = Vector3.Distance(colliders[i].transform.position, mRole.transform.position);
    //            if (dis < minDis)
    //            {
    //                minDis = dis;

    //                targetRole = colliders[i].GetComponent<Role>();
    //            }
    //        }
    //    }

    //    if (targetRole != null && Player.TargetRole != targetRole)
    //    {
    //        if (Player.TargetRole)
    //        {
    //            Player.TargetRole.LockStampEffect.SetActive(false);
    //        }

    //        targetRole.LockStampEffect.SetActive(true);
    //    }
    //    else if (targetRole == null && Player.TargetRole != targetRole)
    //    {
    //        Player.TargetRole.LockStampEffect.SetActive(false);
    //    }
    //    Player.TargetRole = targetRole;

    //    if (targetRole != null)
    //    {
    //        BattleCanvas.Instance.ShowLockMonsterHP(targetRole);
    //        if (mHeadLookAtTarget != null)
    //        {
    //            mHeadLookAtTarget.m_TargetObject = targetRole.gameObject;
    //        }
    //    }
    //    else
    //    {
    //        BattleCanvas.Instance.HideLockMonsterHP();
    //        if (mHeadLookAtTarget != null)
    //        {
    //            mHeadLookAtTarget.m_TargetObject = null;
    //        }
    //    }

    //    return targetRole;
    //}

    ///// <summary>
    ///// 清理连击信息
    ///// </summary>
    //public void ClearCombos(bool idleAni = false)
    //{
    //    Debug.Log("执行清理连击");

    //    mCurKeys.Clear();
    //    mCurCombos.Clear();
    //    mCurComboIndex = 1;
    //    bLockCombo = false;
    //    mAttackLockTime = 0;
    //    IsCheckIdle = false;
    //    mMoveing = false;
    //    bCanMove = true;
    //    bCrossMoveAni = false;

    //    if (this.mRole)
    //    {
    //        this.mRole.mInvincible = false;
    //    }

    //    if (idleAni)
    //    {
    //        PlayAnimation("Idle", 0.25f);
    //    }
    //}

    ///// <summary>
    ///// 播放动画
    ///// </summary>
    ///// <param name="aniName">动画名称</param>
    ///// <param name="fadeTime">淡入时间</param>
    //public void PlayAnimation(string aniName, float fadeTime = 0)
    //{
    //    if (mAttackLockTime > 0)
    //    {
    //        return;
    //    }

    //    // 人物死亡 中断
    //    if (mRole == null || mRole.isDie)
    //    {
    //        return;
    //    }

    //    // 直接播放
    //    if (fadeTime < 0.01f)
    //    {
    //        Player.mAnimator.PlayInFixedTime(aniName, 0, 0);
    //    }
    //    else
    //    {
    //        Player.mAnimator.CrossFadeInFixedTime(aniName, fadeTime);
    //    }
    //}

    ///// <summary>
    ///// 播放连击动作
    ///// </summary>
    ///// <param name="info">信息</param>
    ///// <param name="autoIdleTime">自动静止的时间</param>
    //private void PlayComboAnimation(KeyComboInfo info, float autoIdleTime = 0.5f)
    //{
    //    if (Player.mData.MP_Final < info.Skill.costPowerPoint)
    //    {
    //        Debug.Log("能量不足，无法释放！！！" + info.Skill.name);
    //        bLockCombo = false;
    //        return;
    //    }

    //    // 检测最近玩家
    //    if (Player.TargetRole == null || Player.TargetRole.IsDead())
    //    {
    //        CheckNearTarget();
    //    }

    //    // 检测是否冲刺
    //    if (Player.TargetRole)
    //    {
    //        float dis = Vector3.Distance(Player.transform.position, Player.TargetRole.transform.position);
    //        if (dis > Player.mData.ARG_Final)
    //        {
    //            PlayerPush(Player.transform.position + mPushDir * (dis - Player.mData.ARG_Final));

    //            // 如果处于连招中，则重新从第一招开始
    //            if (mCurCombos.Count > 1)
    //            {
    //                info = mCurCombos[0];
    //                ClearCombos();
    //            }
    //        }
    //    }

    //    IsCheckIdle = true;
    //    PlayAnimation(info.Skill.actShow);

    //    mAttackLockTime = autoIdleTime;
    //    mCurComboInfo = info;

    //    // 设置使用的技能
    //    Player.mData.SetCurUseSkill(info.Skill.typeId.ToString());
    //    // 消耗能量
    //    Player.mData.UpdateMP(-info.Skill.costPowerPoint, true);

    //    // 显示特效
    //    ShowEffect(mCurComboInfo.Skill.effShow);

    //    // 默认维持人物正方向
    //    mPushDir = mRole.transform.forward;

    //    // 存在锁定目标，则朝向锁定目标
    //    if (Player.TargetRole && info.Skill.skillType < 2)
    //    {
    //        mPushDir = Player.TargetRole.transform.position - mRole.transform.position;
    //        mPushDir.Normalize();

    //        mRole.SetRotation(mPushDir);
    //    }
    //}

    ///// <summary>
    ///// 设置玩家位置 
    ///// </summary>
    ///// <param name="tran">设置的transform</param>
    //public void SetPlayerPos(Transform tran)
    //{
    //    if (tran == null)
    //    {
    //        return;
    //    }

    //    Player.transform.position = tran.position;
    //    Player.transform.localRotation = tran.localRotation;
    //}

    ///// <summary>
    ///// 技能必杀
    ///// </summary>
    //private void AnimationEvent_PlayerSkill()
    //{
    //    // 此处可能会有技能的特殊逻辑，暂时没发现有此需求，直接用攻击的逻辑
    //    AnimationEvent_Attack();
    //}

    ///// <summary>
    ///// 攻击检测
    ///// </summary>
    //private void AnimationEvent_Attack()
    //{
    //    /// 0默认值错误值
    //    /// 1指定角色(指定ID)
    //    /// 2自己、
    //    /// 3自身以及相邻单位、
    //    /// 4所有友方(包括自己)
    //    /// 5敌方随机N个
    //    /// 6当前目标及相邻单位
    //    /// 7所有敌人
    //    Collider[] colliders;
    //    switch (mCurComboInfo.Skill.aim)
    //    {
    //        case 1:
    //            colliders = Physics.OverlapSphere(mRole.transform.position, mCurComboInfo.Skill.attackRadius, 1 << LayerMask.NameToLayer("Enemy"));
    //            break;
    //        case 2:
    //            colliders = new Collider[1];
    //            colliders[0] = this.mRole.mCollider;
    //            break;
    //        case 3:
    //            colliders = Physics.OverlapSphere(mRole.transform.position, mCurComboInfo.Skill.attackRadius, 1 << LayerMask.NameToLayer("Player"));
    //            break;
    //        case 4:
    //            colliders = Physics.OverlapSphere(mRole.transform.position, mCurComboInfo.Skill.attackRadius, 1 << LayerMask.NameToLayer("Player"));
    //            break;
    //        case 5:
    //            colliders = Physics.OverlapSphere(mRole.transform.position, mCurComboInfo.Skill.attackRadius, 1 << LayerMask.NameToLayer("Enemy"));
    //            break;
    //        case 6:
    //            colliders = Physics.OverlapSphere(mRole.transform.position, mCurComboInfo.Skill.attackRadius, 1 << LayerMask.NameToLayer("Enemy"));
    //            break;
    //        case 7:
    //            colliders = Physics.OverlapSphere(mRole.transform.position, mCurComboInfo.Skill.attackRadius, 1 << LayerMask.NameToLayer("Enemy"));
    //            break;
    //        default:
    //            colliders = null;
    //            break;
    //    }

    //    if (colliders != null && colliders.Length > 0)
    //    {
    //        for (int i = 0; i < colliders.Length; i++)
    //        {
    //            // 忽略角色控制器的碰撞
    //            if (colliders[i] == null || colliders[i] is CharacterController)
    //            {
    //                continue;
    //            }

    //            float dis = Vector3.Distance(colliders[i].transform.position, mRole.transform.position);
    //            if (dis > mCurComboInfo.Skill.attackRadius)
    //            {
    //                continue;
    //            }

    //            Role tRole = colliders[i].GetComponent<Role>();
    //            if (tRole == null)
    //            {
    //                continue;
    //            }
    //            else if (tRole.isDie == false)
    //            {
    //                // 无敌中，不受伤害
    //                if (tRole.mInvincible)
    //                {
    //                    continue;
    //                }
    //            }

    //            // 筛选符合攻击范围的玩家
    //            Vector3 v3Dir = colliders[i].transform.position - mRole.transform.position;
    //            v3Dir.Normalize();
    //            float angle = Vector3.Angle(mRole.transform.forward, v3Dir);
    //            if (angle <= mCurComboInfo.Skill.attackAngle * 0.5f)
    //            {
    //                this.comboNowTime = comboSpaceTime;
    //                LocalSettings.BattleComboCount++;
    //                if (LocalSettings.MaxCombCount < LocalSettings.BattleComboCount)
    //                {
    //                    LocalSettings.MaxCombCount = LocalSettings.BattleComboCount;
    //                }

    //                // 恢复能量
    //                Player.mData.UpdateMP(3, true);

    //                X2Battle.X2BattleManager.Instance.mBulletModel.OnCastSkill(
    //           Player.mData.UID, Player.mData.GetCurUseSkill(), false, X2Battle.EBulletCastPoint.ECAST_POINT_DEFLUAT, tRole.mData.UID, false);

    //                Vector3 dir = tRole.transform.position - mRole.transform.position;
    //                dir.Normalize();

    //                RPGEffectManager.Instance.CreateEffect(1, tRole.mHitPos.GetPosition(), dir);
    //            }
    //        }
    //    }
    //}

    ///// <summary>
    ///// 显示特效
    ///// </summary>
    ///// <param name="effectName">名称</param>
    //public void ShowEffect(string effectName)
    //{
    //    // 特效名无效
    //    if (string.IsNullOrEmpty(effectName))
    //    {
    //        return;
    //    }

    //    Transform tran = Player.mAnimator.transform.Find("Effect_000/" + effectName);
    //    if (tran)
    //    {
    //        tran.gameObject.SetActive(false);
    //        tran.gameObject.SetActive(true);
    //    }
    //}

    ///// <summary>
    ///// 玩家推进
    ///// </summary>
    ///// <param name="pos">推进到的位置</param>
    ///// <param name="pushTime">推进时间</param>
    //public void PlayerPush(Vector3 pos, float pushTime = 0.35f)
    //{
    //    float dis = Vector3.Distance(Player.transform.position, pos);

    //    mPushTime = pushTime;
    //    mPushSpeed = dis / pushTime;
    //    mPush = true;
    //}

    ///// <summary>
    ///// 是否正在播放动画
    ///// </summary>
    ///// <param name="playProgress">播放的进度(大于1.0f表示播放完成)</param>
    ///// <returns></returns>
    //public bool IsPlaying(float playProgress = 1.0f)
    //{
    //    if (Player == null)
    //    {
    //        return false;
    //    }

    //    // 获取动画层 0 指Base Layer.
    //    AnimatorStateInfo stateinfo = Player.mAnimator.GetCurrentAnimatorStateInfo(0);
    //    if (stateinfo.loop)
    //    {
    //        return false;
    //    }
    //    else
    //    {
    //        if (stateinfo.normalizedTime >= playProgress)
    //        {
    //            return false;
    //        }
    //        else
    //        {
    //            return true;
    //        }
    //    }
    //}

    ///// <summary>
    ///// 是否处于连击中
    ///// </summary>
    ///// <param name="keylist">按键列表</param>
    ///// <returns>处于连击中的状态</returns>
    //private bool IsCombo(List<E_KeyType> keylist)
    //{
    //    if (keylist == null || keylist.Count < 1)
    //    {
    //        return false;
    //    }

    //    for (int aci = 0; aci < mAllComboInfos.Count; aci++)
    //    {
    //        ComboData comboData = mAllComboInfos[aci];
    //        mCurCombos.Clear();

    //        for (int i = 0; i < keylist.Count; i++)
    //        {
    //            if (i >= comboData.comboInfos.Count)
    //            {
    //                return true;
    //            }

    //            KeyComboInfo comboInfo = comboData.comboInfos[i];

    //            if (keylist[i] != comboInfo.Key)
    //            {
    //                break;
    //            }
    //            else
    //            {
    //                // 已经播放过的动作不再加入列表
    //                if (i >= mCurComboIndex)
    //                {
    //                    mCurCombos.Add(comboInfo);
    //                }
    //            }
    //        }

    //        // 匹配到连招，中断
    //        if (mCurCombos.Count > 0)
    //        {
    //            return true;
    //        }
    //    }

    //    return true;
    //}
}

public enum SkillBtnIconType
{
    Yanling1 = 1,
    Yanling2 = 2,
    Yanling3 = 3,
    Heti1 = 4,
    Heti2 = 5,
    Heti3 = 6,
    Heti4 = 7,
    Putong = 8,
    Bisha = 9,
    Shanbi = 10,
    Count,
}