NoelStephensUnity
commented
1 year ago Hi @SoulMuncher!
This kind of functionality is not supported "out of the box", but you could do something like this:
using System;
using System.Reflection;
using System.Collections.Generic;
using Unity.Netcode;
using UnityEngine;
public class BaseClass : INetworkSerializable
{
static private Dictionary<string, Type> RegisteredTypes = new Dictionary<string, Type>();
private string SerializedClass;
private string ClassType;
public static void RegisterAllTypes()
{
foreach(var type in Assembly.GetExecutingAssembly().GetTypes())
{
if (type.IsSubclassOf(typeof(BaseClass)))
{
RegisterType(type);
}
}
}
private static void RegisterType(Type classType)
{
if (!RegisteredTypes.ContainsKey(classType.Name))
{
RegisteredTypes.Add(classType.Name, classType);
}
}
public BaseClass GetInstance()
{
if (!RegisteredTypes.ContainsKey(ClassType))
{
// If the receiver hasn't created an instance go ahead and register all child derived
// classes of BaseClass
RegisterAllTypes();
// If we still don't find an entry then there is a mismatch in the build where the sender
// has a new or old class that doesn't exist on the receiver side
if (!RegisteredTypes.ContainsKey(ClassType))
{
Debug.LogError($"Could not find class type ({ClassType})!");
return null;
}
}
return (BaseClass)JsonUtility.FromJson(SerializedClass, RegisteredTypes[ClassType]);
}
public virtual void NetworkSerialize<T>(BufferSerializer<T> serializer) where T : IReaderWriter
{
if (serializer.IsWriter)
{
SerializedClass = JsonUtility.ToJson(this);
}
serializer.SerializeValue(ref ClassType);
serializer.SerializeValue(ref SerializedClass);
}
public virtual void Test()
{
throw new System.NotImplementedException();
}
public BaseClass()
{
var classType = GetType();
RegisterType(GetType());
ClassType = classType.Name;
}
}
[Serializable]
public class FirstChildClass : BaseClass
{
[SerializeField]
public int var1;
[SerializeField]
public Vector3 var2;
public FirstChildClass(int var1, Vector3 var2)
{
this.var1 = var1;
this.var2 = var2;
}
public override void Test()
{
Debug.Log($"[FirstChildClass] {var1} | {var2}");
}
}
[Serializable]
public class SecondChildClass : BaseClass
{
[SerializeField]
public long var1;
[SerializeField]
public Vector3Int var2;
public SecondChildClass(long var1, Vector3Int var2)
{
this.var1 = var1;
this.var2 = var2;
}
public override void Test()
{
Debug.Log($"[SecondChildClass] {var1} | {var2}");
}
}And here is a NetworkBehaviour component so you can see it working:
using System.Collections;
using System.Collections.Generic;
using Unity.Netcode;
using UnityEngine;
public class NetworkBehaviourTest : NetworkBehaviour
{
[ServerRpc(RequireOwnership = false)]
private void SendBaseClassDerivedClassServerRpc(BaseClass baseClass, ServerRpcParams serverRpcParams = default)
{
// Get the actual instance
var instance = baseClass.GetInstance();
// Log the instance type
Debug.Log(instance);
// Invoke the virtual method
instance.Test();
}
public void Test1()
{
Debug.Log("[Test] Sending first child derived class");
SendBaseClassDerivedClassServerRpc(new FirstChildClass(2, Vector3.one * 2));
}
public void Test2()
{
Debug.Log("[Test] Sending second child derived class");
SendBaseClassDerivedClassServerRpc(new SecondChildClass(3, Vector3Int.one * 3));
}
private void Update()
{
if (!IsSpawned)
{
return;
}
if (Input.GetKeyDown(KeyCode.Alpha1))
{
Test1();
}
if (Input.GetKeyDown(KeyCode.Alpha2))
{
Test2();
}
}
}The end result should look like this in the console output:
Let me know if this provides you with enough information to accomplish your project's design requirements?
SoulMuncher
Is your feature request related to a problem? Please describe. I am unable to send subclasses through an RPC without them turning into the highest parent class, unless I explicitly define and checking Enums for each one within the parent class, which is not always feasible, and never ideal. I believe this is a problem with all inherited things, including structs and interfaces, not just classes. See end of NGO Document: https://docs-multiplayer.unity3d.com/netcode/current/advanced-topics/serialization/inetworkserializable/
Describe the solution you'd like The object sent through RPC's should keep its initial type, and should use its own overridden NetworkSerialize function to determine exactly what data needs to be serialized and networked.
In this case, I should be able to send a Cat, Dog, or Bird through this function, and all clients should create the respective new Cat(), new Dog(), or new Bird() with any defined serialization from those specific subclasses, as opposed to serializing the more generic/abstract "Animal"
Describe alternatives you've considered I believe this is a reasonable implementation, as it reflects the standard programming syntax found in nearly every programming language.
Additional context From my understanding, the recommended solution for inheritance is to create a new manager class that holds an Animal, and check Enums to create a new instance of the subclass during serialization. This is obviously not a convenient nor efficient solution if there are lots of different animals, it does not allow any subclass specific data to be transferred over the RPC, and it does not allow the user to follow good coding practices (no polymorphism)