// we need to inject several initializations into NetworkBehaviour cctor
void InjectIntoStaticConstructor(ref bool WeavingFailed)
{
if (commands.Count == 0 && clientRpcs.Count == 0 && targetRpcs.Count == 0)
{
return;
}
// find static constructor
MethodDefinition cctor = netBehaviourSubclass.GetMethod(".cctor");
bool cctorFound = cctor != null;
if (cctor != null)
{
// remove the return opcode from end of function. will add our own later.
if (!RemoveFinalRetInstruction(cctor))
{
Log.Error($"{netBehaviourSubclass.Name} has invalid class constructor", cctor);
WeavingFailed = true;
return;
}
}
else
{
// make one!
cctor = new MethodDefinition(".cctor", MethodAttributes.Private |
MethodAttributes.HideBySig |
MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName |
MethodAttributes.Static,
weaverTypes.Import(typeof(void)));
}
ILProcessor cctorWorker = cctor.Body.GetILProcessor();
// register all commands in cctor
for (int i = 0; i < commands.Count; ++i)
{
CmdResult cmdResult = commands[i];
GenerateRegisterCommandDelegate(cctorWorker, weaverTypes.registerCommandReference, commandInvocationFuncs[i], cmdResult);
}
// register all client rpcs in cctor
for (int i = 0; i < clientRpcs.Count; ++i)
{
ClientRpcResult clientRpcResult = clientRpcs[i];
GenerateRegisterRemoteDelegate(cctorWorker, weaverTypes.registerRpcReference, clientRpcInvocationFuncs[i], clientRpcResult.method.FullName);
}
// register all target rpcs in cctor
for (int i = 0; i < targetRpcs.Count; ++i)
{
GenerateRegisterRemoteDelegate(cctorWorker, weaverTypes.registerRpcReference, targetRpcInvocationFuncs[i], targetRpcs[i].FullName);
}
// add final 'Ret' instruction to cctor
cctorWorker.Append(cctorWorker.Create(OpCodes.Ret));
if (!cctorFound)
{
netBehaviourSubclass.Methods.Add(cctor);
}
// in case class had no cctor, it might have BeforeFieldInit, so injected cctor would be called too late
netBehaviourSubclass.Attributes &= ~TypeAttributes.BeforeFieldInit;
}
void GenerateConstants()
{
if (commands.Count == 0 && clientRpcs.Count == 0 && targetRpcs.Count == 0 && syncObjects.Count == 0)
{
return;
}
Weaver.DLog(netBehaviourSubclass, " GenerateConstants ");
// find static constructor
MethodDefinition cctor = netBehaviourSubclass.GetMethod(".cctor");
bool cctorFound = cctor != null;
if (cctor != null)
{
// remove the return opcode from end of function. will add our own later.
if (cctor.Body.Instructions.Count != 0)
{
Instruction retInstr = cctor.Body.Instructions[cctor.Body.Instructions.Count - 1];
if (retInstr.OpCode == OpCodes.Ret)
{
cctor.Body.Instructions.RemoveAt(cctor.Body.Instructions.Count - 1);
}
else
{
Weaver.Error($"{netBehaviourSubclass.Name} has invalid class constructor", cctor);
return;
}
}
}
else
{
// make one!
cctor = new MethodDefinition(".cctor", MethodAttributes.Private |
MethodAttributes.HideBySig |
MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName |
MethodAttributes.Static,
WeaverTypes.Import(typeof(void)));
}
// find instance constructor
MethodDefinition ctor = netBehaviourSubclass.GetMethod(".ctor");
if (ctor == null)
{
Weaver.Error($"{netBehaviourSubclass.Name} has invalid constructor", netBehaviourSubclass);
return;
}
Instruction ret = ctor.Body.Instructions[ctor.Body.Instructions.Count - 1];
if (ret.OpCode == OpCodes.Ret)
{
ctor.Body.Instructions.RemoveAt(ctor.Body.Instructions.Count - 1);
}
else
{
Weaver.Error($"{netBehaviourSubclass.Name} has invalid constructor", ctor);
return;
}
// TODO: find out if the order below matters. If it doesn't split code below into 2 functions
ILProcessor ctorWorker = ctor.Body.GetILProcessor();
ILProcessor cctorWorker = cctor.Body.GetILProcessor();
for (int i = 0; i < commands.Count; ++i)
{
CmdResult cmdResult = commands[i];
GenerateRegisterCommandDelegate(cctorWorker, WeaverTypes.registerCommandDelegateReference, commandInvocationFuncs[i], cmdResult);
}
for (int i = 0; i < clientRpcs.Count; ++i)
{
ClientRpcResult clientRpcResult = clientRpcs[i];
GenerateRegisterRemoteDelegate(cctorWorker, WeaverTypes.registerRpcDelegateReference, clientRpcInvocationFuncs[i], clientRpcResult.method.Name);
}
for (int i = 0; i < targetRpcs.Count; ++i)
{
GenerateRegisterRemoteDelegate(cctorWorker, WeaverTypes.registerRpcDelegateReference, targetRpcInvocationFuncs[i], targetRpcs[i].Name);
}
foreach (FieldDefinition fd in syncObjects)
{
SyncObjectInitializer.GenerateSyncObjectInitializer(ctorWorker, fd);
}
cctorWorker.Append(cctorWorker.Create(OpCodes.Ret));
if (!cctorFound)
{
netBehaviourSubclass.Methods.Add(cctor);
}
// finish ctor
ctorWorker.Append(ctorWorker.Create(OpCodes.Ret));
// in case class had no cctor, it might have BeforeFieldInit, so injected cctor would be called too late
netBehaviourSubclass.Attributes &= ~TypeAttributes.BeforeFieldInit;
}
// we need to inject several initializations into NetworkBehaviour cctor
void InjectIntoStaticConstructor(ref bool WeavingFailed)
{
if (commands.Count == 0 && clientRpcs.Count == 0 && targetRpcs.Count == 0)
{
return;
}
// find static constructor
MethodDefinition cctor = netBehaviourSubclass.GetMethod(".cctor");
bool cctorFound = cctor != null;
if (cctor != null)
{
// remove the return opcode from end of function. will add our own later.
if (!RemoveFinalRetInstruction(cctor))
{
Log.Error($"{netBehaviourSubclass.Name} has invalid class constructor", cctor);
WeavingFailed = true;
return;
}
}
else
{
// make one!
cctor = new MethodDefinition(".cctor", MethodAttributes.Private |
MethodAttributes.HideBySig |
MethodAttributes.SpecialName |
MethodAttributes.RTSpecialName |
MethodAttributes.Static,
weaverTypes.Import(typeof(void)));
}
// Static constructors are lazily called when the class is first "used"
// https://docs.microsoft.com/en-us/dotnet/csharp/programming-guide/classes-and-structs/static-constructors
// > It is called automatically before the first instance is created or any static members are referenced.
//
// This means, in particular circumstances, client and server may diverge on which classes they have "loaded"
// and thus the rpc index will be desynced
//
// One such example would be on-demand-loading of prefabs via custom spawn handlers:
// A game might not want to preload all its monster prefabs since there's quite many of them
// and it is practically impossible to encounter them all (or even a majority of them) in a single play
// session.
// So a custom spawn handler is used to load the monster prefabs on demand.
// All monsters would have the "Monster" NetworkBehaviour class, which would have a few RPCs on it.
// Since the monster prefabs are loaded ONLY when needed via a custom spawn handler and the Monster class
// itself isn't referenced or "loaded" by anything else other than the prefab, the monster classes static
// constructor will not have been called when a client first joins a game, while it may have been called
// on the server/host. This will in turn cause Rpc indexes to not match up between client/server
//
// By just forcing the static constructors to run via the [RuntimeInitializeOnLoadMethod] attribute
// this is not a problem anymore, since all static constructors are always run and all RPCs will
// always be registered by the time they are used
if (!cctor.HasCustomAttribute <RuntimeInitializeOnLoadMethodAttribute>())
{
Helpers.AddRuntimeInitializeOnLoadAttribute(assembly, weaverTypes, cctor);
}
ILProcessor cctorWorker = cctor.Body.GetILProcessor();
// register all commands in cctor
for (int i = 0; i < commands.Count; ++i)
{
CmdResult cmdResult = commands[i];
GenerateRegisterCommandDelegate(cctorWorker, weaverTypes.registerCommandReference, commandInvocationFuncs[i], cmdResult);
}
// register all client rpcs in cctor
for (int i = 0; i < clientRpcs.Count; ++i)
{
ClientRpcResult clientRpcResult = clientRpcs[i];
GenerateRegisterRemoteDelegate(cctorWorker, weaverTypes.registerRpcReference, clientRpcInvocationFuncs[i], clientRpcResult.method.FullName);
}
// register all target rpcs in cctor
for (int i = 0; i < targetRpcs.Count; ++i)
{
GenerateRegisterRemoteDelegate(cctorWorker, weaverTypes.registerRpcReference, targetRpcInvocationFuncs[i], targetRpcs[i].FullName);
}
// add final 'Ret' instruction to cctor
cctorWorker.Append(cctorWorker.Create(OpCodes.Ret));
if (!cctorFound)
{
netBehaviourSubclass.Methods.Add(cctor);
}
// in case class had no cctor, it might have BeforeFieldInit, so injected cctor would be called too late
netBehaviourSubclass.Attributes &= ~TypeAttributes.BeforeFieldInit;
}
