// Enable IntelligentRoute AutoPF integration (ported from original PW client).
// 启用智能寻路 AutoPF 集成（从原版完美客户端移植）。
#define ENABLE_CEC_INTELLIGENT_ROUTE

using CSNetwork.GPDataType;
using System;
using System.Collections.Generic;
using UnityEngine;
using BrewMonster.Managers;
using Types = BrewMonster.Scripts.CECHPWorkMove.DestTypes;
using BrewMonster.Network;

namespace BrewMonster.Scripts
{
    public class CECHPWorkMove : CECHPWork
    {
        public static class DestTypes
        {
            public const int DEST_2D = 0,
            DEST_3D = 1,
            DEST_DIR = 2,
            DEST_PUSH = 3,
            DEST_STANDJUMP = 4,
            DEST_AUTOPF = 5;        //	Movement type
        }
        const float A3D_PI = 3.1415926535f;
        static float DEG2RAD(float deg) => ((deg) * A3D_PI / 180.0f);
        static float pitch_ang_wing => DEG2RAD(45.0f);
        static float pitch_ang_fly_sword => DEG2RAD(25.0f);
        static float lean_max_ang => DEG2RAD(45.0f);
        static float ang_vel_fly => 1.0f / DEG2RAD(60.0f);
        static float ang_vel_swim => 1.0f / DEG2RAD(180.0f);
        static float pitch_co_wing => pitch_ang_wing / A3D_PI;
        static float pitch_co_fly_sword => pitch_ang_fly_sword / A3D_PI;
        const float sidle_co = .5f;
        static float sidle_co_r => 1.0f - sidle_co;
        static float push_pitch_vel_wing => pitch_ang_wing / 0.5f;
        static float push_pitch_vel_fly_sword => pitch_ang_fly_sword / 0.5f;

        private const uint MoveInputMask = 0x0F; // MD_FORWARD | MD_RIGHT | MD_BACK | MD_LEFT

        protected A3DVECTOR3 m_vMoveDest; //	Move destination position or direction
        protected int m_iDestType;    //	Destination type
        protected bool m_bHaveDest;   //	true, have destination
        protected bool m_bMeetSlide;  //	true, meet slide
        protected A3DVECTOR3 m_vCurDir;       //	Current move direction
        protected bool m_bReadyCancel;    //	true, ready to cancel
        protected bool m_bGliding;        //	glide
        protected float m_fGlideTime;
        protected float m_fGlideSpan;
        protected float m_fGlideAng;
        protected float m_fGlideVel;  //	glide angular vel
        protected float m_fGlidePitch;    //	glide pitch angle
        protected float m_fCurPitch;
        protected float m_fPushPitch;
        protected float m_fPushLean;
        protected A3DVECTOR3 vDir = new A3DVECTOR3();


        protected bool m_bUseAutoMoveDialog;  //  Auto move
        protected float m_fAutoHeight;    //  Height of auto moving destination 
        protected bool m_bAutoLand;   //  Auto land when arrive at destination
        protected bool m_bAutoFly;        //  Auto fly
        protected bool m_bReachedHeight;// Player reached specified height
        protected bool m_bAutoFlyPending;     //  Mark whether a fly command had been executed

        protected int m_iNPCTempleId;
        protected int m_iTaskId;
        protected bool m_bSwitchTo2D;

        protected bool m_bResetAutoPF;

        /// <summary>
        /// RMap marks deep water as blocked; AutoPF snaps goals to nearest land. If the real mission point
        /// (m_vMoveDest) is still farther horizontally (e.g. in water), continue with DEST_2D after AutoPF ends.
        /// </summary>
        const float AutoPF_WorldDestContinueDistH = 0.1f;

        /// <summary>Horizontal radius to treat DEST_2D as arrived (swim/fly overshoot logic often never fires).</summary>
        const float Dest2D_ArrivalDistH = 0.1f;

        public CECHPWorkMove(CECHPWorkMan pWorkMan) : base(Host_work_ID.WORK_MOVETOPOS, pWorkMan)
        {
            m_dwMask = Work_mask.MASK_MOVETOPOS;
            m_dwTransMask = Work_mask.MASK_STAND | Work_mask.MASK_TRACEOBJECT | Work_mask.MASK_FOLLOW;
            Reset();
        }

        public CECHPWorkMove(int iWorkID, CECHPWorkMan pWorkMan) : base(iWorkID, pWorkMan)
        {
        }

        //	Set destination position or direction
        public void SetDestination(int iDestType, A3DVECTOR3 vMoveDest)
        {
            m_iDestType = iDestType;
            m_vMoveDest = vMoveDest;
            m_bHaveDest = true;
            m_bGliding = false;
            //m_pHost.SetAdjustOrient(false);	//	2014-9-10 ���ı��� CECHPWorkMove ������ʱ�򶼻���ô˺������ᵼ������ʱ��ͨ�� SetDestDirAndUp ���ö�����ij������ʧЧ��
            //	���ַ���Ϊ�����ɡ�����ӽ�������ͷź����ϰ�ס'A'��'D'���ƶ�������ס���ţ�����������ʩ������ƫ��Ŀ��������ƶ��������γ��ԣ�

            //���������Ϣ
            m_iTaskId = 0;
            m_iNPCTempleId = 0;
            ResetUseAutoPF();

            if (iDestType == Types.DEST_DIR)
            {
                m_vCurDir = vMoveDest;
                if (m_bUseAutoMoveDialog)
                {
                    m_bUseAutoMoveDialog = false;
                    m_bAutoLand = false;
                    m_fAutoHeight = -1.0f;
                    m_bAutoFly = false;
                    m_bReachedHeight = true;
                    m_bAutoFlyPending = false;
                }
            }
            else if (iDestType == Types.DEST_2D || iDestType == Types.DEST_3D)
            {
                m_vCurDir = vMoveDest - m_pHost.GetPos();
                m_vCurDir.y = 0.0f;
                if (m_vCurDir.Normalize() > 1e-4f)
                    OrientHostHorizontal(m_vCurDir);
            }
            else if (IsAutoPF())
            {
                // Search() has not run yet — GetCurDest() is wrong here; use goal direction until first waypoint.
                // Search() 尚未执行时 GetCurDest() 不可靠；先用目标方向，寻路成功后再对准第一个节点。
                m_vCurDir = vMoveDest - m_pHost.GetPos();
                m_vCurDir.y = 0.0f;
                if (m_vCurDir.Normalize() > 1e-4f)
                    OrientHostHorizontal(m_vCurDir);
                if (m_bUseAutoMoveDialog)
                {
                    //	�˴����� m_bUseAutoMoveDialog���� SetUseAutoMoveDialog ��˵��
                    m_bUseAutoMoveDialog = false;
                    m_bAutoLand = false;
                    m_fAutoHeight = -1.0f;
                    m_bAutoFly = false;
                    m_bReachedHeight = true;
                    m_bAutoFlyPending = false;
                }
            }

            // Swim/fly velocity carry-over skews the first AirWaterMove/GroundMove frame on new click.
            if (iDestType == Types.DEST_2D || iDestType == Types.DEST_3D || iDestType == Types.DEST_AUTOPF)
            {
                m_pHost.m_vVelocity.x = 0f;
                m_pHost.m_vVelocity.z = 0f;
            }

            // TO DO: fix later
            //if (m_pHost.m_pMoveTargetGFX)
            //{
            //    if (iDestType != DEST_PUSH)
            //        m_pHost.m_pMoveTargetGFX.Stop();
            //}
        }

        void ResetUseAutoPF()
        {
            m_bResetAutoPF = true;
        }

        //	Tick routine
        public override bool Tick(float dwDeltaTime)
        {
            UpdateResetUseAutoPF();
            if (m_bSwitchTo2D)
            {
                SwitchToDest2D();
                m_bSwitchTo2D = false;
                return true;
            }

#if ENABLE_CEC_INTELLIGENT_ROUTE
            if (IsAutoPF())
            {
                if (global::BrewMonster.Scripts.CECIntelligentRoute.Instance().IsIdle())
                {
                    // C++: AutoPF not ready yet, wait next tick for SwitchTo2D (EC_HPWorkMove.cpp).
                    // C++：智能寻路模式未成功时，等待下个 Tick 切换到 DEST_2D 模式。
                    return true;
                }
                // EC_HPWorkMove.cpp: mid-air AutoPF → reset route and switch to DEST_2D next tick.
                if (m_pHost.IsFlying())
                {
                    global::BrewMonster.Scripts.CECIntelligentRoute.Instance().ResetSearch();
                    m_bSwitchTo2D = true;
                    return true;
                }
            }
#endif

            base.Tick(dwDeltaTime);

            // Draw red line showing the path the player has to move
            // 绘制红色线条显示玩家需要移动的路径
            if (m_bHaveDest)
            {
                A3DVECTOR3 curPos = m_pHost.GetPos();
                Vector3 vCurPos = new Vector3(curPos.x, curPos.y, curPos.z);
#if ENABLE_CEC_INTELLIGENT_ROUTE
                if (IsAutoPF() && global::BrewMonster.Scripts.CECIntelligentRoute.Instance().IsMoveOn())
                {
                    // Draw AutoPF path in red
                    // 绘制 AutoPF 路径（红色）
                    List<Vector3> path = global::BrewMonster.Scripts.CECIntelligentRoute.Instance().GetFullPath();
                    if (path != null && path.Count > 1)
                    {
                        // Draw lines connecting all path nodes (red)
                        // 绘制连接所有路径节点的线（红色）
                        for (int i = 0; i < path.Count - 1; i++)
                        {
                            Vector3 from = path[i];
                            Vector3 to = path[i + 1];
                            Debug.DrawLine(from, to, Color.red, 0.1f, false);
                        }
                        // Draw line from current position to first path node (red)
                        // 绘制从当前位置到第一个路径节点的线（红色）
                        if (path.Count > 0)
                        {
                            Debug.DrawLine(vCurPos, path[0], Color.red, 0.1f, false);
                        }
                    }
                }
                else
#endif
                {
                    // Draw straight line to destination (red)
                    // 绘制到目的地的直线（红色）
                    Vector3 vDest = new Vector3(m_vMoveDest.x, m_vMoveDest.y, m_vMoveDest.z);
                    Debug.DrawLine(vCurPos, vDest, Color.red, 0.1f, false);
                }
            }

            if (m_pHost.IsRooting())
                return true;

            if (m_pHost.IsDead())
            {
                Finish();
                return true;
            }

            if (m_bUseAutoMoveDialog)
            {
                if (m_pHost.IsFlying())
                {
                    m_bAutoFly = false;
                    m_bAutoFlyPending = false;
                }

                if (m_bAutoFly && !m_bAutoFlyPending && !m_pHost.IsFlying())
                {
                    if (m_pHost.CmdFly(true))
                    {
                        m_bAutoFly = false;
                        m_bAutoFlyPending = true;
                    }
                }
            }
            else
            {
                // Make sure 'Win_AutoPlay' dialog doesn't show up
                /*  CECGameUIMan pGameUI = g_pGame.GetGameRun().GetUIManager().GetInGameUIMan();
                  pGameUI.AutoMoveShowDialog(false);*/
            }

            // 如果目标是任务 NPC（模板ID），当接近时切换到 WorkTrace（对话/交互）。
            // English: If destination is a task NPC (template id), handoff to WorkTrace (talk/interact) when close.
            if ((m_vMoveDest - m_pHost.GetPos()).MagnitudeH() <= 5.0f)
            {
                if (m_iNPCTempleId != 0)
                {
                    // Find live NPC in scene by template id.
                    // 按模板ID在场景中查找活体 NPC。
                    CECNPC pNPC = EC_ManMessageMono.Instance != null
                        ? EC_ManMessageMono.Instance.CECNPCMan.FindNPCByTemplateID(m_iNPCTempleId)
                        : null;

                    if (pNPC != null && m_pHost.SelectTarget(pNPC.GetNPCID()))
                    {
                        CECHPWorkTrace pWork = m_pWorkMan.CreateNPCTraceWork(pNPC, m_iTaskId);
                        if (pWork != null)
                        {
                            // Prevent auto land before switching.
                            // 防止在切换前自动降落。
                            m_bAutoLand = false;
                            Finish();
                            m_pWorkMan.SetPostTickCommand(new CECHPWorkPostTickRunWorkCommand(pWork, true));
                            return true;
                        }
                    }
                }
            }
            //m_pHost.SetGroundInfoClient();
            float fDeltaTime = dwDeltaTime;
            if (m_pHost.m_iMoveEnv == (int)MoveEnvironment.MOVEENV_GROUND ||
                m_pHost.m_iMoveEnv == (int)MoveEnvironment.MOVEENV_WATER && m_pHost.IsJumping() && (m_pHost.m_CDRInfo.vAbsVelocity.y > 0 || m_pHost.m_CDRInfo.fYVel > 0))
            {
                //	Play appropriate actions
                if (!m_pHost.IsJumping() && !m_pHost.IsPlayingAction((int)PLAYER_ACTION_TYPE.ACT_TRICK_RUN) &&
                    m_pHost.m_iMoveMode != (int)MoveMode.MOVE_SLIDE && !m_bMeetSlide)
                {
                    int iAction = m_pHost.GetMoveStandAction(true);
                    m_pHost.PlayAction(iAction, false);
                }

                Tick_Walk(fDeltaTime);
            }
            else    //	(m_pHost.m_iMoveEnv == CECPlayer::MOVEENV_AIR || m_pHost.m_iMoveEnv == CECPlayer::MOVEENV_WATER)
            {
                m_pHost.ResetJump();

                //	Play appropriate actions
                if (!m_bGliding)
                {
                    int iAction = m_pHost.GetMoveStandAction(true);
                    m_pHost.PlayAction(iAction, false);
                }

                Tick_FlySwim(fDeltaTime);
            }

            return true;
        }
        //	Reset work
        public override void Reset()
        {
            base.Reset();

            m_iDestType = DestTypes.DEST_2D;
            m_bHaveDest = false;
            m_bMeetSlide = false;
            m_bReadyCancel = false;
            m_bGliding = false;
            m_fGlideTime = 0;
            m_fCurPitch = 0;
            m_fPushPitch = 0;
            m_fPushLean = 0;

            m_bUseAutoMoveDialog = false;
            m_fAutoHeight = -1.0f;
            m_bAutoLand = false;
            m_bAutoFly = false;
            m_bReachedHeight = true;
            m_bAutoFlyPending = false;

            m_iNPCTempleId = 0;
            m_iTaskId = 0;
            m_bSwitchTo2D = false;

            m_bResetAutoPF = false;
        }
        //	Work is cancel
        public override void Cancel()
        {
            //if (m_pHost.m_pMoveTargetGFX)
            //    m_pHost.m_pMoveTargetGFX.Stop();

            //A3DVECTOR3 vDir = m_pHost.GetDir();
            //vDir.y = 0;
            //vDir.Normalize();
            //if (!vDir.IsZero())
            //{
            //    m_pHost.StopModelMove(vDir, g_vAxisY, 0);
            //}

            ClearResetUseAutoPF();
            //if (CECIntelligentRoute::Instance().IsUsageMove())
            //{
            //    if (!CECIntelligentRoute::Instance().IsIdle())
            //    {
            //        CECIntelligentRoute::Instance().ResetSearch();
            //        m_bSwitchTo2D = true;   //	Æô¶¯·ÉÐÐÖжϺó»Ö¸´Ê±¡¢ÐèÒªÇл»µ½ DEST_2D ģʽ
            //    }
            //}
            base.Cancel();
            //AP_ActionEvent(AP_EVENT_MOVEFINISHED);
        }

        //	This work is do player moving ?
        public override bool IsMoving() { return true; }
        //	Copy work data
        public override bool CopyData(CECHPWork pWork)
        {
            if (!base.CopyData(pWork))
                return false;

            CECHPWorkMove pSrc = pWork as CECHPWorkMove;

            m_iDestType = pSrc.m_iDestType;
            m_bHaveDest = pSrc.m_bHaveDest;
            m_bMeetSlide = pSrc.m_bMeetSlide;
            m_bReadyCancel = pSrc.m_bReadyCancel;
            m_bGliding = pSrc.m_bGliding;
            m_fGlideTime = pSrc.m_fGlideTime;
            m_fGlideSpan = pSrc.m_fGlideSpan;
            m_fGlideAng = pSrc.m_fGlideAng;
            m_fGlideVel = pSrc.m_fGlideVel;
            m_fGlidePitch = pSrc.m_fGlidePitch;
            m_fCurPitch = pSrc.m_fCurPitch;
            m_fPushPitch = pSrc.m_fPushPitch;
            m_fPushLean = pSrc.m_fPushLean;
            m_iDestType = pSrc.m_iDestType;
            m_vMoveDest = pSrc.m_vMoveDest;
            m_vCurDir = pSrc.m_vCurDir;

            m_bUseAutoMoveDialog = pSrc.m_bUseAutoMoveDialog;
            m_fAutoHeight = pSrc.m_fAutoHeight;
            m_bAutoLand = pSrc.m_bAutoLand;
            m_bAutoFly = pSrc.m_bAutoFly;
            m_bReachedHeight = pSrc.m_bReachedHeight;
            m_bAutoFlyPending = pSrc.m_bAutoFlyPending;

            m_iNPCTempleId = pSrc.m_iNPCTempleId;
            m_iTaskId = pSrc.m_iTaskId;
            m_bSwitchTo2D = pSrc.m_bSwitchTo2D;

            m_bResetAutoPF = pSrc.m_bResetAutoPF;
            return true;
        }

        //	Play move target effect
        public void PlayMoveTargetGFX(A3DVECTOR3 vPos, A3DVECTOR3 vNormal)
        {

        }

        //	User press cancel button
        public void PressCancel() { m_bReadyCancel = true; }

        public void SetUseAutoMoveDialog(bool bUseAutoMoveDialog)
        {
            m_bUseAutoMoveDialog = bUseAutoMoveDialog;
        }

        public bool GetUseAutoMoveDialog() { return m_bUseAutoMoveDialog; }

        /// <summary>Matches C++ CECHPWorkMove::GetAutoMove — must not always return true or input stays "auto" forever.</summary>
        public bool GetAutoMove()
        {
            if (m_bUseAutoMoveDialog)
                return true;
#if ENABLE_CEC_INTELLIGENT_ROUTE
            if (IsAutoPF())
            {
                var r = global::BrewMonster.Scripts.CECIntelligentRoute.Instance();
                return r.IsUsageMove() && !r.IsIdle();
            }
#endif
            return false;
        }

        void SetAutoLand(bool bAutoLand) { m_bAutoLand = bAutoLand; }
        bool GetAutoLand() { return m_bAutoLand; }

        void SetAutoHeight(float fHeight) { m_fAutoHeight = fHeight; m_bAutoFly = true; m_bReachedHeight = false; }
        float GetAutoHeight() { return m_fAutoHeight; }
        bool IsAutoFly() { return m_bAutoFly; }

        bool IsAutoPF() { return m_iDestType == Types.DEST_AUTOPF; }

        //	Finish work
        public void Finish()
        {
            m_bFinished = true;
            Cancel();

            // Close 'Win_AutoPlay' dialog if it exists
            //CECGameUIMan* pGameUI = g_pGame.GetGameRun().GetUIManager().GetInGameUIMan();
            //pGameUI.AutoMoveShowDialog(false);

            if (m_bUseAutoMoveDialog)
            {
                if (m_bAutoLand)
                {
                    m_bAutoLand = false;
                    if (EC_Game.GetGameRun().GetHostPlayer().IsFlying())
                        EC_Game.GetGameRun().GetHostPlayer().CmdFly(false);
                }

                m_bUseAutoMoveDialog = false;
                m_fAutoHeight = -1.0f;
                m_bAutoFly = false;
                m_bReachedHeight = true;
            }

            //�������׷������
            m_iNPCTempleId = 0;
            m_iTaskId = 0;
        }

        public void SetTaskNPCInfo(int tid, int taskid)
        {
            m_iNPCTempleId = tid;
            m_iTaskId = taskid;
        }

        void SwitchToDest2D()
        {
            int tid, taskid;
            tid = m_iNPCTempleId;
            taskid = m_iTaskId;
            //CECGameUIMan* pGameUI = g_pGame.GetGameRun().GetUIManager().GetInGameUIMan();
            //pGameUI.SetAutoMoveShowDialogTarget((int)m_vMoveDest.x, (int)m_vMoveDest.z);
            SetDestination(CECHPWorkMove.DestTypes.DEST_2D, m_vMoveDest);
            SetTaskNPCInfo(tid, taskid);
            SetUseAutoMoveDialog(true);
        }

#if ENABLE_CEC_INTELLIGENT_ROUTE
        /// <returns>True if switched to direct 2D leg — caller must not Finish() this frame.</returns>
        bool TryContinueAutoPFToWorldDestDirect()
        {
            A3DVECTOR3 p = m_pHost.GetPos();
            float dx = m_vMoveDest.x - p.x;
            float dz = m_vMoveDest.z - p.z;
            if (dx * dx + dz * dz <= AutoPF_WorldDestContinueDistH * AutoPF_WorldDestContinueDistH)
                return false;

            int tid = m_iNPCTempleId;
            int taskid = m_iTaskId;
            global::BrewMonster.Scripts.CECIntelligentRoute.Instance().ResetSearch();
            SetDestination(DestTypes.DEST_2D, m_vMoveDest);
            SetTaskNPCInfo(tid, taskid);
            SetUseAutoMoveDialog(true);
            return true;
        }
#endif

        /// <summary>
        /// Swim/fly DEST_2D often never satisfies the overshoot branch; ground can miss when vTPNormal is zero.
        /// Finishes the move work so GetAutoMove() goes false and the player can steer again.
        /// </summary>
        bool TryFinishDest2DIfArrived(A3DVECTOR3 vCurPos, float stopSpeed, int iMoveMode, bool flySwimAddRun)
        {
            if (m_iDestType != DestTypes.DEST_2D)
                return false;
            float dx = m_vMoveDest.x - vCurPos.x;
            float dz = m_vMoveDest.z - vCurPos.z;
            if (dx * dx + dz * dz > Dest2D_ArrivalDistH * Dest2D_ArrivalDistH)
                return false;
            Finish();
            int mode = flySwimAddRun ? (iMoveMode | (int)GPMoveMode.GP_MOVE_RUN) : iMoveMode;
            m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), stopSpeed, mode);
            return true;
        }

        void OrientHostHorizontal(A3DVECTOR3 dirHorizontal)
        {
            if (dirHorizontal.IsZero())
                return;
            Vector3 d = EC_Utility.ToVector3(dirHorizontal);
            d.y = 0f;
            if (d.sqrMagnitude < 1e-8f)
                return;
            d.Normalize();
            m_pHost.SetDirAndUp(d, Vector3.up);
        }

#if ENABLE_CEC_INTELLIGENT_ROUTE
        /// <summary>After Search(), face the first path node so swim/air/walk doesn't use previous heading.</summary>
        void OrientHostToFirstAutoPFWaypoint()
        {
            var route = global::BrewMonster.Scripts.CECIntelligentRoute.Instance();
            if (!route.IsMoveOn())
                return;
            A3DVECTOR3 d = route.GetCurDest() - m_pHost.GetPos();
            d.y = 0f;
            if (d.Normalize() < 1e-4f)
                return;
            m_vCurDir = d;
            OrientHostHorizontal(d);
        }
#endif

        //	On first tick
        protected override void OnFirstTick()
        {
            m_pHost.m_iMoveMode = Move_Mode.MOVE_MOVE;
            //PlayMoveTargetGFX();

            if (m_pHost.m_iMoveEnv != CECPlayer.Move_environment.MOVEENV_AIR)
                m_pHost.ShowWing(false);

            if (!m_pHost.IsJumping())
            {
                int iAction = m_pHost.GetMoveStandAction(true);
                m_pHost.PlayAction(iAction, false);
            }
        }

        //	Tick routine of walking on ground
        protected bool Tick_Walk(float fDeltaTime)
        {
            A3DVECTOR3 vCurPos = m_pHost.GetPos();
            ref CDR_INFO cdr = ref m_pHost.m_CDRInfo;

            if (m_pHost.m_iMoveMode == (int)MoveMode.MOVE_SLIDE)
            {
                m_pHost.PlayAction((int)PLAYER_ACTION_TYPE.ACT_JUMP_LOOP, false);

                A3DVECTOR3 vDir;
                if (m_iDestType == DestTypes.DEST_DIR)
                {
                    vDir = m_vCurDir;
                }
                else if (m_iDestType == DestTypes.DEST_PUSH)
                {
                    vDir = GetCurrentModelDir();
                }
#if ENABLE_CEC_INTELLIGENT_ROUTE
                else if (IsAutoPF())
                {
                    vDir = global::BrewMonster.Scripts.CECIntelligentRoute.Instance().GetCurDest() - vCurPos;
                    vDir.y = 0.0f;
                    vDir.Normalize();
                }
#endif
                else
                {
                    vDir = m_vMoveDest - vCurPos;
                    vDir.y = 0.0f;
                    vDir.Normalize();
                }

                float fMaxSpeedV = 0.0f;
                m_bMeetSlide = m_pHost.m_MoveCtrl.MeetSlope(vDir, fMaxSpeedV);
                cdr.fYVel = EC_Utility.a_ClampFloor(cdr.fYVel, -fMaxSpeedV);
                if (m_pHost.m_GndInfo.bOnGround)
                    m_vCurDir = vDir;

                vCurPos = m_pHost.m_MoveCtrl.GroundMove(m_vCurDir, m_pHost.GetGroundSpeed(), fDeltaTime);
                if (m_pHost.m_MoveCtrl.MoveBlocked() >= 3)
                {
                    m_pHost.m_MoveCtrl.SetSlideLock(true);
                    cdr.fYVel = 0.0f;
                    Finish();
                    m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), m_pHost.GetGroundSpeed(), (int)GPMoveMode.GP_MOVE_SLIDE);
                }
                else
                {
                    m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));
#if ENABLE_CEC_INTELLIGENT_ROUTE
                    if (IsAutoPF() && global::BrewMonster.Scripts.CECIntelligentRoute.Instance().IsMoveOn())
                        global::BrewMonster.Scripts.CECIntelligentRoute.Instance().OnPlayerPosChange(vCurPos);
#endif
#if SHOW_AUTOMOVE_FOOTPRINTS
                    if (IsAutoPF() || m_iDestType == DestTypes.DEST_2D)
                        g_AutoPFFollowPoints.Add(vCurPos);
#endif
                    m_pHost.m_MoveCtrl.SendMoveCmd(
                        vCurPos,
                        2,
                        GPDataTypeHelper.g_vOrigin,
                        (cdr.vAbsVelocity),
                        (int)GPMoveMode.GP_MOVE_SLIDE);
                }
            }
            else if (!m_bMeetSlide)
            {
                float fSpeed = m_pHost.GetGroundSpeed();
                int iMoveMode = m_pHost.m_bWalkRun ? (int)GPMoveMode.GP_MOVE_RUN : (int)GPMoveMode.GP_MOVE_WALK;
                if (m_pHost.IsJumping())
                    iMoveMode = (int)GPMoveMode.GP_MOVE_JUMP;
                else if (!m_pHost.m_GndInfo.bOnGround)
                    iMoveMode = (int)GPMoveMode.GP_MOVE_FALL;

                if (m_bReadyCancel && m_pHost.m_GndInfo.bOnGround)
                {
                    Finish();
                    m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fSpeed, iMoveMode);
                    return true;
                }

                if ((GetMoveRelDirMask() & (uint)((CECHostPlayer.MOVE_DIR.MD_LEFT | CECHostPlayer.MOVE_DIR.MD_RIGHT | CECHostPlayer.MOVE_DIR.MD_FORWARD | CECHostPlayer.MOVE_DIR.MD_BACK))) != 0)
                    m_iDestType = DestTypes.DEST_PUSH;
                if (m_iDestType == DestTypes.DEST_2D)
                {
                    if (TryFinishDest2DIfArrived(vCurPos, fSpeed, iMoveMode, false))
                        return true;

                    float fDist;
                    if (m_pHost.m_GndInfo.bOnGround)
                    {
                        m_vCurDir = m_vMoveDest - vCurPos;
                        m_vCurDir.y = 0.0f;
                        fDist = m_vCurDir.Normalize();
                    }
                    else
                    {
                        fDist = (m_vMoveDest - vCurPos).MagnitudeH();
                    }

                    vCurPos = m_pHost.m_MoveCtrl.GroundMove(m_vCurDir, fSpeed, fDeltaTime, m_pHost.m_fVertSpeed);
                    UpdateFacingFromDelta(vCurPos);

                    if (m_pHost.m_MoveCtrl.MoveBlocked() >= 3)
                    {
                        cdr.fYVel = 0.0f;
                        Finish();
                        m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fSpeed, iMoveMode);
                    }
                    else if (cdr.vTPNormal != new A3DVECTOR3(0))
                    {
                        A3DVECTOR3 vMoveDelta = vCurPos - m_pHost.GetPos();
                        vMoveDelta.y = 0.0f;
                        float fMoveDist = vMoveDelta.Normalize();

                        if (fMoveDist >= fDist)
                        {
                            Finish();
                            m_bUseAutoMoveDialog = false;
                            m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));
                            m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fSpeed, iMoveMode);
                        }
                        else
                        {
                            m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));
                            m_pHost.m_MoveCtrl.SendMoveCmd(
                                vCurPos,
                                0,
                                m_vMoveDest,
                                (cdr.vAbsVelocity),
                                iMoveMode);
                        }
#if SHOW_AUTOMOVE_FOOTPRINTS
                        g_AutoPFFollowPoints.Add(vCurPos);
#endif
                    }
                    else
                    {
#if SHOW_AUTOMOVE_FOOTPRINTS
                        g_AutoPFFollowPoints.Add(vCurPos);
#endif
                        m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));
                        m_pHost.m_MoveCtrl.SendMoveCmd(
                            vCurPos,
                            1,
                            m_vMoveDest,
                            (cdr.vAbsVelocity),
                            iMoveMode);
                    }
                }
                else if (m_iDestType == DestTypes.DEST_DIR)
                {
                    vCurPos = m_pHost.m_MoveCtrl.GroundMove(m_vCurDir, fSpeed -0.5f, fDeltaTime, m_pHost.m_fVertSpeed);
                    UpdateFacingFromDelta(vCurPos);
                    m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));

                    if (m_pHost.m_MoveCtrl.MoveBlocked() >= 3)
                    {
                        cdr.fYVel = 0.0f;
                        Finish();
                        m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fSpeed, iMoveMode);
                    }
                    else if (m_pHost.m_GndInfo.bOnGround)
                    {
                        m_pHost.m_MoveCtrl.SendMoveCmd(
                            vCurPos,
                            2,
                            GPDataTypeHelper.g_vOrigin,
                            (cdr.vAbsVelocity),
                            iMoveMode);
                    }
                    else
                    {
                        m_pHost.m_MoveCtrl.SendMoveCmd(
                            vCurPos,
                            1,
                            m_vMoveDest,
                            (cdr.vAbsVelocity),
                            iMoveMode);
                    }
                }
                else if (m_iDestType == DestTypes.DEST_STANDJUMP)
                {
                    if (!m_pHost.IsJumping())
                    {
                        Finish();
                        m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fSpeed, iMoveMode);
                    }
                    else
                    {
                        vCurPos = m_pHost.m_MoveCtrl.GroundMove(GPDataTypeHelper.g_vOrigin, 0.0f, fDeltaTime, m_pHost.m_fVertSpeed);  
                        m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));

                        if (m_pHost.m_MoveCtrl.MoveBlocked() >= 3)
                        {
                            m_pHost.ResetJump();
                            Finish();
                            m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fSpeed, iMoveMode);
                        }
                        else
                        {
                            m_pHost.m_MoveCtrl.SendMoveCmd(
                                vCurPos,
                                0,
                                m_vMoveDest,
                                (cdr.vAbsVelocity),
                                iMoveMode);
                        }
                    }
                }
                else if (m_iDestType == DestTypes.DEST_PUSH)
                {
                    Vector3 vMoveDir = Vector3.zero;//EC_Utility.ToVector3(GPDataTypeHelper.g_vOrigin);
                    fSpeed = m_pHost.GetGroundSpeed();
                    bool bFinish = false;

                    if (m_pHost.GetPushDir(ref vMoveDir, (uint)(CECHostPlayer.MOVE_DIR.MD_FORWARD | CECHostPlayer.MOVE_DIR.MD_BACK | CECHostPlayer.MOVE_DIR.MD_LEFT | CECHostPlayer.MOVE_DIR.MD_RIGHT), fDeltaTime))
                    {
                        if (vMoveDir != Vector3.zero)
                        {
                            m_pHost.SetRotationHP(vMoveDir);
                        }

                        vCurPos = m_pHost.m_MoveCtrl.GroundMove(EC_Utility.ToA3DVECTOR3(vMoveDir), fSpeed, fDeltaTime, m_pHost.m_fVertSpeed);
                        m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));
                    }
                    else
                    {
                        if (!m_bUseAutoMoveDialog)
                            bFinish = true;
                        else
                            m_iDestType = DestTypes.DEST_2D;
                    }

                    if (bFinish || m_pHost.m_MoveCtrl.MoveBlocked() >= 3)
                    {
                        if (m_pHost.m_MoveCtrl.MoveBlocked() >= 3)
                        {
                            cdr.fYVel = 0.0f;
                        }

                        Finish();
                        m_pHost.m_vVelocity.Clear();
                        m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fSpeed, iMoveMode);
                    }
                    else
                    {
                        m_pHost.m_vVelocity = EC_Utility.ToA3DVECTOR3(vMoveDir) * fSpeed;
                        m_pHost.m_MoveCtrl.SendMoveCmd(
                            vCurPos,
                            2,
                            GPDataTypeHelper.g_vOrigin,
                            m_pHost.m_vVelocity,
                            iMoveMode);
                    }
                }
                //else if (m_iDestType == DestTypes.DEST_PUSH)
                //{
                //    m_iDestType = DestTypes.DEST_2D;
                //}
#if ENABLE_CEC_INTELLIGENT_ROUTE
                else if (IsAutoPF())
                {
                    float fDist = 0.0f;
                    A3DVECTOR3 vCurDest = global::BrewMonster.Scripts.CECIntelligentRoute.Instance().GetCurDest();
                    if (m_pHost.m_GndInfo.bOnGround)
                    {
                        m_vCurDir = vCurDest - vCurPos;
                        m_vCurDir.y = 0.0f;
                        fDist = m_vCurDir.Normalize();
                    }
                    else
                    {
                        fDist = (vCurDest - vCurPos).MagnitudeH();
                    }

                    vCurPos = m_pHost.m_MoveCtrl.GroundMove(m_vCurDir, fSpeed, fDeltaTime, m_pHost.m_fVertSpeed);
                    if (!m_vCurDir.IsZero())
                    {
                        //m_pHost.StartModelMove(m_vCurDir, GPDataTypeHelper.g_vAxisY, 100);
                        //m_pHost.ChangeModelTargetDirAndUp(m_vCurDir, GPDataTypeHelper.g_vAxisY);
                        UpdateFacingFromDelta(vCurPos);
                    }

                    if (m_pHost.m_MoveCtrl.MoveBlocked() >= 3)
                    {
                        cdr.fYVel = 0.0f;
                        Finish();
                        m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fSpeed, iMoveMode);
                    }
                    else
                    {
                        m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));
                        global::BrewMonster.Scripts.CECIntelligentRoute.Instance().OnPlayerPosChange(vCurPos);
                        if (global::BrewMonster.Scripts.CECIntelligentRoute.Instance().IsPathFinished())
                        {
                            if (TryContinueAutoPFToWorldDestDirect())
                                return true;
                            Finish();
                            m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fSpeed, iMoveMode);
                        }
                        else
                        {
                            // C++: SendMoveCmd(vCurPos, 1, vCurDest, cdr.vAbsVelocity, iMoveMode)
                            m_pHost.m_MoveCtrl.SendMoveCmd(vCurPos, 1, vCurDest, cdr.vAbsVelocity, iMoveMode);
                        }
                    }
                }
#else
                else if (IsAutoPF())
                {
                    m_bSwitchTo2D = true;
                }
#endif
            }
            else
            {
                m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), m_pHost.GetGroundSpeed(), (int)GPMoveMode.GP_MOVE_SLIDE);
                Finish();
            }

            return true;
        }

        //	Tick routine of flying or swimming
        protected bool Tick_FlySwim(float fDeltaTime)
        {
            A3DVECTOR3 vCurPos = m_pHost.GetPos();
            int iMoveMode = (m_pHost.m_iMoveEnv == (int)MoveEnvironment.MOVEENV_AIR) ? (int)GPMoveMode.GP_MOVE_AIR : (int)GPMoveMode.GP_MOVE_WATER;

            float na, fMaxSpeed;
            bool bInAir;
            //Debug.LogError("Tick_FlySwim m_pHost.m_dwMoveRelDir = " + m_pHost.m_dwMoveRelDir);

            if (m_pHost.m_iMoveEnv == (int)MoveEnvironment.MOVEENV_AIR)
            {
                bInAir = true;
                na = CECHostMove.EC_NACCE_AIR;
                fMaxSpeed = m_pHost.GetFlySpeed();
            }
            else
            {
                bInAir = false;
                na = CECHostMove.EC_NACCE_WATER;
                fMaxSpeed = m_pHost.GetSwimSpeedSev();
            }

            if (m_bReadyCancel || m_bMeetSlide)
            {
                m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fMaxSpeed, iMoveMode | (int)GPMoveMode.GP_MOVE_RUN);
                Finish();
                return true;
            }

            // for auto move
            if (m_bUseAutoMoveDialog && m_fAutoHeight > 0.0f && m_iDestType != DestTypes.DEST_PUSH)
            {
                if (m_pHost.m_dwMoveRelDir == 0)
                {
                    if ((int)(vCurPos.y / 10.0f) == (int)m_fAutoHeight)
                    {
                        if (!m_bReachedHeight)
                        {
                            m_pHost.m_vVelocity.y = 0.0f;
                            m_pHost.m_dwMoveRelDir &= ~((uint)(CECHostPlayer.MOVE_DIR.MD_ABSUP | CECHostPlayer.MOVE_DIR.MD_ABSDOWN));
                            m_bReachedHeight = true;
                        }
                    }
                    else
                    {
                        if (!m_bReachedHeight)
                        {
                            if (vCurPos.y < m_fAutoHeight * 10.0f)
                            {
                                m_pHost.m_dwMoveRelDir &= ~((uint)(CECHostPlayer.MOVE_DIR.MD_ABSDOWN));
                                m_pHost.m_dwMoveRelDir |= ((uint)CECHostPlayer.MOVE_DIR.MD_ABSUP);
                            }
                            else if (vCurPos.y > m_fAutoHeight * 10.0f)
                            {
                                m_pHost.m_dwMoveRelDir &= ~((uint)(CECHostPlayer.MOVE_DIR.MD_ABSUP));
                                m_pHost.m_dwMoveRelDir |= (uint)CECHostPlayer.MOVE_DIR.MD_ABSDOWN;
                            }
                        }
                        else  // Auto adjust height, so we should refresh move height
                        {
                            m_fAutoHeight = vCurPos.y / 10.0f;
                        }
                    }
                }
                else    // Player manually set auto move height
                {
                    m_bReachedHeight = true;

                    m_fAutoHeight = vCurPos.y / 10.0f;
                }
            }

            if ((m_pHost.m_dwMoveRelDir & (uint)(CECHostPlayer.MOVE_DIR.MD_LEFT | CECHostPlayer.MOVE_DIR.MD_RIGHT | CECHostPlayer.MOVE_DIR.MD_FORWARD | CECHostPlayer.MOVE_DIR.MD_BACK)) != 0)
                m_iDestType = DestTypes.DEST_PUSH;

            ON_AIR_CDR_INFO cdr = m_pHost.m_AirCDRInfo;

            if (m_iDestType == DestTypes.DEST_DIR)
            {
                Vector3 vPushDir = Vector3.zero;
                m_pHost.GetPushDir(ref vPushDir, (uint)CECHostPlayer.MOVE_DIR.MD_ALL, 0);
                vPushDir.x = vPushDir.z = 0.0f;

                float fSpeed1H = m_pHost.m_vVelocity.MagnitudeH();
                float fSpeed1V = m_pHost.m_vVelocity.y;

                A3DVECTOR3 vMoveDirH = m_vMoveDest;
                float pa = CECHostMove.EC_PUSH_ACCE;

                float fSpeed2H = fSpeed1H + (pa + na) * fDeltaTime;
                if (Math.Abs(pa - 0) < float.Epsilon && fSpeed2H < 0.0f)
                    fSpeed2H = 0.0f;    //	Only resistance couldn't generate negative speed
                else if (fSpeed2H > fMaxSpeed)
                    fSpeed2H = fMaxSpeed;

                Glide(5.0f, vMoveDirH, fDeltaTime, bInAir);

                vMoveDirH = m_pHost.GetModelMoveDir();
                vMoveDirH.y = 0;
                vMoveDirH.Normalize();

                //	Vertical speed
                float fSpeed2V = CalcFlySwimVertSpeed(fSpeed1V, vPushDir.y, CECHostMove.EC_PUSH_ACCE, fDeltaTime);
                A3DVECTOR3 vVel2 = vMoveDirH * fSpeed2H + GPDataTypeHelper.g_vAxisY * fSpeed2V;

                //	Air/water move
                vCurPos = m_pHost.m_MoveCtrl.AirWaterMove(vVel2, fDeltaTime, bInAir);
                m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));
                m_pHost.m_vVelocity = vVel2;

                if (m_pHost.m_MoveCtrl.MoveBlocked() >= 3)
                {
                    Finish();
                    m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fMaxSpeed, iMoveMode | (int)GPMoveMode.GP_MOVE_RUN);
                }
                else
                    m_pHost.m_MoveCtrl.SendMoveCmd(vCurPos, 0, m_vMoveDest, vVel2, iMoveMode | (int)GPMoveMode.GP_MOVE_RUN);
            }
            else if (m_iDestType == DestTypes.DEST_2D)
            {
                if (TryFinishDest2DIfArrived(vCurPos, fMaxSpeed, iMoveMode, true))
                    return true;

                Vector3 vPushDir = Vector3.zero;
                m_pHost.GetPushDir(ref vPushDir, (uint)CECHostPlayer.MOVE_DIR.MD_ALL, 0f);
                vPushDir.x = vPushDir.z = 0.0f;

                float fSpeed1H = m_pHost.m_vVelocity.MagnitudeH();
                float fSpeed1V = m_pHost.m_vVelocity.y;

                A3DVECTOR3 vMoveDirH = m_vMoveDest - vCurPos;
                vMoveDirH.y = 0.0f;
                float fDistH = vMoveDirH.Normalize();

                float pa = 0.0f;

                //	Calculate the distance to reduce velocity to 0
                float s = -0.5f * fSpeed1H * fSpeed1H / na;
                if (fDistH > s - 0.01f)
                    pa = CECHostMove.EC_PUSH_ACCE;

                float fSpeed2H = fSpeed1H + (pa + na) * fDeltaTime;
                if (Math.Abs(pa - 0f) < float.Epsilon && fSpeed2H < 0.0f)
                    fSpeed2H = 0.0f;    //	Only resistance couldn't generate negative speed
                else if (fSpeed2H > fMaxSpeed)
                    fSpeed2H = fMaxSpeed;

                Glide(fDistH / fMaxSpeed, vMoveDirH, fDeltaTime, bInAir);

                vMoveDirH = m_pHost.GetModelMoveDir();
                vMoveDirH.y = 0;
                vMoveDirH.Normalize();

                //	Vertical speed
                float fSpeed2V = CalcFlySwimVertSpeed(fSpeed1V, vPushDir.y, CECHostMove.EC_PUSH_ACCE, fDeltaTime);
                A3DVECTOR3 vVel2 = vMoveDirH * fSpeed2H + GPDataTypeHelper.g_vAxisY * fSpeed2V;

                //	Air/water move
                vCurPos = m_pHost.m_MoveCtrl.AirWaterMove(vVel2, fDeltaTime, bInAir);

                if (m_pHost.m_MoveCtrl.MoveBlocked() >= 3)
                {
                    vVel2.Clear();
                    Finish();
                }
                else
                {
                    //	Reached destination ?
                    A3DVECTOR3 vMoveDelta = vCurPos - m_pHost.GetPos();
                    vMoveDelta.y = 0.0f;
                    float fMoveDistH = vMoveDelta.Normalize();
                    if (fMoveDistH >= fDistH)
                    {
                        vVel2.x = vVel2.z = 0.0f;
                        if (Math.Abs(vVel2.y - 0f) < float.Epsilon)
                        {
                            Finish();
                        }
                        else
                        {
                            if (m_bUseAutoMoveDialog)
                            {
                                Finish();
                                vVel2.y = 0.0f;
                            }

                            m_iDestType = DestTypes.DEST_PUSH;
                        }
                    }
                }

                m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));
                m_pHost.m_vVelocity = vVel2;

                if (m_bFinished)
                    m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), vVel2.Magnitude(), iMoveMode | (int)GPMoveMode.GP_MOVE_RUN);
                else
                    m_pHost.m_MoveCtrl.SendMoveCmd(vCurPos, 0, m_vMoveDest, vVel2, iMoveMode | (int)GPMoveMode.GP_MOVE_RUN);
            }
            else if (m_iDestType == DestTypes.DEST_3D)
            {
                float fSpeed1 = m_pHost.m_vVelocity.Magnitude();
                A3DVECTOR3 vMoveDir = m_vMoveDest - vCurPos;
                float fDist = vMoveDir.Normalize();

                float pa = 0.0f;

                //	Calculate the distance to reduce velocity to 0
                float s = -0.5f * fSpeed1 * fSpeed1 / na;
                if (fDist > s - 0.01f)
                    pa = CECHostMove.EC_PUSH_ACCE;

                float fSpeed2 = fSpeed1 + (pa + na) * fDeltaTime;
                if (Math.Abs(pa - 0f) < float.Epsilon && fSpeed2 < 0.0f)
                    fSpeed2 = 0.0f; //	Only resistance couldn't generate negative speed

                AAssist.a_Clamp(ref fSpeed2, -fMaxSpeed, fMaxSpeed);

                Vector3 vMoveDirH = new Vector3(vMoveDir.x, 0.0f, vMoveDir.z);
                if (vMoveDirH != Vector3.zero)
                {
                    //m_pHost.StartModelMove(vMoveDirH, g_vAxisY, 100);
                    //m_pHost.ChangeModelTargetDirAndUp(vMoveDirH, g_vAxisY);
                    m_pHost.SetRotationHP(vMoveDirH);
                }

                //	Air/water move
                //	A3DVECTOR3 vVel1 = vMoveDir * fSpeed1;
                A3DVECTOR3 vVel2 = vMoveDir * fSpeed2;
                vCurPos = m_pHost.m_MoveCtrl.AirWaterMove(vMoveDir, fSpeed2, fDeltaTime, bInAir, false);

                if (m_pHost.m_MoveCtrl.MoveBlocked() >= 3)
                {
                    vVel2.Clear();
                    Finish();
                }
                else
                {
                    //	Reached destination ?
                    A3DVECTOR3 vMoveDelta = vCurPos - m_pHost.GetPos();
                    float fMoveDist = vMoveDelta.Normalize();
                    if (fMoveDist >= fDist)
                    {
                        vVel2.Clear();
                        Finish();
                        m_bUseAutoMoveDialog = false;
                    }
                }

                m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));
                m_pHost.m_vVelocity = vVel2;

                if (m_bFinished)
                    m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fMaxSpeed, iMoveMode | (int)GPMoveMode.GP_MOVE_RUN);
                else
                    m_pHost.m_MoveCtrl.SendMoveCmd(vCurPos, 1, m_vMoveDest, vVel2, iMoveMode | (int)GPMoveMode.GP_MOVE_RUN);
            }
            else if (m_iDestType == DestTypes.DEST_PUSH)
            {
                Vector3 vPushDir = Vector3.zero;
                bool bPush = m_pHost.GetPushDir(ref vPushDir, (uint)(CECHostPlayer.MOVE_DIR.MD_FORWARD | CECHostPlayer.MOVE_DIR.MD_BACK | CECHostPlayer.MOVE_DIR.MD_LEFT | CECHostPlayer.MOVE_DIR.MD_RIGHT), fDeltaTime);

                if (!bPush)
                {
                    //vPushDir = m_pHost.GetCameraCoord().GetDir();
                    vPushDir.y = 0;
                    vPushDir.Normalize();
                }

                int nPitchDir = 0;
                if ((m_pHost.m_dwMoveRelDir & (int)(CECHostPlayer.MOVE_DIR.MD_LEFT | CECHostPlayer.MOVE_DIR.MD_RIGHT)) == 0)
                {
                    A3DVECTOR3 vOldDir = m_pHost.GetModelMoveDir();
                    vOldDir.y = 0;
                    vOldDir.Normalize();

                    A3DVECTOR3 vNewDir = EC_Utility.ToA3DVECTOR3(vPushDir);
                    vNewDir.y = 0;
                    vNewDir.Normalize();

                    float fAngle = A3DVECTOR3.DotProduct(vOldDir, vNewDir);
                    if (fAngle < 1.0f - 1e-4)
                    {
                        A3DVECTOR3 vUp_fAngle = A3DVECTOR3.CrossProduct(vOldDir, vNewDir);
                        if (vUp_fAngle.y > 0) nPitchDir = 1;
                        else nPitchDir = -1;
                        if ((m_pHost.m_dwMoveRelDir & (uint)CECHostPlayer.MOVE_DIR.MD_BACK) != 0)
                            nPitchDir = -nPitchDir;
                    }
                }
                if (m_pHost.m_dwMoveRelDir != 0)
                {
                    if ((m_pHost.m_dwMoveRelDir & ~(uint)(CECHostPlayer.MOVE_DIR.MD_ABSDOWN | CECHostPlayer.MOVE_DIR.MD_ABSUP)) != 0)
                    {
                        float fPitchDelta = (/*m_pHost.UsingWing()*/m_pHost.GetWingType() == enumWingType.WINGTYPE_WING ? push_pitch_vel_wing : push_pitch_vel_fly_sword) * fDeltaTime;

                        if ((m_pHost.m_dwMoveRelDir & (uint)CECHostPlayer.MOVE_DIR.MD_LEFT) != 0 || nPitchDir == -1)
                        {
                            if ((m_pHost.m_dwMoveRelDir & (uint)CECHostPlayer.MOVE_DIR.MD_BACK) != 0)
                                m_fPushPitch -= fPitchDelta;
                            else
                                m_fPushPitch += fPitchDelta;
                        }
                        else if ((m_pHost.m_dwMoveRelDir & (uint)CECHostPlayer.MOVE_DIR.MD_RIGHT) != 0 || nPitchDir == 1)
                        {
                            if ((m_pHost.m_dwMoveRelDir & (uint)CECHostPlayer.MOVE_DIR.MD_BACK) != 0)
                                m_fPushPitch += fPitchDelta;
                            else
                                m_fPushPitch -= fPitchDelta;
                        }
                        else if (m_fPushPitch > fPitchDelta)
                            m_fPushPitch -= fPitchDelta;
                        else if (m_fPushPitch < -fPitchDelta)
                            m_fPushPitch += fPitchDelta;
                        else
                            m_fPushPitch = 0;
                        // TO DO: fix after
                        //A3DVECTOR3 vRight = m_pHost.GetCameraCoord().GetRight();
                        //float fLean = -Math.Asin(m_pHost.GetCameraCoord().GetDir().y);
                        //AAssist.a_Clamp(ref fLean, -lean_max_ang, lean_max_ang);

                        //if (Math.Abs(fLean) > DEG2RAD(3.0f))
                        //{
                        //    vPushDir = a3d_RotatePosAroundAxis(vPushDir, vRight, fLean);
                        //    vUp = a3d_RotatePosAroundAxis(g_vAxisY, vRight, fLean);
                        //}
                        //else
                        //    vUp = EC_Utility.ToVector3(GPDataTypeHelper.g_vAxisY);

                        //float pitch_ang = /*m_pHost.UsingWing()*/ m_pHost.GetWingType() == enumWingType.WINGTYPE_WING ? pitch_ang_wing : pitch_ang_fly_sword;
                        //AAssist.a_Clamp(ref m_fPushPitch, -pitch_ang, pitch_ang);

                        //if (Math.Abs(m_fPushPitch) > DEG2RAD(4.0f))
                        //    vUp = a3d_RotatePosAroundAxis(vUp, vPushDir, m_fPushPitch);

                        //m_pHost.StartModelMove(vPushDir, vUp, 0);

                        if (vPushDir != Vector3.zero)
                        {
                            m_pHost.SetRotationHPWithTime(vPushDir, 0.1f);
                        }
                    }

                    //	if (bPush)
                    if (bPush || (m_pHost.m_dwMoveRelDir & (uint)(CECHostPlayer.MOVE_DIR.MD_ABSDOWN | CECHostPlayer.MOVE_DIR.MD_ABSUP)) != 0)
                    {
                        //	float pa = bPush ? EC_PUSH_ACCE : 0.0f;
                        float pa = CECHostMove.EC_PUSH_ACCE;
                        float na1 = m_pHost.m_iMoveEnv == (int)MoveEnvironment.MOVEENV_AIR ? CECHostMove.EC_NACCE_AIR : CECHostMove.EC_NACCE_WATER;
                        float fAccel = pa + na1;

                        float fSpeed1 = m_pHost.m_vVelocity.Magnitude();
                        float fSpeed2 = fSpeed1 + fAccel * fDeltaTime;
                        AAssist.a_Clamp(ref fSpeed2, 0.0f, fMaxSpeed);

                        //	Air/water move
                        Vector3 vVelDir = Vector3.zero;
                        if (bPush)
                            vVelDir = vPushDir;

                        if ((m_pHost.m_dwMoveRelDir & (uint)CECHostPlayer.MOVE_DIR.MD_ABSDOWN) != 0)
                        {
                            vVelDir += -EC_Utility.ToVector3(GPDataTypeHelper.g_vAxisY);
                            vVelDir.Normalize();
                        }
                        else if ((m_pHost.m_dwMoveRelDir & (uint)CECHostPlayer.MOVE_DIR.MD_ABSUP) != 0)
                        {
                            vVelDir += EC_Utility.ToVector3(GPDataTypeHelper.g_vAxisY);
                            vVelDir.Normalize();
                        }

                        //	A3DVECTOR3 vVel = vPushDir * fSpeed2;
                        Vector3 vVel = vVelDir * fSpeed2;
                        vCurPos = m_pHost.m_MoveCtrl.AirWaterMove(EC_Utility.ToA3DVECTOR3(vVel), fDeltaTime, bInAir);
                        if (m_pHost.m_MoveCtrl.MoveBlocked() >= 3)
                        {
                            Finish();
                            m_pHost.m_vVelocity.Clear();
                            m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fMaxSpeed, iMoveMode | (int)GPMoveMode.GP_MOVE_RUN);
                        }
                        else
                        {
                            m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));
                            if (m_bUseAutoMoveDialog)
                            {
                                m_fAutoHeight = vCurPos.y / 10.0f;
                            }
                            m_pHost.m_vVelocity = EC_Utility.ToA3DVECTOR3(vVel);
                            m_pHost.m_MoveCtrl.SendMoveCmd(vCurPos, 2, GPDataTypeHelper.g_vOrigin, EC_Utility.ToA3DVECTOR3(vVel), iMoveMode | (int)GPMoveMode.GP_MOVE_RUN);
                        }
                    }
                }
                else
                {
                    if (!m_bUseAutoMoveDialog)
                        Finish();
                    else
                        m_iDestType = DestTypes.DEST_2D;

                    m_fPushPitch = 0;
                    m_pHost.m_vVelocity.Clear();
                    m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), fMaxSpeed, iMoveMode | (int)GPMoveMode.GP_MOVE_RUN);
                }
            }
            else if (m_iDestType == DestTypes.DEST_STANDJUMP)
            {
                //	If host player fly off when jumping up, code will go here. In the
                //	case, just stop move work is well.
                Finish();
            }
            else if (IsAutoPF())
            {
                // EC_HPWorkMove.cpp Tick_FlySwim: AutoPF in air/water does not walk waypoints — drop path and use DEST_2D.
#if ENABLE_CEC_INTELLIGENT_ROUTE
                global::BrewMonster.Scripts.CECIntelligentRoute.Instance().ResetSearch();
#endif
                m_bSwitchTo2D = true;
            }
            return true;
        }
        
        //	Start gliding
        protected void Glide(float fMoveTime, A3DVECTOR3 vMoveDirH, float fDeltaTime, bool bFly)
        {

        }

        //	Calculate vertical speed when fly or swim
        protected float CalcFlySwimVertSpeed(float fSpeed1, float fPushDir, float fPushAccel, float fDeltaTime)
        {
            float pa = Math.Abs(fPushDir - 0.0f) > float.Epsilon ? fPushAccel : 0.0f;

            float na = 0.0f, fMaxSpeed;
            if (m_pHost.m_iMoveEnv == CECPlayer.Move_environment.MOVEENV_AIR)
            {
                na = CECHostMove.EC_NACCE_AIR;
                fMaxSpeed = m_pHost.GetFlySpeed();
            }
            else
            {
                na = CECHostMove.EC_NACCE_WATER;
                fMaxSpeed = m_pHost.GetSwimSpeedSev();
            }

            //	When player free fall into water, fSpeed1 may be >= fMaxSpeed
            if (Math.Abs(fSpeed1) > fMaxSpeed)
            {
                na *= 2.0f;
                if (fPushDir * fSpeed1 > 0.0f)
                    pa = 0.0f;
            }

            //	Vertical accelerate
            float fAccel = 0.0f;
            if (fPushDir > 0.0f)
                fAccel = pa + na;
            else if (fPushDir < 0.0f)
                fAccel = -(pa + na);
            else if (fSpeed1 > 0.0f)
                fAccel = na;
            else if (fSpeed1 < 0.0f)
                fAccel = -na;

            //	Vertical speed
            float fSpeed2 = fSpeed1 + fAccel * fDeltaTime;
            if (Math.Abs(pa - 0.0f) < float.Epsilon && fSpeed2 * fSpeed1 < 0.0f)
                fSpeed2 = 0.0f;

            //	If accelerate and speed on same direction, limit speed
            if (fAccel * fSpeed2 > 0.0f)
                AAssist.a_Clamp(ref fSpeed2, -fMaxSpeed, fMaxSpeed);

            return fSpeed2;
        }

        protected void ClearResetUseAutoPF()
        {
            m_bResetAutoPF = false;
        }
        protected void UpdateResetUseAutoPF()
        {
            if (!m_bResetAutoPF)
            {
                return;
            }

#if ENABLE_CEC_INTELLIGENT_ROUTE
            global::BrewMonster.Scripts.CECIntelligentRoute.Instance().SetUsage(global::BrewMonster.Scripts.CECIntelligentRoute.Usage.enumUsageWorkMove);
            global::BrewMonster.Scripts.CECIntelligentRoute.Instance().ResetSearch();

            if (IsAutoPF())
            {
                bool bSwitchTo2D = true;

                while (true)
                {
                    // EC_HPWorkMove.cpp UpdateResetUseAutoPF: skip Search while flying (bSwitchTo2D stays true).
                    if (m_pHost.IsFlying())
                        break;

                    // Brush test is not fully ported yet; pass null for now (static movemap only).
                    // BrushTest 暂未完整移植；当前先传 null（仅静态 movemap）。
                    var ret = global::BrewMonster.Scripts.CECIntelligentRoute.Instance().Search(
                        m_pHost.GetPos(),
                        m_vMoveDest,
                        null);

                    if (ret == CECIntelligentRoute.SearchResult.enumSearchNoPath)
                    {
                        // C++ UpdateResetUseAutoPF: Search != success → break; bSwitchTo2D stays true (fallback straight line).
                        // Do not Finish() — same as EC_HPWorkMove.cpp (no path still switches to DEST_2D).
                        int mapX = Mathf.RoundToInt(m_vMoveDest.x / 10.0f) + 400;
                        int mapY = Mathf.RoundToInt(m_vMoveDest.y / 10.0f);
                        int mapZ = Mathf.RoundToInt(m_vMoveDest.z / 10.0f) + 550;
                        Debug.LogWarning(
                            $"[CECIntelligentRoute] No path; switching to DEST_2D. Map coords: ({mapX}, {mapZ}, ↑{mapY}).");
                        break;
                    }
                    else if (ret != CECIntelligentRoute.SearchResult.enumSearchSuccess)
                    {
                        break;
                    }
                    bSwitchTo2D = false;
                    OrientHostToFirstAutoPFWaypoint();
                    break;
                }

                if (bSwitchTo2D)
                {
                    m_bSwitchTo2D = true;
                }
            }
#endif

            ClearResetUseAutoPF();
        }

        protected virtual uint GetMoveRelDirMask()
        {
            // TODO: hook up CECHostPlayer move-direction flags when available.
            return m_pHost.m_dwMoveRelDir;
        }

        private void UpdateFacingFromDelta(A3DVECTOR3 nextPos)
        {
            A3DVECTOR3 prevPos = m_pHost.GetPos();
            Vector3 delta = EC_Utility.ToVector3(nextPos - prevPos);
            delta.y = 0.0f;
            if (delta.sqrMagnitude > 1e-6f)
            {
                delta.Normalize();
                m_pHost.SetDirAndUp(delta, Vector3.up);
            }
        }

        private A3DVECTOR3 GetCurrentModelDir()
        {
            Vector3 forward = m_pHost != null ? m_pHost.transform.forward : Vector3.forward;
            return new A3DVECTOR3(forward.x, forward.y, forward.z);
        }

    }
}