Convention-Unity-Demo/Assets/Scripts/Framework/DDT.cs

using Convention;
using Demo.Game.Attr;
using System;
using System.Collections;
using System.IO;
using Unity.Collections;
using UnityEngine;
using UnityEngine.Rendering;

namespace Demo.Game
{
    namespace ConfigType
    {
        public class DDTConfig : ScriptLoadableConfig
        {
            [Content] public NativeArray<float> Datas = new(128, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
            [Content] public int Count = 0;

            public override void Deserialize(BinaryReader reader)
            {
                BinarySerializeUtility.DeserializeNativeArray(reader, ref Datas);
                Count = Datas.Length;
                base.Deserialize(reader);
            }

            public override void Serialize(BinaryWriter writer)
            {
                var newArray = new NativeArray<float>(Count, Allocator.Persistent, NativeArrayOptions.UninitializedMemory);
                NativeArray<float>.Copy(Datas, newArray, Count);
                Datas = newArray;
                BinarySerializeUtility.SerializeNativeArray(writer, Datas);
                base.Serialize(writer);
            }
        }
    }

    [Scriptable]
    public class DDT : ScriptableObject
    {
        protected override ConfigType.ScriptLoadableConfig MakeConfig()
        {
            return new ConfigType.DDTConfig();
        }
        protected override bool IsSelfEnableUpdate => false;
        public static DDT Make()
        {
            return new GameObject().AddComponent<DDT>();
        }


        [Convention.RScript.Variable.Attr.Method]
        public void Add(float value)
        {
            int Count = GetConfig<ConfigType.DDTConfig>().Count;
            if (Count >= GetConfig<ConfigType.DDTConfig>().Datas.Length)
                GetConfig<ConfigType.DDTConfig>().Datas.ResizeArray(Mathf.FloorToInt(Count * 1.5f));
            GetConfig<ConfigType.DDTConfig>().Datas[Count] = value;
            GetConfig<ConfigType.DDTConfig>().Count++;
        }

        [Convention.RScript.Variable.Attr.Method]
        public void Add(int barSplitTimes, int barCount, int tickCount)
        {
            Add((barCount + tickCount / (float)barSplitTimes) * OneBarTime);
        }

        [Convention.RScript.Variable.Attr.Method]
        public float At(int index)
        {
            int Count = GetConfig<ConfigType.DDTConfig>().Count;
            if (index < 0)
                index = Count + index;
            if (index < 0 || index >= Count)
                throw new IndexOutOfRangeException($"{index} is out of [0, {Count})");
            return GetConfig<ConfigType.DDTConfig>().Datas[index];
        }

        [Convention.RScript.Variable.Attr.Method]
        public int GetCount()
        {
            return GetConfig<ConfigType.DDTConfig>().Count;
        }

        private void OnDestroy()
        {
            if (GetConfig<ConfigType.DDTConfig>().Datas.IsCreated)
                GetConfig<ConfigType.DDTConfig>().Datas.Dispose();
        }

        #region Serialize

        protected override bool IsImptSerialize => true;
        protected override IEnumerator CreateAndLoadingImptCacheFile(ToolFile scriptFile, ToolFile cacheFile)
        {
            yield return this.ParseScript2Expr(scriptFile.LoadAsText());
            using var stream = File.OpenWrite(cacheFile.GetFullPath());
            using var writer = new BinaryWriter(stream);
            writer.Write(GetConfig<ConfigType.DDTConfig>().Count);
            for (int i = 0, e = GetConfig<ConfigType.DDTConfig>().Count; i < e; i++)
            {
                writer.Write(GetConfig<ConfigType.DDTConfig>().Datas[i]);
            }
        }
        protected override IEnumerator LoadFromImptCacheFile(ToolFile cacheFile)
        {
            using var stream = File.OpenRead(cacheFile.GetFullPath());
            using var reader = new BinaryReader(stream);
            GetConfig<ConfigType.DDTConfig>().Count = reader.ReadInt32();
            GetConfig<ConfigType.DDTConfig>().Datas.ResizeArray(Mathf.Max(128, GetConfig<ConfigType.DDTConfig>().Count));
            for (int i = 0, e = GetConfig<ConfigType.DDTConfig>().Count; i < e; i++)
            {
                GetConfig<ConfigType.DDTConfig>().Datas[i] = reader.ReadSingle();
            }
            yield break;
        }

        #endregion
    }
}