统一序列化时，ScriptableObject通用列表使所有派生实例都成为基本类型

Question

I'm trying to make a stat system library to use in as many games as possible in the future, but unity's serialization got in the way.

Knowing how awful is the serialization in unity and that derived instances get transformed to base type during serialization, I decided to make the base class derive from ScriptableObject, but it does not work. My code was becoming a bit messy at this point so I decided to make a much simpler test version from scratch, by the book, as explained here:

https://forum.unity.com/threads/serialization-best-practices-megapost.155352/

But that didn't work either.

The base class:

[System.Serializable]
public class BaseClass : ScriptableObject
{
    [SerializeField]
    private string m_Name;

    [SerializeField]
    public string Name { get => m_Name; set => m_Name = value; }

    public static BaseClass NewInstance()
    {
        BaseClass b = CreateInstance<BaseClass>();
        b.Name = string.Empty;
        return b;
    }
    public static BaseClass NewInstance(string name)
    {
        BaseClass b = CreateInstance<BaseClass>();
        b.Name = name;
        return b;
    }
}

The derived class:

[System.Serializable]
public class DerivedClass : BaseClass
{
    [SerializeField]
    private string m_Value;

    [SerializeField]
    public string Value { get => m_Value; set => m_Value = value; }

    public new static DerivedClass NewInstance()
    {
        DerivedClass d = CreateInstance<DerivedClass>();
        d.Name = string.Empty;
        d.Value = string.Empty;
        return d;
    }
    public static DerivedClass NewInstance(string name, string value)
    {
        DerivedClass d = CreateInstance<DerivedClass>();
        d.Name = name;
        d.Value = value;
        return d;
    }
}

And finally the collection class:

[System.Serializable] [CreateAssetMenu(menuName = "CollectionA")]
public class CollectionA : ScriptableObject
{
    [SerializeField]
    private List<BaseClass> m_TestList;

    [SerializeField]
    public List<BaseClass> TestList { get => m_TestList; set => m_TestList = value; }

    public static CollectionA NewInstance()
    {
        CollectionA c = CreateInstance<CollectionA>();
        c.TestList = new List<BaseClass>();
        return c;
    }

    public List<T> GetAllWithType<T>()
    {
        try { return TestList.OfType<T>().ToList<T>(); }
        catch { return new List<T>(); }
    }
}

I am creating instances and checking the list like this:

private void Update()
{
    if (Input.GetKeyDown("k"))
    {
        print("Derived stats:");
        List<DerivedClass> derived = collection.GetAllWithType<DerivedClass>();
        foreach (DerivedClass t in derived)
        { print(t.Name + " | " + t.Value); }
    }
    if (Input.GetKeyDown("p"))
    {
        DerivedClass d = DerivedClass.NewInstance("Hey", "Hello");
        collection.TestList.Add(d);
    }
}

The custom editor I am using:

[CustomEditor(typeof(CollectionA))]
public class CollectionAEditor : Editor
{
    private CollectionA collection;
    private List<DerivedClass> derived;
    struct derivedValues
    {
        public string name, value;
    }

    derivedValues addDerived = new derivedValues();

    public override void OnInspectorGUI()
    {
        if (target is CollectionA)
            collection = (CollectionA)target;
        if (collection != null)
        {
            DrawInspector();
        }
    }

    private void DrawInspector()
    {
        derived = collection.GetAllWithType<DerivedClass>();

        // title
        EditorGUILayout.Space();
        GUILayout.Label("CLASS LIST", EditorStyles.largeLabel);

        // title
        EditorGUILayout.Space();
        GUILayout.Label("Derived classes:", EditorStyles.boldLabel);

        // layout labels
        GUILayout.BeginHorizontal();
        GUILayout.Label("Name", GUILayout.MinWidth(35));
        GUILayout.Label("Value", GUILayout.MinWidth(35));
        GUILayout.EndHorizontal();

        // derived classes list
        if (derived.Count <= 0)
            GUILayout.Label("Class list empty", EditorStyles.centeredGreyMiniLabel);
        else
        {
            foreach (DerivedClass x in derived)
            {
                GUILayout.BeginHorizontal();
                x.Name = GUILayout.TextField(x.Name, GUILayout.MinWidth(35));
                x.Value = GUILayout.TextField(x.Value, GUILayout.MinWidth(35));
                GUILayout.EndHorizontal();
            }
        }

        // add derived stat
        EditorGUILayout.Space();
        GUILayout.BeginHorizontal();
        GUILayout.Label("Values:", GUILayout.Width(50f));
        addDerived.name = GUILayout.TextField(addDerived.name, GUILayout.MinWidth(35));
        addDerived.value = GUILayout.TextField(addDerived.value, GUILayout.MinWidth(35));
        GUILayout.EndHorizontal();
        if (GUILayout.Button("Add derived class"))
        {
            collection.TestList.Add(
                DerivedClass.NewInstance(addDerived.name, addDerived.value));
            addDerived = new derivedValues();
        }

        // default stats title
        EditorGUILayout.Space();
        GUILayout.BeginHorizontal();
        GUILayout.Label("All classes as default:", EditorStyles.boldLabel);
        if (collection.TestList == null) Debug.Log("NULL");
        GUILayout.Label(collection.TestList.Count.ToString());
        GUILayout.EndHorizontal();

        EditorGUILayout.Space();
        if (GUILayout.Button("Delete all instances"))
            collection.TestList.Clear();

        GUILayout.BeginHorizontal();
        GUILayout.Label("Name", GUILayout.MinWidth(35));
        GUILayout.EndHorizontal();

        // all classes list
        if (collection.TestList.Count <= 0)
            GUILayout.Label("Class list empty", EditorStyles.centeredGreyMiniLabel);
        else
        {
            foreach (BaseClass x in collection.TestList)
            {
                GUILayout.BeginHorizontal();
                x.name = GUILayout.TextField(x.name, GUILayout.MinWidth(35));
                GUILayout.EndHorizontal();
            }
        }
    }
}

If I press Play and add a new derived instance to the list, it is recognized properly until I press Play again, when the derived instance gets moved to base type.

I tried a lot of things, but none seem to work so thank you for trying to help me.

Answer 1

OK I figured it out. I was not creating assets out of the 2 classes. ScriptableObjects as assets can't reference non asset / prefab instances without loosing references apparently, so the data of my list of BaseClass got lost.

Conclusion: it's not enough to make a ScriptableObject wrapper for ScriptableObject fields that you make an asset out of, but you need to make assets out of the fields too so the reference doesn't get lost.

@derHugo thank you for your time.