private void OnReceiveData(IAsyncResult ar)
{
    int bytesRead = stream.EndRead(ar);
    if (bytesRead <= 0) return;

    byte[] receivedData = new byte[bytesRead];
    Buffer.BlockCopy(receiveBuffer, 0, receivedData, 0, bytesRead);

    PacketHandler.HandlePacket(receivedData);
    stream.BeginRead(receiveBuffer, 0, receiveBuffer.Length, new AsyncCallback(OnReceiveData), null);
}

public void SendPacket(FlatBufferBuilder builder, short pktId)
{
    ...

    byte[] packetData = builder.SizedByteArray();
    // 패킷 헤더 생성
    PacketHeader header;
    header.size = (short)(Marshal.SizeOf(typeof(PacketHeader)) + packetData.Length);
    header.id = pktId;

    // 패킷 직렬화
    byte[] headerBytes = Serialize(header);
    byte[] finalPacket = new byte[headerBytes.Length + packetData.Length];

    Buffer.BlockCopy(headerBytes, 0, finalPacket, 0, headerBytes.Length);
    Buffer.BlockCopy(packetData, 0, finalPacket, headerBytes.Length, packetData.Length);

    try
    {
        stream.Write(finalPacket, 0, finalPacket.Length);
    }
    catch (Exception ex)
    {
        Debug.LogError($"패킷 전송 실패: {ex.Message}");
    }
}

// 패킷 헤더 구조체 정의
[StructLayout(LayoutKind.Sequential, Pack = 1)]
public struct PacketHeader
{
    public short size; // 패킷 전체 크기
    public short id;   // 패킷 ID
}

public enum PKT_ID : short
{
    PKT_C_REGISTER = 1000, // C -> S
    PKT_S_TRADE_INVITATION = 1021
    ...
}

public class PacketHandler
{
    private static Dictionary<PKT_ID, Func<byte[], bool>> packetHandlers = new Dictionary<PKT_ID, Func<byte[], bool>>();

    public static void Init()
    {
        packetHandlers.Add(0, PacketHandler.Handle_INVALID);
        packetHandlers.Add(PKT_ID.PKT_S_REGISTER, PacketHandler.Handle_S_REGISTER);
        packetHandlers.Add(PKT_ID.PKT_S_TRADE_INVITATION, PacketHandler.Handle_S_TRADE_INVITATION);
        ...
    }

    public static bool Handle_INVALID(byte[] data)
    {
        Debug.Log("잘못된 패킷 번호입니다");
        return false;
    }

    public static bool Handle_S_REGISTER(byte[] data)
    {
        ByteBuffer bb = new ByteBuffer(data);
        S_REGISTER sRegister = S_REGISTER.GetRootAsS_REGISTER(bb);
        bool response = sRegister.Success;
        string msg = sRegister.Message;

        GameManager.Instance.RegisterProcess(msg, response);

        return true;
    }

    // 패킷 받는 역할
    public static bool HandlePacket(byte[] data)
    {
        PacketHeader header = Deserialize<PacketHeader>(data);
        int headerSize = Marshal.SizeOf<PacketHeader>();
        byte[] payload = new byte[data.Length - headerSize];
        Buffer.BlockCopy(data, headerSize, payload, 0, payload.Length);
        
        if (!packetHandlers.TryGetValue((PKT_ID)header.id, out Func<byte[], bool> handler))
        {
            Debug.LogWarning("알 수 없는 패킷 ID: " + header.id);
            handler = Handle_INVALID; // 기본 핸들러 실행
        }

        return handler.Invoke(payload);
    }

public enum ItemType
{
    Weapon,     // 무기
    Armor,      // 방어구
    Consumable, // 소비 아이템 (예: 물약)
    Accessory,  // 악세서리
    general,    // 일반
}

[CreateAssetMenu(fileName = "ItemData", menuName = "Scriptable Objects/ItemData")]
public class ItemData : ScriptableObject
{
    [Header("기본 정보")]
    public int itemId;             // 아이템 고유 ID (데이터베이스와 연동할 경우)
    public string itemName;        // 아이템 이름
    public ItemType type;          // 아이템 종류

    [Header("설명")]
    [TextArea]
    public string description;     // 아이템 설명

    [Header("능력치/효과")]
    public int atk;                // 공격력 (무기일 경우)
    public int def;                // 방어력 (방어구일 경우)
    public int healRecovery;       // 회복량 (소비 아이템, 예: 물약)

    [Header("가격")]
    public int price;              // 아이템 가격

    [Header("UI")]
    public Sprite icon;            // UI에 표시할 아이콘 (옵션)
}

private static readonly Queue<Action> executionQueue = new Queue<Action>();

private void Awake()
{
    if (Instance == null)
    {
        Instance = this;
        DontDestroyOnLoad(gameObject);
    }
    else
    {
        Destroy(gameObject);
    }
}

private void Update()
{
    while (true)
    {
        Action action = null;
        lock (executionQueue)
        {
            if (executionQueue.Count > 0)
                action = executionQueue.Dequeue();
            else
                break;
        }
        try
        {
            action?.Invoke();
        }
        catch (Exception ex)
        {
            Debug.LogError("메인 스레드 작업 실행 중 오류 발생: " + ex);
        }
    }
}

public static void Enqueue(Action action)
{
    if (action == null)
        return;

    lock (executionQueue)
    {
        executionQueue.Enqueue(action);
    }
}

public class ItemSlotUI : MonoBehaviour, IPointerClickHandler
{
    public int itemId;
    public int quantity;
    public TextMeshProUGUI itemNameText;

    // 클릭 이벤트를 알리기 위한 델리게이트
    public System.Action<int> OnItemClicked;
    public System.Action<int, int> OnItemIdQuantityClicked;

    // 프리팹을 초기화할 때 호출하는 함수
    public void Setup(ItemData itemData, int quantity, int price)
    {
        ...
    }

    // IPointerClickHandler 인터페이스 구현 – 마우스 클릭 감지
    public void OnPointerClick(PointerEventData eventData)
    {
        OnItemClicked?.Invoke(itemId);
        OnItemIdQuantityClicked?.Invoke(itemId, quantity);
    }
}

private void OnTradeButtonClicked()
{
    // 상대방에게 거래 요청 응답 보내기...
    FlatBufferBuilder builder = new FlatBufferBuilder(1024);
    C_TRADE_REQUEST.StartC_TRADE_REQUEST(builder);
    C_TRADE_REQUEST.AddSenderId(builder, GameManager.Instance.currentPlayer.objectId);
    C_TRADE_REQUEST.AddReceiverId(builder, otherPlayerObjectId);
    var cTradeRequestPacket = C_TRADE_REQUEST.EndC_TRADE_REQUEST(builder);
    builder.Finish(cTradeRequestPacket.Value);
    
    PacketHandler.SendPacket(builder, (short)PKT_ID.PKT_C_TRADE_REQUEST);
}