Further explanation into net methods.

[Jdance-Media]

Made a few of these discussions lately 🤦‍♂️

Recently I had the idea of making a totally new gamemode within the game by having the client and the server install the same module. I figured it would be best to stick with the current net system that the game uses, so after looking at some decompiled examples I went ahead and made this:

   public class TestManager : SteamCaller
    {
        private static readonly ClientStaticMethod<string> SendTestNet = ClientStaticMethod<string>.Get(ReceiveTestNet);

        public static void ServerTestNet(ITransportConnection connection, string str)
        {
            SendTestNet.Invoke(ENetReliability.Reliable, connection, str);
        }

        [SteamCall(ESteamCallValidation.ONLY_FROM_SERVER)]
        public static void ReceiveTestNet(string str)
        {
            PlayerUI.message(EPlayerMessage.NPC_CUSTOM, str, 2);
        }
    }
    
    [NetInvokableGeneratedClass(typeof(TestManager))]
    public class TestManager_NetMethods
    {
        [NetInvokableGeneratedMethod("ReceiveTestNet", ENetInvokableGeneratedMethodPurpose.Read)]
        public static void ReceiveTestNet_Read(in ClientInvocationContext context)
        {
            NetPakReader reader = context.reader;
            reader.ReadString(out var value);
            TestManager.ReceiveTestNet(value);
        }

        [NetInvokableGeneratedMethod("ReceiveTestNet", ENetInvokableGeneratedMethodPurpose.Write)]
        public static void ReceiveTestNet_Write(NetPakWriter writer, string str)
        {
            writer.WriteString(str);
        }
    }

After attempting to use ServerTestNet server-side, I received a NullReferenceException, likely relating to this log message:

[2023-10-30 00:41:50] Unable to find client method info for TestManager.ReceiveTestNet

I'm clueless as to how the all of it works, but I do suspect that the problem might be caused by using Assembly.GetExecutingAssembly instead of GetCallingAssembly in the ctor for NetReflection.

Was this intended to prevent modules from using the net method stuff? If not, is there something I'm doing wrong on my end or does the constructor for NetReflection need to be modified?

[DanielWillett]

I believe those attributes generate read/write methods at compile time, so they won't be of much use to you (which could be changed to be done at runtime using Dynamic Methods).

As someone who has also done this, I had success with making my own knockoff of his RPCs that use dynamic methods.

If you want you can check out how I was able to update the read/write methods to add a few extra enum values to EServerMessage and EClientMessage and add my own listeners for it:
https://github.com/DanielWillett/DevkitServer/blob/master/Multiplayer/Networking/NetFactory.cs#L100

• Note you need to patch the read/write methods and change the amount of bits they read/write to support larger values.
• Then you have to get either the NetMessages.serverReadCallbacks or NetMessages.clientReadCallbacks (depending on which side your module is on) and add your invokers to that at the index of your new enum value(s).
• And finally you just need your own copy of the send method which you can pass your own Message enum values and offset them by the amount of values in the original enum: https://github.com/DanielWillett/DevkitServer/blob/master/Multiplayer/Networking/NetFactory.cs#L1209

(Note this method is not compatible with clients/servers that do not have your module)

[SDGNelson]

This approach sounds like a good way for the meantime. It's possible also that the client/server message index will become extensible at some point because I had hoped to make e.g. the BattlEye packets less hardcoded. It depends when/if there needs to be another built-in message type.

[Maximjetfs1305]

Hi bro, did you manage to realize the communication between client and server)?

[Jdance-Media]

Hi, @SDGNelson do you think you could simply make it so NetReflection does not use a type initializer and instead make it so it is activated/registers methods after modules are loaded?

I, with the assistance of a few others, have tried to use a transpiler to add my own types to the search and recall the initializer. I've been trying to do this for close to a year now. We have concluded that we are likely limited by the fact that you are using a static constructor and readonly fields.

[DanielWillett]

To add a bit of context, it's impossible to patch a static constructor (type initializer) since patching has to call the static constructor. Surprisingly there seems to be weird inconsistencies with setting static readonly fields in mono after the type initializer. In most environments it works fine (in .NET "core" it can throw an exception) but for some reason it sets it to null instead of the desired value, making this way of doing it almost impossible.

I don't think you'll be able to move it after ModuleHook.start without worrying about execution order so may just be easier to add some internal methods for working with them that he can call with reflection and use lists instead of arrays.

// NetReflection

// replace arrays with lists so they can be changed later:

private static readonly List<ClientMethodInfo> clientMethodsList = new List<ClientMethodInfo>();
private static readonly List<ServerMethodInfo> serverMethodsList = new List<ServerMethodInfo>();
public static readonly uint clientMethodsLength;
public static readonly int clientMethodsBitCount;
public static readonly uint serverMethodsLength;
public static readonly int serverMethodsBitCount;

public static IReadOnlyList<ClientMethodInfo> ClientMethods { get; } = clientMethodsList.AsReadOnly();
public static IReadOnlyList<ServerMethodInfo> ServerMethods { get; } = serverMethodsList.AsReadOnly();

// keep updating these for backwards compat if you really want to, un-readonlying them shouldn't break anything
[Obsolete("use ClientMethods property instead.")]
public static ClientMethodInfo[] clientMethods;
[Obsolete("use ServerMethods property instead.")]
public static ServerMethodInfo[] serverMethods;

// in place of static NetReflection()

/// <summary>
/// Register net methods from the given assembly and add them to the execution list. Call order matters.
/// </summary>
internal static void RegisterFromAssembly(Assembly assembly)

// Provider

public void awake()
{
   // ... (call this pretty early)
   NetReflection.RegisterFromAssembly(Assembly.GetExecutingAssembly());
   // ...
}

[SDGNelson]

@Jdance-Media @DanielWillett I'm sorry to say none of the network features were built with support for dynamic third-party message registration in mind. Even if NetReflection exposed a method to register another assembly the indices wouldn't match up between client and server if registered in different orders or with different modules enabled. For your projects would there only be one custom module installed on both client and server? If so, maybe your proposal is enough for it to work. :S

[Jdance-Media]

I cannot say much for Blaze (Daniel) but my project involves the same module being used on both the client and server. I know that Blaze has a different implementation for creating net methods that get around the hiccups with NetReflection, but I assume it would be a lot easier if we could just register our own assemblies and avoid having to make a bunch of new classes to handle networking.

I have a not-so-good implementation of net methods which is proven to work if both the server and client have the same module installed, so making the change from a static constructor over to a method following the activations of modules would indeed work.

[SDGNelson]

Okay: I've implemented RegisterFromAssembly like you proposed and it'll be up on the preview branch relatively soon. Fingers crossed that it works without issue. I'll be interested to see how you put it to use!