test/Assets/PerfectWorld/Scripts/Managers/EC_HPWorkStand.cs

using CSNetwork.GPDataType;
using UnityEngine;

namespace BrewMonster.Scripts
{
    public class CECHPWorkStand : CECHPWork
    {
        protected bool m_bMeetSlide;    // true, meet slide
        protected int m_iPoseAction;    // pose action
        protected bool m_bSession;      // doing session pose
        protected bool m_bWaterStop;    // stop moving down in water
        protected bool m_bMoving;       // moving flag
        protected bool m_bStopSlide;    // stop sliding flag
        protected int m_iCurAction;     // current playing action

        public CECHPWorkStand(CECHPWorkMan pWorkMan) : base(Host_work_ID.WORK_STAND, pWorkMan)
        {
            m_dwMask = Work_mask.MASK_STAND;
            m_dwTransMask = Work_mask.MASK_MOVETOPOS | Work_mask.MASK_FLYOFF | Work_mask.MASK_FREEFALL | Work_mask.MASK_TRACEOBJECT |
                            Work_mask.MASK_SIT | Work_mask.MASK_SPELLOBJECT | Work_mask.MASK_FOLLOW | Work_mask.MASK_CONCENTRATE | Work_mask.MASK_USEITEM;
            Reset();
        }

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

            m_bMeetSlide = false;
            m_iPoseAction = (int)CECPlayer.PLAYER_ACTION_TYPE.ACT_STAND;
            m_bSession = false;
            m_bWaterStop = false;
            m_bMoving = false;
            m_bStopSlide = false;
            m_iCurAction = (int)CECPlayer.PLAYER_ACTION_TYPE.ACT_STAND;
        }

        // Copy work data
        public override bool CopyData(CECHPWork pWork)
        {
            if (!base.CopyData(pWork))
                return false;

            CECHPWorkStand pSrc = (CECHPWorkStand)pWork;

            m_bMeetSlide = pSrc.m_bMeetSlide;
            m_iPoseAction = pSrc.m_iPoseAction;
            m_bSession = pSrc.m_bSession;
            m_bWaterStop = pSrc.m_bWaterStop;
            m_bMoving = pSrc.m_bMoving;
            m_bStopSlide = pSrc.m_bStopSlide;
            m_iCurAction = pSrc.m_iCurAction;

            return true;
        }

        public void SetPoseAction(int iAction, bool bSession)
        {
            m_iPoseAction = iAction;
            m_bSession = bSession;

            m_pHost.PlayAction(m_iPoseAction, true);

            if (!bSession && iAction != (int)CECPlayer.PLAYER_ACTION_TYPE.ACT_EXP_KISS)
                m_pHost.PlayAction(m_pHost.GetMoveStandAction(false, false), true, 300, true);
        }

        // On first tick
        protected override void OnFirstTick()
        {
            m_pHost.m_iMoveMode = (int)Move_Mode.MOVE_STAND;
            // Velocity/acceleration reset are skipped here due to partial host API availability in C#
            // If needed, add host velocity reset when fields are available

            // if (m_pHost.m_pMoveTargetGFX) m_pHost.m_pMoveTargetGFX.Stop();
        }

        // Should player start move?
        int ShouldMove()
        {
            int iMoveReason = 0;

            if (m_pHost.IsJumping())
            {
                iMoveReason = 1;
            }
            else if (!m_pHost.m_GndInfo.bOnGround)
            {
                if (m_pHost.m_iMoveEnv != CECPlayer.Move_environment.MOVEENV_AIR &&
                    m_pHost.m_iMoveEnv != CECPlayer.Move_environment.MOVEENV_WATER)
                    iMoveReason = 2;
            }

            return iMoveReason;
        }

        // On work shift
        public override void OnWorkShift()
        {
            m_bWaterStop = false;
            m_bMoving = false;
            m_bMeetSlide = false;
            m_bStopSlide = false;
        }

        // Work is cancel
        public override void Cancel()
        {
            m_iPoseAction = (int)CECPlayer.PLAYER_ACTION_TYPE.ACT_STAND;
            m_bSession = false;
            m_pHost.m_bPrepareFight = false;
            base.Cancel();
        }

        // Doing session pose?
        public bool DoingSessionPose()
        {
            return (m_iPoseAction != (int)CECPlayer.PLAYER_ACTION_TYPE.ACT_STAND && m_bSession);
        }

        // Tick routine
        public override bool Tick(float dwDeltaTime)
        {
            base.Tick(dwDeltaTime);

            int iMoveReason = ShouldMove();
            if (iMoveReason != 0)
            {
                if (iMoveReason == 1)
                {
                    var pWork = (CECHPWorkMove)m_pWorkMan.CreateWork(Host_work_ID.WORK_MOVETOPOS);
                    if (pWork != null)
                    {
                        pWork.SetDestination(CECHPWorkMove.Types.DEST_STANDJUMP, GPDataTypeHelper.g_vOrigin);
                        m_pWorkMan.SetPostTickCommand(new CECHPWorkPostTickRunWorkCommand(
                            pWork, false, CECHPWorkMan.Work_priority.PRIORITY_1, true, (uint)dwDeltaTime));
                    }
                }
                else if (iMoveReason == 2)
                {
                    // var pWork = (CECHPWorkFall)m_pWorkMan.CreateWork(Host_work_ID.WORK_FREEFALL);
                    // if (pWork != null) {
                    //     pWork.SetFallType(CECHPWorkFall.TYPE_FREEFALL);
                    //     m_pWorkMan.SetPostTickCommand(new CECHPWorkPostTickRunWorkCommand(pWork));
                    // }
                }
                else
                {
                    // ASSERT(0);
                }

                return true;
            }

            // Play appropriate actions
            if (m_iPoseAction == (int)CECPlayer.PLAYER_ACTION_TYPE.ACT_STAND)
            {
                bool bFight = m_pHost.IsFighting() || m_pHost.m_bPrepareFight;
                m_iCurAction = m_pHost.GetMoveStandAction(false, bFight);
            }

            float fDeltaTime = dwDeltaTime * 0.001f;

            if (!m_pHost.IsRooting())
            {
                if (m_pHost.m_iMoveEnv == CECPlayer.Move_environment.MOVEENV_GROUND)
                    Tick_Walk(fDeltaTime);
               /* else    // AIR or WATER
                    Tick_FlySwim(fDeltaTime);*/
            }

            if (m_iPoseAction == (int)CECPlayer.PLAYER_ACTION_TYPE.ACT_STAND)
            {
                // Chariot war special case omitted for now
                m_pHost.PlayAction(m_iCurAction, false, 300);
            }

            // Force to update object's direction and up
            // m_pHost.m_vecGroundNormal = m_pHost.m_vecGroundNormalSet;
            // m_pHost.StopModelMove(m_pHost.GetDir(), m_pHost.GetUp(), 0);

            return true;
        }

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

            if (m_pHost.m_iMoveMode == (int)Move_Mode.MOVE_SLIDE)
            {
                if (m_bStopSlide)
                    return true;

                m_iCurAction = (int)CECPlayer.PLAYER_ACTION_TYPE.ACT_JUMP_LOOP;

                m_bMeetSlide = true;
                m_bMoving = true;

                vCurPos = m_pHost.m_MoveCtrl.GroundMove(GPDataTypeHelper.g_vOrigin, 0.0f, fDeltaTime);
                m_pHost.SetPos(EC_Utility.ToVector3(vCurPos));

                if (m_pHost.m_MoveCtrl.MoveBlocked() >= 3)
                {
                    m_bStopSlide = true;
                    m_bMoving = false;
                    m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), m_pHost.GetGroundSpeed(), (int)GPMoveMode.GP_MOVE_SLIDE);
                }
                else
                {
                    m_pHost.m_MoveCtrl.SendMoveCmd(vCurPos, 2, GPDataTypeHelper.g_vOrigin, EC_Utility.ToA3DVECTOR3(cdr.vAbsVelocity), (int)GPMoveMode.GP_MOVE_SLIDE);
                }
            }
            else if (m_bMeetSlide)
            {
                m_bMeetSlide = false;
                m_bMoving = false;
                m_pHost.m_MoveCtrl.SendStopMoveCmd(EC_Utility.ToVector3(vCurPos), m_pHost.GetGroundSpeed(), (int)GPMoveMode.GP_MOVE_SLIDE);
            }

            return true;
        }

        // Tick routine of flying or swimming
       /* bool Tick_FlySwim(float fDeltaTime)
        {
            m_bMoving = false;

            if (m_pHost.m_iMoveEnv == CECPlayer.Move_environment.MOVEENV_WATER && !m_bWaterStop)
            {
                // Handle floating at water surface after falling into water
                A3DVECTOR3 vCurPos = m_pHost.GetPos();
                // ON_AIR_CDR_INFO not available in current C# port; approximate using CDR_INFO where applicable
                float fSpeed = m_pHost.GetSwimSpeedSev();

                // As we don't have water height/extent readily available on host in this port,
                // retain structure and leave movement here minimal.
                // If water height APIs are added, restore the original logic.
                // m_bMoving = true; // enable when full water logic is available
            }

            return true;
        }*/
    }
}