protected RpcProcessor(ModuleDefinition module, Readers readers, Writers writers, IWeaverLogger logger)
{
this.module = module;
this.readers = readers;
this.writers = writers;
this.logger = logger;
}
/// <summary>
/// Adds the body to the types constructor
/// </summary>
/// <param name="typeDefinition"></param>
/// <param name="body"></param>
/// <param name="logger"></param>
public static void AddToConstructor(this TypeDefinition typeDefinition, IWeaverLogger logger, Action <ILProcessor> body)
{
// find instance constructor
var ctor = typeDefinition.GetMethod(".ctor");
if (ctor == null)
{
logger.Error($"{typeDefinition.Name} has invalid constructor", typeDefinition);
return;
}
var ret = ctor.Body.Instructions[ctor.Body.Instructions.Count - 1];
if (ret.OpCode == OpCodes.Ret)
{
// remove Ret so we can emit body
ctor.Body.Instructions.RemoveAt(ctor.Body.Instructions.Count - 1);
}
else
{
logger.Error($"{typeDefinition.Name} has invalid constructor", ctor, ctor.DebugInformation.SequencePoints.FirstOrDefault());
return;
}
var worker = ctor.Body.GetILProcessor();
body.Invoke(worker);
// re-add Ret after body
worker.Emit(OpCodes.Ret);
}
public SyncVarProcessor(ModuleDefinition module, Readers readers, Writers writers, PropertySiteProcessor propertySiteProcessor, IWeaverLogger logger)
{
this.module = module;
this.readers = readers;
this.writers = writers;
this.propertySiteProcessor = propertySiteProcessor;
this.logger = logger;
}
public NetworkBehaviourProcessor(TypeDefinition td, Readers readers, Writers writers, PropertySiteProcessor propertySiteProcessor, IWeaverLogger logger)
{
Weaver.DLog(td, "NetworkBehaviourProcessor");
netBehaviourSubclass = td;
this.logger = logger;
serverRpcProcessor = new ServerRpcProcessor(netBehaviourSubclass.Module, readers, writers, logger);
clientRpcProcessor = new ClientRpcProcessor(netBehaviourSubclass.Module, readers, writers, logger);
syncVarProcessor = new SyncVarProcessor(netBehaviourSubclass.Module, readers, writers, propertySiteProcessor, logger);
syncObjectProcessor = new SyncObjectProcessor(readers, writers, logger);
}
public AttributeProcessor(ModuleDefinition module, IWeaverLogger logger)
{
this.logger = logger;
// Cache these so that we dont import them for each site we process
IsServer = module.ImportReference((NetworkBehaviour nb) => nb.IsServer);
IsClient = module.ImportReference((NetworkBehaviour nb) => nb.IsClient);
HasAuthority = module.ImportReference((NetworkBehaviour nb) => nb.HasAuthority);
IsLocalPlayer = module.ImportReference((NetworkBehaviour nb) => nb.IsLocalPlayer);
}
public static AssemblyDefinition Build(IWeaverLogger logger)
{
AssemblyDefinition assembly = null;
var assemblyBuilder = new AssemblyBuilder(Path.Combine(OutputDirectory, OutputFile), SourceFiles.ToArray())
{
referencesOptions = ReferencesOptions.UseEngineModules
};
if (AllowUnsafe)
{
assemblyBuilder.compilerOptions.AllowUnsafeCode = true;
}
assemblyBuilder.buildFinished += delegate(string assemblyPath, CompilerMessage[] compilerMessages)
{
CompilerMessages.AddRange(compilerMessages);
foreach (CompilerMessage cm in compilerMessages)
{
if (cm.type == CompilerMessageType.Error)
{
Debug.Log($"Error At: {cm.file}:{ cm.line} -- {cm.message}");
CompilerErrors = true;
}
}
Debug.LogWarning($"Test Assembler errors: {CompilerErrors} for {OutputFile}");
// assembly builder does not call ILPostProcessor (WTF Unity?), so we must invoke it ourselves.
var compiledAssembly = new CompiledAssembly(assemblyPath)
{
Defines = assemblyBuilder.defaultDefines,
References = assemblyBuilder.defaultReferences
};
var weaver = new Weaver(logger);
assembly = weaver.Weave(compiledAssembly);
};
// Start build of assembly
if (!assemblyBuilder.Build())
{
Debug.LogErrorFormat("Failed to start build of assembly {0}", assemblyBuilder.assemblyPath);
return(assembly);
}
while (assemblyBuilder.status != AssemblyBuilderStatus.Finished)
{
System.Threading.Thread.Sleep(10);
}
return(assembly);
}
public NetworkBehaviourProcessor(TypeDefinition td, Readers readers, Writers writers, PropertySiteProcessor propertySiteProcessor, IWeaverLogger logger)
{
Weaver.DebugLog(td, "NetworkBehaviourProcessor");
netBehaviourSubclass = td;
this.logger = logger;
serverRpcProcessor = new ServerRpcProcessor(netBehaviourSubclass.Module, readers, writers, logger);
clientRpcProcessor = new ClientRpcProcessor(netBehaviourSubclass.Module, readers, writers, logger);
syncVarProcessor = new SyncVarProcessor(netBehaviourSubclass.Module, readers, writers, propertySiteProcessor);
syncObjectProcessor = new SyncObjectProcessor(readers, writers, logger);
// no max for rpcs, index is sent as var int, so more rpc just means bigger header size (still smaller than 4 byte hash)
rpcCounter = new ConstFieldTracker("RPC_COUNT", td, int.MaxValue, "Rpc");
}
/// <summary>
/// Builds and Weaves an Assembly with references to unity engine and other asmdefs.
/// <para>
/// NOTE: Does not write the weaved assemble to disk
/// </para>
/// </summary>
public AssemblyDefinition Build(IWeaverLogger logger)
{
AssemblyDefinition assembly = null;
// This will compile scripts with the same references as files in the asset folder.
// This means that the dll will get references to all asmdef just as if it was the default "Assembly-CSharp.dll"
var assemblyBuilder = new AssemblyBuilder(ProjectPathFile, sourceFiles.ToArray())
{
referencesOptions = ReferencesOptions.UseEngineModules
};
assemblyBuilder.buildFinished += delegate(string assemblyPath, CompilerMessage[] compilerMessages)
{
#if !UNITY_2020_2_OR_NEWER
CompilerMessages.AddRange(compilerMessages);
foreach (CompilerMessage cm in compilerMessages)
{
if (cm.type == CompilerMessageType.Error)
{
Debug.LogErrorFormat("{0}:{1} -- {2}", cm.file, cm.line, cm.message);
CompilerErrors = true;
}
}
#endif
// assembly builder does not call ILPostProcessor (WTF Unity?), so we must invoke it ourselves.
var compiledAssembly = new CompiledAssembly(assemblyPath)
{
Defines = assemblyBuilder.defaultDefines,
References = assemblyBuilder.defaultReferences
};
var weaver = new Weaver(logger);
assembly = weaver.Weave(compiledAssembly);
};
// Start build of assembly
if (!assemblyBuilder.Build())
{
Debug.LogErrorFormat("Failed to start build of assembly {0}", assemblyBuilder.assemblyPath);
return(assembly);
}
while (assemblyBuilder.status != AssemblyBuilderStatus.Finished)
{
System.Threading.Thread.Sleep(10);
}
return(assembly);
}
public void ProcessSyncVars(TypeDefinition td, IWeaverLogger logger)
{
behaviour = new FoundNetworkBehaviour(module, td);
// the mapping of dirtybits to sync-vars is implicit in the order of the fields here. this order is recorded in m_replacementProperties.
// start assigning syncvars at the place the base class stopped, if any
// get numbers of syncvars in parent class, it will be added to syncvars in this class for total
behaviour.GetSyncVarCountFromBase();
// find syncvars
// use ToArray to create copy, ProcessSyncVar might add new fields
foreach (FieldDefinition fd in td.Fields.ToArray())
{
// try/catch for each field, and log once
// we dont want to spam multiple logs for a single field
try
{
if (IsValidSyncVar(fd))
{
FoundSyncVar syncVar = behaviour.AddSyncVar(fd);
ProcessSyncVar(syncVar);
syncVar.HasProcessed = true;
}
}
catch (ValueSerializerException e)
{
logger.Error(e.Message, fd);
}
catch (SyncVarException e)
{
logger.Error(e);
}
catch (SerializeFunctionException e)
{
// use field as member referecne
logger.Error(e.Message, fd);
}
}
behaviour.SetSyncVarCount();
GenerateSerialization();
GenerateDeserialization();
}
/// <summary>
/// Builds and Weaves an Assembly with references to unity engine and other asmdefs.
/// <para>
/// NOTE: Does not write the weaved assemble to disk
/// </para>
/// </summary>
public async Task <AssemblyDefinition> BuildAsync(IWeaverLogger logger)
{
Log($"Assembler.Build for {OutputFile}");
if (UnityEditor.EditorApplication.isCompiling)
{
Debug.LogWarning("Assembler.Build Already compiling, AssemblyBuilder build may fail");
}
this.logger = logger;
// This will compile scripts with the same references as files in the asset folder.
// This means that the dll will get references to all asmdef just as if it was the default "Assembly-CSharp.dll"
builder = new AssemblyBuilder(ProjectPathFile, sourceFiles.ToArray())
{
referencesOptions = ReferencesOptions.UseEngineModules,
};
builder.buildFinished += buildFinished;
var started = builder.Build();
// Start build of assembly
if (!started)
{
Debug.LogErrorFormat("Failed to start build of assembly {0}", builder.assemblyPath);
return(builtAssembly);
}
while (builder.status != AssemblyBuilderStatus.Finished)
{
await Task.Yield();
}
return(builtAssembly);
}
public Writers(ModuleDefinition module, IWeaverLogger logger)
{
this.logger = logger;
this.module = module;
}
public MonoBehaviourProcessor(IWeaverLogger logger)
{
this.logger = logger;
}
public SyncObjectProcessor(Readers readers, Writers writers, IWeaverLogger logger)
{
this.readers = readers;
this.writers = writers;
this.logger = logger;
}
public Readers(ModuleDefinition module, IWeaverLogger logger) : base(module, logger)
{
}
public Weaver(IWeaverLogger logger)
{
this.logger = logger;
}
public static void Error(this IWeaverLogger logger, WeaverException exception, SequencePoint sequencePoint)
{
logger.Error(exception.Message, exception.MemberReference, sequencePoint);
}
public Readers(ModuleDefinition module, IWeaverLogger logger)
{
this.module = module;
this.logger = logger;
}
public ServerRpcProcessor(ModuleDefinition module, Readers readers, Writers writers, IWeaverLogger logger) : base(module, readers, writers, logger)
{
}
protected SerializeFunctionBase(ModuleDefinition module, IWeaverLogger logger)
{
this.logger = logger;
this.module = module;
}
public ServerClientAttributeProcessor(IWeaverLogger logger)
{
this.logger = logger;
}
