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

using BrewMonster;
using BrewMonster.Scripts.World;
using CSNetwork;
using CSNetwork.GPDataType;
using DG.Tweening;
using System;
using System.Buffers.Binary;
using System.Collections.Generic;
using System.Runtime.InteropServices;
using Unity.VisualScripting;
using UnityEngine;

public class CECNPCMan : IMsgHandler
{
    private Dictionary<int, CECNPC> m_NPCTab = new Dictionary<int, CECNPC>(512);
    private Dictionary<int, int> m_UkNPCTab = new Dictionary<int, int>(32);


    List<CECNPC> m_aDisappearNPCs = new List<CECNPC>(32);
    public int HandlerId => (int)MANAGER_INDEX.MAN_NPC;

    public CECNPCMan()
    {
    }
    public bool ProcessMessage(ECMSG Msg)
    {
        if (Msg.iSubID == 0)
        {
            switch (Msg.dwMsg)
            {
                case long value when value == EC_MsgDef.MSG_NM_NPCINFO: OnMsgNPCInfo(Msg); break;
                case long value when value == EC_MsgDef.MSG_NM_NPCMOVE: OnMsgNPCMove(Msg); break;
                case long value when value == EC_MsgDef.MSG_NM_NPCSTOPMOVE: OnMsgNPCStopMove(Msg); break;
                case long value when value == EC_MsgDef.MSG_NM_NPCRUNOUT: OnMsgNPCRunOut(Msg); break;
                case long value when value == EC_MsgDef.MSG_NM_NPCDIED: OnMsgNPCDied(Msg); break;
                case long value when value == EC_MsgDef.MSG_NM_NPCDISAPPEAR: OnMsgNPCDisappear(Msg); break;
                case long value when value == EC_MsgDef.MSG_NM_NPCATKRESULT: TransmitMessage(Msg); break;
            }
        }
        return true;
    }
    public void Tick()
    {
        int SIZE_REMOVETAB = 64;
        int iRemoveCnt = 0;
        CECNPC[] aRemove = new CECNPC[64];

        foreach (var pNPC in m_NPCTab.Values)
        {
            if (pNPC.ShouldDisappear())
            {
                if (iRemoveCnt < SIZE_REMOVETAB)
                    aRemove[iRemoveCnt++] = pNPC;
            }
            else
            {

            }
        }

        for (int i = 0; i < iRemoveCnt; i++)
            NPCLeave(aRemove[i].GetNPCID());
    }
    private void OnMsgNPCDisappear(ECMSG Msg)
    {
        BMLogger.Log("HoangDev : OnMsgNPCDisappear ");

        var pCmd = GPDataTypeHelper.FromBytes<cmd_object_disappear>((byte[])Msg.dwParam1);
        NPCDisappear(pCmd.id);
    }
    void NPCDisappear(int nid)
    {
        CECNPC pNPC = GetNPC(nid);
        if (pNPC)
        {
            if (!pNPC.IsDead())
            {
                //	NPC Ïûʧʱ£¨¿ÉÄÜÉíÉÏ»¹ÓÐÏà¹ØÌØЧ£¬ÐèÒª´¥·¢£¬Èç×Ô±¬Ê±±¬Õ¨ÌØЧ£©
                //	ËäÈ»ÔÚ CECNPC::Killed ÖÐÒÑ×ö´¦Àí£¬µ«¿Í»§¶Ë¿ÉÄÜ»áÖ±½ÓÊÕµ½ disappear ÏûÏ¢£¨Èç×Ô±¬¼¼ÄÜ£©
                //	Òò´ËÕâÀïÐèÒªÔö¼Ó´¥·¢µ÷ÓÃ
                //	Èô֮ǰ NPC ÒÑËÀÍö£¬Ôò˵Ã÷Òѵ÷Óùý
                pNPC.ClearComActFlag(true);
            }

            pNPC.Disappear();

            //	From npc from active table and add it to disappear table
            NPCLeave(nid, true, false);
            m_aDisappearNPCs.Add(pNPC);
        }
    }
    void NPCLeave(int nid, bool bUpdateMMArray = true, bool bRelease = true)
    {
        //	Release NPC
        CECNPC pNPC = GetNPC(nid);
        if (!pNPC)
            return;

        /*if (bUpdateMMArray)
            RemoveNPCFromMiniMap(pNPC);*/

        pNPC.m_iMMIndex = -1;
        var hostplayer = GameController.Instance.GetHostPlayer();
        //	If this NPC is selected by host, cancel the selection
        if (pNPC.GetNPCID() == hostplayer.GetSelectedTarget())
            hostplayer.SelectTarget(0);

        //	Remove it from active NPC table
        m_NPCTab.Remove(nid);

        //	Forbid reloading npc's resources
        //QueueNPCUndoLoad(nid, pNPC->GetBornStamp());

        //	Release NPC resource
        if (bRelease)
            ReleaseNPC(pNPC);
        else
        {
            CECHostPlayer pHost = hostplayer;
            if (pHost != null)
                pHost.RemoveObjectFromTabSels(pNPC);
        }

        /* CECPlayerWrapper* pWrapper = CECAutoPolicy::GetInstance().GetPlayerWrapper();
         if (pWrapper) pWrapper->OnObjectDisappear(nid);*/
    }
    void ReleaseNPC(CECNPC pNPC)
    {
        if (pNPC)
        {
            //	Remove tab-selected array
            CECHostPlayer pHost = GameController.Instance.GetHostPlayer();
            if (pHost)
                pHost.RemoveObjectFromTabSels(pNPC);

            pNPC.Release();
            pNPC.DestroySelf();
        }
    }
    private bool TransmitMessage(ECMSG Msg)
    {
        int nid = 0;

        switch (Msg.dwMsg)
        {
            case long value when value == EC_MsgDef.MSG_NM_NPCATKRESULT:
                nid = GPDataTypeHelper.FromBytes<cmd_object_atk_result>((byte[])Msg.dwParam1).attacker_id;
                break;

                /* case long value when value == EC_MsgDef.MSG_NM_NPCEXTSTATE:
                 nbvlijuhygtfrde4dws84wi7ujyxfsdcefvgbhjzsxdcfvcgvhjaqzsDRa
                     nid = ((cmd_update_ext_state*)Msg.dwParam1)->id;
                     break;

                 case long value when value == EC_MsgDef.MSG_NM_NPCCASTSKILL:

                     nid = ((cmd_object_cast_skill*)Msg.dwParam1)->caster;
                     break;

                 case long value when value == EC_MsgDef.MSG_NM_ENCHANTRESULT:

                     nid = ((cmd_enchant_result*)Msg.dwParam1)->caster;
                     break;

                 case long value when value == EC_MsgDef.MSG_NM_NPCROOT:

                     nid = ((cmd_object_root*)Msg.dwParam1)->id;
                     break;

                 case long value when value == EC_MsgDef.MSG_NM_NPCSKILLRESULT:

                     nid = ((cmd_object_skill_attack_result*)Msg.dwParam1)->attacker_id;
                     break;

                 case long value when value == EC_MsgDef.MSG_NM_NPCLEVELUP:

                     nid = ((cmd_level_up*)Msg.dwParam1)->id;
                     break;

                 case long value when value == EC_MsgDef.MSG_NM_NPCINVISIBLE:

                     nid = ((cmd_object_invisible*)Msg.dwParam1)->id;
                     break;

                 case long value when value == EC_MsgDef.MSG_NM_NPCSTARTPLAYACTION:
                     nid = ((cmd_object_start_play_action*)Msg.dwParam1)->id;
                     break;

                 case long value when value == EC_MsgDef.MSG_NM_NPCSTOPPLAYACTION:
                     nid = ((cmd_object_stop_play_action*)Msg.dwParam1)->id;
                     break;
                 case long value when value == EC_MsgDef.MSG_NM_MULTIOBJECT_EFFECT:
                     nid = ((cmd_multiobj_effect*)Msg.dwParam1)->id;
                     break;

                 default:
                     return false;*/
        }
        CECNPC pNPC = SeekOutNPC(nid);
        if (pNPC)
            pNPC.ProcessMessage(Msg);
        return true;
    }

    private bool OnMsgNPCDied(ECMSG msg)
    {
        int nid = 0, idKiller = 0;
        bool bDelay = false;

        var stateNPC = Convert.ToInt32(msg.dwParam2);
        var byteArray = (byte[])msg.dwParam1;
        BMLogger.Log("HoangDev : OnMsgNPCDied " + stateNPC);

        if (stateNPC == CommandID.NPC_DIED)
        {
            cmd_npc_died pCmd = EC_Utility.ByteArrayToStructure<cmd_npc_died>(byteArray);
            nid = pCmd.id;
            idKiller = pCmd.idKiller;
        }
        else if (stateNPC == CommandID.NPC_DIED2)
        {
            cmd_npc_died2 pCmd = EC_Utility.ByteArrayToStructure<cmd_npc_died2>(byteArray);
            nid = pCmd.id;
            idKiller = pCmd.idKiller;
            bDelay = true;
        }
        if (!GPDataTypeHelper.ISNPCID(nid))
            return false;

        CECNPC pNPC = GetNPC(nid);
        EventBus.Publish(new NPCDiedEvent(nid));
        if (pNPC && !pNPC.IsAboutToDie())
        {
            pNPC.Killed(bDelay);

            //	Below codes may case the last damaged bubble number before
            //	npc died couldn't popup
            //	if (!bDelay)
            //		NPCDisappear(nid);
        }
        return true;
    }

    private bool OnMsgNPCStopMove(ECMSG msg)
    {
        cmd_object_stop_move pCmd = EC_Utility.ByteArrayToStructure<cmd_object_stop_move>((byte[])msg.dwParam1);

        CECNPC pNPC = SeekOutNPC(pCmd.id);
        if (pNPC)
            pNPC.StopMoveTo(pCmd);

        return true;
    }

    private bool OnMsgNPCRunOut(ECMSG msg)
    {
        int id = GPDataTypeHelper.FromBytes<int>((byte[])msg.dwParam1);
        NPCLeave(id);
        return true;
    }

    private bool OnMsgNPCMove(ECMSG msg)
    {
        var buffer = (byte[])msg.dwParam1;
        cmd_object_move pCmd = MemoryMarshal.Read<cmd_object_move>(buffer);

        if (pCmd.use_time == 0)
            return true;

        CECNPC pNPC = SeekOutNPC(pCmd.id);


        if (pNPC)
            pNPC.MoveTo(pCmd);

        return true;
    }
    public CECNPC SeekOutNPC(int nid)
    {
        if (!m_NPCTab.TryGetValue(nid, out var npc))
        {
            // Couldn't find this NPC, put it into unknown NPC table
            m_UkNPCTab[nid] = nid;
            return null;
        }

        return npc;
    }
    private bool OnMsgNPCInfo(ECMSG msg)
    {
        switch (Convert.ToInt32(msg.dwParam2))
        {
            case CommandID.NPC_INFO_LIST:
                {
                    // msg.dwParam1 chính là buffer chứa placeholder data (không có header cmd_npc_info_list)
                    cmd_npc_info_list pCmd = MemoryMarshal.Read<cmd_npc_info_list>(((byte[])msg.dwParam1).AsSpan());

                    int offset = Marshal.OffsetOf<cmd_npc_info_list>("placeholder").ToInt32();
                    byte[] buffer = (byte[])msg.dwParam1;
                    Span<byte> pDataBuf = buffer.AsSpan(offset);

                    for (int i = 0; i < pCmd.count; i++)
                    {
                        // giống const info_npc& Info = *(const info_npc*)pDataBuf;
                        info_npc info = MemoryMarshal.Read<info_npc>(pDataBuf);

                        int iSize = info_npc.HEADER_SIZE;
                        if ((info.state & PlayerNPCState.GP_STATE_EXTEND_PROPERTY) != 0)
                            iSize += sizeof(uint) * NumberDWORDsPlayerNPC.OBJECT_EXT_STATE_COUNT;
                        if ((info.state & PlayerNPCState.GP_STATE_NPC_PET) != 0)
                            iSize += sizeof(int);
                        if ((info.state & PlayerNPCState.GP_STATE_NPC_NAME) != 0)
                        {
                            byte len = pDataBuf[iSize];
                            iSize += 1 + len;
                        }
                        if ((info.state & PlayerNPCState.GP_STATE_MULTIOBJ_EFFECT) != 0)
                        {
                            int countEff = BinaryPrimitives.ReadInt32LittleEndian(
                                pDataBuf.Slice(iSize, sizeof(int)));
                            iSize += sizeof(int) + countEff * (sizeof(int) + 1);
                        }
                        if ((info.state & PlayerNPCState.GP_STATE_NPC_MAFIA) != 0)
                            iSize += sizeof(int);
                        NPCEnter(info, false, buffer, offset);

                        // dịch pDataBuf về sau (giống pDataBuf += iSize)
                        pDataBuf = pDataBuf.Slice(iSize);
                        offset += iSize;
                    }
                    break;
                }

            case CommandID.NPC_ENTER_SLICE:
                {
                    var buffer = (byte[])msg.dwParam1;
                    info_npc info = MemoryMarshal.Read<info_npc>(buffer.AsSpan(0, info_npc.HEADER_SIZE));
                    NPCEnter(info, false, buffer, info_npc.HEADER_SIZE);
                    break;
                }

            case CommandID.NPC_ENTER_WORLD:
                {
                    var buffer = (byte[])msg.dwParam1;
                    info_npc info = MemoryMarshal.Read<info_npc>(buffer.AsSpan(0, info_npc.HEADER_SIZE));
                    NPCEnter(info, true, buffer, info_npc.HEADER_SIZE);
                    break;
                }
            case CommandID.NPC_INFO_00:
                {
                    BMLogger.LogError("HoangDev: NPCMAN NPC_INFO_00");
                    var buffer = (byte[])msg.dwParam1;
                    cmd_npc_info_00 pCmd = GPDataTypeHelper.FromBytes<cmd_npc_info_00>(buffer);
                    
                    CECNPC pNPC = SeekOutNPC(pCmd.idNPC);
                    if (pNPC)
                    {
                        ROLEBASICPROP bp = pNPC.GetBasicProps();
                        ROLEEXTPROP ep = pNPC.GetExtendProps();

                        bp.iCurHP = pCmd.iHP;
                        ep.bs.max_hp = pCmd.iMaxHP;
                        pNPC.SetSelectedTarget(pCmd.iTargetID);
                        pNPC.SetWorldHealthImage((float)pCmd.iHP , (float)pCmd.iMaxHP);
                        BMLogger.LogError("HoangDev: publish NPCMAN NPC_INFO_00");

                        EventBus.Publish(new NPCINFO(pNPC.GetName(),pCmd.iHP,pCmd.iMaxHP, pCmd.idNPC));
                    }
                    break;
                }
            case CommandID.NPC_VISIBLE_TID_NOTIFY:
                {
                    cmd_npc_visible_tid_notify pCmd = (cmd_npc_visible_tid_notify)msg.dwParam1;
                    CECNPC pNPC = SeekOutNPC(pCmd.nid);
                    if (pNPC)
                        pNPC.TransformShape(pCmd.vis_tid);
                    break;
                }
        }
        return true;
    }

    public bool NPCEnter(in info_npc Info, bool bBornInSight, ReadOnlySpan<byte> packet, int infoOffset)
    {
        var npc = GetNPC(Info.nid);
        if (npc != null)
        {
            m_NPCTab.Remove(Info.nid);
        }

        // Nếu id này có trong bảng unknown thì xóa nó
        if (m_UkNPCTab.ContainsKey(Info.nid))
        {
            m_UkNPCTab.Remove(Info.nid);
        }

        // Tạo NPC mới
        npc = CreateNPC(Info, bBornInSight, packet, infoOffset);
        //if (npc != null)
        //{
        //    npc.SetUpCECNPC(this);
        //}
        if (object.ReferenceEquals(npc, null))
        {
            BrewMonster.BMLogger.LogError($"Failed to create NPC ({Info.tid})");
            return false;
        }

        // Thêm NPC vào bảng
        m_NPCTab[Info.nid] = npc;
        return true;
    }
    // Get NPC by id and optional bornStamp
    public CECNPC GetNPC(int nid, uint bornStamp = 0)
    {
        if (!m_NPCTab.TryGetValue(nid, out var npc))
            return null;

        return npc;
    }
    public CECNPC GetNPCFromAll(int nid)
    {
        CECNPC pNPC = GetNPC(nid);
        if (pNPC)
            return pNPC;

        //	Search from disappear array ?
        /*for (int i = 0; i < m_aDisappearNPCs.GetSize(); i++)
        {
            CECNPC* pNPC = m_aDisappearNPCs[i];
            if (pNPC->GetNPCID() == nid)
                return pNPC;
        }*/

        return null;
    }
    public CECNPC CreateNPC(info_npc Info, bool bBornInSight, ReadOnlySpan<byte> packet, int infoOffset)
    {
        CECNPC pNPC = null;

        int tid = Info.tid;
        bool bPet = (Info.state & PlayerNPCState.GP_STATE_NPC_PET) != 0;

        // Get data type from database
        var edm = ElementDataManProvider.GetElementDataMan(); // tương đương g_pGame->GetElementDataMan()
        DATA_TYPE dataType = edm.get_data_type((uint)tid, ID_SPACE.ID_SPACE_ESSENCE);

        if (dataType != DATA_TYPE.DT_NPC_ESSENCE &&
            dataType != DATA_TYPE.DT_MONSTER_ESSENCE &&
            dataType != DATA_TYPE.DT_PET_ESSENCE)
        {
            // Try default npc
            tid = 4249;
            dataType = edm.get_data_type((uint)tid, ID_SPACE.ID_SPACE_ESSENCE);
        }
        if (bPet)
        {
            //pNPC = new CECPet(this);
        }
        else
        {
            switch (dataType)
            {
                case DATA_TYPE.DT_NPC_ESSENCE: 
                    pNPC = GameController.Instance.GetNPCServer();
                    break;
                case DATA_TYPE.DT_MONSTER_ESSENCE:
                    pNPC = GameController.Instance.GetMonster();
                    break;
                case DATA_TYPE.DT_PET_ESSENCE:/* pNPC = new CECPet(this);*/ break;
                default:
                    UnityEngine.Debug.Assert(false, "Invalid DATA_TYPE in CreateNPC");
                    return null;
            }
        }
        // Set born stamp & born-in-sight (giữ nguyên semantics)
        uint bornStamp = CECWorld.Instance.GetBornStamp();

        if (!object.ReferenceEquals(pNPC, null))
        {
            pNPC.SetBornStamp(bornStamp);
            pNPC.SetBornInSight(bBornInSight);
            pNPC.SetUpCECNPC(this);
        }
        else
        {
            return null;
        }

        // Init với tid + Info như C++
        if (!pNPC.Init(tid, Info, packet, infoOffset))
        {

            // đảm bảo giải phóng nếu bạn có tài nguyên kèm theo
            //pNPC?.Release();
            pNPC = null;

            // log lỗi tương tự glb_ErrorOutput
            UnityEngine.Debug.LogError($"CECNPCMan::CreateNPC failed, tid={tid}");
            return null;
        }

        return pNPC;
    }
}
public struct NPCDiedEvent
{
    public int NPCID;
    public NPCDiedEvent(int npcID)
    {
        NPCID = npcID;
    }
}