test/Assets/PerfectWorld/Scripts/Players/CECActionSwitcherBase.cs

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;

namespace BrewMonster.Assets.PerfectWorld.Scripts.Players
{
    public abstract class CECActionBase
    {
	    public enum ACTION_RESULT
        {
            FD_NONE = 0,
            FD_SUCC,
            FD_FAIL,
        };

        public CECHostPlayer m_pHostPlayer;
        public ACTION_RESULT m_iFirstDoRes;
        public CECActionSequencedRelationFilter m_ActionFilter;

        public CECActionBase(CECHostPlayer pHost)
        {
            m_pHostPlayer = pHost;
            m_iFirstDoRes = (ACTION_RESULT.FD_NONE);
            m_ActionFilter = null;
        }

        public bool NeedBeRemoved()
        {
            return (m_iFirstDoRes != ACTION_RESULT.FD_NONE);
        }
        public CECActionSequencedRelationFilter GetActionFilter() { return m_ActionFilter; }

        public abstract bool CanDo();
        public abstract bool DoOnce();	

	    public virtual bool Update(uint dt)
        {
            FlagKeeper keeper = new FlagKeeper(m_pHostPlayer.GetActionSwitcher());

            // do once
            if (CanDo() && m_iFirstDoRes == ACTION_RESULT.FD_NONE)
                m_iFirstDoRes = DoOnce() ? ACTION_RESULT.FD_SUCC : ACTION_RESULT.FD_FAIL;

            return true;
        }
        public virtual bool CanAddTo(CECActionContext pContext)
        {
            return m_ActionFilter != null && m_ActionFilter.CanAddAction(pContext, this);
        }

    };

    public abstract class CECFitlerBase
    {
        public abstract bool CanAddAction(CECActionContext pContext, CECActionBase pAct);
    }

    public abstract class CECActionSequencedRelationFilter : CECFitlerBase
    {
        public override bool CanAddAction(CECActionContext pContext, CECActionBase pAct)
        {
            // If the action queue is empty and the action can be executed, then add it.
            if (pContext.GetActionCount() == 0 && pAct.CanDo())
                return true;

            // Determine the predecessor–successor order relationship of actions in the action queue.
            CECActionBase pLastAct = pContext != null ? pContext.GetLastAction() : null;
            CECActionSequencedRelationFilter filter = pLastAct != null ? pLastAct.GetActionFilter() : null;
            if (filter != null && filter.IsPredecessorTo(pAct.GetActionFilter()))
                return true;

            return false;
        }

        public abstract bool IsPredecessorTo(CECActionSequencedRelationFilter cECActionSequencedRelationFilter);

	    public virtual bool IsSuccessorTo(CECCancelRideActionFilter pFilter) { return false; }
        public virtual bool IsSuccessorTo(CECRideActionFilter pFilter) { return false; }
        public virtual bool IsSuccessorTo(CECLandingActionFilter pFilter) { return false; }
        public virtual bool IsSuccessorTo(CECFlyActionFilter pFilter) { return false; }
        public virtual bool IsSuccessorTo(CECSkillActionFilter pFilter) { return false; }
        public virtual bool IsSuccessorTo(CECUseSkillItemActionFilter pFilter) { return false; }
    };

    public class FlagKeeper
    {
	    public CECActionSwitcherBase m_pSwitcher;
	    public FlagKeeper(CECActionSwitcherBase pSwitcher)
        {
            m_pSwitcher = pSwitcher;
            pSwitcher.SetPostMessageFlag(false); 
        }
    };

    public class CECCancelRideActionFilter :  CECActionSequencedRelationFilter
    {
        public bool IsSuccessorTo(CECRideActionFilter filter ) { return true; }

        public override bool IsPredecessorTo(CECActionSequencedRelationFilter pFilter)
        {
            return pFilter.IsSuccessorTo(this);
        }
    };

    public class CECRideActionFilter :  CECActionSequencedRelationFilter
    {
        public virtual bool IsSuccessorTo(CECCancelRideActionFilter filter) { return true; }
        public virtual bool IsSuccessorTo(CECLandingActionFilter filter ) { return true; }

        public override bool IsPredecessorTo(CECActionSequencedRelationFilter pFilter)
        {
            return pFilter.IsSuccessorTo(this);
        }
    };

    public class CECLandingActionFilter :  CECActionSequencedRelationFilter
    {
	    public virtual bool IsSuccessorTo(CECFlyActionFilter filter) { return true; }
        public override bool IsPredecessorTo(CECActionSequencedRelationFilter pFilter)
        {
            return pFilter.IsSuccessorTo(this);
        }
    };

    public class CECFlyActionFilter :  CECActionSequencedRelationFilter
    {
	    public virtual bool IsSuccessorTo(CECCancelRideActionFilter pFilter) { return true; }
        public virtual bool IsSuccessorTo(CECLandingActionFilter pFilter) { return true; }
        public override bool IsPredecessorTo(CECActionSequencedRelationFilter pFilter)
        {
            return pFilter.IsSuccessorTo(this);
        }
    };

    public class CECSkillActionFilter : CECActionSequencedRelationFilter
    {
        public virtual bool IsSuccessorTo(CECCancelRideActionFilter pFilter) { return true; }
        public virtual bool IsSuccessorTo(CECLandingActionFilter pFilter) { return true; }
        public virtual bool IsSuccessorTo(CECFlyActionFilter pFilter) { return true; }
        public override bool IsPredecessorTo(CECActionSequencedRelationFilter pFilter)
        {
            return pFilter.IsSuccessorTo(this);
        }
    };

    public class CECUseSkillItemActionFilter :  CECActionSequencedRelationFilter
    {
        public virtual bool IsSuccessorTo(CECCancelRideActionFilter pFilter) { return true; }
        public virtual bool IsSuccessorTo(CECLandingActionFilter pFilter) { return true; }
        public virtual bool IsSuccessorTo(CECFlyActionFilter pFilter) { return true; }
        public override bool IsPredecessorTo(CECActionSequencedRelationFilter pFilter)
        {
            return pFilter.IsSuccessorTo(this);
        }
    };

    public class CECContextValidChecker
    {
	    public CECContextValidChecker(CECActionContext context)
        {
            m_pActionContext = context;
            error_correct = 0;
        }

        public virtual void Update(uint dt)
        {
            //After the client sends mount or dismount commands, it immediately sends a movement message.
            // As a result, the mount/ dismount operation on the server may fail, but the client is not notified.
            // Therefore, a confirmation check is required here.
            if (m_pActionContext.GetActionCount() != 0 && m_pActionContext.NeedCheckValid())
            {
                error_correct += (int)dt;

                if (error_correct > MAX_ERRORTIME && !m_pActionContext.GetHostPlayer().GetWorkMan().IsOperatingPet())
                {
                    m_pActionContext.SetForceRemove(true);
                    error_correct = 0;
                }
            }
        }

	    public int error_correct;
        public CECActionContext m_pActionContext;
        public const int MAX_ERRORTIME = 3000;
    };

    public class CECActionSwitcherBase
    {
        CECHostPlayer m_pHostPlayer;
        bool m_bCanAddMsg;
        protected List<int> m_msgs = new List<int>();
        List<CECActionContext> m_actionContexts;
        public CECActionSwitcherBase(CECHostPlayer pHost)
        {
            m_pHostPlayer = pHost;
        }
        public virtual bool OnRideToSkillAction(int skill, bool bCom, int iSel, int iForceAtk) { return false; }
        public bool CanAddMessage() { return m_bCanAddMsg; }
        public void PostMessge(int msg)
        {
            if (CanAddMessage())
                m_msgs.UniquelyAdd(msg);
        }
        public void SetPostMessageFlag(bool bCan) { m_bCanAddMsg = bCan; }

        public virtual bool OnFlyToRideAction(int petIndex) { return false; } // fly -> ride

        /// <summary>Ride mount then fly (shortcut CMD_FLY). 骑乘后飞行</summary>
        public virtual bool OnRideToFlyAction() { return false; }
    }
    public enum EMsgActionSwitcher

    {
        MSG_FLY = 0,
        MSG_MOUNTPET,
        MSG_CASTSKILL,
    };
}