test/Assets/PerfectWorld/Scripts/Task/TaskTest.cs

using BrewMonster;
using System;
using System.IO;
using System.Reflection;
using System.Runtime.InteropServices;
using PerfectWorld.Scripts.Task;
using UnityEngine;


namespace BrewMonster.Scripts.Task
{
    public class TaskTest : MonoSingleton<TaskTest>
    {
        public ATaskTemplMan m_pTaskMan;
        public bool WasLoadTaskData = false;

        private void OnValidate()
        {
            WasLoadTaskData = m_pTaskMan != null && m_pTaskMan.TaskLoadedCount > 0;
        }

        [ContextMenu("Load Data")]
        void LoadTaskData()
        {
            if (m_pTaskMan == null)
            {
                m_pTaskMan = new ATaskTemplMan();
            }

            string path = Path.Combine(Application.streamingAssetsPath, "data/tasks.data");
            WasLoadTaskData = m_pTaskMan.LoadTasksFromPack(path, true);
        }

        [ContextMenu("Test Size")]
        void TestSize()
        {
            var size = Marshal.SizeOf(typeof(ATaskTemplFixedData));
            BMLogger.Log("Size of ATaskTemplFixedData: " + size);
        }
        [ContextMenu("🧾 Log Struct Field Sizes (ATaskTemplFixedData)")]
        private void LogStructFieldSizes()
        {
            Type structType = typeof(ATaskTemplFixedData);
            FieldInfo[] fields = structType.GetFields(BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);

            Debug.Log($"===== Struct: {structType.Name} =====");

            foreach (var field in fields)
            {
                string name = field.Name;
                Type fieldType = field.FieldType;

                int sizeInBytes = -1;
                string note = "";

                // 🟢 1. Nếu field có [MarshalAs], lấy SizeConst
                var marshalAttr = field.GetCustomAttribute<MarshalAsAttribute>();
                if (marshalAttr != null && marshalAttr.SizeConst > 0)
                {
                    int elemSize = GetElementSize(fieldType);
                    sizeInBytes = elemSize * marshalAttr.SizeConst;
                    note = $"(ByValArray × {marshalAttr.SizeConst})";
                }
                else
                {
                    try
                    {
                        sizeInBytes = Marshal.SizeOf(fieldType);
                    }
                    catch
                    {
                        note = "(reference type / variable size)";
                    }
                }

                string sizeText = sizeInBytes >= 0 ? $"{sizeInBytes} bytes" : "unknown size";
                Debug.Log($"{name,-40} | {fieldType.Name,-25} | {sizeText} {note}");
            }

            try
            {
                int total = Marshal.SizeOf(structType);
                Debug.Log($"===== Total Struct Size: {total} bytes =====");
            }
            catch
            {
                Debug.Log($"⚠️ Struct {structType.Name} contains non-blittable fields; total size unknown.");
            }
        }

        /// <summary>
        /// Tính kích thước phần tử cơ bản của mảng blittable
        /// </summary>
        private int GetElementSize(Type type)
        {
            if (type.IsArray)
            {
                Type elemType = type.GetElementType();
                if (elemType != null)
                {
                    try { return Marshal.SizeOf(elemType); }
                    catch { return 1; } // fallback
                }
            }
            return Marshal.SizeOf(type);
        }
    }
}