Main/Assets/Code/Logic/_Required/Input/Handler/RollDodgeHandler.cs

using Thousandto.Cfg.Data;
using Thousandto.Code.Center;
using Thousandto.Code.Logic.LocalPlayerBT;
using Thousandto.Core.Asset;
using Thousandto.Core.Framework;
using Thousandto.Core.Base;
using Thousandto.Plugins.Common.UniScene;
using System;
using System.Collections.Generic;

using System.Text;
using UnityEngine;

namespace Thousandto.Code.Logic
{
    /// <summary>
    /// 角色翻滚处理器
    /// </summary>
    public class RollDodgeHandler
    {
        private float _cdTime = 3f;
        private float _rollTime = 0.5f;
        private float _frontRollTime = 0f;

        public float RollCDTime
        {
            get
            {
                return _cdTime;
            }
        }
        public float RollTime
        {
            get
            {
                return _rollTime;
            }
        }
        public float CurRollCD
        {
            get
            {
                float time = Time.realtimeSinceStartup - _frontRollTime;
                if(time < _cdTime)
                {
                    return _cdTime - time;
                }
                return 0f;
            }
        }

        public void OnServerRolldodge()
        {
            _frontRollTime = Time.realtimeSinceStartup;
        }

        public void Initialize()
        {
        }

        public void Uninitialize()
        {

        }

        public void DoRollDadge()
        {
            var lp = GameCenter.GameSceneSystem.GetLocalPlayer();
            if (lp == null && lp.Scene.navigator != null)
                return;

            if (!lp.CanRollDodge())
            {
                GameCenter.MsgPromptSystem.ShowPrompt(Thousandto.Cfg.Data.DeclareMessageString.Get(Thousandto.Cfg.Data.DeclareMessageString.C_ROLLDOGEFAILED_STATE));
                return;
            }

            if(Time.realtimeSinceStartup - _frontRollTime < _cdTime)
            {
                GameCenter.MsgPromptSystem.ShowPrompt(Thousandto.Cfg.Data.DeclareMessageString.Get(Thousandto.Cfg.Data.DeclareMessageString.C_ROLLDOGEFAILED_CDING));
                return;
            }

            var cfg = DeclareRollDodge.Get(lp.PropMoudle.RollDodgeLevel);
            if (cfg == null)
                return;
            _rollTime = cfg.ExecuteTime / 1000f;
            _cdTime = cfg.CdTime / 1000f + 0.5f;

            var dir2D = lp.GetMovingDirection2d();
            if (GameCenter.InputSystem.JoystickHandler.Draging)
            {
                dir2D = GameCenter.InputSystem.JoystickHandler.CurWorldJoystickDir2d;
            }
            else if (GameCenter.WarningFiledManager.FiledList.Count > 0)
            {
                var tarCircle = new Math2d.Circle(lp.Position2d, lp.PropMoudle.LogicBodyRadius);
                for (int i = 0; i < GameCenter.WarningFiledManager.FiledList.Count; ++i)
                {
                    bool isBreak = false;
                    var warInst = GameCenter.WarningFiledManager.FiledList[i];
                    switch (warInst.AreaType)
                    {
                        case SkillTargetArea.Rectangle:
                            {
                                float width = warInst.SkillParam1 + 0.2f;
                                float height = warInst.SkillParam2 + 0.2f;

                                var instForward = warInst.Forward2D.normalized;
                                var instForward3d = new Vector3(instForward.x, 0f, instForward.y);
                                var skillAreaShape = new Math2d.Obb(warInst.Position2D, instForward, width / 2, height, 0);
                                if (Math2d.CollisionTest(skillAreaShape, tarCircle))
                                {
                                    isBreak = true;
                                    if(UnityEngine.Random.Range(0,2) == 0)
                                    {
                                        //左
                                        var dir3d = Quaternion.AngleAxis(90f, Vector3.up) * instForward3d;
                                        dir2D = new Vector2(dir3d.x, dir3d.z);
                                    }
                                    else
                                    {
                                        //右
                                        var dir3d = Quaternion.AngleAxis(-90f, Vector3.up) * instForward3d;
                                        dir2D = new Vector2(dir3d.x, dir3d.z);
                                    }
                                }
                            }
                            break;
                        case SkillTargetArea.FanShaped:
                            {
                                int angle = (int)warInst.SkillParam1;
                                float radius = warInst.SkillParam2 + 0.2f;

                                var instForward = warInst.Forward2D.normalized;
                                var instForward3d = new Vector3(instForward.x, 0f, instForward.y);
                                var skillAreaShape = new Math2d.Sector(warInst.Position2D, radius, instForward, angle * Mathf.Deg2Rad * 0.5f);
                                if (Math2d.CollisionTest(ref skillAreaShape, ref tarCircle))
                                {
                                    isBreak = true;
                                    if (UnityEngine.Random.Range(0, 2) == 0)
                                    {
                                        //左
                                        var dir3d = Quaternion.AngleAxis(90f, Vector3.up) * instForward3d;
                                        dir2D = new Vector2(dir3d.x, dir3d.z);
                                    }
                                    else
                                    {
                                        //右
                                        var dir3d = Quaternion.AngleAxis(-90f, Vector3.up) * instForward3d;
                                        dir2D = new Vector2(dir3d.x, dir3d.z);
                                    }
                                }
                            }
                            break;
                        case SkillTargetArea.Round:
                            {
                                float radius = warInst.SkillParam1 + 0.2f;
                                var skillCircle = new Math2d.Circle(warInst.Position2D, radius + 1f);
                                if (Math2d.CollisionTest(ref skillCircle, ref tarCircle))
                                {
                                    //圆形朝后翻滚
                                    dir2D = lp.Position2d - warInst.Position2D;
                                    isBreak = true;

                                    if(lp.CurSelectedTargetId == warInst.Host.ID)
                                    {
                                        var host = warInst.Host as Character;
                                        if (host != null && host.skillManager.CurUseSkill != null)
                                        {
                                            //暂停挂机
                                            var time = host.skillManager.CurUseSkill.SkillVisualCfg.FrameCount * Skill.OneFrameTime - warInst.LifeTimer;
                                            GameCenter.LuaSystem.Adaptor.SetMandatePause(time);
                                        }
                                    }
                                }
                            }
                            break;
                    }

                    if(isBreak)
                    {
                        break;
                    }
                }
            }
            dir2D = dir2D.normalized;
            Vector2 tagPos2d = lp.Position2d + dir2D * ((cfg.MaxDis / 100f) - 0.5f);
            tagPos2d = lp.Scene.navigator.CalculationRayCastPos2d(lp.Position2d, tagPos2d);
            lp.skillManager.Clear();
            NetHandler.SendMessage_RollDodge(lp.Position2d, tagPos2d);
            lp.Action_RollDodge(tagPos2d);
        }
    }
}